AU: Don't send no-op operations in the delta payload.

delta_diff_generator.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_diff_generator.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <sys/stat.h>
@@ skipping 29 matching lines @@
 using std::map;
 using std::max;
 using std::min;
 using std::set;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 typedef DeltaDiffGenerator::Block Block;
+typedef map<const DeltaArchiveManifest_InstallOperation*,
+            const string*> OperationNameMap;
 
 namespace {
 const size_t kBlockSize = 4096;  // bytes
 const size_t kRootFSPartitionSize = 1 * 1024 * 1024 * 1024;  // bytes
 const uint64_t kVersionNumber = 1;
 const uint64_t kFullUpdateChunkSize = 1024 * 1024;  // bytes
 
 static const char* kInstallOperationTypes[] = {
   "REPLACE",
   "REPLACE_BZ",
@@ skipping 309 matching lines @@
 
 // Writes the uint64_t passed in in host-endian to the file as big-endian.
 // Returns true on success.
 bool WriteUint64AsBigEndian(FileWriter* writer, const uint64_t value) {
   uint64_t value_be = htobe64(value);
   TEST_AND_RETURN_FALSE(writer->Write(&value_be, sizeof(value_be)) ==
                         sizeof(value_be));
   return true;
 }
 
-// Adds each operation from the graph to the manifest in the order
-// specified by 'order'.
+// Adds each operation from |graph| to |out_manifest| in the order specified by
+// |order| while building |out_op_name_map| with operation to name
+// mappings. Adds all |kernel_ops| to |out_manifest|. Filters out no-op
+// operations.
 void InstallOperationsToManifest(
     const Graph& graph,
     const vector<Vertex::Index>& order,
     const vector<DeltaArchiveManifest_InstallOperation>& kernel_ops,
-    DeltaArchiveManifest* out_manifest) {
+    DeltaArchiveManifest* out_manifest,
+    OperationNameMap* out_op_name_map) {
   for (vector<Vertex::Index>::const_iterator it = order.begin();
        it != order.end(); ++it) {
+    const Vertex& vertex = graph[*it];
+    const DeltaArchiveManifest_InstallOperation& add_op = vertex.op;
+    if (DeltaDiffGenerator::IsNoopOperation(add_op)) {
+      continue;
+    }
     DeltaArchiveManifest_InstallOperation* op =
         out_manifest->add_install_operations();
-    *op = graph[*it].op;
+    *op = add_op;
+    (*out_op_name_map)[op] = &vertex.file_name;
   }
   for (vector<DeltaArchiveManifest_InstallOperation>::const_iterator it =
            kernel_ops.begin(); it != kernel_ops.end(); ++it) {
+    const DeltaArchiveManifest_InstallOperation& add_op = *it;
+    if (DeltaDiffGenerator::IsNoopOperation(add_op)) {
+      continue;
+    }
     DeltaArchiveManifest_InstallOperation* op =
         out_manifest->add_kernel_install_operations();
-    *op = *it;
+    *op = add_op;
   }
 }
 
 void CheckGraph(const Graph& graph) {
   for (Graph::const_iterator it = graph.begin(); it != graph.end(); ++it) {
     CHECK(it->op.has_type());
   }
 }
 
 // Delta compresses a kernel partition |new_kernel_part| with knowledge of the
@@ skipping 39 matching lines @@
         type(in_type),
         size(in_size) {}
   bool operator <(const DeltaObject& object) const {
     return (size != object.size) ? (size < object.size) : (name < object.name);
   }
   string name;
   int type;
   off_t size;
 };
 
-void ReportPayloadUsage(const Graph& graph,
-                        const DeltaArchiveManifest& manifest,
-                        const int64_t manifest_metadata_size) {
+void ReportPayloadUsage(const DeltaArchiveManifest& manifest,
+                        const int64_t manifest_metadata_size,
+                        const OperationNameMap& op_name_map) {
   vector<DeltaObject> objects;
   off_t total_size = 0;
 
-  // Graph nodes with information about file names.
-  for (Vertex::Index node = 0; node < graph.size(); node++) {
-    const Vertex& vertex = graph[node];
-    if (!vertex.valid) {
-      continue;
-    }
-    objects.push_back(DeltaObject(vertex.file_name,
-                                  vertex.op.type(),
-                                  vertex.op.data_length()));
-    total_size += vertex.op.data_length();
+  // Rootfs install operations.
+  for (int i = 0; i < manifest.install_operations_size(); ++i) {
+    const DeltaArchiveManifest_InstallOperation& op =
+        manifest.install_operations(i);
+    objects.push_back(DeltaObject(*op_name_map.find(&op)->second,
+                                  op.type(),
+                                  op.data_length()));
+    total_size += op.data_length();
   }
 
   // Kernel install operations.
   for (int i = 0; i < manifest.kernel_install_operations_size(); ++i) {
     const DeltaArchiveManifest_InstallOperation& op =
         manifest.kernel_install_operations(i);
     objects.push_back(DeltaObject(StringPrintf("<kernel-operation-%d>", i),
                                   op.type(),
                                   op.data_length()));
     total_size += op.data_length();
@@ skipping 423 matching lines @@
       return true;
     }
     // check for wrap-around, which would be a bug:
     CHECK(start <= (start + num));
   }
   return false;
 }
 
 }  // namespace {}
 
+// Returns true if |op| is a no-op operation that doesn't do any useful work
+// (e.g., a move operation that copies blocks onto themselves).
+bool DeltaDiffGenerator::IsNoopOperation(
+    const DeltaArchiveManifest_InstallOperation& op) {
+  return (op.type() == DeltaArchiveManifest_InstallOperation_Type_MOVE &&
+          ExpandExtents(op.src_extents()) == ExpandExtents(op.dst_extents()));
+}
+
 bool DeltaDiffGenerator::AssignTempBlocks(
     Graph* graph,
     const string& new_root,
     int data_fd,
     off_t* data_file_size,
     vector<Vertex::Index>* op_indexes,
     vector<vector<Vertex::Index>::size_type>* reverse_op_indexes,
     vector<CutEdgeVertexes>& cuts) {
   CHECK(!cuts.empty());
   for (vector<CutEdgeVertexes>::size_type i = cuts.size() - 1, e = 0;
@@ skipping 438 matching lines @@
                                                    fd,
                                                    &data_file_size,
                                                    kFullUpdateChunkSize,
                                                    &kernel_ops,
                                                    &final_order));
     }
   }
 
   // Convert to protobuf Manifest object
   DeltaArchiveManifest manifest;
