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 
62 /** @class BIOSConfig
63  *  @brief Manager BIOS Attributes
64  */
65 class BIOSConfig
66 {
67   public:
68     BIOSConfig() = delete;
69     BIOSConfig(const BIOSConfig&) = delete;
70     BIOSConfig(BIOSConfig&&) = delete;
71     BIOSConfig& operator=(const BIOSConfig&) = delete;
72     BIOSConfig& operator=(BIOSConfig&&) = delete;
73     ~BIOSConfig() = default;
74 
75     /** @brief Construct BIOSConfig
76      *  @param[in] jsonDir - The directory where json file exists
77      *  @param[in] tableDir - The directory where the persistent table is placed
78      *  @param[in] dbusHandler - Dbus Handler
79      *  @param[in] fd - socket descriptor to communicate to host
80      *  @param[in] eid - MCTP EID of host firmware
81      *  @param[in] instanceIdDb - pointer to an InstanceIdDb object
82      *  @param[in] handler - PLDM request handler
83      *  @param[in] platformConfigHandler - pointer to platform config Handler
84      */
85     explicit BIOSConfig(
86         const char* jsonDir, const char* tableDir,
87         pldm::utils::DBusHandler* const dbusHandler, int fd, uint8_t eid,
88         pldm::InstanceIdDb* instanceIdDb,
89         pldm::requester::Handler<pldm::requester::Request>* handler,
90         pldm::responder::platform_config::Handler* platformConfigHandler);
91 
92     /** @brief Set attribute value on dbus and attribute value table
93      *  @param[in] entry - attribute value entry
94      *  @param[in] size - size of the attribute value entry
95      *  @param[in] isBMC - indicates if the attribute is set by BMC
96      *  @param[in] updateDBus          - update Attr value D-Bus property
97      *                                   if this is set to true
98      *  @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
99      *                                   if this is set to true
100      *  @return pldm_completion_codes
101      */
102     int setAttrValue(const void* entry, size_t size, bool isBMC,
103                      bool updateDBus = true, bool updateBaseBIOSTable = true);
104 
105     /** @brief Remove the persistent tables */
106     void removeTables();
107 
108     /** @brief Build bios tables(string,attribute,attribute value table)*/
109     void buildTables();
110 
111     /** @brief Get BIOS table of specified type
112      *  @param[in] tableType - The table type
113      *  @return The bios table, std::nullopt if the table is unaviliable
114      */
115     std::optional<Table> getBIOSTable(pldm_bios_table_types tableType);
116 
117     /** @brief set BIOS table
118      *  @param[in] tableType - Indicates what table is being transferred
119      *             {BIOSStringTable=0x0, BIOSAttributeTable=0x1,
120      *              BIOSAttributeValueTable=0x2}
121      *  @param[in] table - table data
122      *  @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
123      *                                   if this is set to true
124      *  @return pldm_completion_codes
125      */
126     int setBIOSTable(uint8_t tableType, const Table& table,
127                      bool updateBaseBIOSTable = true);
128 
129   private:
130     /** @enum Index into the fields in the BaseBIOSTable
131      */
132     enum class Index : uint8_t
133     {
134         attributeType = 0,
135         readOnly,
136         displayName,
137         description,
138         menuPath,
139         currentValue,
140         defaultValue,
141         options,
142     };
143 
144     const fs::path jsonDir;
145     const fs::path tableDir;
146     pldm::utils::DBusHandler* const dbusHandler;
147     BaseBIOSTable baseBIOSTableMaps;
148 
149     /** @brief socket descriptor to communicate to host */
150     int fd;
151 
152     /** @brief MCTP EID of host firmware */
153     uint8_t eid;
154 
155     /** @brief pointer to an Instance ID database object, used to obtain PLDM
156      * instance IDs.
157      */
158     pldm::InstanceIdDb* instanceIdDb;
159 
160     /** @brief PLDM request handler */
161     pldm::requester::Handler<pldm::requester::Request>* handler;
162 
163     /** @brief platform config Handler*/
164     pldm::responder::platform_config::Handler* platformConfigHandler;
165 
166     // vector persists all attributes
167     using BIOSAttributes = std::vector<std::unique_ptr<BIOSAttribute>>;
168     BIOSAttributes biosAttributes;
169 
170     using propName = std::string;
171     using DbusChObjProperties = std::map<propName, pldm::utils::PropertyValue>;
172 
173     using ifaceName = std::string;
174     using DbusIfacesAdded = std::map<ifaceName, DbusChObjProperties>;
175 
176     // vector to catch the D-Bus property change signals for BIOS attributes
177     std::vector<std::unique_ptr<sdbusplus::bus::match_t>> biosAttrMatch;
178 
179     /** @brief system type/model */
180     std::string sysType;
181 
182     /** @brief Method to update a BIOS attribute when the corresponding Dbus
183      *  property is changed
184      *  @param[in] chProperties - list of properties which have changed
185      *  @param[in] biosAttrIndex - Index of BIOSAttribute pointer in
186      * biosAttributes
187      *  @return - none
188      */
189     void processBiosAttrChangeNotification(
190         const DbusChObjProperties& chProperties, uint32_t biosAttrIndex);
191 
192     /** @brief Construct an attribute and persist it
193      *  @tparam T - attribute type
194      *  @param[in] entry - json entry
195      */
196     template <typename T>
197     void constructAttribute(const Json& entry)
198     {
199         try
200         {
201             biosAttributes.push_back(std::make_unique<T>(entry, dbusHandler));
202             auto biosAttrIndex = biosAttributes.size() - 1;
203             auto dBusMap = biosAttributes[biosAttrIndex]->getDBusMap();
204 
205             if (dBusMap.has_value())
206             {
207                 using namespace sdbusplus::bus::match::rules;
208                 biosAttrMatch.push_back(
209                     std::make_unique<sdbusplus::bus::match_t>(
210                         pldm::utils::DBusHandler::getBus(),
211                         propertiesChanged(dBusMap->objectPath,
212                                           dBusMap->interface),
213                         [this, biosAttrIndex](sdbusplus::message_t& msg) {
214                     DbusChObjProperties props;
215                     std::string iface;
216                     msg.read(iface, props);
217                     processBiosAttrChangeNotification(props, biosAttrIndex);
218                 }));
219 
220                 biosAttrMatch.push_back(
221                     std::make_unique<sdbusplus::bus::match_t>(
222                         pldm::utils::DBusHandler::getBus(),
223                         interfacesAdded() + argNpath(0, dBusMap->objectPath),
224                         [this, biosAttrIndex, interface = dBusMap->interface](
225                             sdbusplus::message_t& msg) {
226                     sdbusplus::message::object_path path;
227                     DbusIfacesAdded interfaces;
228 
229                     msg.read(path, interfaces);
230                     auto ifaceIt = interfaces.find(interface);
231                     if (ifaceIt != interfaces.end())
232                     {
233                         processBiosAttrChangeNotification(ifaceIt->second,
234                                                           biosAttrIndex);
235                     }
236                 }));
237             }
238         }
239         catch (const std::exception& e)
240         {
241             error("Constructs Attribute Error, {ERR_EXCEP}", "ERR_EXCEP",
242                   e.what());
243         }
244     }
245 
246     /** Construct attributes and persist them */
247     void constructAttributes();
248 
249     using ParseHandler = std::function<void(const Json& entry)>;
250 
251     /** @brief Helper function to parse json
252      *  @param[in] filePath - Path of json file
253      *  @param[in] handler - Handler to process each entry in the json
254      */
255     void load(const fs::path& filePath, ParseHandler handler);
256 
257     /** @brief Build String Table and persist it
258      *  @return The built string table, std::nullopt if it fails.
259      */
260     std::optional<Table> buildAndStoreStringTable();
261 
262     /** @brief Build attribute table and attribute value table and persist them
263      *         Read the BaseBIOSTable from the bios-settings-manager and update
264      *         attribute table and attribute value table.
265      *
266      *  @param[in] stringTable - The string Table
267      */
268     void buildAndStoreAttrTables(const Table& stringTable);
269 
270     /** @brief Persist the table
271      *  @param[in] path - Path to persist the table
272      *  @param[in] table - The table
273      */
274     void storeTable(const fs::path& path, const Table& table);
275 
276     /** @brief Load bios table to ram
277      *  @param[in] path - Path of the table
278      *  @return The table, std::nullopt if loading fails
279      */
280     std::optional<Table> loadTable(const fs::path& path);
281 
282     /** @brief Method to decode the attribute name from the string handle
283      *
284      *  @param[in] stringEntry - string entry from string table
285      *  @return the decoded string
286      */
287     std::string decodeStringFromStringEntry(
288         const pldm_bios_string_table_entry* stringEntry);
289 
290     /** @brief Method to print the string Handle by passing the attribute Handle
291      *         of the bios attribute that got updated
292      *
293      *  @param[in] handle - the Attribute handle of the bios attribute
294      *  @param[in] index - index to the possible value handles
295      *  @param[in] attrTable - the attribute table
296      *  @param[in] stringTable - the string table
297      *  @return string handle from the string table and decoded string to the
298      * name handle
299      */
300     std::string displayStringHandle(uint16_t handle, uint8_t index,
301                                     const std::optional<Table>& attrTable,
302                                     const std::optional<Table>& stringTable);
303 
304     /** @brief Method to trace the bios attribute which got changed
305      *
306      *  @param[in] attrValueEntry - The attribute value entry to update
307      *  @param[in] attrEntry - The attribute table entry
308      *  @param[in] isBMC - indicates if the attribute is set by BMC
309      */
310     void traceBIOSUpdate(const pldm_bios_attr_val_table_entry* attrValueEntry,
311                          const pldm_bios_attr_table_entry* attrEntry,
312                          bool isBMC);
313 
314     /** @brief Check the attribute value to update
315      *  @param[in] attrValueEntry - The attribute value entry to update
316      *  @param[in] attrEntry - The attribute table entry
317      *  @param[in] stringTable - The string  table
318      *  @return pldm_completion_codes
319      */
320     int checkAttrValueToUpdate(
321         const pldm_bios_attr_val_table_entry* attrValueEntry,
322         const pldm_bios_attr_table_entry* attrEntry, Table& stringTable);
323 
324     /** @brief Check the attribute table
325      *  @param[in] table - The table
326      *  @return pldm_completion_codes
327      */
328     int checkAttributeTable(const Table& table);
329 
330     /** @brief Check the attribute value table
331      *  @param[in] table - The table
332      *  @return pldm_completion_codes
333      */
334     int checkAttributeValueTable(const Table& table);
335 
336     /** @brief Update the BaseBIOSTable property of the D-Bus interface
337      */
338     void updateBaseBIOSTableProperty();
339 
340     /** @brief Listen the PendingAttributes property of the D-Bus interface and
341      *         update BaseBIOSTable
342      */
343     void listenPendingAttributes();
344 
345     /** @brief Find attribute handle from bios attribute table
346      *  @param[in] attrName - attribute name
347      *  @return attribute handle
348      */
349     uint16_t findAttrHandle(const std::string& attrName);
350 
351     /** @brief Listen the PendingAttributes property of the D-Bus interface
352      * and update BaseBIOSTable
353      *  @param[in] msg - Data associated with subscribed signal
354      */
355     void constructPendingAttribute(const PendingAttributes& pendingAttributes);
356 };
357 
358 } // namespace bios
359 } // namespace responder
360 } // namespace pldm
361