| #pragma once |
| |
| #include "common/instance_id.hpp" |
| #include "common/types.hpp" |
| #include "common/utils.hpp" |
| #include "libpldmresponder/event_parser.hpp" |
| #include "libpldmresponder/oem_handler.hpp" |
| #include "libpldmresponder/pdr_utils.hpp" |
| #include "requester/handler.hpp" |
| #include "utils.hpp" |
| |
| #include <libpldm/base.h> |
| #include <libpldm/platform.h> |
| |
| #include <sdeventplus/event.hpp> |
| #include <sdeventplus/source/event.hpp> |
| |
| #include <deque> |
| #include <filesystem> |
| #include <map> |
| #include <memory> |
| #include <vector> |
| |
| namespace pldm |
| { |
| // vector which would hold the PDR record handle data returned by |
| // pldmPDRRepositoryChgEvent event data |
| using ChangeEntry = uint32_t; |
| using PDRRecordHandles = std::deque<ChangeEntry>; |
| |
| /** @struct SensorEntry |
| * |
| * SensorEntry is a unique key which maps a sensorEventType request in the |
| * PlatformEventMessage command to a host sensor PDR. This struct is a key |
| * in a std::map, so implemented operator==and operator<. |
| */ |
| struct SensorEntry |
| { |
| pdr::TerminusID terminusID; |
| pdr::SensorID sensorID; |
| |
| bool operator==(const SensorEntry& e) const |
| { |
| return ((terminusID == e.terminusID) && (sensorID == e.sensorID)); |
| } |
| |
| bool operator<(const SensorEntry& e) const |
| { |
| return ((terminusID < e.terminusID) || |
| ((terminusID == e.terminusID) && (sensorID < e.sensorID))); |
| } |
| }; |
| |
| using HostStateSensorMap = std::map<SensorEntry, pdr::SensorInfo>; |
| using PDRList = std::vector<std::vector<uint8_t>>; |
| |
| /** @class HostPDRHandler |
| * @brief This class can fetch and process PDRs from host firmware |
| * @details Provides an API to fetch PDRs from the host firmware. Upon |
| * receiving the PDRs, they are stored into the BMC's primary PDR repo. |
| * Adjustments are made to entity association PDRs received from the host, |
| * because they need to be assimilated into the BMC's entity association |
| * tree. A PLDM event containing the record handles of the updated entity |
| * association PDRs is sent to the host. |
| */ |
| class HostPDRHandler |
| { |
| public: |
| HostPDRHandler() = delete; |
| HostPDRHandler(const HostPDRHandler&) = delete; |
| HostPDRHandler(HostPDRHandler&&) = delete; |
| HostPDRHandler& operator=(const HostPDRHandler&) = delete; |
| HostPDRHandler& operator=(HostPDRHandler&&) = delete; |
| ~HostPDRHandler() = default; |
| |
| using TerminusInfo = |
| std::tuple<pdr::TerminusID, pdr::EID, pdr::TerminusValidity>; |
| using TLPDRMap = std::map<pdr::TerminusHandle, TerminusInfo>; |
| |
| /** @brief Constructor |
| * @param[in] mctp_fd - fd of MCTP communications socket |
| * @param[in] mctp_eid - MCTP EID of host firmware |
| * @param[in] event - reference of main event loop of pldmd |
| * @param[in] repo - pointer to BMC's primary PDR repo |
| * @param[in] eventsJsonDir - directory path which has the config JSONs |
| * @param[in] entityTree - Pointer to BMC and Host entity association tree |
| * @param[in] bmcEntityTree - pointer to BMC's entity association tree |
| * @param[in] instanceIdDb - reference to an InstanceIdDb object |
| * @param[in] handler - PLDM request handler |
| */ |
| explicit HostPDRHandler( |
| int mctp_fd, uint8_t mctp_eid, sdeventplus::Event& event, |
| pldm_pdr* repo, const std::string& eventsJsonsDir, |
| pldm_entity_association_tree* entityTree, |
| pldm_entity_association_tree* bmcEntityTree, |
| pldm::InstanceIdDb& instanceIdDb, |
| pldm::requester::Handler<pldm::requester::Request>* handler); |
| |
| /** @brief fetch PDRs from host firmware. See @class. |
| * @param[in] recordHandles - list of record handles pointing to host's |
| * PDRs that need to be fetched. |
| */ |
| |
| void fetchPDR(PDRRecordHandles&& recordHandles); |
| |
| /** @brief Send a PLDM event to host firmware containing a list of record |
| * handles of PDRs that the host firmware has to fetch. |
| * @param[in] pdrTypes - list of PDR types that need to be looked up in the |
| * BMC repo |
| * @param[in] eventDataFormat - format for PDRRepositoryChgEvent in DSP0248 |
| */ |
| void sendPDRRepositoryChgEvent(std::vector<uint8_t>&& pdrTypes, |
| uint8_t eventDataFormat); |
| |
| /** @brief Lookup host sensor info corresponding to requested SensorEntry |
| * |
| * @param[in] entry - TerminusID and SensorID |
| * |
| * @return SensorInfo corresponding to the input parameter SensorEntry |
| * throw std::out_of_range exception if not found |
| */ |
| const pdr::SensorInfo& lookupSensorInfo(const SensorEntry& entry) const |
| { |
| return sensorMap.at(entry); |
| } |
| |
| /** @brief Handles state sensor event |
| * |
| * @param[in] entry - state sensor entry |
| * @param[in] state - event state |
| * |
| * @return PLDM completion code |
| */ |
| int handleStateSensorEvent( |
| const pldm::responder::events::StateSensorEntry& entry, |
| pdr::EventState state); |
| |
| /** @brief Parse state sensor PDRs and populate the sensorMap lookup data |
| * structure |
| * |
| * @param[in] stateSensorPDRs - host state sensor PDRs |
| * |
| */ |
| void parseStateSensorPDRs(const PDRList& stateSensorPDRs); |
| |
| /** @brief this function sends a GetPDR request to Host firmware. |
| * And processes the PDRs based on type |
| * |
| * @param[in] - nextRecordHandle - the next record handle to ask for |
| */ |
| void getHostPDR(uint32_t nextRecordHandle = 0); |
| |
| /** @brief set the Host firmware condition when pldmd starts |
| */ |
| void setHostFirmwareCondition(); |
| |
| /** @brief set HostSensorStates when pldmd starts or restarts |
| * and updates the D-Bus property |
| * @param[in] stateSensorPDRs - host state sensor PDRs |
| */ |
| void setHostSensorState(const PDRList& stateSensorPDRs); |
| |
| /** @brief whether we received PLDM_RECORDS_MODIFIED event data operation |
| * from host |
| */ |
| bool isHostPdrModified = false; |
| |
| /** @brief check whether Host is running when pldmd starts |
| */ |
| bool isHostUp(); |
| |
| /* @brief Method to set the oem platform handler in host pdr handler class |
| * |
| * @param[in] handler - oem platform handler |
| */ |
| inline void |
| setOemPlatformHandler(pldm::responder::oem_platform::Handler* handler) |
| { |
| oemPlatformHandler = handler; |
| } |
| |
| /** @brief map that captures various terminus information **/ |
| TLPDRMap tlPDRInfo; |
| |
| private: |
| /** @brief deferred function to fetch PDR from Host, scheduled to work on |
| * the event loop. The PDR exchg with the host is async. |
| * @param[in] source - sdeventplus event source |
| */ |
| void _fetchPDR(sdeventplus::source::EventBase& source); |
| |
| /** @brief Merge host firmware's entity association PDRs into BMC's |
| * @details A merge operation involves adding a pldm_entity under the |
| * appropriate parent, and updating container ids. |
| * @param[in] pdr - entity association pdr |
| * @param[in] size - size of input PDR record in bytes |
| * @param[in] record_handle - record handle of the PDR |
| */ |
| void |
| mergeEntityAssociations(const std::vector<uint8_t>& pdr, |
| [[maybe_unused]] const uint32_t& size, |
| [[maybe_unused]] const uint32_t& record_handle); |
| |
| /** @brief process the Host's PDR and add to BMC's PDR repo |
| * @param[in] eid - MCTP id of Host |
| * @param[in] response - response from Host for GetPDR |
| * @param[in] respMsgLen - response message length |
| */ |
| void processHostPDRs(mctp_eid_t eid, const pldm_msg* response, |
| size_t respMsgLen); |
| |
| /** @brief send PDR Repo change after merging Host's PDR to BMC PDR repo |
| * @param[in] source - sdeventplus event source |
| */ |
| void _processPDRRepoChgEvent(sdeventplus::source::EventBase& source); |
| |
| /** @brief fetch the next PDR based on the record handle sent by Host |
| * @param[in] nextRecordHandle - next record handle |
| * @param[in] source - sdeventplus event source |
| */ |
| void _processFetchPDREvent(uint32_t nextRecordHandle, |
| sdeventplus::source::EventBase& source); |
| |
| /** @brief Get FRU record table metadata by remote PLDM terminus |
| * |
| * @param[out] uint16_t - total table records |
| */ |
| void getFRURecordTableMetadataByRemote(const PDRList& fruRecordSetPDRs); |
| |
| /** @brief Set Location Code in the dbus objects |
| * |
| * @param[in] fruRecordSetPDRs - the Fru Record set PDR's |
| * @param[in] fruRecordData - the Fru Record Data |
| */ |
| |
| void setFRUDataOnDBus( |
| const PDRList& fruRecordSetPDRs, |
| const std::vector<responder::pdr_utils::FruRecordDataFormat>& |
| fruRecordData); |
| |
| /** @brief Get FRU record table by remote PLDM terminus |
| * |
| * @param[in] fruRecordSetPDRs - the Fru Record set PDR's |
| * @param[in] totalTableRecords - the Number of total table records |
| * @return |
| */ |
| void getFRURecordTableByRemote(const PDRList& fruRecordSetPDRs, |
| uint16_t totalTableRecords); |
| |
| /** @brief Create Dbus objects by remote PLDM entity Fru PDRs |
| * |
| * @param[in] fruRecordSetPDRs - fru record set pdr |
| * |
| * @ return |
| */ |
| void createDbusObjects(const PDRList& fruRecordSetPDRs); |
| |
| /** @brief Get FRU Record Set Identifier from FRU Record data Format |
| * @param[in] fruRecordSetPDRs - fru record set pdr |
| * @param[in] entity - PLDM entity information |
| * @return |
| */ |
| std::optional<uint16_t> getRSI(const PDRList& fruRecordSetPDRs, |
| const pldm_entity& entity); |
| |
| /** @brief fd of MCTP communications socket */ |
| int mctp_fd; |
| /** @brief MCTP EID of host firmware */ |
| uint8_t mctp_eid; |
| /** @brief reference of main event loop of pldmd, primarily used to schedule |
| * work. |
| */ |
| sdeventplus::Event& event; |
| /** @brief pointer to BMC's primary PDR repo, host PDRs are added here */ |
| pldm_pdr* repo; |
| |
| pldm::responder::events::StateSensorHandler stateSensorHandler; |
| /** @brief Pointer to BMC's and Host's entity association tree */ |
| pldm_entity_association_tree* entityTree; |
| |
| /** @brief Pointer to BMC's entity association tree */ |
| pldm_entity_association_tree* bmcEntityTree; |
| |
| /** @brief reference to Instance ID database object, used to obtain PLDM |
| * instance IDs |
| */ |
| pldm::InstanceIdDb& instanceIdDb; |
| |
| /** @brief PLDM request handler */ |
| pldm::requester::Handler<pldm::requester::Request>* handler; |
| |
| /** @brief sdeventplus event source */ |
| std::unique_ptr<sdeventplus::source::Defer> pdrFetchEvent; |
| std::unique_ptr<sdeventplus::source::Defer> deferredFetchPDREvent; |
| std::unique_ptr<sdeventplus::source::Defer> deferredPDRRepoChgEvent; |
| |
| /** @brief list of PDR record handles pointing to host's PDRs */ |
| PDRRecordHandles pdrRecordHandles; |
| /** @brief maps an entity type to parent pldm_entity from the BMC's entity |
| * association tree |
| */ |
| |
| /** @brief list of PDR record handles modified pointing to host PDRs */ |
| PDRRecordHandles modifiedPDRRecordHandles; |
| |
| /** @brief D-Bus property changed signal match */ |
| std::unique_ptr<sdbusplus::bus::match_t> hostOffMatch; |
| |
| /** @brief sensorMap is a lookup data structure that is build from the |
| * hostPDR that speeds up the lookup of <TerminusID, SensorID> in |
| * PlatformEventMessage command request. |
| */ |
| HostStateSensorMap sensorMap; |
| |
| /** @brief whether response received from Host */ |
| bool responseReceived; |
| |
| /** @brief variable that captures if the first entity association PDR |
| * from host is merged into the BMC tree |
| */ |
| bool mergedHostParents; |
| |
| /** @brief maps an object path to pldm_entity from the BMC's entity |
| * association tree |
| */ |
| pldm::utils::ObjectPathMaps objPathMap; |
| |
| /** @brief maps an entity name to map, maps to entity name to pldm_entity |
| */ |
| pldm::utils::EntityAssociations entityAssociations; |
| |
| /** @brief the vector of FRU Record Data Format |
| */ |
| std::vector<responder::pdr_utils::FruRecordDataFormat> fruRecordData; |
| |
| /** @OEM platform handler */ |
| pldm::responder::oem_platform::Handler* oemPlatformHandler = nullptr; |
| |
| /** @brief entityID and entity name is only loaded once |
| */ |
| pldm::utils::EntityMaps entityMaps; |
| }; |
| |
| } // namespace pldm |