diff --git a/oem/ibm/libpldm/file_io.h b/oem/ibm/libpldm/file_io.h
index 15a6818..53f4343 100644
--- a/oem/ibm/libpldm/file_io.h
+++ b/oem/ibm/libpldm/file_io.h
@@ -51,6 +51,7 @@
 	PLDM_FILE_TYPE_PEL = 0,
 	PLDM_FILE_TYPE_LID_PERM = 1,
 	PLDM_FILE_TYPE_LID_TEMP = 2,
+	PLDM_FILE_TYPE_DUMP = 3,
 };
 
 #define PLDM_RW_FILE_MEM_REQ_BYTES 20
diff --git a/oem/ibm/libpldmresponder/file_io.cpp b/oem/ibm/libpldmresponder/file_io.cpp
index bf622c3..9322d9d 100644
--- a/oem/ibm/libpldmresponder/file_io.cpp
+++ b/oem/ibm/libpldmresponder/file_io.cpp
@@ -611,6 +611,56 @@
                                   payloadLength);
 }
 
+Response Handler::writeFileByType(const pldm_msg* request, size_t payloadLength)
+{
+    Response response(sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_RESP_BYTES);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+
+    if (payloadLength != PLDM_RW_FILE_BY_TYPE_REQ_BYTES)
+    {
+        encode_rw_file_by_type_resp(request->hdr.instance_id,
+                                    PLDM_WRITE_FILE_BY_TYPE,
+                                    PLDM_ERROR_INVALID_LENGTH, 0, responsePtr);
+        return response;
+    }
+    uint16_t fileType{};
+    uint32_t fileHandle{};
+    uint32_t offset{};
+    uint32_t length{};
+
+    auto rc = decode_rw_file_by_type_req(request, payloadLength, &fileType,
+                                         &fileHandle, &offset, &length);
+    if (rc != PLDM_SUCCESS)
+    {
+        encode_rw_file_by_type_resp(request->hdr.instance_id,
+                                    PLDM_WRITE_FILE_BY_TYPE, rc, 0,
+                                    responsePtr);
+        return response;
+    }
+
+    std::unique_ptr<FileHandler> handler{};
+    try
+    {
+        handler = getHandlerByType(fileType, fileHandle);
+    }
+    catch (const InternalFailure& e)
+    {
+        std::cerr << "unknown file type, TYPE=" << fileType << "\n";
+        encode_rw_file_by_type_resp(request->hdr.instance_id,
+                                    PLDM_WRITE_FILE_BY_TYPE,
+                                    PLDM_INVALID_FILE_TYPE, 0, responsePtr);
+        return response;
+    }
+
+    rc = handler->write(reinterpret_cast<const char*>(
+                            request->payload + PLDM_RW_FILE_BY_TYPE_RESP_BYTES),
+                        offset, length);
+    encode_rw_file_by_type_resp(request->hdr.instance_id,
+                                PLDM_WRITE_FILE_BY_TYPE, rc, length,
+                                responsePtr);
+    return response;
+}
+
 Response Handler::readFileByType(const pldm_msg* request, size_t payloadLength)
 {
     Response response(sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_RESP_BYTES);
@@ -687,6 +737,7 @@
     {
         handler = getHandlerByType(fileType, fileHandle);
     }
+
     catch (const InternalFailure& e)
     {
         encode_file_ack_resp(request->hdr.instance_id, PLDM_INVALID_FILE_TYPE,
@@ -735,6 +786,44 @@
     return response;
 }
 
+Response Handler::newFileAvailable(const pldm_msg* request,
+                                   size_t payloadLength)
+{
+    Response response(sizeof(pldm_msg_hdr) + PLDM_NEW_FILE_RESP_BYTES);
+
+    if (payloadLength != PLDM_NEW_FILE_REQ_BYTES)
+    {
+        return CmdHandler::ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
+    }
+    uint16_t fileType{};
+    uint32_t fileHandle{};
+    uint64_t length{};
+
+    auto rc = decode_new_file_req(request, payloadLength, &fileType,
+                                  &fileHandle, &length);
+
+    if (rc != PLDM_SUCCESS)
+    {
+        return CmdHandler::ccOnlyResponse(request, rc);
+    }
+
+    std::unique_ptr<FileHandler> handler{};
+    try
+    {
+        handler = getHandlerByType(fileType, fileHandle);
+    }
+    catch (const InternalFailure& e)
+    {
+        std::cerr << "unknown file type, TYPE=" << fileType << "\n";
+        return CmdHandler::ccOnlyResponse(request, PLDM_INVALID_FILE_TYPE);
+    }
+
+    rc = handler->newFileAvailable(length);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    encode_new_file_resp(request->hdr.instance_id, rc, responsePtr);
+    return response;
+}
+
 } // namespace oem_ibm
 } // namespace responder
 } // namespace pldm
