blob: 98734bae0fa22a9ad14c76fa00fb2a5c16f8dc46 [file] [log] [blame]
John Wangd9659342020-02-27 16:46:05 +08001#pragma once
2
3#include "bios_attribute.hpp"
4#include "bios_table.hpp"
5
6#include <functional>
7#include <iostream>
8#include <memory>
9#include <nlohmann/json.hpp>
10#include <optional>
11#include <set>
12#include <string>
13#include <vector>
14
15#include "bios_table.h"
16
17namespace pldm
18{
19namespace responder
20{
21namespace bios
22{
23
24/** @class BIOSConfig
25 * @brief Manager BIOS Attributes
26 */
27class BIOSConfig
28{
29 public:
30 BIOSConfig() = delete;
31 BIOSConfig(const BIOSConfig&) = delete;
32 BIOSConfig(BIOSConfig&&) = delete;
33 BIOSConfig& operator=(const BIOSConfig&) = delete;
34 BIOSConfig& operator=(BIOSConfig&&) = delete;
35 ~BIOSConfig() = default;
36
37 /** @brief Construct BIOSConfig
38 * @param[in] jsonDir - The directory where json file exists
39 * @param[in] tableDir - The directory where the persistent table is placed
40 * @param[in] dbusHandler - Dbus Handler
41 */
42 explicit BIOSConfig(const char* jsonDir, const char* tableDir,
43 DBusHandler* const dbusHandler);
44
45 /** @brief Set attribute value on dbus and attribute value table
46 * @param[in] entry - attribute value entry
47 * @param[in] size - size of the attribute value entry
48 * @return pldm_completion_codes
49 */
50 int setAttrValue(const void* entry, size_t size);
51
52 /** @brief Remove the persistent tables */
53 void removeTables();
54
55 /** @brief Build bios tables(string,attribute,attribute value table)*/
56 void buildTables();
57
58 /** @brief Get BIOS table of specified type
59 * @param[in] tableType - The table type
60 * @return The bios table, std::nullopt if the table is unaviliable
61 */
62 std::optional<Table> getBIOSTable(pldm_bios_table_types tableType);
63
64 private:
65 const fs::path jsonDir;
66 const fs::path tableDir;
67 DBusHandler* const dbusHandler;
68
69 // vector persists all attributes
70 using BIOSAttributes = std::vector<std::unique_ptr<BIOSAttribute>>;
71 BIOSAttributes biosAttributes;
72
Sampa Misra46ece062020-03-18 07:17:44 -050073 using propName = std::string;
74 using DbusChObjProperties = std::map<propName, PropertyValue>;
75
76 // vector to catch the D-Bus property change signals for BIOS attributes
77 std::vector<std::unique_ptr<sdbusplus::bus::match::match>> biosAttrMatch;
78
79 /** @brief Method to update a BIOS attribute when the corresponding Dbus
80 * property is changed
81 * @param[in] chProperties - list of properties which have changed
82 * @param[in] biosAttrIndex - Index of BIOSAttribute pointer in
83 * biosAttributes
84 * @return - none
85 */
86 void processBiosAttrChangeNotification(
87 const DbusChObjProperties& chProperties, uint32_t biosAttrIndex);
88
John Wangd9659342020-02-27 16:46:05 +080089 /** @brief Construct an attribute and persist it
90 * @tparam T - attribute type
91 * @param[in] entry - json entry
92 */
93 template <typename T>
94 void constructAttribute(const Json& entry)
95 {
96 try
97 {
98 biosAttributes.push_back(std::make_unique<T>(entry, dbusHandler));
Sampa Misra46ece062020-03-18 07:17:44 -050099 auto biosAttrIndex = biosAttributes.size() - 1;
100 auto dBusMap = biosAttributes[biosAttrIndex]->getDBusMap();
101
102 if (dBusMap.has_value())
103 {
104 using namespace sdbusplus::bus::match::rules;
105 biosAttrMatch.push_back(
106 std::make_unique<sdbusplus::bus::match::match>(
107 pldm::utils::DBusHandler::getBus(),
108 propertiesChanged(dBusMap->objectPath,
109 dBusMap->interface),
110 [this,
111 biosAttrIndex](sdbusplus::message::message& msg) {
112 DbusChObjProperties props;
113 std::string iface;
114 msg.read(iface, props);
115 processBiosAttrChangeNotification(props,
116 biosAttrIndex);
117 }));
118 }
John Wangd9659342020-02-27 16:46:05 +0800119 }
120 catch (const std::exception& e)
121 {
122 std::cerr << "Constructs Attribute Error, " << e.what()
123 << std::endl;
124 }
125 }
126
127 /** Construct attributes and persist them */
128 void constructAttributes();
129
130 using ParseHandler = std::function<void(const Json& entry)>;
131
132 /** @brief Helper function to parse json
133 * @param[in] filePath - Path of json file
134 * @param[in] handler - Handler to process each entry in the json
135 */
136 void load(const fs::path& filePath, ParseHandler handler);
137
138 /** @brief Build String Table and persist it
139 * @return The built string table, std::nullopt if it fails.
140 */
141 std::optional<Table> buildAndStoreStringTable();
142
143 /** @brief Build attr table and attr value table and persist them
144 * @param[in] stringTable - The string Table
145 */
146 void buildAndStoreAttrTables(const Table& stringTable);
147
148 /** @brief Persist the table
149 * @param[in] path - Path to persist the table
150 * @param[in] table - The table
151 */
152 void storeTable(const fs::path& path, const Table& table);
153
154 /** @brief Load bios table to ram
155 * @param[in] path - Path of the table
156 * @return The table, std::nullopt if loading fails
157 */
158 std::optional<Table> loadTable(const fs::path& path);
John Wang8241b342020-06-05 10:49:17 +0800159
160 /** @brief Check the attribute value to update
161 * @param[in] attrValueEntry - The attribute value entry to update
162 * @param[in] attrEntry - The attribute table entry
163 * @param[in] stringTable - The string table
164 * @return pldm_completion_codes
165 */
166 int checkAttrValueToUpdate(
167 const pldm_bios_attr_val_table_entry* attrValueEntry,
168 const pldm_bios_attr_table_entry* attrEntry, Table& stringTable);
John Wangd9659342020-02-27 16:46:05 +0800169};
170
171} // namespace bios
172} // namespace responder
Sampa Misra46ece062020-03-18 07:17:44 -0500173} // namespace pldm