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 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>& 55 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 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 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 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 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 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 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 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 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 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 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 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 830 void Handler::_processPostGetPDRActions(sdeventplus::source::EventBase& 831 /*source */) 832 { 833 deferredGetPDREvent.reset(); 834 dbusToPLDMEventHandler->listenSensorEvent(pdrRepo, sensorDbusObjMaps); 835 } 836 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 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 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