diff --git a/dump-extensions/openpower-dumps/dump-extensions.cpp b/dump-extensions/openpower-dumps/dump-extensions.cpp
index 45864ca..3b91842 100644
--- a/dump-extensions/openpower-dumps/dump-extensions.cpp
+++ b/dump-extensions/openpower-dumps/dump-extensions.cpp
@@ -4,21 +4,52 @@
 
 #include "dump-extensions/openpower-dumps/openpower_dumps_config.h"
 
+#include "com/ibm/Dump/Entry/Hardware/server.hpp"
+#include "com/ibm/Dump/Entry/Hostboot/server.hpp"
+#include "com/ibm/Dump/Entry/SBE/server.hpp"
+#include "dump_manager_hostdump.hpp"
 #include "dump_manager_resource.hpp"
 #include "dump_manager_system.hpp"
+#include "dump_utils.hpp"
+#include "host_dump_entry.hpp"
+
+#include <fmt/core.h>
+
+#include <phosphor-logging/log.hpp>
 
 namespace phosphor
 {
 namespace dump
 {
 
-void loadExtensions(sdbusplus::bus_t& bus, DumpManagerList& dumpList)
+using namespace phosphor::logging;
+void loadExtensions(sdbusplus::bus::bus& bus,
+                    const phosphor::dump::EventPtr& event,
+                    DumpManagerList& dumpList)
 {
-
     dumpList.push_back(std::make_unique<openpower::dump::system::Manager>(
         bus, SYSTEM_DUMP_OBJPATH, SYSTEM_DUMP_OBJ_ENTRY));
     dumpList.push_back(std::make_unique<openpower::dump::resource::Manager>(
         bus, RESOURCE_DUMP_OBJPATH, RESOURCE_DUMP_OBJ_ENTRY));
+
+    try
+    {
+        std::filesystem::create_directories(HOSTBOOT_DUMP_PATH);
+    }
+    catch (std::exception& e)
+    {
+        log<level::ERR>(
+            fmt::format("Failed to create hostboot dump directory({})",
+                        HOSTBOOT_DUMP_PATH)
+                .c_str());
+        throw std::runtime_error("Failed to create hostboot dump directory");
+    }
+    dumpList.push_back(std::make_unique<openpower::dump::hostdump::Manager<
+                           sdbusplus::com::ibm::Dump::Entry::server::Hostboot>>(
+        bus, event, HOSTBOOT_DUMP_OBJPATH, HOSTBOOT_DUMP_OBJ_ENTRY,
+        HOSTBOOT_DUMP_PATH, "hbdump", HOSTBOOT_DUMP_TMP_FILE_DIR,
+        HOSTBOOT_DUMP_MAX_SIZE, HOSTBOOT_DUMP_MIN_SPACE_REQD,
+        HOSTBOOT_DUMP_TOTAL_SIZE));
 }
 } // namespace dump
 } // namespace phosphor
