1 #pragma once
2 
3 #include "pdr.hpp"
4 #include "pdr_utils.hpp"
5 
6 #include <libpldm/platform.h>
7 
8 #include <phosphor-logging/lg2.hpp>
9 
10 PHOSPHOR_LOG2_USING;
11 
12 namespace pldm
13 {
14 namespace responder
15 {
16 namespace pdr_state_effecter
17 {
18 using Json = nlohmann::json;
19 
20 static 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  */
29 template <class DBusInterface, class Handler>
30 void generateStateEffecterPDR(const DBusInterface& dBusIntf, const Json& json,
31                               Handler& handler, pdr_utils::RepoInterface& repo)
32 {
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             {
45                 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));
49                 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());
61         if (!pdr)
62         {
63             error("Failed to get state effecter PDR.");
64             continue;
65         }
66         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 
72         pdr->terminus_handle = TERMINUS_HANDLE;
73         pdr->effecter_id = handler.getNextEffecterId();
74 
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);
94 
95                 // do not create the PDR when the FRU or the entity path is not
96                 // present
97                 if (!pdr->entity_type)
98                 {
99                     error("The entity path for the FRU is not present.");
100                     continue;
101                 }
102             }
103         }
104         catch (const std::exception& ex)
105         {
106             pdr->entity_type = e.value("type", 0);
107             pdr->entity_instance = e.value("instance", 0);
108             pdr->container_id = e.value("container", 0);
109         }
110 
111         pdr->effecter_semantic_id = 0;
112         pdr->effecter_init = PLDM_NO_INIT;
113         pdr->has_description_pdr = false;
114         pdr->composite_effecter_count = effecters.size();
115 
116         pldm::responder::pdr_utils::DbusMappings dbusMappings{};
117         pldm::responder::pdr_utils::DbusValMaps dbusValMaps{};
118         uint8_t* start = entry.data() + sizeof(pldm_state_effecter_pdr) -
119                          sizeof(uint8_t);
120         for (const auto& effecter : effecters)
121         {
122             auto set = effecter.value("set", empty);
123             state_effecter_possible_states* possibleStates =
124                 reinterpret_cast<state_effecter_possible_states*>(start);
125             possibleStates->state_set_id = set.value("id", 0);
126             possibleStates->possible_states_size = set.value("size", 0);
127 
128             start += sizeof(possibleStates->state_set_id) +
129                      sizeof(possibleStates->possible_states_size);
130             static const std::vector<uint8_t> emptyStates{};
131             pldm::responder::pdr_utils::PossibleValues stateValues;
132             auto states = set.value("states", emptyStates);
133             for (const auto& state : states)
134             {
135                 auto index = state / 8;
136                 auto bit = state - (index * 8);
137                 bitfield8_t* bf = reinterpret_cast<bitfield8_t*>(start + index);
138                 bf->byte |= 1 << bit;
139                 stateValues.emplace_back(state);
140             }
141             start += possibleStates->possible_states_size;
142 
143             auto dbusEntry = effecter.value("dbus", empty);
144             auto objectPath = dbusEntry.value("path", "");
145             auto interface = dbusEntry.value("interface", "");
146             auto propertyName = dbusEntry.value("property_name", "");
147             auto propertyType = dbusEntry.value("property_type", "");
148 
149             pldm::responder::pdr_utils::StatestoDbusVal dbusIdToValMap{};
150             pldm::utils::DBusMapping dbusMapping{};
151             try
152             {
153                 auto service = dBusIntf.getService(objectPath.c_str(),
154                                                    interface.c_str());
155 
156                 dbusMapping = pldm::utils::DBusMapping{
157                     objectPath, interface, propertyName, propertyType};
158                 dbusIdToValMap = pldm::responder::pdr_utils::populateMapping(
159                     propertyType, dbusEntry["property_values"], stateValues);
160             }
161             catch (const std::exception& e)
162             {
163                 error(
164                     "D-Bus object path does not exist, effecter ID: {EFFECTER_ID}",
165                     "EFFECTER_ID", static_cast<uint16_t>(pdr->effecter_id));
166             }
167 
168             dbusMappings.emplace_back(std::move(dbusMapping));
169             dbusValMaps.emplace_back(std::move(dbusIdToValMap));
170         }
171         handler.addDbusObjMaps(
172             pdr->effecter_id,
173             std::make_tuple(std::move(dbusMappings), std::move(dbusValMaps)));
174         pldm::responder::pdr_utils::PdrEntry pdrEntry{};
175         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
184