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