AU: Class to perform delta updates.

src/platform/update_engine/delta_diff_generator.cc

 // Copyright (c) 2009 The Chromium 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 <sys/stat.h>
 #include <sys/types.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <algorithm>
@@ skipping 20 matching lines @@
 using std::set;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 typedef DeltaDiffGenerator::Block Block;
 
 namespace {
 const size_t kBlockSize = 4096;
-const char* const kBsdiffPath = "/usr/bin/bsdiff";
-const uint64 kVersionNumber = 1;
-const char* const kDeltaMagic = "CrAU";
+const uint64_t kVersionNumber = 1;
 
 // 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;
 }
 
@@ skipping 317 matching lines @@
   out_op->set_dst_length(kBlockSize * block_count);
   DeltaDiffGenerator::StoreExtents(extents, out_op->mutable_dst_extents());
   
   TEST_AND_RETURN_FALSE(utils::WriteAll(blobs_fd,
                                         &compressed_data[0],
                                         compressed_data.size()));
   LOG(INFO) << "done with extra blocks";
   return true;
 }
 
-// Writes the uint64 passed in in host-endian to the file as big-endian.
+// 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 value) {
-  uint64 value_be = htobe64(value);
+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'.
 void InstallOperationsToManifest(
     const Graph& graph,
     const vector<Vertex::Index>& order,
@@ skipping 90 matching lines @@
   *out_op = operation;
   
   return true;
 }
 
 void DeltaDiffGenerator::SubstituteBlocks(
     DeltaArchiveManifest_InstallOperation* op,
     const vector<Extent>& remove_extents,
     const vector<Extent>& replace_extents) {
   // First, expand out the blocks that op reads from
-  vector<uint64> read_blocks;
+  vector<uint64_t> read_blocks;
   for (int i = 0; i < op->src_extents_size(); i++) {
     const Extent& extent = op->src_extents(i);
     if (extent.start_block() == kSparseHole) {
       read_blocks.resize(read_blocks.size() + extent.num_blocks(), kSparseHole);
     } else {
-      for (uint64 block = extent.start_block();
+      for (uint64_t block = extent.start_block();
            block < (extent.start_block() + extent.num_blocks()); block++) {
         read_blocks.push_back(block);
       }
     }
   }
   {
     // Expand remove_extents and replace_extents
-    vector<uint64> remove_extents_expanded;
+    vector<uint64_t> remove_extents_expanded;
     for (vector<Extent>::const_iterator it = remove_extents.begin();
          it != remove_extents.end(); ++it) {
       const Extent& extent = *it;
-      for (uint64 block = extent.start_block();
+      for (uint64_t block = extent.start_block();
            block < (extent.start_block() + extent.num_blocks()); block++) {
         remove_extents_expanded.push_back(block);
       }
     }
-    vector<uint64> replace_extents_expanded;
+    vector<uint64_t> replace_extents_expanded;
     for (vector<Extent>::const_iterator it = replace_extents.begin();
          it != replace_extents.end(); ++it) {
       const Extent& extent = *it;
-      for (uint64 block = extent.start_block();
+      for (uint64_t block = extent.start_block();
            block < (extent.start_block() + extent.num_blocks()); block++) {
         replace_extents_expanded.push_back(block);
       }
     }
     CHECK_EQ(remove_extents_expanded.size(), replace_extents_expanded.size());
-    for (vector<uint64>::size_type i = 0;
+    for (vector<uint64_t>::size_type i = 0;
          i < replace_extents_expanded.size(); i++) {
-      vector<uint64>::size_type index = 0;
+      vector<uint64_t>::size_type index = 0;
       CHECK(utils::VectorIndexOf(read_blocks,
                                  remove_extents_expanded[i],
                                  &index));
       CHECK(read_blocks[index] == remove_extents_expanded[i]);
       read_blocks[index] = replace_extents_expanded[i];
     }
   }
   // Convert read_blocks back to extents
   op->clear_src_extents();
   vector<Extent> new_extents;
-  for (vector<uint64>::const_iterator it = read_blocks.begin();
+  for (vector<uint64_t>::const_iterator it = read_blocks.begin();
        it != read_blocks.end(); ++it) {
     graph_utils::AppendBlockToExtents(&new_extents, *it);
   }
   DeltaDiffGenerator::StoreExtents(new_extents, op->mutable_src_extents());
 }
 
 bool DeltaDiffGenerator::CutEdges(Graph* graph,
                                   const vector<Block>& blocks,
                                   const set<Edge>& edges) {
   // First, find enough scratch space for the edges we'll be cutting.
@@ skipping 94 matching lines @@
   int in_fd = open(data_blobs_path.c_str(), O_RDONLY, 0);
   TEST_AND_RETURN_FALSE_ERRNO(in_fd >= 0);
   ScopedFdCloser in_fd_closer(&in_fd);
   
   DirectFileWriter writer;
   TEST_AND_RETURN_FALSE(
       writer.Open(new_data_blobs_path.c_str(),
                   O_WRONLY | O_TRUNC | O_CREAT,
                   0644) == 0);
   ScopedFileWriterCloser writer_closer(&writer);
-  uint64 out_file_size = 0;
+  uint64_t out_file_size = 0;
   
   for (int i = 0; i < manifest->install_operations_size(); i++) {
     DeltaArchiveManifest_InstallOperation* op =
         manifest->mutable_install_operations(i);
     if (!op->has_data_offset())
       continue;
     CHECK(op->has_data_length());
     vector<char> buf(op->data_length());
     ssize_t rc = pread(in_fd, &buf[0], buf.size(), op->data_offset());
     TEST_AND_RETURN_FALSE(rc == static_cast<ssize_t>(buf.size()));
@@ skipping 17 matching lines @@
   TEST_AND_RETURN_FALSE_ERRNO(stat(new_image.c_str(), &new_image_stbuf) == 0);
   LOG_IF(WARNING, new_image_stbuf.st_size != old_image_stbuf.st_size)
       << "Old and new images are different sizes.";
   LOG_IF(FATAL, new_image_stbuf.st_size % kBlockSize)
       << "New image not a multiple of block size " << kBlockSize;
   LOG_IF(FATAL, old_image_stbuf.st_size % kBlockSize)
       << "Old image not a multiple of block size " << kBlockSize;
 
   vector<Block> blocks(min(old_image_stbuf.st_size / kBlockSize,
                            new_image_stbuf.st_size / kBlockSize));
-  LOG(INFO) << "w:" << blocks[4097].writer;
   LOG(INFO) << "invalid: " << Vertex::kInvalidIndex;
   LOG(INFO) << "len: " << blocks.size();
   for (vector<Block>::size_type i = 0; i < blocks.size(); i++) {
     CHECK(blocks[i].reader == Vertex::kInvalidIndex);
     CHECK(blocks[i].writer == Vertex::kInvalidIndex);
   }
   Graph graph;
   CheckGraph(graph);
   
   const string kTempFileTemplate("/tmp/CrAU_temp_data.XXXXXX");
@@ skipping 69 matching lines @@
   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.
   {
-    vector<uint32> written_count(blocks.size(), 0);
-    uint64 next_blob_offset = 0;
+    vector<uint32_t> written_count(blocks.size(), 0);
+    uint64_t next_blob_offset = 0;
     for (int i = 0; i < manifest.install_operations_size(); i++) {
       const DeltaArchiveManifest_InstallOperation& op =
           manifest.install_operations(i);
       for (int j = 0; j < op.dst_extents_size(); j++) {
         const Extent& extent = op.dst_extents(j);
-        for (uint64 block = extent.start_block();
+        for (uint64_t block = extent.start_block();
              block < (extent.start_block() + extent.num_blocks()); block++) {
           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>::size_type i = 0; i < written_count.size(); i++) {
+    for (vector<uint32_t>::size_type i = 0; i < written_count.size(); i++) {
       if (written_count[i] == 0) {
         LOG(FATAL) << "block " << i << " not written!";
       }
     }
   }
 
   // Serialize protobuf
   string serialized_manifest;
   
   CheckGraph(graph);
@@ skipping 20 matching lines @@
   
   // Write protobuf
   LOG(INFO) << "Writing final delta file protobuf... "
             << serialized_manifest.size();
   TEST_AND_RETURN_FALSE(writer.Write(serialized_manifest.data(),
                                      serialized_manifest.size()) ==
                         static_cast<ssize_t>(serialized_manifest.size()));
   
   // Append the data blobs
   LOG(INFO) << "Writing final delta file data blobs...";
-  int blobs_fd = open(temp_file_path.c_str(), O_RDONLY, 0);
+  int blobs_fd = open(ordered_blobs_path.c_str(), O_RDONLY, 0);
   ScopedFdCloser blobs_fd_closer(&blobs_fd);
   TEST_AND_RETURN_FALSE(blobs_fd >= 0);
   for (;;) {
     char buf[kBlockSize];
     ssize_t rc = read(blobs_fd, buf, sizeof(buf));
     if (0 == rc) {
       // EOF
       break;
     }
     TEST_AND_RETURN_FALSE_ERRNO(rc > 0);
     TEST_AND_RETURN_FALSE(writer.Write(buf, rc) == rc);
   }
   
   LOG(INFO) << "All done. Successfully created delta file.";
   return true;
 }
 
 };  // namespace chromeos_update_engine