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