1 #include "oem_ibm_handler.hpp" 2 3 #include "file_io_type_lid.hpp" 4 #include "libpldmresponder/file_io.hpp" 5 #include "libpldmresponder/pdr_utils.hpp" 6 7 #include <libpldm/entity.h> 8 #include <libpldm/entity_oem_ibm.h> 9 #include <libpldm/pldm.h> 10 11 #include <phosphor-logging/lg2.hpp> 12 13 PHOSPHOR_LOG2_USING; 14 15 using namespace pldm::pdr; 16 using namespace pldm::utils; 17 18 namespace pldm 19 { 20 namespace responder 21 { 22 namespace oem_ibm_platform 23 { 24 int pldm::responder::oem_ibm_platform::Handler:: 25 getOemStateSensorReadingsHandler( 26 EntityType entityType, EntityInstance entityInstance, 27 StateSetId stateSetId, CompositeCount compSensorCnt, 28 std::vector<get_sensor_state_field>& stateField) 29 { 30 int rc = PLDM_SUCCESS; 31 stateField.clear(); 32 33 for (size_t i = 0; i < compSensorCnt; i++) 34 { 35 uint8_t sensorOpState{}; 36 if (entityType == PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE && 37 stateSetId == PLDM_OEM_IBM_BOOT_STATE) 38 { 39 sensorOpState = fetchBootSide(entityInstance, codeUpdate); 40 } 41 else 42 { 43 rc = PLDM_PLATFORM_INVALID_STATE_VALUE; 44 break; 45 } 46 stateField.push_back({PLDM_SENSOR_ENABLED, PLDM_SENSOR_UNKNOWN, 47 PLDM_SENSOR_UNKNOWN, sensorOpState}); 48 } 49 return rc; 50 } 51 52 int pldm::responder::oem_ibm_platform::Handler:: 53 oemSetStateEffecterStatesHandler( 54 uint16_t entityType, uint16_t entityInstance, uint16_t stateSetId, 55 uint8_t compEffecterCnt, 56 std::vector<set_effecter_state_field>& stateField, 57 uint16_t /*effecterId*/) 58 { 59 int rc = PLDM_SUCCESS; 60 61 for (uint8_t currState = 0; currState < compEffecterCnt; ++currState) 62 { 63 if (stateField[currState].set_request == PLDM_REQUEST_SET) 64 { 65 if (entityType == PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE && 66 stateSetId == PLDM_OEM_IBM_BOOT_STATE) 67 { 68 rc = setBootSide(entityInstance, currState, stateField, 69 codeUpdate); 70 } 71 else if (entityType == PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE && 72 stateSetId == PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE) 73 { 74 if (stateField[currState].effecter_state == 75 uint8_t(CodeUpdateState::START)) 76 { 77 codeUpdate->setCodeUpdateProgress(true); 78 startUpdateEvent = 79 std::make_unique<sdeventplus::source::Defer>( 80 event, 81 std::bind(std::mem_fn(&oem_ibm_platform::Handler:: 82 _processStartUpdate), 83 this, std::placeholders::_1)); 84 } 85 else if (stateField[currState].effecter_state == 86 uint8_t(CodeUpdateState::END)) 87 { 88 rc = PLDM_SUCCESS; 89 assembleImageEvent = std::make_unique< 90 sdeventplus::source::Defer>( 91 event, 92 std::bind( 93 std::mem_fn( 94 &oem_ibm_platform::Handler::_processEndUpdate), 95 this, std::placeholders::_1)); 96 97 // sendCodeUpdateEvent(effecterId, END, START); 98 } 99 else if (stateField[currState].effecter_state == 100 uint8_t(CodeUpdateState::ABORT)) 101 { 102 codeUpdate->setCodeUpdateProgress(false); 103 codeUpdate->clearDirPath(LID_STAGING_DIR); 104 auto sensorId = codeUpdate->getFirmwareUpdateSensor(); 105 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0, 106 uint8_t(CodeUpdateState::ABORT), 107 uint8_t(CodeUpdateState::START)); 108 // sendCodeUpdateEvent(effecterId, ABORT, END); 109 } 110 else if (stateField[currState].effecter_state == 111 uint8_t(CodeUpdateState::ACCEPT)) 112 { 113 auto sensorId = codeUpdate->getFirmwareUpdateSensor(); 114 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0, 115 uint8_t(CodeUpdateState::ACCEPT), 116 uint8_t(CodeUpdateState::END)); 117 // TODO Set new Dbus property provided by code update app 118 // sendCodeUpdateEvent(effecterId, ACCEPT, END); 119 } 120 else if (stateField[currState].effecter_state == 121 uint8_t(CodeUpdateState::REJECT)) 122 { 123 auto sensorId = codeUpdate->getFirmwareUpdateSensor(); 124 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0, 125 uint8_t(CodeUpdateState::REJECT), 126 uint8_t(CodeUpdateState::END)); 127 // TODO Set new Dbus property provided by code update app 128 // sendCodeUpdateEvent(effecterId, REJECT, END); 129 } 130 } 131 else if (entityType == PLDM_ENTITY_SYSTEM_CHASSIS && 132 stateSetId == PLDM_OEM_IBM_SYSTEM_POWER_STATE) 133 { 134 if (stateField[currState].effecter_state == POWER_CYCLE_HARD) 135 { 136 systemRebootEvent = 137 std::make_unique<sdeventplus::source::Defer>( 138 event, 139 std::bind(std::mem_fn(&oem_ibm_platform::Handler:: 140 _processSystemReboot), 141 this, std::placeholders::_1)); 142 } 143 } 144 else 145 { 146 rc = PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE; 147 } 148 } 149 if (rc != PLDM_SUCCESS) 150 { 151 break; 152 } 153 } 154 return rc; 155 } 156 157 void buildAllCodeUpdateEffecterPDR(oem_ibm_platform::Handler* platformHandler, 158 uint16_t entityType, uint16_t entityInstance, 159 uint16_t stateSetID, pdr_utils::Repo& repo) 160 { 161 size_t pdrSize = 0; 162 pdrSize = sizeof(pldm_state_effecter_pdr) + 163 sizeof(state_effecter_possible_states); 164 std::vector<uint8_t> entry{}; 165 entry.resize(pdrSize); 166 pldm_state_effecter_pdr* pdr = 167 reinterpret_cast<pldm_state_effecter_pdr*>(entry.data()); 168 if (!pdr) 169 { 170 error("Failed to get record by PDR type, ERROR:{ERR_CODE}", "ERR_CODE", 171 lg2::hex, 172 static_cast<unsigned>(PLDM_PLATFORM_INVALID_EFFECTER_ID)); 173 return; 174 } 175 pdr->hdr.record_handle = 0; 176 pdr->hdr.version = 1; 177 pdr->hdr.type = PLDM_STATE_EFFECTER_PDR; 178 pdr->hdr.record_change_num = 0; 179 pdr->hdr.length = sizeof(pldm_state_effecter_pdr) - sizeof(pldm_pdr_hdr); 180 pdr->terminus_handle = TERMINUS_HANDLE; 181 pdr->effecter_id = platformHandler->getNextEffecterId(); 182 pdr->entity_type = entityType; 183 pdr->entity_instance = entityInstance; 184 pdr->container_id = 1; 185 pdr->effecter_semantic_id = 0; 186 pdr->effecter_init = PLDM_NO_INIT; 187 pdr->has_description_pdr = false; 188 pdr->composite_effecter_count = 1; 189 190 auto* possibleStatesPtr = pdr->possible_states; 191 auto possibleStates = 192 reinterpret_cast<state_effecter_possible_states*>(possibleStatesPtr); 193 possibleStates->state_set_id = stateSetID; 194 possibleStates->possible_states_size = 2; 195 auto state = 196 reinterpret_cast<state_effecter_possible_states*>(possibleStates); 197 if (stateSetID == PLDM_OEM_IBM_BOOT_STATE) 198 state->states[0].byte = 6; 199 else if (stateSetID == PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE) 200 state->states[0].byte = 126; 201 else if (stateSetID == PLDM_OEM_IBM_SYSTEM_POWER_STATE) 202 state->states[0].byte = 2; 203 pldm::responder::pdr_utils::PdrEntry pdrEntry{}; 204 pdrEntry.data = entry.data(); 205 pdrEntry.size = pdrSize; 206 repo.addRecord(pdrEntry); 207 } 208 209 void buildAllCodeUpdateSensorPDR(oem_ibm_platform::Handler* platformHandler, 210 uint16_t entityType, uint16_t entityInstance, 211 uint16_t stateSetID, pdr_utils::Repo& repo) 212 { 213 size_t pdrSize = 0; 214 pdrSize = sizeof(pldm_state_sensor_pdr) + 215 sizeof(state_sensor_possible_states); 216 std::vector<uint8_t> entry{}; 217 entry.resize(pdrSize); 218 pldm_state_sensor_pdr* pdr = 219 reinterpret_cast<pldm_state_sensor_pdr*>(entry.data()); 220 if (!pdr) 221 { 222 error("Failed to get record by PDR type, ERROR:{ERR_CODE}", "ERR_CODE", 223 lg2::hex, static_cast<unsigned>(PLDM_PLATFORM_INVALID_SENSOR_ID)); 224 return; 225 } 226 pdr->hdr.record_handle = 0; 227 pdr->hdr.version = 1; 228 pdr->hdr.type = PLDM_STATE_SENSOR_PDR; 229 pdr->hdr.record_change_num = 0; 230 pdr->hdr.length = sizeof(pldm_state_sensor_pdr) - sizeof(pldm_pdr_hdr); 231 pdr->terminus_handle = TERMINUS_HANDLE; 232 pdr->sensor_id = platformHandler->getNextSensorId(); 233 pdr->entity_type = entityType; 234 pdr->entity_instance = entityInstance; 235 pdr->container_id = 1; 236 pdr->sensor_init = PLDM_NO_INIT; 237 pdr->sensor_auxiliary_names_pdr = false; 238 pdr->composite_sensor_count = 1; 239 240 auto* possibleStatesPtr = pdr->possible_states; 241 auto possibleStates = 242 reinterpret_cast<state_sensor_possible_states*>(possibleStatesPtr); 243 possibleStates->state_set_id = stateSetID; 244 possibleStates->possible_states_size = 2; 245 auto state = 246 reinterpret_cast<state_sensor_possible_states*>(possibleStates); 247 if ((stateSetID == PLDM_OEM_IBM_BOOT_STATE) || 248 (stateSetID == PLDM_OEM_IBM_VERIFICATION_STATE)) 249 state->states[0].byte = 6; 250 else if (stateSetID == PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE) 251 state->states[0].byte = 126; 252 pldm::responder::pdr_utils::PdrEntry pdrEntry{}; 253 pdrEntry.data = entry.data(); 254 pdrEntry.size = pdrSize; 255 repo.addRecord(pdrEntry); 256 } 257 258 void pldm::responder::oem_ibm_platform::Handler::buildOEMPDR( 259 pdr_utils::Repo& repo) 260 { 261 buildAllCodeUpdateEffecterPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 262 ENTITY_INSTANCE_0, PLDM_OEM_IBM_BOOT_STATE, 263 repo); 264 buildAllCodeUpdateEffecterPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 265 ENTITY_INSTANCE_1, PLDM_OEM_IBM_BOOT_STATE, 266 repo); 267 buildAllCodeUpdateEffecterPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 268 ENTITY_INSTANCE_0, 269 PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE, repo); 270 buildAllCodeUpdateEffecterPDR(this, PLDM_ENTITY_SYSTEM_CHASSIS, 271 ENTITY_INSTANCE_1, 272 PLDM_OEM_IBM_SYSTEM_POWER_STATE, repo); 273 274 buildAllCodeUpdateSensorPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 275 ENTITY_INSTANCE_0, PLDM_OEM_IBM_BOOT_STATE, 276 repo); 277 buildAllCodeUpdateSensorPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 278 ENTITY_INSTANCE_1, PLDM_OEM_IBM_BOOT_STATE, 279 repo); 280 buildAllCodeUpdateSensorPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 281 ENTITY_INSTANCE_0, 282 PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE, repo); 283 buildAllCodeUpdateSensorPDR(this, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 284 ENTITY_INSTANCE_0, 285 PLDM_OEM_IBM_VERIFICATION_STATE, repo); 286 auto sensorId = findStateSensorId( 287 repo.getPdr(), 0, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 288 ENTITY_INSTANCE_0, 1, PLDM_OEM_IBM_VERIFICATION_STATE); 289 codeUpdate->setMarkerLidSensor(sensorId); 290 sensorId = findStateSensorId( 291 repo.getPdr(), 0, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE, 292 ENTITY_INSTANCE_0, 1, PLDM_OEM_IBM_FIRMWARE_UPDATE_STATE); 293 codeUpdate->setFirmwareUpdateSensor(sensorId); 294 } 295 296 void pldm::responder::oem_ibm_platform::Handler::setPlatformHandler( 297 pldm::responder::platform::Handler* handler) 298 { 299 platformHandler = handler; 300 } 301 302 int pldm::responder::oem_ibm_platform::Handler::sendEventToHost( 303 std::vector<uint8_t>& requestMsg, uint8_t instanceId) 304 { 305 if (requestMsg.size()) 306 { 307 std::ostringstream tempStream; 308 for (int byte : requestMsg) 309 { 310 tempStream << std::setfill('0') << std::setw(2) << std::hex << byte 311 << " "; 312 } 313 std::cout << tempStream.str() << std::endl; 314 } 315 auto oemPlatformEventMessageResponseHandler = 316 [](mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) { 317 uint8_t completionCode{}; 318 uint8_t status{}; 319 auto rc = decode_platform_event_message_resp(response, respMsgLen, 320 &completionCode, &status); 321 if (rc || completionCode) 322 { 323 error( 324 "Failed to decode_platform_event_message_resp: for code update event rc={RC}, cc={CC}", 325 "RC", rc, "CC", static_cast<unsigned>(completionCode)); 326 } 327 }; 328 auto rc = handler->registerRequest( 329 mctp_eid, instanceId, PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE, 330 std::move(requestMsg), 331 std::move(oemPlatformEventMessageResponseHandler)); 332 if (rc) 333 { 334 error("Failed to send BIOS attribute change event message "); 335 } 336 337 return rc; 338 } 339 340 int encodeEventMsg(uint8_t eventType, const std::vector<uint8_t>& eventDataVec, 341 std::vector<uint8_t>& requestMsg, uint8_t instanceId) 342 { 343 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 344 345 auto rc = encode_platform_event_message_req( 346 instanceId, 1 /*formatVersion*/, TERMINUS_ID /*tId*/, eventType, 347 eventDataVec.data(), eventDataVec.size(), request, 348 eventDataVec.size() + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES); 349 350 return rc; 351 } 352 353 void pldm::responder::oem_ibm_platform::Handler::sendStateSensorEvent( 354 uint16_t sensorId, enum sensor_event_class_states sensorEventClass, 355 uint8_t sensorOffset, uint8_t eventState, uint8_t prevEventState) 356 { 357 std::vector<uint8_t> sensorEventDataVec{}; 358 size_t sensorEventSize = PLDM_SENSOR_EVENT_DATA_MIN_LENGTH + 1; 359 sensorEventDataVec.resize(sensorEventSize); 360 auto eventData = reinterpret_cast<struct pldm_sensor_event_data*>( 361 sensorEventDataVec.data()); 362 eventData->sensor_id = sensorId; 363 eventData->sensor_event_class_type = sensorEventClass; 364 auto eventClassStart = eventData->event_class; 365 auto eventClass = 366 reinterpret_cast<struct pldm_sensor_event_state_sensor_state*>( 367 eventClassStart); 368 eventClass->sensor_offset = sensorOffset; 369 eventClass->event_state = eventState; 370 eventClass->previous_event_state = prevEventState; 371 auto instanceId = instanceIdDb.next(mctp_eid); 372 std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) + 373 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES + 374 sensorEventDataVec.size()); 375 auto rc = encodeEventMsg(PLDM_SENSOR_EVENT, sensorEventDataVec, requestMsg, 376 instanceId); 377 if (rc != PLDM_SUCCESS) 378 { 379 error("Failed to encode state sensor event, rc = {RC}", "RC", rc); 380 instanceIdDb.free(mctp_eid, instanceId); 381 return; 382 } 383 rc = sendEventToHost(requestMsg, instanceId); 384 if (rc != PLDM_SUCCESS) 385 { 386 error("Failed to send event to host: rc={RC}", "RC", rc); 387 } 388 return; 389 } 390 391 void pldm::responder::oem_ibm_platform::Handler::_processEndUpdate( 392 sdeventplus::source::EventBase& /*source */) 393 { 394 assembleImageEvent.reset(); 395 int retc = codeUpdate->assembleCodeUpdateImage(); 396 if (retc != PLDM_SUCCESS) 397 { 398 codeUpdate->setCodeUpdateProgress(false); 399 auto sensorId = codeUpdate->getFirmwareUpdateSensor(); 400 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0, 401 uint8_t(CodeUpdateState::FAIL), 402 uint8_t(CodeUpdateState::START)); 403 } 404 } 405 406 void pldm::responder::oem_ibm_platform::Handler::_processStartUpdate( 407 sdeventplus::source::EventBase& /*source */) 408 { 409 codeUpdate->deleteImage(); 410 CodeUpdateState state = CodeUpdateState::START; 411 auto rc = codeUpdate->setRequestedApplyTime(); 412 if (rc != PLDM_SUCCESS) 413 { 414 error("setRequestedApplyTime failed"); 415 state = CodeUpdateState::FAIL; 416 } 417 auto sensorId = codeUpdate->getFirmwareUpdateSensor(); 418 sendStateSensorEvent(sensorId, PLDM_STATE_SENSOR_STATE, 0, uint8_t(state), 419 uint8_t(CodeUpdateState::END)); 420 } 421 422 void pldm::responder::oem_ibm_platform::Handler::_processSystemReboot( 423 sdeventplus::source::EventBase& /*source */) 424 { 425 pldm::utils::PropertyValue value = 426 "xyz.openbmc_project.State.Chassis.Transition.Off"; 427 pldm::utils::DBusMapping dbusMapping{"/xyz/openbmc_project/state/chassis0", 428 "xyz.openbmc_project.State.Chassis", 429 "RequestedPowerTransition", "string"}; 430 try 431 { 432 dBusIntf->setDbusProperty(dbusMapping, value); 433 } 434 catch (const std::exception& e) 435 { 436 error( 437 "Chassis State transition to Off failed, unable to set property RequestedPowerTransition ERROR={ERR_EXCEP}", 438 "ERR_EXCEP", e.what()); 439 } 440 441 using namespace sdbusplus::bus::match::rules; 442 chassisOffMatch = std::make_unique<sdbusplus::bus::match_t>( 443 pldm::utils::DBusHandler::getBus(), 444 propertiesChanged("/xyz/openbmc_project/state/chassis0", 445 "xyz.openbmc_project.State.Chassis"), 446 [this](sdbusplus::message_t& msg) { 447 DbusChangedProps props{}; 448 std::string intf; 449 msg.read(intf, props); 450 const auto itr = props.find("CurrentPowerState"); 451 if (itr != props.end()) 452 { 453 PropertyValue value = itr->second; 454 auto propVal = std::get<std::string>(value); 455 if (propVal == "xyz.openbmc_project.State.Chassis.PowerState.Off") 456 { 457 pldm::utils::DBusMapping dbusMapping{ 458 "/xyz/openbmc_project/control/host0/" 459 "power_restore_policy/one_time", 460 "xyz.openbmc_project.Control.Power.RestorePolicy", 461 "PowerRestorePolicy", "string"}; 462 value = "xyz.openbmc_project.Control.Power.RestorePolicy." 463 "Policy.AlwaysOn"; 464 try 465 { 466 dBusIntf->setDbusProperty(dbusMapping, value); 467 } 468 catch (const std::exception& e) 469 { 470 error( 471 "Setting one-time restore policy failed, unable to set property PowerRestorePolicy ERROR={ERR_EXCEP}", 472 "ERR_EXCEP", e.what()); 473 } 474 dbusMapping = pldm::utils::DBusMapping{ 475 "/xyz/openbmc_project/state/bmc0", 476 "xyz.openbmc_project.State.BMC", "RequestedBMCTransition", 477 "string"}; 478 value = "xyz.openbmc_project.State.BMC.Transition.Reboot"; 479 try 480 { 481 dBusIntf->setDbusProperty(dbusMapping, value); 482 } 483 catch (const std::exception& e) 484 { 485 error( 486 "BMC state transition to reboot failed, unable to set property RequestedBMCTransition ERROR={ERR_EXCEP}", 487 "ERR_EXCEP", e.what()); 488 } 489 } 490 } 491 }); 492 } 493 494 void pldm::responder::oem_ibm_platform::Handler::checkAndDisableWatchDog() 495 { 496 if (!hostOff && setEventReceiverCnt == SET_EVENT_RECEIVER_SENT) 497 { 498 disableWatchDogTimer(); 499 } 500 501 return; 502 } 503 504 bool pldm::responder::oem_ibm_platform::Handler::watchDogRunning() 505 { 506 static constexpr auto watchDogObjectPath = 507 "/xyz/openbmc_project/watchdog/host0"; 508 static constexpr auto watchDogEnablePropName = "Enabled"; 509 static constexpr auto watchDogInterface = 510 "xyz.openbmc_project.State.Watchdog"; 511 bool isWatchDogRunning = false; 512 try 513 { 514 isWatchDogRunning = pldm::utils::DBusHandler().getDbusProperty<bool>( 515 watchDogObjectPath, watchDogEnablePropName, watchDogInterface); 516 } 517 catch (const std::exception& e) 518 { 519 return false; 520 } 521 return isWatchDogRunning; 522 } 523 524 void pldm::responder::oem_ibm_platform::Handler::resetWatchDogTimer() 525 { 526 static constexpr auto watchDogService = "xyz.openbmc_project.Watchdog"; 527 static constexpr auto watchDogObjectPath = 528 "/xyz/openbmc_project/watchdog/host0"; 529 static constexpr auto watchDogInterface = 530 "xyz.openbmc_project.State.Watchdog"; 531 static constexpr auto watchDogResetPropName = "ResetTimeRemaining"; 532 533 bool wdStatus = watchDogRunning(); 534 if (wdStatus == false) 535 { 536 return; 537 } 538 try 539 { 540 auto& bus = pldm::utils::DBusHandler::getBus(); 541 auto resetMethod = 542 bus.new_method_call(watchDogService, watchDogObjectPath, 543 watchDogInterface, watchDogResetPropName); 544 resetMethod.append(true); 545 bus.call_noreply(resetMethod); 546 } 547 catch (const std::exception& e) 548 { 549 error("Failed To reset watchdog timer ERROR={ERR_EXCEP}", "ERR_EXCEP", 550 e.what()); 551 return; 552 } 553 } 554 555 void pldm::responder::oem_ibm_platform::Handler::disableWatchDogTimer() 556 { 557 setEventReceiverCnt = 0; 558 pldm::utils::DBusMapping dbusMapping{"/xyz/openbmc_project/watchdog/host0", 559 "xyz.openbmc_project.State.Watchdog", 560 "Enabled", "bool"}; 561 bool wdStatus = watchDogRunning(); 562 563 if (!wdStatus) 564 { 565 return; 566 } 567 try 568 { 569 pldm::utils::DBusHandler().setDbusProperty(dbusMapping, false); 570 } 571 catch (const std::exception& e) 572 { 573 error("Failed To disable watchdog timer ERROR={ERR_EXCEP}", "ERR_EXCEP", 574 e.what()); 575 } 576 } 577 int pldm::responder::oem_ibm_platform::Handler::checkBMCState() 578 { 579 try 580 { 581 pldm::utils::PropertyValue propertyValue = 582 pldm::utils::DBusHandler().getDbusPropertyVariant( 583 "/xyz/openbmc_project/state/bmc0", "CurrentBMCState", 584 "xyz.openbmc_project.State.BMC"); 585 586 if (std::get<std::string>(propertyValue) == 587 "xyz.openbmc_project.State.BMC.BMCState.NotReady") 588 { 589 error("GetPDR : PLDM stack is not ready for PDR exchange"); 590 return PLDM_ERROR_NOT_READY; 591 } 592 } 593 catch (const std::exception& e) 594 { 595 error("Error getting the current BMC state"); 596 return PLDM_ERROR; 597 } 598 return PLDM_SUCCESS; 599 } 600 601 } // namespace oem_ibm_platform 602 } // namespace responder 603 } // namespace pldm 604