diff --git a/dump-extensions/openpower-dumps/dump_manager_hostdump.hpp b/dump-extensions/openpower-dumps/dump_manager_hostdump.hpp
new file mode 100644
index 0000000..95fe8ed
--- /dev/null
+++ b/dump-extensions/openpower-dumps/dump_manager_hostdump.hpp
@@ -0,0 +1,315 @@
+#pragma once
+
+#include "dump-extensions/openpower-dumps/openpower_dumps_config.h"
+
+#include "dump_manager_bmcstored.hpp"
+#include "dump_utils.hpp"
+#include "host_dump_entry.hpp"
+#include "op_dump_util.hpp"
+#include "watch.hpp"
+#include "xyz/openbmc_project/Common/error.hpp"
+#include "xyz/openbmc_project/Dump/Create/error.hpp"
+#include "xyz/openbmc_project/Dump/NewDump/server.hpp"
+
+#include <fmt/core.h>
+#include <sys/inotify.h>
+#include <unistd.h>
+
+#include <com/ibm/Dump/Create/server.hpp>
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <sdeventplus/exception.hpp>
+#include <sdeventplus/source/base.hpp>
+#include <sdeventplus/source/child.hpp>
+#include <xyz/openbmc_project/Dump/Create/server.hpp>
+
+#include <ctime>
+#include <filesystem>
+#include <regex>
+
+namespace openpower
+{
+namespace dump
+{
+namespace hostdump
+{
+
+using namespace sdbusplus::xyz::openbmc_project::Common::Error;
+using namespace phosphor::logging;
+
+constexpr auto INVALID_DUMP_SIZE = 0;
+constexpr auto HOST_DUMP_COMMON_FILENAME_PART =
+    "_([0-9]+)_([0-9]+).([a-zA-Z0-9]+)";
+
+using CreateIface = sdbusplus::server::object::object<
+    sdbusplus::xyz::openbmc_project::Dump::server::Create,
+    sdbusplus::com::ibm::Dump::server::Create,
+    sdbusplus::xyz::openbmc_project::Dump::server::NewDump>;
+
+using UserMap = phosphor::dump::inotify::UserMap;
+
+using Watch = phosphor::dump::inotify::Watch;
+using ::sdeventplus::source::Child;
+
+using originatorTypes = sdbusplus::xyz::openbmc_project::Common::server::
+    OriginatedBy::OriginatorTypes;
+
+/** @class Manager
+ *  @brief Host Dump  manager implementation.
+ *  @details A concrete implementation for the
+ *  xyz.openbmc_project.Dump.Create
+ *  com::ibm::Dump::Create and
+ *  xyz::openbmc_project::Dump::NewDump D-Bus APIs
+ */
+template <typename T>
+class Manager :
+    virtual public CreateIface,
+    public phosphor::dump::bmc_stored::Manager
+{
+  public:
+    Manager() = delete;
+    Manager(const Manager&) = default;
+    Manager& operator=(const Manager&) = delete;
+    Manager(Manager&&) = delete;
+    Manager& operator=(Manager&&) = delete;
+    virtual ~Manager() = default;
+
+    /** @brief Constructor to put object onto bus at a dbus path.
+     *  @param[in] bus - Bus to attach to.
+     *  @param[in] event - Dump manager sd_event loop.
+     *  @param[in] path - Path to attach at.
+     *  @param[in] baseEntryPath - Base path for dump entry.
+     *  @param[in] filePath - Path where the dumps are stored.
+     *  @param[in] dumpNamePrefix - Prefix to the dump filename
+     *  @param[in] dumpTempFileDir - Temporary location of dump files
+     *  @param[in] maxDumpSize - Maximum allowed size of dump file
+     *  @param[in] minDumpSize - Minimum size of a usable dump
+     *  @param[in] allocatedSize - Total allocated space for the dump.
+     */
+    Manager(sdbusplus::bus::bus& bus, const phosphor::dump::EventPtr& event,
+            const char* path, const std::string& baseEntryPath,
+            const char* filePath, const std::string dumpNamePrefix,
+            const std::string dumpTempFileDir, const uint64_t maxDumpSize,
+            const uint64_t minDumpSize, const uint64_t allocatedSize) :
+        CreateIface(bus, path),
+        phosphor::dump::bmc_stored::Manager(
+            bus, event, path, baseEntryPath, filePath,
+            dumpNamePrefix + HOST_DUMP_COMMON_FILENAME_PART, maxDumpSize,
+            minDumpSize, allocatedSize),
+        dumpNamePrefix(dumpNamePrefix), dumpTempFileDir(dumpTempFileDir)
+    {}
+
+    /** @brief Implementation for CreateDump
+     *  Method to create a host dump entry when user requests for a
+     *  new host dump
+     *
+     *  @return object_path - The object path of the new dump entry.
+     */
+    sdbusplus::message::object_path
+        createDump(phosphor::dump::DumpCreateParams params) override
+    {
+        using InvalidArgument =
+            sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument;
+        using Argument = xyz::openbmc_project::Common::InvalidArgument;
+        if (!params.empty())
+        {
+            log<level::ERR>(fmt::format("Dump type({}) accepts no additional "
+                                        "parameters, number of parameters({})",
+                                        dumpNamePrefix, params.size())
+                                .c_str());
+            elog<InvalidArgument>(
+                Argument::ARGUMENT_NAME("NO_PARAMETERS_NEEDED"),
+                Argument::ARGUMENT_VALUE("INVALID_PARAMETERS"));
+        }
+
+        // Check dump policy
+        util::isOPDumpsEnabled();
+
+        auto size = getAllowedSize();
+
+        uint32_t id = ++lastEntryId;
+
+        // Entry Object path.
+        auto objPath =
+            std::filesystem::path(baseEntryPath) / std::to_string(id);
+
+        log<level::INFO>(fmt::format("Create dump type({}) with id({}) "
+                                     "available space: ({}) kilobytes",
+                                     dumpNamePrefix, id, size)
+                             .c_str());
+
+        std::time_t timeStamp = std::time(nullptr);
+        createEntry(id, objPath, timeStamp, 0, std::string(),
+                    phosphor::dump::OperationStatus::InProgress, std::string(),
+                    originatorTypes::Internal);
+
+        return objPath.string();
+    }
+
+    /** @brief Notify the host dump manager about creation of a new dump.
+     *  @param[in] dumpId - Id from the source of the dump.
+     *  @param[in] size - Size of the dump.
+     */
+    void notify(uint32_t dumpId, uint64_t) override
+    {
+        try
+        {
+            captureDump(dumpId);
+        }
+        catch (std::exception& e)
+        {
+            log<level::ERR>(
+                fmt::format("Failed to package dump({}): id({}) errorMsg({})",
+                            dumpNamePrefix, dumpId, e.what())
+                    .c_str());
+            throw std::runtime_error("Failed to package dump");
+        }
+    }
+    /** @brief Create a  Dump Entry Object
+     *  @param[in] id - Id of the dump
+     *  @param[in] objPath - Object path to attach to
+     *  @param[in] ms - Dump creation timestamp since the epoch.
+     *  @param[in] fileSize - Dump file size in bytes.
+     *  @param[in] file - Name of dump file.
+     *  @param[in] status - status of the dump.
+     *  @param[in] originatorId - Id of the originator of the dump
+     *  @param[in] originatorType - Originator type
+     */
+
+    virtual void createEntry(const uint32_t id, const std::string objPath,
+                             const uint64_t ms, uint64_t fileSize,
+                             const std::filesystem::path& file,
+                             phosphor::dump::OperationStatus status,
+                             std::string originatorId,
+                             originatorTypes originatorType) override
+    {
+        try
+        {
+            entries.insert(std::make_pair(
+                id, std::make_unique<openpower::dump::hostdump::Entry<T>>(
+                        bus, objPath.c_str(), id, ms, fileSize, file, status,
+                        originatorId, originatorType, *this)));
+        }
+        catch (const std::invalid_argument& e)
+        {
+            log<level::ERR>(fmt::format("Error in creating host dump entry, "
+                                        "errormsg({}), OBJECTPATH({}), ID({})",
+                                        e.what(), objPath.c_str(), id)
+                                .c_str());
+            throw std::runtime_error("Error in creating host dump entry");
+        }
+    }
+
+  private:
+    std::string dumpNamePrefix;
+    std::string dumpTempFileDir;
+
+    void captureDump(uint32_t dumpId)
+    {
+        std::string idStr;
+        try
+        {
+            idStr = std::to_string(dumpId);
+        }
+        catch (std::exception& e)
+        {
+            log<level::ERR>("Dump capture: Error converting idto string");
+            throw std::runtime_error(
+                "Dump capture: Error converting dump id to string");
+        }
+
+        // Get Dump size.
+        // TODO #ibm-openbmc/issues/3061
+        // Dump request will be rejected if there is not enough space for
+        // one complete dump, change this behavior to crate a partial dump
+        // with available space.
+        auto size = getAllowedSize();
+
+        auto dumpTempPath = std::filesystem::path(dumpTempFileDir) / idStr;
+
+        pid_t pid = fork();
+        if (pid == 0)
+        {
+            std::filesystem::path dumpPath(dumpDir);
+            dumpPath /= idStr;
+            execl("/usr/bin/opdreport", "opdreport", "-d", dumpPath.c_str(),
+                  "-i", idStr.c_str(), "-s", std::to_string(size).c_str(), "-q",
+                  "-v", "-p", dumpTempPath.c_str(), "-n",
+                  dumpNamePrefix.c_str(), nullptr);
+
+            // opdreport script execution is failed.
+            auto error = errno;
+            log<level::ERR>(
+                fmt::format(
+                    "Dump capture: Error occurred during "
+                    "opdreport function execution, errno({}), dumpPrefix({}), "
+                    "dumpPath({}), dumpSourcePath({}), allowedSize({})",
+                    error, dumpNamePrefix.c_str(), dumpPath.c_str(),
+                    dumpTempPath.c_str(), size)
+                    .c_str());
+            throw std::runtime_error("Dump capture: Error occured during "
+                                     "opdreport script execution");
+        }
+        else if (pid > 0)
+        {
+            phosphor::dump::Entry* dumpEntry = NULL;
+            auto dumpIt = entries.find(dumpId);
+            if (dumpIt != entries.end())
+            {
+                dumpEntry = dumpIt->second.get();
+            }
+            Child::Callback callback = [this, dumpEntry,
+                                        pid](Child&, const siginfo_t* si) {
+                // Set progress as failed if packaging return error
+                if (si->si_status != 0)
+                {
+                    log<level::ERR>("Dump packaging failed");
+                    if (dumpEntry != nullptr)
+                    {
+                        reinterpret_cast<phosphor::dump::Entry*>(dumpEntry)
+                            ->status(phosphor::dump::OperationStatus::Failed);
+                    }
+                }
+                else
+                {
+                    log<level::INFO>("Dump packaging completed");
+                }
+                this->childPtrMap.erase(pid);
+            };
+            try
+            {
+                childPtrMap.emplace(
+                    pid, std::make_unique<Child>(eventLoop.get(), pid,
+                                                 WEXITED | WSTOPPED,
+                                                 std::move(callback)));
+            }
+            catch (const sdeventplus::SdEventError& ex)
+            {
+                // Failed to add to event loop
+                log<level::ERR>(
+                    fmt::format("Dump capture: Error occurred during "
+                                "the sdeventplus::source::Child ex({})",
+                                ex.what())
+                        .c_str());
+                throw std::runtime_error(
+                    "Dump capture: Error occurred during the "
+                    "sdeventplus::source::Child creation");
+            }
+        }
+        else
+        {
+            auto error = errno;
+            log<level::ERR>(
+                fmt::format(
+                    "Dump capture: Error occurred during fork, errno({})",
+                    error)
+                    .c_str());
+            throw std::runtime_error(
+                "Dump capture: Error occurred during fork");
+        }
+    }
+};
+
+} // namespace hostdump
+} // namespace dump
+} // namespace openpower
diff --git a/dump-extensions/openpower-dumps/host_dump_entry.hpp b/dump-extensions/openpower-dumps/host_dump_entry.hpp
new file mode 100644
index 0000000..fe2b839
--- /dev/null
+++ b/dump-extensions/openpower-dumps/host_dump_entry.hpp
@@ -0,0 +1,75 @@
+#pragma once
+
+#include "bmcstored_dump_entry.hpp"
+
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server/object.hpp>
+
+#include <filesystem>
+
+namespace openpower
+{
+namespace dump
+{
+namespace hostdump
+{
+
+using originatorTypes = sdbusplus::xyz::openbmc_project::Common::server::
+    OriginatedBy::OriginatorTypes;
+
+template <typename T>
+using ServerObject = typename sdbusplus::server::object_t<T>;
+
+template <typename T>
+using EntryIfaces = sdbusplus::server::object_t<T>;
+
+/** @class Entry
+ *  @brief Host Dump Entry implementation.
+ *  @details A concrete implementation for the
+ *  host dump type DBus API
+ */
+template <typename T>
+class Entry :
+    virtual public EntryIfaces<T>,
+    virtual public phosphor::dump::bmc_stored::Entry
+{
+  public:
+    Entry() = delete;
+    Entry(const Entry&) = delete;
+    Entry& operator=(const Entry&) = delete;
+    Entry(Entry&&) = delete;
+    Entry& operator=(Entry&&) = delete;
+    ~Entry() = default;
+
+    /** @brief Constructor for the Dump Entry Object
+     *  @param[in] bus - Bus to attach to.
+     *  @param[in] objPath - Object path to attach to
+     *  @param[in] dumpId - Dump id.
+     *  @param[in] timeStamp - Dump creation timestamp
+     *             since the epoch.
+     *  @param[in] fileSize - Dump file size in bytes.
+     *  @param[in] file - Name of dump file.
+     *  @param[in] status - status of the dump.
+     *  @param[in] originatorId - Id of the originator of the dump
+     *  @param[in] originatorType - Originator type
+     *  @param[in] parent - The dump entry's parent.
+     */
+    Entry(sdbusplus::bus_t& bus, const std::string& objPath, uint32_t dumpId,
+          uint64_t timeStamp, uint64_t fileSize,
+          const std::filesystem::path& file,
+          phosphor::dump::OperationStatus status, std::string originatorId,
+          originatorTypes originatorType, phosphor::dump::Manager& parent) :
+        EntryIfaces<T>(bus, objPath.c_str(),
+                       EntryIfaces<T>::action::emit_object_added),
+        phosphor::dump::bmc_stored::Entry(bus, objPath.c_str(), dumpId,
+                                          timeStamp, fileSize, file, status,
+                                          originatorId, originatorType, parent)
+    {
+        // Emit deferred signal.
+        this->openpower::dump::hostdump::EntryIfaces<T>::emit_object_added();
+    }
+};
+
+} // namespace hostdump
+} // namespace dump
+} // namespace openpower
diff --git a/dump-extensions/openpower-dumps/meson.build b/dump-extensions/openpower-dumps/meson.build
index c367421..ac971a4 100644
--- a/dump-extensions/openpower-dumps/meson.build
+++ b/dump-extensions/openpower-dumps/meson.build
@@ -19,6 +19,30 @@
 opconf_data.set_quoted('RESOURCE_DUMP_OBJ_ENTRY', get_option('RESOURCE_DUMP_OBJ_ENTRY'),
                       description : 'The resource dump entry D-Bus object path'
                     )
