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