1 #include "dbus_to_event_handler.hpp" 2 3 #include "libpldmresponder/pdr.hpp" 4 5 #include <phosphor-logging/lg2.hpp> 6 7 PHOSPHOR_LOG2_USING; 8 9 namespace pldm 10 { 11 using namespace pldm::responder; 12 using namespace pldm::responder::pdr; 13 using namespace pldm::responder::pdr_utils; 14 using namespace pldm::utils; 15 using namespace sdbusplus::bus::match::rules; 16 17 namespace state_sensor 18 { 19 const std::vector<uint8_t> pdrTypes{PLDM_STATE_SENSOR_PDR}; 20 21 DbusToPLDMEvent::DbusToPLDMEvent( 22 int mctp_fd, uint8_t mctp_eid, pldm::InstanceIdDb& instanceIdDb, 23 pldm::requester::Handler<pldm::requester::Request>* handler) : 24 mctp_fd(mctp_fd), 25 mctp_eid(mctp_eid), instanceIdDb(instanceIdDb), handler(handler) 26 {} 27 28 void DbusToPLDMEvent::sendEventMsg(uint8_t eventType, 29 const std::vector<uint8_t>& eventDataVec) 30 { 31 auto instanceId = instanceIdDb.next(mctp_eid); 32 std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) + 33 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES + 34 eventDataVec.size()); 35 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 36 37 auto rc = encode_platform_event_message_req( 38 instanceId, 1 /*formatVersion*/, TERMINUS_ID /*tId*/, eventType, 39 eventDataVec.data(), eventDataVec.size(), request, 40 eventDataVec.size() + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES); 41 if (rc != PLDM_SUCCESS) 42 { 43 instanceIdDb.free(mctp_eid, instanceId); 44 error("Failed to encode_platform_event_message_req, rc = {RC}", "RC", 45 rc); 46 return; 47 } 48 49 auto platformEventMessageResponseHandler = 50 [](mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) { 51 if (response == nullptr || !respMsgLen) 52 { 53 error("Failed to receive response for platform event message"); 54 return; 55 } 56 uint8_t completionCode{}; 57 uint8_t status{}; 58 auto rc = decode_platform_event_message_resp(response, respMsgLen, 59 &completionCode, &status); 60 if (rc || completionCode) 61 { 62 error( 63 "Failed to decode_platform_event_message_resp: rc = {RC}, cc = {CC}", 64 "RC", rc, "CC", static_cast<unsigned>(completionCode)); 65 } 66 }; 67 68 rc = handler->registerRequest( 69 mctp_eid, instanceId, PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE, 70 std::move(requestMsg), std::move(platformEventMessageResponseHandler)); 71 if (rc) 72 { 73 error("Failed to send the platform event message"); 74 } 75 } 76 77 void DbusToPLDMEvent::sendStateSensorEvent(SensorId sensorId, 78 const DbusObjMaps& dbusMaps) 79 { 80 // Encode PLDM platform event msg to indicate a state sensor change. 81 // DSP0248_1.2.0 Table 19 82 if (!dbusMaps.contains(sensorId)) 83 { 84 // this is not an error condition, if we end up here 85 // that means that the sensor with the sensor id has 86 // custom behaviour(or probably an oem sensor) in 87 // sending events that cannot be captured via standard 88 // dbus-json infastructure 89 return; 90 } 91 92 size_t sensorEventSize = PLDM_SENSOR_EVENT_DATA_MIN_LENGTH + 1; 93 const auto& [dbusMappings, dbusValMaps] = dbusMaps.at(sensorId); 94 for (uint8_t offset = 0; offset < dbusMappings.size(); ++offset) 95 { 96 std::vector<uint8_t> sensorEventDataVec{}; 97 sensorEventDataVec.resize(sensorEventSize); 98 auto eventData = reinterpret_cast<struct pldm_sensor_event_data*>( 99 sensorEventDataVec.data()); 100 eventData->sensor_id = sensorId; 101 eventData->sensor_event_class_type = PLDM_STATE_SENSOR_STATE; 102 eventData->event_class[0] = offset; 103 eventData->event_class[1] = PLDM_SENSOR_UNKNOWN; 104 eventData->event_class[2] = PLDM_SENSOR_UNKNOWN; 105 106 const auto& dbusMapping = dbusMappings[offset]; 107 const auto& dbusValueMapping = dbusValMaps[offset]; 108 auto stateSensorMatch = std::make_unique<sdbusplus::bus::match_t>( 109 pldm::utils::DBusHandler::getBus(), 110 propertiesChanged(dbusMapping.objectPath.c_str(), 111 dbusMapping.interface.c_str()), 112 [this, sensorEventDataVec, dbusValueMapping, 113 dbusMapping](auto& msg) mutable { 114 DbusChangedProps props{}; 115 std::string intf; 116 msg.read(intf, props); 117 if (!props.contains(dbusMapping.propertyName)) 118 { 119 return; 120 } 121 for (const auto& itr : dbusValueMapping) 122 { 123 bool findValue = false; 124 if (dbusMapping.propertyType == "string") 125 { 126 std::string src = std::get<std::string>(itr.second); 127 std::string dst = std::get<std::string>( 128 props.at(dbusMapping.propertyName)); 129 130 auto values = pldm::utils::split(src, "||", " "); 131 for (auto& value : values) 132 { 133 if (value == dst) 134 { 135 findValue = true; 136 break; 137 } 138 } 139 } 140 else 141 { 142 findValue = itr.second == props.at(dbusMapping.propertyName) 143 ? true 144 : false; 145 } 146 147 if (findValue) 148 { 149 auto eventData = 150 reinterpret_cast<struct pldm_sensor_event_data*>( 151 sensorEventDataVec.data()); 152 eventData->event_class[1] = itr.first; 153 eventData->event_class[2] = itr.first; 154 this->sendEventMsg(PLDM_SENSOR_EVENT, sensorEventDataVec); 155 break; 156 } 157 } 158 }); 159 stateSensorMatchs.emplace_back(std::move(stateSensorMatch)); 160 } 161 } 162 163 void DbusToPLDMEvent::listenSensorEvent(const pdr_utils::Repo& repo, 164 const DbusObjMaps& dbusMaps) 165 { 166 const std::map<Type, sensorEvent> sensorHandlers = { 167 {PLDM_STATE_SENSOR_PDR, 168 [this](SensorId sensorId, const DbusObjMaps& dbusMaps) { 169 this->sendStateSensorEvent(sensorId, dbusMaps); 170 }}}; 171 172 pldm_state_sensor_pdr* pdr = nullptr; 173 std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> sensorPdrRepo( 174 pldm_pdr_init(), pldm_pdr_destroy); 175 if (!sensorPdrRepo) 176 { 177 throw std::runtime_error("Unable to instantiate sensor PDR repository"); 178 } 179 180 for (auto pdrType : pdrTypes) 181 { 182 Repo sensorPDRs(sensorPdrRepo.get()); 183 getRepoByType(repo, sensorPDRs, pdrType); 184 if (sensorPDRs.empty()) 185 { 186 return; 187 } 188 189 PdrEntry pdrEntry{}; 190 auto pdrRecord = sensorPDRs.getFirstRecord(pdrEntry); 191 while (pdrRecord) 192 { 193 pdr = reinterpret_cast<pldm_state_sensor_pdr*>(pdrEntry.data); 194 SensorId sensorId = LE16TOH(pdr->sensor_id); 195 if (sensorHandlers.contains(pdrType)) 196 { 197 sensorHandlers.at(pdrType)(sensorId, dbusMaps); 198 } 199 200 pdrRecord = sensorPDRs.getNextRecord(pdrRecord, pdrEntry); 201 } 202 } 203 } 204 205 } // namespace state_sensor 206 } // namespace pldm 207