diff --git a/UpdateEngine.conf b/UpdateEngine.conf
index dee64ee..3688250 100644
--- a/UpdateEngine.conf
+++ b/UpdateEngine.conf
@@ -49,6 +49,9 @@
     <allow send_destination="org.chromium.UpdateEngine"
            send_interface="org.chromium.UpdateEngineInterface"
            send_member="GetUpdateOverCellularPermission"/>
+    <allow send_destination="org.chromium.UpdateEngine"
+           send_interface="org.chromium.UpdateEngineInterface"
+           send_member="GetDurationSinceUpdate"/>
     <allow send_interface="org.chromium.UpdateEngineLibcrosProxyResolvedInterface" />
   </policy>
   <policy context="default">
diff --git a/clock.cc b/clock.cc
index 96979f9..ac8945b 100644
--- a/clock.cc
+++ b/clock.cc
@@ -16,7 +16,25 @@
   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...
+    // often and we don't want to fill up the disk. Note that this
+    // only fails if running on ancient kernels (CLOCK_MONOTONIC_RAW
+    // was added in Linux 2.6.28) so it never fails on a ChromeOS
+    // device.
+    return base::Time();
+  }
+  struct timeval now_tv;
+  now_tv.tv_sec = now_ts.tv_sec;
+  now_tv.tv_usec = now_ts.tv_nsec/base::Time::kNanosecondsPerMicrosecond;
+  return base::Time::FromTimeVal(now_tv);
+}
+
+base::Time Clock::GetBootTime() {
+  struct timespec now_ts;
+  if (clock_gettime(CLOCK_BOOTTIME, &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. Note that this
+    // only fails if running on ancient kernels (CLOCK_BOOTTIME was
+    // added in Linux 2.6.39) so it never fails on a ChromeOS device.
     return base::Time();
   }
   struct timeval now_tv;
diff --git a/clock.h b/clock.h
index 027bcff..8cfe366 100644
--- a/clock.h
+++ b/clock.h
@@ -18,6 +18,8 @@
 
   virtual base::Time GetMonotonicTime();
 
+  virtual base::Time GetBootTime();
+
  private:
 
   DISALLOW_COPY_AND_ASSIGN(Clock);
diff --git a/clock_interface.h b/clock_interface.h
index c2b1a04..d9e6124 100644
--- a/clock_interface.h
+++ b/clock_interface.h
@@ -27,6 +27,13 @@
   // (This is a simple wrapper around clock_gettime(2) / CLOCK_MONOTONIC_RAW.)
   virtual base::Time GetMonotonicTime() = 0;
 
+  // Returns monotonic time since some unspecified starting point. It
+  // is increased when the system is sleeping but it's not affected
+  // by NTP or the user changing the time.
+  //
+  // (This is a simple wrapper around clock_gettime(2) / CLOCK_BOOTTIME.)
+  virtual base::Time GetBootTime() = 0;
+
   virtual ~ClockInterface() {}
 };
 
diff --git a/dbus_service.cc b/dbus_service.cc
index 42bcfa3..956b73b 100644
--- a/dbus_service.cc
+++ b/dbus_service.cc
@@ -10,6 +10,7 @@
 #include <base/logging.h>
 #include <policy/device_policy.h>
 
+#include "update_engine/clock_interface.h"
 #include "update_engine/connection_manager.h"
 #include "update_engine/dbus_constants.h"
 #include "update_engine/hardware_interface.h"
@@ -347,6 +348,20 @@
   return TRUE;
 }
 
+gboolean update_engine_service_get_duration_since_update(
+    UpdateEngineService* self,
+    gint64* out_usec_wallclock,
+    GError **/*error*/) {
+
+  base::Time time;
+  if (!self->system_state_->update_attempter()->GetBootTimeAtUpdate(&time))
+    return FALSE;
+
+  chromeos_update_engine::ClockInterface *clock = self->system_state_->clock();
+  *out_usec_wallclock = (clock->GetBootTime() - time).InMicroseconds();
+  return TRUE;
+}
+
 gboolean update_engine_service_emit_status_update(
     UpdateEngineService* self,
     gint64 last_checked_time,
diff --git a/dbus_service.h b/dbus_service.h
index 6d449df..5d0f500 100644
--- a/dbus_service.h
+++ b/dbus_service.h
@@ -128,6 +128,14 @@
     gboolean* allowed,
     GError **error);
 
+// Returns the duration since the last successful update, as the
+// duration on the wallclock. Returns an error if the device has not
+// updated.
+gboolean update_engine_service_get_duration_since_update(
+    UpdateEngineService* self,
+    gint64* out_usec_wallclock,
+    GError **error);
+
 gboolean update_engine_service_emit_status_update(
     UpdateEngineService* self,
     gint64 last_checked_time,
diff --git a/fake_clock.h b/fake_clock.h
index 105d664..d920aaf 100644
--- a/fake_clock.h
+++ b/fake_clock.h
@@ -22,6 +22,10 @@
     return monotonic_time_;
   }
 
+  virtual base::Time GetBootTime() {
+    return boot_time_;
+  }
+
   void SetWallclockTime(const base::Time &time) {
     wallclock_time_ = time;
   }
@@ -30,9 +34,14 @@
     monotonic_time_ = time;
   }
 
+  void SetBootTime(const base::Time &time) {
+    boot_time_ = time;
+  }
+
  private:
   base::Time wallclock_time_;
   base::Time monotonic_time_;
+  base::Time boot_time_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeClock);
 };
diff --git a/update_attempter.cc b/update_attempter.cc
index 69a625d..eb57644 100644
--- a/update_attempter.cc
+++ b/update_attempter.cc
@@ -9,8 +9,11 @@
 #include <vector>
 
 #include <base/file_util.h>
