AU: Start checkpointing update progress.

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>
 #include <cstring>
 #include <string>
 #include <vector>
 
 #include <base/scoped_ptr.h>
 #include <base/string_util.h>
 #include <google/protobuf/repeated_field.h>
 
 #include "update_engine/bzip_extent_writer.h"
 #include "update_engine/delta_diff_generator.h"
 #include "update_engine/extent_writer.h"
 #include "update_engine/graph_types.h"
 #include "update_engine/payload_signer.h"
+#include "update_engine/prefs_interface.h"
 #include "update_engine/subprocess.h"
 
 using std::min;
 using std::string;
 using std::vector;
 using google::protobuf::RepeatedPtrField;
 
 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;
+
+// Returns true if |op| is idempotent -- i.e., if we can interrupt it and repeat
+// it safely. Returns false otherwise.
+bool IsIdempotentOperation(const DeltaArchiveManifest_InstallOperation& op) {
+  if (op.src_extents_size() == 0) {
+    return true;
+  }
+  // TODO(petkov): Cover the case where the source and target extents don't
+  // intersect.
+  return false;
+}
 
 // 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 121 matching lines @@
     }
     // We have the full proto buffer in buffer_. Parse it.
     const int offset = strlen(kDeltaMagic) + kDeltaVersionLength +
         kDeltaProtobufLengthLength;
     if (!manifest_.ParseFromArray(&buffer_[offset], protobuf_length)) {
       LOG(ERROR) << "Unable to parse manifest in update file.";
       return -EINVAL;
     }
     // Remove protobuf and header info from buffer_, so buffer_ contains
     // just data blobs
-    DiscardBufferHeadBytes(strlen(kDeltaMagic) +
-                           kDeltaVersionLength +
-                           kDeltaProtobufLengthLength + protobuf_length,
+    size_t metadata_size = strlen(kDeltaMagic) + kDeltaVersionLength +
+        kDeltaProtobufLengthLength + protobuf_length;
+    DiscardBufferHeadBytes(metadata_size,
                            true);  // do_hash
+    LOG_IF(WARNING, !prefs_->SetInt64(kPrefsManifestMetadataSize,
+                                      metadata_size))
+        << "Unable to save the manifest metadata size.";
     manifest_valid_ = true;
     block_size_ = manifest_.block_size();
   }
   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;
     // 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)) {
+      ResetUpdateProgress();
+    }
     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)) {
         LOG(ERROR) << "Failed to perform move operation "
                    << next_operation_num_;
         return -EINVAL;
       }
     } else if (op.type() == DeltaArchiveManifest_InstallOperation_Type_BSDIFF) {
       if (!PerformBsdiffOperation(op, is_kernel_partition)) {
         LOG(ERROR) << "Failed to perform bsdiff operation "
                    << next_operation_num_;
         return -EINVAL;
       }
     }
     next_operation_num_++;
+    CheckpointUpdateProgress();
   }
   return count;
 }
 
 bool DeltaPerformer::CanPerformInstallOperation(
     const chromeos_update_engine::DeltaArchiveManifest_InstallOperation&
     operation) {
   // Move operations don't require any data blob, so they can always
   // be performed
   if (operation.type() == DeltaArchiveManifest_InstallOperation_Type_MOVE)
@@ skipping 246 matching lines @@
   return hash_data == signed_hash_data;
 }
 
 void DeltaPerformer::DiscardBufferHeadBytes(size_t count, bool do_hash) {
   if (do_hash) {
     hash_calculator_.Update(&buffer_[0], count);
   }
   buffer_.erase(buffer_.begin(), buffer_.begin() + count);
 }
 
+bool DeltaPerformer::ResetUpdateProgress() {
+  TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextOperation,
+                                         kUpdateStateOperationInvalid));
+  return true;
+}
+
+bool DeltaPerformer::CheckpointUpdateProgress() {
+  // First reset the progress in case we die in the middle of the state update.
+  ResetUpdateProgress();
+  TEST_AND_RETURN_FALSE(prefs_->SetString(kPrefsUpdateStateSignedSHA256Context,
+                                          hash_calculator_.GetContext()));
+  TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextDataOffset,
+                                         buffer_offset_));
+  TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextOperation,
+                                         next_operation_num_));
+  return true;
+}
+
 }  // namespace chromeos_update_engine