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();