1 #include "platform.hpp"
2
3 #include "common/types.hpp"
4 #include "common/utils.hpp"
5 #include "event_parser.hpp"
6 #include "pdr.hpp"
7 #include "pdr_numeric_effecter.hpp"
8 #include "pdr_state_effecter.hpp"
9 #include "pdr_state_sensor.hpp"
10 #include "pdr_utils.hpp"
11 #include "platform_numeric_effecter.hpp"
12 #include "platform_state_effecter.hpp"
13 #include "platform_state_sensor.hpp"
14 #include "pldmd/handler.hpp"
15 #include "requester/handler.hpp"
16
17 #include <libpldm/entity.h>
18 #include <libpldm/state_set.h>
19
20 #include <phosphor-logging/lg2.hpp>
21
22 PHOSPHOR_LOG2_USING;
23
24 using namespace pldm::utils;
25 using namespace pldm::responder::pdr;
26 using namespace pldm::responder::pdr_utils;
27
28 namespace pldm
29 {
30 namespace responder
31 {
32 namespace platform
33 {
34 using InternalFailure =
35 sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
36
37 static const Json empty{};
38
addDbusObjMaps(uint16_t id,std::tuple<pdr_utils::DbusMappings,pdr_utils::DbusValMaps> dbusObj,TypeId typeId)39 void Handler::addDbusObjMaps(
40 uint16_t id,
41 std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps> dbusObj,
42 TypeId typeId)
43 {
44 if (typeId == TypeId::PLDM_SENSOR_ID)
45 {
46 sensorDbusObjMaps.emplace(id, dbusObj);
47 }
48 else
49 {
50 effecterDbusObjMaps.emplace(id, dbusObj);
51 }
52 }
53
54 const std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps>&
getDbusObjMaps(uint16_t id,TypeId typeId) const55 Handler::getDbusObjMaps(uint16_t id, TypeId typeId) const
56 {
57 if (typeId == TypeId::PLDM_SENSOR_ID)
58 {
59 return sensorDbusObjMaps.at(id);
60 }
61 else
62 {
63 return effecterDbusObjMaps.at(id);
64 }
65 }
66
generate(const pldm::utils::DBusHandler & dBusIntf,const std::vector<fs::path> & dir,Repo & repo)67 void Handler::generate(const pldm::utils::DBusHandler& dBusIntf,
68 const std::vector<fs::path>& dir, Repo& repo)
69 {
70 for (const auto& directory : dir)
71 {
72 info("Checking if directory '{DIRECTORY}' exists", "DIRECTORY",
73 directory);
74 if (!fs::exists(directory))
75 {
76 return;
77 }
78 }
79
80 // A map of PDR type to a lambda that handles creation of that PDR type.
81 // The lambda essentially would parse the platform specific PDR JSONs to
82 // generate the PDR structures. This function iterates through the map to
83 // invoke all lambdas, so that all PDR types can be created.
84
85 const std::map<Type, generatePDR> generateHandlers = {
86 {PLDM_STATE_EFFECTER_PDR,
87 [this](const DBusHandler& dBusIntf, const auto& json,
88 RepoInterface& repo) {
89 pdr_state_effecter::generateStateEffecterPDR<
90 pldm::utils::DBusHandler, Handler>(dBusIntf, json, *this,
91 repo);
92 }},
93 {PLDM_NUMERIC_EFFECTER_PDR,
94 [this](const DBusHandler& dBusIntf, const auto& json,
95 RepoInterface& repo) {
96 pdr_numeric_effecter::generateNumericEffecterPDR<
97 pldm::utils::DBusHandler, Handler>(dBusIntf, json, *this,
98 repo);
99 }},
100 {PLDM_STATE_SENSOR_PDR, [this](const DBusHandler& dBusIntf,
101 const auto& json, RepoInterface& repo) {
102 pdr_state_sensor::generateStateSensorPDR<pldm::utils::DBusHandler,
103 Handler>(dBusIntf, json,
104 *this, repo);
105 }}};
106
107 Type pdrType{};
108 for (const auto& directory : dir)
109 {
110 for (const auto& dirEntry : fs::directory_iterator(directory))
111 {
112 try
113 {
114 if (fs::is_regular_file(dirEntry.path().string()))
115 {
116 auto json = readJson(dirEntry.path().string());
117 if (!json.empty())
118 {
119 auto effecterPDRs = json.value("effecterPDRs", empty);
120 for (const auto& effecter : effecterPDRs)
121 {
122 pdrType = effecter.value("pdrType", 0);
123 generateHandlers.at(
124 pdrType)(dBusIntf, effecter, repo);
125 }
126
127 auto sensorPDRs = json.value("sensorPDRs", empty);
128 for (const auto& sensor : sensorPDRs)
129 {
130 pdrType = sensor.value("pdrType", 0);
131 generateHandlers.at(
132 pdrType)(dBusIntf, sensor, repo);
133 }
134 }
135 }
136 }
137 catch (const InternalFailure& e)
138 {
139 error(
140 "PDR config directory '{PATH}' does not exist or empty for '{TYPE}' pdr, error - {ERROR}",
141 "PATH", dirEntry.path(), "TYPE", pdrType, "ERROR", e);
142 }
143 catch (const Json::exception& e)
144 {
145 error(
146 "Failed to parse PDR JSON file for '{TYPE}' pdr, error - {ERROR}",
147 "TYPE", pdrType, "ERROR", e);
148 pldm::utils::reportError(
149 "xyz.openbmc_project.PLDM.Error.Generate.PDRJsonFileParseFail");
150 }
151 catch (const std::exception& e)
152 {
153 error(
154 "Failed to parse PDR JSON file for '{TYPE}' pdr, error - {ERROR}",
155 "TYPE", pdrType, "ERROR", e);
156 pldm::utils::reportError(
157 "xyz.openbmc_project.PLDM.Error.Generate.PDRJsonFileParseFail");
158 }
159 }
160 }
161 }
162
getPDR(const pldm_msg * request,size_t payloadLength)163 Response Handler::getPDR(const pldm_msg* request, size_t payloadLength)
164 {
165 if (oemPlatformHandler)
166 {
167 auto rc = oemPlatformHandler->checkBMCState();
168 if (rc != PLDM_SUCCESS)
169 {
170 return ccOnlyResponse(request, PLDM_ERROR_NOT_READY);
171 }
172 }
173
174 // Build FRU table if not built, since entity association PDR's
175 // are built when the FRU table is constructed.
176 if (fruHandler)
177 {
178 fruHandler->buildFRUTable();
179 }
180
181 if (!pdrCreated)
182 {
183 generateTerminusLocatorPDR(pdrRepo);
184 if (platformConfigHandler)
185 {
186 auto systemType = platformConfigHandler->getPlatformName();
187 if (systemType.has_value())
188 {
189 // In case of normal poweron , the system type would have been
190 // already filled by entity manager when ever BMC reaches Ready
191 // state. If this is not filled by time we get a getpdr request
192 // we can assume that the entity manager service is not present
193 // on this system & continue to build the common PDR's.
194 pdrJsonsDir.push_back(pdrJsonDir / systemType.value());
195 }
196 }
197
198 if (oemPlatformHandler != nullptr)
199 {
200 oemPlatformHandler->buildOEMPDR(pdrRepo);
201 }
202 generate(*dBusIntf, pdrJsonsDir, pdrRepo);
203
204 pdrCreated = true;
205
206 if (dbusToPLDMEventHandler)
207 {
208 deferredGetPDREvent = std::make_unique<sdeventplus::source::Defer>(
209 event,
210 std::bind(std::mem_fn(&pldm::responder::platform::Handler::
211 _processPostGetPDRActions),
212 this, std::placeholders::_1));
213 }
214 }
215
216 Response response(sizeof(pldm_msg_hdr) + PLDM_GET_PDR_MIN_RESP_BYTES, 0);
217
218 if (payloadLength != PLDM_GET_PDR_REQ_BYTES)
219 {
220 return CmdHandler::ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
221 }
222
223 uint32_t recordHandle{};
224 uint32_t dataTransferHandle{};
225 uint8_t transferOpFlag{};
226 uint16_t reqSizeBytes{};
227 uint16_t recordChangeNum{};
228
229 auto rc = decode_get_pdr_req(request, payloadLength, &recordHandle,
230 &dataTransferHandle, &transferOpFlag,
231 &reqSizeBytes, &recordChangeNum);
232 if (rc != PLDM_SUCCESS)
233 {
234 return CmdHandler::ccOnlyResponse(request, rc);
235 }
236
237 uint16_t respSizeBytes{};
238 uint8_t* recordData = nullptr;
239 try
240 {
241 pdr_utils::PdrEntry e;
242 auto record = pdr::getRecordByHandle(pdrRepo, recordHandle, e);
243 if (record == nullptr)
244 {
245 return CmdHandler::ccOnlyResponse(
246 request, PLDM_PLATFORM_INVALID_RECORD_HANDLE);
247 }
248
249 if (reqSizeBytes)
250 {
251 respSizeBytes = e.size;
252 if (respSizeBytes > reqSizeBytes)
253 {
254 respSizeBytes = reqSizeBytes;
255 }
256 recordData = e.data;
257 }
258 response.resize(sizeof(pldm_msg_hdr) + PLDM_GET_PDR_MIN_RESP_BYTES +
259 respSizeBytes,
260 0);
261 auto responsePtr = new (response.data()) pldm_msg;
262 rc = encode_get_pdr_resp(
263 request->hdr.instance_id, PLDM_SUCCESS, e.handle.nextRecordHandle,
264 0, PLDM_START_AND_END, respSizeBytes, recordData, 0, responsePtr);
265 if (rc != PLDM_SUCCESS)
266 {
267 return ccOnlyResponse(request, rc);
268 }
269 }
270 catch (const std::exception& e)
271 {
272 error(
273 "Failed to access PDR record handle '{RECORD_HANDLE}', error - {ERROR}",
274 "RECORD_HANDLE", recordHandle, "ERROR", e);
275 return CmdHandler::ccOnlyResponse(request, PLDM_ERROR);
276 }
277 return response;
278 }
279
setStateEffecterStates(const pldm_msg * request,size_t payloadLength)280 Response Handler::setStateEffecterStates(const pldm_msg* request,
281 size_t payloadLength)
282 {
283 Response response(
284 sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES, 0);
285 auto responsePtr = new (response.data()) pldm_msg;
286 uint16_t effecterId;
287 uint8_t compEffecterCnt;
288 constexpr auto maxCompositeEffecterCnt = 8;
289 std::vector<set_effecter_state_field> stateField(maxCompositeEffecterCnt,
290 {0, 0});
291
292 if ((payloadLength > PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES) ||
293 (payloadLength < sizeof(effecterId) + sizeof(compEffecterCnt) +
294 sizeof(set_effecter_state_field)))
295 {
296 return CmdHandler::ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
297 }
298
299 int rc = decode_set_state_effecter_states_req(
300 request, payloadLength, &effecterId, &compEffecterCnt,
301 stateField.data());
302
303 if (rc != PLDM_SUCCESS)
304 {
305 return CmdHandler::ccOnlyResponse(request, rc);
306 }
307
308 stateField.resize(compEffecterCnt);
309 const pldm::utils::DBusHandler dBusIntf;
310 uint16_t entityType{};
311 uint16_t entityInstance{};
312 uint16_t stateSetId{};
313
314 if (isOemStateEffecter(*this, effecterId, compEffecterCnt, entityType,
315 entityInstance, stateSetId) &&
316 oemPlatformHandler != nullptr &&
317 !effecterDbusObjMaps.contains(effecterId))
318 {
319 rc = oemPlatformHandler->oemSetStateEffecterStatesHandler(
320 entityType, entityInstance, stateSetId, compEffecterCnt, stateField,
321 effecterId);
322 }
323 else
324 {
325 rc = platform_state_effecter::setStateEffecterStatesHandler<
326 pldm::utils::DBusHandler, Handler>(dBusIntf, *this, effecterId,
327 stateField);
328 }
329 if (rc != PLDM_SUCCESS)
330 {
331 return CmdHandler::ccOnlyResponse(request, rc);
332 }
333
334 rc = encode_set_state_effecter_states_resp(request->hdr.instance_id, rc,
335 responsePtr);
336 if (rc != PLDM_SUCCESS)
337 {
338 return ccOnlyResponse(request, rc);
339 }
340
341 return response;
342 }
343
platformEventMessage(const pldm_msg * request,size_t payloadLength)344 Response Handler::platformEventMessage(const pldm_msg* request,
345 size_t payloadLength)
346 {
347 uint8_t formatVersion{};
348 uint8_t tid{};
349 uint8_t eventClass{};
350 size_t offset{};
351
352 auto rc = decode_platform_event_message_req(
353 request, payloadLength, &formatVersion, &tid, &eventClass, &offset);
354 if (rc != PLDM_SUCCESS)
355 {
356 return CmdHandler::ccOnlyResponse(request, rc);
357 }
358
359 if (eventClass == PLDM_HEARTBEAT_TIMER_ELAPSED_EVENT)
360 {
361 rc = PLDM_SUCCESS;
362 if (oemPlatformHandler)
363 {
364 if (oemPlatformHandler->watchDogRunning())
365 {
366 oemPlatformHandler->resetWatchDogTimer();
367 }
368 else
369 {
370 oemPlatformHandler->setSurvTimer(tid, true);
371 }
372 }
373 }
374 else
375 {
376 try
377 {
378 const auto& handlers = eventHandlers.at(eventClass);
379 bool oneFailedHandler = false;
380 for (const auto& handler : handlers)
381 {
382 auto rc =
383 handler(request, payloadLength, formatVersion, tid, offset);
384 if (rc != PLDM_SUCCESS)
385 {
386 oneFailedHandler = true;
387 }
388 }
389 if (oneFailedHandler)
390 {
391 return CmdHandler::ccOnlyResponse(request, rc);
392 }
393 }
394 catch (const std::out_of_range& e)
395 {
396 error("Failed to handle platform event msg, error - {ERROR}",
397 "ERROR", e);
398 return CmdHandler::ccOnlyResponse(request, PLDM_ERROR_INVALID_DATA);
399 }
400 }
401 Response response(
402 sizeof(pldm_msg_hdr) + PLDM_PLATFORM_EVENT_MESSAGE_RESP_BYTES, 0);
403 auto responsePtr = new (response.data()) pldm_msg;
404
405 rc = encode_platform_event_message_resp(request->hdr.instance_id, rc,
406 PLDM_EVENT_NO_LOGGING, responsePtr);
407 if (rc != PLDM_SUCCESS)
408 {
409 return ccOnlyResponse(request, rc);
410 }
411
412 return response;
413 }
414
sensorEvent(const pldm_msg * request,size_t payloadLength,uint8_t,uint8_t tid,size_t eventDataOffset)415 int Handler::sensorEvent(const pldm_msg* request, size_t payloadLength,
416 uint8_t /*formatVersion*/, uint8_t tid,
417 size_t eventDataOffset)
418 {
419 uint16_t sensorId{};
420 uint8_t eventClass{};
421 size_t eventClassDataOffset{};
422 auto eventData =
423 reinterpret_cast<const uint8_t*>(request->payload) + eventDataOffset;
424 auto eventDataSize = payloadLength - eventDataOffset;
425
426 auto rc = decode_sensor_event_data(eventData, eventDataSize, &sensorId,
427 &eventClass, &eventClassDataOffset);
428 if (rc != PLDM_SUCCESS)
429 {
430 return rc;
431 }
432
433 auto eventClassData = reinterpret_cast<const uint8_t*>(request->payload) +
434 eventDataOffset + eventClassDataOffset;
435 auto eventClassDataSize =
436 payloadLength - eventDataOffset - eventClassDataOffset;
437
438 if (eventClass == PLDM_STATE_SENSOR_STATE)
439 {
440 uint8_t sensorOffset{};
441 uint8_t eventState{};
442 uint8_t previousEventState{};
443
444 rc = decode_state_sensor_data(eventClassData, eventClassDataSize,
445 &sensorOffset, &eventState,
446 &previousEventState);
447 if (rc != PLDM_SUCCESS)
448 {
449 return PLDM_ERROR;
450 }
451
452 // Emitting state sensor event signal
453 emitStateSensorEventSignal(tid, sensorId, sensorOffset, eventState,
454 previousEventState);
455
456 // If there are no HOST PDR's, there is no further action
457 if (hostPDRHandler == nullptr)
458 {
459 return PLDM_SUCCESS;
460 }
461
462 // Handle PLDM events for which PDR is available
463 SensorEntry sensorEntry{tid, sensorId};
464
465 pldm::pdr::EntityInfo entityInfo{};
466 pldm::pdr::CompositeSensorStates compositeSensorStates{};
467 std::vector<pldm::pdr::StateSetId> stateSetIds{};
468
469 try
470 {
471 std::tie(entityInfo, compositeSensorStates, stateSetIds) =
472 hostPDRHandler->lookupSensorInfo(sensorEntry);
473 }
474 catch (const std::out_of_range&)
475 {
476 // If there is no mapping for tid, sensorId combination, try
477 // PLDM_TID_RESERVED, sensorId for terminus that is yet to
478 // implement TL PDR.
479 try
480 {
481 sensorEntry.terminusID = PLDM_TID_RESERVED;
482 std::tie(entityInfo, compositeSensorStates, stateSetIds) =
483 hostPDRHandler->lookupSensorInfo(sensorEntry);
484 }
485 // If there is no mapping for events return PLDM_SUCCESS
486 catch (const std::out_of_range&)
487 {
488 return PLDM_SUCCESS;
489 }
490 }
491
492 if (sensorOffset >= compositeSensorStates.size())
493 {
494 return PLDM_ERROR_INVALID_DATA;
495 }
496
497 const auto& possibleStates = compositeSensorStates[sensorOffset];
498 if (!possibleStates.contains(eventState))
499 {
500 return PLDM_ERROR_INVALID_DATA;
501 }
502
503 const auto& [containerId, entityType, entityInstance] = entityInfo;
504 events::StateSensorEntry stateSensorEntry{
505 containerId,
506 entityType,
507 entityInstance,
508 sensorOffset,
509 stateSetIds[sensorOffset],
510 false};
511 return hostPDRHandler->handleStateSensorEvent(stateSensorEntry,
512 eventState);
513 }
514 else
515 {
516 return PLDM_ERROR_INVALID_DATA;
517 }
518
519 return PLDM_SUCCESS;
520 }
521
pldmPDRRepositoryChgEvent(const pldm_msg * request,size_t payloadLength,uint8_t,uint8_t tid,size_t eventDataOffset)522 int Handler::pldmPDRRepositoryChgEvent(
523 const pldm_msg* request, size_t payloadLength, uint8_t /*formatVersion*/,
524 uint8_t tid, size_t eventDataOffset)
525 {
526 uint8_t eventDataFormat{};
527 uint8_t numberOfChangeRecords{};
528 size_t dataOffset{};
529
530 auto eventData =
531 reinterpret_cast<const uint8_t*>(request->payload) + eventDataOffset;
532 auto eventDataSize = payloadLength - eventDataOffset;
533
534 auto rc = decode_pldm_pdr_repository_chg_event_data(
535 eventData, eventDataSize, &eventDataFormat, &numberOfChangeRecords,
536 &dataOffset);
537 if (rc != PLDM_SUCCESS)
538 {
539 return rc;
540 }
541
542 PDRRecordHandles pdrRecordHandles;
543
544 if (eventDataFormat == FORMAT_IS_PDR_TYPES)
545 {
546 return PLDM_ERROR_INVALID_DATA;
547 }
548
549 if (eventDataFormat == FORMAT_IS_PDR_HANDLES)
550 {
551 uint8_t eventDataOperation{};
552 uint8_t numberOfChangeEntries{};
553
554 auto changeRecordData = eventData + dataOffset;
555 auto changeRecordDataSize = eventDataSize - dataOffset;
556
557 while (changeRecordDataSize)
558 {
559 rc = decode_pldm_pdr_repository_change_record_data(
560 changeRecordData, changeRecordDataSize, &eventDataOperation,
561 &numberOfChangeEntries, &dataOffset);
562
563 if (rc != PLDM_SUCCESS)
564 {
565 return rc;
566 }
567
568 if (eventDataOperation == PLDM_RECORDS_MODIFIED)
569 {
570 hostPDRHandler->isHostPdrModified = true;
571 }
572
573 rc = getPDRRecordHandles(
574 reinterpret_cast<const ChangeEntry*>(
575 changeRecordData + dataOffset),
576 changeRecordDataSize - dataOffset,
577 static_cast<size_t>(numberOfChangeEntries), pdrRecordHandles);
578
579 if (rc != PLDM_SUCCESS)
580 {
581 error("Invalid data, no pdr handles found");
582 return rc;
583 }
584
585 changeRecordData +=
586 dataOffset + (numberOfChangeEntries * sizeof(ChangeEntry));
587 changeRecordDataSize -=
588 dataOffset + (numberOfChangeEntries * sizeof(ChangeEntry));
589 }
590 }
591 if (hostPDRHandler)
592 {
593 // if we get a Repository change event with the eventDataFormat
594 // as REFRESH_ENTIRE_REPOSITORY, then delete all the PDR's that
595 // have the matched Terminus handle
596 if (eventDataFormat == REFRESH_ENTIRE_REPOSITORY)
597 {
598 // We cannot get the Repo change event from the Terminus
599 // that is not already added to the BMC repository
600
601 for (auto it = hostPDRHandler->tlPDRInfo.cbegin();
602 it != hostPDRHandler->tlPDRInfo.cend();)
603 {
604 if (std::get<0>(it->second) == tid)
605 {
606 pldm_pdr_remove_pdrs_by_terminus_handle(pdrRepo.getPdr(),
607 it->first);
608 hostPDRHandler->tlPDRInfo.erase(it++);
609 }
610 else
611 {
612 ++it;
613 }
614 }
615 }
616 hostPDRHandler->fetchPDR(std::move(pdrRecordHandles));
617 }
618
619 return PLDM_SUCCESS;
620 }
621
getPDRRecordHandles(const ChangeEntry * changeEntryData,size_t changeEntryDataSize,size_t numberOfChangeEntries,PDRRecordHandles & pdrRecordHandles)622 int Handler::getPDRRecordHandles(
623 const ChangeEntry* changeEntryData, size_t changeEntryDataSize,
624 size_t numberOfChangeEntries, PDRRecordHandles& pdrRecordHandles)
625 {
626 if (numberOfChangeEntries > (changeEntryDataSize / sizeof(ChangeEntry)))
627 {
628 return PLDM_ERROR_INVALID_DATA;
629 }
630 for (size_t i = 0; i < numberOfChangeEntries; i++)
631 {
632 pdrRecordHandles.push_back(changeEntryData[i]);
633 }
634 return PLDM_SUCCESS;
635 }
636
getNumericEffecterValue(const pldm_msg * request,size_t payloadLength)637 Response Handler::getNumericEffecterValue(const pldm_msg* request,
638 size_t payloadLength)
639 {
640 if (payloadLength != PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES)
641 {
642 return ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
643 }
644
645 uint16_t effecterId{};
646 auto rc = decode_get_numeric_effecter_value_req(request, payloadLength,
647 &effecterId);
648 if (rc != PLDM_SUCCESS)
649 {
650 return ccOnlyResponse(request, rc);
651 }
652
653 const pldm::utils::DBusHandler dBusIntf;
654 uint8_t effecterDataSize{};
655 pldm::utils::PropertyValue dbusValue;
656 std::string propertyType;
657 using effecterOperationalState = uint8_t;
658 using completionCode = uint8_t;
659
660 rc = platform_numeric_effecter::getNumericEffecterData<
661 pldm::utils::DBusHandler, Handler>(
662 dBusIntf, *this, effecterId, effecterDataSize, propertyType, dbusValue);
663
664 if (rc != PLDM_SUCCESS)
665 {
666 return ccOnlyResponse(request, rc);
667 }
668
669 // Refer DSP0248_1.2.0.pdf (section 22.3, Table 48)
670 // Completion Code (uint8), Effecter Data Size(uint8), Effecter Operational
671 // State(uint8), PendingValue (uint8|sint8|uint16|sint16|uint32|sint32 )
672 // PresentValue (uint8|sint8|uint16|sint16|uint32|sint32 )
673 // Size of PendingValue and PresentValue calculated based on size is
674 // provided in effecter data size
675 size_t responsePayloadLength =
676 sizeof(completionCode) + sizeof(effecterDataSize) +
677 sizeof(effecterOperationalState) +
678 getEffecterDataSize(effecterDataSize) +
679 getEffecterDataSize(effecterDataSize);
680
681 Response response(responsePayloadLength + sizeof(pldm_msg_hdr));
682 auto responsePtr = new (response.data()) pldm_msg;
683
684 rc = platform_numeric_effecter::getNumericEffecterValueHandler(
685 propertyType, dbusValue, effecterDataSize, responsePtr,
686 responsePayloadLength, request->hdr.instance_id);
687
688 if (rc != PLDM_SUCCESS)
689 {
690 error(
691 "Failed to get response of GetNumericEffecterValue for effecter ID '{EFFECTERID}', response code '{RC}'.",
692 "EFFECTERID", effecterId, "RC", rc);
693 return ccOnlyResponse(request, rc);
694 }
695 return response;
696 }
697
setNumericEffecterValue(const pldm_msg * request,size_t payloadLength)698 Response Handler::setNumericEffecterValue(const pldm_msg* request,
699 size_t payloadLength)
700 {
701 Response response(
702 sizeof(pldm_msg_hdr) + PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES);
703 uint16_t effecterId{};
704 uint8_t effecterDataSize{};
705 uint8_t effecterValue[4] = {};
706
707 if ((payloadLength > sizeof(effecterId) + sizeof(effecterDataSize) +
708 sizeof(union_effecter_data_size)) ||
709 (payloadLength < sizeof(effecterId) + sizeof(effecterDataSize) + 1))
710 {
711 return ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
712 }
713
714 int rc = decode_set_numeric_effecter_value_req(
715 request, payloadLength, &effecterId, &effecterDataSize, effecterValue);
716
717 if (rc == PLDM_SUCCESS)
718 {
719 const pldm::utils::DBusHandler dBusIntf;
720 rc = platform_numeric_effecter::setNumericEffecterValueHandler<
721 pldm::utils::DBusHandler, Handler>(
722 dBusIntf, *this, effecterId, effecterDataSize, effecterValue,
723 sizeof(effecterValue));
724 }
725
726 return ccOnlyResponse(request, rc);
727 }
728
generateTerminusLocatorPDR(Repo & repo)729 void Handler::generateTerminusLocatorPDR(Repo& repo)
730 {
731 std::vector<uint8_t> pdrBuffer(sizeof(pldm_terminus_locator_pdr));
732
733 auto pdr = new (pdrBuffer.data()) pldm_terminus_locator_pdr;
734
735 pdr->hdr.record_handle = 0;
736 pdr->hdr.version = 1;
737 pdr->hdr.type = PLDM_TERMINUS_LOCATOR_PDR;
738 pdr->hdr.record_change_num = 0;
739 pdr->hdr.length = sizeof(pldm_terminus_locator_pdr) - sizeof(pldm_pdr_hdr);
740 pdr->terminus_handle = TERMINUS_HANDLE;
741 pdr->validity = PLDM_TL_PDR_VALID;
742 pdr->tid = TERMINUS_ID;
743 pdr->container_id = 0x0;
744 pdr->terminus_locator_type = PLDM_TERMINUS_LOCATOR_TYPE_MCTP_EID;
745 pdr->terminus_locator_value_size =
746 sizeof(pldm_terminus_locator_type_mctp_eid);
747 auto locatorValue = new (pdr->terminus_locator_value)
748 pldm_terminus_locator_type_mctp_eid;
749 locatorValue->eid = pldm::BmcMctpEid;
750
751 PdrEntry pdrEntry{};
752 pdrEntry.data = pdrBuffer.data();
753 pdrEntry.size = pdrBuffer.size();
754 repo.addRecord(pdrEntry);
755 if (hostPDRHandler)
756 {
757 hostPDRHandler->tlPDRInfo.insert_or_assign(
758 pdr->terminus_handle,
759 std::make_tuple(pdr->tid, locatorValue->eid, pdr->validity));
760 }
761 }
762
getStateSensorReadings(const pldm_msg * request,size_t payloadLength)763 Response Handler::getStateSensorReadings(const pldm_msg* request,
764 size_t payloadLength)
765 {
766 uint16_t sensorId{};
767 bitfield8_t sensorRearm{};
768 uint8_t reserved{};
769
770 if (payloadLength != PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES)
771 {
772 return ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
773 }
774
775 int rc = decode_get_state_sensor_readings_req(
776 request, payloadLength, &sensorId, &sensorRearm, &reserved);
777
778 if (rc != PLDM_SUCCESS)
779 {
780 return ccOnlyResponse(request, rc);
781 }
782
783 // 0x01 to 0x08
784 uint8_t sensorRearmCount = std::popcount(sensorRearm.byte);
785 std::vector<get_sensor_state_field> stateField(sensorRearmCount);
786 uint8_t comSensorCnt{};
787 const pldm::utils::DBusHandler dBusIntf;
788
789 uint16_t entityType{};
790 uint16_t entityInstance{};
791 uint16_t stateSetId{};
792 uint16_t containerId{};
793
794 if (isOemStateSensor(*this, sensorId, sensorRearmCount, comSensorCnt,
795 entityType, entityInstance, stateSetId, containerId) &&
796 oemPlatformHandler && !sensorDbusObjMaps.contains(sensorId))
797 {
798 rc = oemPlatformHandler->getOemStateSensorReadingsHandler(
799 entityType, entityInstance, containerId, stateSetId, comSensorCnt,
800 sensorId, stateField);
801 }
802 else
803 {
804 rc = platform_state_sensor::getStateSensorReadingsHandler<
805 pldm::utils::DBusHandler, Handler>(
806 dBusIntf, *this, sensorId, sensorRearmCount, comSensorCnt,
807 stateField, dbusToPLDMEventHandler->getSensorCache());
808 }
809
810 if (rc != PLDM_SUCCESS)
811 {
812 return ccOnlyResponse(request, rc);
813 }
814
815 Response response(
816 sizeof(pldm_msg_hdr) + PLDM_GET_STATE_SENSOR_READINGS_MIN_RESP_BYTES +
817 sizeof(get_sensor_state_field) * comSensorCnt);
818 auto responsePtr = new (response.data()) pldm_msg;
819 rc = encode_get_state_sensor_readings_resp(
820 request->hdr.instance_id, rc, comSensorCnt, stateField.data(),
821 responsePtr);
822 if (rc != PLDM_SUCCESS)
823 {
824 return ccOnlyResponse(request, rc);
825 }
826
827 return response;
828 }
829
_processPostGetPDRActions(sdeventplus::source::EventBase &)830 void Handler::_processPostGetPDRActions(sdeventplus::source::EventBase&
831 /*source */)
832 {
833 deferredGetPDREvent.reset();
834 dbusToPLDMEventHandler->listenSensorEvent(pdrRepo, sensorDbusObjMaps);
835 }
836
isOemStateSensor(Handler & handler,uint16_t sensorId,uint8_t sensorRearmCount,uint8_t & compSensorCnt,uint16_t & entityType,uint16_t & entityInstance,uint16_t & stateSetId,uint16_t & containerId)837 bool isOemStateSensor(Handler& handler, uint16_t sensorId,
838 uint8_t sensorRearmCount, uint8_t& compSensorCnt,
839 uint16_t& entityType, uint16_t& entityInstance,
840 uint16_t& stateSetId, uint16_t& containerId)
841 {
842 pldm_state_sensor_pdr* pdr = nullptr;
843
844 std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> stateSensorPdrRepo(
845 pldm_pdr_init(), pldm_pdr_destroy);
846 if (!stateSensorPdrRepo)
847 {
848 error("Failed to instantiate state sensor PDR repository");
849 return false;
850 }
851 Repo stateSensorPDRs(stateSensorPdrRepo.get());
852 getRepoByType(handler.getRepo(), stateSensorPDRs, PLDM_STATE_SENSOR_PDR);
853 if (stateSensorPDRs.empty())
854 {
855 error("Failed to get record by PDR type");
856 return false;
857 }
858
859 PdrEntry pdrEntry{};
860 auto pdrRecord = stateSensorPDRs.getFirstRecord(pdrEntry);
861 while (pdrRecord)
862 {
863 pdr = new (pdrEntry.data) pldm_state_sensor_pdr;
864 assert(pdr != nullptr);
865 if (pdr->sensor_id != sensorId)
866 {
867 pdr = nullptr;
868 pdrRecord = stateSensorPDRs.getNextRecord(pdrRecord, pdrEntry);
869 continue;
870 }
871 auto tmpEntityType = pdr->entity_type;
872 auto tmpEntityInstance = pdr->entity_instance;
873 auto tmpEntityContainerId = pdr->container_id;
874 auto tmpCompSensorCnt = pdr->composite_sensor_count;
875 auto tmpPossibleStates =
876 reinterpret_cast<state_sensor_possible_states*>(
877 pdr->possible_states);
878 auto tmpStateSetId = tmpPossibleStates->state_set_id;
879
880 if (sensorRearmCount > tmpCompSensorCnt)
881 {
882 error(
883 "The requester sent wrong sensor rearm count '{SENSOR_REARM_COUNT}' for the sensor ID '{SENSORID}'.",
884 "SENSOR_REARM_COUNT", (uint16_t)sensorRearmCount, "SENSORID",
885 sensorId);
886 break;
887 }
888
889 if ((tmpEntityType >= PLDM_OEM_ENTITY_TYPE_START &&
890 tmpEntityType <= PLDM_OEM_ENTITY_TYPE_END) ||
891 (tmpStateSetId >= PLDM_OEM_STATE_SET_ID_START &&
892 tmpStateSetId < PLDM_OEM_STATE_SET_ID_END))
893 {
894 entityType = tmpEntityType;
895 entityInstance = tmpEntityInstance;
896 stateSetId = tmpStateSetId;
897 compSensorCnt = tmpCompSensorCnt;
898 containerId = tmpEntityContainerId;
899 return true;
900 }
901 else
902 {
903 return false;
904 }
905 }
906 return false;
907 }
908
isOemStateEffecter(Handler & handler,uint16_t effecterId,uint8_t compEffecterCnt,uint16_t & entityType,uint16_t & entityInstance,uint16_t & stateSetId)909 bool isOemStateEffecter(Handler& handler, uint16_t effecterId,
910 uint8_t compEffecterCnt, uint16_t& entityType,
911 uint16_t& entityInstance, uint16_t& stateSetId)
912 {
913 pldm_state_effecter_pdr* pdr = nullptr;
914
915 std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> stateEffecterPdrRepo(
916 pldm_pdr_init(), pldm_pdr_destroy);
917 if (!stateEffecterPdrRepo)
918 {
919 error("Failed to instantiate state effecter PDR repository");
920 return false;
921 }
922 Repo stateEffecterPDRs(stateEffecterPdrRepo.get());
923 getRepoByType(handler.getRepo(), stateEffecterPDRs,
924 PLDM_STATE_EFFECTER_PDR);
925 if (stateEffecterPDRs.empty())
926 {
927 error("Failed to get record by PDR type");
928 return false;
929 }
930
931 PdrEntry pdrEntry{};
932 auto pdrRecord = stateEffecterPDRs.getFirstRecord(pdrEntry);
933 while (pdrRecord)
934 {
935 pdr = new (pdrEntry.data) pldm_state_effecter_pdr;
936 assert(pdr != nullptr);
937 if (pdr->effecter_id != effecterId)
938 {
939 pdr = nullptr;
940 pdrRecord = stateEffecterPDRs.getNextRecord(pdrRecord, pdrEntry);
941 continue;
942 }
943
944 auto tmpEntityType = pdr->entity_type;
945 auto tmpEntityInstance = pdr->entity_instance;
946 auto tmpPossibleStates =
947 reinterpret_cast<state_effecter_possible_states*>(
948 pdr->possible_states);
949 auto tmpStateSetId = tmpPossibleStates->state_set_id;
950
951 if (compEffecterCnt > pdr->composite_effecter_count)
952 {
953 error(
954 "The requester sent wrong composite effecter count '{COMPOSITE_EFFECTER_COUNT}' for the effecter ID '{EFFECTERID}'.",
955 "COMPOSITE_EFFECTER_COUNT", compEffecterCnt, "EFFECTERID",
956 effecterId);
957 return false;
958 }
959
960 if ((tmpEntityType >= PLDM_OEM_ENTITY_TYPE_START &&
961 tmpEntityType <= PLDM_OEM_ENTITY_TYPE_END) ||
962 (tmpStateSetId >= PLDM_OEM_STATE_SET_ID_START &&
963 tmpStateSetId < PLDM_OEM_STATE_SET_ID_END))
964 {
965 entityType = tmpEntityType;
966 entityInstance = tmpEntityInstance;
967 stateSetId = tmpStateSetId;
968 return true;
969 }
970 else
971 {
972 return false;
973 }
974 }
975 return false;
976 }
977
setEventReceiver()978 void Handler::setEventReceiver()
979 {
980 std::vector<uint8_t> requestMsg(
981 sizeof(pldm_msg_hdr) + PLDM_SET_EVENT_RECEIVER_REQ_BYTES);
982 auto request = new (requestMsg.data()) pldm_msg;
983 auto instanceId = instanceIdDb->next(eid);
984 uint8_t eventMessageGlobalEnable =
985 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE;
986 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
987 uint8_t eventReceiverAddressInfo = pldm::BmcMctpEid;
988 uint16_t heartbeatTimer = HEARTBEAT_TIMEOUT;
989
990 auto rc = encode_set_event_receiver_req(
991 instanceId, eventMessageGlobalEnable, transportProtocolType,
992 eventReceiverAddressInfo, heartbeatTimer, request);
993 if (rc != PLDM_SUCCESS)
994 {
995 instanceIdDb->free(eid, instanceId);
996 error(
997 "Failed to encode set event receiver request, response code '{RC}'",
998 "RC", lg2::hex, rc);
999 return;
1000 }
1001
1002 auto processSetEventReceiverResponse = [](mctp_eid_t /*eid*/,
1003 const pldm_msg* response,
1004 size_t respMsgLen) {
1005 if (response == nullptr || !respMsgLen)
1006 {
1007 error("Failed to receive response for setEventReceiver command");
1008 return;
1009 }
1010
1011 uint8_t completionCode{};
1012 auto rc = decode_set_event_receiver_resp(response, respMsgLen,
1013 &completionCode);
1014 if (rc || completionCode)
1015 {
1016 error(
1017 "Failed to decode setEventReceiver command, response code '{RC}' and completion code '{CC}'",
1018 "RC", rc, "CC", completionCode);
1019 pldm::utils::reportError(
1020 "xyz.openbmc_project.bmc.pldm.InternalFailure");
1021 }
1022 };
1023 rc = handler->registerRequest(
1024 eid, instanceId, PLDM_PLATFORM, PLDM_SET_EVENT_RECEIVER,
1025 std::move(requestMsg), std::move(processSetEventReceiverResponse));
1026
1027 if (rc != PLDM_SUCCESS)
1028 {
1029 error("Failed to send the setEventReceiver request");
1030 }
1031
1032 if (oemPlatformHandler)
1033 {
1034 oemPlatformHandler->countSetEventReceiver();
1035 oemPlatformHandler->checkAndDisableWatchDog();
1036 }
1037 }
1038
1039 } // namespace platform
1040 } // namespace responder
1041 } // namespace pldm
1042