Measure and send update duration (and corresponding uptime) to UMA
This patch introduces two new metrics, Installer.UpdateDuration and
Installer.UpdateDurationUptime. The former is the timespan from when
the update was first discovered until it has been downloaded and
applied (including the time the device is suspended or powered
off). The latter is similar, but without taking into account time
spent in suspend or powered off.
For example, if the device is suspended (or powered off) for N seconds
while updating, the Installer.UpdateDuration metric will be N seconds
bigger than Installer.UpdateDurationUptime metric:
Histogram: Installer.UpdateDuration recorded 1 samples, average = 313.0
Histogram: Installer.UpdateDurationUptime recorded 1 samples, average = 251.0
Also remove the existing Installer.UpdateTime metric as this didn't
take process restarts into account and is now superseeded by the
Installer.UpdateDuration metric.
This is done by using the CLOCK_MONOTONIC_RAW clock (available in
Linux 2.6.28 and later) since this clock indeed does not advance when
the system is sleeping.
We use the PayloadState class to persist recorded data across
update_engine process restart (including device reboots).
Since clock_gettime(2) and CLOCK_MONOTONIC_RAW requires linking to the
librt library do this and also request the system header files to
expose the required symbols and defines, i.e. define _POSIX_C_SOURCE
>= 199309L.
Also remove _POSIX_C_SOURCE mangling from update_attempter.cc since
it's actually not needed there and generally it's better to make the
environment the same across all translation units (by putting whatever
is needed in e.g. CCFLAGS).
BUG=chromium:226763
TEST=unit tests, force update, examine chrome://histograms
Change-Id: I883668564b5fa78ff3e19156bd77496ff929ca58
Signed-off-by: David Zeuthen <[email protected]>
Reviewed-on: https://gerrit.chromium.org/gerrit/47928
Reviewed-by: Jay Srinivasan <[email protected]>
diff --git a/SConstruct b/SConstruct
index 85a11d1..78e50b6 100644
--- a/SConstruct
+++ b/SConstruct
@@ -191,6 +191,7 @@
-Wuninitialized
-D__STDC_FORMAT_MACROS=1
-D_FILE_OFFSET_BITS=64
+ -D_POSIX_C_SOURCE=199309L
-I/usr/include/libxml2""".split());
env['CCFLAGS'] += (' ' + ' '.join(env['CFLAGS']))
@@ -208,6 +209,7 @@
protobuf
pthread
rootdev
+ rt
ssl
udev
xml2""" % BASE_VER)
diff --git a/constants.cc b/constants.cc
index f9c6ce5..de7bb91 100644
--- a/constants.cc
+++ b/constants.cc
@@ -39,5 +39,7 @@
const char kPrefsUpdateStateSignedSHA256Context[] =
"update-state-signed-sha-256-context";
const char kPrefsWallClockWaitPeriod[] = "wall-clock-wait-period";
+const char kPrefsUpdateTimestampStart[] = "update-timestamp-start";
+const char kPrefsUpdateDurationUptime[] = "update-duration-uptime";
}
diff --git a/constants.h b/constants.h
index 5bba2d3..4f335c3 100644
--- a/constants.h
+++ b/constants.h
@@ -38,6 +38,8 @@
extern const char kPrefsUpdateStateSignatureBlob[];
extern const char kPrefsUpdateStateSignedSHA256Context[];
extern const char kPrefsWallClockWaitPeriod[];
+extern const char kPrefsUpdateTimestampStart[];
+extern const char kPrefsUpdateDurationUptime[];
} // namespace chromeos_update_engine
diff --git a/mock_payload_state.h b/mock_payload_state.h
index 049624b..a2c80f4 100644
--- a/mock_payload_state.h
+++ b/mock_payload_state.h
@@ -21,6 +21,7 @@
MOCK_METHOD1(SetResponse, void(const OmahaResponse& response));
MOCK_METHOD0(DownloadComplete, void());
MOCK_METHOD1(DownloadProgress, void(size_t count));
+ MOCK_METHOD0(UpdateSucceeded, void());
MOCK_METHOD1(UpdateFailed, void(ActionExitCode error));
MOCK_METHOD0(ShouldBackoffDownload, bool());
@@ -30,6 +31,8 @@
MOCK_METHOD0(GetUrlIndex, uint32_t());
MOCK_METHOD0(GetUrlFailureCount, uint32_t());
MOCK_METHOD0(GetBackoffExpiryTime, base::Time());
+ MOCK_METHOD0(GetUpdateDuration, base::TimeDelta());
+ MOCK_METHOD0(GetUpdateDurationUptime, base::TimeDelta());
};
} // namespace chromeos_update_engine
diff --git a/payload_state.cc b/payload_state.cc
index 585988a..1699f64 100644
--- a/payload_state.cc
+++ b/payload_state.cc
@@ -19,6 +19,8 @@
namespace chromeos_update_engine {
+const TimeDelta PayloadState::kDurationSlack = TimeDelta::FromSeconds(600);
+
// We want to upperbound backoffs to 16 days
static const uint32_t kMaxBackoffDays = 16;
@@ -33,6 +35,10 @@
LoadUrlIndex();
LoadUrlFailureCount();
LoadBackoffExpiryTime();
+ LoadUpdateTimestampStart();
+ // The LoadUpdateDurationUptime() method relies on LoadUpdateTimestampStart()
+ // being called before it. Don't reorder.
+ LoadUpdateDurationUptime();
return true;
}
@@ -75,6 +81,8 @@
if (count == 0)
return;
+ CalculateUpdateDurationUptime();
+
// We've received non-zero bytes from a recent download operation. Since our
// URL failure count is meant to penalize a URL only for consecutive
// failures, downloading bytes successfully means we should reset the failure
@@ -92,6 +100,11 @@
SetUrlFailureCount(0);
}
+void PayloadState::UpdateSucceeded() {
+ CalculateUpdateDurationUptime();
+ SetUpdateTimestampEnd(Time::Now());
+}
+
void PayloadState::UpdateFailed(ActionExitCode error) {
ActionExitCode base_error = utils::GetBaseErrorCode(error);
LOG(INFO) << "Updating payload state for error code: " << base_error
@@ -320,6 +333,9 @@
SetUrlIndex(0);
SetUrlFailureCount(0);
UpdateBackoffExpiryTime(); // This will reset the backoff expiry time.
+ SetUpdateTimestampStart(Time::Now());
+ SetUpdateTimestampEnd(Time()); // Set to null time
+ SetUpdateDurationUptime(TimeDelta::FromSeconds(0));
}
string PayloadState::CalculateResponseSignature() {
@@ -457,4 +473,124 @@
backoff_expiry_time_.ToInternalValue());
}
+TimeDelta PayloadState::GetUpdateDuration() {
+ Time end_time = update_timestamp_end_.is_null() ? Time::Now() :
+ update_timestamp_end_;
+ return end_time - update_timestamp_start_;
+}
+
+void PayloadState::LoadUpdateTimestampStart() {
+ int64_t stored_value;
+ Time stored_time;
+
+ CHECK(prefs_);
+
+ Time now = Time::Now();
+
+ if (!prefs_->Exists(kPrefsUpdateTimestampStart)) {
+ // The preference missing is not unexpected - in that case, just
+ // use the current time as start time
+ stored_time = now;
+ } else if (!prefs_->GetInt64(kPrefsUpdateTimestampStart, &stored_value)) {
+ LOG(ERROR) << "Invalid UpdateTimestampStart value. Resetting.";
+ stored_time = now;
+ } else {
+ stored_time = Time::FromInternalValue(stored_value);
+ }
+
+ // Sanity check: If the time read from disk is in the future
+ // (modulo some slack to account for possible NTP drift
+ // adjustments), something is fishy and we should report and
+ // reset.
+ TimeDelta duration_according_to_stored_time = now - stored_time;
+ if (duration_according_to_stored_time < -kDurationSlack) {
+ LOG(ERROR) << "The UpdateTimestampStart value ("
+ << utils::ToString(stored_time)
+ << ") in persisted state is "
+ << duration_according_to_stored_time.InSeconds()
+ << " seconds in the future. Resetting.";
+ stored_time = now;
+ }
+
+ SetUpdateTimestampStart(stored_time);
+}
+
+void PayloadState::SetUpdateTimestampStart(const Time& value) {
+ CHECK(prefs_);
+ update_timestamp_start_ = value;
+ prefs_->SetInt64(kPrefsUpdateTimestampStart,
+ update_timestamp_start_.ToInternalValue());
+ LOG(INFO) << "Update Timestamp Start = "
+ << utils::ToString(update_timestamp_start_);
+}
+
+void PayloadState::SetUpdateTimestampEnd(const Time& value) {
+ update_timestamp_end_ = value;
+ LOG(INFO) << "Update Timestamp End = "
+ << utils::ToString(update_timestamp_end_);
+}
+
+TimeDelta PayloadState::GetUpdateDurationUptime() {
+ return update_duration_uptime_;
+}
+
+void PayloadState::LoadUpdateDurationUptime() {
+ int64_t stored_value;
+ TimeDelta stored_delta;
+
+ CHECK(prefs_);
+
+ if (!prefs_->Exists(kPrefsUpdateDurationUptime)) {
+ // The preference missing is not unexpected - in that case, just
+ // we'll use zero as the delta
+ } else if (!prefs_->GetInt64(kPrefsUpdateDurationUptime, &stored_value)) {
+ LOG(ERROR) << "Invalid UpdateDurationUptime value. Resetting.";
+ stored_delta = TimeDelta::FromSeconds(0);
+ } else {
+ stored_delta = TimeDelta::FromInternalValue(stored_value);
+ }
+
+ // Sanity-check: Uptime can never be greater than the wall-clock
+ // difference (modulo some slack). If it is, report and reset
+ // to the wall-clock difference.
+ TimeDelta diff = GetUpdateDuration() - stored_delta;
+ if (diff < -kDurationSlack) {
+ LOG(ERROR) << "The UpdateDurationUptime value ("
+ << stored_delta.InSeconds() << " seconds"
+ << ") in persisted state is "
+ << diff.InSeconds()
+ << " seconds larger than the wall-clock delta. Resetting.";
+ stored_delta = update_duration_current_;
+ }
+
+ SetUpdateDurationUptime(stored_delta);
+}
+
+void PayloadState::SetUpdateDurationUptimeExtended(const TimeDelta& value,
+ const Time& timestamp,
+ bool use_logging) {
+ CHECK(prefs_);
+ update_duration_uptime_ = value;
+ update_duration_uptime_timestamp_ = timestamp;
+ prefs_->SetInt64(kPrefsUpdateDurationUptime,
+ update_duration_uptime_.ToInternalValue());
+ if (use_logging) {
+ LOG(INFO) << "Update Duration Uptime = "
+ << update_duration_uptime_.InSeconds()
+ << " seconds";
+ }
+}
+
+void PayloadState::SetUpdateDurationUptime(const TimeDelta& value) {
+ SetUpdateDurationUptimeExtended(value, utils::GetMonotonicTime(), true);
+}
+
+void PayloadState::CalculateUpdateDurationUptime() {
+ Time now = utils::GetMonotonicTime();
+ TimeDelta uptime_since_last_update = now - update_duration_uptime_timestamp_;
+ TimeDelta new_uptime = update_duration_uptime_ + uptime_since_last_update;
+ // We're frequently called so avoid logging this write
+ SetUpdateDurationUptimeExtended(new_uptime, now, false);
+}
+
} // namespace chromeos_update_engine
diff --git a/payload_state.h b/payload_state.h
index eb9d655..0557d0a 100644
--- a/payload_state.h
+++ b/payload_state.h
@@ -40,6 +40,7 @@
virtual void SetResponse(const OmahaResponse& response);
virtual void DownloadComplete();
virtual void DownloadProgress(size_t count);
+ virtual void UpdateSucceeded();
virtual void UpdateFailed(ActionExitCode error);
virtual bool ShouldBackoffDownload();
@@ -63,6 +64,10 @@
return backoff_expiry_time_;
}
+ virtual base::TimeDelta GetUpdateDuration();
+
+ virtual base::TimeDelta GetUpdateDurationUptime();
+
private:
// Increments the payload attempt number which governs the backoff behavior
// at the time of the next update check.
@@ -132,6 +137,36 @@
// restart.
void SetBackoffExpiryTime(const base::Time& new_time);
+ // Initializes |update_timestamp_start_| from the persisted state.
+ void LoadUpdateTimestampStart();
+
+ // Sets |update_timestamp_start_| to the given value and persists the value.
+ void SetUpdateTimestampStart(const base::Time& value);
+
+ // Sets |update_timestamp_end_| to the given value. This is not persisted
+ // as it happens at the end of the update process where state is deleted
+ // anyway.
+ void SetUpdateTimestampEnd(const base::Time& value);
+
+ // Initializes |update_duration_uptime_| from the persisted state.
+ void LoadUpdateDurationUptime();
+
+ // Helper method used in SetUpdateDurationUptime() and
+ // CalculateUpdateDurationUptime().
+ void SetUpdateDurationUptimeExtended(const base::TimeDelta& value,
+ const base::Time& timestamp,
+ bool use_logging);
+
+ // Sets |update_duration_uptime_| to the given value and persists
+ // the value and sets |update_duration_uptime_timestamp_| to the
+ // current monotonic time.
+ void SetUpdateDurationUptime(const base::TimeDelta& value);
+
+ // Adds the difference between current monotonic time and
+ // |update_duration_uptime_timestamp_| to |update_duration_uptime_| and
+ // sets |update_duration_uptime_timestamp_| to current monotonic time.
+ void CalculateUpdateDurationUptime();
+
// Interface object with which we read/write persisted state. This must
// be set by calling the Initialize method before calling any other method.
PrefsInterface* prefs_;
@@ -168,6 +203,22 @@
// payload again, so as to backoff repeated downloads.
base::Time backoff_expiry_time_;
+ // The most recently calculated value of the update duration.
+ base::TimeDelta update_duration_current_;
+
+ // The point in time (wall-clock) that the update was started.
+ base::Time update_timestamp_start_;
+
+ // The point in time (wall-clock) that the update ended. If the update
+ // is still in progress, this is set to the Epoch (e.g. 0).
+ base::Time update_timestamp_end_;
+
+ // The update duration uptime
+ base::TimeDelta update_duration_uptime_;
+
+ // The monotonic time when |update_duration_uptime_| was last set
+ base::Time update_duration_uptime_timestamp_;
+
// Returns the number of URLs in the current response.
// Note: This value will be 0 if this method is called before we receive
// the first valid Omaha response in this process.
@@ -175,6 +226,11 @@
return response_.payload_urls.size();
}
+ // A small timespan used when comparing wall-clock times for coping
+ // with the fact that clocks drift and consequently are adjusted
+ // (either forwards or backwards) via NTP.
+ static const base::TimeDelta kDurationSlack;
+
DISALLOW_COPY_AND_ASSIGN(PayloadState);
};
diff --git a/payload_state_interface.h b/payload_state_interface.h
index 35bab04..d681154 100644
--- a/payload_state_interface.h
+++ b/payload_state_interface.h
@@ -39,6 +39,9 @@
// able to make forward progress with the current URL.
virtual void DownloadProgress(size_t count) = 0;
+ // This method should be called whenever an update attempt succeeds.
+ virtual void UpdateSucceeded() = 0;
+
// This method should be called whenever an update attempt fails with the
// given error code. We use this notification to update the payload state
// depending on the type of the error that happened.
@@ -63,6 +66,16 @@
// Returns the expiry time for the current backoff period.
virtual base::Time GetBackoffExpiryTime() = 0;
+
+ // Returns the elapsed time used for this update, including time
+ // where the device is powered off and sleeping. If the
+ // update has not completed, returns the time spent so far.
+ virtual base::TimeDelta GetUpdateDuration() = 0;
+
+ // Returns the time used for this update not including time when
+ // the device is powered off or sleeping. If the update has not
+ // completed, returns the time spent so far.
+ virtual base::TimeDelta GetUpdateDurationUptime() = 0;
};
} // namespace chromeos_update_engine
diff --git a/payload_state_unittest.cc b/payload_state_unittest.cc
index 9f7f5c1..62de02b 100644
--- a/payload_state_unittest.cc
+++ b/payload_state_unittest.cc
@@ -22,6 +22,7 @@
using testing::NiceMock;
using testing::Return;
using testing::SetArgumentPointee;
+using testing::AtLeast;
namespace chromeos_update_engine {
@@ -76,6 +77,8 @@
EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateTimestampStart, _)).Times(AtLeast(1));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateDurationUptime, _)).Times(AtLeast(1));
PayloadState payload_state;
EXPECT_TRUE(payload_state.Initialize(&prefs));
payload_state.SetResponse(response);
@@ -105,6 +108,8 @@
EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateTimestampStart, _)).Times(AtLeast(1));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateDurationUptime, _)).Times(AtLeast(1));
PayloadState payload_state;
EXPECT_TRUE(payload_state.Initialize(&prefs));
payload_state.SetResponse(response);
@@ -136,6 +141,8 @@
EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, 0));
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0));
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateTimestampStart, _)).Times(AtLeast(1));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateDurationUptime, _)).Times(AtLeast(1));
PayloadState payload_state;
EXPECT_TRUE(payload_state.Initialize(&prefs));
payload_state.SetResponse(response);
@@ -165,6 +172,10 @@
EXPECT_CALL(prefs, SetInt64(kPrefsPayloadAttemptNumber, 1)).Times(1);
EXPECT_CALL(prefs, SetInt64(kPrefsBackoffExpiryTime, _)).Times(2);
+ // Durations will be set
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateTimestampStart, _)).Times(AtLeast(1));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateDurationUptime, _)).Times(AtLeast(1));
+
// Url index should go from 0 to 1 twice.
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(2);
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 1)).Times(2);
@@ -235,6 +246,9 @@
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 1)).Times(2);
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 2)).Times(1);
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateTimestampStart, _)).Times(AtLeast(1));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateDurationUptime, _)).Times(AtLeast(1));
+
EXPECT_TRUE(payload_state.Initialize(&prefs));
SetupPayloadStateWith2Urls("Hash5873", &payload_state, &response);
@@ -321,6 +335,9 @@
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlIndex, 0)).Times(1);
EXPECT_CALL(prefs, SetInt64(kPrefsCurrentUrlFailureCount, 0)).Times(1);
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateTimestampStart, _)).Times(AtLeast(1));
+ EXPECT_CALL(prefs, SetInt64(kPrefsUpdateDurationUptime, _)).Times(AtLeast(1));
+
EXPECT_TRUE(payload_state.Initialize(&prefs));
SetupPayloadStateWith2Urls("Hash8593", &payload_state, &response);
@@ -360,6 +377,8 @@
EXPECT_CALL(prefs2, GetInt64(kPrefsCurrentUrlIndex, _))
.WillOnce(DoAll(SetArgumentPointee<1>(2), Return(true)));
EXPECT_CALL(prefs2, GetInt64(kPrefsCurrentUrlFailureCount, _));
+ EXPECT_CALL(prefs2, GetInt64(kPrefsUpdateTimestampStart, _));
+ EXPECT_CALL(prefs2, GetInt64(kPrefsUpdateDurationUptime, _));
// Note: This will be a different payload object, but the response should
// have the same hash as before so as to not trivially reset because the
diff --git a/update_attempter.cc b/update_attempter.cc
index 8235b19..9e5e49b 100644
--- a/update_attempter.cc
+++ b/update_attempter.cc
@@ -4,12 +4,6 @@
#include "update_engine/update_attempter.h"
-// From 'man clock_gettime': feature test macro: _POSIX_C_SOURCE >= 199309L
-#ifndef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE 199309L
-#endif // _POSIX_C_SOURCE
-#include <time.h>
-
#include <string>
#include <tr1/memory>
#include <vector>
@@ -610,6 +604,27 @@
omaha_request_params_->app_version());
DeltaPerformer::ResetUpdateProgress(prefs_, false);
+ system_state_->payload_state()->UpdateSucceeded();
+
+ if (!fake_update_success_) {
+ // Get the time it took to update the system
+ TimeDelta duration = system_state_->payload_state()->GetUpdateDuration();
+ TimeDelta duration_uptime =
+ system_state_->payload_state()->GetUpdateDurationUptime();
+ system_state_->metrics_lib()->SendToUMA(
+ "Installer.UpdateDuration",
+ static_cast<int>(duration.InSeconds()), // sample
+ 1, // min = 1 second
+ 20 * 60, // max = 20 minutes
+ 50); // buckets
+ system_state_->metrics_lib()->SendToUMA(
+ "Installer.UpdateDurationUptime",
+ static_cast<int>(duration_uptime.InSeconds()), // sample
+ 1, // min = 1 second
+ 20 * 60, // max = 20 minutes
+ 50); // buckets
+ }
+
// Since we're done with scattering fully at this point, this is the
// safest point delete the state files, as we're sure that the status is
// set to reboot (which means no more updates will be applied until reboot)
@@ -622,21 +637,13 @@
prefs_->Delete(kPrefsUpdateCheckCount);
prefs_->Delete(kPrefsWallClockWaitPeriod);
prefs_->Delete(kPrefsUpdateFirstSeenAt);
+ prefs_->Delete(kPrefsUpdateTimestampStart);
+ prefs_->Delete(kPrefsUpdateDurationUptime);
LOG(INFO) << "Update successfully applied, waiting to reboot.";
SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT,
kUpdateNoticeUnspecified);
- // Report the time it took to update the system.
- int64_t update_time = time(NULL) - last_checked_time_;
- if (!fake_update_success_)
- system_state_->metrics_lib()->SendToUMA(
- "Installer.UpdateTime",
- static_cast<int>(update_time), // sample
- 1, // min = 1 second
- 20 * 60, // max = 20 minutes
- 50); // buckets
-
// Also report the success code so that the percentiles can be
// interpreted properly for the remaining error codes in UMA.
utils::SendErrorCodeToUma(system_state_, code);
diff --git a/utils.cc b/utils.cc
index 756ef8a..c6bc6b8 100644
--- a/utils.cc
+++ b/utils.cc
@@ -15,6 +15,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <time.h>
#include <unistd.h>
#include <algorithm>
@@ -924,6 +925,20 @@
return result;
}
+
+Time GetMonotonicTime() {
+ struct timespec now_ts;
+ if (clock_gettime(CLOCK_MONOTONIC_RAW, &now_ts) != 0) {
+ // Avoid logging this as an error as call-sites may call this very
+ // often and we don't want to fill up the disk...
+ return Time();
+ }
+ struct timeval now_tv;
+ now_tv.tv_sec = now_ts.tv_sec;
+ now_tv.tv_usec = now_ts.tv_nsec/Time::kNanosecondsPerMicrosecond;
+ return Time::FromTimeVal(now_tv);
+}
+
} // namespace utils
} // namespace chromeos_update_engine
diff --git a/utils.h b/utils.h
index a5a5a1e..46b06e1 100644
--- a/utils.h
+++ b/utils.h
@@ -27,6 +27,13 @@
namespace utils {
+// Returns monotonic time since some unspecified starting point. It is
+// not increased when the system is sleeping nor is it affected by
+// NTP or the user changing the time.
+//
+// (This is a simple wrapper around clock_gettime(2) / CLOCK_MONOTONIC_RAW.)
+base::Time GetMonotonicTime();
+
// Returns true if this is an official Chrome OS build, false otherwise.
bool IsOfficialBuild();