+#include <base/logging.h>
 #include <base/rand_util.h>
+#include <base/stringprintf.h>
 #include <chromeos/dbus/service_constants.h>
+
 #include <glib.h>
 #include <metrics/metrics_library.h>
 #include <policy/libpolicy.h>
@@ -38,8 +41,10 @@
 #include "update_engine/update_check_scheduler.h"
 #include "update_engine/utils.h"
 
+using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
+using base::StringPrintf;
 using google::protobuf::NewPermanentCallback;
 using std::make_pair;
 using std::tr1::shared_ptr;
@@ -799,6 +804,18 @@
   return true;
 }
 
+void UpdateAttempter::WriteUpdateCompletedMarker() {
+  if (update_completed_marker_.empty())
+    return;
+
+  int64_t value = system_state_->clock()->GetBootTime().ToInternalValue();
+  string contents = StringPrintf("%" PRIi64, value);
+
+  utils::WriteFile(update_completed_marker_.c_str(),
+                   contents.c_str(),
+                   contents.length());
+}
+
 // Delegate methods:
 void UpdateAttempter::ProcessingDone(const ActionProcessor* processor,
                                      ErrorCode code) {
@@ -825,8 +842,7 @@
   }
 
   if (code == kErrorCodeSuccess) {
-    if (!update_completed_marker_.empty())
-      utils::WriteFile(update_completed_marker_.c_str(), "", 0);
+    WriteUpdateCompletedMarker();
     prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
     prefs_->SetString(kPrefsPreviousVersion,
                       omaha_request_params_->app_version());
@@ -1423,4 +1439,24 @@
   return true;
 }
 
+bool UpdateAttempter::GetBootTimeAtUpdate(base::Time *out_boot_time) {
+  if (update_completed_marker_.empty())
+    return false;
+
+  string contents;
+  if (!utils::ReadFile(update_completed_marker_, &contents))
+    return false;
+
+  char *endp;
+  int64_t stored_value = strtoll(contents.c_str(), &endp, 10);
+  if (*endp != '\0') {
+    LOG(ERROR) << "Error parsing file " << update_completed_marker_ << " "
+               << "with content '" << contents << "'";
+    return false;
+  }
+
+  *out_boot_time = Time::FromInternalValue(stored_value);
+  return true;
+}
+
 }  // namespace chromeos_update_engine
diff --git a/update_attempter.h b/update_attempter.h
index 74b73f6..70381d9 100644
--- a/update_attempter.h
+++ b/update_attempter.h
@@ -179,6 +179,10 @@
   // from the server asynchronously at its own frequency.
   void RefreshDevicePolicy();
 
+  // Returns the boottime (CLOCK_BOOTTIME) recorded at the last
+  // successful update. Returns false if the device has not updated.
+  bool GetBootTimeAtUpdate(base::Time *out_boot_time);
+
  private:
   // Update server URL for automated lab test.
   static const char* const kTestUpdateUrl;
@@ -203,6 +207,7 @@
   FRIEND_TEST(UpdateAttempterTest, ScheduleErrorEventActionTest);
   FRIEND_TEST(UpdateAttempterTest, UpdateTest);
   FRIEND_TEST(UpdateAttempterTest, ReportDailyMetrics);
+  FRIEND_TEST(UpdateAttempterTest, BootTimeInUpdateMarkerFile);
 
   // Ctor helper method.
   void Init(SystemState* system_state,
@@ -329,6 +334,10 @@
   // started and housekeeping was performed.
   bool StartP2PAtStartup();
 
+  // Writes to the processing completed marker. Does nothing if
+  // |update_completed_marker_| is empty.
+  void WriteUpdateCompletedMarker();
+
   // Last status notification timestamp used for throttling. Use monotonic
   // TimeTicks to ensure that notifications are sent even if the system clock is
   // set back in the middle of an update.
diff --git a/update_attempter_unittest.cc b/update_attempter_unittest.cc
index 2e3c6b2..10af01e 100644
--- a/update_attempter_unittest.cc
+++ b/update_attempter_unittest.cc
@@ -1094,4 +1094,22 @@
   EXPECT_TRUE(utils::RecursiveUnlinkDir(temp_dir));
 }
 
+TEST_F(UpdateAttempterTest, BootTimeInUpdateMarkerFile) {
+  const string update_completed_marker = test_dir_ + "/update-completed-marker";
+  UpdateAttempterUnderTest attempter(&mock_system_state_, &dbus_,
+                                     update_completed_marker);
+
+  FakeClock fake_clock;
+  fake_clock.SetBootTime(Time::FromTimeT(42));
+  mock_system_state_.set_clock(&fake_clock);
+
+  Time boot_time;
+  EXPECT_FALSE(attempter.GetBootTimeAtUpdate(&boot_time));
+
+  attempter.WriteUpdateCompletedMarker();
+
+  EXPECT_TRUE(attempter.GetBootTimeAtUpdate(&boot_time));
+  EXPECT_EQ(boot_time.ToTimeT(), 42);
+}
+
 }  // namespace chromeos_update_engine
diff --git a/update_engine.xml b/update_engine.xml
index ad6c36b..5a2b722 100644
--- a/update_engine.xml
+++ b/update_engine.xml
@@ -65,6 +65,9 @@
     <method name="GetUpdateOverCellularPermission">
       <arg type="b" name="allowed" direction="out" />
     </method>
+    <method name="GetDurationSinceUpdate">
+      <arg type="x" name="usec_wallclock" direction="out" />
+    </method>
     <signal name="StatusUpdate">
       <arg type="x" name="last_checked_time" />
       <arg type="d" name="progress" />