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 using EntityType = uint16_t; 27 // vector which would hold the PDR record handle data returned by 28 // pldmPDRRepositoryChgEvent event data 29 using ChangeEntry = uint32_t; 30 using PDRRecordHandles = std::deque<ChangeEntry>; 31 32 /** @struct SensorEntry 33 * 34 * SensorEntry is a unique key which maps a sensorEventType request in the 35 * PlatformEventMessage command to a host sensor PDR. This struct is a key 36 * in a std::map, so implemented operator==and operator<. 37 */ 38 struct SensorEntry 39 { 40 pdr::TerminusID terminusID; 41 pdr::SensorID sensorID; 42 43 bool operator==(const SensorEntry& e) const 44 { 45 return ((terminusID == e.terminusID) && (sensorID == e.sensorID)); 46 } 47 48 bool operator<(const SensorEntry& e) const 49 { 50 return ((terminusID < e.terminusID) || 51 ((terminusID == e.terminusID) && (sensorID < e.sensorID))); 52 } 53 }; 54 55 using HostStateSensorMap = std::map<SensorEntry, pdr::SensorInfo>; 56 using PDRList = std::vector<std::vector<uint8_t>>; 57 58 /** @class HostPDRHandler 59 * @brief This class can fetch and process PDRs from host firmware 60 * @details Provides an API to fetch PDRs from the host firmware. Upon 61 * receiving the PDRs, they are stored into the BMC's primary PDR repo. 62 * Adjustments are made to entity association PDRs received from the host, 63 * because they need to be assimilated into the BMC's entity association 64 * tree. A PLDM event containing the record handles of the updated entity 65 * association PDRs is sent to the host. 66 */ 67 class HostPDRHandler 68 { 69 public: 70 HostPDRHandler() = delete; 71 HostPDRHandler(const HostPDRHandler&) = delete; 72 HostPDRHandler(HostPDRHandler&&) = delete; 73 HostPDRHandler& operator=(const HostPDRHandler&) = delete; 74 HostPDRHandler& operator=(HostPDRHandler&&) = delete; 75 ~HostPDRHandler() = default; 76 77 using TerminusInfo = 78 std::tuple<pdr::TerminusID, pdr::EID, pdr::TerminusValidity>; 79 using TLPDRMap = std::map<pdr::TerminusHandle, TerminusInfo>; 80 81 /** @brief Constructor 82 * @param[in] mctp_fd - fd of MCTP communications socket 83 * @param[in] mctp_eid - MCTP EID of host firmware 84 * @param[in] event - reference of main event loop of pldmd 85 * @param[in] repo - pointer to BMC's primary PDR repo 86 * @param[in] eventsJsonDir - directory path which has the config JSONs 87 * @param[in] entityTree - Pointer to BMC and Host entity association tree 88 * @param[in] bmcEntityTree - pointer to BMC's entity association tree 89 * @param[in] instanceIdDb - reference to an InstanceIdDb object 90 * @param[in] handler - PLDM request 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 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 parameter 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 Method to set the oem platform handler in host pdr handler class 174 * 175 * @param[in] handler - oem platform handler 176 */ 177 inline void 178 setOemPlatformHandler(pldm::responder::oem_platform::Handler* handler) 179 { 180 oemPlatformHandler = handler; 181 } 182 183 /** @brief map that captures various terminus information **/ 184 TLPDRMap tlPDRInfo; 185 186 private: 187 /** @brief deferred function to fetch PDR from Host, scheduled to work on 188 * the event loop. The PDR exchg with the host is async. 189 * @param[in] source - sdeventplus event source 190 */ 191 void _fetchPDR(sdeventplus::source::EventBase& source); 192 193 /** @brief Merge host firmware's entity association PDRs into BMC's 194 * @details A merge operation involves adding a pldm_entity under the 195 * appropriate parent, and updating container ids. 196 * @param[in] pdr - entity association pdr 197 * @param[in] size - size of input PDR record in bytes 198 * @param[in] record_handle - record handle of the PDR 199 */ 200 void 201 mergeEntityAssociations(const std::vector<uint8_t>& pdr, 202 [[maybe_unused]] const uint32_t& size, 203 [[maybe_unused]] const uint32_t& record_handle); 204 205 /** @brief process the Host's PDR and add to BMC's PDR repo 206 * @param[in] eid - MCTP id of Host 207 * @param[in] response - response from Host for GetPDR 208 * @param[in] respMsgLen - response message length 209 */ 210 void processHostPDRs(mctp_eid_t eid, const pldm_msg* response, 211 size_t respMsgLen); 212 213 /** @brief send PDR Repo change after merging Host's PDR to BMC PDR repo 214 * @param[in] source - sdeventplus event source 215 */ 216 void _processPDRRepoChgEvent(sdeventplus::source::EventBase& source); 217 218 /** @brief fetch the next PDR based on the record handle sent by Host 219 * @param[in] nextRecordHandle - next record handle 220 * @param[in] source - sdeventplus event source 221 */ 222 void _processFetchPDREvent(uint32_t nextRecordHandle, 223 sdeventplus::source::EventBase& source); 224 225 /** @brief Get FRU record table metadata by remote PLDM terminus 226 * 227 * @param[out] uint16_t - total table records 228 */ 229 void getFRURecordTableMetadataByRemote(const PDRList& fruRecordSetPDRs); 230 231 /** @brief Set Location Code in the dbus objects 232 * 233 * @param[in] fruRecordSetPDRs - the Fru Record set PDR's 234 * @param[in] fruRecordData - the Fru Record Data 235 */ 236 237 void setFRUDataOnDBus( 238 const PDRList& fruRecordSetPDRs, 239 const std::vector<responder::pdr_utils::FruRecordDataFormat>& 240 fruRecordData); 241 242 /** @brief Get FRU record table by remote PLDM terminus 243 * 244 * @param[in] fruRecordSetPDRs - the Fru Record set PDR's 245 * @param[in] totalTableRecords - the Number of total table records 246 * @return 247 */ 248 void getFRURecordTableByRemote(const PDRList& fruRecordSetPDRs, 249 uint16_t totalTableRecords); 250 251 /** @brief Create Dbus objects by remote PLDM entity Fru PDRs 252 * 253 * @param[in] fruRecordSetPDRs - fru record set pdr 254 * 255 * @ return 256 */ 257 void createDbusObjects(const PDRList& fruRecordSetPDRs); 258 259 /** @brief Get FRU Record Set Identifier from FRU Record data Format 260 * @param[in] fruRecordSetPDRs - fru record set pdr 261 * @param[in] entity - PLDM entity information 262 * @return 263 */ 264 std::optional<uint16_t> getRSI(const PDRList& fruRecordSetPDRs, 265 const pldm_entity& entity); 266 267 /** @brief fd of MCTP communications socket */ 268 int mctp_fd; 269 /** @brief MCTP EID of host firmware */ 270 uint8_t mctp_eid; 271 /** @brief reference of main event loop of pldmd, primarily used to schedule 272 * work. 273 */ 274 sdeventplus::Event& event; 275 /** @brief pointer to BMC's primary PDR repo, host PDRs are added here */ 276 pldm_pdr* repo; 277 278 pldm::responder::events::StateSensorHandler stateSensorHandler; 279 /** @brief Pointer to BMC's and Host's entity association tree */ 280 pldm_entity_association_tree* entityTree; 281 282 /** @brief Pointer to BMC's entity association tree */ 283 pldm_entity_association_tree* bmcEntityTree; 284 285 /** @brief reference to Instance ID database object, used to obtain PLDM 286 * instance IDs 287 */ 288 pldm::InstanceIdDb& instanceIdDb; 289 290 /** @brief PLDM request handler */ 291 pldm::requester::Handler<pldm::requester::Request>* handler; 292 293 /** @brief sdeventplus event source */ 294 std::unique_ptr<sdeventplus::source::Defer> pdrFetchEvent; 295 std::unique_ptr<sdeventplus::source::Defer> deferredFetchPDREvent; 296 std::unique_ptr<sdeventplus::source::Defer> deferredPDRRepoChgEvent; 297 298 /** @brief list of PDR record handles pointing to host's PDRs */ 299 PDRRecordHandles pdrRecordHandles; 300 /** @brief maps an entity type to parent pldm_entity from the BMC's entity 301 * association tree 302 */ 303 304 /** @brief list of PDR record handles modified pointing to host PDRs */ 305 PDRRecordHandles modifiedPDRRecordHandles; 306 307 /** @brief D-Bus property changed signal match */ 308 std::unique_ptr<sdbusplus::bus::match_t> hostOffMatch; 309 310 /** @brief sensorMap is a lookup data structure that is build from the 311 * hostPDR that speeds up the lookup of <TerminusID, SensorID> in 312 * PlatformEventMessage command request. 313 */ 314 HostStateSensorMap sensorMap; 315 316 /** @brief whether response received from Host */ 317 bool responseReceived; 318 319 /** @brief variable that captures if the first entity association PDR 320 * from host is merged into the BMC tree 321 */ 322 bool mergedHostParents; 323 324 /** @brief maps an object path to pldm_entity from the BMC's entity 325 * association tree 326 */ 327 ObjectPathMaps objPathMap; 328 329 /** @brief maps an entity name to map, maps to entity name to pldm_entity 330 */ 331 EntityAssociations entityAssociations; 332 333 /** @brief the vector of FRU Record Data Format 334 */ 335 std::vector<responder::pdr_utils::FruRecordDataFormat> fruRecordData; 336 337 /** @OEM platform handler */ 338 pldm::responder::oem_platform::Handler* oemPlatformHandler = nullptr; 339 340 /** @brief entityID and entity name is only loaded once 341 */ 342 EntityMaps entityMaps; 343 }; 344 345 } // namespace pldm 346