AU: Fall back to a new update after a certain number of failed resume attempts.

delta_performer.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "update_engine/delta_performer.h"
 
 #include <endian.h>
 #include <errno.h>
 
 #include <algorithm>
@@ skipping 22 matching lines @@
 
 namespace chromeos_update_engine {
 
 namespace {
 
 const int kDeltaVersionLength = 8;
 const int kDeltaProtobufLengthLength = 8;
 const char kUpdatePayloadPublicKeyPath[] =
     "/usr/share/update_engine/update-payload-key.pub.pem";
 const int kUpdateStateOperationInvalid = -1;
+const int kMaxResumedUpdateFailures = 10;
 
 // Converts extents to a human-readable string, for use by DumpUpdateProto().
 string ExtentsToString(const RepeatedPtrField<Extent>& extents) {
   string ret;
   for (int i = 0; i < extents.size(); i++) {
     const Extent& extent = extents.Get(i);
     if (extent.start_block() == kSparseHole) {
       ret += StringPrintf("{kSparseHole, %" PRIu64 "}, ", extent.num_blocks());
     } else {
       ret += StringPrintf("{%" PRIu64 ", %" PRIu64 "}, ",
@@ skipping 503 matching lines @@
                                         &next_operation) &&
                         next_operation != kUpdateStateOperationInvalid &&
                         next_operation > 0);
 
   string interrupted_hash;
   TEST_AND_RETURN_FALSE(prefs->GetString(kPrefsUpdateCheckResponseHash,
                                          &interrupted_hash) &&
                         !interrupted_hash.empty() &&
                         interrupted_hash == update_check_response_hash);
 
+  int64_t resumed_update_failures;
+  TEST_AND_RETURN_FALSE(!prefs->GetInt64(kPrefsResumedUpdateFailures,
+                                         &resumed_update_failures) ||
+                        resumed_update_failures <= kMaxResumedUpdateFailures);
+
   // Sanity check the rest.
   int64_t next_data_offset = -1;
   TEST_AND_RETURN_FALSE(prefs->GetInt64(kPrefsUpdateStateNextDataOffset,
                                         &next_data_offset) &&
                         next_data_offset >= 0);
 
   string sha256_context;
   TEST_AND_RETURN_FALSE(
       prefs->GetString(kPrefsUpdateStateSHA256Context, &sha256_context) &&
       !sha256_context.empty());
 
   int64_t manifest_metadata_size = 0;
   TEST_AND_RETURN_FALSE(prefs->GetInt64(kPrefsManifestMetadataSize,
                                         &manifest_metadata_size) &&
                         manifest_metadata_size > 0);
 
   return true;
 }
 
 bool DeltaPerformer::ResetUpdateProgress(PrefsInterface* prefs, bool quick) {
   TEST_AND_RETURN_FALSE(prefs->SetInt64(kPrefsUpdateStateNextOperation,
                                         kUpdateStateOperationInvalid));
   if (!quick) {
     prefs->SetString(kPrefsUpdateCheckResponseHash, "");
     prefs->SetInt64(kPrefsUpdateStateNextDataOffset, -1);
     prefs->SetString(kPrefsUpdateStateSHA256Context, "");
     prefs->SetString(kPrefsUpdateStateSignedSHA256Context, "");
     prefs->SetInt64(kPrefsManifestMetadataSize, -1);
+    prefs->SetInt64(kPrefsResumedUpdateFailures, 0);
   }
   return true;
 }
 
 bool DeltaPerformer::CheckpointUpdateProgress() {
   Terminator::set_exit_blocked(true);
   if (last_updated_buffer_offset_ != buffer_offset_) {
     // Resets the progress in case we die in the middle of the state update.
     ResetUpdateProgress(prefs_, true);
     TEST_AND_RETURN_FALSE(
@@ skipping 37 matching lines @@
   TEST_AND_RETURN_FALSE(prefs_->GetString(kPrefsUpdateStateSHA256Context,
                                           &hash_context) &&
                         hash_calculator_.SetContext(hash_context));
 
   int64_t manifest_metadata_size = 0;
   TEST_AND_RETURN_FALSE(prefs_->GetInt64(kPrefsManifestMetadataSize,
                                          &manifest_metadata_size) &&
                         manifest_metadata_size > 0);
   manifest_metadata_size_ = manifest_metadata_size;
 
+  // Speculatively count the resume as a failure.
+  int64_t resumed_update_failures;
+  if (prefs_->GetInt64(kPrefsResumedUpdateFailures, &resumed_update_failures)) {
+    resumed_update_failures++;
+  } else {
+    resumed_update_failures = 1;
+  }
+  prefs_->SetInt64(kPrefsResumedUpdateFailures, resumed_update_failures);
   return true;
 }
 
 }  // namespace chromeos_update_engine