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> constructAttribute(const Json & entry)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("Failed to construct an attribute, error - {ERROR}", "ERROR", 266 e); 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