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