1 #pragma once 2 3 #include "common/utils.hpp" 4 #include "oem/ibm/requester/dbus_to_file_handler.hpp" 5 #include "oem_ibm_handler.hpp" 6 #include "pldmd/handler.hpp" 7 #include "requester/handler.hpp" 8 9 #include <fcntl.h> 10 #include <libpldm/base.h> 11 #include <libpldm/oem/ibm/file_io.h> 12 #include <libpldm/oem/ibm/host.h> 13 #include <sys/stat.h> 14 #include <sys/types.h> 15 #include <unistd.h> 16 17 #include <phosphor-logging/lg2.hpp> 18 19 #include <cstdint> 20 #include <filesystem> 21 #include <iostream> 22 #include <vector> 23 24 PHOSPHOR_LOG2_USING; 25 26 namespace pldm 27 { 28 namespace responder 29 { 30 namespace dma 31 { 32 // The minimum data size of dma transfer in bytes 33 constexpr uint32_t minSize = 16; 34 35 constexpr size_t maxSize = DMA_MAXSIZE; 36 37 namespace fs = std::filesystem; 38 39 /** 40 * @class DMA 41 * 42 * Expose API to initiate transfer of data by DMA 43 * 44 * This class only exposes the public API transferDataHost to transfer data 45 * between BMC and host using DMA. This allows for mocking the transferDataHost 46 * for unit testing purposes. 47 */ 48 class DMA 49 { 50 public: 51 /** @brief API to transfer data between BMC and host using DMA 52 * 53 * @param[in] path - pathname of the file to transfer data from or to 54 * @param[in] offset - offset in the file 55 * @param[in] length - length of the data to transfer 56 * @param[in] address - DMA address on the host 57 * @param[in] upstream - indicates direction of the transfer; true indicates 58 * transfer to the host 59 * 60 * @return returns 0 on success, negative errno on failure 61 */ 62 int transferDataHost(int fd, uint32_t offset, uint32_t length, 63 uint64_t address, bool upstream); 64 65 /** @brief API to transfer data on to unix socket from host using DMA 66 * 67 * @param[in] path - pathname of the file to transfer data from or to 68 * @param[in] length - length of the data to transfer 69 * @param[in] address - DMA address on the host 70 * 71 * @return returns 0 on success, negative errno on failure 72 */ 73 int transferHostDataToSocket(int fd, uint32_t length, uint64_t address); 74 }; 75 76 /** @brief Transfer the data between BMC and host using DMA. 77 * 78 * There is a max size for each DMA operation, transferAll API abstracts this 79 * and the requested length is broken down into multiple DMA operations if the 80 * length exceed max size. 81 * 82 * @tparam[in] T - DMA interface type 83 * @param[in] intf - interface passed to invoke DMA transfer 84 * @param[in] command - PLDM command 85 * @param[in] path - pathname of the file to transfer data from or to 86 * @param[in] offset - offset in the file 87 * @param[in] length - length of the data to transfer 88 * @param[in] address - DMA address on the host 89 * @param[in] upstream - indicates direction of the transfer; true indicates 90 * transfer to the host 91 * @param[in] instanceId - Message's instance id 92 * @return PLDM response message 93 */ 94 95 template <class DMAInterface> transferAll(DMAInterface * intf,uint8_t command,fs::path & path,uint32_t offset,uint32_t length,uint64_t address,bool upstream,uint8_t instanceId)96 Response transferAll(DMAInterface* intf, uint8_t command, fs::path& path, 97 uint32_t offset, uint32_t length, uint64_t address, 98 bool upstream, uint8_t instanceId) 99 { 100 uint32_t origLength = length; 101 Response response(sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES, 0); 102 auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); 103 104 int flags{}; 105 if (upstream) 106 { 107 flags = O_RDONLY; 108 } 109 else if (fs::exists(path)) 110 { 111 flags = O_RDWR; 112 } 113 else 114 { 115 flags = O_WRONLY; 116 } 117 int file = open(path.string().c_str(), flags); 118 if (file == -1) 119 { 120 error("File at path '{PATH}' does not exist", "PATH", path); 121 encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0, 122 responsePtr); 123 return response; 124 } 125 pldm::utils::CustomFD fd(file); 126 127 while (length > dma::maxSize) 128 { 129 auto rc = intf->transferDataHost(fd(), offset, dma::maxSize, address, 130 upstream); 131 if (rc < 0) 132 { 133 encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0, 134 responsePtr); 135 return response; 136 } 137 138 offset += dma::maxSize; 139 length -= dma::maxSize; 140 address += dma::maxSize; 141 } 142 143 auto rc = intf->transferDataHost(fd(), offset, length, address, upstream); 144 if (rc < 0) 145 { 146 encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0, 147 responsePtr); 148 return response; 149 } 150 151 encode_rw_file_memory_resp(instanceId, command, PLDM_SUCCESS, origLength, 152 responsePtr); 153 return response; 154 } 155 156 } // namespace dma 157 158 namespace oem_ibm 159 { 160 static constexpr auto dumpObjPath = "/xyz/openbmc_project/dump/resource/entry/"; 161 static constexpr auto resDumpEntry = "com.ibm.Dump.Entry.Resource"; 162 163 static constexpr auto certObjPath = "/xyz/openbmc_project/certs/ca/"; 164 static constexpr auto certAuthority = 165 "xyz.openbmc_project.PLDM.Provider.Certs.Authority.CSR"; 166 class Handler : public CmdHandler 167 { 168 public: Handler(oem_platform::Handler * oemPlatformHandler,int hostSockFd,uint8_t hostEid,pldm::InstanceIdDb * instanceIdDb,pldm::requester::Handler<pldm::requester::Request> * handler)169 Handler(oem_platform::Handler* oemPlatformHandler, int hostSockFd, 170 uint8_t hostEid, pldm::InstanceIdDb* instanceIdDb, 171 pldm::requester::Handler<pldm::requester::Request>* handler) : 172 oemPlatformHandler(oemPlatformHandler) 173 { 174 handlers.emplace( 175 PLDM_READ_FILE_INTO_MEMORY, 176 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 177 return this->readFileIntoMemory(request, payloadLength); 178 }); 179 handlers.emplace( 180 PLDM_WRITE_FILE_FROM_MEMORY, 181 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 182 return this->writeFileFromMemory(request, payloadLength); 183 }); 184 handlers.emplace( 185 PLDM_WRITE_FILE_BY_TYPE_FROM_MEMORY, 186 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 187 return this->writeFileByTypeFromMemory(request, payloadLength); 188 }); 189 handlers.emplace( 190 PLDM_READ_FILE_BY_TYPE_INTO_MEMORY, 191 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 192 return this->readFileByTypeIntoMemory(request, payloadLength); 193 }); 194 handlers.emplace( 195 PLDM_READ_FILE_BY_TYPE, 196 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 197 return this->readFileByType(request, payloadLength); 198 }); 199 handlers.emplace( 200 PLDM_WRITE_FILE_BY_TYPE, 201 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 202 return this->writeFileByType(request, payloadLength); 203 }); 204 handlers.emplace( 205 PLDM_GET_FILE_TABLE, 206 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 207 return this->getFileTable(request, payloadLength); 208 }); 209 handlers.emplace( 210 PLDM_READ_FILE, 211 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 212 return this->readFile(request, payloadLength); 213 }); 214 handlers.emplace( 215 PLDM_WRITE_FILE, 216 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 217 return this->writeFile(request, payloadLength); 218 }); 219 handlers.emplace( 220 PLDM_FILE_ACK, 221 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 222 return this->fileAck(request, payloadLength); 223 }); 224 handlers.emplace( 225 PLDM_HOST_GET_ALERT_STATUS, 226 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 227 return this->getAlertStatus(request, payloadLength); 228 }); 229 handlers.emplace( 230 PLDM_NEW_FILE_AVAILABLE, 231 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 232 return this->newFileAvailable(request, payloadLength); 233 }); 234 handlers.emplace( 235 PLDM_FILE_ACK_WITH_META_DATA, 236 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 237 return this->fileAckWithMetaData(request, payloadLength); 238 }); 239 handlers.emplace( 240 PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA, 241 [this](pldm_tid_t, const pldm_msg* request, size_t payloadLength) { 242 return this->newFileAvailableWithMetaData(request, 243 payloadLength); 244 }); 245 246 resDumpMatcher = std::make_unique<sdbusplus::bus::match_t>( 247 pldm::utils::DBusHandler::getBus(), 248 sdbusplus::bus::match::rules::interfacesAdded() + 249 sdbusplus::bus::match::rules::argNpath(0, dumpObjPath), 250 [this, hostSockFd, hostEid, instanceIdDb, 251 handler](sdbusplus::message_t& msg) { 252 std::map< 253 std::string, 254 std::map<std::string, std::variant<std::string, uint32_t>>> 255 interfaces; 256 sdbusplus::message::object_path path; 257 msg.read(path, interfaces); 258 std::string vspstring; 259 std::string password; 260 261 for (const auto& interface : interfaces) 262 { 263 if (interface.first == resDumpEntry) 264 { 265 for (const auto& property : interface.second) 266 { 267 if (property.first == "VSPString") 268 { 269 vspstring = 270 std::get<std::string>(property.second); 271 } 272 else if (property.first == "Password") 273 { 274 password = 275 std::get<std::string>(property.second); 276 } 277 } 278 dbusToFileHandlers 279 .emplace_back( 280 std::make_unique<pldm::requester::oem_ibm:: 281 DbusToFileHandler>( 282 hostSockFd, hostEid, instanceIdDb, path, 283 handler)) 284 ->processNewResourceDump(vspstring, password); 285 break; 286 } 287 } 288 }); 289 vmiCertMatcher = std::make_unique<sdbusplus::bus::match_t>( 290 pldm::utils::DBusHandler::getBus(), 291 sdbusplus::bus::match::rules::interfacesAdded() + 292 sdbusplus::bus::match::rules::argNpath(0, certObjPath), 293 [this, hostSockFd, hostEid, instanceIdDb, 294 handler](sdbusplus::message_t& msg) { 295 std::map< 296 std::string, 297 std::map<std::string, std::variant<std::string, uint32_t>>> 298 interfaces; 299 sdbusplus::message::object_path path; 300 msg.read(path, interfaces); 301 std::string csr; 302 303 for (const auto& interface : interfaces) 304 { 305 if (interface.first == certAuthority) 306 { 307 for (const auto& property : interface.second) 308 { 309 if (property.first == "CSR") 310 { 311 csr = std::get<std::string>(property.second); 312 auto fileHandle = 313 sdbusplus::message::object_path(path) 314 .filename(); 315 316 dbusToFileHandlers 317 .emplace_back(std::make_unique< 318 pldm::requester::oem_ibm:: 319 DbusToFileHandler>( 320 hostSockFd, hostEid, instanceIdDb, path, 321 handler)) 322 ->newCsrFileAvailable(csr, fileHandle); 323 break; 324 } 325 } 326 break; 327 } 328 } 329 }); 330 } 331 332 /** @brief Handler for readFileIntoMemory command 333 * 334 * @param[in] request - pointer to PLDM request payload 335 * @param[in] payloadLength - length of the message 336 * 337 * @return PLDM response message 338 */ 339 Response readFileIntoMemory(const pldm_msg* request, size_t payloadLength); 340 341 /** @brief Handler for writeFileIntoMemory command 342 * 343 * @param[in] request - pointer to PLDM request payload 344 * @param[in] payloadLength - length of the message 345 * 346 * @return PLDM response message 347 */ 348 Response writeFileFromMemory(const pldm_msg* request, size_t payloadLength); 349 350 /** @brief Handler for writeFileByTypeFromMemory command 351 * 352 * @param[in] request - pointer to PLDM request payload 353 * @param[in] payloadLength - length of the message 354 * 355 * @return PLDM response message 356 */ 357 358 Response writeFileByTypeFromMemory(const pldm_msg* request, 359 size_t payloadLength); 360 361 /** @brief Handler for readFileByTypeIntoMemory command 362 * 363 * @param[in] request - pointer to PLDM request payload 364 * @param[in] payloadLength - length of the message 365 * 366 * @return PLDM response message 367 */ 368 Response readFileByTypeIntoMemory(const pldm_msg* request, 369 size_t payloadLength); 370 371 /** @brief Handler for writeFileByType command 372 * 373 * @param[in] request - pointer to PLDM request payload 374 * @param[in] payloadLength - length of the message 375 * 376 * @return PLDM response message 377 */ 378 Response readFileByType(const pldm_msg* request, size_t payloadLength); 379 380 Response writeFileByType(const pldm_msg* request, size_t payloadLength); 381 382 /** @brief Handler for GetFileTable command 383 * 384 * @param[in] request - pointer to PLDM request payload 385 * @param[in] payloadLength - length of the message payload 386 * 387 * @return PLDM response message 388 */ 389 Response getFileTable(const pldm_msg* request, size_t payloadLength); 390 391 /** @brief Handler for readFile command 392 * 393 * @param[in] request - PLDM request msg 394 * @param[in] payloadLength - length of the message payload 395 * 396 * @return PLDM response message 397 */ 398 Response readFile(const pldm_msg* request, size_t payloadLength); 399 400 /** @brief Handler for writeFile command 401 * 402 * @param[in] request - PLDM request msg 403 * @param[in] payloadLength - length of the message payload 404 * 405 * @return PLDM response message 406 */ 407 Response writeFile(const pldm_msg* request, size_t payloadLength); 408 409 Response fileAck(const pldm_msg* request, size_t payloadLength); 410 411 /** @brief Handler for getAlertStatus command 412 * 413 * @param[in] request - PLDM request msg 414 * @param[in] payloadLength - length of the message payload 415 * 416 * @return PLDM response message 417 */ 418 Response getAlertStatus(const pldm_msg* request, size_t payloadLength); 419 420 /** @brief Handler for newFileAvailable command 421 * 422 * @param[in] request - PLDM request msg 423 * @param[in] payloadLength - length of the message payload 424 * 425 * @return PLDM response message 426 */ 427 Response newFileAvailable(const pldm_msg* request, size_t payloadLength); 428 429 /** @brief Handler for fileAckWithMetaData command 430 * 431 * @param[in] request - PLDM request msg 432 * @param[in] payloadLength - length of the message payload 433 * 434 * @return PLDM response message 435 */ 436 Response fileAckWithMetaData(const pldm_msg* request, size_t payloadLength); 437 438 /** @brief Handler for newFileAvailableWithMetaData command 439 * 440 * @param[in] request - PLDM request msg 441 * @param[in] payloadLength - length of the message payload 442 * 443 * @return PLDM response messsage 444 */ 445 Response newFileAvailableWithMetaData(const pldm_msg* request, 446 size_t payloadLength); 447 448 private: 449 oem_platform::Handler* oemPlatformHandler; 450 using DBusInterfaceAdded = std::vector<std::pair< 451 std::string, 452 std::vector<std::pair<std::string, std::variant<std::string>>>>>; 453 std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler> 454 dbusToFileHandler; //!< pointer to send request to Host 455 std::unique_ptr<sdbusplus::bus::match_t> 456 resDumpMatcher; //!< Pointer to capture the interface added signal 457 //!< for new resource dump 458 std::unique_ptr<sdbusplus::bus::match_t> 459 vmiCertMatcher; //!< Pointer to capture the interface added signal 460 //!< for new csr string 461 /** @brief PLDM request handler */ 462 std::vector<std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>> 463 dbusToFileHandlers; 464 }; 465 466 } // namespace oem_ibm 467 } // namespace responder 468 } // namespace pldm 469