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 #include "utils.hpp" 11 12 #include <libpldm/base.h> 13 #include <libpldm/platform.h> 14 15 #include <sdeventplus/event.hpp> 16 #include <sdeventplus/source/event.hpp> 17 18 #include <deque> 19 #include <filesystem> 20 #include <map> 21 #include <memory> 22 #include <vector> 23 24 namespace pldm 25 { 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 * @param[in] oemUtilsHandler - pointer oem utils handler 91 */ 92 explicit HostPDRHandler( 93 int mctp_fd, uint8_t mctp_eid, sdeventplus::Event& event, 94 pldm_pdr* repo, const std::string& eventsJsonsDir, 95 pldm_entity_association_tree* entityTree, 96 pldm_entity_association_tree* bmcEntityTree, 97 pldm::InstanceIdDb& instanceIdDb, 98 pldm::requester::Handler<pldm::requester::Request>* handler); 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 delete PDRs from remote pldm endpoint. 108 * @param[in] recordHandles - list of record handles pointing to remote 109 * PDRs that need to be deleted. 110 */ 111 void deletePDRFromRepo(PDRRecordHandles&& recordHandles); 112 113 /** @brief Send a PLDM event to host firmware containing a list of record 114 * handles of PDRs that the host firmware has to fetch. 115 * @param[in] pdrTypes - list of PDR types that need to be looked up in the 116 * BMC repo 117 * @param[in] eventDataFormat - format for PDRRepositoryChgEvent in DSP0248 118 */ 119 void sendPDRRepositoryChgEvent(std::vector<uint8_t>&& pdrTypes, 120 uint8_t eventDataFormat); 121 122 /** @brief Lookup host sensor info corresponding to requested SensorEntry 123 * 124 * @param[in] entry - TerminusID and SensorID 125 * 126 * @return SensorInfo corresponding to the input parameter SensorEntry 127 * throw std::out_of_range exception if not found 128 */ 129 const pdr::SensorInfo& lookupSensorInfo(const SensorEntry& entry) const 130 { 131 return sensorMap.at(entry); 132 } 133 134 /** @brief Handles state sensor event 135 * 136 * @param[in] entry - state sensor entry 137 * @param[in] state - event state 138 * 139 * @return PLDM completion code 140 */ 141 int handleStateSensorEvent( 142 const pldm::responder::events::StateSensorEntry& entry, 143 pdr::EventState state); 144 145 /** @brief Parse state sensor PDRs and populate the sensorMap lookup data 146 * structure 147 * 148 * @param[in] stateSensorPDRs - host state sensor PDRs 149 * 150 */ 151 void parseStateSensorPDRs(const PDRList& stateSensorPDRs); 152 153 /** @brief this function sends a GetPDR request to Host firmware. 154 * And processes the PDRs based on type 155 * 156 * @param[in] - nextRecordHandle - the next record handle to ask for 157 */ 158 void getHostPDR(uint32_t nextRecordHandle = 0); 159 160 /** @brief set the Host firmware condition when pldmd starts 161 */ 162 void setHostFirmwareCondition(); 163 164 /** @brief set HostSensorStates when pldmd starts or restarts 165 * and updates the D-Bus property 166 * @param[in] stateSensorPDRs - host state sensor PDRs 167 */ 168 void setHostSensorState(const PDRList& stateSensorPDRs); 169 170 /** @brief whether we received PLDM_RECORDS_MODIFIED event data operation 171 * from host 172 */ 173 bool isHostPdrModified = false; 174 175 /** @brief check whether Host is running when pldmd starts 176 */ 177 bool isHostUp(); 178 179 /* @brief Method to set the oem platform handler in host pdr handler class 180 * 181 * @param[in] handler - oem platform handler 182 */ 183 inline void setOemPlatformHandler( 184 pldm::responder::oem_platform::Handler* handler) 185 { 186 oemPlatformHandler = handler; 187 } 188 189 /* @brief Method to set the oem utils handler in host pdr handler class 190 * 191 * @param[in] handler - oem utils handler 192 */ 193 inline void setOemUtilsHandler(pldm::responder::oem_utils::Handler* handler) 194 { 195 oemUtilsHandler = handler; 196 } 197 198 /** @brief map that captures various terminus information **/ 199 TLPDRMap tlPDRInfo; 200 201 private: 202 /** @brief deferred function to fetch PDR from Host, scheduled to work on 203 * the event loop. The PDR exchg with the host is async. 204 * @param[in] source - sdeventplus event source 205 */ 206 void _fetchPDR(sdeventplus::source::EventBase& source); 207 208 /** @brief Merge host firmware's entity association PDRs into BMC's 209 * @details A merge operation involves adding a pldm_entity under the 210 * appropriate parent, and updating container ids. 211 * @param[in] pdr - entity association pdr 212 * @param[in] size - size of input PDR record in bytes 213 * @param[in] record_handle - record handle of the PDR 214 */ 215 void mergeEntityAssociations( 216 const std::vector<uint8_t>& pdr, [[maybe_unused]] const uint32_t& size, 217 [[maybe_unused]] const uint32_t& record_handle); 218 219 /** @brief process the Host's PDR and add to BMC's PDR repo 220 * @param[in] eid - MCTP id of Host 221 * @param[in] response - response from Host for GetPDR 222 * @param[in] respMsgLen - response message length 223 */ 224 void processHostPDRs(mctp_eid_t eid, const pldm_msg* response, 225 size_t respMsgLen); 226 227 /** @brief send PDR Repo change after merging Host's PDR to BMC PDR repo 228 * @param[in] source - sdeventplus event source 229 */ 230 void _processPDRRepoChgEvent(sdeventplus::source::EventBase& source); 231 232 /** @brief fetch the next PDR based on the record handle sent by Host 233 * @param[in] nextRecordHandle - next record handle 234 * @param[in] source - sdeventplus event source 235 */ 236 void _processFetchPDREvent(uint32_t nextRecordHandle, 237 sdeventplus::source::EventBase& source); 238 239 /** @brief Get FRU record table metadata by remote PLDM terminus 240 * 241 * @param[out] uint16_t - total table records 242 */ 243 void getFRURecordTableMetadataByRemote(const PDRList& fruRecordSetPDRs); 244 245 /** @brief Set Location Code in the dbus objects 246 * 247 * @param[in] fruRecordSetPDRs - the Fru Record set PDR's 248 * @param[in] fruRecordData - the Fru Record Data 249 */ 250 251 void setFRUDataOnDBus( 252 const PDRList& fruRecordSetPDRs, 253 const std::vector<responder::pdr_utils::FruRecordDataFormat>& 254 fruRecordData); 255 256 /** @brief Get FRU record table by remote PLDM terminus 257 * 258 * @param[in] fruRecordSetPDRs - the Fru Record set PDR's 259 * @param[in] totalTableRecords - the Number of total table records 260 * @return 261 */ 262 void getFRURecordTableByRemote(const PDRList& fruRecordSetPDRs, 263 uint16_t totalTableRecords); 264 265 /** @brief Create Dbus objects by remote PLDM entity Fru PDRs 266 * 267 * @param[in] fruRecordSetPDRs - fru record set pdr 268 * 269 * @ return 270 */ 271 void createDbusObjects(const PDRList& fruRecordSetPDRs); 272 273 /** @brief set the FRU presence based on the remote PLDM terminus off signal 274 */ 275 void setPresenceFrus(); 276 277 /** @brief Set the Present dbus Property 278 * @param[in] path - object path 279 * @return 280 */ 281 void setPresentPropertyStatus(const std::string& path); 282 283 /** @brief Set the availabilty dbus Property 284 * @param[in] path - object path 285 */ 286 void setAvailabilityState(const std::string& path); 287 288 /** @brief Get FRU Record Set Identifier from FRU Record data Format 289 * @param[in] fruRecordSetPDRs - fru record set pdr 290 * @param[in] entity - PLDM entity information 291 * @return 292 */ 293 std::optional<uint16_t> getRSI(const PDRList& fruRecordSetPDRs, 294 const pldm_entity& entity); 295 296 /** @brief MCTP EID of host firmware */ 297 uint8_t mctp_eid; 298 /** @brief reference of main event loop of pldmd, primarily used to schedule 299 * work. 300 */ 301 sdeventplus::Event& event; 302 /** @brief pointer to BMC's primary PDR repo, host PDRs are added here */ 303 pldm_pdr* repo; 304 305 pldm::responder::events::StateSensorHandler stateSensorHandler; 306 /** @brief Pointer to BMC's and Host's entity association tree */ 307 pldm_entity_association_tree* entityTree; 308 309 /** @brief reference to Instance ID database object, used to obtain PLDM 310 * instance IDs 311 */ 312 pldm::InstanceIdDb& instanceIdDb; 313 314 /** @brief PLDM request handler */ 315 pldm::requester::Handler<pldm::requester::Request>* handler; 316 317 /** @brief sdeventplus event source */ 318 std::unique_ptr<sdeventplus::source::Defer> pdrFetchEvent; 319 std::unique_ptr<sdeventplus::source::Defer> deferredFetchPDREvent; 320 std::unique_ptr<sdeventplus::source::Defer> deferredPDRRepoChgEvent; 321 322 /** @brief list of PDR record handles pointing to host's PDRs */ 323 PDRRecordHandles pdrRecordHandles; 324 /** @brief maps an entity type to parent pldm_entity from the BMC's entity 325 * association tree 326 */ 327 328 /** @brief list of PDR record handles modified pointing to host PDRs */ 329 PDRRecordHandles modifiedPDRRecordHandles; 330 331 /** @brief D-Bus property changed signal match */ 332 std::unique_ptr<sdbusplus::bus::match_t> hostOffMatch; 333 334 /** @brief sensorMap is a lookup data structure that is build from the 335 * hostPDR that speeds up the lookup of <TerminusID, SensorID> in 336 * PlatformEventMessage command request. 337 */ 338 HostStateSensorMap sensorMap; 339 340 /** @brief whether response received from Host */ 341 bool responseReceived; 342 343 /** @brief variable that captures if the first entity association PDR 344 * from host is merged into the BMC tree 345 */ 346 bool mergedHostParents; 347 348 /** @brief maps an object path to pldm_entity from the BMC's entity 349 * association tree 350 */ 351 pldm::utils::ObjectPathMaps objPathMap; 352 353 /** @brief maps an entity name to map, maps to entity name to pldm_entity 354 */ 355 pldm::utils::EntityAssociations entityAssociations; 356 357 /** @brief the vector of FRU Record Data Format 358 */ 359 std::vector<responder::pdr_utils::FruRecordDataFormat> fruRecordData; 360 361 /** @OEM platform handler */ 362 pldm::responder::oem_platform::Handler* oemPlatformHandler = nullptr; 363 364 /** @brief entityID and entity name is only loaded once 365 */ 366 pldm::utils::EntityMaps entityMaps; 367 368 /** @OEM Utils handler */ 369 pldm::responder::oem_utils::Handler* oemUtilsHandler; 370 }; 371 372 } // namespace pldm 373