Enabling warm reboot and HALT method support in sonic-buildimage in rebootbackend process

Author: rkavitha-hcl

src/sonic-framework/rebootbackend/reboot_thread.cpp

@@ -117,6 +117,10 @@ void RebootThread::do_reboot(void) {
 
   if (m_request.method() == RebootMethod::COLD) {
     do_cold_reboot(s);
+  } else if (m_request.method() == RebootMethod::HALT) {
+    do_halt_reboot(s);
+  } else if (m_request.method() == RebootMethod::WARM) {
+    do_warm_reboot(s);
   } else {
     // This shouldn't be possible. Reference check_start_preconditions()
     SWSS_LOG_ERROR("Received unrecognized method type = %s",
@@ -163,6 +167,45 @@ void RebootThread::do_cold_reboot(swss::Select &s) {
   // We shouldn't be here. Platform reboot should've killed us.
   log_error_and_set_non_retry_failure("platform failed to reboot");
 
+  // Set critical state
+  // m_critical_interface.report_critical_state("platform failed to reboot");
+  return;
+}
+
+void RebootThread::do_halt_reboot(swss::Select &s) {
+  SWSS_LOG_ENTER();
+  SWSS_LOG_NOTICE("Sending halt reboot request to platform");
+  if (send_dbus_reboot_request() == Progress::EXIT_EARLY) {
+    return;
+  }
+
+  // Wait for platform to reboot. If we return, reboot failed.
+  // Logging, error status and monitoring for critical state are handled within.
+  if (wait_for_platform_reboot(s) == Progress::EXIT_EARLY) {
+    return;
+  }
+
+  // We shouldn't be here. Platform reboot halt should've killed us.
+  log_error_and_set_non_retry_failure("platform failed to halt the system");
+
+  return;
+}
+
+void RebootThread::do_warm_reboot(swss::Select &s) {
+  SWSS_LOG_ENTER();
+  SWSS_LOG_NOTICE("Sending warm reboot request to platform");
+  if (send_dbus_reboot_request() == Progress::EXIT_EARLY) {
+    return;
+  }
+
+  // Wait for warm reboot. If we return, reboot failed.
+  if (wait_for_platform_reboot(s) == Progress::EXIT_EARLY) {
+    return;
+  }
+
+  // We shouldn't be here. Platform reboot should've killed us.
+  log_error_and_set_non_retry_failure("failed to warm reboot");
+
   return;
 }
 
@@ -184,9 +227,19 @@ bool RebootThread::check_start_preconditions(const RebootRequest &request,
     response.json_string = "RebootThread: can't Start while active";
     response.status = swss::StatusCode::SWSS_RC_IN_USE;
   } else if (request.method() != RebootMethod::COLD &&
+             request.method() != RebootMethod::HALT &&
              request.method() != RebootMethod::WARM) {
     response.json_string = "RebootThread: Start rx'd unsupported method";
     response.status = swss::StatusCode::SWSS_RC_INVALID_PARAM;
+  } else if (request.method() == RebootMethod::WARM) {
+    if (m_status.get_last_reboot_status() ==
+        RebootStatus_Status::RebootStatus_Status_STATUS_FAILURE) {
+      // If the last reboot failed with a non-retriable failure, don't retry.
+      // But, we will allow a cold boot to recover.
+      response.json_string =
+          "RebootThread: last WARM reboot failed with non-retriable failure";
+      response.status = swss::StatusCode::SWSS_RC_FAILED_PRECONDITION;
+    }
   } else if (request.delay() != 0) {
     response.json_string = "RebootThread: delayed start not supported";
     response.status = swss::StatusCode::SWSS_RC_INVALID_PARAM;

src/sonic-framework/rebootbackend/reboot_thread.h

@@ -32,7 +32,7 @@ class ThreadStatus {
     // Number of reboots since active.
     m_proto_status.set_count(0);
 
-    // RebootMethod is type of of reboot: cold, warm, fast from a
+    // RebootMethod is type of of reboot: cold, halt, warm, fast from a
     // RebootRequest
     m_proto_status.set_method(gnoi::system::RebootMethod::UNKNOWN);
 
@@ -161,6 +161,8 @@ class RebootThread {
   void do_reboot(void);
   Progress send_dbus_reboot_request();
   void do_cold_reboot(swss::Select &s);
+  void do_halt_reboot(swss::Select &s);
+  void do_warm_reboot(swss::Select &s);
 
   // Inner loop select handler to wait for platform reboot.
   //   wait for timeout

src/sonic-framework/rebootbackend/rebootbe.cpp

@@ -149,7 +149,7 @@ NotificationResponse RebootBE::HandleRebootRequest(
   if (!RebootAllowed(request.method())) {
     response.status = swss::StatusCode::SWSS_RC_IN_USE;
     response.json_string =
-        "Reboot not allowed at this time. Reboot or "
+        "Reboot not allowed at this time. Reboot, halt or "
         "post-warmboot in progress";
     SWSS_LOG_WARN("%s", response.json_string.c_str());
     return response;
@@ -161,6 +161,8 @@ NotificationResponse RebootBE::HandleRebootRequest(
   if (response.status == swss::StatusCode::SWSS_RC_SUCCESS) {
     if (request.method() == gnoi::system::RebootMethod::COLD) {
       SetCurrentStatus(RebManagerStatus::COLD_REBOOT_IN_PROGRESS);
+    } else if (request.method() == gnoi::system::RebootMethod::HALT) {
+      SetCurrentStatus(RebManagerStatus::HALT_REBOOT_IN_PROGRESS);
     } else if (request.method() == gnoi::system::RebootMethod::WARM) {
       SetCurrentStatus(RebManagerStatus::WARM_REBOOT_IN_PROGRESS);
     }
@@ -172,6 +174,7 @@ bool RebootBE::RebootAllowed(const gnoi::system::RebootMethod rebMethod) {
   RebManagerStatus current_status = GetCurrentStatus();
   switch (current_status) {
     case RebManagerStatus::COLD_REBOOT_IN_PROGRESS:
+    case RebManagerStatus::HALT_REBOOT_IN_PROGRESS:
     case RebManagerStatus::WARM_REBOOT_IN_PROGRESS: {
       return false;
     }

src/sonic-framework/rebootbackend/rebootbe.h

@@ -24,6 +24,7 @@ class RebootBE {
     WARM_INIT_WAIT,
     IDLE,
     COLD_REBOOT_IN_PROGRESS,
+    HALT_REBOOT_IN_PROGRESS,
     WARM_REBOOT_IN_PROGRESS
   };
 

src/sonic-framework/tests/reboot_thread_test.cpp

@@ -91,6 +91,38 @@ TEST_F(RebootStatusTest, TestGetStatus) {
   EXPECT_EQ(0, response.when());
 }
 
+TEST_F(RebootStatusTest, TestHaltGetStatus) {
+  std::chrono::nanoseconds curr_ns =
+      std::chrono::high_resolution_clock::now().time_since_epoch();
+
+  m_status.set_start_status(gnoi::system::RebootMethod::HALT, "reboot because");
+
+  gnoi::system::RebootStatusResponse response = m_status.get_response();
+  EXPECT_EQ(
+      response.status().status(),
+      gnoi::system::RebootStatus_Status::RebootStatus_Status_STATUS_UNKNOWN);
+
+  m_status.set_completed_status(
+      gnoi::system::RebootStatus_Status::RebootStatus_Status_STATUS_SUCCESS,
+      "anything");
+
+  response = m_status.get_response();
+
+  // message should be empty while reboot is active
+  EXPECT_THAT(response.status().message(), StrEq(""));
+
+  uint64_t reboot_ns = response.when();
+  EXPECT_TRUE(reboot_ns > (uint64_t)curr_ns.count());
+
+  m_status.set_inactive();
+  response = m_status.get_response();
+  EXPECT_THAT(response.status().message(), StrEq("anything"));
+  EXPECT_EQ(
+      response.status().status(),
+      gnoi::system::RebootStatus_Status::RebootStatus_Status_STATUS_SUCCESS);
+  EXPECT_EQ(0, response.when());
+}
+
 TEST_F(RebootStatusTest, TestGetWarmStatus) {
   std::chrono::nanoseconds curr_ns =
       std::chrono::high_resolution_clock::now().time_since_epoch();