1 #pragma once
2 
3 #include "bios_attribute.hpp"
4 #include "bios_table.hpp"
5 #include "common/instance_id.hpp"
6 #include "oem_handler.hpp"
7 #include "platform_config.hpp"
8 #include "requester/handler.hpp"
9 
10 #include <libpldm/bios_table.h>
11 
12 #include <nlohmann/json.hpp>
13 #include <phosphor-logging/lg2.hpp>
14 
15 #include <functional>
16 #include <iostream>
17 #include <memory>
18 #include <optional>
19 #include <set>
20 #include <string>
21 #include <vector>
22 
23 PHOSPHOR_LOG2_USING;
24 
25 namespace pldm
26 {
27 namespace responder
28 {
29 namespace bios
30 {
31 enum class BoundType
32 {
33     LowerBound,
34     UpperBound,
35     ScalarIncrement,
36     MinStringLength,
37     MaxStringLength,
38     OneOf
39 };
40 
41 using AttributeName = std::string;
42 using AttributeType = std::string;
43 using ReadonlyStatus = bool;
44 using DisplayName = std::string;
45 using Description = std::string;
46 using MenuPath = std::string;
47 using CurrentValue = std::variant<int64_t, std::string>;
48 using DefaultValue = std::variant<int64_t, std::string>;
49 using OptionString = std::string;
50 using OptionValue = std::variant<int64_t, std::string>;
51 using ValueDisplayName = std::string;
52 using Option =
53     std::vector<std::tuple<OptionString, OptionValue, ValueDisplayName>>;
54 using BIOSTableObj =
55     std::tuple<AttributeType, ReadonlyStatus, DisplayName, Description,
56                MenuPath, CurrentValue, DefaultValue, Option>;
57 using BaseBIOSTable = std::map<AttributeName, BIOSTableObj>;
58 
59 using PendingObj = std::tuple<AttributeType, CurrentValue>;
60 using PendingAttributes = std::map<AttributeName, PendingObj>;
61 using Callback = std::function<void()>;
62 
63 /** @class BIOSConfig
64  *  @brief Manager BIOS Attributes
65  */
66 class BIOSConfig
67 {
68   public:
69     BIOSConfig() = delete;
70     BIOSConfig(const BIOSConfig&) = delete;
71     BIOSConfig(BIOSConfig&&) = delete;
72     BIOSConfig& operator=(const BIOSConfig&) = delete;
73     BIOSConfig& operator=(BIOSConfig&&) = delete;
74     ~BIOSConfig() = default;
75 
76     /** @brief Construct BIOSConfig
77      *  @param[in] jsonDir - The directory where json file exists
78      *  @param[in] tableDir - The directory where the persistent table is placed
79      *  @param[in] dbusHandler - Dbus Handler
80      *  @param[in] fd - socket descriptor to communicate to host
81      *  @param[in] eid - MCTP EID of host firmware
82      *  @param[in] instanceIdDb - pointer to an InstanceIdDb object
83      *  @param[in] handler - PLDM request handler
84      *  @param[in] platformConfigHandler - pointer to platform config Handler
85      *  @param[in] requestPLDMServiceName - Callback for claiming the PLDM
86      *             service name Called only after building BIOS tables.
87      */
88     explicit BIOSConfig(
89         const char* jsonDir, const char* tableDir,
90         pldm::utils::DBusHandler* const dbusHandler, int fd, uint8_t eid,
91         pldm::InstanceIdDb* instanceIdDb,
92         pldm::requester::Handler<pldm::requester::Request>* handler,
93         pldm::responder::platform_config::Handler* platformConfigHandler,
94         pldm::responder::bios::Callback requestPLDMServiceName);
95 
96     /** @brief Set attribute value on dbus and attribute value table
97      *  @param[in] entry - attribute value entry
98      *  @param[in] size - size of the attribute value entry
99      *  @param[in] isBMC - indicates if the attribute is set by BMC
100      *  @param[in] updateDBus          - update Attr value D-Bus property
101      *                                   if this is set to true
102      *  @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
103      *                                   if this is set to true
104      *  @return pldm_completion_codes
105      */
106     int setAttrValue(const void* entry, size_t size, bool isBMC,
107                      bool updateDBus = true, bool updateBaseBIOSTable = true);
108 
109     /** @brief Remove the persistent tables */
110     void removeTables();
111 
112     /** @brief Build bios tables(string,attribute,attribute value table)*/
113     void buildTables();
114 
115     /** @brief Get BIOS table of specified type
116      *  @param[in] tableType - The table type
117      *  @return The bios table, std::nullopt if the table is unaviliable
118      */
119     std::optional<Table> getBIOSTable(pldm_bios_table_types tableType);
120 
121     /** @brief set BIOS table
122      *  @param[in] tableType - Indicates what table is being transferred
123      *             {BIOSStringTable=0x0, BIOSAttributeTable=0x1,
124      *              BIOSAttributeValueTable=0x2}
125      *  @param[in] table - table data
126      *  @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
127      *                                   if this is set to true
128      *  @return pldm_completion_codes
129      */
130     int setBIOSTable(uint8_t tableType, const Table& table,
131                      bool updateBaseBIOSTable = true);
132 
133     /** @brief Construct the BIOS Attributes and build the tables
134      *         after receiving system type from entity manager.
135      *         Also register the Service Name only if
136      *         System specific Bios attributes are supported
137      *  @param[in] String - System Type
138      *  @param[in] bool - flag to register service name
139      *  @return void
140      */
141     void initBIOSAttributes(const std::string& sysType, bool registerService);
142 
143   private:
144     /** @enum Index into the fields in the BaseBIOSTable
145      */
146     enum class Index : uint8_t
147     {
148         attributeType = 0,
149         readOnly,
150         displayName,
151         description,
152         menuPath,
153         currentValue,
154         defaultValue,
155         options,
156     };
157 
158     const fs::path jsonDir;
159     const fs::path tableDir;
160     pldm::utils::DBusHandler* const dbusHandler;
161     BaseBIOSTable baseBIOSTableMaps;
162 
163     /** @brief socket descriptor to communicate to host */
164     int fd;
165 
166     /** @brief MCTP EID of host firmware */
167     uint8_t eid;
168 
169     /** @brief pointer to an Instance ID database object, used to obtain PLDM
170      * instance IDs.
171      */
172     pldm::InstanceIdDb* instanceIdDb;
173 
174     /** @brief PLDM request handler */
175     pldm::requester::Handler<pldm::requester::Request>* handler;
176 
177     /** @brief platform config Handler*/
178     pldm::responder::platform_config::Handler* platformConfigHandler;
179 
180     /** @brief Callback for registering the PLDM service name */
181     pldm::responder::bios::Callback requestPLDMServiceName;
182 
183     // vector persists all attributes
184     using BIOSAttributes = std::vector<std::unique_ptr<BIOSAttribute>>;
185     BIOSAttributes biosAttributes;
186 
187     using propName = std::string;
188     using DbusChObjProperties = std::map<propName, pldm::utils::PropertyValue>;
189 
190     using ifaceName = std::string;
191     using DbusIfacesAdded = std::map<ifaceName, DbusChObjProperties>;
192 
193     // vector to catch the D-Bus property change signals for BIOS attributes
194     std::vector<std::unique_ptr<sdbusplus::bus::match_t>> biosAttrMatch;
195 
196     /** @brief system type/model */
197     std::string sysType;
198 
199     /** @brief Method to update a BIOS attribute when the corresponding Dbus
200      *  property is changed
201      *  @param[in] chProperties - list of properties which have changed
202      *  @param[in] biosAttrIndex - Index of BIOSAttribute pointer in
203      * biosAttributes
204      *  @return - none
205      */
206     void processBiosAttrChangeNotification(
207         const DbusChObjProperties& chProperties, uint32_t biosAttrIndex);
208 
209     /** @brief Method is used to initiate bios attributes only if system type
210      *  is already populated by entity manager.
211      *  Register the callback if system type is yet to be populated by Entity
212      * manager
213      */
214     void checkSystemTypeAvailability();
215 
216     /** @brief Construct an attribute and persist it
217      *  @tparam T - attribute type
218      *  @param[in] entry - json entry
219      */
220     template <typename T>
221     void constructAttribute(const Json& entry)
222     {
223         try
224         {
225             biosAttributes.push_back(std::make_unique<T>(entry, dbusHandler));
226             auto biosAttrIndex = biosAttributes.size() - 1;
227             auto dBusMap = biosAttributes[biosAttrIndex]->getDBusMap();
228 
229             if (dBusMap.has_value())
230             {
231                 using namespace sdbusplus::bus::match::rules;
232                 biosAttrMatch.push_back(
233                     std::make_unique<sdbusplus::bus::match_t>(
234                         pldm::utils::DBusHandler::getBus(),
235                         propertiesChanged(dBusMap->objectPath,
236                                           dBusMap->interface),
237                         [this, biosAttrIndex](sdbusplus::message_t& msg) {
238                     DbusChObjProperties props;
239                     std::string iface;
240                     msg.read(iface, props);
241                     processBiosAttrChangeNotification(props, biosAttrIndex);
242                 }));
243 
244                 biosAttrMatch.push_back(
245                     std::make_unique<sdbusplus::bus::match_t>(
246                         pldm::utils::DBusHandler::getBus(),
247                         interfacesAdded() + argNpath(0, dBusMap->objectPath),
248                         [this, biosAttrIndex, interface = dBusMap->interface](
249                             sdbusplus::message_t& msg) {
250                     sdbusplus::message::object_path path;
251                     DbusIfacesAdded interfaces;
252 
253                     msg.read(path, interfaces);
254                     auto ifaceIt = interfaces.find(interface);
255                     if (ifaceIt != interfaces.end())
256                     {
257                         processBiosAttrChangeNotification(ifaceIt->second,
258                                                           biosAttrIndex);
259                     }
260                 }));
261             }
262         }
263         catch (const std::exception& e)
264         {
265             error("Constructs Attribute Error, {ERR_EXCEP}", "ERR_EXCEP",
266                   e.what());
267         }
268     }
269 
270     /** Construct attributes and persist them */
271     void constructAttributes();
272 
273     using ParseHandler = std::function<void(const Json& entry)>;
274 
275     /** @brief Helper function to parse json
276      *  @param[in] filePath - Path of json file
277      *  @param[in] handler - Handler to process each entry in the json
278      */
279     void load(const fs::path& filePath, ParseHandler handler);
280 
281     /** @brief Build String Table and persist it
282      *  @return The built string table, std::nullopt if it fails.
283      */
284     std::optional<Table> buildAndStoreStringTable();
285 
286     /** @brief Build attribute table and attribute value table and persist them
287      *         Read the BaseBIOSTable from the bios-settings-manager and update
288      *         attribute table and attribute value table.
289      *
290      *  @param[in] stringTable - The string Table
291      */
292     void buildAndStoreAttrTables(const Table& stringTable);
293 
294     /** @brief Persist the table
295      *  @param[in] path - Path to persist the table
296      *  @param[in] table - The table
297      */
298     void storeTable(const fs::path& path, const Table& table);
299 
300     /** @brief Load bios table to ram
301      *  @param[in] path - Path of the table
302      *  @return The table, std::nullopt if loading fails
303      */
304     std::optional<Table> loadTable(const fs::path& path);
305 
306     /** @brief Method to decode the attribute name from the string handle
307      *
308      *  @param[in] stringEntry - string entry from string table
309      *  @return the decoded string
310      */
311     std::string decodeStringFromStringEntry(
312         const pldm_bios_string_table_entry* stringEntry);
313 
314     /** @brief Method to print the string Handle by passing the attribute Handle
315      *         of the bios attribute that got updated
316      *
317      *  @param[in] handle - the Attribute handle of the bios attribute
318      *  @param[in] index - index to the possible value handles
319      *  @param[in] attrTable - the attribute table
320      *  @param[in] stringTable - the string table
321      *  @return string handle from the string table and decoded string to the
322      * name handle
323      */
324     std::string displayStringHandle(uint16_t handle, uint8_t index,
325                                     const std::optional<Table>& attrTable,
326                                     const std::optional<Table>& stringTable);
327 
328     /** @brief Method to trace the bios attribute which got changed
329      *
330      *  @param[in] attrValueEntry - The attribute value entry to update
331      *  @param[in] attrEntry - The attribute table entry
332      *  @param[in] isBMC - indicates if the attribute is set by BMC
333      */
334     void traceBIOSUpdate(const pldm_bios_attr_val_table_entry* attrValueEntry,
335                          const pldm_bios_attr_table_entry* attrEntry,
336                          bool isBMC);
337 
338     /** @brief Check the attribute value to update
339      *  @param[in] attrValueEntry - The attribute value entry to update
340      *  @param[in] attrEntry - The attribute table entry
341      *  @param[in] stringTable - The string  table
342      *  @return pldm_completion_codes
343      */
344     int checkAttrValueToUpdate(
345         const pldm_bios_attr_val_table_entry* attrValueEntry,
346         const pldm_bios_attr_table_entry* attrEntry, Table& stringTable);
347 
348     /** @brief Check the attribute table
349      *  @param[in] table - The table
350      *  @return pldm_completion_codes
351      */
352     int checkAttributeTable(const Table& table);
353 
354     /** @brief Check the attribute value table
355      *  @param[in] table - The table
356      *  @return pldm_completion_codes
357      */
358     int checkAttributeValueTable(const Table& table);
359 
360     /** @brief Update the BaseBIOSTable property of the D-Bus interface
361      */
362     void updateBaseBIOSTableProperty();
363 
364     /** @brief Listen the PendingAttributes property of the D-Bus interface and
365      *         update BaseBIOSTable
366      */
367     void listenPendingAttributes();
368 
369     /** @brief Find attribute handle from bios attribute table
370      *  @param[in] attrName - attribute name
371      *  @return attribute handle
372      */
373     uint16_t findAttrHandle(const std::string& attrName);
374 
375     /** @brief Listen the PendingAttributes property of the D-Bus interface
376      * and update BaseBIOSTable
377      *  @param[in] msg - Data associated with subscribed signal
378      */
379     void constructPendingAttribute(const PendingAttributes& pendingAttributes);
380 };
381 
382 } // namespace bios
383 } // namespace responder
384 } // namespace pldm
385