diff --git a/oem/ibm/libpldmresponder/file_io.hpp b/oem/ibm/libpldmresponder/file_io.hpp
index f0555d7..9ff8f86 100644
--- a/oem/ibm/libpldmresponder/file_io.hpp
+++ b/oem/ibm/libpldmresponder/file_io.hpp
@@ -173,6 +173,11 @@
                                                         size_t payloadLength) {
             return this->readFileByType(request, payloadLength);
         });
+        handlers.emplace(PLDM_WRITE_FILE_BY_TYPE,
+                         [this](const pldm_msg* request, size_t payloadLength) {
+                             return this->writeFileByType(request,
+                                                          payloadLength);
+                         });
         handlers.emplace(PLDM_GET_FILE_TABLE,
                          [this](const pldm_msg* request, size_t payloadLength) {
                              return this->getFileTable(request, payloadLength);
@@ -194,6 +199,11 @@
                              return this->getAlertStatus(request,
                                                          payloadLength);
                          });
+        handlers.emplace(PLDM_NEW_FILE_AVAILABLE,
+                         [this](const pldm_msg* request, size_t payloadLength) {
+                             return this->newFileAvailable(request,
+                                                           payloadLength);
+                         });
     }
 
     /** @brief Handler for readFileIntoMemory command
@@ -235,7 +245,7 @@
     Response readFileByTypeIntoMemory(const pldm_msg* request,
                                       size_t payloadLength);
 
-    /** @brief Handler for readFileByType command
+    /** @brief Handler for writeFileByType command
      *
      *  @param[in] request - pointer to PLDM request payload
      *  @param[in] payloadLength - length of the message
@@ -244,6 +254,8 @@
      */
     Response readFileByType(const pldm_msg* request, size_t payloadLength);
 
+    Response writeFileByType(const pldm_msg* request, size_t payloadLength);
+
     /** @brief Handler for GetFileTable command
      *
      *  @param[in] request - pointer to PLDM request payload
@@ -281,6 +293,15 @@
      *  @return PLDM response message
      */
     Response getAlertStatus(const pldm_msg* request, size_t payloadLength);
+
+    /** @brief Handler for newFileAvailable command
+     *
+     *  @param[in] request - PLDM request msg
+     *  @param[in] payloadLength - length of the message payload
+     *
+     *  @return PLDM response message
+     */
+    Response newFileAvailable(const pldm_msg* request, size_t payloadLength);
 };
 
 } // namespace oem_ibm
diff --git a/oem/ibm/libpldmresponder/file_io_by_type.cpp b/oem/ibm/libpldmresponder/file_io_by_type.cpp
index e076253..2ecc3d9 100644
--- a/oem/ibm/libpldmresponder/file_io_by_type.cpp
+++ b/oem/ibm/libpldmresponder/file_io_by_type.cpp
@@ -2,6 +2,7 @@
 
 #include "file_io_by_type.hpp"
 
+#include "file_io_type_dump.hpp"
 #include "file_io_type_lid.hpp"
 #include "file_io_type_pel.hpp"
 #include "utils.hpp"
@@ -120,6 +121,11 @@
             return std::make_unique<LidHandler>(fileHandle, false);
             break;
         }
