blob: 64f244281c70c8519275b06b4bacede3f9084cb4 [file] [log] [blame]
Pavithra Barithaya51efaf82020-04-02 02:42:27 -05001#pragma once
2
Deepak Kodihallid130e1a2020-06-17 05:55:32 -05003#include "common/types.hpp"
4#include "common/utils.hpp"
Pavithra Barithaya3aec9972020-12-14 01:55:44 -06005#include "libpldmresponder/event_parser.hpp"
Tom Josephb4268602020-04-17 17:20:45 +05306#include "libpldmresponder/pdr_utils.hpp"
Deepak Kodihalli1521f6d2020-06-16 08:51:02 -05007#include "pldmd/dbus_impl_requester.hpp"
Tom Joseph74f27c72021-05-16 07:58:53 -07008#include "requester/handler.hpp"
Pavithra Barithaya51efaf82020-04-02 02:42:27 -05009
George Liuc453e162022-12-21 17:16:23 +080010#include <libpldm/base.h>
11#include <libpldm/platform.h>
12
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050013#include <sdeventplus/event.hpp>
Deepak Kodihalli8cb6f662020-04-10 02:55:43 -050014#include <sdeventplus/source/event.hpp>
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050015
Deepak Kodihalli7246e0c2020-07-08 06:40:18 -050016#include <deque>
George Liu6492f522020-06-16 10:34:05 +080017#include <map>
18#include <memory>
19#include <vector>
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050020
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050021namespace pldm
22{
Deepak Kodihalli87514cc2020-04-16 09:08:38 -050023using EntityType = uint16_t;
Deepak Kodihalli8cb6f662020-04-10 02:55:43 -050024// vector which would hold the PDR record handle data returned by
25// pldmPDRRepositoryChgEvent event data
26using ChangeEntry = uint32_t;
Deepak Kodihalli7246e0c2020-07-08 06:40:18 -050027using PDRRecordHandles = std::deque<ChangeEntry>;
Deepak Kodihalli8cb6f662020-04-10 02:55:43 -050028
Tom Josephb4268602020-04-17 17:20:45 +053029/** @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 */
35struct 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
52using HostStateSensorMap = std::map<SensorEntry, pdr::SensorInfo>;
Sampa Misra868c8792020-05-26 03:12:13 -050053using PDRList = std::vector<std::vector<uint8_t>>;
Tom Josephb4268602020-04-17 17:20:45 +053054
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050055/** @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 */
64class 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
Manojkiran Eda60e1fe92021-10-08 15:58:16 +053074 using TerminusInfo =
75 std::tuple<pdr::TerminusID, pdr::EID, pdr::TerminusValidity>;
76 using TLPDRMap = std::map<pdr::TerminusHandle, TerminusInfo>;
Sampa Misra868c8792020-05-26 03:12:13 -050077
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050078 /** @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
Pavithra Barithaya3aec9972020-12-14 01:55:44 -060083 * @param[in] eventsJsonDir - directory path which has the config JSONs
Tom Joseph74f27c72021-05-16 07:58:53 -070084 * @param[in] entityTree - Pointer to BMC and Host entity association tree
85 * @param[in] bmcEntityTree - pointer to BMC's entity association tree
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050086 * @param[in] requester - reference to Requester object
Tom Joseph74f27c72021-05-16 07:58:53 -070087 * @param[in] handler - PLDM request handler
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050088 */
Tom Joseph74f27c72021-05-16 07:58:53 -070089 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,
Brad Bishop5079ac42021-08-19 18:35:06 -040093 pldm_entity_association_tree* bmcEntityTree,
94 pldm::dbus_api::Requester& requester,
Tom Josephe5268cd2021-09-07 13:04:03 +053095 pldm::requester::Handler<pldm::requester::Request>* handler);
Pavithra Barithaya51efaf82020-04-02 02:42:27 -050096
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 */
Pavithra Barithayae8beb892020-04-14 23:24:25 -0500101
Deepak Kodihalli7246e0c2020-07-08 06:40:18 -0500102 void fetchPDR(PDRRecordHandles&& recordHandles);
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500103
Pavithra Barithayae8beb892020-04-14 23:24:25 -0500104 /** @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
Tom Josephb4268602020-04-17 17:20:45 +0530113 /** @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
Pavithra Barithaya3aec9972020-12-14 01:55:44 -0600125 /** @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 */
Brad Bishop5079ac42021-08-19 18:35:06 -0400132 int handleStateSensorEvent(
133 const pldm::responder::events::StateSensorEntry& entry,
134 pdr::EventState state);
Pavithra Barithaya3aec9972020-12-14 01:55:44 -0600135
Sampa Misra868c8792020-05-26 03:12:13 -0500136 /** @brief Parse state sensor PDRs and populate the sensorMap lookup data
137 * structure
138 *
139 * @param[in] stateSensorPDRs - host state sensor PDRs
Sampa Misra868c8792020-05-26 03:12:13 -0500140 *
141 */
Manojkiran Eda60e1fe92021-10-08 15:58:16 +0530142 void parseStateSensorPDRs(const PDRList& stateSensorPDRs);
Sampa Misra868c8792020-05-26 03:12:13 -0500143
Sampa Misrac0c79482021-06-02 08:01:54 -0500144 /** @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
Sampa Misraf9ba8c12021-08-06 00:33:47 -0500151 /** @brief set the Host firmware condition when pldmd starts
sampmisr6decfc12021-03-02 11:07:36 +0530152 */
Sampa Misraf9ba8c12021-08-06 00:33:47 -0500153 void setHostFirmwareCondition();
sampmisr6decfc12021-03-02 11:07:36 +0530154
Pavithra Barithaya4f2538a2021-03-05 07:32:15 -0600155 /** @brief set HostSensorStates when pldmd starts or restarts
156 * and updates the D-Bus property
157 * @param[in] stateSensorPDRs - host state sensor PDRs
Pavithra Barithaya4f2538a2021-03-05 07:32:15 -0600158 */
Manojkiran Eda60e1fe92021-10-08 15:58:16 +0530159 void setHostSensorState(const PDRList& stateSensorPDRs);
Pavithra Barithaya4f2538a2021-03-05 07:32:15 -0600160
Pavithra Barithayaae5c97e2022-08-29 02:57:59 -0500161 /** @brief whether we received PLDM_RECORDS_MODIFIED event data operation
162 * from host
163 */
164 bool isHostPdrModified = false;
165
sampmisr6decfc12021-03-02 11:07:36 +0530166 /** @brief check whether Host is running when pldmd starts
167 */
168 bool isHostUp();
169
Manojkiran Eda60e1fe92021-10-08 15:58:16 +0530170 /** @brief map that captures various terminus information **/
171 TLPDRMap tlPDRInfo;
172
sampmisr6decfc12021-03-02 11:07:36 +0530173 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
Deepak Kodihalli87514cc2020-04-16 09:08:38 -0500180 /** @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
Sampa Misrac0c79482021-06-02 08:01:54 -0500195 /** @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
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500215 /** @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;
Pavithra Barithaya3aec9972020-12-14 01:55:44 -0600225
Brad Bishop5079ac42021-08-19 18:35:06 -0400226 pldm::responder::events::StateSensorHandler stateSensorHandler;
Sampa Misrac073a202021-05-08 10:56:05 -0500227 /** @brief Pointer to BMC's and Host's entity association tree */
Deepak Kodihalli87514cc2020-04-16 09:08:38 -0500228 pldm_entity_association_tree* entityTree;
Sampa Misrac073a202021-05-08 10:56:05 -0500229
230 /** @brief Pointer to BMC's entity association tree */
231 pldm_entity_association_tree* bmcEntityTree;
232
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500233 /** @brief reference to Requester object, primarily used to access API to
234 * obtain PLDM instance id.
235 */
Brad Bishop5079ac42021-08-19 18:35:06 -0400236 pldm::dbus_api::Requester& requester;
Tom Joseph74f27c72021-05-16 07:58:53 -0700237
238 /** @brief PLDM request handler */
Sampa Misrac0c79482021-06-02 08:01:54 -0500239 pldm::requester::Handler<pldm::requester::Request>* handler;
Tom Joseph74f27c72021-05-16 07:58:53 -0700240
Deepak Kodihalli8cb6f662020-04-10 02:55:43 -0500241 /** @brief sdeventplus event source */
242 std::unique_ptr<sdeventplus::source::Defer> pdrFetchEvent;
Sampa Misrac0c79482021-06-02 08:01:54 -0500243 std::unique_ptr<sdeventplus::source::Defer> deferredFetchPDREvent;
244 std::unique_ptr<sdeventplus::source::Defer> deferredPDRRepoChgEvent;
245
Deepak Kodihalli8cb6f662020-04-10 02:55:43 -0500246 /** @brief list of PDR record handles pointing to host's PDRs */
247 PDRRecordHandles pdrRecordHandles;
Deepak Kodihalli87514cc2020-04-16 09:08:38 -0500248 /** @brief maps an entity type to parent pldm_entity from the BMC's entity
249 * association tree
250 */
Pavithra Barithayaae5c97e2022-08-29 02:57:59 -0500251
252 /** @brief list of PDR record handles modified pointing to host PDRs */
253 PDRRecordHandles modifiedPDRRecordHandles;
254
Deepak Kodihalli87514cc2020-04-16 09:08:38 -0500255 std::map<EntityType, pldm_entity> parents;
Deepak Kodihalli6b1d1ca2020-04-27 07:24:51 -0500256 /** @brief D-Bus property changed signal match */
Patrick Williams84b790c2022-07-22 19:26:56 -0500257 std::unique_ptr<sdbusplus::bus::match_t> hostOffMatch;
Tom Josephb4268602020-04-17 17:20:45 +0530258
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;
sampmisr6decfc12021-03-02 11:07:36 +0530264
265 /** @brief whether response received from Host */
266 bool responseReceived;
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500267};
268
269} // namespace pldm