AU: Delta Performer: properly detect idempotent operations

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_ranges.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"
 #include "update_engine/terminator.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 "}, ",
                           extent.start_block(), extent.num_blocks());
@@ skipping 50 matching lines @@
     *err = errno;
     PLOG(ERROR) << "Unable to open file " << path;
     return false;
   }
   *err = 0;
   return true;
 }
 
 }  // namespace {}
 
+// Returns true if |op| is idempotent -- i.e., if we can interrupt it and repeat
+// it safely. Returns false otherwise.
+bool DeltaPerformer::IsIdempotentOperation(
+    const DeltaArchiveManifest_InstallOperation& op) {
+  if (op.src_extents_size() == 0) {
+    return true;
+  }
+  // TODO(adlr): detect other types of idempotent operations. For example,
+  // a MOVE may move a block onto itself.
+
+  // When in doubt, it's safe to declare an op non-idempotent.
+  ExtentRanges src_ranges;
+  src_ranges.AddRepeatedExtents(op.src_extents());
+  const uint64_t block_count = src_ranges.blocks();
+  src_ranges.SubtractRepeatedExtents(op.dst_extents());
+  return block_count == src_ranges.blocks();
+}
+
 int DeltaPerformer::Open(const char* path, int flags, mode_t mode) {
   int err;
   if (OpenFile(path, &fd_, &err))
     path_ = path;
   return -err;
 }
 
 bool DeltaPerformer::OpenKernel(const char* kernel_path) {
   int err;
   bool success = OpenFile(kernel_path, &kernel_fd_, &err);
@@ skipping 454 matching lines @@
     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;
 }
 
 }  // namespace chromeos_update_engine