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/dbus_impl_requester.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] requester - reference to Requester 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::dbus_api::Requester& requester,
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 Find parent of input entity type, from the entity association
188      *  tree
189      *  @param[in] type - PLDM entity type
190      *  @param[out] parent - PLDM entity information of parent
191      *  @return bool - true if parent found, false otherwise
192      */
193     bool getParent(EntityType type, pldm_entity& parent);
194 
195     /** @brief process the Host's PDR and add to BMC's PDR repo
196      *  @param[in] eid - MCTP id of Host
197      *  @param[in] response - response from Host for GetPDR
198      *  @param[in] respMsgLen - response message length
199      */
200     void processHostPDRs(mctp_eid_t eid, const pldm_msg* response,
201                          size_t respMsgLen);
202 
203     /** @brief send PDR Repo change after merging Host's PDR to BMC PDR repo
204      *  @param[in] source - sdeventplus event source
205      */
206     void _processPDRRepoChgEvent(sdeventplus::source::EventBase& source);
207 
208     /** @brief fetch the next PDR based on the record handle sent by Host
209      *  @param[in] nextRecordHandle - next record handle
210      *  @param[in] source - sdeventplus event source
211      */
212     void _processFetchPDREvent(uint32_t nextRecordHandle,
213                                sdeventplus::source::EventBase& source);
214 
215     /** @brief fd of MCTP communications socket */
216     int mctp_fd;
217     /** @brief MCTP EID of host firmware */
218     uint8_t mctp_eid;
219     /** @brief reference of main event loop of pldmd, primarily used to schedule
220      *  work.
221      */
222     sdeventplus::Event& event;
223     /** @brief pointer to BMC's primary PDR repo, host PDRs are added here */
224     pldm_pdr* repo;
225 
226     pldm::responder::events::StateSensorHandler stateSensorHandler;
227     /** @brief Pointer to BMC's and Host's entity association tree */
228     pldm_entity_association_tree* entityTree;
229 
230     /** @brief Pointer to BMC's entity association tree */
231     pldm_entity_association_tree* bmcEntityTree;
232 
233     /** @brief reference to Requester object, primarily used to access API to
234      *  obtain PLDM instance id.
235      */
236     pldm::dbus_api::Requester& requester;
237 
238     /** @brief PLDM request handler */
239     pldm::requester::Handler<pldm::requester::Request>* handler;
240 
241     /** @brief sdeventplus event source */
242     std::unique_ptr<sdeventplus::source::Defer> pdrFetchEvent;
243     std::unique_ptr<sdeventplus::source::Defer> deferredFetchPDREvent;
244     std::unique_ptr<sdeventplus::source::Defer> deferredPDRRepoChgEvent;
245 
246     /** @brief list of PDR record handles pointing to host's PDRs */
247     PDRRecordHandles pdrRecordHandles;
248     /** @brief maps an entity type to parent pldm_entity from the BMC's entity
249      *  association tree
250      */
251 
252     /** @brief list of PDR record handles modified pointing to host PDRs */
253     PDRRecordHandles modifiedPDRRecordHandles;
254 
255     std::map<EntityType, pldm_entity> parents;
256     /** @brief D-Bus property changed signal match */
257     std::unique_ptr<sdbusplus::bus::match_t> hostOffMatch;
258 
259     /** @brief sensorMap is a lookup data structure that is build from the
260      *         hostPDR that speeds up the lookup of <TerminusID, SensorID> in
261      *         PlatformEventMessage command request.
262      */
263     HostStateSensorMap sensorMap;
264 
265     /** @brief whether response received from Host */
266     bool responseReceived;
267 };
268 
269 } // namespace pldm
270