1 #pragma once 2 3 #include "common/instance_id.hpp" 4 #include "common/types.hpp" 5 #include "common/utils.hpp" 6 #include "libpldmresponder/event_parser.hpp" 7 #include "libpldmresponder/oem_handler.hpp" 8 #include "libpldmresponder/pdr_utils.hpp" 9 #include "requester/handler.hpp" 10 11 #include <libpldm/base.h> 12 #include <libpldm/platform.h> 13 14 #include <sdeventplus/event.hpp> 15 #include <sdeventplus/source/event.hpp> 16 17 #include <deque> 18 #include <filesystem> 19 #include <map> 20 #include <memory> 21 #include <vector> 22 23 namespace pldm 24 { 25 using EntityType = uint16_t; 26 // vector which would hold the PDR record handle data returned by 27 // pldmPDRRepositoryChgEvent event data 28 using ChangeEntry = uint32_t; 29 using PDRRecordHandles = std::deque<ChangeEntry>; 30 31 /** @struct SensorEntry 32 * 33 * SensorEntry is a unique key which maps a sensorEventType request in the 34 * PlatformEventMessage command to a host sensor PDR. This struct is a key 35 * in a std::map, so implemented operator==and operator<. 36 */ 37 struct SensorEntry 38 { 39 pdr::TerminusID terminusID; 40 pdr::SensorID sensorID; 41 42 bool operator==(const SensorEntry& e) const 43 { 44 return ((terminusID == e.terminusID) && (sensorID == e.sensorID)); 45 } 46 47 bool operator<(const SensorEntry& e) const 48 { 49 return ((terminusID < e.terminusID) || 50 ((terminusID == e.terminusID) && (sensorID < e.sensorID))); 51 } 52 }; 53 54 using HostStateSensorMap = std::map<SensorEntry, pdr::SensorInfo>; 55 using PDRList = std::vector<std::vector<uint8_t>>; 56 57 /** @class HostPDRHandler 58 * @brief This class can fetch and process PDRs from host firmware 59 * @details Provides an API to fetch PDRs from the host firmware. Upon 60 * receiving the PDRs, they are stored into the BMC's primary PDR repo. 61 * Adjustments are made to entity association PDRs received from the host, 62 * because they need to be assimilated into the BMC's entity association 63 * tree. A PLDM event containing the record handles of the updated entity 64 * association PDRs is sent to the host. 65 */ 66 class HostPDRHandler 67 { 68 public: 69 HostPDRHandler() = delete; 70 HostPDRHandler(const HostPDRHandler&) = delete; 71 HostPDRHandler(HostPDRHandler&&) = delete; 72 HostPDRHandler& operator=(const HostPDRHandler&) = delete; 73 HostPDRHandler& operator=(HostPDRHandler&&) = delete; 74 ~HostPDRHandler() = default; 75 76 using TerminusInfo = 77 std::tuple<pdr::TerminusID, pdr::EID, pdr::TerminusValidity>; 78 using TLPDRMap = std::map<pdr::TerminusHandle, TerminusInfo>; 79 80 /** @brief Constructor 81 * @param[in] mctp_fd - fd of MCTP communications socket 82 * @param[in] mctp_eid - MCTP EID of host firmware 83 * @param[in] event - reference of main event loop of pldmd 84 * @param[in] repo - pointer to BMC's primary PDR repo 85 * @param[in] eventsJsonDir - directory path which has the config JSONs 86 * @param[in] entityTree - Pointer to BMC and Host entity association tree 87 * @param[in] bmcEntityTree - pointer to BMC's entity association tree 88 * @param[in] instanceIdDb - reference to an InstanceIdDb object 89 * @param[in] handler - PLDM request handler 90 */ 91 explicit HostPDRHandler( 92 int mctp_fd, uint8_t mctp_eid, sdeventplus::Event& event, 93 pldm_pdr* repo, const std::string& eventsJsonsDir, 94 pldm_entity_association_tree* entityTree, 95 pldm_entity_association_tree* bmcEntityTree, 96 pldm::InstanceIdDb& instanceIdDb, 97 pldm::requester::Handler<pldm::requester::Request>* handler, 98 pldm::responder::oem_platform::Handler* oemPlatformHandler); 99 100 /** @brief fetch PDRs from host firmware. See @class. 101 * @param[in] recordHandles - list of record handles pointing to host's 102 * PDRs that need to be fetched. 103 */ 104 105 void fetchPDR(PDRRecordHandles&& recordHandles); 106 107 /** @brief Send a PLDM event to host firmware containing a list of record 108 * handles of PDRs that the host firmware has to fetch. 109 * @param[in] pdrTypes - list of PDR types that need to be looked up in the 110 * BMC repo 111 * @param[in] eventDataFormat - format for PDRRepositoryChgEvent in DSP0248 112 */ 113 void sendPDRRepositoryChgEvent(std::vector<uint8_t>&& pdrTypes, 114 uint8_t eventDataFormat); 115 116 /** @brief Lookup host sensor info corresponding to requested SensorEntry 117 * 118 * @param[in] entry - TerminusID and SensorID 119 * 120 * @return SensorInfo corresponding to the input paramter SensorEntry 121 * throw std::out_of_range exception if not found 122 */ 123 const pdr::SensorInfo& lookupSensorInfo(const SensorEntry& entry) const 124 { 125 return sensorMap.at(entry); 126 } 127 128 /** @brief Handles state sensor event 129 * 130 * @param[in] entry - state sensor entry 131 * @param[in] state - event state 132 * 133 * @return PLDM completion code 134 */ 135 int handleStateSensorEvent( 136 const pldm::responder::events::StateSensorEntry& entry, 137 pdr::EventState state); 138 139 /** @brief Parse state sensor PDRs and populate the sensorMap lookup data 140 * structure 141 * 142 * @param[in] stateSensorPDRs - host state sensor PDRs 143 * 144 */ 145 void parseStateSensorPDRs(const PDRList& stateSensorPDRs); 146 147 /** @brief this function sends a GetPDR request to Host firmware. 148 * And processes the PDRs based on type 149 * 150 * @param[in] - nextRecordHandle - the next record handle to ask for 151 */ 152 void getHostPDR(uint32_t nextRecordHandle = 0); 153 154 /** @brief set the Host firmware condition when pldmd starts 155 */ 156 void setHostFirmwareCondition(); 157 158 /** @brief set HostSensorStates when pldmd starts or restarts 159 * and updates the D-Bus property 160 * @param[in] stateSensorPDRs - host state sensor PDRs 161 */ 162 void setHostSensorState(const PDRList& stateSensorPDRs); 163 164 /** @brief whether we received PLDM_RECORDS_MODIFIED event data operation 165 * from host 166 */ 167 bool isHostPdrModified = false; 168 169 /** @brief check whether Host is running when pldmd starts 170 */ 171 bool isHostUp(); 172 173 /** @brief map that captures various terminus information **/ 174 TLPDRMap tlPDRInfo; 175 176 private: 177 /** @brief deferred function to fetch PDR from Host, scheduled to work on 178 * the event loop. The PDR exchg with the host is async. 179 * @param[in] source - sdeventplus event source 180 */ 181 void _fetchPDR(sdeventplus::source::EventBase& source); 182 183 /** @brief Merge host firmware's entity association PDRs into BMC's 184 * @details A merge operation involves adding a pldm_entity under the 185 * appropriate parent, and updating container ids. 186 * @param[in] pdr - entity association pdr 187 * @param[in] size - size of input PDR record in bytes 188 * @param[in] record_handle - record handle of the PDR 189 */ 190 void 191 mergeEntityAssociations(const std::vector<uint8_t>& pdr, 192 [[maybe_unused]] const uint32_t& size, 193 [[maybe_unused]] const uint32_t& record_handle); 194 195 /** @brief process the Host's PDR and add to BMC's PDR repo 196 * @param[in] eid - MCTP id of Host 197 * @param[in] response - response from Host for GetPDR 198 * @param[in] respMsgLen - response message length 199 */ 200 void processHostPDRs(mctp_eid_t eid, const pldm_msg* response, 201 size_t respMsgLen); 202 203 /** @brief send PDR Repo change after merging Host's PDR to BMC PDR repo 204 * @param[in] source - sdeventplus event source 205 */ 206 void _processPDRRepoChgEvent(sdeventplus::source::EventBase& source); 207 208 /** @brief fetch the next PDR based on the record handle sent by Host 209 * @param[in] nextRecordHandle - next record handle 210 * @param[in] source - sdeventplus event source 211 */ 212 void _processFetchPDREvent(uint32_t nextRecordHandle, 213 sdeventplus::source::EventBase& source); 214 215 /** @brief Get FRU record table metadata by remote PLDM terminus 216 * 217 * @param[out] uint16_t - total table records 218 */ 219 void getFRURecordTableMetadataByRemote(const PDRList& fruRecordSetPDRs); 220 221 /** @brief Set Location Code in the dbus objects 222 * 223 * @param[in] fruRecordSetPDRs - the Fru Record set PDR's 224 * @param[in] fruRecordData - the Fru Record Data 225 */ 226 227 void setFRUDataOnDBus( 228 const PDRList& fruRecordSetPDRs, 229 const std::vector<responder::pdr_utils::FruRecordDataFormat>& 230 fruRecordData); 231 232 /** @brief Get FRU record table by remote PLDM terminus 233 * 234 * @param[in] fruRecordSetPDRs - the Fru Record set PDR's 235 * @param[in] totalTableRecords - the Number of total table records 236 * @return 237 */ 238 void getFRURecordTableByRemote(const PDRList& fruRecordSetPDRs, 239 uint16_t totalTableRecords); 240 241 /** @brief Create Dbus objects by remote PLDM entity Fru PDRs 242 * 243 * @param[in] fruRecordSetPDRs - fru record set pdr 244 * 245 * @ return 246 */ 247 void createDbusObjects(const PDRList& fruRecordSetPDRs); 248 249 /** @brief Get FRU Record Set Identifier from FRU Record data Format 250 * @param[in] fruRecordSetPDRs - fru record set pdr 251 * @param[in] entity - PLDM entity information 252 * @return 253 */ 254 std::optional<uint16_t> getRSI(const PDRList& fruRecordSetPDRs, 255 const pldm_entity& entity); 256 257 /** @brief fd of MCTP communications socket */ 258 int mctp_fd; 259 /** @brief MCTP EID of host firmware */ 260 uint8_t mctp_eid; 261 /** @brief reference of main event loop of pldmd, primarily used to schedule 262 * work. 263 */ 264 sdeventplus::Event& event; 265 /** @brief pointer to BMC's primary PDR repo, host PDRs are added here */ 266 pldm_pdr* repo; 267 268 pldm::responder::events::StateSensorHandler stateSensorHandler; 269 /** @brief Pointer to BMC's and Host's entity association tree */ 270 pldm_entity_association_tree* entityTree; 271 272 /** @brief Pointer to BMC's entity association tree */ 273 pldm_entity_association_tree* bmcEntityTree; 274 275 /** @brief reference to Instance ID database object, used to obtain PLDM 276 * instance IDs 277 */ 278 pldm::InstanceIdDb& instanceIdDb; 279 280 /** @brief PLDM request handler */ 281 pldm::requester::Handler<pldm::requester::Request>* handler; 282 283 /** @brief sdeventplus event source */ 284 std::unique_ptr<sdeventplus::source::Defer> pdrFetchEvent; 285 std::unique_ptr<sdeventplus::source::Defer> deferredFetchPDREvent; 286 std::unique_ptr<sdeventplus::source::Defer> deferredPDRRepoChgEvent; 287 288 /** @brief list of PDR record handles pointing to host's PDRs */ 289 PDRRecordHandles pdrRecordHandles; 290 /** @brief maps an entity type to parent pldm_entity from the BMC's entity 291 * association tree 292 */ 293 294 /** @brief list of PDR record handles modified pointing to host PDRs */ 295 PDRRecordHandles modifiedPDRRecordHandles; 296 297 std::map<EntityType, pldm_entity> parents; 298 /** @brief D-Bus property changed signal match */ 299 std::unique_ptr<sdbusplus::bus::match_t> hostOffMatch; 300 301 /** @brief sensorMap is a lookup data structure that is build from the 302 * hostPDR that speeds up the lookup of <TerminusID, SensorID> in 303 * PlatformEventMessage command request. 304 */ 305 HostStateSensorMap sensorMap; 306 307 /** @brief whether response received from Host */ 308 bool responseReceived; 309 310 /** @brief variable that captures if the first entity association PDR 311 * from host is merged into the BMC tree 312 */ 313 bool mergedHostParents; 314 315 /** @brief whether timed out waiting for a response from Host */ 316 bool timeOut; 317 318 /** @brief request message instance id */ 319 uint8_t insId; 320 321 /** @brief maps an object path to pldm_entity from the BMC's entity 322 * association tree 323 */ 324 utils::ObjectPathMaps objPathMap; 325 326 /** @brief maps an entity name to map, maps to entity name to pldm_entity 327 */ 328 utils::EntityAssociations entityAssociations; 329 330 /** @brief the vector of FRU Record Data Format 331 */ 332 std::vector<responder::pdr_utils::FruRecordDataFormat> fruRecordData; 333 334 /** @OEM platform handler */ 335 pldm::responder::oem_platform::Handler* oemPlatformHandler; 336 337 /** @brief Object path and entity association and is only loaded once 338 */ 339 bool objPathEntityAssociation; 340 }; 341 342 } // namespace pldm 343