+        case PLDM_FILE_TYPE_DUMP:
+        {
+            return std::make_unique<DumpHandler>(fileHandle);
+            break;
+        }
         default:
         {
             throw InternalFailure();
diff --git a/oem/ibm/libpldmresponder/file_io_by_type.hpp b/oem/ibm/libpldmresponder/file_io_by_type.hpp
index b970886..0a5c1d8 100644
--- a/oem/ibm/libpldmresponder/file_io_by_type.hpp
+++ b/oem/ibm/libpldmresponder/file_io_by_type.hpp
@@ -48,8 +48,26 @@
      */
     virtual int read(uint32_t offset, uint32_t& length, Response& response) = 0;
 
+    /** @brief Method to write an oem file by type
+     *  @param[in] buffer - buffer to be written to file
+     *  @param[in] offset - offset to write to
+     *  @param[in/out] length - length to be written
+     *  @return PLDM status code
+     */
+    virtual int write(const char* buffer, uint32_t offset,
+                      uint32_t& length) = 0;
+
     virtual int fileAck(uint8_t fileStatus) = 0;
 
+    /** @brief Method to process a new file available notification from the
+     *  host. The bmc can chose to do different actions based on the file type.
+     *
+     *  @param[in] length - size of the file content to be transferred
+     *
+     *  @return PLDM status code
+     */
+    virtual int newFileAvailable(uint64_t length) = 0;
+
     /** @brief Method to read an oem file type's content into the PLDM response.
      *  @param[in] filePath - file to read from
      *  @param[in] offset - offset to read
diff --git a/oem/ibm/libpldmresponder/file_io_type_dump.cpp b/oem/ibm/libpldmresponder/file_io_type_dump.cpp
new file mode 100644
index 0000000..2360733
--- /dev/null
+++ b/oem/ibm/libpldmresponder/file_io_type_dump.cpp
@@ -0,0 +1,110 @@
+#include "file_io_type_dump.hpp"
+
+#include "utils.hpp"
+#include "xyz/openbmc_project/Common/error.hpp"
+
+#include <stdint.h>
+#include <systemd/sd-bus.h>
+#include <unistd.h>
+
+#include <exception>
+#include <filesystem>
+#include <iostream>
+#include <sdbusplus/server.hpp>
+#include <xyz/openbmc_project/Dump/NewDump/server.hpp>
+
+#include "libpldm/base.h"
+#include "oem/ibm/libpldm/file_io.h"
+
+namespace pldm
+{
+namespace responder
+{
+
+static constexpr auto nbdInterface = "/dev/nbd1";
+
+int DumpHandler::fd = -1;
+
+int DumpHandler::newFileAvailable(uint64_t length)
+{
+    static constexpr auto dumpObjPath = "/xyz/openbmc_project/dump";
+    static constexpr auto dumpInterface = "xyz.openbmc_project.Dump.NewDump";
+
+    auto& bus = pldm::utils::DBusHandler::getBus();
+
+    try
+    {
+        auto service =
+            pldm::utils::DBusHandler().getService(dumpObjPath, dumpInterface);
+        using namespace sdbusplus::xyz::openbmc_project::Dump::server;
+        auto method = bus.new_method_call(service.c_str(), dumpObjPath,
+                                          dumpInterface, "Notify");
+        method.append(
+            sdbusplus::xyz::openbmc_project::Dump::server::convertForMessage(
+                NewDump::DumpType::System),
+            fileHandle, length);
+        bus.call_noreply(method);
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "failed to make a d-bus call to DUMP manager, ERROR="
+                  << e.what() << "\n";
+        return PLDM_ERROR;
+    }
+
+    return PLDM_SUCCESS;
+}
+
+int DumpHandler::writeFromMemory(uint32_t offset, uint32_t length,
+                                 uint64_t address)
+{
+    int flags = O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE;
+
+    if (DumpHandler::fd == -1)
+    {
+        DumpHandler::fd = open(nbdInterface, flags);
+        if (DumpHandler::fd == -1)
+        {
+            std::cerr << "NBD file does not exist at " << nbdInterface
+                      << " ERROR=" << errno << "\n";
+            return PLDM_ERROR;
+        }
+    }
+    return transferFileData(DumpHandler::fd, false, offset, length, address);
+}
+
+int DumpHandler::write(const char* buffer, uint32_t offset, uint32_t& length)
+{
+    int flags = O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE;
+    if (DumpHandler::fd == -1)
+    {
+        DumpHandler::fd = open(nbdInterface, flags);
+        if (DumpHandler::fd == -1)
+        {
+            std::cerr << "NBD file does not exist at " << nbdInterface
+                      << " ERROR=" << errno << "\n";
+            return PLDM_ERROR;
+        }
+    }
+
+    int rc = lseek(DumpHandler::fd, offset, SEEK_SET);
+    if (rc == -1)
+    {
+        std::cerr << "lseek failed, ERROR=" << errno << ", OFFSET=" << offset
+                  << "\n";
+        return PLDM_ERROR;
+    }
+    rc = ::write(DumpHandler::fd, buffer, length);
+    if (rc == -1)
+    {
+        std::cerr << "file write failed, ERROR=" << errno
+                  << ", LENGTH=" << length << ", OFFSET=" << offset << "\n";
+        return PLDM_ERROR;
+    }
+    length = rc;
+
+    return PLDM_SUCCESS;
+}
+
+} // namespace responder
+} // namespace pldm
diff --git a/oem/ibm/libpldmresponder/file_io_type_dump.hpp b/oem/ibm/libpldmresponder/file_io_type_dump.hpp
new file mode 100644
index 0000000..e20d0d7
--- /dev/null
+++ b/oem/ibm/libpldmresponder/file_io_type_dump.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "file_io_by_type.hpp"
+
+namespace pldm
+{
+namespace responder
+{
+
+/** @class DumpHandler
+ *
+ *  @brief Inherits and implements FileHandler. This class is used
+ *  handle the dump offload/streaming from host to the destination via bmc
+ */
+class DumpHandler : public FileHandler
+{
+  public:
+    /** @brief DumpHandler constructor
+     */
+    DumpHandler(uint32_t fileHandle) : FileHandler(fileHandle)
+    {
+    }
+
+    virtual int writeFromMemory(uint32_t offset, uint32_t length,
+                                uint64_t address);
+
+    virtual int readIntoMemory(uint32_t /*offset*/, uint32_t& /*length*/,
+                               uint64_t /*address*/)
+    {
+        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+    }
+    virtual int read(uint32_t /*offset*/, uint32_t& /*length*/,
+                     Response& /*response*/)
+    {
+        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+    }
+
+    virtual int write(const char* buffer, uint32_t offset, uint32_t& length);
+
+    virtual int newFileAvailable(uint64_t length);
+
+    virtual int fileAck(uint8_t /*fileStatus*/)
+    {
+        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+    }
+
+    /** @brief DumpHandler destructor
+     */
+    ~DumpHandler()
+    {
+    }
+
+  private:
+    static int fd; //!< fd to manage the dump offload to bmc
+};
+
+} // namespace responder
+} // namespace pldm
diff --git a/oem/ibm/libpldmresponder/file_io_type_lid.hpp b/oem/ibm/libpldmresponder/file_io_type_lid.hpp
index 3a3332a..163629d 100644
--- a/oem/ibm/libpldmresponder/file_io_type_lid.hpp
+++ b/oem/ibm/libpldmresponder/file_io_type_lid.hpp
@@ -44,6 +44,12 @@
         return transferFileData(lidPath, true, offset, length, address);
     }
 
