Adding support for asynchronous file transfer

- File transfer between BMC and Host is synchronous mechanism.
- File transfer interrupted because of many reasons, so if
  file transfer interrupted between BMC and Host then PLDM is
  ending up in the hung state and not able to respond to the
  upcoming new requests. User has to do work around to restart
  the PLDM to get work again.
- I have added asynchronous file transfer support using
  eventloop mechanism and non-blocking socket communication,
  so file transfer will be taken care by event loop and PLDM
  is free to receive another request from the Host.
- If file transfer will be stuck or interrupted during
  asynchronous transfer then time-out occurs and file transfer
  will be aborted and same status communicated to the Host.

Signed-off-by: Kamalkumar Patel <[email protected]>

Author: Patel-Kamalkumar

oem/ibm/libpldmresponder/file_io.cpp

@@ -1,13 +1,34 @@
 #pragma once
 
+#include "libpldm/file_io.h"
+
 #include "oem_ibm_handler.hpp"
 #include "pldmd/pldm_resp_interface.hpp"
 
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server.hpp>
+#include <sdbusplus/server/object.hpp>
+#include <sdbusplus/timer.hpp>
+#include <sdeventplus/clock.hpp>
+#include <sdeventplus/event.hpp>
+#include <sdeventplus/exception.hpp>
+#include <sdeventplus/source/io.hpp>
+#include <sdeventplus/source/signal.hpp>
+#include <sdeventplus/source/time.hpp>
+#include <stdplus/signal.hpp>
+#include <xyz/openbmc_project/Logging/Entry/server.hpp>
+
+#include <vector>
 namespace pldm
 {
 
 namespace responder
 {
+using namespace sdeventplus;
+using namespace sdeventplus::source;
+constexpr auto clockId = sdeventplus::ClockId::RealTime;
+using Timer = Time<clockId>;
+using Clock = Clock<clockId>;
 
 class FileHandler;
 namespace dma
@@ -33,6 +54,34 @@ namespace fs = std::filesystem;
  */
 class FileHandler
 {
+  protected:
+    /** @brief method to send response to host after completion of DMA operation
+     * @param[in] responseHdr - contain response related data
+     * @param[in] rStatus - operation status either success/fail/not suppoted.
+     * @param[in] length - length to be read/write mentioned by Host
+     */
+    virtual void dmaResponseToHost(const ResponseHdr& responseHdr,
+                                   const pldm_completion_codes rStatus,
+                                   uint32_t length);
+
+    /** @brief method to send response to host after completion of DMA operation
+     * @param[in] responseHdr - contain response related data
+     * @param[in] rStatus - operation status either success/fail/not suppoted.
+     * @param[in] length - length to be read/write mentioned by Host
+     */
+    virtual void dmaResponseToHost(const ResponseHdr& responseHdr,
+                                   const pldm_fileio_completion_codes rStatus,
+                                   uint32_t length);
+
+    /** @brief method to delete all shared pointer object
+     * @param[in] responseHdr - contain response related data
+     * @param[in] xdmaInterface - interface to transfer data between BMc and
+     * Host
+     */
+    virtual void
+        deleteAIOobjects(const std::shared_ptr<dma::DMA>& xdmaInterface,
+                         const ResponseHdr& responseHdr);
+
   public:
     /** @brief Method to write an oem file type from host memory. Individual
      *  file types need to override this method to do the file specific
@@ -44,9 +93,11 @@ class FileHandler
      *                                  tasks
      *  @return PLDM status code
      */
-    virtual int writeFromMemory(uint32_t offset, uint32_t length,
-                                uint64_t address,
-                                oem_platform::Handler* oemPlatformHandler) = 0;
+    virtual void writeFromMemory(uint32_t offset, uint32_t length,
+                                 uint64_t address,
+                                 oem_platform::Handler* oemPlatformHandler,
+                                 ResponseHdr& responseHdr,
+                                 sdeventplus::Event& event) = 0;
 
     /** @brief Method to read an oem file type into host memory. Individual
      *  file types need to override this method to do the file specific
@@ -58,9 +109,11 @@ class FileHandler
      *                                  tasks
      *  @return PLDM status code
      */
-    virtual int readIntoMemory(uint32_t offset, uint32_t& length,
-                               uint64_t address,
-                               oem_platform::Handler* oemPlatformHandler) = 0;
+    virtual void readIntoMemory(uint32_t offset, uint32_t& length,
+                                uint64_t address,
+                                oem_platform::Handler* oemPlatformHandler,
+                                ResponseHdr& responseHdr,
+                                sdeventplus::Event& event) = 0;
 
     /** @brief Method to read an oem file type's content into the PLDM response.
      *  @param[in] offset - offset to read
@@ -151,15 +204,28 @@ class FileHandler
      *
      *  @return PLDM status code
      */
-    virtual int transferFileData(const fs::path& path, bool upstream,
-                                 uint32_t offset, uint32_t& length,
-                                 uint64_t address);
+    virtual void transferFileData(const fs::path& path, bool upstream,
+                                  uint32_t offset, uint32_t& length,
+                                  uint64_t address, ResponseHdr& responseHdr,
+                                  sdeventplus::Event& event);
 
-    virtual int transferFileData(int fd, bool upstream, uint32_t offset,
-                                 uint32_t& length, uint64_t address);
+    virtual void transferFileData(int fd, bool upstream, uint32_t offset,
+                                  uint32_t& length, uint64_t address,
+                                  ResponseHdr& responseHdr,
+                                  sdeventplus::Event& event);
 
-    virtual int transferFileDataToSocket(int fd, uint32_t& length,
-                                         uint64_t address);
+    virtual void transferFileDataToSocket(int fd, uint32_t& length,
+                                          uint64_t address,
+                                          ResponseHdr& responseHdr,
+                                          sdeventplus::Event& event);
+
+    /** @brief method to do necessary operation according different
+     *  file type and being call when data transfer completed.
+     *
+     *  @param[in] IsWriteToMemOp - type of operation to decide what operation
+     * needs to be done after data transfer.
+     */
+    virtual void postDataTransferCallBack(bool IsWriteToMemOp) = 0;
 
     /** @brief Constructor to create a FileHandler object
      */
@@ -181,5 +247,13 @@ class FileHandler
 
 std::unique_ptr<FileHandler> getHandlerByType(uint16_t fileType,
                                               uint32_t fileHandle);
+
+/** @brief Method to create shared file handler objects based on file type
+ *
+ *  @param[in] fileType - type of file
+ *  @param[in] fileHandle - file handle
+ */
+std::shared_ptr<FileHandler> getSharedHandlerByType(uint16_t fileType,
+                                                    uint32_t fileHandle);
 } // namespace responder
 } // namespace pldm

oem/ibm/libpldmresponder/file_io.hpp

@@ -25,51 +25,75 @@ static constexpr auto certFilePath = "/var/lib/ibm/bmcweb/";
 
 CertMap CertHandler::certMap;
 
-int CertHandler::writeFromMemory(uint32_t offset, uint32_t length,
-                                 uint64_t address,
-                                 oem_platform::Handler* /*oemPlatformHandler*/)
+void CertHandler::writeFromMemory(uint32_t offset, uint32_t length,
+                                  uint64_t address,
+                                  oem_platform::Handler* /*oemPlatformHandler*/,
+                                  ResponseHdr& responseHdr,
+                                  sdeventplus::Event& event)
 {
     auto it = certMap.find(certType);
     if (it == certMap.end())
     {
         error(
             "CertHandler::writeFromMemory:file for type {CERT_TYP} doesn't exist",
             "CERT_TYP", certType);
-        return PLDM_ERROR;
+        FileHandler::dmaResponseToHost(responseHdr, PLDM_ERROR, 0);
+        FileHandler::deleteAIOobjects(nullptr, responseHdr);
+        return;
     }
-
+    m_length = length;
     auto fd = std::get<0>(it->second);
-    auto& remSize = std::get<1>(it->second);
-    auto rc = transferFileData(fd, false, offset, length, address);
-    if (rc == PLDM_SUCCESS)
+    transferFileData(fd, false, offset, length, address, responseHdr, event);
+
+    return;
+}
+
+void CertHandler::postDataTransferCallBack(bool IsWriteToMemOp)
+{
+    if (IsWriteToMemOp)
     {
-        remSize -= length;
+        auto it = certMap.find(certType);
+        if (it == certMap.end())
+        {
+            error(
+                "CertHandler::writeFromMemory:file for type {TYPE} doesn't exist",
+                "TYPE", certType);
+            return;
+        }
+        // auto fd = std::get<0>(it->second);
+        auto& remSize = std::get<1>(it->second);
+        remSize -= m_length;
         if (!remSize)
         {
-            close(fd);
+            // close(fd);
             certMap.erase(it);
         }
     }
-    return rc;
+    else
+    {
+        fs::remove(certfilePath);
+    }
+    return;
 }
 
-int CertHandler::readIntoMemory(uint32_t offset, uint32_t& length,
-                                uint64_t address,
-                                oem_platform::Handler* /*oemPlatformHandler*/)
+void CertHandler::readIntoMemory(uint32_t offset, uint32_t& length,
+                                 uint64_t address,
+                                 oem_platform::Handler* /*oemPlatformHandler*/,
+                                 ResponseHdr& responseHdr,
+                                 sdeventplus::Event& event)
 {
     std::string filePath = certFilePath;
     filePath += "CSR_" + std::to_string(fileHandle);
     if (certType != PLDM_FILE_TYPE_CERT_SIGNING_REQUEST)
     {
-        return PLDM_ERROR_INVALID_DATA;
-    }
-    auto rc = transferFileData(filePath.c_str(), true, offset, length, address);
-    fs::remove(filePath);
-    if (rc)
-    {
-        return PLDM_ERROR;
+        FileHandler::dmaResponseToHost(responseHdr, PLDM_ERROR_INVALID_DATA,
+                                       length);
+        FileHandler::deleteAIOobjects(nullptr, responseHdr);
+        return;
     }
-    return PLDM_SUCCESS;
+    certfilePath = filePath;
+    transferFileData(filePath.c_str(), true, offset, length, address,
+                     responseHdr, event);
 }
 
 int CertHandler::read(uint32_t offset, uint32_t& length, Response& response,

oem/ibm/libpldmresponder/file_io_by_type.cpp

@@ -29,12 +29,16 @@ class CertHandler : public FileHandler
         FileHandler(fileHandle), certType(fileType)
     {}
 
-    virtual int writeFromMemory(uint32_t offset, uint32_t length,
+    virtual void writeFromMemory(uint32_t offset, uint32_t length,
+                                 uint64_t address,
+                                 oem_platform::Handler* /*oemPlatformHandler*/,
+                                 ResponseHdr& responseHdr,
+                                 sdeventplus::Event& event);
+    virtual void readIntoMemory(uint32_t offset, uint32_t& length,
                                 uint64_t address,
-                                oem_platform::Handler* /*oemPlatformHandler*/);
-    virtual int readIntoMemory(uint32_t offset, uint32_t& length,
-                               uint64_t address,
-                               oem_platform::Handler* /*oemPlatformHandler*/);
+                                oem_platform::Handler* /*oemPlatformHandler*/,
+                                ResponseHdr& responseHdr,
+                                sdeventplus::Event& event);
     virtual int read(uint32_t offset, uint32_t& length, Response& response,
                      oem_platform::Handler* /*oemPlatformHandler*/);
 
@@ -60,6 +64,8 @@ class CertHandler : public FileHandler
                                              uint32_t /*metaDataValue3*/,
                                              uint32_t /*metaDataValue4*/);
 
+    virtual void postDataTransferCallBack(bool IsWriteToMemOp);
+
     /** @brief CertHandler destructor
      */
     ~CertHandler() {}
@@ -68,7 +74,8 @@ class CertHandler : public FileHandler
     uint16_t certType;      //!< type of the certificate
     static CertMap certMap; //!< holds the fd and remaining read/write size for
                             //!< each certificate
-
+    uint32_t m_length;
+    std::string certfilePath;
     enum SignedCertStatus
     {
         PLDM_INVALID_CERT_DATA = 0X03

oem/ibm/libpldmresponder/file_io_by_type.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "file_io_by_type.hpp"
+#include "file_io.hpp"
 
 namespace pldm
 {
@@ -21,18 +21,26 @@ class ChapHandler : public FileHandler
         FileHandler(fileHandle), chapType(fileType)
     {}
 
-    virtual int writeFromMemory(uint32_t /*offset*/, uint32_t /*length*/,
-                                uint64_t /*address*/,
-                                oem_platform::Handler* /*oemPlatformHandle*/)
+    virtual void writeFromMemory(uint32_t /*offset*/, uint32_t length,
+                                 uint64_t /*address*/,
+                                 oem_platform::Handler* /*oemPlatformHandle*/,
+                                 ResponseHdr& responseHdr,
+                                 sdeventplus::Event& /*event*/)
     {
-        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+        FileHandler::dmaResponseToHost(responseHdr,
+                                       PLDM_ERROR_UNSUPPORTED_PLDM_CMD, length);
+        FileHandler::deleteAIOobjects(nullptr, responseHdr);
     }
 
-    virtual int readIntoMemory(uint32_t /*offset*/, uint32_t& /*length*/,
-                               uint64_t /*address*/,
-                               oem_platform::Handler* /*oemPlatformHandler*/)
+    virtual void readIntoMemory(uint32_t /*offset*/, uint32_t& length,
+                                uint64_t /*address*/,
+                                oem_platform::Handler* /*oemPlatformHandler*/,
+                                ResponseHdr& responseHdr,
+                                sdeventplus::Event& /*event*/)
     {
-        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+        FileHandler::dmaResponseToHost(responseHdr,
+                                       PLDM_ERROR_UNSUPPORTED_PLDM_CMD, length);
+        FileHandler::deleteAIOobjects(nullptr, responseHdr);
     }
 
     virtual int read(uint32_t offset, uint32_t& length, Response& response,
@@ -70,6 +78,8 @@ class ChapHandler : public FileHandler
         return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
     }
 
+    virtual void postDataTransferCallBack(bool /*IsWriteToMemOp*/) {}
+
     /** @brief ChapHandler destructor
      */
     ~ChapHandler() {}