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