xref: /openbmc/pldm/pldmd/pldmd.cpp (revision 3012b632)
1 
2 #include "common/flight_recorder.hpp"
3 #include "common/instance_id.hpp"
4 #include "common/transport.hpp"
5 #include "common/utils.hpp"
6 #include "dbus_impl_requester.hpp"
7 #include "fw-update/manager.hpp"
8 #include "invoker.hpp"
9 #include "platform-mc/manager.hpp"
10 #include "requester/handler.hpp"
11 #include "requester/mctp_endpoint_discovery.hpp"
12 #include "requester/request.hpp"
13 
14 #include <err.h>
15 #include <getopt.h>
16 #include <libpldm/base.h>
17 #include <libpldm/bios.h>
18 #include <libpldm/pdr.h>
19 #include <libpldm/platform.h>
20 #include <libpldm/transport.h>
21 #include <poll.h>
22 #include <stdlib.h>
23 #include <sys/socket.h>
24 #include <sys/types.h>
25 #include <sys/un.h>
26 #include <unistd.h>
27 
28 #include <phosphor-logging/lg2.hpp>
29 #include <sdeventplus/event.hpp>
30 #include <sdeventplus/source/io.hpp>
31 #include <sdeventplus/source/signal.hpp>
32 #include <stdplus/signal.hpp>
33 
34 #include <cstdio>
35 #include <cstring>
36 #include <fstream>
37 #include <iomanip>
38 #include <iterator>
39 #include <memory>
40 #include <ranges>
41 #include <sstream>
42 #include <stdexcept>
43 #include <string>
44 #include <vector>
45 
46 PHOSPHOR_LOG2_USING;
47 
48 #ifdef LIBPLDMRESPONDER
49 #include "dbus_impl_pdr.hpp"
50 #include "host-bmc/dbus_to_event_handler.hpp"
51 #include "host-bmc/dbus_to_host_effecters.hpp"
52 #include "host-bmc/host_condition.hpp"
53 #include "host-bmc/host_pdr_handler.hpp"
54 #include "libpldmresponder/base.hpp"
55 #include "libpldmresponder/bios.hpp"
56 #include "libpldmresponder/fru.hpp"
57 #include "libpldmresponder/oem_handler.hpp"
58 #include "libpldmresponder/platform.hpp"
59 #include "libpldmresponder/platform_config.hpp"
60 #include "xyz/openbmc_project/PLDM/Event/server.hpp"
61 #endif
62 
63 #ifdef OEM_IBM
64 #include "oem_ibm.hpp"
65 #endif
66 
67 constexpr const char* PLDMService = "xyz.openbmc_project.PLDM";
68 
69 using namespace pldm;
70 using namespace sdeventplus;
71 using namespace sdeventplus::source;
72 using namespace pldm::responder;
73 using namespace pldm::utils;
74 using sdeventplus::source::Signal;
75 using namespace pldm::flightrecorder;
76 
77 void interruptFlightRecorderCallBack(Signal& /*signal*/,
78                                      const struct signalfd_siginfo*)
79 {
80     error("Received SIGUR1(10) Signal interrupt");
81     // obtain the flight recorder instance and dump the recorder
82     FlightRecorder::GetInstance().playRecorder();
83 }
84 
85 void requestPLDMServiceName()
86 {
87     try
88     {
89         auto& bus = pldm::utils::DBusHandler::getBus();
90         bus.request_name(PLDMService);
91     }
92     catch (const sdbusplus::exception_t& e)
93     {
94         error("Failed to request D-Bus name {NAME} with error {ERROR}.", "NAME",
95               PLDMService, "ERROR", e);
96     }
97 }
98 
99 static std::optional<Response>
100     processRxMsg(const std::vector<uint8_t>& requestMsg, Invoker& invoker,
101                  requester::Handler<requester::Request>& handler,
102                  fw_update::Manager* fwManager, pldm_tid_t tid)
103 {
104     uint8_t eid = tid;
105 
106     pldm_header_info hdrFields{};
107     auto hdr = reinterpret_cast<const pldm_msg_hdr*>(requestMsg.data());
108     if (PLDM_SUCCESS != unpack_pldm_header(hdr, &hdrFields))
109     {
110         error("Empty PLDM request header");
111         return std::nullopt;
112     }
113 
114     if (PLDM_RESPONSE != hdrFields.msg_type)
115     {
116         Response response;
117         auto request = reinterpret_cast<const pldm_msg*>(hdr);
118         size_t requestLen = requestMsg.size() - sizeof(struct pldm_msg_hdr);
119         try
120         {
121             if (hdrFields.pldm_type != PLDM_FWUP)
122             {
123                 response =
124                     invoker.handle(tid, hdrFields.pldm_type, hdrFields.command,
125                                    request, requestLen);
126             }
127             else
128             {
129                 response = fwManager->handleRequest(eid, hdrFields.command,
130                                                     request, requestLen);
131             }
132         }
133         catch (const std::out_of_range& e)
134         {
135             uint8_t completion_code = PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
136             response.resize(sizeof(pldm_msg_hdr));
137             auto responseHdr = reinterpret_cast<pldm_msg_hdr*>(response.data());
138             pldm_header_info header{};
139             header.msg_type = PLDM_RESPONSE;
140             header.instance = hdrFields.instance;
141             header.pldm_type = hdrFields.pldm_type;
142             header.command = hdrFields.command;
143             if (PLDM_SUCCESS != pack_pldm_header(&header, responseHdr))
144             {
145                 error(
146                     "Failed to add response header for processing Rx, error - {ERROR}",
147                     "ERROR", e);
148                 return std::nullopt;
149             }
150             response.insert(response.end(), completion_code);
151         }
152         return response;
153     }
154     else if (PLDM_RESPONSE == hdrFields.msg_type)
155     {
156         auto response = reinterpret_cast<const pldm_msg*>(hdr);
157         size_t responseLen = requestMsg.size() - sizeof(struct pldm_msg_hdr);
158         handler.handleResponse(eid, hdrFields.instance, hdrFields.pldm_type,
159                                hdrFields.command, response, responseLen);
160     }
161     return std::nullopt;
162 }
163 
164 void optionUsage(void)
165 {
166     info("Usage: pldmd [options]");
167     info("Options:");
168     info(" [--verbose] - would enable verbosity");
169 }
170 
171 int main(int argc, char** argv)
172 {
173     bool verbose = false;
174     static struct option long_options[] = {{"verbose", no_argument, 0, 'v'},
175                                            {0, 0, 0, 0}};
176 
177     auto argflag = getopt_long(argc, argv, "v", long_options, nullptr);
178     switch (argflag)
179     {
180         case 'v':
181             verbose = true;
182             break;
183         case -1:
184             break;
185         default:
186             optionUsage();
187             exit(EXIT_FAILURE);
188     }
189     // Setup PLDM requester transport
190     auto hostEID = pldm::utils::readHostEID();
191     /* To maintain current behaviour until we have the infrastructure to find
192      * and use the correct TIDs */
193     pldm_tid_t TID = hostEID;
194     PldmTransport pldmTransport{};
195     auto event = Event::get_default();
196     auto& bus = pldm::utils::DBusHandler::getBus();
197     sdbusplus::server::manager_t objManager(bus,
198                                             "/xyz/openbmc_project/software");
199     sdbusplus::server::manager_t sensorObjManager(
200         bus, "/xyz/openbmc_project/sensors");
201 
202     InstanceIdDb instanceIdDb;
203     dbus_api::Requester dbusImplReq(bus, "/xyz/openbmc_project/pldm",
204                                     instanceIdDb);
205     sdbusplus::server::manager_t inventoryManager(
206         bus, "/xyz/openbmc_project/inventory");
207 
208     Invoker invoker{};
209     requester::Handler<requester::Request> reqHandler(&pldmTransport, event,
210                                                       instanceIdDb, verbose);
211 
212 #ifdef LIBPLDMRESPONDER
213     using namespace pldm::state_sensor;
214     dbus_api::Host dbusImplHost(bus, "/xyz/openbmc_project/pldm");
215     std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> pdrRepo(
216         pldm_pdr_init(), pldm_pdr_destroy);
217     if (!pdrRepo)
218     {
219         throw std::runtime_error("Failed to instantiate PDR repository");
220     }
221     std::unique_ptr<pldm_entity_association_tree,
222                     decltype(&pldm_entity_association_tree_destroy)>
223         entityTree(pldm_entity_association_tree_init(),
224                    pldm_entity_association_tree_destroy);
225     if (!entityTree)
226     {
227         throw std::runtime_error(
228             "Failed to instantiate general PDR entity association tree");
229     }
230     std::unique_ptr<pldm_entity_association_tree,
231                     decltype(&pldm_entity_association_tree_destroy)>
232         bmcEntityTree(pldm_entity_association_tree_init(),
233                       pldm_entity_association_tree_destroy);
234     if (!bmcEntityTree)
235     {
236         throw std::runtime_error(
237             "Failed to instantiate BMC PDR entity association tree");
238     }
239     std::shared_ptr<HostPDRHandler> hostPDRHandler;
240     std::unique_ptr<pldm::host_effecters::HostEffecterParser>
241         hostEffecterParser;
242     std::unique_ptr<DbusToPLDMEvent> dbusToPLDMEventHandler;
243     DBusHandler dbusHandler;
244     std::unique_ptr<platform_config::Handler> platformConfigHandler{};
245     platformConfigHandler =
246         std::make_unique<platform_config::Handler>(PDR_JSONS_DIR);
247 
248     if (hostEID)
249     {
250         hostPDRHandler = std::make_shared<HostPDRHandler>(
251             pldmTransport.getEventSource(), hostEID, event, pdrRepo.get(),
252             EVENTS_JSONS_DIR, entityTree.get(), bmcEntityTree.get(),
253             instanceIdDb, &reqHandler);
254 
255         // HostFirmware interface needs access to hostPDR to know if host
256         // is running
257         dbusImplHost.setHostPdrObj(hostPDRHandler);
258 
259         hostEffecterParser =
260             std::make_unique<pldm::host_effecters::HostEffecterParser>(
261                 &instanceIdDb, pldmTransport.getEventSource(), pdrRepo.get(),
262                 &dbusHandler, HOST_JSONS_DIR, &reqHandler);
263         dbusToPLDMEventHandler = std::make_unique<DbusToPLDMEvent>(
264             pldmTransport.getEventSource(), hostEID, instanceIdDb, &reqHandler);
265     }
266 
267     auto fruHandler = std::make_unique<fru::Handler>(
268         FRU_JSONS_DIR, FRU_MASTER_JSON, pdrRepo.get(), entityTree.get(),
269         bmcEntityTree.get());
270 
271     // FRU table is built lazily when a FRU command or Get PDR command is
272     // handled. To enable building FRU table, the FRU handler is passed to the
273     // Platform handler.
274     auto platformHandler = std::make_unique<platform::Handler>(
275         &dbusHandler, hostEID, &instanceIdDb, PDR_JSONS_DIR, pdrRepo.get(),
276         hostPDRHandler.get(), dbusToPLDMEventHandler.get(), fruHandler.get(),
277         platformConfigHandler.get(), &reqHandler, event, true);
278 
279     auto biosHandler = std::make_unique<bios::Handler>(
280         pldmTransport.getEventSource(), hostEID, &instanceIdDb, &reqHandler,
281         platformConfigHandler.get(), requestPLDMServiceName);
282 
283     auto baseHandler = std::make_unique<base::Handler>(event);
284 
285 #ifdef OEM_IBM
286     pldm::oem_ibm::OemIBM oemIBM(
287         &dbusHandler, pldmTransport.getEventSource(), hostEID, pdrRepo.get(),
288         instanceIdDb, event, invoker, hostPDRHandler.get(),
289         platformHandler.get(), fruHandler.get(), baseHandler.get(),
290         &reqHandler);
291 #endif
292 
293     invoker.registerHandler(PLDM_BIOS, std::move(biosHandler));
294     invoker.registerHandler(PLDM_PLATFORM, std::move(platformHandler));
295     invoker.registerHandler(PLDM_FRU, std::move(fruHandler));
296     invoker.registerHandler(PLDM_BASE, std::move(baseHandler));
297 
298     dbus_api::Pdr dbusImplPdr(bus, "/xyz/openbmc_project/pldm", pdrRepo.get());
299     sdbusplus::xyz::openbmc_project::PLDM::server::Event dbusImplEvent(
300         bus, "/xyz/openbmc_project/pldm");
301 
302 #endif
303 
304     std::unique_ptr<fw_update::Manager> fwManager =
305         std::make_unique<fw_update::Manager>(event, reqHandler, instanceIdDb);
306     std::unique_ptr<platform_mc::Manager> platformManager =
307         std::make_unique<platform_mc::Manager>(event, reqHandler, instanceIdDb);
308     std::unique_ptr<MctpDiscovery> mctpDiscoveryHandler =
309         std::make_unique<MctpDiscovery>(
310             bus, std::initializer_list<MctpDiscoveryHandlerIntf*>{
311                      fwManager.get(), platformManager.get()});
312     auto callback = [verbose, &invoker, &reqHandler, &fwManager, &pldmTransport,
313                      TID](IO& io, int fd, uint32_t revents) mutable {
314         if (!(revents & EPOLLIN))
315         {
316             return;
317         }
318         if (fd < 0)
319         {
320             return;
321         }
322 
323         int returnCode = 0;
324         void* requestMsg;
325         size_t recvDataLength;
326         returnCode = pldmTransport.recvMsg(TID, requestMsg, recvDataLength);
327 
328         if (returnCode == PLDM_REQUESTER_SUCCESS)
329         {
330             std::vector<uint8_t> requestMsgVec(
331                 static_cast<uint8_t*>(requestMsg),
332                 static_cast<uint8_t*>(requestMsg) + recvDataLength);
333             FlightRecorder::GetInstance().saveRecord(requestMsgVec, false);
334             if (verbose)
335             {
336                 printBuffer(Rx, requestMsgVec);
337             }
338             // process message and send response
339             auto response = processRxMsg(requestMsgVec, invoker, reqHandler,
340                                          fwManager.get(), TID);
341             if (response.has_value())
342             {
343                 FlightRecorder::GetInstance().saveRecord(*response, true);
344                 if (verbose)
345                 {
346                     printBuffer(Tx, *response);
347                 }
348 
349                 returnCode = pldmTransport.sendMsg(TID, (*response).data(),
350                                                    (*response).size());
351                 if (returnCode != PLDM_REQUESTER_SUCCESS)
352                 {
353                     warning(
354                         "Failed to send pldmTransport message for TID '{TID}', response code '{RETURN_CODE}'",
355                         "TID", TID, "RETURN_CODE", returnCode);
356                 }
357             }
358         }
359         // TODO check that we get here if mctp-demux dies?
360         else if (returnCode == PLDM_REQUESTER_RECV_FAIL)
361         {
362             // MCTP daemon has closed the socket this daemon is connected to.
363             // This may or may not be an error scenario, in either case the
364             // recovery mechanism for this daemon is to restart, and hence exit
365             // the event loop, that will cause this daemon to exit with a
366             // failure code.
367             error(
368                 "MCTP daemon closed the socket, IO exiting with response code '{RC}'",
369                 "RC", returnCode);
370             io.get_event().exit(0);
371         }
372         else
373         {
374             warning(
375                 "Failed to receive PLDM request for pldmTransport, response code '{RETURN_CODE}'",
376                 "RETURN_CODE", returnCode);
377         }
378         /* Free requestMsg after using */
379         free(requestMsg);
380     };
381 
382     bus.attach_event(event.get(), SD_EVENT_PRIORITY_NORMAL);
383 #ifndef SYSTEM_SPECIFIC_BIOS_JSON
384     try
385     {
386         bus.request_name(PLDMService);
387     }
388     catch (const sdbusplus::exception_t& e)
389     {
390         error("Failed to request D-Bus name {NAME} with error {ERROR}.", "NAME",
391               PLDMService, "ERROR", e);
392     }
393 #endif
394     IO io(event, pldmTransport.getEventSource(), EPOLLIN, std::move(callback));
395 #ifdef LIBPLDMRESPONDER
396     if (hostPDRHandler)
397     {
398         hostPDRHandler->setHostFirmwareCondition();
399     }
400 #endif
401     stdplus::signal::block(SIGUSR1);
402     sdeventplus::source::Signal sigUsr1(
403         event, SIGUSR1, std::bind_front(&interruptFlightRecorderCallBack));
404     int returnCode = event.loop();
405     if (returnCode)
406     {
407         exit(EXIT_FAILURE);
408     }
409 
410     exit(EXIT_SUCCESS);
411 }
412