blob: 57fcdf40e814ef2321917a63a83d140d1b4b9075 [file] [log] [blame]
John Wangd9659342020-02-27 16:46:05 +08001#pragma once
2
3#include "bios_attribute.hpp"
4#include "bios_table.hpp"
Tom Joseph7f839f92020-09-21 10:20:44 +05305#include "pldmd/dbus_impl_requester.hpp"
Sampa Misrac0c79482021-06-02 08:01:54 -05006#include "requester/handler.hpp"
John Wangd9659342020-02-27 16:46:05 +08007
George Liuc453e162022-12-21 17:16:23 +08008#include <libpldm/bios_table.h>
9
George Liu6492f522020-06-16 10:34:05 +080010#include <nlohmann/json.hpp>
11
John Wangd9659342020-02-27 16:46:05 +080012#include <functional>
13#include <iostream>
14#include <memory>
John Wangd9659342020-02-27 16:46:05 +080015#include <optional>
16#include <set>
17#include <string>
18#include <vector>
19
John Wangd9659342020-02-27 16:46:05 +080020namespace pldm
21{
22namespace responder
23{
24namespace bios
25{
George Liu1b180d82020-07-23 14:01:58 +080026enum class BoundType
27{
28 LowerBound,
29 UpperBound,
30 ScalarIncrement,
31 MinStringLength,
32 MaxStringLength,
33 OneOf
34};
35
36using AttributeName = std::string;
37using AttributeType = std::string;
38using ReadonlyStatus = bool;
39using DisplayName = std::string;
40using Description = std::string;
41using MenuPath = std::string;
42using CurrentValue = std::variant<int64_t, std::string>;
43using DefaultValue = std::variant<int64_t, std::string>;
44using OptionString = std::string;
45using OptionValue = std::variant<int64_t, std::string>;
46using Option = std::vector<std::tuple<OptionString, OptionValue>>;
47using BIOSTableObj =
48 std::tuple<AttributeType, ReadonlyStatus, DisplayName, Description,
49 MenuPath, CurrentValue, DefaultValue, Option>;
50using BaseBIOSTable = std::map<AttributeName, BIOSTableObj>;
51
George Liu1244acf2020-08-14 09:11:11 +080052using PendingObj = std::tuple<AttributeType, CurrentValue>;
53using PendingAttributes = std::map<AttributeName, PendingObj>;
54
John Wangd9659342020-02-27 16:46:05 +080055/** @class BIOSConfig
56 * @brief Manager BIOS Attributes
57 */
58class BIOSConfig
59{
60 public:
61 BIOSConfig() = delete;
62 BIOSConfig(const BIOSConfig&) = delete;
63 BIOSConfig(BIOSConfig&&) = delete;
64 BIOSConfig& operator=(const BIOSConfig&) = delete;
65 BIOSConfig& operator=(BIOSConfig&&) = delete;
66 ~BIOSConfig() = default;
67
68 /** @brief Construct BIOSConfig
69 * @param[in] jsonDir - The directory where json file exists
70 * @param[in] tableDir - The directory where the persistent table is placed
71 * @param[in] dbusHandler - Dbus Handler
Tom Joseph7f839f92020-09-21 10:20:44 +053072 * @param[in] fd - socket descriptor to communicate to host
73 * @param[in] eid - MCTP EID of host firmware
74 * @param[in] requester - pointer to Requester object
Sampa Misrac0c79482021-06-02 08:01:54 -050075 * @param[in] handler - PLDM request handler
John Wangd9659342020-02-27 16:46:05 +080076 */
Sampa Misrac0c79482021-06-02 08:01:54 -050077 explicit BIOSConfig(
78 const char* jsonDir, const char* tableDir,
Brad Bishop5079ac42021-08-19 18:35:06 -040079 pldm::utils::DBusHandler* const dbusHandler, int fd, uint8_t eid,
Sampa Misrac0c79482021-06-02 08:01:54 -050080 dbus_api::Requester* requester,
81 pldm::requester::Handler<pldm::requester::Request>* handler);
John Wangd9659342020-02-27 16:46:05 +080082
83 /** @brief Set attribute value on dbus and attribute value table
84 * @param[in] entry - attribute value entry
85 * @param[in] size - size of the attribute value entry
Sagar Srinivascac0ebb2021-11-23 07:50:28 -060086 * @param[in] isBMC - indicates if the attribute is set by BMC
George Liu6d6d1e82021-02-16 11:08:55 +080087 * @param[in] updateDBus - update Attr value D-Bus property
88 * if this is set to true
Tom Joseph7f839f92020-09-21 10:20:44 +053089 * @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
90 * if this is set to true
John Wangd9659342020-02-27 16:46:05 +080091 * @return pldm_completion_codes
92 */
Sagar Srinivascac0ebb2021-11-23 07:50:28 -060093 int setAttrValue(const void* entry, size_t size, bool isBMC,
94 bool updateDBus = true, bool updateBaseBIOSTable = true);
John Wangd9659342020-02-27 16:46:05 +080095
96 /** @brief Remove the persistent tables */
97 void removeTables();
98
99 /** @brief Build bios tables(string,attribute,attribute value table)*/
100 void buildTables();
101
102 /** @brief Get BIOS table of specified type
103 * @param[in] tableType - The table type
104 * @return The bios table, std::nullopt if the table is unaviliable
105 */
106 std::optional<Table> getBIOSTable(pldm_bios_table_types tableType);
107
George Liu1b180d82020-07-23 14:01:58 +0800108 /** @brief set BIOS table
109 * @param[in] tableType - Indicates what table is being transferred
110 * {BIOSStringTable=0x0, BIOSAttributeTable=0x1,
111 * BIOSAttributeValueTable=0x2}
112 * @param[in] table - table data
Tom Joseph7f839f92020-09-21 10:20:44 +0530113 * @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
114 * if this is set to true
George Liu1b180d82020-07-23 14:01:58 +0800115 * @return pldm_completion_codes
116 */
Tom Joseph7f839f92020-09-21 10:20:44 +0530117 int setBIOSTable(uint8_t tableType, const Table& table,
118 bool updateBaseBIOSTable = true);
George Liu1b180d82020-07-23 14:01:58 +0800119
John Wangd9659342020-02-27 16:46:05 +0800120 private:
Tom Josephca7b2522020-11-18 12:27:11 +0530121 /** @enum Index into the fields in the BaseBIOSTable
122 */
123 enum class Index : uint8_t
124 {
125 attributeType = 0,
126 readOnly,
127 displayName,
128 description,
129 menuPath,
130 currentValue,
131 defaultValue,
132 options,
133 };
134
John Wangd9659342020-02-27 16:46:05 +0800135 const fs::path jsonDir;
136 const fs::path tableDir;
Brad Bishop5079ac42021-08-19 18:35:06 -0400137 pldm::utils::DBusHandler* const dbusHandler;
George Liu1b180d82020-07-23 14:01:58 +0800138 BaseBIOSTable baseBIOSTableMaps;
John Wangd9659342020-02-27 16:46:05 +0800139
Tom Joseph7f839f92020-09-21 10:20:44 +0530140 /** @brief socket descriptor to communicate to host */
141 int fd;
142
143 /** @brief MCTP EID of host firmware */
144 uint8_t eid;
145
146 /** @brief pointer to Requester object, primarily used to access API to
147 * obtain PLDM instance id.
148 */
149 dbus_api::Requester* requester;
150
Sampa Misrac0c79482021-06-02 08:01:54 -0500151 /** @brief PLDM request handler */
152 pldm::requester::Handler<pldm::requester::Request>* handler;
153
John Wangd9659342020-02-27 16:46:05 +0800154 // vector persists all attributes
155 using BIOSAttributes = std::vector<std::unique_ptr<BIOSAttribute>>;
156 BIOSAttributes biosAttributes;
157
Sampa Misra46ece062020-03-18 07:17:44 -0500158 using propName = std::string;
Brad Bishop5079ac42021-08-19 18:35:06 -0400159 using DbusChObjProperties = std::map<propName, pldm::utils::PropertyValue>;
Sampa Misra46ece062020-03-18 07:17:44 -0500160
161 // vector to catch the D-Bus property change signals for BIOS attributes
Patrick Williams84b790c2022-07-22 19:26:56 -0500162 std::vector<std::unique_ptr<sdbusplus::bus::match_t>> biosAttrMatch;
Sampa Misra46ece062020-03-18 07:17:44 -0500163
164 /** @brief Method to update a BIOS attribute when the corresponding Dbus
165 * property is changed
166 * @param[in] chProperties - list of properties which have changed
167 * @param[in] biosAttrIndex - Index of BIOSAttribute pointer in
168 * biosAttributes
169 * @return - none
170 */
171 void processBiosAttrChangeNotification(
172 const DbusChObjProperties& chProperties, uint32_t biosAttrIndex);
173
John Wangd9659342020-02-27 16:46:05 +0800174 /** @brief Construct an attribute and persist it
175 * @tparam T - attribute type
176 * @param[in] entry - json entry
177 */
178 template <typename T>
179 void constructAttribute(const Json& entry)
180 {
181 try
182 {
183 biosAttributes.push_back(std::make_unique<T>(entry, dbusHandler));
Sampa Misra46ece062020-03-18 07:17:44 -0500184 auto biosAttrIndex = biosAttributes.size() - 1;
185 auto dBusMap = biosAttributes[biosAttrIndex]->getDBusMap();
186
187 if (dBusMap.has_value())
188 {
189 using namespace sdbusplus::bus::match::rules;
190 biosAttrMatch.push_back(
Patrick Williams84b790c2022-07-22 19:26:56 -0500191 std::make_unique<sdbusplus::bus::match_t>(
Sampa Misra46ece062020-03-18 07:17:44 -0500192 pldm::utils::DBusHandler::getBus(),
193 propertiesChanged(dBusMap->objectPath,
194 dBusMap->interface),
Patrick Williams84b790c2022-07-22 19:26:56 -0500195 [this, biosAttrIndex](sdbusplus::message_t& msg) {
Sampa Misra46ece062020-03-18 07:17:44 -0500196 DbusChObjProperties props;
197 std::string iface;
198 msg.read(iface, props);
199 processBiosAttrChangeNotification(props,
200 biosAttrIndex);
201 }));
202 }
John Wangd9659342020-02-27 16:46:05 +0800203 }
204 catch (const std::exception& e)
205 {
206 std::cerr << "Constructs Attribute Error, " << e.what()
207 << std::endl;
208 }
209 }
210
211 /** Construct attributes and persist them */
212 void constructAttributes();
213
214 using ParseHandler = std::function<void(const Json& entry)>;
215
216 /** @brief Helper function to parse json
217 * @param[in] filePath - Path of json file
218 * @param[in] handler - Handler to process each entry in the json
219 */
220 void load(const fs::path& filePath, ParseHandler handler);
221
222 /** @brief Build String Table and persist it
223 * @return The built string table, std::nullopt if it fails.
224 */
225 std::optional<Table> buildAndStoreStringTable();
226
Tom Josephca7b2522020-11-18 12:27:11 +0530227 /** @brief Build attribute table and attribute value table and persist them
228 * Read the BaseBIOSTable from the bios-settings-manager and update
229 * attribute table and attribute value table.
230 *
John Wangd9659342020-02-27 16:46:05 +0800231 * @param[in] stringTable - The string Table
232 */
233 void buildAndStoreAttrTables(const Table& stringTable);
234
235 /** @brief Persist the table
236 * @param[in] path - Path to persist the table
237 * @param[in] table - The table
238 */
239 void storeTable(const fs::path& path, const Table& table);
240
241 /** @brief Load bios table to ram
242 * @param[in] path - Path of the table
243 * @return The table, std::nullopt if loading fails
244 */
245 std::optional<Table> loadTable(const fs::path& path);
John Wang8241b342020-06-05 10:49:17 +0800246
Sagar Srinivascac0ebb2021-11-23 07:50:28 -0600247 /** @brief Method to decode the attribute name from the string handle
248 *
249 * @param[in] stringEntry - string entry from string table
250 * @return the decoded string
251 */
252 std::string decodeStringFromStringEntry(
253 const pldm_bios_string_table_entry* stringEntry);
254
255 /** @brief Method to print the string Handle by passing the attribute Handle
256 * of the bios attribute that got updated
257 *
258 * @param[in] handle - the Attribute handle of the bios attribute
259 * @param[in] index - index to the possible value handles
260 * @param[in] attrTable - the attribute table
261 * @param[in] stringTable - the string table
262 * @return string handle from the string table and decoded string to the
263 * name handle
264 */
265 std::string displayStringHandle(uint16_t handle, uint8_t index,
266 const std::optional<Table>& attrTable,
267 const std::optional<Table>& stringTable);
268
269 /** @brief Method to trace the bios attribute which got changed
270 *
271 * @param[in] attrValueEntry - The attribute value entry to update
272 * @param[in] attrEntry - The attribute table entry
273 * @param[in] isBMC - indicates if the attribute is set by BMC
274 */
275 void traceBIOSUpdate(const pldm_bios_attr_val_table_entry* attrValueEntry,
276 const pldm_bios_attr_table_entry* attrEntry,
277 bool isBMC);
278
John Wang8241b342020-06-05 10:49:17 +0800279 /** @brief Check the attribute value to update
280 * @param[in] attrValueEntry - The attribute value entry to update
281 * @param[in] attrEntry - The attribute table entry
282 * @param[in] stringTable - The string table
283 * @return pldm_completion_codes
284 */
285 int checkAttrValueToUpdate(
286 const pldm_bios_attr_val_table_entry* attrValueEntry,
287 const pldm_bios_attr_table_entry* attrEntry, Table& stringTable);
George Liu1b180d82020-07-23 14:01:58 +0800288
289 /** @brief Check the attribute table
290 * @param[in] table - The table
291 * @return pldm_completion_codes
292 */
293 int checkAttributeTable(const Table& table);
294
295 /** @brief Check the attribute value table
296 * @param[in] table - The table
297 * @return pldm_completion_codes
298 */
299 int checkAttributeValueTable(const Table& table);
300
301 /** @brief Update the BaseBIOSTable property of the D-Bus interface
302 */
303 void updateBaseBIOSTableProperty();
George Liu1244acf2020-08-14 09:11:11 +0800304
305 /** @brief Listen the PendingAttributes property of the D-Bus interface and
306 * update BaseBIOSTable
307 */
308 void listenPendingAttributes();
309
310 /** @brief Find attribute handle from bios attribute table
311 * @param[in] attrName - attribute name
312 * @return attribute handle
313 */
314 uint16_t findAttrHandle(const std::string& attrName);
315
316 /** @brief Listen the PendingAttributes property of the D-Bus interface
317 * and update BaseBIOSTable
318 * @param[in] msg - Data associated with subscribed signal
319 */
320 void constructPendingAttribute(const PendingAttributes& pendingAttributes);
John Wangd9659342020-02-27 16:46:05 +0800321};
322
323} // namespace bios
324} // namespace responder
Sampa Misra46ece062020-03-18 07:17:44 -0500325} // namespace pldm