update_attempter.cc revision 305345001d85ca2282112c2a30fe75c7a4773491 
1// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "update_engine/update_attempter.h"
6
7#include <stdint.h>
8
9#include <algorithm>
10#include <memory>
11#include <set>
12#include <string>
13#include <utility>
14#include <vector>
15
16#include <base/bind.h>
17#include <base/files/file_util.h>
18#include <base/logging.h>
19#include <base/rand_util.h>
20#include <base/strings/string_util.h>
21#include <base/strings/stringprintf.h>
22#include <chromeos/bind_lambda.h>
23#include <chromeos/dbus/service_constants.h>
24#include <chromeos/message_loops/message_loop.h>
25
26#include <glib.h>
27#include <metrics/metrics_library.h>
28#include <policy/device_policy.h>
29#include <policy/libpolicy.h>
30
31#include "update_engine/certificate_checker.h"
32#include "update_engine/clock_interface.h"
33#include "update_engine/constants.h"
34#include "update_engine/dbus_service.h"
35#include "update_engine/download_action.h"
36#include "update_engine/filesystem_verifier_action.h"
37#include "update_engine/hardware_interface.h"
38#include "update_engine/libcurl_http_fetcher.h"
39#include "update_engine/metrics.h"
40#include "update_engine/multi_range_http_fetcher.h"
41#include "update_engine/omaha_request_action.h"
42#include "update_engine/omaha_request_params.h"
43#include "update_engine/omaha_response_handler_action.h"
44#include "update_engine/p2p_manager.h"
45#include "update_engine/payload_state_interface.h"
46#include "update_engine/postinstall_runner_action.h"
47#include "update_engine/prefs_interface.h"
48#include "update_engine/subprocess.h"
49#include "update_engine/system_state.h"
50#include "update_engine/update_manager/policy.h"
51#include "update_engine/update_manager/update_manager.h"
52#include "update_engine/utils.h"
53
54using base::Bind;
55using base::Callback;
56using base::StringPrintf;
57using base::Time;
58using base::TimeDelta;
59using base::TimeTicks;
60using chromeos::MessageLoop;
61using chromeos_update_manager::EvalStatus;
62using chromeos_update_manager::Policy;
63using chromeos_update_manager::UpdateCheckParams;
64using std::set;
65using std::shared_ptr;
66using std::string;
67using std::vector;
68
69namespace chromeos_update_engine {
70
71const int UpdateAttempter::kMaxDeltaUpdateFailures = 3;
72
73namespace {
74const int kMaxConsecutiveObeyProxyRequests = 20;
75
76const char kUpdateCompletedMarker[] =
77    "/var/run/update_engine_autoupdate_completed";
78
79// By default autest bypasses scattering. If we want to test scattering,
80// use kScheduledAUTestURLRequest. The URL used is same in both cases, but
81// different params are passed to CheckForUpdate().
82const char kAUTestURLRequest[] = "autest";
83const char kScheduledAUTestURLRequest[] = "autest-scheduled";
84}  // namespace
85
86const char* UpdateStatusToString(UpdateStatus status) {
87  switch (status) {
88    case UPDATE_STATUS_IDLE:
89      return update_engine::kUpdateStatusIdle;
90    case UPDATE_STATUS_CHECKING_FOR_UPDATE:
91      return update_engine::kUpdateStatusCheckingForUpdate;
92    case UPDATE_STATUS_UPDATE_AVAILABLE:
93      return update_engine::kUpdateStatusUpdateAvailable;
94    case UPDATE_STATUS_DOWNLOADING:
95      return update_engine::kUpdateStatusDownloading;
96    case UPDATE_STATUS_VERIFYING:
97      return update_engine::kUpdateStatusVerifying;
98    case UPDATE_STATUS_FINALIZING:
99      return update_engine::kUpdateStatusFinalizing;
100    case UPDATE_STATUS_UPDATED_NEED_REBOOT:
101      return update_engine::kUpdateStatusUpdatedNeedReboot;
102    case UPDATE_STATUS_REPORTING_ERROR_EVENT:
103      return update_engine::kUpdateStatusReportingErrorEvent;
104    case UPDATE_STATUS_ATTEMPTING_ROLLBACK:
105      return update_engine::kUpdateStatusAttemptingRollback;
106    case UPDATE_STATUS_DISABLED:
107      return update_engine::kUpdateStatusDisabled;
108    default:
109      return "unknown status";
110  }
111}
112
113// Turns a generic ErrorCode::kError to a generic error code specific
114// to |action| (e.g., ErrorCode::kFilesystemVerifierError). If |code| is
115// not ErrorCode::kError, or the action is not matched, returns |code|
116// unchanged.
117ErrorCode GetErrorCodeForAction(AbstractAction* action,
118                                     ErrorCode code) {
119  if (code != ErrorCode::kError)
120    return code;
121
122  const string type = action->Type();
123  if (type == OmahaRequestAction::StaticType())
124    return ErrorCode::kOmahaRequestError;
125  if (type == OmahaResponseHandlerAction::StaticType())
126    return ErrorCode::kOmahaResponseHandlerError;
127  if (type == FilesystemVerifierAction::StaticType())
128    return ErrorCode::kFilesystemVerifierError;
129  if (type == PostinstallRunnerAction::StaticType())
130    return ErrorCode::kPostinstallRunnerError;
131
132  return code;
133}
134
135UpdateAttempter::UpdateAttempter(
136    SystemState* system_state,
137    LibCrosProxy* libcros_proxy,
138    org::chromium::debugdProxyInterface* debugd_proxy)
139    : UpdateAttempter(system_state, libcros_proxy, debugd_proxy,
140                      kUpdateCompletedMarker) {}
141
142UpdateAttempter::UpdateAttempter(
143    SystemState* system_state,
144    LibCrosProxy* libcros_proxy,
145    org::chromium::debugdProxyInterface* debugd_proxy,
146    const string& update_completed_marker)
147    : processor_(new ActionProcessor()),
148      system_state_(system_state),
149      chrome_proxy_resolver_(libcros_proxy),
150      update_completed_marker_(update_completed_marker),
151      debugd_proxy_(debugd_proxy) {
152  if (!update_completed_marker_.empty() &&
153      utils::FileExists(update_completed_marker_.c_str())) {
154    status_ = UPDATE_STATUS_UPDATED_NEED_REBOOT;
155  } else {
156    status_ = UPDATE_STATUS_IDLE;
157  }
158}
159
160UpdateAttempter::~UpdateAttempter() {
161  CleanupCpuSharesManagement();
162}
163
164void UpdateAttempter::Init() {
165  // Pulling from the SystemState can only be done after construction, since
166  // this is an aggregate of various objects (such as the UpdateAttempter),
167  // which requires them all to be constructed prior to it being used.
168  prefs_ = system_state_->prefs();
169  omaha_request_params_ = system_state_->request_params();
170}
171
172void UpdateAttempter::ScheduleUpdates() {
173  if (IsUpdateRunningOrScheduled())
174    return;
175
176  chromeos_update_manager::UpdateManager* const update_manager =
177      system_state_->update_manager();
178  CHECK(update_manager);
179  Callback<void(EvalStatus, const UpdateCheckParams&)> callback = Bind(
180      &UpdateAttempter::OnUpdateScheduled, base::Unretained(this));
181  // We limit the async policy request to a reasonably short time, to avoid a
182  // starvation due to a transient bug.
183  update_manager->AsyncPolicyRequest(callback, &Policy::UpdateCheckAllowed);
184  waiting_for_scheduled_check_ = true;
185}
186
187bool UpdateAttempter::CheckAndReportDailyMetrics() {
188  int64_t stored_value;
189  Time now = system_state_->clock()->GetWallclockTime();
190  if (system_state_->prefs()->Exists(kPrefsDailyMetricsLastReportedAt) &&
191      system_state_->prefs()->GetInt64(kPrefsDailyMetricsLastReportedAt,
192                                       &stored_value)) {
193    Time last_reported_at = Time::FromInternalValue(stored_value);
194    TimeDelta time_reported_since = now - last_reported_at;
195    if (time_reported_since.InSeconds() < 0) {
196      LOG(WARNING) << "Last reported daily metrics "
197                   << utils::FormatTimeDelta(time_reported_since) << " ago "
198                   << "which is negative. Either the system clock is wrong or "
199                   << "the kPrefsDailyMetricsLastReportedAt state variable "
200                   << "is wrong.";
201      // In this case, report daily metrics to reset.
202    } else {
203      if (time_reported_since.InSeconds() < 24*60*60) {
204        LOG(INFO) << "Last reported daily metrics "
205                  << utils::FormatTimeDelta(time_reported_since) << " ago.";
206        return false;
207      }
208      LOG(INFO) << "Last reported daily metrics "
209                << utils::FormatTimeDelta(time_reported_since) << " ago, "
210                << "which is more than 24 hours ago.";
211    }
212  }
213
214  LOG(INFO) << "Reporting daily metrics.";
215  system_state_->prefs()->SetInt64(kPrefsDailyMetricsLastReportedAt,
216                                   now.ToInternalValue());
217
218  ReportOSAge();
219
220  return true;
221}
222
223void UpdateAttempter::ReportOSAge() {
224  struct stat sb;
225
226  if (system_state_ == nullptr)
227    return;
228
229  if (stat("/etc/lsb-release", &sb) != 0) {
230    PLOG(ERROR) << "Error getting file status for /etc/lsb-release "
231                << "(Note: this may happen in some unit tests)";
232    return;
233  }
234
235  Time lsb_release_timestamp = utils::TimeFromStructTimespec(&sb.st_ctim);
236  Time now = system_state_->clock()->GetWallclockTime();
237  TimeDelta age = now - lsb_release_timestamp;
238  if (age.InSeconds() < 0) {
239    LOG(ERROR) << "The OS age (" << utils::FormatTimeDelta(age)
240               << ") is negative. Maybe the clock is wrong? "
241               << "(Note: this may happen in some unit tests.)";
242    return;
243  }
244
245  string metric = "Installer.OSAgeDays";
246  LOG(INFO) << "Uploading " << utils::FormatTimeDelta(age)
247            << " for metric " <<  metric;
248  system_state_->metrics_lib()->SendToUMA(
249       metric,
250       static_cast<int>(age.InDays()),
251       0,             // min: 0 days
252       6*30,          // max: 6 months (approx)
253       kNumDefaultUmaBuckets);
254
255  metrics::ReportDailyMetrics(system_state_, age);
256}
257
258void UpdateAttempter::Update(const string& app_version,
259                             const string& omaha_url,
260                             const string& target_channel,
261                             const string& target_version_prefix,
262                             bool obey_proxies,
263                             bool interactive) {
264  // This is normally called frequently enough so it's appropriate to use as a
265  // hook for reporting daily metrics.
266  // TODO(garnold) This should be hooked to a separate (reliable and consistent)
267  // timeout event.
268  CheckAndReportDailyMetrics();
269
270  // Notify of the new update attempt, clearing prior interactive requests.
271  if (forced_update_pending_callback_.get())
272    forced_update_pending_callback_->Run(false, false);
273
274  chrome_proxy_resolver_.Init();
275  fake_update_success_ = false;
276  if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
277    // Although we have applied an update, we still want to ping Omaha
278    // to ensure the number of active statistics is accurate.
279    //
280    // Also convey to the UpdateEngine.Check.Result metric that we're
281    // not performing an update check because of this.
282    LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
283              << "reboot, we'll ping Omaha instead";
284    metrics::ReportUpdateCheckMetrics(system_state_,
285                                      metrics::CheckResult::kRebootPending,
286                                      metrics::CheckReaction::kUnset,
287                                      metrics::DownloadErrorCode::kUnset);
288    PingOmaha();
289    return;
290  }
291  if (status_ != UPDATE_STATUS_IDLE) {
292    // Update in progress. Do nothing
293    return;
294  }
295
296  if (!CalculateUpdateParams(app_version,
297                             omaha_url,
298                             target_channel,
299                             target_version_prefix,
300                             obey_proxies,
301                             interactive)) {
302    return;
303  }
304
305  BuildUpdateActions(interactive);
306
307  SetStatusAndNotify(UPDATE_STATUS_CHECKING_FOR_UPDATE);
308
309  // Update the last check time here; it may be re-updated when an Omaha
310  // response is received, but this will prevent us from repeatedly scheduling
311  // checks in the case where a response is not received.
312  UpdateLastCheckedTime();
313
314  // Just in case we didn't update boot flags yet, make sure they're updated
315  // before any update processing starts.
316  start_action_processor_ = true;
317  UpdateBootFlags();
318}
319
320void UpdateAttempter::RefreshDevicePolicy() {
321  // Lazy initialize the policy provider, or reload the latest policy data.
322  if (!policy_provider_.get())
323    policy_provider_.reset(new policy::PolicyProvider());
324  policy_provider_->Reload();
325
326  const policy::DevicePolicy* device_policy = nullptr;
327  if (policy_provider_->device_policy_is_loaded())
328    device_policy = &policy_provider_->GetDevicePolicy();
329
330  if (device_policy)
331    LOG(INFO) << "Device policies/settings present";
332  else
333    LOG(INFO) << "No device policies/settings present.";
334
335  system_state_->set_device_policy(device_policy);
336  system_state_->p2p_manager()->SetDevicePolicy(device_policy);
337}
338
339void UpdateAttempter::CalculateP2PParams(bool interactive) {
340  bool use_p2p_for_downloading = false;
341  bool use_p2p_for_sharing = false;
342
343  // Never use p2p for downloading in interactive checks unless the
344  // developer has opted in for it via a marker file.
345  //
346  // (Why would a developer want to opt in? If he's working on the
347  // update_engine or p2p codebases so he can actually test his
348  // code.).
349
350  if (system_state_ != nullptr) {
351    if (!system_state_->p2p_manager()->IsP2PEnabled()) {
352      LOG(INFO) << "p2p is not enabled - disallowing p2p for both"
353                << " downloading and sharing.";
354    } else {
355      // Allow p2p for sharing, even in interactive checks.
356      use_p2p_for_sharing = true;
357      if (!interactive) {
358        LOG(INFO) << "Non-interactive check - allowing p2p for downloading";
359        use_p2p_for_downloading = true;
360      } else {
361        LOG(INFO) << "Forcibly disabling use of p2p for downloading "
362                  << "since this update attempt is interactive.";
363      }
364    }
365  }
366
367  PayloadStateInterface* const payload_state = system_state_->payload_state();
368  payload_state->SetUsingP2PForDownloading(use_p2p_for_downloading);
369  payload_state->SetUsingP2PForSharing(use_p2p_for_sharing);
370}
371
372bool UpdateAttempter::CalculateUpdateParams(const string& app_version,
373                                            const string& omaha_url,
374                                            const string& target_channel,
375                                            const string& target_version_prefix,
376                                            bool obey_proxies,
377                                            bool interactive) {
378  http_response_code_ = 0;
379  PayloadStateInterface* const payload_state = system_state_->payload_state();
380
381  // Refresh the policy before computing all the update parameters.
382  RefreshDevicePolicy();
383
384  // Set the target version prefix, if provided.
385  if (!target_version_prefix.empty())
386    omaha_request_params_->set_target_version_prefix(target_version_prefix);
387
388  CalculateScatteringParams(interactive);
389
390  CalculateP2PParams(interactive);
391  if (payload_state->GetUsingP2PForDownloading() ||
392      payload_state->GetUsingP2PForSharing()) {
393    // OK, p2p is to be used - start it and perform housekeeping.
394    if (!StartP2PAndPerformHousekeeping()) {
395      // If this fails, disable p2p for this attempt
396      LOG(INFO) << "Forcibly disabling use of p2p since starting p2p or "
397                << "performing housekeeping failed.";
398      payload_state->SetUsingP2PForDownloading(false);
399      payload_state->SetUsingP2PForSharing(false);
400    }
401  }
402
403  if (!omaha_request_params_->Init(app_version,
404                                   omaha_url,
405                                   interactive)) {
406    LOG(ERROR) << "Unable to initialize Omaha request params.";
407    return false;
408  }
409
410  // Set the target channel, if one was provided.
411  if (target_channel.empty()) {
412    LOG(INFO) << "No target channel mandated by policy.";
413  } else {
414    LOG(INFO) << "Setting target channel as mandated: " << target_channel;
415    // Pass in false for powerwash_allowed until we add it to the policy
416    // protobuf.
417    omaha_request_params_->SetTargetChannel(target_channel, false);
418
419    // Since this is the beginning of a new attempt, update the download
420    // channel. The download channel won't be updated until the next attempt,
421    // even if target channel changes meanwhile, so that how we'll know if we
422    // should cancel the current download attempt if there's such a change in
423    // target channel.
424    omaha_request_params_->UpdateDownloadChannel();
425  }
426
427  LOG(INFO) << "target_version_prefix = "
428            << omaha_request_params_->target_version_prefix()
429            << ", scatter_factor_in_seconds = "
430            << utils::FormatSecs(scatter_factor_.InSeconds());
431
432  LOG(INFO) << "Wall Clock Based Wait Enabled = "
433            << omaha_request_params_->wall_clock_based_wait_enabled()
434            << ", Update Check Count Wait Enabled = "
435            << omaha_request_params_->update_check_count_wait_enabled()
436            << ", Waiting Period = " << utils::FormatSecs(
437               omaha_request_params_->waiting_period().InSeconds());
438
439  LOG(INFO) << "Use p2p For Downloading = "
440            << payload_state->GetUsingP2PForDownloading()
441            << ", Use p2p For Sharing = "
442            << payload_state->GetUsingP2PForSharing();
443
444  obeying_proxies_ = true;
445  if (obey_proxies || proxy_manual_checks_ == 0) {
446    LOG(INFO) << "forced to obey proxies";
447    // If forced to obey proxies, every 20th request will not use proxies
448    proxy_manual_checks_++;
449    LOG(INFO) << "proxy manual checks: " << proxy_manual_checks_;
450    if (proxy_manual_checks_ >= kMaxConsecutiveObeyProxyRequests) {
451      proxy_manual_checks_ = 0;
452      obeying_proxies_ = false;
453    }
454  } else if (base::RandInt(0, 4) == 0) {
455    obeying_proxies_ = false;
456  }
457  LOG_IF(INFO, !obeying_proxies_) << "To help ensure updates work, this update "
458      "check we are ignoring the proxy settings and using "
459      "direct connections.";
460
461  DisableDeltaUpdateIfNeeded();
462  return true;
463}
464
465void UpdateAttempter::CalculateScatteringParams(bool interactive) {
466  // Take a copy of the old scatter value before we update it, as
467  // we need to update the waiting period if this value changes.
468  TimeDelta old_scatter_factor = scatter_factor_;
469  const policy::DevicePolicy* device_policy = system_state_->device_policy();
470  if (device_policy) {
471    int64_t new_scatter_factor_in_secs = 0;
472    device_policy->GetScatterFactorInSeconds(&new_scatter_factor_in_secs);
473    if (new_scatter_factor_in_secs < 0)  // sanitize input, just in case.
474      new_scatter_factor_in_secs  = 0;
475    scatter_factor_ = TimeDelta::FromSeconds(new_scatter_factor_in_secs);
476  }
477
478  bool is_scatter_enabled = false;
479  if (scatter_factor_.InSeconds() == 0) {
480    LOG(INFO) << "Scattering disabled since scatter factor is set to 0";
481  } else if (interactive) {
482    LOG(INFO) << "Scattering disabled as this is an interactive update check";
483  } else if (!system_state_->hardware()->IsOOBEComplete(nullptr)) {
484    LOG(INFO) << "Scattering disabled since OOBE is not complete yet";
485  } else {
486    is_scatter_enabled = true;
487    LOG(INFO) << "Scattering is enabled";
488  }
489
490  if (is_scatter_enabled) {
491    // This means the scattering policy is turned on.
492    // Now check if we need to update the waiting period. The two cases
493    // in which we'd need to update the waiting period are:
494    // 1. First time in process or a scheduled check after a user-initiated one.
495    //    (omaha_request_params_->waiting_period will be zero in this case).
496    // 2. Admin has changed the scattering policy value.
497    //    (new scattering value will be different from old one in this case).
498    int64_t wait_period_in_secs = 0;
499    if (omaha_request_params_->waiting_period().InSeconds() == 0) {
500      // First case. Check if we have a suitable value to set for
501      // the waiting period.
502      if (prefs_->GetInt64(kPrefsWallClockWaitPeriod, &wait_period_in_secs) &&
503          wait_period_in_secs > 0 &&
504          wait_period_in_secs <= scatter_factor_.InSeconds()) {
505        // This means:
506        // 1. There's a persisted value for the waiting period available.
507        // 2. And that persisted value is still valid.
508        // So, in this case, we should reuse the persisted value instead of
509        // generating a new random value to improve the chances of a good
510        // distribution for scattering.
511        omaha_request_params_->set_waiting_period(
512          TimeDelta::FromSeconds(wait_period_in_secs));
513        LOG(INFO) << "Using persisted wall-clock waiting period: " <<
514            utils::FormatSecs(
515                omaha_request_params_->waiting_period().InSeconds());
516      } else {
517        // This means there's no persisted value for the waiting period
518        // available or its value is invalid given the new scatter_factor value.
519        // So, we should go ahead and regenerate a new value for the
520        // waiting period.
521        LOG(INFO) << "Persisted value not present or not valid ("
522                  << utils::FormatSecs(wait_period_in_secs)
523                  << ") for wall-clock waiting period.";
524        GenerateNewWaitingPeriod();
525      }
526    } else if (scatter_factor_ != old_scatter_factor) {
527      // This means there's already a waiting period value, but we detected
528      // a change in the scattering policy value. So, we should regenerate the
529      // waiting period to make sure it's within the bounds of the new scatter
530      // factor value.
531      GenerateNewWaitingPeriod();
532    } else {
533      // Neither the first time scattering is enabled nor the scattering value
534      // changed. Nothing to do.
535      LOG(INFO) << "Keeping current wall-clock waiting period: " <<
536          utils::FormatSecs(
537              omaha_request_params_->waiting_period().InSeconds());
538    }
539
540    // The invariant at this point is that omaha_request_params_->waiting_period
541    // is non-zero no matter which path we took above.
542    LOG_IF(ERROR, omaha_request_params_->waiting_period().InSeconds() == 0)
543        << "Waiting Period should NOT be zero at this point!!!";
544
545    // Since scattering is enabled, wall clock based wait will always be
546    // enabled.
547    omaha_request_params_->set_wall_clock_based_wait_enabled(true);
548
549    // If we don't have any issues in accessing the file system to update
550    // the update check count value, we'll turn that on as well.
551    bool decrement_succeeded = DecrementUpdateCheckCount();
552    omaha_request_params_->set_update_check_count_wait_enabled(
553      decrement_succeeded);
554  } else {
555    // This means the scattering feature is turned off or disabled for
556    // this particular update check. Make sure to disable
557    // all the knobs and artifacts so that we don't invoke any scattering
558    // related code.
559    omaha_request_params_->set_wall_clock_based_wait_enabled(false);
560    omaha_request_params_->set_update_check_count_wait_enabled(false);
561    omaha_request_params_->set_waiting_period(TimeDelta::FromSeconds(0));
562    prefs_->Delete(kPrefsWallClockWaitPeriod);
563    prefs_->Delete(kPrefsUpdateCheckCount);
564    // Don't delete the UpdateFirstSeenAt file as we don't want manual checks
565    // that result in no-updates (e.g. due to server side throttling) to
566    // cause update starvation by having the client generate a new
567    // UpdateFirstSeenAt for each scheduled check that follows a manual check.
568  }
569}
570
571void UpdateAttempter::GenerateNewWaitingPeriod() {
572  omaha_request_params_->set_waiting_period(TimeDelta::FromSeconds(
573      base::RandInt(1, scatter_factor_.InSeconds())));
574
575  LOG(INFO) << "Generated new wall-clock waiting period: " << utils::FormatSecs(
576                omaha_request_params_->waiting_period().InSeconds());
577
578  // Do a best-effort to persist this in all cases. Even if the persistence
579  // fails, we'll still be able to scatter based on our in-memory value.
580  // The persistence only helps in ensuring a good overall distribution
581  // across multiple devices if they tend to reboot too often.
582  system_state_->payload_state()->SetScatteringWaitPeriod(
583      omaha_request_params_->waiting_period());
584}
585
586void UpdateAttempter::BuildPostInstallActions(
587    InstallPlanAction* previous_action) {
588  shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
589        new PostinstallRunnerAction());
590  actions_.push_back(shared_ptr<AbstractAction>(postinstall_runner_action));
591  BondActions(previous_action,
592              postinstall_runner_action.get());
593}
594
595void UpdateAttempter::BuildUpdateActions(bool interactive) {
596  CHECK(!processor_->IsRunning());
597  processor_->set_delegate(this);
598
599  // Actions:
600  LibcurlHttpFetcher* update_check_fetcher =
601      new LibcurlHttpFetcher(GetProxyResolver(), system_state_);
602  // Try harder to connect to the network, esp when not interactive.
603  // See comment in libcurl_http_fetcher.cc.
604  update_check_fetcher->set_no_network_max_retries(interactive ? 1 : 3);
605  update_check_fetcher->set_check_certificate(CertificateChecker::kUpdate);
606  shared_ptr<OmahaRequestAction> update_check_action(
607      new OmahaRequestAction(system_state_,
608                             nullptr,
609                             update_check_fetcher,  // passes ownership
610                             false));
611  shared_ptr<OmahaResponseHandlerAction> response_handler_action(
612      new OmahaResponseHandlerAction(system_state_));
613  shared_ptr<FilesystemVerifierAction> src_filesystem_verifier_action(
614      new FilesystemVerifierAction(system_state_,
615                                   PartitionType::kSourceRootfs));
616  shared_ptr<FilesystemVerifierAction> src_kernel_filesystem_verifier_action(
617      new FilesystemVerifierAction(system_state_,
618                                   PartitionType::kSourceKernel));
619
620  shared_ptr<OmahaRequestAction> download_started_action(
621      new OmahaRequestAction(system_state_,
622                             new OmahaEvent(
623                                 OmahaEvent::kTypeUpdateDownloadStarted),
624                             new LibcurlHttpFetcher(GetProxyResolver(),
625                                                    system_state_),
626                             false));
627  LibcurlHttpFetcher* download_fetcher =
628      new LibcurlHttpFetcher(GetProxyResolver(), system_state_);
629  download_fetcher->set_check_certificate(CertificateChecker::kDownload);
630  shared_ptr<DownloadAction> download_action(
631      new DownloadAction(prefs_,
632                         system_state_,
633                         new MultiRangeHttpFetcher(
634                             download_fetcher)));  // passes ownership
635  shared_ptr<OmahaRequestAction> download_finished_action(
636      new OmahaRequestAction(system_state_,
637                             new OmahaEvent(
638                                 OmahaEvent::kTypeUpdateDownloadFinished),
639                             new LibcurlHttpFetcher(GetProxyResolver(),
640                                                    system_state_),
641                             false));
642  shared_ptr<FilesystemVerifierAction> dst_filesystem_verifier_action(
643      new FilesystemVerifierAction(system_state_, PartitionType::kRootfs));
644  shared_ptr<FilesystemVerifierAction> dst_kernel_filesystem_verifier_action(
645      new FilesystemVerifierAction(system_state_, PartitionType::kKernel));
646  shared_ptr<OmahaRequestAction> update_complete_action(
647      new OmahaRequestAction(system_state_,
648                             new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
649                             new LibcurlHttpFetcher(GetProxyResolver(),
650                                                    system_state_),
651                             false));
652
653  download_action->set_delegate(this);
654  response_handler_action_ = response_handler_action;
655  download_action_ = download_action;
656
657  actions_.push_back(shared_ptr<AbstractAction>(update_check_action));
658  actions_.push_back(shared_ptr<AbstractAction>(response_handler_action));
659  actions_.push_back(shared_ptr<AbstractAction>(
660      src_filesystem_verifier_action));
661  actions_.push_back(shared_ptr<AbstractAction>(
662      src_kernel_filesystem_verifier_action));
663  actions_.push_back(shared_ptr<AbstractAction>(download_started_action));
664  actions_.push_back(shared_ptr<AbstractAction>(download_action));
665  actions_.push_back(shared_ptr<AbstractAction>(download_finished_action));
666  actions_.push_back(shared_ptr<AbstractAction>(
667      dst_filesystem_verifier_action));
668  actions_.push_back(shared_ptr<AbstractAction>(
669      dst_kernel_filesystem_verifier_action));
670
671  // Bond them together. We have to use the leaf-types when calling
672  // BondActions().
673  BondActions(update_check_action.get(),
674              response_handler_action.get());
675  BondActions(response_handler_action.get(),
676              src_filesystem_verifier_action.get());
677  BondActions(src_filesystem_verifier_action.get(),
678              src_kernel_filesystem_verifier_action.get());
679  BondActions(src_kernel_filesystem_verifier_action.get(),
680              download_action.get());
681  BondActions(download_action.get(),
682              dst_filesystem_verifier_action.get());
683  BondActions(dst_filesystem_verifier_action.get(),
684              dst_kernel_filesystem_verifier_action.get());
685
686  BuildPostInstallActions(dst_kernel_filesystem_verifier_action.get());
687
688  actions_.push_back(shared_ptr<AbstractAction>(update_complete_action));
689
690  // Enqueue the actions
691  for (const shared_ptr<AbstractAction>& action : actions_) {
692    processor_->EnqueueAction(action.get());
693  }
694}
695
696bool UpdateAttempter::Rollback(bool powerwash) {
697  if (!CanRollback()) {
698    return false;
699  }
700
701  // Extra check for enterprise-enrolled devices since they don't support
702  // powerwash.
703  if (powerwash) {
704    // Enterprise-enrolled devices have an empty owner in their device policy.
705    string owner;
706    RefreshDevicePolicy();
707    const policy::DevicePolicy* device_policy = system_state_->device_policy();
708    if (device_policy && (!device_policy->GetOwner(&owner) || owner.empty())) {
709      LOG(ERROR) << "Enterprise device detected. "
710                 << "Cannot perform a powerwash for enterprise devices.";
711      return false;
712    }
713  }
714
715  processor_->set_delegate(this);
716
717  // Initialize the default request params.
718  if (!omaha_request_params_->Init("", "", true)) {
719    LOG(ERROR) << "Unable to initialize Omaha request params.";
720    return false;
721  }
722
723  LOG(INFO) << "Setting rollback options.";
724  InstallPlan install_plan;
725
726  TEST_AND_RETURN_FALSE(utils::GetInstallDev(
727      system_state_->hardware()->BootDevice(),
728      &install_plan.install_path));
729
730  install_plan.kernel_install_path =
731      utils::KernelDeviceOfBootDevice(install_plan.install_path);
732  install_plan.source_path = system_state_->hardware()->BootDevice();
733  install_plan.kernel_source_path =
734      utils::KernelDeviceOfBootDevice(install_plan.source_path);
735  install_plan.powerwash_required = powerwash;
736
737  LOG(INFO) << "Using this install plan:";
738  install_plan.Dump();
739
740  shared_ptr<InstallPlanAction> install_plan_action(
741      new InstallPlanAction(install_plan));
742  actions_.push_back(shared_ptr<AbstractAction>(install_plan_action));
743
744  BuildPostInstallActions(install_plan_action.get());
745
746  // Enqueue the actions
747  for (const shared_ptr<AbstractAction>& action : actions_) {
748    processor_->EnqueueAction(action.get());
749  }
750
751  // Update the payload state for Rollback.
752  system_state_->payload_state()->Rollback();
753
754  SetStatusAndNotify(UPDATE_STATUS_ATTEMPTING_ROLLBACK);
755
756  // Just in case we didn't update boot flags yet, make sure they're updated
757  // before any update processing starts. This also schedules the start of the
758  // actions we just posted.
759  start_action_processor_ = true;
760  UpdateBootFlags();
761  return true;
762}
763
764bool UpdateAttempter::CanRollback() const {
765  // We can only rollback if the update_engine isn't busy and we have a valid
766  // rollback partition.
767  return (status_ == UPDATE_STATUS_IDLE && !GetRollbackPartition().empty());
768}
769
770string UpdateAttempter::GetRollbackPartition() const {
771  vector<string> kernel_devices =
772      system_state_->hardware()->GetKernelDevices();
773
774  string boot_kernel_device =
775      system_state_->hardware()->BootKernelDevice();
776
777  LOG(INFO) << "UpdateAttempter::GetRollbackPartition";
778  for (const auto& name : kernel_devices)
779    LOG(INFO) << "  Available kernel device = " << name;
780  LOG(INFO) << "  Boot kernel device =      " << boot_kernel_device;
781
782  auto current = std::find(kernel_devices.begin(), kernel_devices.end(),
783                           boot_kernel_device);
784
785  if (current == kernel_devices.end()) {
786    LOG(ERROR) << "Unable to find the boot kernel device in the list of "
787               << "available devices";
788    return string();
789  }
790
791  for (string const& device_name : kernel_devices) {
792    if (device_name != *current) {
793      bool bootable = false;
794      if (system_state_->hardware()->IsKernelBootable(device_name, &bootable) &&
795          bootable) {
796        return device_name;
797      }
798    }
799  }
800
801  return string();
802}
803
804vector<std::pair<string, bool>>
805    UpdateAttempter::GetKernelDevices() const {
806  vector<string> kernel_devices =
807    system_state_->hardware()->GetKernelDevices();
808
809  string boot_kernel_device =
810    system_state_->hardware()->BootKernelDevice();
811
812  vector<std::pair<string, bool>> info_list;
813  info_list.reserve(kernel_devices.size());
814
815  for (string device_name : kernel_devices) {
816    bool bootable = false;
817    system_state_->hardware()->IsKernelBootable(device_name, &bootable);
818    // Add '*' to the name of the partition we booted from.
819    if (device_name == boot_kernel_device)
820      device_name += '*';
821    info_list.emplace_back(device_name, bootable);
822  }
823
824  return info_list;
825}
826
827void UpdateAttempter::CheckForUpdate(const string& app_version,
828                                     const string& omaha_url,
829                                     bool interactive) {
830  LOG(INFO) << "Forced update check requested.";
831  forced_app_version_.clear();
832  forced_omaha_url_.clear();
833
834  // Certain conditions must be met to allow setting custom version and update
835  // server URLs. However, kScheduledAUTestURLRequest and kAUTestURLRequest are
836  // always allowed regardless of device state.
837  if (IsAnyUpdateSourceAllowed()) {
838    forced_app_version_ = app_version;
839    forced_omaha_url_ = omaha_url;
840  }
841  if (omaha_url == kScheduledAUTestURLRequest) {
842    forced_omaha_url_ = chromeos_update_engine::kAUTestOmahaUrl;
843    // Pretend that it's not user-initiated even though it is,
844    // so as to test scattering logic, etc. which get kicked off
845    // only in scheduled update checks.
846    interactive = false;
847  } else if (omaha_url == kAUTestURLRequest) {
848    forced_omaha_url_ = chromeos_update_engine::kAUTestOmahaUrl;
849  }
850
851  if (forced_update_pending_callback_.get()) {
852    // Make sure that a scheduling request is made prior to calling the forced
853    // update pending callback.
854    ScheduleUpdates();
855    forced_update_pending_callback_->Run(true, interactive);
856  }
857}
858
859bool UpdateAttempter::RebootIfNeeded() {
860  if (status_ != UPDATE_STATUS_UPDATED_NEED_REBOOT) {
861    LOG(INFO) << "Reboot requested, but status is "
862              << UpdateStatusToString(status_) << ", so not rebooting.";
863    return false;
864  }
865
866  if (USE_POWER_MANAGEMENT && RequestPowerManagerReboot())
867    return true;
868
869  return RebootDirectly();
870}
871
872void UpdateAttempter::WriteUpdateCompletedMarker() {
873  if (update_completed_marker_.empty())
874    return;
875
876  int64_t value = system_state_->clock()->GetBootTime().ToInternalValue();
877  string contents = StringPrintf("%" PRIi64, value);
878
879  utils::WriteFile(update_completed_marker_.c_str(),
880                   contents.c_str(),
881                   contents.length());
882}
883
884bool UpdateAttempter::RequestPowerManagerReboot() {
885  org::chromium::PowerManagerProxyInterface* power_manager_proxy =
886      system_state_->power_manager_proxy();
887  if (!power_manager_proxy) {
888    LOG(WARNING) << "No PowerManager proxy defined, skipping reboot.";
889    return false;
890  }
891  LOG(INFO) << "Calling " << power_manager::kPowerManagerInterface << "."
892            << power_manager::kRequestRestartMethod;
893  chromeos::ErrorPtr error;
894  return power_manager_proxy->RequestRestart(
895      power_manager::REQUEST_RESTART_FOR_UPDATE, &error);
896}
897
898bool UpdateAttempter::RebootDirectly() {
899  vector<string> command;
900  command.push_back("/sbin/shutdown");
901  command.push_back("-r");
902  command.push_back("now");
903  LOG(INFO) << "Running \"" << JoinString(command, ' ') << "\"";
904  int rc = 0;
905  Subprocess::SynchronousExec(command, &rc, nullptr);
906  return rc == 0;
907}
908
909void UpdateAttempter::OnUpdateScheduled(EvalStatus status,
910                                        const UpdateCheckParams& params) {
911  waiting_for_scheduled_check_ = false;
912
913  if (status == EvalStatus::kSucceeded) {
914    if (!params.updates_enabled) {
915      LOG(WARNING) << "Updates permanently disabled.";
916      // Signal disabled status, then switch right back to idle. This is
917      // necessary for ensuring that observers waiting for a signal change will
918      // actually notice one on subsequent calls. Note that we don't need to
919      // re-schedule a check in this case as updates are permanently disabled;
920      // further (forced) checks may still initiate a scheduling call.
921      SetStatusAndNotify(UPDATE_STATUS_DISABLED);
922      SetStatusAndNotify(UPDATE_STATUS_IDLE);
923      return;
924    }
925
926    LOG(INFO) << "Running "
927              << (params.is_interactive ? "interactive" : "periodic")
928              << " update.";
929
930    string app_version, omaha_url;
931    if (params.is_interactive) {
932      app_version = forced_app_version_;
933      omaha_url = forced_omaha_url_;
934    } else {
935      // Flush previously generated UMA reports before periodic updates.
936      CertificateChecker::FlushReport();
937    }
938
939    Update(app_version, omaha_url, params.target_channel,
940           params.target_version_prefix, false, params.is_interactive);
941  } else {
942    LOG(WARNING)
943        << "Update check scheduling failed (possibly timed out); retrying.";
944    ScheduleUpdates();
945  }
946
947  // This check ensures that future update checks will be or are already
948  // scheduled. The check should never fail. A check failure means that there's
949  // a bug that will most likely prevent further automatic update checks. It
950  // seems better to crash in such cases and restart the update_engine daemon
951  // into, hopefully, a known good state.
952  CHECK(IsUpdateRunningOrScheduled());
953}
954
955void UpdateAttempter::UpdateLastCheckedTime() {
956  last_checked_time_ = system_state_->clock()->GetWallclockTime().ToTimeT();
957}
958
959// Delegate methods:
960void UpdateAttempter::ProcessingDone(const ActionProcessor* processor,
961                                     ErrorCode code) {
962  LOG(INFO) << "Processing Done.";
963  actions_.clear();
964
965  // Reset cpu shares back to normal.
966  CleanupCpuSharesManagement();
967
968  if (status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
969    LOG(INFO) << "Error event sent.";
970
971    // Inform scheduler of new status;
972    SetStatusAndNotify(UPDATE_STATUS_IDLE);
973    ScheduleUpdates();
974
975    if (!fake_update_success_) {
976      return;
977    }
978    LOG(INFO) << "Booted from FW B and tried to install new firmware, "
979        "so requesting reboot from user.";
980  }
981
982  if (code == ErrorCode::kSuccess) {
983    WriteUpdateCompletedMarker();
984    prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
985    prefs_->SetString(kPrefsPreviousVersion,
986                      omaha_request_params_->app_version());
987    DeltaPerformer::ResetUpdateProgress(prefs_, false);
988
989    system_state_->payload_state()->UpdateSucceeded();
990
991    // Since we're done with scattering fully at this point, this is the
992    // safest point delete the state files, as we're sure that the status is
993    // set to reboot (which means no more updates will be applied until reboot)
994    // This deletion is required for correctness as we want the next update
995    // check to re-create a new random number for the update check count.
996    // Similarly, we also delete the wall-clock-wait period that was persisted
997    // so that we start with a new random value for the next update check
998    // after reboot so that the same device is not favored or punished in any
999    // way.
1000    prefs_->Delete(kPrefsUpdateCheckCount);
1001    system_state_->payload_state()->SetScatteringWaitPeriod(TimeDelta());
1002    prefs_->Delete(kPrefsUpdateFirstSeenAt);
1003
1004    SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT);
1005    ScheduleUpdates();
1006    LOG(INFO) << "Update successfully applied, waiting to reboot.";
1007
1008    // This pointer is null during rollback operations, and the stats
1009    // don't make much sense then anyway.
1010    if (response_handler_action_) {
1011      const InstallPlan& install_plan =
1012          response_handler_action_->install_plan();
1013
1014      // Generate an unique payload identifier.
1015      const string target_version_uid =
1016          install_plan.payload_hash + ":" + install_plan.metadata_signature;
1017
1018      // Expect to reboot into the new version to send the proper metric during
1019      // next boot.
1020      system_state_->payload_state()->ExpectRebootInNewVersion(
1021          target_version_uid);
1022
1023      // Also report the success code so that the percentiles can be
1024      // interpreted properly for the remaining error codes in UMA.
1025      utils::SendErrorCodeToUma(system_state_, code);
1026    } else {
1027      // If we just finished a rollback, then we expect to have no Omaha
1028      // response. Otherwise, it's an error.
1029      if (system_state_->payload_state()->GetRollbackVersion().empty()) {
1030        LOG(ERROR) << "Can't send metrics because expected "
1031            "response_handler_action_ missing.";
1032      }
1033    }
1034    return;
1035  }
1036
1037  if (ScheduleErrorEventAction()) {
1038    return;
1039  }
1040  LOG(INFO) << "No update.";
1041  SetStatusAndNotify(UPDATE_STATUS_IDLE);
1042  ScheduleUpdates();
1043}
1044
1045void UpdateAttempter::ProcessingStopped(const ActionProcessor* processor) {
1046  // Reset cpu shares back to normal.
1047  CleanupCpuSharesManagement();
1048  download_progress_ = 0.0;
1049  SetStatusAndNotify(UPDATE_STATUS_IDLE);
1050  ScheduleUpdates();
1051  actions_.clear();
1052  error_event_.reset(nullptr);
1053}
1054
1055// Called whenever an action has finished processing, either successfully
1056// or otherwise.
1057void UpdateAttempter::ActionCompleted(ActionProcessor* processor,
1058                                      AbstractAction* action,
1059                                      ErrorCode code) {
1060  // Reset download progress regardless of whether or not the download
1061  // action succeeded. Also, get the response code from HTTP request
1062  // actions (update download as well as the initial update check
1063  // actions).
1064  const string type = action->Type();
1065  if (type == DownloadAction::StaticType()) {
1066    download_progress_ = 0.0;
1067    DownloadAction* download_action = static_cast<DownloadAction*>(action);
1068    http_response_code_ = download_action->GetHTTPResponseCode();
1069  } else if (type == OmahaRequestAction::StaticType()) {
1070    OmahaRequestAction* omaha_request_action =
1071        static_cast<OmahaRequestAction*>(action);
1072    // If the request is not an event, then it's the update-check.
1073    if (!omaha_request_action->IsEvent()) {
1074      http_response_code_ = omaha_request_action->GetHTTPResponseCode();
1075
1076      // Record the number of consecutive failed update checks.
1077      if (http_response_code_ == kHttpResponseInternalServerError ||
1078          http_response_code_ == kHttpResponseServiceUnavailable) {
1079        consecutive_failed_update_checks_++;
1080      } else {
1081        consecutive_failed_update_checks_ = 0;
1082      }
1083
1084      // Store the server-dictated poll interval, if any.
1085      server_dictated_poll_interval_ =
1086          std::max(0, omaha_request_action->GetOutputObject().poll_interval);
1087    }
1088  }
1089  if (code != ErrorCode::kSuccess) {
1090    // If the current state is at or past the download phase, count the failure
1091    // in case a switch to full update becomes necessary. Ignore network
1092    // transfer timeouts and failures.
1093    if (status_ >= UPDATE_STATUS_DOWNLOADING &&
1094        code != ErrorCode::kDownloadTransferError) {
1095      MarkDeltaUpdateFailure();
1096    }
1097    // On failure, schedule an error event to be sent to Omaha.
1098    CreatePendingErrorEvent(action, code);
1099    return;
1100  }
1101  // Find out which action completed.
1102  if (type == OmahaResponseHandlerAction::StaticType()) {
1103    // Note that the status will be updated to DOWNLOADING when some bytes get
1104    // actually downloaded from the server and the BytesReceived callback is
1105    // invoked. This avoids notifying the user that a download has started in
1106    // cases when the server and the client are unable to initiate the download.
1107    CHECK(action == response_handler_action_.get());
1108    const InstallPlan& plan = response_handler_action_->install_plan();
1109    UpdateLastCheckedTime();
1110    new_version_ = plan.version;
1111    new_payload_size_ = plan.payload_size;
1112    SetupDownload();
1113    SetupCpuSharesManagement();
1114    SetStatusAndNotify(UPDATE_STATUS_UPDATE_AVAILABLE);
1115  } else if (type == DownloadAction::StaticType()) {
1116    SetStatusAndNotify(UPDATE_STATUS_FINALIZING);
1117  }
1118}
1119
1120void UpdateAttempter::SetDownloadStatus(bool active) {
1121  download_active_ = active;
1122  LOG(INFO) << "Download status: " << (active ? "active" : "inactive");
1123}
1124
1125void UpdateAttempter::BytesReceived(uint64_t bytes_received, uint64_t total) {
1126  if (!download_active_) {
1127    LOG(ERROR) << "BytesReceived called while not downloading.";
1128    return;
1129  }
1130  double progress = static_cast<double>(bytes_received) /
1131      static_cast<double>(total);
1132  // Self throttle based on progress. Also send notifications if
1133  // progress is too slow.
1134  const double kDeltaPercent = 0.01;  // 1%
1135  if (status_ != UPDATE_STATUS_DOWNLOADING ||
1136      bytes_received == total ||
1137      progress - download_progress_ >= kDeltaPercent ||
1138      TimeTicks::Now() - last_notify_time_ >= TimeDelta::FromSeconds(10)) {
1139    download_progress_ = progress;
1140    SetStatusAndNotify(UPDATE_STATUS_DOWNLOADING);
1141  }
1142}
1143
1144bool UpdateAttempter::ResetStatus() {
1145  LOG(INFO) << "Attempting to reset state from "
1146            << UpdateStatusToString(status_) << " to UPDATE_STATUS_IDLE";
1147
1148  switch (status_) {
1149    case UPDATE_STATUS_IDLE:
1150      // no-op.
1151      return true;
1152
1153    case UPDATE_STATUS_UPDATED_NEED_REBOOT:  {
1154      bool ret_value = true;
1155      status_ = UPDATE_STATUS_IDLE;
1156      LOG(INFO) << "Reset Successful";
1157
1158      // Remove the reboot marker so that if the machine is rebooted
1159      // after resetting to idle state, it doesn't go back to
1160      // UPDATE_STATUS_UPDATED_NEED_REBOOT state.
1161      if (!update_completed_marker_.empty()) {
1162        if (!base::DeleteFile(base::FilePath(update_completed_marker_), false))
1163          ret_value = false;
1164      }
1165
1166      // Notify the PayloadState that the successful payload was canceled.
1167      system_state_->payload_state()->ResetUpdateStatus();
1168
1169      return ret_value;
1170    }
1171
1172    default:
1173      LOG(ERROR) << "Reset not allowed in this state.";
1174      return false;
1175  }
1176}
1177
1178bool UpdateAttempter::GetStatus(int64_t* last_checked_time,
1179                                double* progress,
1180                                string* current_operation,
1181                                string* new_version,
1182                                int64_t* new_payload_size) {
1183  *last_checked_time = last_checked_time_;
1184  *progress = download_progress_;
1185  *current_operation = UpdateStatusToString(status_);
1186  *new_version = new_version_;
1187  *new_payload_size = new_payload_size_;
1188  return true;
1189}
1190
1191void UpdateAttempter::UpdateBootFlags() {
1192  if (update_boot_flags_running_) {
1193    LOG(INFO) << "Update boot flags running, nothing to do.";
1194    return;
1195  }
1196  if (updated_boot_flags_) {
1197    LOG(INFO) << "Already updated boot flags. Skipping.";
1198    if (start_action_processor_) {
1199      ScheduleProcessingStart();
1200    }
1201    return;
1202  }
1203  // This is purely best effort. Failures should be logged by Subprocess. Run
1204  // the script asynchronously to avoid blocking the event loop regardless of
1205  // the script runtime.
1206  update_boot_flags_running_ = true;
1207  LOG(INFO) << "Updating boot flags...";
1208  vector<string> cmd{"/usr/sbin/chromeos-setgoodkernel"};
1209  if (skip_set_good_kernel_) {
1210    CompleteUpdateBootFlags(1, "Skipping the call to set");
1211  } else {
1212    if (!Subprocess::Get().Exec(cmd,
1213                                Bind(&UpdateAttempter::CompleteUpdateBootFlags,
1214                                     base::Unretained(this)))) {
1215      CompleteUpdateBootFlags(
1216          1, "Failed to launch process to mark kernel as good");
1217    }
1218  }
1219}
1220
1221void UpdateAttempter::CompleteUpdateBootFlags(int return_code,
1222                                              const string& output) {
1223  update_boot_flags_running_ = false;
1224  updated_boot_flags_ = true;
1225  if (start_action_processor_) {
1226    ScheduleProcessingStart();
1227  }
1228}
1229
1230void UpdateAttempter::BroadcastStatus() {
1231  if (!dbus_adaptor_)
1232    return;
1233  last_notify_time_ = TimeTicks::Now();
1234  dbus_adaptor_->SendStatusUpdateSignal(
1235      last_checked_time_,
1236      download_progress_,
1237      UpdateStatusToString(status_),
1238      new_version_.c_str(),
1239      new_payload_size_);
1240}
1241
1242uint32_t UpdateAttempter::GetErrorCodeFlags()  {
1243  uint32_t flags = 0;
1244
1245  if (!system_state_->hardware()->IsNormalBootMode())
1246    flags |= static_cast<uint32_t>(ErrorCode::kDevModeFlag);
1247
1248  if (response_handler_action_.get() &&
1249      response_handler_action_->install_plan().is_resume)
1250    flags |= static_cast<uint32_t>(ErrorCode::kResumedFlag);
1251
1252  if (!system_state_->hardware()->IsOfficialBuild())
1253    flags |= static_cast<uint32_t>(ErrorCode::kTestImageFlag);
1254
1255  if (omaha_request_params_->update_url() != kProductionOmahaUrl)
1256    flags |= static_cast<uint32_t>(ErrorCode::kTestOmahaUrlFlag);
1257
1258  return flags;
1259}
1260
1261bool UpdateAttempter::ShouldCancel(ErrorCode* cancel_reason) {
1262  // Check if the channel we're attempting to update to is the same as the
1263  // target channel currently chosen by the user.
1264  OmahaRequestParams* params = system_state_->request_params();
1265  if (params->download_channel() != params->target_channel()) {
1266    LOG(ERROR) << "Aborting download as target channel: "
1267               << params->target_channel()
1268               << " is different from the download channel: "
1269               << params->download_channel();
1270    *cancel_reason = ErrorCode::kUpdateCanceledByChannelChange;
1271    return true;
1272  }
1273
1274  return false;
1275}
1276
1277void UpdateAttempter::SetStatusAndNotify(UpdateStatus status) {
1278  status_ = status;
1279  BroadcastStatus();
1280}
1281
1282void UpdateAttempter::CreatePendingErrorEvent(AbstractAction* action,
1283                                              ErrorCode code) {
1284  if (error_event_.get()) {
1285    // This shouldn't really happen.
1286    LOG(WARNING) << "There's already an existing pending error event.";
1287    return;
1288  }
1289
1290  // For now assume that a generic Omaha response action failure means that
1291  // there's no update so don't send an event. Also, double check that the
1292  // failure has not occurred while sending an error event -- in which case
1293  // don't schedule another. This shouldn't really happen but just in case...
1294  if ((action->Type() == OmahaResponseHandlerAction::StaticType() &&
1295       code == ErrorCode::kError) ||
1296      status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
1297    return;
1298  }
1299
1300  // Classify the code to generate the appropriate result so that
1301  // the Borgmon charts show up the results correctly.
1302  // Do this before calling GetErrorCodeForAction which could potentially
1303  // augment the bit representation of code and thus cause no matches for
1304  // the switch cases below.
1305  OmahaEvent::Result event_result;
1306  switch (code) {
1307    case ErrorCode::kOmahaUpdateIgnoredPerPolicy:
1308    case ErrorCode::kOmahaUpdateDeferredPerPolicy:
1309    case ErrorCode::kOmahaUpdateDeferredForBackoff:
1310      event_result = OmahaEvent::kResultUpdateDeferred;
1311      break;
1312    default:
1313      event_result = OmahaEvent::kResultError;
1314      break;
1315  }
1316
1317  code = GetErrorCodeForAction(action, code);
1318  fake_update_success_ = code == ErrorCode::kPostinstallBootedFromFirmwareB;
1319
1320  // Compute the final error code with all the bit flags to be sent to Omaha.
1321  code = static_cast<ErrorCode>(
1322      static_cast<uint32_t>(code) | GetErrorCodeFlags());
1323  error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
1324                                    event_result,
1325                                    code));
1326}
1327
1328bool UpdateAttempter::ScheduleErrorEventAction() {
1329  if (error_event_.get() == nullptr)
1330    return false;
1331
1332  LOG(ERROR) << "Update failed.";
1333  system_state_->payload_state()->UpdateFailed(error_event_->error_code);
1334
1335  // Send it to Uma.
1336  LOG(INFO) << "Reporting the error event";
1337  utils::SendErrorCodeToUma(system_state_, error_event_->error_code);
1338
1339  // Send it to Omaha.
1340  shared_ptr<OmahaRequestAction> error_event_action(
1341      new OmahaRequestAction(system_state_,
1342                             error_event_.release(),  // Pass ownership.
1343                             new LibcurlHttpFetcher(GetProxyResolver(),
1344                                                    system_state_),
1345                             false));
1346  actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
1347  processor_->EnqueueAction(error_event_action.get());
1348  SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT);
1349  processor_->StartProcessing();
1350  return true;
1351}
1352
1353void UpdateAttempter::SetCpuShares(utils::CpuShares shares) {
1354  if (shares_ == shares) {
1355    return;
1356  }
1357  if (utils::SetCpuShares(shares)) {
1358    shares_ = shares;
1359    LOG(INFO) << "CPU shares = " << shares_;
1360  }
1361}
1362
1363void UpdateAttempter::SetupCpuSharesManagement() {
1364  if (manage_shares_id_ != MessageLoop::kTaskIdNull) {
1365    LOG(ERROR) << "Cpu shares timeout source hasn't been destroyed.";
1366    CleanupCpuSharesManagement();
1367  }
1368  const int kCpuSharesTimeout = 2 * 60 * 60;  // 2 hours
1369  manage_shares_id_ = MessageLoop::current()->PostDelayedTask(
1370      FROM_HERE,
1371      Bind(&UpdateAttempter::ManageCpuSharesCallback, base::Unretained(this)),
1372      TimeDelta::FromSeconds(kCpuSharesTimeout));
1373  SetCpuShares(utils::kCpuSharesLow);
1374}
1375
1376void UpdateAttempter::CleanupCpuSharesManagement() {
1377  if (manage_shares_id_ != MessageLoop::kTaskIdNull) {
1378    // The UpdateAttempter is instantiated by default by the FakeSystemState,
1379    // even when it is not used. We check the manage_shares_id_ before calling
1380    // the MessageLoop::current() since the unit test using a FakeSystemState
1381    // may have not define a MessageLoop for the current thread.
1382    MessageLoop::current()->CancelTask(manage_shares_id_);
1383    manage_shares_id_ = MessageLoop::kTaskIdNull;
1384  }
1385  SetCpuShares(utils::kCpuSharesNormal);
1386}
1387
1388void UpdateAttempter::ScheduleProcessingStart() {
1389  LOG(INFO) << "Scheduling an action processor start.";
1390  start_action_processor_ = false;
1391  MessageLoop::current()->PostTask(
1392      FROM_HERE,
1393      Bind([this] { this->processor_->StartProcessing(); }));
1394}
1395
1396void UpdateAttempter::ManageCpuSharesCallback() {
1397  SetCpuShares(utils::kCpuSharesNormal);
1398  manage_shares_id_ = MessageLoop::kTaskIdNull;
1399}
1400
1401void UpdateAttempter::DisableDeltaUpdateIfNeeded() {
1402  int64_t delta_failures;
1403  if (omaha_request_params_->delta_okay() &&
1404      prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) &&
1405      delta_failures >= kMaxDeltaUpdateFailures) {
1406    LOG(WARNING) << "Too many delta update failures, forcing full update.";
1407    omaha_request_params_->set_delta_okay(false);
1408  }
1409}
1410
1411void UpdateAttempter::MarkDeltaUpdateFailure() {
1412  // Don't try to resume a failed delta update.
1413  DeltaPerformer::ResetUpdateProgress(prefs_, false);
1414  int64_t delta_failures;
1415  if (!prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) ||
1416      delta_failures < 0) {
1417    delta_failures = 0;
1418  }
1419  prefs_->SetInt64(kPrefsDeltaUpdateFailures, ++delta_failures);
1420}
1421
1422void UpdateAttempter::SetupDownload() {
1423  MultiRangeHttpFetcher* fetcher =
1424      static_cast<MultiRangeHttpFetcher*>(download_action_->http_fetcher());
1425  fetcher->ClearRanges();
1426  if (response_handler_action_->install_plan().is_resume) {
1427    // Resuming an update so fetch the update manifest metadata first.
1428    int64_t manifest_metadata_size = 0;
1429    prefs_->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size);
1430    fetcher->AddRange(0, manifest_metadata_size);
1431    // If there're remaining unprocessed data blobs, fetch them. Be careful not
1432    // to request data beyond the end of the payload to avoid 416 HTTP response
1433    // error codes.
1434    int64_t next_data_offset = 0;
1435    prefs_->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset);
1436    uint64_t resume_offset = manifest_metadata_size + next_data_offset;
1437    if (resume_offset < response_handler_action_->install_plan().payload_size) {
1438      fetcher->AddRange(resume_offset);
1439    }
1440  } else {
1441    fetcher->AddRange(0);
1442  }
1443}
1444
1445void UpdateAttempter::PingOmaha() {
1446  if (!processor_->IsRunning()) {
1447    shared_ptr<OmahaRequestAction> ping_action(
1448        new OmahaRequestAction(system_state_,
1449                               nullptr,
1450                               new LibcurlHttpFetcher(GetProxyResolver(),
1451                                                      system_state_),
1452                               true));
1453    actions_.push_back(shared_ptr<OmahaRequestAction>(ping_action));
1454    processor_->set_delegate(nullptr);
1455    processor_->EnqueueAction(ping_action.get());
1456    // Call StartProcessing() synchronously here to avoid any race conditions
1457    // caused by multiple outstanding ping Omaha requests.  If we call
1458    // StartProcessing() asynchronously, the device can be suspended before we
1459    // get a chance to callback to StartProcessing().  When the device resumes
1460    // (assuming the device sleeps longer than the next update check period),
1461    // StartProcessing() is called back and at the same time, the next update
1462    // check is fired which eventually invokes StartProcessing().  A crash
1463    // can occur because StartProcessing() checks to make sure that the
1464    // processor is idle which it isn't due to the two concurrent ping Omaha
1465    // requests.
1466    processor_->StartProcessing();
1467  } else {
1468    LOG(WARNING) << "Action processor running, Omaha ping suppressed.";
1469  }
1470
1471  // Update the last check time here; it may be re-updated when an Omaha
1472  // response is received, but this will prevent us from repeatedly scheduling
1473  // checks in the case where a response is not received.
1474  UpdateLastCheckedTime();
1475
1476  // Update the status which will schedule the next update check
1477  SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT);
1478  ScheduleUpdates();
1479}
1480
1481
1482bool UpdateAttempter::DecrementUpdateCheckCount() {
1483  int64_t update_check_count_value;
1484
1485  if (!prefs_->Exists(kPrefsUpdateCheckCount)) {
1486    // This file does not exist. This means we haven't started our update
1487    // check count down yet, so nothing more to do. This file will be created
1488    // later when we first satisfy the wall-clock-based-wait period.
1489    LOG(INFO) << "No existing update check count. That's normal.";
1490    return true;
1491  }
1492
1493  if (prefs_->GetInt64(kPrefsUpdateCheckCount, &update_check_count_value)) {
1494    // Only if we're able to read a proper integer value, then go ahead
1495    // and decrement and write back the result in the same file, if needed.
1496    LOG(INFO) << "Update check count = " << update_check_count_value;
1497
1498    if (update_check_count_value == 0) {
1499      // It could be 0, if, for some reason, the file didn't get deleted
1500      // when we set our status to waiting for reboot. so we just leave it
1501      // as is so that we can prevent another update_check wait for this client.
1502      LOG(INFO) << "Not decrementing update check count as it's already 0.";
1503      return true;
1504    }
1505
1506    if (update_check_count_value > 0)
1507      update_check_count_value--;
1508    else
1509      update_check_count_value = 0;
1510
1511    // Write out the new value of update_check_count_value.
1512    if (prefs_->SetInt64(kPrefsUpdateCheckCount, update_check_count_value)) {
1513      // We successfully wrote out te new value, so enable the
1514      // update check based wait.
1515      LOG(INFO) << "New update check count = " << update_check_count_value;
1516      return true;
1517    }
1518  }
1519
1520  LOG(INFO) << "Deleting update check count state due to read/write errors.";
1521
1522  // We cannot read/write to the file, so disable the update check based wait
1523  // so that we don't get stuck in this OS version by any chance (which could
1524  // happen if there's some bug that causes to read/write incorrectly).
1525  // Also attempt to delete the file to do our best effort to cleanup.
1526  prefs_->Delete(kPrefsUpdateCheckCount);
1527  return false;
1528}
1529
1530
1531void UpdateAttempter::UpdateEngineStarted() {
1532  // If we just booted into a new update, keep the previous OS version
1533  // in case we rebooted because of a crash of the old version, so we
1534  // can do a proper crash report with correct information.
1535  // This must be done before calling
1536  // system_state_->payload_state()->UpdateEngineStarted() since it will
1537  // delete SystemUpdated marker file.
1538  if (system_state_->system_rebooted() &&
1539      prefs_->Exists(kPrefsSystemUpdatedMarker)) {
1540    if (!prefs_->GetString(kPrefsPreviousVersion, &prev_version_)) {
1541      // If we fail to get the version string, make sure it stays empty.
1542      prev_version_.clear();
1543    }
1544  }
1545
1546  system_state_->payload_state()->UpdateEngineStarted();
1547  StartP2PAtStartup();
1548}
1549
1550bool UpdateAttempter::StartP2PAtStartup() {
1551  if (system_state_ == nullptr ||
1552      !system_state_->p2p_manager()->IsP2PEnabled()) {
1553    LOG(INFO) << "Not starting p2p at startup since it's not enabled.";
1554    return false;
1555  }
1556
1557  if (system_state_->p2p_manager()->CountSharedFiles() < 1) {
1558    LOG(INFO) << "Not starting p2p at startup since our application "
1559              << "is not sharing any files.";
1560    return false;
1561  }
1562
1563  return StartP2PAndPerformHousekeeping();
1564}
1565
1566bool UpdateAttempter::StartP2PAndPerformHousekeeping() {
1567  if (system_state_ == nullptr)
1568    return false;
1569
1570  if (!system_state_->p2p_manager()->IsP2PEnabled()) {
1571    LOG(INFO) << "Not starting p2p since it's not enabled.";
1572    return false;
1573  }
1574
1575  LOG(INFO) << "Ensuring that p2p is running.";
1576  if (!system_state_->p2p_manager()->EnsureP2PRunning()) {
1577    LOG(ERROR) << "Error starting p2p.";
1578    return false;
1579  }
1580
1581  LOG(INFO) << "Performing p2p housekeeping.";
1582  if (!system_state_->p2p_manager()->PerformHousekeeping()) {
1583    LOG(ERROR) << "Error performing housekeeping for p2p.";
1584    return false;
1585  }
1586
1587  LOG(INFO) << "Done performing p2p housekeeping.";
1588  return true;
1589}
1590
1591bool UpdateAttempter::GetBootTimeAtUpdate(Time *out_boot_time) {
1592  if (update_completed_marker_.empty())
1593    return false;
1594
1595  string contents;
1596  if (!utils::ReadFile(update_completed_marker_, &contents))
1597    return false;
1598
1599  char *endp;
1600  int64_t stored_value = strtoll(contents.c_str(), &endp, 10);
1601  if (*endp != '\0') {
1602    LOG(ERROR) << "Error parsing file " << update_completed_marker_ << " "
1603               << "with content '" << contents << "'";
1604    return false;
1605  }
1606
1607  *out_boot_time = Time::FromInternalValue(stored_value);
1608  return true;
1609}
1610
1611bool UpdateAttempter::IsUpdateRunningOrScheduled() {
1612  return ((status_ != UPDATE_STATUS_IDLE &&
1613           status_ != UPDATE_STATUS_UPDATED_NEED_REBOOT) ||
1614          waiting_for_scheduled_check_);
1615}
1616
1617bool UpdateAttempter::IsAnyUpdateSourceAllowed() {
1618  // We allow updates from any source if either of these are true:
1619  //  * The device is running an unofficial (dev/test) image.
1620  //  * The debugd dev features are accessible (i.e. in devmode with no owner).
1621  // This protects users running a base image, while still allowing a specific
1622  // window (gated by the debug dev features) where `cros flash` is usable.
1623  if (!system_state_->hardware()->IsOfficialBuild()) {
1624    LOG(INFO) << "Non-official build; allowing any update source.";
1625    return true;
1626  }
1627
1628  // Even though the debugd tools are also gated on devmode, checking here can
1629  // save us a D-Bus call so it's worth doing explicitly.
1630  if (system_state_->hardware()->IsNormalBootMode()) {
1631    LOG(INFO) << "Not in devmode; disallowing custom update sources.";
1632    return false;
1633  }
1634
1635  // Official images in devmode are allowed a custom update source iff the
1636  // debugd dev tools are enabled.
1637  if (!debugd_proxy_)
1638    return false;
1639  int32_t dev_features = debugd::DEV_FEATURES_DISABLED;
1640  chromeos::ErrorPtr error;
1641  bool success = debugd_proxy_->QueryDevFeatures(&dev_features, &error);
1642
1643  // Some boards may not include debugd so it's expected that this may fail,
1644  // in which case we default to disallowing custom update sources.
1645  if (success && !(dev_features & debugd::DEV_FEATURES_DISABLED)) {
1646    LOG(INFO) << "Debugd dev tools enabled; allowing any update source.";
1647    return true;
1648  }
1649  LOG(INFO) << "Debugd dev tools disabled; disallowing custom update sources.";
1650  return false;
1651}
1652
1653}  // namespace chromeos_update_engine
1654