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