diff --git a/recipes-google/ipmi/google-ipmi-sys/0002-boot-time-monitor-Add-commands.patch b/recipes-google/ipmi/google-ipmi-sys/0002-boot-time-monitor-Add-commands.patch
new file mode 100644
index 0000000..99231a9
--- /dev/null
+++ b/recipes-google/ipmi/google-ipmi-sys/0002-boot-time-monitor-Add-commands.patch
@@ -0,0 +1,944 @@
+From 9a87ff5d07318ce7733ef7f6eb157eb491c4ad04 Mon Sep 17 00:00:00 2001
+From: Michael Shen <gpgpgp@google.com>
+Date: Mon, 29 Apr 2024 03:30:08 +0000
+Subject: [PATCH 2/2] boot-time-monitor: Add commands
+
+Add new commands `sendRebootCheckpoint`, `sendRebootComplete` and
+`sendRebootAdditionalDuration`.
+
+These commands are for the `BootTimeMonitor` feature in
+https://gbmc.googlesource.com/BootTimeMonitor/
+
+Basically that daemon is for monitoring the reboot process for BMC and
+hosts. It will be useful for profiling the reboot process and knowing
+how to optimize it.
+
+Tested:
+```
+bmc:~# ipmitool raw 0x2e 0x32 0x79 0x2b 0x00 0x12 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x03 0x41 0x42 0x43
+ 79 2b 00 12
+bmc:~# ipmitool raw 0x2e 0x32 0x79 0x2b 0x00 0x14 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x03 0x41 0x42 0x43
+ 79 2b 00 14
+bmc:~# ipmitool raw 0x2e 0x32 0x79 0x2b 0x00 0x13
+ 79 2b 00 13
+```
+
+Patch Tracking Bug: b/310528119
+Upstream info / review: go/obmcl/66345
+Upstream-Status: Submitted
+Justification: [enable feature] Adding BootTimeMonitor needed IPMI
+commands.
+
+Signed-off-by: Michael Shen <gpgpgp@google.com>
+Change-Id: Ie740de503d110007820c0da77a6f1522fdf66a9f
+---
+ README.md                           |  43 ++++++
+ boot_time_monitor.cpp               | 135 ++++++++++++++++++
+ boot_time_monitor.hpp               |  50 +++++++
+ handler.cpp                         |  75 ++++++++++
+ handler.hpp                         |  29 ++++
+ handler_impl.hpp                    |   5 +
+ ipmi.cpp                            |   7 +
+ meson.build                         |   1 +
+ test/boot_time_monitor_unittest.cpp | 211 ++++++++++++++++++++++++++++
+ test/handler_mock.hpp               |   6 +
+ test/handler_unittest.cpp           | 196 +++++++++++++++++++++++++-
+ test/meson.build                    |   1 +
+ 12 files changed, 757 insertions(+), 2 deletions(-)
+ create mode 100644 boot_time_monitor.cpp
+ create mode 100644 boot_time_monitor.hpp
+ create mode 100644 test/boot_time_monitor_unittest.cpp
+
+diff --git a/README.md b/README.md
+index 71a213b..9e8097d 100644
+--- a/README.md
++++ b/README.md
+@@ -457,6 +457,49 @@ Response (if applicable)
+ | ------- | ----- | ---------- |
+ | 0x00    | 0x11  | Subcommand |
+ 
++### SendRebootCheckpoint - SubCommand 0x12
++
++Send checkpoints to BMC to monitor the current reboot process.
++User can put current wall lock time in the command or put `0` to let BMC fetch
++the wall clock time by itself.
++If user can somehow have the self measurement of a duration when they send
++checkpoint to BMC, BMC will help to calculate the transition time from previous
++checkpoint to current checkpoint. Then add a checkpoint with the name
++`To_${checkpoint}`. Or specify `0` to ignore it.
++
++Request
++
++| Byte(s)        | Value           | Data                                   |
++| -------------- | --------------- | -------------------------------------- |
++| 0x00           | 0x12            | Subcommand                             |
++| 0x01..0x08     | Wall Time       | Current epoch time in milliseconds     |
++| 0x09..0x10     | Duration        | Self measured duration in milliseconds |
++| 0x11           | Length (N)      | Length of checkpoint name              |
++| 0x12..0x12 + N | Checkpoint name | Checkpoint name ([0-9a-ZA-Z_] only)    |
++
++### SendRebootComplete - SubCommand 0x13
++
++Informing BMC that the current reboot process is completed.
++
++Request
++
++| Byte(s) | Value | Data       |
++| ------- | ----- | ---------- |
++| 0x00    | 0x13  | Subcommand |
++
++### SendRebootAdditionalDuration - SubCommand 0x14
++
++This command allows users to store any duration that they are interested in BMC.
++
++Request
++
++| Byte(s)        | Value         | Data                                   |
++| -------------- | ------------- | -------------------------------------- |
++| 0x00           | 0x14          | Subcommand                             |
++| 0x01..0x08     | Duration      | Self measured duration in milliseconds |
++| 0x09           | Length (N)    | Length of duration name                |
++| 0x0A..0x0A + N | Duration name | Duration name ([0-9a-ZA-Z_] only)      |
++
+ ### SysGetAccelVrSettings - SubCommand 0x15
+ 
+ Get the accel's VR setting value for the given chip and settings ID
+diff --git a/boot_time_monitor.cpp b/boot_time_monitor.cpp
+new file mode 100644
+index 0000000..8c18162
+--- /dev/null
++++ b/boot_time_monitor.cpp
+@@ -0,0 +1,135 @@
++/*
++ * Copyright 2022 Google Inc.
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#include "boot_time_monitor.hpp"
++
++#include "commands.hpp"
++#include "errors.hpp"
++#include "handler.hpp"
++
++#include <cstdint>
++#include <cstring>
++#include <ipmid/api-types.hpp>
++#include <optional>
++#include <regex>
++#include <span>
++#include <string>
++#include <vector>
++
++namespace google
++{
++namespace ipmi
++{
++Resp sendRebootCheckpoint(std::span<const uint8_t> data,
++                          const HandlerInterface* handler)
++{
++    constexpr auto kNameOffset = sizeof(struct CheckpointReqHeader);
++    if (data.size() < kNameOffset ||
++        data.size() < kNameOffset + data[offsetof(CheckpointReqHeader, length)])
++    {
++        std::fprintf(stderr, "Invalid command length: %u\n",
++                     static_cast<unsigned int>(data.size()));
++        return ::ipmi::responseReqDataLenInvalid();
++    }
++    const auto kNameLen = data[offsetof(CheckpointReqHeader, length)];
++
++    const std::string name{data.data() + kNameOffset,
++                           data.data() + kNameOffset + kNameLen};
++    std::fprintf(stderr, "name = %s", name.c_str());
++    if (std::regex_search(name, std::regex("[^0-9a-zA-Z_]")))
++    {
++        std::fprintf(stderr,
++                     "Invalid checkpoint name, only [0-9a-zA-Z_] are allowed");
++        return ::ipmi::responseParmOutOfRange();
++    }
++
++    int64_t wallTime = 0, duration = 0;
++    memcpy(&wallTime, data.data() + offsetof(CheckpointReqHeader, wallTime),
++           sizeof(wallTime));
++    memcpy(&duration, data.data() + offsetof(CheckpointReqHeader, duration),
++           sizeof(duration));
++
++    try
++    {
++        handler->sendRebootCheckpoint(name, wallTime, duration);
++    }
++    catch (const IpmiException& e)
++    {
++        return ::ipmi::response(e.getIpmiError());
++    }
++
++    return ::ipmi::responseSuccess(SysOEMCommands::SysSendRebootCheckpoint,
++                                   std::vector<uint8_t>{});
++}
++
++Resp sendRebootComplete([[maybe_unused]] std::span<const uint8_t> data,
++                        const HandlerInterface* handler)
++{
++    try
++    {
++        handler->sendRebootComplete();
++    }
++    catch (const IpmiException& e)
++    {
++        return ::ipmi::response(e.getIpmiError());
++    }
++
++    return ::ipmi::responseSuccess(SysOEMCommands::SysSendRebootComplete,
++                                   std::vector<uint8_t>{});
++}
++
++Resp sendRebootAdditionalDuration(std::span<const uint8_t> data,
++                                  const HandlerInterface* handler)
++{
++    constexpr auto kNameOffset = sizeof(struct DurationReqHeader);
++    if (data.size() < kNameOffset ||
++        data.size() < kNameOffset + data[offsetof(DurationReqHeader, length)])
++    {
++        std::fprintf(stderr, "Invalid command length: %u\n",
++                     static_cast<unsigned int>(data.size()));
++        return ::ipmi::responseReqDataLenInvalid();
++    }
++    const auto kNameLen = data[offsetof(DurationReqHeader, length)];
++
++    const std::string name{data.data() + kNameOffset,
++                           data.data() + kNameOffset + kNameLen};
++    if (std::regex_search(name, std::regex("[^0-9a-zA-Z_]")))
++    {
++        std::fprintf(stderr,
++                     "Invalid duration name, only [0-9a-zA-Z_] are allowed");
++        return ::ipmi::responseParmOutOfRange();
++    }
++
++    int64_t duration = 0;
++    memcpy(&duration, data.data() + offsetof(DurationReqHeader, duration),
++           sizeof(duration));
++
++    try
++    {
++        handler->sendRebootAdditionalDuration(name, duration);
++    }
++    catch (const IpmiException& e)
++    {
++        return ::ipmi::response(e.getIpmiError());
++    }
++
++    return ::ipmi::responseSuccess(
++        SysOEMCommands::SysSendRebootAdditionalDuration,
++        std::vector<uint8_t>{});
++}
++
++} // namespace ipmi
++} // namespace google
+diff --git a/boot_time_monitor.hpp b/boot_time_monitor.hpp
+new file mode 100644
+index 0000000..0bea4bd
+--- /dev/null
++++ b/boot_time_monitor.hpp
+@@ -0,0 +1,50 @@
++// Copyright 2021 Google LLC
++//
++// Licensed under the Apache License, Version 2.0 (the "License");
++// you may not use this file except in compliance with the License.
++// You may obtain a copy of the License at
++//
++//      http://www.apache.org/licenses/LICENSE-2.0
++//
++// Unless required by applicable law or agreed to in writing, software
++// distributed under the License is distributed on an "AS IS" BASIS,
++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++// See the License for the specific language governing permissions and
++// limitations under the License.
++
++#pragma once
++
++#include "handler.hpp"
++
++#include <ipmid/api.h>
++
++#include <ipmid/api-types.hpp>
++#include <span>
++
++namespace google
++{
++namespace ipmi
++{
++
++struct CheckpointReqHeader
++{
++    int64_t wallTime;
++    int64_t duration;
++    uint8_t length;
++} __attribute__((packed));
++
++struct DurationReqHeader
++{
++    int64_t duration;
++    uint8_t length;
++} __attribute__((packed));
++
++Resp sendRebootCheckpoint(std::span<const uint8_t> data,
++                          const HandlerInterface* handler);
++Resp sendRebootComplete(std::span<const uint8_t> data,
++                        const HandlerInterface* handler);
++Resp sendRebootAdditionalDuration(std::span<const uint8_t> data,
++                                  const HandlerInterface* handler);
++
++} // namespace ipmi
++} // namespace google
+diff --git a/handler.cpp b/handler.cpp
+index 2bcb634..7b051f3 100644
+--- a/handler.cpp
++++ b/handler.cpp
+@@ -753,6 +753,81 @@ void Handler::linuxBootDone() const
+     }
+ }
+ 
++constexpr std::string_view BTMONITOR_SERVICE =
++    "com.google.gbmc.boot_time_monitor";
++constexpr std::string_view BTMONITOR_OBJECT =
++    "/xyz/openbmc_project/time/boot/host0";
++constexpr std::string_view BTMONITOR_CHECKPOINT_INTERFACE =
++    "xyz.openbmc_project.Time.Boot.Checkpoint";
++constexpr std::string_view BTMONITOR_SETCHECKPOINT = "SetCheckpoint";
++constexpr std::string_view BTMONITOR_COMPLETE = "RebootComplete";
++constexpr std::string_view BTMONITOR_DURATION_INTERFACE =
++    "xyz.openbmc_project.Time.Boot.Duration";
++constexpr std::string_view BTMONITOR_SETDURATION = "SetDuration";
++
++void Handler::sendRebootCheckpoint(std::string_view name, int64_t wallTime,
++                                   int64_t duration) const
++{
++    try
++    {
++        auto bus = getDbus();
++        auto method = bus.new_method_call(BTMONITOR_SERVICE.data(),
++                                          BTMONITOR_OBJECT.data(),
++                                          BTMONITOR_CHECKPOINT_INTERFACE.data(),
++                                          BTMONITOR_SETCHECKPOINT.data());
++        method.append(name.data());
++        method.append(wallTime);
++        method.append(duration);
++        bus.call_noreply(method);
++    }
++    catch (const sdbusplus::exception::SdBusError& ex)
++    {
++        std::fprintf(stderr, "Failed to call btmanager `SetCheckpoint`: %s",
++                     ex.what());
++        throw IpmiException(::ipmi::ccUnspecifiedError);
++    }
++}
++
++void Handler::sendRebootComplete() const
++{
++    try
++    {
++        auto bus = getDbus();
++        auto method = bus.new_method_call(
++            BTMONITOR_SERVICE.data(), BTMONITOR_OBJECT.data(),
++            BTMONITOR_CHECKPOINT_INTERFACE.data(), BTMONITOR_COMPLETE.data());
++
++        bus.call_noreply(method);
++    }
++    catch (const sdbusplus::exception::SdBusError& ex)
++    {
++        std::fprintf(stderr, "Failed to call btmanager `Complete`: %s",
++                     ex.what());
++        throw IpmiException(::ipmi::ccUnspecifiedError);
++    }
++}
++
++void Handler::sendRebootAdditionalDuration(std::string_view name,
++                                           int64_t duration) const
++{
++    try
++    {
++        auto bus = getDbus();
++        auto method = bus.new_method_call(
++            BTMONITOR_SERVICE.data(), BTMONITOR_OBJECT.data(),
++            BTMONITOR_DURATION_INTERFACE.data(), BTMONITOR_SETDURATION.data());
++        method.append(name.data());
++        method.append(duration);
++        bus.call_noreply(method);
++    }
++    catch (const sdbusplus::exception::SdBusError& ex)
++    {
++        std::fprintf(stderr, "Failed to call btmanager `SetDuration`: %s",
++                     ex.what());
++        throw IpmiException(::ipmi::ccUnspecifiedError);
++    }
++}
++
+ static constexpr char ACCEL_POWER_SERVICE[] = "xyz.openbmc_project.AccelPower";
+ static constexpr char ACCEL_POWER_PATH_PREFIX[] =
+     "/xyz/openbmc_project/control/accel_power_";
+diff --git a/handler.hpp b/handler.hpp
+index d805b56..5b3328e 100644
+--- a/handler.hpp
++++ b/handler.hpp
+@@ -216,6 +216,35 @@ class HandlerInterface
+      */
+     virtual void linuxBootDone() const = 0;
+ 
++    /**
++     * Send checkpoint to BMC to monitor reboot process.
++     *
++     * @param[in] name - Checkpoint name.
++     * @param[in] wallTime - Current epoch time in microseconds.
++     * @param[in] duration - Self measured duration in microsecond.
++     * @throw IpmiException on failure.
++     */
++    virtual void sendRebootCheckpoint(std::string_view name, int64_t wallTime,
++                                      int64_t duration) const = 0;
++
++    /**
++     * Inform BMC that current reboot process is completed.
++     *
++     * @throw IpmiException on failure.
++     */
++    virtual void sendRebootComplete() const = 0;
++
++    /**
++     * Send additional durations to BMC to store any duration that user is
++     * interested.
++     *
++     * @param[in] name - Duration name.
++     * @param[in] duration - duration in millisecond.
++     * @throw IpmiException on failure.
++     */
++    virtual void sendRebootAdditionalDuration(std::string_view name,
++                                              int64_t duration) const = 0;
++
+     /**
+      * Update the VR settings for the given settings_id
+      *
+diff --git a/handler_impl.hpp b/handler_impl.hpp
+index 7fbae3e..10ba504 100644
+--- a/handler_impl.hpp
++++ b/handler_impl.hpp
+@@ -84,6 +84,11 @@ class Handler : public HandlerInterface
+     void accelOobWrite(std::string_view name, uint64_t address,
+                        uint8_t num_bytes, uint64_t data) const override;
+     void linuxBootDone() const override;
++    void sendRebootComplete() const override;
++    void sendRebootCheckpoint(std::string_view name, int64_t wallTime,
++                              int64_t duration) const override;
++    void sendRebootAdditionalDuration(std::string_view name,
++                                      int64_t duration) const override;
+     void accelSetVrSettings(::ipmi::Context::ptr ctx, uint8_t chip_id,
+                             uint8_t settings_id, uint16_t value) const override;
+     uint16_t accelGetVrSettings(::ipmi::Context::ptr ctx, uint8_t chip_id,
+diff --git a/ipmi.cpp b/ipmi.cpp
+index 170304d..836f57f 100644
+--- a/ipmi.cpp
++++ b/ipmi.cpp
+@@ -18,6 +18,7 @@
+ 
+ #include "bm_instance.hpp"
+ #include "bmc_mode.hpp"
++#include "boot_time_monitor.hpp"
+ #include "cable.hpp"
+ #include "commands.hpp"
+ #include "cpld.hpp"
+@@ -90,6 +91,12 @@ Resp handleSysCommand(HandlerInterface* handler, ::ipmi::Context::ptr ctx,
+             return pcieBifurcation(ctx, data, handler, DYNAMIC_BIFURCATION);
+         case SysLinuxBootDone:
+             return linuxBootDone(data, handler);
++        case SysSendRebootCheckpoint:
++            return sendRebootCheckpoint(data, handler);
++        case SysSendRebootComplete:
++            return sendRebootComplete(data, handler);
++        case SysSendRebootAdditionalDuration:
++            return sendRebootAdditionalDuration(data, handler);
+         case SysGetAccelVrSettings:
+             return accelGetVrSettings(ctx, data, handler);
+         case SysSetAccelVrSettings:
+diff --git a/meson.build b/meson.build
+index e1145d7..b7e3f44 100644
+--- a/meson.build
++++ b/meson.build
+@@ -60,6 +60,7 @@ sys_lib = static_library(
+   'eth.cpp',
+   'flash_size.cpp',
+   'handler.cpp',
++  'boot_time_monitor.cpp',
+   'host_power_off.cpp',
+   'ipmi.cpp',
+   'linux_boot_done.cpp',
+diff --git a/test/boot_time_monitor_unittest.cpp b/test/boot_time_monitor_unittest.cpp
+new file mode 100644
+index 0000000..be597af
+--- /dev/null
++++ b/test/boot_time_monitor_unittest.cpp
+@@ -0,0 +1,211 @@
++// Copyright 2021 Google LLC
++//
++// Licensed under the Apache License, Version 2.0 (the "License");
++// you may not use this file except in compliance with the License.
++// You may obtain a copy of the License at
++//
++//      http://www.apache.org/licenses/LICENSE-2.0
++//
++// Unless required by applicable law or agreed to in writing, software
++// distributed under the License is distributed on an "AS IS" BASIS,
++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++// See the License for the specific language governing permissions and
++// limitations under the License.
++
++#include "boot_time_monitor.hpp"
++#include "commands.hpp"
++#include "errors.hpp"
++#include "handler_mock.hpp"
++#include "helper.hpp"
++
++#include <cstdint>
++#include <memory>
++#include <string>
++#include <vector>
++
++#include <gtest/gtest.h>
++
++namespace google
++{
++namespace ipmi
++{
++
++using ::testing::Return;
++using ::testing::Throw;
++
++constexpr uint32_t cpHeadLen = sizeof(struct CheckpointReqHeader);
++constexpr uint32_t durHeadLen = sizeof(struct DurationReqHeader);
++
++TEST(SendRebootCheckpointTest, RequestLenTest)
++{
++    HandlerMock hMock;
++    std::vector<uint8_t> request = {};
++
++    // Empty request test
++    EXPECT_EQ(::ipmi::responseReqDataLenInvalid(),
++              sendRebootCheckpoint(request, &hMock));
++
++    constexpr std::string_view kName = "GoodName";
++    constexpr uint32_t kExtraSize = 1;
++    CheckpointReqHeader r = {
++        .wallTime = 0,
++        .duration = 0,
++        .length = kName.size(),
++    };
++    request.resize(cpHeadLen + kName.size());
++
++    // Test if request len is correct.
++    // Expect OK
++    memcpy(request.data(), &r, cpHeadLen);
++    memcpy(request.data() + cpHeadLen, kName.data(), r.length);
++    EXPECT_NO_THROW(sendRebootCheckpoint(request, &hMock));
++
++    // Test if request is too long
++    // Expect OK
++    r.length = kName.size() - kExtraSize;
++    memcpy(request.data(), &r, cpHeadLen);
++    memcpy(request.data() + cpHeadLen, kName.data(), r.length);
++    EXPECT_NO_THROW(sendRebootCheckpoint(request, &hMock));
++
++    // Test if request is too short
++    // Expect Error
++    r.length = kName.size() + kExtraSize;
++    memcpy(request.data(), &r, cpHeadLen);
++    memcpy(request.data() + cpHeadLen, kName.data(), kName.size());
++    EXPECT_EQ(::ipmi::responseReqDataLenInvalid(),
++              sendRebootCheckpoint(request, &hMock));
++}
++
++TEST(SendRebootCheckpointTest, InvalidName)
++{
++    HandlerMock hMock;
++    constexpr std::string_view kName = "+BadName-";
++    std::vector<uint8_t> request(cpHeadLen + kName.size());
++
++    CheckpointReqHeader r = {
++        .wallTime = 0,
++        .duration = 0,
++        .length = kName.size(),
++    };
++    memcpy(request.data(), &r, cpHeadLen + kName.size());
++    memcpy(request.data() + cpHeadLen, kName.data(), kName.size());
++    EXPECT_EQ(::ipmi::responseParmOutOfRange(),
++              sendRebootCheckpoint(request, &hMock));
++}
++
++TEST(SendRebootCheckpointTest, DBusCallThrow)
++{
++    HandlerMock hMock;
++    constexpr std::string_view kName = "GoodName";
++    std::vector<uint8_t> request(cpHeadLen + kName.size());
++
++    CheckpointReqHeader r = {
++        .wallTime = 0,
++        .duration = 0,
++        .length = kName.size(),
++    };
++    memcpy(request.data(), &r, cpHeadLen + kName.size());
++    memcpy(request.data() + cpHeadLen, kName.data(), kName.size());
++
++    EXPECT_CALL(hMock, sendRebootCheckpoint(kName, r.wallTime, r.duration))
++        .WillOnce(Throw(IpmiException(::ipmi::ccUnspecifiedError)));
++    EXPECT_EQ(::ipmi::response(
++                  IpmiException(::ipmi::ccUnspecifiedError).getIpmiError()),
++              sendRebootCheckpoint(request, &hMock));
++}
++
++TEST(SendRebootComplete, Success)
++{
++    HandlerMock hMock;
++
++    EXPECT_NO_THROW(sendRebootComplete(std::vector<uint8_t>{}, &hMock));
++}
++
++TEST(SendRebootComplete, DBusCallThrow)
++{
++    HandlerMock hMock;
++
++    EXPECT_CALL(hMock, sendRebootComplete())
++        .WillOnce(Throw(IpmiException(::ipmi::ccUnspecifiedError)));
++    EXPECT_EQ(::ipmi::response(
++                  IpmiException(::ipmi::ccUnspecifiedError).getIpmiError()),
++              sendRebootComplete(std::vector<uint8_t>{}, &hMock));
++}
++
++TEST(SendRebootAdditionalDurationTest, RequestLenTest)
++{
++    HandlerMock hMock;
++    std::vector<uint8_t> request = {};
++
++    // Empty request test
++    EXPECT_EQ(::ipmi::responseReqDataLenInvalid(),
++              sendRebootAdditionalDuration(request, &hMock));
++
++    constexpr std::string_view kName = "GoodName";
++    constexpr uint32_t kExtraSize = 1;
++    DurationReqHeader r = {
++        .duration = 0,
++        .length = kName.size(),
++    };
++    request.resize(durHeadLen + kName.size());
++
++    // Test if request len is correct.
++    // Expect OK
++    memcpy(request.data(), &r, durHeadLen);
++    memcpy(request.data() + durHeadLen, kName.data(), r.length);
++    EXPECT_NO_THROW(sendRebootAdditionalDuration(request, &hMock));
++
++    // Test if request is too long
++    // Expect OK
++    r.length = kName.size() - kExtraSize;
++    memcpy(request.data(), &r, durHeadLen);
++    memcpy(request.data() + durHeadLen, kName.data(), r.length);
++    EXPECT_NO_THROW(sendRebootAdditionalDuration(request, &hMock));
++
++    // Test if request is too short
++    // Expect Error
++    r.length = kName.size() + kExtraSize;
++    memcpy(request.data(), &r, durHeadLen);
++    memcpy(request.data() + durHeadLen, kName.data(), kName.size());
++    EXPECT_EQ(::ipmi::responseReqDataLenInvalid(),
++              sendRebootAdditionalDuration(request, &hMock));
++}
++
++TEST(SendRebootAdditionalDurationTest, InvalidName)
++{
++    HandlerMock hMock;
++    constexpr std::string_view kName = "+BadName-";
++    std::vector<uint8_t> request(durHeadLen + kName.size());
++
++    DurationReqHeader r = {
++        .duration = 0,
++        .length = kName.size(),
++    };
++    memcpy(request.data(), &r, durHeadLen + kName.size());
++    memcpy(request.data() + durHeadLen, kName.data(), kName.size());
++    EXPECT_EQ(::ipmi::responseParmOutOfRange(),
++              sendRebootAdditionalDuration(request, &hMock));
++}
++
++TEST(SendRebootAdditionalDurationTest, DBusCallThrow)
++{
++    HandlerMock hMock;
++    constexpr std::string_view kName = "GoodName";
++    std::vector<uint8_t> request(durHeadLen + kName.size());
++
++    DurationReqHeader r = {
++        .duration = 0,
++        .length = kName.size(),
++    };
++    memcpy(request.data(), &r, durHeadLen + kName.size());
++    memcpy(request.data() + durHeadLen, kName.data(), kName.size());
++
++    EXPECT_CALL(hMock, sendRebootAdditionalDuration(kName, r.duration))
++        .WillOnce(Throw(IpmiException(::ipmi::ccUnspecifiedError)));
++    EXPECT_EQ(::ipmi::response(
++                  IpmiException(::ipmi::ccUnspecifiedError).getIpmiError()),
++              sendRebootAdditionalDuration(request, &hMock));
++}
++
++} // namespace ipmi
++} // namespace google
+diff --git a/test/handler_mock.hpp b/test/handler_mock.hpp
+index c5b2df0..7a3e96b 100644
+--- a/test/handler_mock.hpp
++++ b/test/handler_mock.hpp
+@@ -67,6 +67,12 @@ class HandlerMock : public HandlerInterface
+     MOCK_METHOD(std::vector<uint8_t>, pcieBifurcation,
+                 (::ipmi::Context::ptr, uint8_t, bool), (override));
+     MOCK_METHOD(void, linuxBootDone, (), (const, override));
++    MOCK_METHOD((void), sendRebootCheckpoint,
++                (std::string_view name, int64_t wallTime, int64_t duration),
++                (const, override));
++    MOCK_METHOD((void), sendRebootComplete, (), (const, override));
++    MOCK_METHOD((void), sendRebootAdditionalDuration,
++                (std::string_view name, int64_t duration), (const, override));
+     MOCK_METHOD(void, accelSetVrSettings,
+                 (::ipmi::Context::ptr, uint8_t, uint8_t, uint16_t),
+                 (const, override));
+diff --git a/test/handler_unittest.cpp b/test/handler_unittest.cpp
+index aabec39..ec0fdfc 100644
+--- a/test/handler_unittest.cpp
++++ b/test/handler_unittest.cpp
+@@ -307,8 +307,8 @@ void ExpectGetManagedObjects(StrictMock<sdbusplus::SdBusMock>& mock,
+ }
+ 
+ void ExpectSdBusError(StrictMock<sdbusplus::SdBusMock>& mock,
+-                      const std::string& service, const std::string& objPath,
+-                      const std::string& interface, const std::string& function)
++                      std::string_view service, std::string_view objPath,
++                      std::string_view interface, std::string_view function)
+ {
+     EXPECT_CALL(
+         mock, sd_bus_message_new_method_call(_,         // sd_bus *bus,
+@@ -866,6 +866,198 @@ TEST(HandlerTest, PcieBifurcationDynamic)
+     std::remove(testFilename);
+ }
+ 
++constexpr std::string_view BTMONITOR_SERVICE =
++    "com.google.gbmc.boot_time_monitor";
++constexpr std::string_view BTMONITOR_OBJECT =
++    "/xyz/openbmc_project/time/boot/host0";
++constexpr std::string_view BTMONITOR_CHECKPOINT_INTERFACE =
++    "xyz.openbmc_project.Time.Boot.Checkpoint";
++constexpr std::string_view BTMONITOR_SETCHECKPOINT = "SetCheckpoint";
++constexpr std::string_view BTMONITOR_COMPLETE = "RebootComplete";
++constexpr std::string_view BTMONITOR_DURATION_INTERFACE =
++    "xyz.openbmc_project.Time.Boot.Duration";
++constexpr std::string_view BTMONITOR_SETDURATION = "SetDuration";
++
++void expectSendCheckpoint(StrictMock<sdbusplus::SdBusMock>& mock,
++                          std::string_view kName, int64_t kWallTime,
++                          int64_t kDur)
++{
++    ::testing::InSequence s;
++
++    constexpr sd_bus_message* method = nullptr;
++
++    EXPECT_CALL(mock, sd_bus_message_new_method_call(
++                          _,         // sd_bus *bus,
++                          NotNull(), // sd_bus_message **m
++                          StrEq(BTMONITOR_SERVICE), StrEq(BTMONITOR_OBJECT),
++                          StrEq(BTMONITOR_CHECKPOINT_INTERFACE),
++                          StrEq(BTMONITOR_SETCHECKPOINT)))
++        .WillOnce(DoAll(TraceDbus("sd_bus_message_new_method_call"),
++                        SetArgPointee<1>(method), Return(0)));
++
++    EXPECT_CALL(mock, sd_bus_message_append_basic(
++                          method, SD_BUS_TYPE_STRING,
++                          MatcherCast<const void*>(SafeMatcherCast<const char*>(
++                              StrEq(kName.data())))))
++        .WillOnce(DoAll(TraceDbus("sd_bus_message_append_basic"), Return(1)));
++
++    EXPECT_CALL(
++        mock, sd_bus_message_append_basic(
++                  method, SD_BUS_TYPE_INT64,
++                  MatcherCast<const void*>(
++                      SafeMatcherCast<const int64_t*>(Pointee(Eq(kWallTime))))))
++        .WillOnce(
++            DoAll(TraceDbus2("sd_bus_message_append_basic(kWallTime) -> 1"),
++                  Return(1)));
++
++    EXPECT_CALL(mock,
++                sd_bus_message_append_basic(
++                    method, SD_BUS_TYPE_INT64,
++                    MatcherCast<const void*>(
++                        SafeMatcherCast<const int64_t*>(Pointee(Eq(kDur))))))
++        .WillOnce(DoAll(TraceDbus2("sd_bus_message_append_basic(kDur) -> 1"),
++                        Return(1)));
++
++    EXPECT_CALL(mock, sd_bus_call(_,         // sd_bus *bus,
++                                  method,    // sd_bus_message *m
++                                  _,         // uint64_t timeout
++                                  NotNull(), // sd_bus_error *ret_error
++                                  IsNull())) // sd_bus_message **reply
++        .WillOnce(DoAll(TraceDbus("sd_bus_call() -> ret_val"),
++                        SetArgPointee<3>(SD_BUS_ERROR_NULL), Return(0)));
++}
++
++void expectSendAdditionalDuration(StrictMock<sdbusplus::SdBusMock>& mock,
++                                  std::string_view kName, int64_t kDur)
++{
++    ::testing::InSequence s;
++
++    constexpr sd_bus_message* method = nullptr;
++
++    EXPECT_CALL(mock, sd_bus_message_new_method_call(
++                          _,         // sd_bus *bus,
++                          NotNull(), // sd_bus_message **m
++                          StrEq(BTMONITOR_SERVICE), StrEq(BTMONITOR_OBJECT),
++                          StrEq(BTMONITOR_DURATION_INTERFACE),
++                          StrEq(BTMONITOR_SETDURATION)))
++        .WillOnce(DoAll(TraceDbus("sd_bus_message_new_method_call"),
++                        SetArgPointee<1>(method), Return(0)));
++
++    EXPECT_CALL(mock, sd_bus_message_append_basic(
++                          method, SD_BUS_TYPE_STRING,
++                          MatcherCast<const void*>(SafeMatcherCast<const char*>(
++                              StrEq(kName.data())))))
++        .WillOnce(DoAll(TraceDbus("sd_bus_message_append_basic"), Return(1)));
++
++    EXPECT_CALL(mock,
++                sd_bus_message_append_basic(
++                    method, SD_BUS_TYPE_INT64,
++                    MatcherCast<const void*>(
++                        SafeMatcherCast<const int64_t*>(Pointee(Eq(kDur))))))
++        .WillOnce(DoAll(TraceDbus2("sd_bus_message_append_basic(kDur) -> 1"),
++                        Return(1)));
++
++    EXPECT_CALL(mock, sd_bus_call(_,         // sd_bus *bus,
++                                  method,    // sd_bus_message *m
++                                  _,         // uint64_t timeout
++                                  NotNull(), // sd_bus_error *ret_error
++                                  IsNull())) // sd_bus_message **reply
++        .WillOnce(DoAll(TraceDbus("sd_bus_call() -> ret_val"),
++                        SetArgPointee<3>(SD_BUS_ERROR_NULL), Return(0)));
++}
++
++TEST(HandlerTest, SendRebootCheckpointTest_Success)
++{
++    // Parameters are not important.
++    constexpr std::string_view kName = "NotImportant";
++    constexpr int64_t kWallTime = 0;
++    constexpr int64_t kDur = 0;
++
++    StrictMock<sdbusplus::SdBusMock> mock;
++    MockDbusHandler h(mock);
++
++    expectSendCheckpoint(mock, kName, kWallTime, kDur);
++    EXPECT_NO_THROW(h.sendRebootCheckpoint(kName, kWallTime, kDur));
++}
++
++TEST(HandlerTest, SendRebootCheckpointTest_Fail)
++{
++    // Parameters are not important.
++    constexpr std::string_view kName = "NotImportant";
++    constexpr int64_t kWallTime = 0;
++    constexpr int64_t kDur = 0;
++
++    StrictMock<sdbusplus::SdBusMock> mock;
++    MockDbusHandler h(mock);
++
++    ExpectSdBusError(mock, BTMONITOR_SERVICE, BTMONITOR_OBJECT,
++                     BTMONITOR_CHECKPOINT_INTERFACE, BTMONITOR_SETCHECKPOINT);
++    EXPECT_THROW(h.sendRebootCheckpoint(kName, kWallTime, kDur), IpmiException);
++}
++
++TEST(HandlerTest, sendRebootCompleteTest_Success)
++{
++    StrictMock<sdbusplus::SdBusMock> mock;
++    MockDbusHandler h(mock);
++
++    constexpr sd_bus_message* method = nullptr;
++    EXPECT_CALL(mock, sd_bus_message_new_method_call(
++                          _,         // sd_bus *bus,
++                          NotNull(), // sd_bus_message **m
++                          StrEq(BTMONITOR_SERVICE), StrEq(BTMONITOR_OBJECT),
++                          StrEq(BTMONITOR_CHECKPOINT_INTERFACE),
++                          StrEq(BTMONITOR_COMPLETE)))
++        .WillOnce(DoAll(TraceDbus("sd_bus_message_new_method_call"),
++                        SetArgPointee<1>(method), Return(0)));
++
++    EXPECT_CALL(mock, sd_bus_call(_,         // sd_bus *bus,
++                                  method,    // sd_bus_message *m
++                                  _,         // uint64_t timeout
++                                  NotNull(), // sd_bus_error *ret_error
++                                  IsNull())) // sd_bus_message **reply
++        .WillOnce(DoAll(TraceDbus("sd_bus_call() -> ret_val"),
++                        SetArgPointee<3>(SD_BUS_ERROR_NULL), Return(0)));
++
++    EXPECT_NO_THROW(h.sendRebootComplete());
++}
++
++TEST(HandlerTest, sendRebootCompleteTest_Fail)
++{
++    StrictMock<sdbusplus::SdBusMock> mock;
++    MockDbusHandler h(mock);
++
++    ExpectSdBusError(mock, BTMONITOR_SERVICE, BTMONITOR_OBJECT,
++                     BTMONITOR_CHECKPOINT_INTERFACE, BTMONITOR_COMPLETE);
++    EXPECT_THROW(h.sendRebootComplete(), IpmiException);
++}
++
++TEST(HandlerTest, sendRebootAdditionalDurationTest_Success)
++{
++    // Parameters are not important.
++    constexpr std::string_view kName = "NotImportant";
++    constexpr int64_t kDur = 0;
++
++    StrictMock<sdbusplus::SdBusMock> mock;
++    MockDbusHandler h(mock);
++
++    expectSendAdditionalDuration(mock, kName, kDur);
++    EXPECT_NO_THROW(h.sendRebootAdditionalDuration(kName, kDur));
++}
++
++TEST(HandlerTest, sendRebootAdditionalDurationTest_Fail)
++{
++    // Parameters are not important.
++    constexpr std::string_view kName = "NotImportant";
++    constexpr int64_t kDur = 0;
++
++    StrictMock<sdbusplus::SdBusMock> mock;
++    MockDbusHandler h(mock);
++
++    ExpectSdBusError(mock, BTMONITOR_SERVICE, BTMONITOR_OBJECT,
++                     BTMONITOR_DURATION_INTERFACE, BTMONITOR_SETDURATION);
++    EXPECT_THROW(h.sendRebootAdditionalDuration(kName, kDur), IpmiException);
++}
++
+ // TODO: Add checks for other functions of handler.
+ 
+ } // namespace ipmi
+diff --git a/test/meson.build b/test/meson.build
+index f7e3bb9..d6f50bd 100644
+--- a/test/meson.build
++++ b/test/meson.build
+@@ -23,6 +23,7 @@ tests = [
+   'flash',
+   'google_accel_oob',
+   'handler',
++  'boot_time_monitor',
+   'machine',
+   'pcie',
+   'poweroff',
+-- 
+2.45.1.288.g0e0cd299f1-goog
+