AU: Resume interrupted update 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 180 matching lines @@
     }
     // Remove protobuf and header info from buffer_, so buffer_ contains
     // just data blobs
     manifest_metadata_size_ = strlen(kDeltaMagic) + kDeltaVersionLength +
         kDeltaProtobufLengthLength + protobuf_length;
     DiscardBufferHeadBytes(manifest_metadata_size_);
     LOG_IF(WARNING, !prefs_->SetInt64(kPrefsManifestMetadataSize,
                                       manifest_metadata_size_))
         << "Unable to save the manifest metadata size.";
     manifest_valid_ = true;
-    block_size_ = manifest_.block_size();
+    if (!PrimeUpdateState()) {
+      LOG(ERROR) << "Unable to prime the update state.";
+      return -EINVAL;
+    }
   }
   ssize_t total_operations = manifest_.install_operations_size() +
       manifest_.kernel_install_operations_size();
   while (next_operation_num_ < total_operations) {
     const DeltaArchiveManifest_InstallOperation &op =
         next_operation_num_ < manifest_.install_operations_size() ?
         manifest_.install_operations(next_operation_num_) :
         manifest_.kernel_install_operations(
             next_operation_num_ - manifest_.install_operations_size());
     if (!CanPerformInstallOperation(op))
       break;
     ScopedTerminatorExitUnblocker exit_unblocker =
         ScopedTerminatorExitUnblocker();  // Avoids a compiler unused var bug.
     // Log every thousandth operation, and also the first and last ones
     if ((next_operation_num_ % 1000 == 0) ||
         (next_operation_num_ + 1 == total_operations)) {
       LOG(INFO) << "Performing operation " << (next_operation_num_ + 1) << "/"
                 << total_operations;
     }
     bool is_kernel_partition =
         (next_operation_num_ >= manifest_.install_operations_size());
     // If about to start a non-idempotent operation, clear the update state so
     // that if the operation gets interrupted, we don't try to resume the
     // update.
     if (!IsIdempotentOperation(op)) {
       Terminator::set_exit_blocked(true);
-      ResetUpdateProgress(prefs_);
+      ResetUpdateProgress(prefs_, true);
     }
     if (op.type() == DeltaArchiveManifest_InstallOperation_Type_REPLACE ||
         op.type() == DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ) {
       if (!PerformReplaceOperation(op, is_kernel_partition)) {
         LOG(ERROR) << "Failed to perform replace operation "
                    << next_operation_num_;
         return -EINVAL;
       }
     } else if (op.type() == DeltaArchiveManifest_InstallOperation_Type_MOVE) {
       if (!PerformMoveOperation(op, is_kernel_partition)) {
@@ skipping 35 matching lines @@
 bool DeltaPerformer::PerformReplaceOperation(
     const DeltaArchiveManifest_InstallOperation& operation,
     bool is_kernel_partition) {
   CHECK(operation.type() == \
         DeltaArchiveManifest_InstallOperation_Type_REPLACE || \
         operation.type() == \
         DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ);
 
   // Since we delete data off the beginning of the buffer as we use it,
   // the data we need should be exactly at the beginning of the buffer.
-  CHECK_EQ(buffer_offset_, operation.data_offset());
-  CHECK_GE(buffer_.size(), operation.data_length());
+  TEST_AND_RETURN_FALSE(buffer_offset_ == operation.data_offset());
+  TEST_AND_RETURN_FALSE(buffer_.size() >= operation.data_length());
 
   // Extract the signature message if it's in this operation.
   ExtractSignatureMessage(operation);
 
   DirectExtentWriter direct_writer;
   ZeroPadExtentWriter zero_pad_writer(&direct_writer);
   scoped_ptr<BzipExtentWriter> bzip_writer;
 
   // Since bzip decompression is optional, we have a variable writer that will
   // point to one of the ExtentWriter objects above.
@@ skipping 102 matching lines @@
     ret.resize(ret.size() - 1);  // Strip trailing comma off
   *positions_string = ret;
   return true;
 }
 
 bool DeltaPerformer::PerformBsdiffOperation(
     const DeltaArchiveManifest_InstallOperation& operation,
     bool is_kernel_partition) {
   // Since we delete data off the beginning of the buffer as we use it,
   // the data we need should be exactly at the beginning of the buffer.
-  CHECK_EQ(buffer_offset_, operation.data_offset());
-  CHECK_GE(buffer_.size(), operation.data_length());
+  TEST_AND_RETURN_FALSE(buffer_offset_ == operation.data_offset());
+  TEST_AND_RETURN_FALSE(buffer_.size() >= operation.data_length());
 
   string input_positions;
   TEST_AND_RETURN_FALSE(ExtentsToBsdiffPositionsString(operation.src_extents(),
                                                        block_size_,
                                                        operation.src_length(),
                                                        &input_positions));
   string output_positions;
   TEST_AND_RETURN_FALSE(ExtentsToBsdiffPositionsString(operation.dst_extents(),
                                                        block_size_,
                                                        operation.dst_length(),
@@ skipping 144 matching lines @@
       !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 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);
+  }
   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_);
+    ResetUpdateProgress(prefs_, true);
     TEST_AND_RETURN_FALSE(
         prefs_->SetString(kPrefsUpdateStateSHA256Context,
                           hash_calculator_.GetContext()));
     TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextDataOffset,
                                            buffer_offset_));
     last_updated_buffer_offset_ = buffer_offset_;
   }
   TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextOperation,
                                          next_operation_num_));
   return true;
 }
 
+bool DeltaPerformer::PrimeUpdateState() {
+  CHECK(manifest_valid_);
+  block_size_ = manifest_.block_size();
+
+  int64_t next_operation = kUpdateStateOperationInvalid;
+  if (!prefs_->GetInt64(kPrefsUpdateStateNextOperation, &next_operation) ||
+      next_operation == kUpdateStateOperationInvalid ||
+      next_operation <= 0) {
+    // Initiating a new update, no more state needs to be initialized.
+    return true;
+  }
+  next_operation_num_ = next_operation;
+
+  // Resuming an update -- load the rest of the update state.
+  int64_t next_data_offset = -1;
+  TEST_AND_RETURN_FALSE(prefs_->GetInt64(kPrefsUpdateStateNextDataOffset,
+                                         &next_data_offset) &&
+                        next_data_offset >= 0);
+  buffer_offset_ = next_data_offset;
+
+  // The signed hash context may be empty if the interrupted update didn't reach
+  // the signature blob.
+  prefs_->GetString(kPrefsUpdateStateSignedSHA256Context,
+                    &signed_hash_context_);
+
+  string hash_context;
+  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;
+
+  return true;
+}
+
 }  // namespace chromeos_update_engine