| #include "dbus_to_terminus_effecters.hpp" |
| |
| #include <libpldm/pdr.h> |
| #include <libpldm/platform.h> |
| |
| #include <phosphor-logging/lg2.hpp> |
| #include <xyz/openbmc_project/Common/error.hpp> |
| #include <xyz/openbmc_project/State/Boot/Progress/client.hpp> |
| #include <xyz/openbmc_project/State/OperatingSystem/Status/server.hpp> |
| |
| #include <fstream> |
| |
| PHOSPHOR_LOG2_USING; |
| |
| using namespace pldm::utils; |
| |
| namespace pldm |
| { |
| namespace host_effecters |
| { |
| using InternalFailure = |
| sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure; |
| |
| constexpr auto hostEffecterJson = "dbus_to_terminus_effecter.json"; |
| |
| void HostEffecterParser::populatePropVals( |
| const Json& dBusValues, std::vector<PropertyValue>& propertyValues, |
| const std::string& propertyType) |
| |
| { |
| for (const auto& elem : dBusValues) |
| { |
| auto value = jsonEntryToDbusVal(propertyType, elem); |
| propertyValues.emplace_back(value); |
| } |
| } |
| |
| void HostEffecterParser::parseEffecterJson(const std::string& jsonPath) |
| { |
| fs::path jsonDir(jsonPath); |
| if (!fs::exists(jsonDir) || fs::is_empty(jsonDir)) |
| { |
| error("Effecter json file for remote terminus '{PATH}' does not exist.", |
| "PATH", jsonPath); |
| return; |
| } |
| |
| fs::path jsonFilePath = jsonDir / hostEffecterJson; |
| if (!fs::exists(jsonFilePath)) |
| { |
| error("Json at path '{PATH}' does not exist.", "PATH", jsonFilePath); |
| throw InternalFailure(); |
| } |
| |
| std::ifstream jsonFile(jsonFilePath); |
| auto data = Json::parse(jsonFile, nullptr, false); |
| if (data.is_discarded()) |
| { |
| error("Failed to parse json file {PATH}", "PATH", jsonFilePath); |
| throw InternalFailure(); |
| } |
| const Json empty{}; |
| const std::vector<Json> emptyList{}; |
| |
| auto entries = data.value("entries", emptyList); |
| for (const auto& entry : entries) |
| { |
| EffecterInfo effecterInfo; |
| effecterInfo.mctpEid = entry.value("mctp_eid", 0xFF); |
| auto jsonEffecterInfo = entry.value("effecter_info", empty); |
| auto effecterId = |
| jsonEffecterInfo.value("effecterID", PLDM_INVALID_EFFECTER_ID); |
| /* default as PLDM_STATE_EFFECTER_PDR */ |
| auto effecterPdrType = |
| jsonEffecterInfo.value("effecterPdrType", PLDM_STATE_EFFECTER_PDR); |
| if (effecterPdrType != PLDM_STATE_EFFECTER_PDR && |
| effecterPdrType != PLDM_NUMERIC_EFFECTER_PDR) |
| { |
| error( |
| "Effecter PDRType not supported {TYPE} of effecterID '{EFFECTERID}'", |
| "TYPE", effecterPdrType, "EFFECTERID", effecterId); |
| continue; |
| } |
| effecterInfo.effecterPdrType = effecterPdrType; |
| effecterInfo.containerId = jsonEffecterInfo.value("containerID", 0); |
| effecterInfo.entityType = jsonEffecterInfo.value("entityType", 0); |
| effecterInfo.entityInstance = |
| jsonEffecterInfo.value("entityInstance", 0); |
| effecterInfo.compEffecterCnt = |
| jsonEffecterInfo.value("compositeEffecterCount", 0); |
| effecterInfo.checkHostState = |
| jsonEffecterInfo.value("checkHostState", true); |
| auto effecters = entry.value("effecters", emptyList); |
| |
| if (effecterPdrType == PLDM_NUMERIC_EFFECTER_PDR) |
| { |
| for (const auto& effecter : effecters) |
| { |
| DBusNumericEffecterMapping dbusInfo{}; |
| auto jsonDbusInfo = effecter.value("dbus_info", empty); |
| dbusInfo.dataSize = effecter.value("effecterDataSize", 0); |
| dbusInfo.unitModifier = effecter.value("unitModifier", 0); |
| dbusInfo.resolution = effecter.value("resolution", 1); |
| dbusInfo.offset = effecter.value("offset", 0); |
| dbusInfo.dbusMap.objectPath = |
| jsonDbusInfo.value("object_path", ""); |
| dbusInfo.dbusMap.interface = |
| jsonDbusInfo.value("interface", ""); |
| dbusInfo.dbusMap.propertyName = |
| jsonDbusInfo.value("property_name", ""); |
| dbusInfo.dbusMap.propertyType = |
| jsonDbusInfo.value("property_type", ""); |
| /** |
| * Only support these property type for Numeric Effecter D-Bus |
| * property: |
| * "uint8_t", "int16_t", "uint16_t", "int32_t", "uint32_t", |
| * "int64_t", "uint64_t", "double" |
| */ |
| if (!dbusValueNumericTypeNames.contains( |
| dbusInfo.dbusMap.propertyType)) |
| { |
| lg2::error( |
| "Invalid PropertyType {TYPE} of object path {PATH} property name {NAME}", |
| "TYPE", dbusInfo.dbusMap.propertyType, "PATH", |
| dbusInfo.dbusMap.objectPath, "NAME", |
| dbusInfo.dbusMap.propertyName); |
| continue; |
| } |
| |
| dbusInfo.propertyValue = |
| std::numeric_limits<double>::quiet_NaN(); |
| auto effecterInfoIndex = hostEffecterInfo.size(); |
| auto dbusInfoIndex = effecterInfo.dbusInfo.size(); |
| createHostEffecterMatch( |
| dbusInfo.dbusMap.objectPath, dbusInfo.dbusMap.interface, |
| effecterInfoIndex, dbusInfoIndex, effecterId); |
| effecterInfo.dbusNumericEffecterInfo.emplace_back( |
| std::move(dbusInfo)); |
| } |
| hostEffecterInfo.emplace_back(std::move(effecterInfo)); |
| continue; |
| } |
| |
| for (const auto& effecter : effecters) |
| { |
| DBusEffecterMapping dbusInfo{}; |
| auto jsonDbusInfo = effecter.value("dbus_info", empty); |
| dbusInfo.dbusMap.objectPath = jsonDbusInfo.value("object_path", ""); |
| dbusInfo.dbusMap.interface = jsonDbusInfo.value("interface", ""); |
| dbusInfo.dbusMap.propertyName = |
| jsonDbusInfo.value("property_name", ""); |
| dbusInfo.dbusMap.propertyType = |
| jsonDbusInfo.value("property_type", ""); |
| Json propertyValues = jsonDbusInfo["property_values"]; |
| |
| populatePropVals(propertyValues, dbusInfo.propertyValues, |
| dbusInfo.dbusMap.propertyType); |
| |
| const std::vector<uint8_t> emptyStates{}; |
| auto state = effecter.value("state", empty); |
| dbusInfo.state.stateSetId = state.value("id", 0); |
| auto states = state.value("state_values", emptyStates); |
| if (dbusInfo.propertyValues.size() != states.size()) |
| { |
| error( |
| "Number of states do not match with number of D-Bus property values in the json. Object path at '{PATH}' and property '{PROPERTY}' will not be monitored", |
| "PATH", dbusInfo.dbusMap.objectPath, "PROPERTY", |
| dbusInfo.dbusMap.propertyName); |
| continue; |
| } |
| for (const auto& s : states) |
| { |
| dbusInfo.state.states.emplace_back(s); |
| } |
| |
| auto effecterInfoIndex = hostEffecterInfo.size(); |
| auto dbusInfoIndex = effecterInfo.dbusInfo.size(); |
| createHostEffecterMatch( |
| dbusInfo.dbusMap.objectPath, dbusInfo.dbusMap.interface, |
| effecterInfoIndex, dbusInfoIndex, effecterId); |
| effecterInfo.dbusInfo.emplace_back(std::move(dbusInfo)); |
| } |
| hostEffecterInfo.emplace_back(std::move(effecterInfo)); |
| } |
| } |
| |
| bool HostEffecterParser::isHostOn(void) |
| { |
| using BootProgress = |
| sdbusplus::client::xyz::openbmc_project::state::boot::Progress<>; |
| constexpr auto hostStatePath = "/xyz/openbmc_project/state/host0"; |
| try |
| { |
| auto propVal = dbusHandler->getDbusPropertyVariant( |
| hostStatePath, "BootProgress", BootProgress::interface); |
| |
| using Stages = BootProgress::ProgressStages; |
| auto currHostState = sdbusplus::message::convert_from_string<Stages>( |
| std::get<std::string>(propVal)) |
| .value(); |
| |
| if (currHostState != Stages::SystemInitComplete && |
| currHostState != Stages::OSRunning && |
| currHostState != Stages::SystemSetup && |
| currHostState != Stages::OEM) |
| { |
| info( |
| "Remote terminus is not up/active, current remote terminus state is: '{CURRENT_HOST_STATE}'", |
| "CURRENT_HOST_STATE", currHostState); |
| return false; |
| } |
| } |
| catch (const sdbusplus::exception_t& e) |
| { |
| error( |
| "Error in getting current remote terminus state. Will still continue to set the remote terminus effecter, error - {ERROR}", |
| "ERROR", e); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void HostEffecterParser::processHostEffecterChangeNotification( |
| const DbusChgHostEffecterProps& chProperties, size_t effecterInfoIndex, |
| size_t dbusInfoIndex, uint16_t effecterId) |
| { |
| const auto& pdrType = hostEffecterInfo[effecterInfoIndex].effecterPdrType; |
| if (pdrType == PLDM_NUMERIC_EFFECTER_PDR) |
| { |
| processTerminusNumericEffecterChangeNotification( |
| chProperties, effecterInfoIndex, dbusInfoIndex, effecterId); |
| return; |
| } |
| const auto& propertyName = hostEffecterInfo[effecterInfoIndex] |
| .dbusInfo[dbusInfoIndex] |
| .dbusMap.propertyName; |
| |
| const auto& it = chProperties.find(propertyName); |
| |
| if (it == chProperties.end()) |
| { |
| return; |
| } |
| |
| if (effecterId == PLDM_INVALID_EFFECTER_ID) |
| { |
| constexpr auto localOrRemote = false; |
| effecterId = findStateEffecterId( |
| pdrRepo, hostEffecterInfo[effecterInfoIndex].entityType, |
| hostEffecterInfo[effecterInfoIndex].entityInstance, |
| hostEffecterInfo[effecterInfoIndex].containerId, |
| hostEffecterInfo[effecterInfoIndex] |
| .dbusInfo[dbusInfoIndex] |
| .state.stateSetId, |
| localOrRemote); |
| if (effecterId == PLDM_INVALID_EFFECTER_ID) |
| { |
| error( |
| "Effecter ID '{EFFECTERID}' of entity type '{TYPE}', entityInstance '{INSTANCE}' and containerID '{CONTAINER_ID}' not found in pdr repo", |
| "EFFECTERID", effecterId, "TYPE", |
| hostEffecterInfo[effecterInfoIndex].entityType, "INSTANCE", |
| hostEffecterInfo[effecterInfoIndex].entityInstance, |
| "CONTAINER_ID", |
| hostEffecterInfo[effecterInfoIndex].containerId); |
| return; |
| } |
| } |
| |
| if (!isHostOn()) |
| { |
| return; |
| } |
| |
| uint8_t newState{}; |
| try |
| { |
| newState = |
| findNewStateValue(effecterInfoIndex, dbusInfoIndex, it->second); |
| } |
| catch (const std::out_of_range& e) |
| { |
| error("Failed to find new state '{NEW_STATE}' in json, error - {ERROR}", |
| "ERROR", e, "NEW_STATE", newState); |
| return; |
| } |
| |
| std::vector<set_effecter_state_field> stateField; |
| for (uint8_t i = 0; i < hostEffecterInfo[effecterInfoIndex].compEffecterCnt; |
| i++) |
| { |
| if (i == dbusInfoIndex) |
| { |
| stateField.push_back({PLDM_REQUEST_SET, newState}); |
| } |
| else |
| { |
| stateField.push_back({PLDM_NO_CHANGE, 0}); |
| } |
| } |
| int rc{}; |
| try |
| { |
| rc = setHostStateEffecter(effecterInfoIndex, stateField, effecterId); |
| } |
| catch (const std::runtime_error& e) |
| { |
| error( |
| "Failed to set remote terminus state effecter for effecter ID '{EFFECTERID}', error - {ERROR}", |
| "ERROR", e, "EFFECTERID", effecterId); |
| return; |
| } |
| if (rc != PLDM_SUCCESS) |
| { |
| error( |
| "Failed to set the remote terminus state effecter for effecter ID '{EFFECTERID}', response code '{RC}'", |
| "EFFECTERID", effecterId, "RC", rc); |
| } |
| } |
| |
| double HostEffecterParser::adjustValue(double value, double offset, |
| double resolution, int8_t modify) |
| { |
| double unitModifier = std::pow(10, signed(modify)); |
| return std::round((value - offset) * resolution / unitModifier); |
| } |
| |
| void HostEffecterParser::processTerminusNumericEffecterChangeNotification( |
| const DbusChgHostEffecterProps& chProperties, size_t effecterInfoIndex, |
| size_t dbusInfoIndex, uint16_t effecterId) |
| { |
| const auto& checkHost = hostEffecterInfo[effecterInfoIndex].checkHostState; |
| const auto& propValues = hostEffecterInfo[effecterInfoIndex] |
| .dbusNumericEffecterInfo[dbusInfoIndex]; |
| const auto& propertyName = propValues.dbusMap.propertyName; |
| const auto& propertyType = propValues.dbusMap.propertyType; |
| |
| if (effecterId == PLDM_INVALID_EFFECTER_ID) |
| { |
| lg2::error( |
| "Dbus to PLDM Numeric Effecter setting requires valid effecter ID. Invalid effecter ID {EFFECTER_ID}", |
| "EFFECTER_ID", effecterId); |
| } |
| |
| if (!dbusValueNumericTypeNames.contains(propertyType)) |
| { |
| lg2::error( |
| "DBus Value to PLDM Numeric Effecter setting only supports D-Bus Numeric data type. Invalid type {TYPE}", |
| "TYPE", propertyType); |
| return; |
| } |
| |
| const auto& it = chProperties.find(propertyName); |
| |
| if (it == chProperties.end()) |
| { |
| return; |
| } |
| |
| double val = std::numeric_limits<double>::quiet_NaN(); |
| if (!pldm::utils::dbusPropValuesToDouble(propertyType, it->second, &val)) |
| { |
| lg2::error( |
| "DBus Value to PLDM Numeric Effecter setting only supports Numeric D-Bus data type. Invalid type {TYPE}", |
| "TYPE", propertyType); |
| return; |
| } |
| |
| /* Update the current value of D-Bus interface*/ |
| if (!std::isnan(val) && std::isnan(propValues.propertyValue)) |
| { |
| hostEffecterInfo[effecterInfoIndex] |
| .dbusNumericEffecterInfo[dbusInfoIndex] |
| .propertyValue = val; |
| return; |
| } |
| |
| /* Bypass the setting when the current value is NA or settting value is NA*/ |
| if (std::isnan(propValues.propertyValue) || std::isnan(val)) |
| { |
| return; |
| } |
| |
| /* Setting value equals the D-Bus value which is real value of effecter */ |
| if (val == propValues.propertyValue) |
| { |
| return; |
| } |
| |
| double rawValue = adjustValue(val, propValues.offset, propValues.resolution, |
| propValues.unitModifier); |
| |
| if (checkHost && !isHostOn()) |
| { |
| return; |
| } |
| |
| try |
| { |
| auto rc = setTerminusNumericEffecter(effecterInfoIndex, effecterId, |
| propValues.dataSize, rawValue); |
| if (rc) |
| { |
| error( |
| "Could not set the numeric effecter ID '{EFFECTERID}' return code '{RC}'", |
| "EFFECTERID", effecterId, "RC", rc); |
| return; |
| } |
| } |
| catch (const std::runtime_error& e) |
| { |
| error("Could not set numeric effecter ID= '{EFFECTERID}'", "EFFECTERID", |
| effecterId); |
| return; |
| } |
| |
| hostEffecterInfo[effecterInfoIndex] |
| .dbusNumericEffecterInfo[dbusInfoIndex] |
| .propertyValue = val; |
| |
| return; |
| } |
| |
| uint8_t HostEffecterParser::findNewStateValue( |
| size_t effecterInfoIndex, size_t dbusInfoIndex, |
| const PropertyValue& propertyValue) |
| { |
| const auto& propValues = hostEffecterInfo[effecterInfoIndex] |
| .dbusInfo[dbusInfoIndex] |
| .propertyValues; |
| auto it = std::find(propValues.begin(), propValues.end(), propertyValue); |
| uint8_t newState{}; |
| if (it != propValues.end()) |
| { |
| auto index = std::distance(propValues.begin(), it); |
| newState = hostEffecterInfo[effecterInfoIndex] |
| .dbusInfo[dbusInfoIndex] |
| .state.states[index]; |
| } |
| else |
| { |
| throw std::out_of_range("new state not found in json"); |
| } |
| return newState; |
| } |
| |
| size_t getEffecterDataSize(uint8_t effecterDataSize) |
| { |
| switch (effecterDataSize) |
| { |
| case PLDM_EFFECTER_DATA_SIZE_UINT8: |
| return sizeof(uint8_t); |
| case PLDM_EFFECTER_DATA_SIZE_SINT8: |
| return sizeof(int8_t); |
| case PLDM_EFFECTER_DATA_SIZE_UINT16: |
| return sizeof(uint16_t); |
| case PLDM_EFFECTER_DATA_SIZE_SINT16: |
| return sizeof(int16_t); |
| case PLDM_EFFECTER_DATA_SIZE_UINT32: |
| return sizeof(uint32_t); |
| case PLDM_EFFECTER_DATA_SIZE_SINT32: |
| return sizeof(int32_t); |
| default: |
| return 0; |
| } |
| } |
| |
| int HostEffecterParser::setTerminusNumericEffecter( |
| size_t effecterInfoIndex, uint16_t effecterId, uint8_t dataSize, |
| double rawValue) |
| { |
| uint8_t& mctpEid = hostEffecterInfo[effecterInfoIndex].mctpEid; |
| auto instanceId = instanceIdDb->next(mctpEid); |
| int rc = PLDM_ERROR; |
| std::vector<uint8_t> requestMsg; |
| |
| /** |
| * PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES = 4. It includes the 1 byte |
| * value for effecterValue as `Table 48 - SetNumericEffecterValue command |
| * format` DSP0248 V1.3.0 So the payload_length of `SetNumericEffecterValue` |
| * request message will be payload_length = |
| * PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES - 1 + sizeof(dataType) |
| */ |
| size_t payload_length = PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES - 1 + |
| getEffecterDataSize(dataSize); |
| requestMsg.resize(sizeof(pldm_msg_hdr) + payload_length); |
| auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); |
| switch (dataSize) |
| { |
| case PLDM_EFFECTER_DATA_SIZE_UINT8: |
| { |
| auto value_uint8 = (uint8_t)rawValue; |
| rc = encode_set_numeric_effecter_value_req( |
| instanceId, effecterId, dataSize, |
| reinterpret_cast<uint8_t*>(&value_uint8), request, |
| payload_length); |
| break; |
| } |
| case PLDM_EFFECTER_DATA_SIZE_SINT8: |
| { |
| auto value_int8 = (int8_t)rawValue; |
| rc = encode_set_numeric_effecter_value_req( |
| instanceId, effecterId, dataSize, |
| reinterpret_cast<uint8_t*>(&value_int8), request, |
| payload_length); |
| break; |
| } |
| case PLDM_EFFECTER_DATA_SIZE_UINT16: |
| { |
| auto value_uint16 = (uint16_t)rawValue; |
| rc = encode_set_numeric_effecter_value_req( |
| instanceId, effecterId, dataSize, |
| reinterpret_cast<uint8_t*>(&value_uint16), request, |
| payload_length); |
| break; |
| } |
| case PLDM_EFFECTER_DATA_SIZE_SINT16: |
| { |
| auto value_int16 = (int16_t)rawValue; |
| rc = encode_set_numeric_effecter_value_req( |
| instanceId, effecterId, dataSize, |
| reinterpret_cast<uint8_t*>(&value_int16), request, |
| payload_length); |
| break; |
| } |
| case PLDM_EFFECTER_DATA_SIZE_UINT32: |
| { |
| auto value_uint32 = (uint32_t)rawValue; |
| rc = encode_set_numeric_effecter_value_req( |
| instanceId, effecterId, dataSize, |
| reinterpret_cast<uint8_t*>(&value_uint32), request, |
| payload_length); |
| break; |
| } |
| case PLDM_EFFECTER_DATA_SIZE_SINT32: |
| { |
| auto value_int32 = (int32_t)rawValue; |
| rc = encode_set_numeric_effecter_value_req( |
| instanceId, effecterId, dataSize, |
| reinterpret_cast<uint8_t*>(&value_int32), request, |
| payload_length); |
| break; |
| } |
| default: |
| break; |
| } |
| |
| if (rc) |
| { |
| error( |
| "Failed to encode set numeric effecter request message for effecter ID '{EFFECTERID}' and instanceID '{INSTANCE}' with error code '{RC}'", |
| "EFFECTERID", effecterId, "INSTANCE", instanceId, "RC", lg2::hex, |
| rc); |
| |
| instanceIdDb->free(mctpEid, instanceId); |
| return rc; |
| } |
| |
| auto setNumericEffecterRespHandler = [effecterId](mctp_eid_t /*eid*/, |
| const pldm_msg* response, |
| size_t respMsgLen) { |
| if (response == nullptr || !respMsgLen) |
| { |
| error( |
| "Failed to receive response for setNumericEffecterValue command"); |
| return; |
| } |
| uint8_t completionCode{}; |
| auto rc = decode_set_numeric_effecter_value_resp(response, respMsgLen, |
| &completionCode); |
| |
| if (rc) |
| { |
| error( |
| "Failed to decode set numeric effecter response message for effecter ID '{EFFECTERID}' with error code '{RC}'", |
| "EFFECTERID", effecterId, "RC", lg2::hex, rc); |
| } |
| if (completionCode) |
| { |
| error( |
| "Failed to set numeric effecter for effecter ID '{EFFECTERID}' with complete code '{CC}'", |
| "EFFECTERID", effecterId, "CC", lg2::hex, completionCode); |
| } |
| }; |
| |
| rc = handler->registerRequest( |
| mctpEid, instanceId, PLDM_PLATFORM, PLDM_SET_NUMERIC_EFFECTER_VALUE, |
| std::move(requestMsg), std::move(setNumericEffecterRespHandler)); |
| if (rc) |
| { |
| error("Failed to send request to set an effecter on Host"); |
| } |
| return rc; |
| } |
| |
| int HostEffecterParser::setHostStateEffecter( |
| size_t effecterInfoIndex, std::vector<set_effecter_state_field>& stateField, |
| uint16_t effecterId) |
| { |
| uint8_t& mctpEid = hostEffecterInfo[effecterInfoIndex].mctpEid; |
| uint8_t& compEffCnt = hostEffecterInfo[effecterInfoIndex].compEffecterCnt; |
| auto instanceId = instanceIdDb->next(mctpEid); |
| |
| std::vector<uint8_t> requestMsg( |
| sizeof(pldm_msg_hdr) + sizeof(effecterId) + sizeof(compEffCnt) + |
| sizeof(set_effecter_state_field) * compEffCnt, |
| 0); |
| auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); |
| auto rc = encode_set_state_effecter_states_req( |
| instanceId, effecterId, compEffCnt, stateField.data(), request); |
| |
| if (rc != PLDM_SUCCESS) |
| { |
| error( |
| "Failed to encode set state effecter states message for effecter ID '{EFFECTERID}' and instanceID '{INSTANCE}' with response code '{RC}'", |
| "EFFECTERID", effecterId, "INSTANCE", instanceId, "RC", lg2::hex, |
| rc); |
| instanceIdDb->free(mctpEid, instanceId); |
| return rc; |
| } |
| |
| auto setStateEffecterStatesRespHandler = [](mctp_eid_t /*eid*/, |
| const pldm_msg* response, |
| size_t respMsgLen) { |
| if (response == nullptr || !respMsgLen) |
| { |
| error( |
| "Failed to receive response for setting state effecter states."); |
| return; |
| } |
| uint8_t completionCode{}; |
| auto rc = decode_set_state_effecter_states_resp(response, respMsgLen, |
| &completionCode); |
| if (rc) |
| { |
| error( |
| "Failed to decode response of set state effecter states, response code '{RC}'", |
| "RC", rc); |
| pldm::utils::reportError( |
| "xyz.openbmc_project.bmc.pldm.SetHostEffecterFailed"); |
| } |
| if (completionCode) |
| { |
| error( |
| "Failed to set a remote terminus effecter, completion code '{CC}'", |
| "CC", completionCode); |
| pldm::utils::reportError( |
| "xyz.openbmc_project.bmc.pldm.SetHostEffecterFailed"); |
| } |
| }; |
| |
| rc = handler->registerRequest( |
| mctpEid, instanceId, PLDM_PLATFORM, PLDM_SET_STATE_EFFECTER_STATES, |
| std::move(requestMsg), std::move(setStateEffecterStatesRespHandler)); |
| if (rc) |
| { |
| error( |
| "Failed to send request to set an effecter on remote terminus for effecter ID '{EFFECTERID}', response code '{RC}'", |
| "EFFECTERID", effecterId, "RC", rc); |
| } |
| return rc; |
| } |
| |
| void HostEffecterParser::createHostEffecterMatch( |
| const std::string& objectPath, const std::string& interface, |
| size_t effecterInfoIndex, size_t dbusInfoIndex, uint16_t effecterId) |
| { |
| using namespace sdbusplus::bus::match::rules; |
| effecterInfoMatch.emplace_back(std::make_unique<sdbusplus::bus::match_t>( |
| pldm::utils::DBusHandler::getBus(), |
| propertiesChanged(objectPath, interface), |
| [this, effecterInfoIndex, dbusInfoIndex, |
| effecterId](sdbusplus::message_t& msg) { |
| DbusChgHostEffecterProps props; |
| std::string iface; |
| msg.read(iface, props); |
| processHostEffecterChangeNotification(props, effecterInfoIndex, |
| dbusInfoIndex, effecterId); |
| })); |
| } |
| |
| } // namespace host_effecters |
| } // namespace pldm |