+
+
+opconf_data.set_quoted('HOSTBOOT_DUMP_OBJPATH', get_option('HOSTBOOT_DUMP_OBJPATH'),
+                      description : 'The Hostboot dump manager D-Bus path'
+                    )
+opconf_data.set_quoted('HOSTBOOT_DUMP_OBJ_ENTRY', get_option('HOSTBOOT_DUMP_OBJ_ENTRY'),
+                      description : 'The hostboot dump entry D-Bus object path'
+                    )
+opconf_data.set_quoted('HOSTBOOT_DUMP_TMP_FILE_DIR', get_option('HOSTBOOT_DUMP_TMP_FILE_DIR'),
+                      description : 'Directory where hostboot dump pieces are stored for packaging'
+                    )
+opconf_data.set_quoted('HOSTBOOT_DUMP_PATH', get_option('HOSTBOOT_DUMP_PATH'),
+                     description : 'Directory where Hostboot dumps are placed'
+             )
+opconf_data.set('HOSTBOOT_DUMP_MAX_SIZE', get_option('HOSTBOOT_DUMP_MAX_SIZE'),
+               description : 'Maximum size of one Hostboot dump in kilo bytes'
+             )
+opconf_data.set('HOSTBOOT_DUMP_MIN_SPACE_REQD', get_option('HOSTBOOT_DUMP_MIN_SPACE_REQD'),
+               description : 'Minimum space required for one Hostboot dump in kilo bytes'
+             )
+opconf_data.set('HOSTBOOT_DUMP_TOTAL_SIZE', get_option('HOSTBOOT_DUMP_TOTAL_SIZE'),
+               description : 'Total size of the dump in kilo bytes'
+             )
+
 configure_file(configuration : opconf_data,
                output : 'openpower_dumps_config.h'
               )