blob: 397eb75a5ffc6068eb3e3163932e25d18a0f1b50 [file] [log] [blame]
Deepak Kodihalli557dfb02019-05-12 13:11:17 +05301#pragma once
2
Sampa Misraa2fa0702019-05-31 01:28:55 -05003#include "config.h"
4
George Liu6492f522020-06-16 10:34:05 +08005#include "libpldm/platform.h"
6#include "libpldm/states.h"
George Liuc4ea6a92020-07-14 15:48:44 +08007#include "pdr.h"
George Liu6492f522020-06-16 10:34:05 +08008
Deepak Kodihallid130e1a2020-06-17 05:55:32 -05009#include "common/utils.hpp"
TOM JOSEPHd4d97a52020-03-23 14:36:34 +053010#include "event_parser.hpp"
Tom Joseph33e9c7e2020-06-11 22:09:52 +053011#include "fru.hpp"
George Liucae18662020-05-15 09:32:57 +080012#include "host-bmc/dbus_to_event_handler.hpp"
Deepak Kodihalliac19bd62020-06-16 08:25:23 -050013#include "host-bmc/host_pdr_handler.hpp"
Sampa Misraa2fa0702019-05-31 01:28:55 -050014#include "libpldmresponder/pdr.hpp"
George Liue53193f2020-02-24 09:23:26 +080015#include "libpldmresponder/pdr_utils.hpp"
Sampa Misraaea5dde2020-08-31 08:33:47 -050016#include "oem_handler.hpp"
Deepak Kodihalli1521f6d2020-06-16 08:51:02 -050017#include "pldmd/handler.hpp"
Sampa Misraa2fa0702019-05-31 01:28:55 -050018
Deepak Kodihalli557dfb02019-05-12 13:11:17 +053019#include <stdint.h>
20
Sampa Misraa2fa0702019-05-31 01:28:55 -050021#include <map>
Deepak Kodihalli557dfb02019-05-12 13:11:17 +053022
Deepak Kodihalli557dfb02019-05-12 13:11:17 +053023namespace pldm
24{
Deepak Kodihalli557dfb02019-05-12 13:11:17 +053025namespace responder
26{
Sampa Misraa2fa0702019-05-31 01:28:55 -050027namespace platform
28{
29
George Liu1ec85d42020-02-12 16:05:32 +080030using namespace pldm::utils;
31using namespace pldm::responder::pdr_utils;
George Liucae18662020-05-15 09:32:57 +080032using namespace pldm::state_sensor;
George Liu1ec85d42020-02-12 16:05:32 +080033
George Liua2870722020-02-11 11:09:30 +080034using generatePDR =
George Liu36e81352020-07-01 14:40:30 +080035 std::function<void(const pldm::utils::DBusHandler& dBusIntf,
36 const Json& json, pdr_utils::RepoInterface& repo)>;
George Liua2870722020-02-11 11:09:30 +080037
George Liu1ec85d42020-02-12 16:05:32 +080038using EffecterId = uint16_t;
George Liua2870722020-02-11 11:09:30 +080039using DbusObjMaps =
40 std::map<EffecterId,
41 std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps>>;
Tom Joseph56e45c52020-03-16 10:01:45 +053042using DbusPath = std::string;
43using EffecterObjs = std::vector<DbusPath>;
44using EventType = uint8_t;
45using EventHandler = std::function<int(
46 const pldm_msg* request, size_t payloadLength, uint8_t formatVersion,
47 uint8_t tid, size_t eventDataOffset)>;
48using EventHandlers = std::vector<EventHandler>;
49using EventMap = std::map<EventType, EventHandlers>;
George Liuc4ea6a92020-07-14 15:48:44 +080050using AssociatedEntityMap = std::map<DbusPath, pldm_entity>;
Deepak Kodihallic682fe22020-03-04 00:42:54 -060051
Deepak Kodihallibc669f12019-11-28 08:52:07 -060052class Handler : public CmdHandler
Sampa Misraa2fa0702019-05-31 01:28:55 -050053{
Deepak Kodihallibc669f12019-11-28 08:52:07 -060054 public:
Deepak Kodihallib5c227e2020-07-13 06:58:34 -050055 Handler(const pldm::utils::DBusHandler* dBusIntf,
Pavithra Barithaya3aec9972020-12-14 01:55:44 -060056 const std::string& pdrJsonsDir, pldm_pdr* repo,
57 HostPDRHandler* hostPDRHandler,
George Liucae18662020-05-15 09:32:57 +080058 DbusToPLDMEvent* dbusToPLDMEventHandler, fru::Handler* fruHandler,
Sampa Misraaea5dde2020-08-31 08:33:47 -050059 pldm::responder::oem_platform::Handler* oemPlatformHandler,
Sampa Misra5fb37d52021-03-06 07:26:00 -060060 sdeventplus::Event& event, bool buildPDRLazily = false,
Tom Joseph56e45c52020-03-16 10:01:45 +053061 const std::optional<EventMap>& addOnHandlersMap = std::nullopt) :
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050062 pdrRepo(repo),
Pavithra Barithaya3aec9972020-12-14 01:55:44 -060063 hostPDRHandler(hostPDRHandler),
George Liucae18662020-05-15 09:32:57 +080064 dbusToPLDMEventHandler(dbusToPLDMEventHandler), fruHandler(fruHandler),
Sampa Misraaea5dde2020-08-31 08:33:47 -050065 dBusIntf(dBusIntf), oemPlatformHandler(oemPlatformHandler),
Sampa Misra5fb37d52021-03-06 07:26:00 -060066 event(event), pdrJsonsDir(pdrJsonsDir), pdrCreated(false)
Sampa Misraa2fa0702019-05-31 01:28:55 -050067 {
Deepak Kodihallib5c227e2020-07-13 06:58:34 -050068 if (!buildPDRLazily)
69 {
Sampa Misra12afe112020-05-25 11:40:44 -050070 generateTerminusLocatorPDR(pdrRepo);
Deepak Kodihallib5c227e2020-07-13 06:58:34 -050071 generate(*dBusIntf, pdrJsonsDir, pdrRepo);
72 pdrCreated = true;
73 }
Deepak Kodihallic682fe22020-03-04 00:42:54 -060074
Deepak Kodihallibc669f12019-11-28 08:52:07 -060075 handlers.emplace(PLDM_GET_PDR,
76 [this](const pldm_msg* request, size_t payloadLength) {
77 return this->getPDR(request, payloadLength);
78 });
George Liueccb0c52020-01-14 11:09:56 +080079 handlers.emplace(PLDM_SET_NUMERIC_EFFECTER_VALUE,
80 [this](const pldm_msg* request, size_t payloadLength) {
81 return this->setNumericEffecterValue(
82 request, payloadLength);
83 });
Deepak Kodihallibc669f12019-11-28 08:52:07 -060084 handlers.emplace(PLDM_SET_STATE_EFFECTER_STATES,
85 [this](const pldm_msg* request, size_t payloadLength) {
86 return this->setStateEffecterStates(request,
87 payloadLength);
88 });
Tom Joseph56e45c52020-03-16 10:01:45 +053089 handlers.emplace(PLDM_PLATFORM_EVENT_MESSAGE,
90 [this](const pldm_msg* request, size_t payloadLength) {
91 return this->platformEventMessage(request,
92 payloadLength);
93 });
George Liu362c18d2020-05-14 09:46:36 +080094 handlers.emplace(PLDM_GET_STATE_SENSOR_READINGS,
95 [this](const pldm_msg* request, size_t payloadLength) {
96 return this->getStateSensorReadings(request,
97 payloadLength);
98 });
Tom Joseph56e45c52020-03-16 10:01:45 +053099
100 // Default handler for PLDM Events
101 eventHandlers[PLDM_SENSOR_EVENT].emplace_back(
102 [this](const pldm_msg* request, size_t payloadLength,
103 uint8_t formatVersion, uint8_t tid, size_t eventDataOffset) {
104 return this->sensorEvent(request, payloadLength, formatVersion,
105 tid, eventDataOffset);
106 });
Deepak Kodihalli8cb6f662020-04-10 02:55:43 -0500107 eventHandlers[PLDM_PDR_REPOSITORY_CHG_EVENT].emplace_back(
108 [this](const pldm_msg* request, size_t payloadLength,
109 uint8_t formatVersion, uint8_t tid, size_t eventDataOffset) {
110 return this->pldmPDRRepositoryChgEvent(request, payloadLength,
111 formatVersion, tid,
112 eventDataOffset);
113 });
Tom Joseph56e45c52020-03-16 10:01:45 +0530114
115 // Additional OEM event handlers for PLDM events, append it to the
116 // standard handlers
117 if (addOnHandlersMap)
118 {
119 auto addOnHandlers = addOnHandlersMap.value();
120 for (EventMap::iterator iter = addOnHandlers.begin();
121 iter != addOnHandlers.end(); ++iter)
122 {
123 auto search = eventHandlers.find(iter->first);
124 if (search != eventHandlers.end())
125 {
126 search->second.insert(std::end(search->second),
127 std::begin(iter->second),
128 std::end(iter->second));
129 }
130 else
131 {
132 eventHandlers.emplace(iter->first, iter->second);
133 }
134 }
135 }
Sampa Misraa2fa0702019-05-31 01:28:55 -0500136 }
137
George Liu1ec85d42020-02-12 16:05:32 +0800138 pdr_utils::Repo& getRepo()
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600139 {
George Liu1ec85d42020-02-12 16:05:32 +0800140 return this->pdrRepo;
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600141 }
142
George Liu1ec85d42020-02-12 16:05:32 +0800143 /** @brief Add D-Bus mapping and value mapping(stateId to D-Bus) for the
George Liuadbe1722020-05-09 19:20:19 +0800144 * Id. If the same id is added, the previous dbusObjs will
George Liu1ec85d42020-02-12 16:05:32 +0800145 * be "over-written".
146 *
George Liuadbe1722020-05-09 19:20:19 +0800147 * @param[in] Id - effecter/sensor id
George Liu1ec85d42020-02-12 16:05:32 +0800148 * @param[in] dbusObj - list of D-Bus object structure and list of D-Bus
149 * property value to attribute value
George Liuadbe1722020-05-09 19:20:19 +0800150 * @param[in] typeId - the type id of enum
George Liu1ec85d42020-02-12 16:05:32 +0800151 */
George Liua2870722020-02-11 11:09:30 +0800152 void addDbusObjMaps(
George Liuadbe1722020-05-09 19:20:19 +0800153 uint16_t id,
154 std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps> dbusObj,
155 TypeId typeId = TypeId::PLDM_EFFECTER_ID);
George Liu1ec85d42020-02-12 16:05:32 +0800156
George Liuadbe1722020-05-09 19:20:19 +0800157 /** @brief Retrieve an id -> D-Bus objects mapping
George Liu1ec85d42020-02-12 16:05:32 +0800158 *
George Liuadbe1722020-05-09 19:20:19 +0800159 * @param[in] Id - id
160 * @param[in] typeId - the type id of enum
George Liu1ec85d42020-02-12 16:05:32 +0800161 *
George Liua2870722020-02-11 11:09:30 +0800162 * @return std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps> -
163 * list of D-Bus object structure and list of D-Bus property value
164 * to attribute value
George Liu1ec85d42020-02-12 16:05:32 +0800165 */
George Liua2870722020-02-11 11:09:30 +0800166 const std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps>&
George Liuadbe1722020-05-09 19:20:19 +0800167 getDbusObjMaps(uint16_t id,
168 TypeId typeId = TypeId::PLDM_EFFECTER_ID) const;
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600169
170 uint16_t getNextEffecterId()
171 {
172 return ++nextEffecterId;
173 }
174
George Liuadbe1722020-05-09 19:20:19 +0800175 uint16_t getNextSensorId()
176 {
177 return ++nextSensorId;
178 }
179
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600180 /** @brief Parse PDR JSONs and build PDR repository
181 *
George Liu36e81352020-07-01 14:40:30 +0800182 * @param[in] dBusIntf - The interface object
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600183 * @param[in] dir - directory housing platform specific PDR JSON files
184 * @param[in] repo - instance of concrete implementation of Repo
185 */
George Liu36e81352020-07-01 14:40:30 +0800186 void generate(const pldm::utils::DBusHandler& dBusIntf,
187 const std::string& dir, Repo& repo);
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600188
189 /** @brief Parse PDR JSONs and build state effecter PDR repository
190 *
191 * @param[in] json - platform specific PDR JSON files
192 * @param[in] repo - instance of state effecter implementation of Repo
193 */
194 void generateStateEffecterRepo(const Json& json, Repo& repo);
195
Tom Joseph56e45c52020-03-16 10:01:45 +0530196 /** @brief map of PLDM event type to EventHandlers
197 *
198 */
199 EventMap eventHandlers;
200
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600201 /** @brief Handler for GetPDR
202 *
203 * @param[in] request - Request message payload
204 * @param[in] payloadLength - Request payload length
205 * @param[out] Response - Response message written here
206 */
207 Response getPDR(const pldm_msg* request, size_t payloadLength);
Sampa Misraa2fa0702019-05-31 01:28:55 -0500208
George Liueccb0c52020-01-14 11:09:56 +0800209 /** @brief Handler for setNumericEffecterValue
210 *
211 * @param[in] request - Request message
212 * @param[in] payloadLength - Request payload length
213 * @return Response - PLDM Response message
214 */
215 Response setNumericEffecterValue(const pldm_msg* request,
216 size_t payloadLength);
217
George Liu362c18d2020-05-14 09:46:36 +0800218 /** @brief Handler for getStateSensorReadings
219 *
220 * @param[in] request - Request message
221 * @param[in] payloadLength - Request payload length
222 * @return Response - PLDM Response message
223 */
224 Response getStateSensorReadings(const pldm_msg* request,
225 size_t payloadLength);
226
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600227 /** @brief Handler for setStateEffecterStates
228 *
229 * @param[in] request - Request message
230 * @param[in] payloadLength - Request payload length
231 * @return Response - PLDM Response message
232 */
233 Response setStateEffecterStates(const pldm_msg* request,
234 size_t payloadLength);
235
Tom Joseph56e45c52020-03-16 10:01:45 +0530236 /** @brief Handler for PlatformEventMessage
237 *
238 * @param[in] request - Request message
239 * @param[in] payloadLength - Request payload length
240 * @return Response - PLDM Response message
241 */
242 Response platformEventMessage(const pldm_msg* request,
243 size_t payloadLength);
244
245 /** @brief Handler for event class Sensor event
246 *
247 * @param[in] request - Request message
248 * @param[in] payloadLength - Request payload length
249 * @param[in] formatVersion - Version of the event format
250 * @param[in] tid - Terminus ID of the event's originator
251 * @param[in] eventDataOffset - Offset of the event data in the request
252 * message
253 * @return PLDM completion code
254 */
255 int sensorEvent(const pldm_msg* request, size_t payloadLength,
256 uint8_t formatVersion, uint8_t tid, size_t eventDataOffset);
257
Deepak Kodihalli8cb6f662020-04-10 02:55:43 -0500258 /** @brief Handler for pldmPDRRepositoryChgEvent
259 *
260 * @param[in] request - Request message
261 * @param[in] payloadLength - Request payload length
262 * @param[in] formatVersion - Version of the event format
263 * @param[in] tid - Terminus ID of the event's originator
264 * @param[in] eventDataOffset - Offset of the event data in the request
265 * message
266 * @return PLDM completion code
267 */
268 int pldmPDRRepositoryChgEvent(const pldm_msg* request, size_t payloadLength,
269 uint8_t formatVersion, uint8_t tid,
270 size_t eventDataOffset);
271
272 /** @brief Handler for extracting the PDR handles from changeEntries
273 *
274 * @param[in] changeEntryData - ChangeEntry data from changeRecord
275 * @param[in] changeEntryDataSize - total size of changeEntryData
276 * @param[in] numberOfChangeEntries - total number of changeEntries to
277 * extract
278 * @param[out] pdrRecordHandles - std::vector where the extracted PDR
279 * handles are placed
280 * @return PLDM completion code
281 */
282 int getPDRRecordHandles(const ChangeEntry* changeEntryData,
283 size_t changeEntryDataSize,
284 size_t numberOfChangeEntries,
285 PDRRecordHandles& pdrRecordHandles);
286
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600287 /** @brief Function to set the effecter requested by pldm requester
288 * @param[in] dBusIntf - The interface object
289 * @param[in] effecterId - Effecter ID sent by the requester to act on
290 * @param[in] stateField - The state field data for each of the states,
291 * equal to composite effecter count in number
292 * @return - Success or failure in setting the states. Returns failure in
293 * terms of PLDM completion codes if atleast one state fails to be set
294 */
295 template <class DBusInterface>
296 int setStateEffecterStatesHandler(
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600297 const DBusInterface& dBusIntf, uint16_t effecterId,
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600298 const std::vector<set_effecter_state_field>& stateField)
Sampa Misraa2fa0702019-05-31 01:28:55 -0500299 {
George Liue53193f2020-02-24 09:23:26 +0800300 using namespace pldm::responder::pdr;
George Liu1e44c732020-02-28 20:20:06 +0800301 using namespace pldm::utils;
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600302 using StateSetNum = uint8_t;
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600303
304 state_effecter_possible_states* states = nullptr;
305 pldm_state_effecter_pdr* pdr = nullptr;
306 uint8_t compEffecterCnt = stateField.size();
George Liu1ec85d42020-02-12 16:05:32 +0800307
308 std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)>
309 stateEffecterPdrRepo(pldm_pdr_init(), pldm_pdr_destroy);
310 Repo stateEffecterPDRs(stateEffecterPdrRepo.get());
311 getRepoByType(pdrRepo, stateEffecterPDRs, PLDM_STATE_EFFECTER_PDR);
312 if (stateEffecterPDRs.empty())
313 {
314 std::cerr << "Failed to get record by PDR type\n";
315 return PLDM_PLATFORM_INVALID_EFFECTER_ID;
316 }
317
George Liue53193f2020-02-24 09:23:26 +0800318 PdrEntry pdrEntry{};
George Liu1ec85d42020-02-12 16:05:32 +0800319 auto pdrRecord = stateEffecterPDRs.getFirstRecord(pdrEntry);
George Liue53193f2020-02-24 09:23:26 +0800320 while (pdrRecord)
321 {
322 pdr = reinterpret_cast<pldm_state_effecter_pdr*>(pdrEntry.data);
323 if (pdr->effecter_id != effecterId)
Sampa Misraa2fa0702019-05-31 01:28:55 -0500324 {
George Liue53193f2020-02-24 09:23:26 +0800325 pdr = nullptr;
George Liu1ec85d42020-02-12 16:05:32 +0800326 pdrRecord =
327 stateEffecterPDRs.getNextRecord(pdrRecord, pdrEntry);
George Liue53193f2020-02-24 09:23:26 +0800328 continue;
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600329 }
George Liue53193f2020-02-24 09:23:26 +0800330
331 states = reinterpret_cast<state_effecter_possible_states*>(
332 pdr->possible_states);
333 if (compEffecterCnt > pdr->composite_effecter_count)
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600334 {
George Liue53193f2020-02-24 09:23:26 +0800335 std::cerr << "The requester sent wrong composite effecter"
336 << " count for the effecter, EFFECTER_ID="
Manojkiran Eda394fac62021-07-22 15:58:29 +0530337 << (unsigned)effecterId
338 << "COMP_EFF_CNT=" << (unsigned)compEffecterCnt
George Liue53193f2020-02-24 09:23:26 +0800339 << "\n";
340 return PLDM_ERROR_INVALID_DATA;
Sampa Misraa2fa0702019-05-31 01:28:55 -0500341 }
George Liue53193f2020-02-24 09:23:26 +0800342 break;
343 }
344
345 if (!pdr)
346 {
347 return PLDM_PLATFORM_INVALID_EFFECTER_ID;
Sampa Misraa2fa0702019-05-31 01:28:55 -0500348 }
Sampa Misraa2fa0702019-05-31 01:28:55 -0500349
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600350 int rc = PLDM_SUCCESS;
George Liu1ec85d42020-02-12 16:05:32 +0800351 try
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600352 {
George Liu1ec85d42020-02-12 16:05:32 +0800353 const auto& [dbusMappings, dbusValMaps] =
George Liuadbe1722020-05-09 19:20:19 +0800354 effecterDbusObjMaps.at(effecterId);
George Liu1ec85d42020-02-12 16:05:32 +0800355 for (uint8_t currState = 0; currState < compEffecterCnt;
356 ++currState)
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600357 {
George Liu1ec85d42020-02-12 16:05:32 +0800358 std::vector<StateSetNum> allowed{};
359 // computation is based on table 79 from DSP0248 v1.1.1
360 uint8_t bitfieldIndex =
361 stateField[currState].effecter_state / 8;
362 uint8_t bit =
363 stateField[currState].effecter_state - (8 * bitfieldIndex);
364 if (states->possible_states_size < bitfieldIndex ||
365 !(states->states[bitfieldIndex].byte & (1 << bit)))
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600366 {
George Liu1ec85d42020-02-12 16:05:32 +0800367 std::cerr
Manojkiran Eda394fac62021-07-22 15:58:29 +0530368 << "Invalid state set value, EFFECTER_ID="
369 << (unsigned)effecterId << " VALUE="
370 << (unsigned)stateField[currState].effecter_state
371 << " COMPOSITE_EFFECTER_ID=" << (unsigned)currState
George Liu1ec85d42020-02-12 16:05:32 +0800372 << " DBUS_PATH=" << dbusMappings[currState].objectPath
373 << "\n";
374 rc = PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE;
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600375 break;
376 }
George Liu1ec85d42020-02-12 16:05:32 +0800377 const DBusMapping& dbusMapping = dbusMappings[currState];
378 const StatestoDbusVal& dbusValToMap = dbusValMaps[currState];
379
380 if (stateField[currState].set_request == PLDM_REQUEST_SET)
381 {
382 try
383 {
384 dBusIntf.setDbusProperty(
385 dbusMapping,
386 dbusValToMap.at(
387 stateField[currState].effecter_state));
388 }
389 catch (const std::exception& e)
390 {
391 std::cerr
392 << "Error setting property, ERROR=" << e.what()
393 << " PROPERTY=" << dbusMapping.propertyName
394 << " INTERFACE="
395 << dbusMapping.interface << " PATH="
396 << dbusMapping.objectPath << "\n";
397 return PLDM_ERROR;
398 }
399 }
400 uint8_t* nextState =
401 reinterpret_cast<uint8_t*>(states) +
402 sizeof(state_effecter_possible_states) -
403 sizeof(states->states) +
404 (states->possible_states_size * sizeof(states->states));
405 states = reinterpret_cast<state_effecter_possible_states*>(
406 nextState);
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600407 }
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600408 }
George Liu1ec85d42020-02-12 16:05:32 +0800409 catch (const std::out_of_range& e)
410 {
411 std::cerr << "the effecterId does not exist. effecter id: "
Manojkiran Eda394fac62021-07-22 15:58:29 +0530412 << (unsigned)effecterId << e.what() << '\n';
George Liu1ec85d42020-02-12 16:05:32 +0800413 }
414
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600415 return rc;
416 }
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600417
Sampa Misra12afe112020-05-25 11:40:44 -0500418 /** @brief Build BMC Terminus Locator PDR
419 *
420 * @param[in] repo - instance of concrete implementation of Repo
421 */
422 void generateTerminusLocatorPDR(Repo& repo);
423
George Liuc4ea6a92020-07-14 15:48:44 +0800424 /** @brief Get std::map associated with the entity
425 * key: object path
426 * value: pldm_entity
427 *
428 * @return std::map<ObjectPath, pldm_entity>
429 */
430 inline const AssociatedEntityMap& getAssociateEntityMap() const
431 {
432 if (fruHandler == nullptr)
433 {
434 throw InternalFailure();
435 }
436 return fruHandler->getAssociateEntityMap();
437 }
438
Sampa Misra5fb37d52021-03-06 07:26:00 -0600439 /** @brief process the actions that needs to be performed after a GetPDR
440 * call is received
441 * @param[in] source - sdeventplus event source
442 */
443 void _processPostGetPDRActions(sdeventplus::source::EventBase& source);
444
Deepak Kodihallic682fe22020-03-04 00:42:54 -0600445 private:
446 pdr_utils::Repo pdrRepo;
447 uint16_t nextEffecterId{};
George Liuadbe1722020-05-09 19:20:19 +0800448 uint16_t nextSensorId{};
449 DbusObjMaps effecterDbusObjMaps{};
450 DbusObjMaps sensorDbusObjMaps{};
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500451 HostPDRHandler* hostPDRHandler;
George Liucae18662020-05-15 09:32:57 +0800452 DbusToPLDMEvent* dbusToPLDMEventHandler;
Tom Joseph33e9c7e2020-06-11 22:09:52 +0530453 fru::Handler* fruHandler;
Deepak Kodihallib5c227e2020-07-13 06:58:34 -0500454 const pldm::utils::DBusHandler* dBusIntf;
Sampa Misraaea5dde2020-08-31 08:33:47 -0500455 pldm::responder::oem_platform::Handler* oemPlatformHandler;
Sampa Misra5fb37d52021-03-06 07:26:00 -0600456 sdeventplus::Event& event;
Deepak Kodihallib5c227e2020-07-13 06:58:34 -0500457 std::string pdrJsonsDir;
458 bool pdrCreated;
Sampa Misra5fb37d52021-03-06 07:26:00 -0600459 std::unique_ptr<sdeventplus::source::Defer> deferredGetPDREvent;
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600460};
461
Sampa Misraaea5dde2020-08-31 08:33:47 -0500462/** @brief Function to check if a sensor falls in OEM range
463 * A sensor is considered to be oem if either of entity
464 * type or state set or both falls in oem range
465 *
466 * @param[in] handler - the interface object
467 * @param[in] sensorId - sensor id
468 * @param[in] sensorRearmCount - sensor rearm count
469 * @param[out] compSensorCnt - composite sensor count
470 * @param[out] entityType - entity type
471 * @param[out] entityInstance - entity instance number
472 * @param[out] stateSetId - state set id
473 *
474 * @return true if the sensor is OEM. All out parameters are invalid
475 * for a non OEM sensor
476 */
477bool isOemStateSensor(Handler& handler, uint16_t sensorId,
478 uint8_t sensorRearmCount, uint8_t& compSensorCnt,
479 uint16_t& entityType, uint16_t& entityInstance,
480 uint16_t& stateSetId);
481
482/** @brief Function to check if an effecter falls in OEM range
483 * An effecter is considered to be oem if either of entity
484 * type or state set or both falls in oem range
485 *
486 * @param[in] handler - the interface object
487 * @param[in] effecterId - effecter id
488 * @param[in] compEffecterCnt - composite effecter count
489 * @param[out] entityType - entity type
490 * @param[out] entityInstance - entity instance number
491 * @param[out] stateSetId - state set id
492 *
493 * @return true if the effecter is OEM. All out parameters are invalid
494 * for a non OEM effecter
495 */
496bool isOemStateEffecter(Handler& handler, uint16_t effecterId,
497 uint8_t compEffecterCnt, uint16_t& entityType,
498 uint16_t& entityInstance, uint16_t& stateSetId);
499
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600500} // namespace platform
Deepak Kodihalli557dfb02019-05-12 13:11:17 +0530501} // namespace responder
502} // namespace pldm