blob: 5812e3bc3a028df5cc811477c6ed1f6afef98cbf [file] [log] [blame]
John Wangd9659342020-02-27 16:46:05 +08001#pragma once
2
3#include "bios_attribute.hpp"
4#include "bios_table.hpp"
Andrew Jeffery2abbce72023-10-18 10:17:35 +10305#include "common/instance_id.hpp"
Sagar Srinivas11ce8d22022-07-28 11:32:34 -05006#include "oem_handler.hpp"
Kamalkumar Patel3c50c822024-01-30 07:14:40 -06007#include "platform_config.hpp"
Sampa Misrac0c79482021-06-02 08:01:54 -05008#include "requester/handler.hpp"
John Wangd9659342020-02-27 16:46:05 +08009
George Liuc453e162022-12-21 17:16:23 +080010#include <libpldm/bios_table.h>
11
George Liu6492f522020-06-16 10:34:05 +080012#include <nlohmann/json.hpp>
Riya Dixit49cfb132023-03-02 04:26:53 -060013#include <phosphor-logging/lg2.hpp>
George Liu6492f522020-06-16 10:34:05 +080014
John Wangd9659342020-02-27 16:46:05 +080015#include <functional>
16#include <iostream>
17#include <memory>
John Wangd9659342020-02-27 16:46:05 +080018#include <optional>
19#include <set>
20#include <string>
21#include <vector>
22
Riya Dixit49cfb132023-03-02 04:26:53 -060023PHOSPHOR_LOG2_USING;
24
John Wangd9659342020-02-27 16:46:05 +080025namespace pldm
26{
27namespace responder
28{
29namespace bios
30{
George Liu1b180d82020-07-23 14:01:58 +080031enum class BoundType
32{
33 LowerBound,
34 UpperBound,
35 ScalarIncrement,
36 MinStringLength,
37 MaxStringLength,
38 OneOf
39};
40
41using AttributeName = std::string;
42using AttributeType = std::string;
43using ReadonlyStatus = bool;
44using DisplayName = std::string;
45using Description = std::string;
46using MenuPath = std::string;
47using CurrentValue = std::variant<int64_t, std::string>;
48using DefaultValue = std::variant<int64_t, std::string>;
49using OptionString = std::string;
50using OptionValue = std::variant<int64_t, std::string>;
Sagar Srinivas7927f902023-10-09 07:53:00 -050051using ValueDisplayName = std::string;
52using Option =
53 std::vector<std::tuple<OptionString, OptionValue, ValueDisplayName>>;
George Liu1b180d82020-07-23 14:01:58 +080054using BIOSTableObj =
55 std::tuple<AttributeType, ReadonlyStatus, DisplayName, Description,
56 MenuPath, CurrentValue, DefaultValue, Option>;
57using BaseBIOSTable = std::map<AttributeName, BIOSTableObj>;
58
George Liu1244acf2020-08-14 09:11:11 +080059using PendingObj = std::tuple<AttributeType, CurrentValue>;
60using PendingAttributes = std::map<AttributeName, PendingObj>;
Archana Kakani62dd8ff2024-02-12 10:00:40 -060061using Callback = std::function<void()>;
George Liu1244acf2020-08-14 09:11:11 +080062
John Wangd9659342020-02-27 16:46:05 +080063/** @class BIOSConfig
64 * @brief Manager BIOS Attributes
65 */
66class 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
Tom Joseph7f839f92020-09-21 10:20:44 +053080 * @param[in] fd - socket descriptor to communicate to host
81 * @param[in] eid - MCTP EID of host firmware
Andrew Jefferya330b2f2023-05-04 14:55:37 +093082 * @param[in] instanceIdDb - pointer to an InstanceIdDb object
Sampa Misrac0c79482021-06-02 08:01:54 -050083 * @param[in] handler - PLDM request handler
Kamalkumar Patel3c50c822024-01-30 07:14:40 -060084 * @param[in] platformConfigHandler - pointer to platform config Handler
Archana Kakani62dd8ff2024-02-12 10:00:40 -060085 * @param[in] requestPLDMServiceName - Callback for claiming the PLDM
86 * service name Called only after building BIOS tables.
John Wangd9659342020-02-27 16:46:05 +080087 */
Sampa Misrac0c79482021-06-02 08:01:54 -050088 explicit BIOSConfig(
89 const char* jsonDir, const char* tableDir,
Brad Bishop5079ac42021-08-19 18:35:06 -040090 pldm::utils::DBusHandler* const dbusHandler, int fd, uint8_t eid,
Andrew Jefferya330b2f2023-05-04 14:55:37 +093091 pldm::InstanceIdDb* instanceIdDb,
Sagar Srinivas11ce8d22022-07-28 11:32:34 -050092 pldm::requester::Handler<pldm::requester::Request>* handler,
Archana Kakani62dd8ff2024-02-12 10:00:40 -060093 pldm::responder::platform_config::Handler* platformConfigHandler,
94 pldm::responder::bios::Callback requestPLDMServiceName);
John Wangd9659342020-02-27 16:46:05 +080095
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
Sagar Srinivascac0ebb2021-11-23 07:50:28 -060099 * @param[in] isBMC - indicates if the attribute is set by BMC
George Liu6d6d1e82021-02-16 11:08:55 +0800100 * @param[in] updateDBus - update Attr value D-Bus property
101 * if this is set to true
Tom Joseph7f839f92020-09-21 10:20:44 +0530102 * @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
103 * if this is set to true
John Wangd9659342020-02-27 16:46:05 +0800104 * @return pldm_completion_codes
105 */
Sagar Srinivascac0ebb2021-11-23 07:50:28 -0600106 int setAttrValue(const void* entry, size_t size, bool isBMC,
107 bool updateDBus = true, bool updateBaseBIOSTable = true);
John Wangd9659342020-02-27 16:46:05 +0800108
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
George Liu1b180d82020-07-23 14:01:58 +0800121 /** @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
Tom Joseph7f839f92020-09-21 10:20:44 +0530126 * @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
127 * if this is set to true
George Liu1b180d82020-07-23 14:01:58 +0800128 * @return pldm_completion_codes
129 */
Tom Joseph7f839f92020-09-21 10:20:44 +0530130 int setBIOSTable(uint8_t tableType, const Table& table,
131 bool updateBaseBIOSTable = true);
George Liu1b180d82020-07-23 14:01:58 +0800132
Archana Kakani62dd8ff2024-02-12 10:00:40 -0600133 /** @brief Construct the BIOS Attributes and build the tables
134 * after receiving system type from entity manager.
Archana Kakani46f352e2024-03-17 08:21:08 -0500135 * Also register the Service Name only if
136 * System specific Bios attributes are supported
Archana Kakani62dd8ff2024-02-12 10:00:40 -0600137 * @param[in] String - System Type
Archana Kakani46f352e2024-03-17 08:21:08 -0500138 * @param[in] bool - flag to register service name
Archana Kakani62dd8ff2024-02-12 10:00:40 -0600139 * @return void
140 */
Archana Kakani46f352e2024-03-17 08:21:08 -0500141 void initBIOSAttributes(const std::string& sysType, bool registerService);
Archana Kakani62dd8ff2024-02-12 10:00:40 -0600142
John Wangd9659342020-02-27 16:46:05 +0800143 private:
Tom Josephca7b2522020-11-18 12:27:11 +0530144 /** @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
John Wangd9659342020-02-27 16:46:05 +0800158 const fs::path jsonDir;
159 const fs::path tableDir;
Brad Bishop5079ac42021-08-19 18:35:06 -0400160 pldm::utils::DBusHandler* const dbusHandler;
George Liu1b180d82020-07-23 14:01:58 +0800161 BaseBIOSTable baseBIOSTableMaps;
John Wangd9659342020-02-27 16:46:05 +0800162
Tom Joseph7f839f92020-09-21 10:20:44 +0530163 /** @brief MCTP EID of host firmware */
164 uint8_t eid;
165
Andrew Jefferya330b2f2023-05-04 14:55:37 +0930166 /** @brief pointer to an Instance ID database object, used to obtain PLDM
167 * instance IDs.
Tom Joseph7f839f92020-09-21 10:20:44 +0530168 */
Andrew Jefferya330b2f2023-05-04 14:55:37 +0930169 pldm::InstanceIdDb* instanceIdDb;
Tom Joseph7f839f92020-09-21 10:20:44 +0530170
Sampa Misrac0c79482021-06-02 08:01:54 -0500171 /** @brief PLDM request handler */
172 pldm::requester::Handler<pldm::requester::Request>* handler;
173
Kamalkumar Patel3c50c822024-01-30 07:14:40 -0600174 /** @brief platform config Handler*/
175 pldm::responder::platform_config::Handler* platformConfigHandler;
Sagar Srinivas11ce8d22022-07-28 11:32:34 -0500176
Archana Kakani62dd8ff2024-02-12 10:00:40 -0600177 /** @brief Callback for registering the PLDM service name */
178 pldm::responder::bios::Callback requestPLDMServiceName;
179
John Wangd9659342020-02-27 16:46:05 +0800180 // vector persists all attributes
181 using BIOSAttributes = std::vector<std::unique_ptr<BIOSAttribute>>;
182 BIOSAttributes biosAttributes;
183
Sampa Misra46ece062020-03-18 07:17:44 -0500184 using propName = std::string;
Brad Bishop5079ac42021-08-19 18:35:06 -0400185 using DbusChObjProperties = std::map<propName, pldm::utils::PropertyValue>;
Sampa Misra46ece062020-03-18 07:17:44 -0500186
Matt Spinlerd987c942023-03-24 10:18:19 -0500187 using ifaceName = std::string;
188 using DbusIfacesAdded = std::map<ifaceName, DbusChObjProperties>;
189
Sampa Misra46ece062020-03-18 07:17:44 -0500190 // vector to catch the D-Bus property change signals for BIOS attributes
Patrick Williams84b790c2022-07-22 19:26:56 -0500191 std::vector<std::unique_ptr<sdbusplus::bus::match_t>> biosAttrMatch;
Sampa Misra46ece062020-03-18 07:17:44 -0500192
Sagar Srinivas11ce8d22022-07-28 11:32:34 -0500193 /** @brief system type/model */
194 std::string sysType;
195
Sampa Misra46ece062020-03-18 07:17:44 -0500196 /** @brief Method to update a BIOS attribute when the corresponding Dbus
197 * property is changed
198 * @param[in] chProperties - list of properties which have changed
199 * @param[in] biosAttrIndex - Index of BIOSAttribute pointer in
200 * biosAttributes
201 * @return - none
202 */
203 void processBiosAttrChangeNotification(
204 const DbusChObjProperties& chProperties, uint32_t biosAttrIndex);
205
Archana Kakani46f352e2024-03-17 08:21:08 -0500206 /** @brief Method is used to initiate bios attributes only if system type
207 * is already populated by entity manager.
208 * Register the callback if system type is yet to be populated by Entity
209 * manager
Archana Kakani62dd8ff2024-02-12 10:00:40 -0600210 */
Archana Kakani46f352e2024-03-17 08:21:08 -0500211 void checkSystemTypeAvailability();
Archana Kakani62dd8ff2024-02-12 10:00:40 -0600212
John Wangd9659342020-02-27 16:46:05 +0800213 /** @brief Construct an attribute and persist it
214 * @tparam T - attribute type
215 * @param[in] entry - json entry
216 */
217 template <typename T>
218 void constructAttribute(const Json& entry)
219 {
220 try
221 {
222 biosAttributes.push_back(std::make_unique<T>(entry, dbusHandler));
Sampa Misra46ece062020-03-18 07:17:44 -0500223 auto biosAttrIndex = biosAttributes.size() - 1;
224 auto dBusMap = biosAttributes[biosAttrIndex]->getDBusMap();
225
226 if (dBusMap.has_value())
227 {
228 using namespace sdbusplus::bus::match::rules;
229 biosAttrMatch.push_back(
Patrick Williams84b790c2022-07-22 19:26:56 -0500230 std::make_unique<sdbusplus::bus::match_t>(
Sampa Misra46ece062020-03-18 07:17:44 -0500231 pldm::utils::DBusHandler::getBus(),
232 propertiesChanged(dBusMap->objectPath,
233 dBusMap->interface),
Patrick Williams84b790c2022-07-22 19:26:56 -0500234 [this, biosAttrIndex](sdbusplus::message_t& msg) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500235 DbusChObjProperties props;
236 std::string iface;
237 msg.read(iface, props);
238 processBiosAttrChangeNotification(props, biosAttrIndex);
Patrick Williamsa6756622023-10-20 11:19:15 -0500239 }));
Matt Spinlerd987c942023-03-24 10:18:19 -0500240
241 biosAttrMatch.push_back(
Patrick Williamsb90fb7f2023-04-12 02:31:38 -0500242 std::make_unique<sdbusplus::bus::match_t>(
Matt Spinlerd987c942023-03-24 10:18:19 -0500243 pldm::utils::DBusHandler::getBus(),
244 interfacesAdded() + argNpath(0, dBusMap->objectPath),
245 [this, biosAttrIndex, interface = dBusMap->interface](
Patrick Williamsb90fb7f2023-04-12 02:31:38 -0500246 sdbusplus::message_t& msg) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500247 sdbusplus::message::object_path path;
248 DbusIfacesAdded interfaces;
Matt Spinlerd987c942023-03-24 10:18:19 -0500249
Patrick Williams6da4f912023-05-10 07:50:53 -0500250 msg.read(path, interfaces);
251 auto ifaceIt = interfaces.find(interface);
252 if (ifaceIt != interfaces.end())
253 {
254 processBiosAttrChangeNotification(ifaceIt->second,
255 biosAttrIndex);
256 }
Patrick Williamsa6756622023-10-20 11:19:15 -0500257 }));
Sampa Misra46ece062020-03-18 07:17:44 -0500258 }
John Wangd9659342020-02-27 16:46:05 +0800259 }
260 catch (const std::exception& e)
261 {
Riya Dixit89644442024-03-31 05:39:59 -0500262 error("Failed to construct an attribute, error - {ERROR}", "ERROR",
263 e);
John Wangd9659342020-02-27 16:46:05 +0800264 }
265 }
266
267 /** Construct attributes and persist them */
268 void constructAttributes();
269
270 using ParseHandler = std::function<void(const Json& entry)>;
271
272 /** @brief Helper function to parse json
273 * @param[in] filePath - Path of json file
274 * @param[in] handler - Handler to process each entry in the json
275 */
276 void load(const fs::path& filePath, ParseHandler handler);
277
278 /** @brief Build String Table and persist it
279 * @return The built string table, std::nullopt if it fails.
280 */
281 std::optional<Table> buildAndStoreStringTable();
282
Tom Josephca7b2522020-11-18 12:27:11 +0530283 /** @brief Build attribute table and attribute value table and persist them
284 * Read the BaseBIOSTable from the bios-settings-manager and update
285 * attribute table and attribute value table.
286 *
John Wangd9659342020-02-27 16:46:05 +0800287 * @param[in] stringTable - The string Table
288 */
289 void buildAndStoreAttrTables(const Table& stringTable);
290
291 /** @brief Persist the table
292 * @param[in] path - Path to persist the table
293 * @param[in] table - The table
294 */
295 void storeTable(const fs::path& path, const Table& table);
296
297 /** @brief Load bios table to ram
298 * @param[in] path - Path of the table
299 * @return The table, std::nullopt if loading fails
300 */
301 std::optional<Table> loadTable(const fs::path& path);
John Wang8241b342020-06-05 10:49:17 +0800302
Sagar Srinivascac0ebb2021-11-23 07:50:28 -0600303 /** @brief Method to decode the attribute name from the string handle
304 *
305 * @param[in] stringEntry - string entry from string table
306 * @return the decoded string
307 */
308 std::string decodeStringFromStringEntry(
309 const pldm_bios_string_table_entry* stringEntry);
310
311 /** @brief Method to print the string Handle by passing the attribute Handle
312 * of the bios attribute that got updated
313 *
314 * @param[in] handle - the Attribute handle of the bios attribute
315 * @param[in] index - index to the possible value handles
316 * @param[in] attrTable - the attribute table
317 * @param[in] stringTable - the string table
318 * @return string handle from the string table and decoded string to the
319 * name handle
320 */
321 std::string displayStringHandle(uint16_t handle, uint8_t index,
322 const std::optional<Table>& attrTable,
323 const std::optional<Table>& stringTable);
324
325 /** @brief Method to trace the bios attribute which got changed
326 *
327 * @param[in] attrValueEntry - The attribute value entry to update
328 * @param[in] attrEntry - The attribute table entry
329 * @param[in] isBMC - indicates if the attribute is set by BMC
330 */
331 void traceBIOSUpdate(const pldm_bios_attr_val_table_entry* attrValueEntry,
332 const pldm_bios_attr_table_entry* attrEntry,
333 bool isBMC);
334
John Wang8241b342020-06-05 10:49:17 +0800335 /** @brief Check the attribute value to update
336 * @param[in] attrValueEntry - The attribute value entry to update
337 * @param[in] attrEntry - The attribute table entry
338 * @param[in] stringTable - The string table
339 * @return pldm_completion_codes
340 */
341 int checkAttrValueToUpdate(
342 const pldm_bios_attr_val_table_entry* attrValueEntry,
343 const pldm_bios_attr_table_entry* attrEntry, Table& stringTable);
George Liu1b180d82020-07-23 14:01:58 +0800344
345 /** @brief Check the attribute table
346 * @param[in] table - The table
347 * @return pldm_completion_codes
348 */
349 int checkAttributeTable(const Table& table);
350
351 /** @brief Check the attribute value table
352 * @param[in] table - The table
353 * @return pldm_completion_codes
354 */
355 int checkAttributeValueTable(const Table& table);
356
357 /** @brief Update the BaseBIOSTable property of the D-Bus interface
358 */
359 void updateBaseBIOSTableProperty();
George Liu1244acf2020-08-14 09:11:11 +0800360
361 /** @brief Listen the PendingAttributes property of the D-Bus interface and
362 * update BaseBIOSTable
363 */
364 void listenPendingAttributes();
365
366 /** @brief Find attribute handle from bios attribute table
367 * @param[in] attrName - attribute name
368 * @return attribute handle
369 */
370 uint16_t findAttrHandle(const std::string& attrName);
371
372 /** @brief Listen the PendingAttributes property of the D-Bus interface
373 * and update BaseBIOSTable
374 * @param[in] msg - Data associated with subscribed signal
375 */
376 void constructPendingAttribute(const PendingAttributes& pendingAttributes);
John Wangd9659342020-02-27 16:46:05 +0800377};
378
379} // namespace bios
380} // namespace responder
Sampa Misra46ece062020-03-18 07:17:44 -0500381} // namespace pldm