Add support for bsdiff of file system metadata blocks

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 12 matching lines @@
 
 #include "update_engine/bzip.h"
 #include "update_engine/cycle_breaker.h"
 #include "update_engine/extent_mapper.h"
 #include "update_engine/extent_ranges.h"
 #include "update_engine/file_writer.h"
 #include "update_engine/filesystem_iterator.h"
 #include "update_engine/full_update_generator.h"
 #include "update_engine/graph_types.h"
 #include "update_engine/graph_utils.h"
+#include "update_engine/metadata.h"
 #include "update_engine/omaha_hash_calculator.h"
 #include "update_engine/payload_signer.h"
 #include "update_engine/subprocess.h"
 #include "update_engine/topological_sort.h"
 #include "update_engine/update_metadata.pb.h"
 #include "update_engine/utils.h"
 
 using std::make_pair;
 using std::map;
 using std::max;
 using std::min;
 using std::pair;
 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
-
-// TODO(adlr): switch from 1GiB to 2GiB when we no longer care about old
-// clients:
-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",
-  "MOVE",
-  "BSDIFF"
-};
-
-// Stores all Extents for a file into 'out'. Returns true on success.
-bool GatherExtents(const string& path,
-                   google::protobuf::RepeatedPtrField<Extent>* out) {
-  vector<Extent> extents;
-  TEST_AND_RETURN_FALSE(extent_mapper::ExtentsForFileFibmap(path, &extents));
-  DeltaDiffGenerator::StoreExtents(extents, out);
-  return true;
-}
-
 // Runs the bsdiff tool on two files and returns the resulting delta in
 // 'out'. Returns true on success.
 bool BsdiffFiles(const string& old_file,
                  const string& new_file,
                  vector<char>* out) {
   const string kPatchFile = "/tmp/delta.patchXXXXXX";
   string patch_file_path;
 
   TEST_AND_RETURN_FALSE(
       utils::MakeTempFile(kPatchFile, &patch_file_path, NULL));
@@ skipping 55 matching lines @@
                      << ") and also " << vertex << "("
                      << graph[vertex].file_name << ")";
         }
         (*blocks)[block].*access_type = vertex;
       }
     }
   }
   return true;
 }
 
+namespace {
+const size_t kBlockSize = 4096;  // bytes
+
+// TODO(adlr): switch from 1GiB to 2GiB when we no longer care about old
+// clients:
+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",
+  "MOVE",
+  "BSDIFF"
+};
+
+// Stores all Extents for a file into 'out'. Returns true on success.
+bool GatherExtents(const string& path,
+                   google::protobuf::RepeatedPtrField<Extent>* out) {
+  vector<Extent> extents;
+  TEST_AND_RETURN_FALSE(extent_mapper::ExtentsForFileFibmap(path, &extents));
+  DeltaDiffGenerator::StoreExtents(extents, out);
+  return true;
+}
+
 // For a given regular file which must exist at new_root + path, and
 // may exist at old_root + path, creates a new InstallOperation and
 // adds it to the graph. Also, populates the |blocks| array as
 // necessary, if |blocks| is non-NULL.  Also, writes the data
 // necessary to send the file down to the client into data_fd, which
 // has length *data_file_size. *data_file_size is updated
 // appropriately. If |existing_vertex| is no kInvalidIndex, use that
 // rather than allocating a new vertex. Returns true on success.
 bool DeltaReadFile(Graph* graph,
                    Vertex::Index existing_vertex,
@@ skipping 1218 matching lines @@
 
       TEST_AND_RETURN_FALSE(DeltaReadFiles(&graph,
                                            &blocks,
                                            old_root,
                                            new_root,
                                            fd,
                                            &data_file_size));
       LOG(INFO) << "done reading normal files";
       CheckGraph(graph);
 
+      LOG(INFO) << "Starting metadata processing";
+      TEST_AND_RETURN_FALSE(DeltaReadMetadata(&graph,
+                                              &blocks,
+                                              old_image,
+                                              new_image,
+                                              fd,
+                                              &data_file_size));
+      LOG(INFO) << "Done metadata processing";
+      CheckGraph(graph);
+
       graph.resize(graph.size() + 1);
       TEST_AND_RETURN_FALSE(ReadUnwrittenBlocks(blocks,
                                                 fd,
                                                 &data_file_size,
                                                 new_image,
                                                 &graph.back()));
 
       // Final scratch block (if there's space)
       if (blocks.size() < (kRootFSPartitionSize / kBlockSize)) {
         scratch_vertex = graph.size();
@@ skipping 180 matching lines @@
 
   LOG(INFO) << "All done. Successfully created delta file.";
   return true;
 }
 
 const char* const kBsdiffPath = "bsdiff";
 const char* const kBspatchPath = "bspatch";
 const char* const kDeltaMagic = "CrAU";
 
 };  // namespace chromeos_update_engine