+  OperationNameMap op_name_map;
   CheckGraph(graph);
-  InstallOperationsToManifest(graph, final_order, kernel_ops, &manifest);
-
+  InstallOperationsToManifest(graph,
+                              final_order,
+                              kernel_ops,
+                              &manifest,
+                              &op_name_map);
   CheckGraph(graph);
   manifest.set_block_size(kBlockSize);
 
   // Reorder the data blobs with the newly ordered manifest
   string ordered_blobs_path;
   TEST_AND_RETURN_FALSE(utils::MakeTempFile(
       "/tmp/CrAU_temp_data.ordered.XXXXXX",
       &ordered_blobs_path,
       false));
   TEST_AND_RETURN_FALSE(ReorderDataBlobs(&manifest,
                                          temp_file_path,
                                          ordered_blobs_path));
 
-  // Check that install op blobs are in order and that all blocks are written.
+  // Check that install op blobs are in order.
   uint64_t next_blob_offset = 0;
   {
-    vector<uint32_t> written_count(blocks.size(), 0);
     for (int i = 0; i < (manifest.install_operations_size() +
                          manifest.kernel_install_operations_size()); i++) {
       DeltaArchiveManifest_InstallOperation* op =
           i < manifest.install_operations_size() ?
           manifest.mutable_install_operations(i) :
           manifest.mutable_kernel_install_operations(
               i - manifest.install_operations_size());
-      for (int j = 0; j < op->dst_extents_size(); j++) {
-        const Extent& extent = op->dst_extents(j);
-        for (uint64_t block = extent.start_block();
-             block < (extent.start_block() + extent.num_blocks()); block++) {
-          if (block < blocks.size())
-            written_count[block]++;
-        }
-      }
       if (op->has_data_offset()) {
         if (op->data_offset() != next_blob_offset) {
           LOG(FATAL) << "bad blob offset! " << op->data_offset() << " != "
                      << next_blob_offset;
         }
         next_blob_offset += op->data_length();
       }
     }
-    // check all blocks written to
-    for (vector<uint32_t>::size_type i = 0; i < written_count.size(); i++) {
-      if (written_count[i] == 0) {
-        LOG(FATAL) << "block " << i << " not written!";
-      }
-    }
   }
 
   // Signatures appear at the end of the blobs. Note the offset in the
   // manifest
   if (!private_key_path.empty()) {
     LOG(INFO) << "Making room for signature in file";
     manifest.set_signatures_offset(next_blob_offset);
     LOG(INFO) << "set? " << manifest.has_signatures_offset();
     // Add a dummy op at the end to appease older clients
     DeltaArchiveManifest_InstallOperation* dummy_op =
@@ skipping 75 matching lines @@
     TEST_AND_RETURN_FALSE(PayloadSigner::SignPayload(output_path,
                                                      private_key_path,
                                                      &signature_blob));
     TEST_AND_RETURN_FALSE(writer.Write(&signature_blob[0],
                                        signature_blob.size()) ==
                           static_cast<ssize_t>(signature_blob.size()));
   }
 
   int64_t manifest_metadata_size =
       strlen(kDeltaMagic) + 2 * sizeof(uint64_t) + serialized_manifest.size();
-  ReportPayloadUsage(graph, manifest, manifest_metadata_size);
+  ReportPayloadUsage(manifest, manifest_metadata_size, op_name_map);
 
   LOG(INFO) << "All done. Successfully created delta file.";
   return true;
 }
 
 const char* const kBsdiffPath = "/usr/bin/bsdiff";
 const char* const kBspatchPath = "/usr/bin/bspatch";
 const char* const kDeltaMagic = "CrAU";
 
 };  // namespace chromeos_update_engine