Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 583d34c1 authored by Luis Hector Chavez's avatar Luis Hector Chavez
Browse files

Make bootstat container-friendly 

This change allows bootstat to read the ro.boot.boottime_offset
property, which is set on devices where Android runs in a container.
This is because the CLOCK_BOOTTIME clock is not reset when (from
Android's perspective) the device restarts, since the host OS does not
restart itself.

Bug: 77273909
Test: CtsBootStatsTestCases

Change-Id: Ifb792864394be0b4686cc9d555c0afced856f4b4
parent 14eb6119

bootstat/bootstat.cpp

+23 −7
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 
#include <android-base/file.h>

#include <android-base/logging.h>

#include <android-base/parseint.h>

#include <android-base/properties.h>

#include <android-base/strings.h>

#include <android/log.h>

#include <cutils/android_reboot.h>
@@ -957,14 +958,28 @@ void SetSystemBootReason() { 
  SetProperty(system_reboot_reason_property, system_boot_reason);

}



// Gets the boot time offset. This is useful when Android is running in a

// container, because the boot_clock is not reset when Android reboots.

std::chrono::nanoseconds GetBootTimeOffset() {

  static const int64_t boottime_offset =

      android::base::GetIntProperty<int64_t>("ro.boot.boottime_offset", 0);

  return std::chrono::nanoseconds(boottime_offset);

}



// Returns the current uptime, accounting for any offset in the CLOCK_BOOTTIME

// clock.

android::base::boot_clock::duration GetUptime() {

  return android::base::boot_clock::now().time_since_epoch() - GetBootTimeOffset();

}



// Records several metrics related to the time it takes to boot the device,

// including disambiguating boot time on encrypted or non-encrypted devices.

void RecordBootComplete() {

  BootEventRecordStore boot_event_store;

  BootEventRecordStore::BootEventRecord record;



  auto time_since_epoch = android::base::boot_clock::now().time_since_epoch();

  auto uptime = std::chrono::duration_cast<std::chrono::seconds>(time_since_epoch);

  auto uptime_ns = GetUptime();

  auto uptime_s = std::chrono::duration_cast<std::chrono::seconds>(uptime_ns);

  time_t current_time_utc = time(nullptr);

  time_t time_since_last_boot = 0;
@@ -990,19 +1005,20 @@ void RecordBootComplete() { 
    // Log the amount of time elapsed until the device is decrypted, which

    // includes the variable amount of time the user takes to enter the

    // decryption password.

    boot_event_store.AddBootEventWithValue("boot_decryption_complete", uptime.count());

    boot_event_store.AddBootEventWithValue("boot_decryption_complete", uptime_s.count());



    // Subtract the decryption time to normalize the boot cycle timing.

    std::chrono::seconds boot_complete = std::chrono::seconds(uptime.count() - record.second);

    std::chrono::seconds boot_complete = std::chrono::seconds(uptime_s.count() - record.second);

    boot_event_store.AddBootEventWithValue(boot_complete_prefix + "_post_decrypt",

                                           boot_complete.count());

  } else {

    boot_event_store.AddBootEventWithValue(boot_complete_prefix + "_no_encryption", uptime.count());

    boot_event_store.AddBootEventWithValue(boot_complete_prefix + "_no_encryption",

                                           uptime_s.count());

  }



  // Record the total time from device startup to boot complete, regardless of

  // encryption state.

  boot_event_store.AddBootEventWithValue(boot_complete_prefix, uptime.count());

  boot_event_store.AddBootEventWithValue(boot_complete_prefix, uptime_s.count());



  RecordInitBootTimeProp(&boot_event_store, "ro.boottime.init");

  RecordInitBootTimeProp(&boot_event_store, "ro.boottime.init.selinux");
@@ -1012,7 +1028,7 @@ void RecordBootComplete() { 
  int32_t bootloader_boot_duration = GetBootloaderTime(bootloader_timings);

  RecordBootloaderTimings(&boot_event_store, bootloader_timings);



  auto uptime_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_since_epoch);

  auto uptime_ms = std::chrono::duration_cast<std::chrono::milliseconds>(uptime_ns);

  auto absolute_boot_time = GetAbsoluteBootTime(bootloader_timings, uptime_ms);

  RecordAbsoluteBootTime(&boot_event_store, absolute_boot_time);