+    virtual int write(const char* /*buffer*/, uint32_t /*offset*/,
+                      uint32_t& /*length*/)
+    {
+        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+    }
+
     virtual int read(uint32_t offset, uint32_t& length, Response& response)
     {
         return readFile(lidPath, offset, length, response);
@@ -54,6 +60,12 @@
         return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
     }
 
+    virtual int newFileAvailable(uint64_t /*length*/)
+
+    {
+        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+    }
+
     /** @brief LidHandler destructor
      */
     ~LidHandler()
diff --git a/oem/ibm/libpldmresponder/file_io_type_pel.hpp b/oem/ibm/libpldmresponder/file_io_type_pel.hpp
index 34f4907..3d5019a 100644
--- a/oem/ibm/libpldmresponder/file_io_type_pel.hpp
+++ b/oem/ibm/libpldmresponder/file_io_type_pel.hpp
@@ -29,6 +29,12 @@
                                uint64_t address);
     virtual int read(uint32_t offset, uint32_t& length, Response& response);
 
+    virtual int write(const char* /*buffer*/, uint32_t /*offset*/,
+                      uint32_t& /*length*/)
+    {
+        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+    }
+
     virtual int fileAck(uint8_t fileStatus);
 
     /** @brief method to store a pel file in tempfs and send
@@ -38,6 +44,11 @@
      */
     virtual int storePel(std::string&& pelFileName);
 
+    virtual int newFileAvailable(uint64_t /*length*/)
+    {
+        return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
+    }
+
     /** @brief PelHandler destructor
      */
     ~PelHandler()
diff --git a/oem/ibm/test/libpldmresponder_fileio_test.cpp b/oem/ibm/test/libpldmresponder_fileio_test.cpp
index 86df25e..a8d0722 100644
--- a/oem/ibm/test/libpldmresponder_fileio_test.cpp
+++ b/oem/ibm/test/libpldmresponder_fileio_test.cpp
@@ -1,5 +1,6 @@
 #include "libpldmresponder/file_io.hpp"
 #include "libpldmresponder/file_io_by_type.hpp"
+#include "libpldmresponder/file_io_type_dump.hpp"
 #include "libpldmresponder/file_io_type_lid.hpp"
 #include "libpldmresponder/file_io_type_pel.hpp"
 #include "libpldmresponder/file_table.hpp"
@@ -795,6 +796,10 @@
     lidType = dynamic_cast<LidHandler*>(handler.get());
     ASSERT_TRUE(lidType != nullptr);
 
+    handler = getHandlerByType(PLDM_FILE_TYPE_DUMP, fileHandle);
+    auto dumpType = dynamic_cast<DumpHandler*>(handler.get());
+    ASSERT_TRUE(dumpType != nullptr);
+
     using namespace sdbusplus::xyz::openbmc_project::Common::Error;
     ASSERT_THROW(getHandlerByType(0xFFFF, fileHandle), InternalFailure);
 }