blob: 49e079c0aeaad05f378397d052e990606d71dda5 [file] [log] [blame]
George Liua2870722020-02-11 11:09:30 +08001#pragma once
2
Sampa Misra12afe112020-05-25 11:40:44 -05003#include "pdr.hpp"
4#include "pdr_utils.hpp"
George Liu6492f522020-06-16 10:34:05 +08005
George Liuc453e162022-12-21 17:16:23 +08006#include <libpldm/platform.h>
Manojkiran Edacc5f1582021-09-29 17:03:06 +05307
Riya Dixit49cfb132023-03-02 04:26:53 -06008#include <phosphor-logging/lg2.hpp>
9
10PHOSPHOR_LOG2_USING;
11
George Liua2870722020-02-11 11:09:30 +080012namespace pldm
13{
George Liua2870722020-02-11 11:09:30 +080014namespace responder
15{
George Liua2870722020-02-11 11:09:30 +080016namespace pdr_state_effecter
17{
George Liua2870722020-02-11 11:09:30 +080018using Json = nlohmann::json;
19
20static const Json empty{};
21
22/** @brief Parse PDR JSON file and generate state effecter PDR structure
23 *
24 * @param[in] json - the JSON Object with the state effecter PDR
25 * @param[out] handler - the Parser of PLDM command handler
26 * @param[out] repo - pdr::RepoInterface
27 *
28 */
George Liu36e81352020-07-01 14:40:30 +080029template <class DBusInterface, class Handler>
30void generateStateEffecterPDR(const DBusInterface& dBusIntf, const Json& json,
31 Handler& handler, pdr_utils::RepoInterface& repo)
George Liua2870722020-02-11 11:09:30 +080032{
33 static const std::vector<Json> emptyList{};
34 auto entries = json.value("entries", emptyList);
35 for (const auto& e : entries)
36 {
37 size_t pdrSize = 0;
38 auto effecters = e.value("effecters", emptyList);
39 for (const auto& effecter : effecters)
40 {
41 auto set = effecter.value("set", empty);
42 auto statesSize = set.value("size", 0);
43 if (!statesSize)
44 {
Riya Dixit49cfb132023-03-02 04:26:53 -060045 error(
46 "Malformed PDR JSON return pdrEntry;- no state set info, TYPE={STATE_EFFECTER_PDR}",
47 "STATE_EFFECTER_PDR",
48 static_cast<unsigned>(PLDM_STATE_EFFECTER_PDR));
George Liua2870722020-02-11 11:09:30 +080049 throw InternalFailure();
50 }
51 pdrSize += sizeof(state_effecter_possible_states) -
52 sizeof(bitfield8_t) + (sizeof(bitfield8_t) * statesSize);
53 }
54 pdrSize += sizeof(pldm_state_effecter_pdr) - sizeof(uint8_t);
55
56 std::vector<uint8_t> entry{};
57 entry.resize(pdrSize);
58
59 pldm_state_effecter_pdr* pdr =
60 reinterpret_cast<pldm_state_effecter_pdr*>(entry.data());
Manojkiran Edabcf91ac2021-03-14 13:50:48 +053061 if (!pdr)
62 {
Riya Dixit49cfb132023-03-02 04:26:53 -060063 error("Failed to get state effecter PDR.");
Manojkiran Edabcf91ac2021-03-14 13:50:48 +053064 continue;
65 }
George Liua2870722020-02-11 11:09:30 +080066 pdr->hdr.record_handle = 0;
67 pdr->hdr.version = 1;
68 pdr->hdr.type = PLDM_STATE_EFFECTER_PDR;
69 pdr->hdr.record_change_num = 0;
70 pdr->hdr.length = pdrSize - sizeof(pldm_pdr_hdr);
71
Manojkiran Edacc5f1582021-09-29 17:03:06 +053072 pdr->terminus_handle = TERMINUS_HANDLE;
George Liua2870722020-02-11 11:09:30 +080073 pdr->effecter_id = handler.getNextEffecterId();
George Liuc4ea6a92020-07-14 15:48:44 +080074
75 try
76 {
77 std::string entity_path = e.value("entity_path", "");
78 auto& associatedEntityMap = handler.getAssociateEntityMap();
79 if (entity_path != "" && associatedEntityMap.find(entity_path) !=
80 associatedEntityMap.end())
81 {
82 pdr->entity_type =
83 associatedEntityMap.at(entity_path).entity_type;
84 pdr->entity_instance =
85 associatedEntityMap.at(entity_path).entity_instance_num;
86 pdr->container_id =
87 associatedEntityMap.at(entity_path).entity_container_id;
88 }
89 else
90 {
91 pdr->entity_type = e.value("type", 0);
92 pdr->entity_instance = e.value("instance", 0);
93 pdr->container_id = e.value("container", 0);
Pavithra Barithaya5f213472022-08-29 02:20:19 -050094
95 // do not create the PDR when the FRU or the entity path is not
96 // present
97 if (!pdr->entity_type)
98 {
Pavithra Barithaya5f213472022-08-29 02:20:19 -050099 continue;
100 }
George Liuc4ea6a92020-07-14 15:48:44 +0800101 }
102 }
Kamalkumar Patel58cbcaf2023-10-06 03:48:25 -0500103 catch (const std::exception&)
George Liuc4ea6a92020-07-14 15:48:44 +0800104 {
105 pdr->entity_type = e.value("type", 0);
106 pdr->entity_instance = e.value("instance", 0);
107 pdr->container_id = e.value("container", 0);
108 }
109
George Liua2870722020-02-11 11:09:30 +0800110 pdr->effecter_semantic_id = 0;
111 pdr->effecter_init = PLDM_NO_INIT;
112 pdr->has_description_pdr = false;
113 pdr->composite_effecter_count = effecters.size();
114
Brad Bishop5079ac42021-08-19 18:35:06 -0400115 pldm::responder::pdr_utils::DbusMappings dbusMappings{};
116 pldm::responder::pdr_utils::DbusValMaps dbusValMaps{};
Patrick Williams6da4f912023-05-10 07:50:53 -0500117 uint8_t* start = entry.data() + sizeof(pldm_state_effecter_pdr) -
118 sizeof(uint8_t);
George Liua2870722020-02-11 11:09:30 +0800119 for (const auto& effecter : effecters)
120 {
121 auto set = effecter.value("set", empty);
122 state_effecter_possible_states* possibleStates =
123 reinterpret_cast<state_effecter_possible_states*>(start);
124 possibleStates->state_set_id = set.value("id", 0);
125 possibleStates->possible_states_size = set.value("size", 0);
126
127 start += sizeof(possibleStates->state_set_id) +
128 sizeof(possibleStates->possible_states_size);
129 static const std::vector<uint8_t> emptyStates{};
Brad Bishop5079ac42021-08-19 18:35:06 -0400130 pldm::responder::pdr_utils::PossibleValues stateValues;
George Liua2870722020-02-11 11:09:30 +0800131 auto states = set.value("states", emptyStates);
132 for (const auto& state : states)
133 {
134 auto index = state / 8;
135 auto bit = state - (index * 8);
136 bitfield8_t* bf = reinterpret_cast<bitfield8_t*>(start + index);
137 bf->byte |= 1 << bit;
George Liuadbe1722020-05-09 19:20:19 +0800138 stateValues.emplace_back(state);
George Liua2870722020-02-11 11:09:30 +0800139 }
140 start += possibleStates->possible_states_size;
141
142 auto dbusEntry = effecter.value("dbus", empty);
143 auto objectPath = dbusEntry.value("path", "");
144 auto interface = dbusEntry.value("interface", "");
145 auto propertyName = dbusEntry.value("property_name", "");
146 auto propertyType = dbusEntry.value("property_type", "");
George Liu36e81352020-07-01 14:40:30 +0800147
Brad Bishop5079ac42021-08-19 18:35:06 -0400148 pldm::responder::pdr_utils::StatestoDbusVal dbusIdToValMap{};
George Liu821ebc42021-01-26 14:36:11 +0800149 pldm::utils::DBusMapping dbusMapping{};
George Liu36e81352020-07-01 14:40:30 +0800150 try
151 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500152 auto service = dBusIntf.getService(objectPath.c_str(),
153 interface.c_str());
George Liu821ebc42021-01-26 14:36:11 +0800154
155 dbusMapping = pldm::utils::DBusMapping{
156 objectPath, interface, propertyName, propertyType};
Brad Bishop5079ac42021-08-19 18:35:06 -0400157 dbusIdToValMap = pldm::responder::pdr_utils::populateMapping(
George Liu821ebc42021-01-26 14:36:11 +0800158 propertyType, dbusEntry["property_values"], stateValues);
George Liu36e81352020-07-01 14:40:30 +0800159 }
160 catch (const std::exception& e)
161 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600162 error(
Manojkiran Edac81d1122024-02-21 20:17:34 +0530163 "Failed to create effecter PDR, D-Bus object '{PATH}' returned {ERROR}",
164 "PATH", objectPath, "ERROR", e);
165 continue;
George Liu36e81352020-07-01 14:40:30 +0800166 }
167
George Liua2870722020-02-11 11:09:30 +0800168 dbusMappings.emplace_back(std::move(dbusMapping));
George Liu821ebc42021-01-26 14:36:11 +0800169 dbusValMaps.emplace_back(std::move(dbusIdToValMap));
George Liua2870722020-02-11 11:09:30 +0800170 }
171 handler.addDbusObjMaps(
172 pdr->effecter_id,
173 std::make_tuple(std::move(dbusMappings), std::move(dbusValMaps)));
Brad Bishop5079ac42021-08-19 18:35:06 -0400174 pldm::responder::pdr_utils::PdrEntry pdrEntry{};
George Liua2870722020-02-11 11:09:30 +0800175 pdrEntry.data = entry.data();
176 pdrEntry.size = pdrSize;
177 repo.addRecord(pdrEntry);
178 }
179}
180
181} // namespace pdr_state_effecter
182} // namespace responder
183} // namespace pldm