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