AU: Include the old/new kernel/rootfs size/hash in the update metadata.

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 11 matching lines @@
 #include <bzlib.h>
 
 #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/graph_types.h"
 #include "update_engine/graph_utils.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;
@@ skipping 537 matching lines @@
   TEST_AND_RETURN_FALSE(
       GatherExtents(new_filename, operation.mutable_dst_extents()));
   operation.set_dst_length(new_data.size());
 
   out_data->swap(data);
   *out_op = operation;
 
   return true;
 }
 
+bool InitializePartitionInfo(const string& partition, PartitionInfo* info) {
+  const off_t size = utils::FileSize(partition);
+  TEST_AND_RETURN_FALSE(size >= 0);
+  info->set_size(size);
+  OmahaHashCalculator hasher;
+  TEST_AND_RETURN_FALSE(hasher.UpdateFile(partition, -1) == size);
+  TEST_AND_RETURN_FALSE(hasher.Finalize());
+  const vector<char>& hash = hasher.raw_hash();
+  info->set_hash(string(&hash[0], hash.size()));
+  return true;
+}
+
+bool InitializePartitionInfos(const string& old_kernel,
+                              const string& new_kernel,
+                              const string& old_rootfs,
+                              const string& new_rootfs,
+                              DeltaArchiveManifest* manifest) {
+  if (!old_kernel.empty()) {
+    TEST_AND_RETURN_FALSE(
+        InitializePartitionInfo(old_kernel,
+                                manifest->mutable_old_kernel_info()));
+  }
+  TEST_AND_RETURN_FALSE(
+      InitializePartitionInfo(new_kernel, manifest->mutable_new_kernel_info()));
+  if (!old_rootfs.empty()) {
+    TEST_AND_RETURN_FALSE(
+        InitializePartitionInfo(old_rootfs,
+                                manifest->mutable_old_rootfs_info()));
+  }
+  TEST_AND_RETURN_FALSE(
+      InitializePartitionInfo(new_rootfs, manifest->mutable_new_rootfs_info()));
+  return true;
+}
+
 namespace {
 
 // Takes a collection (vector or RepeatedPtrField) of Extent and
 // returns a vector of the blocks referenced, in order.
 template<typename T>
 vector<uint64_t> ExpandExtents(const T& extents) {
   vector<uint64_t> ret;
   for (size_t i = 0, e = static_cast<size_t>(extents.size()); i != e; ++i) {
     const Extent extent = graph_utils::GetElement(extents, i);
     if (extent.start_block() == kSparseHole) {
@@ skipping 73 matching lines @@
     LOG(INFO) << "using " << graph_utils::EdgeWeight(*graph, *it)
               << " scratch blocks ("
               << scratch_blocks_used << ")";
     cuts.back().tmp_extents =
         scratch_allocator.Allocate(graph_utils::EdgeWeight(*graph, *it));
     // create vertex to copy original->scratch
     cuts.back().new_vertex = graph->size();
     graph->resize(graph->size() + 1);
     cuts.back().old_src = it->first;
     cuts.back().old_dst = it->second;
-    
+
     EdgeProperties& cut_edge_properties =
         (*graph)[it->first].out_edges.find(it->second)->second;
 
     // This should never happen, as we should only be cutting edges between
     // real file nodes, and write-before relationships are created from
     // a real file node to a temp copy node:
     CHECK(cut_edge_properties.write_extents.empty())
         << "Can't cut edge that has write-before relationship.";
 
     // make node depend on the copy operation
@@ skipping 203 matching lines @@
           kTempBlockStart, kSparseHole - kTempBlockStart));
       ranges.SubtractRepeatedExtents((*graph)[test_node].op.src_extents());
       // For now, for simplicity, subtract out all blocks in read-before
       // dependencies.
       for (Vertex::EdgeMap::const_iterator edge_i =
                (*graph)[test_node].out_edges.begin(),
                edge_e = (*graph)[test_node].out_edges.end();
            edge_i != edge_e; ++edge_i) {
         ranges.SubtractExtents(edge_i->second.extents);
       }
-      
+
       uint64_t blocks_found = ranges.blocks();
       if (blocks_found < blocks_needed) {
         if (blocks_found > 0)
           LOG(INFO) << "insufficient blocks found in topo node " << j
                     << " (node " << (*op_indexes)[j] << "). Found only "
                     << blocks_found;
         continue;
       }
       found_node = true;
       LOG(INFO) << "Found sufficient blocks in topo node " << j
                 << " (node " << (*op_indexes)[j] << ")";
       // Sub in the blocks, and make the node supplying the blocks
       // depend on old_dst.
       vector<Extent> real_extents =
           ranges.GetExtentsForBlockCount(blocks_needed);
-      
+
       // Fix the old dest node w/ the real blocks
       SubstituteBlocks(&(*graph)[node],
                        cuts[i].tmp_extents,
                        real_extents);
-                       
+
       // Fix the new node w/ the real blocks. Since the new node is just a
       // copy operation, we can replace all the dest extents w/ the real
       // blocks.
       DeltaArchiveManifest_InstallOperation *op =
           &(*graph)[cuts[i].new_vertex].op;
       op->clear_dst_extents();
       StoreExtents(real_extents, op->mutable_dst_extents());
-      
+
       // Add an edge from the real-block supplier to the old dest block.
       graph_utils::AddReadBeforeDepExtents(&(*graph)[test_node],
                                            node,
                                            real_extents);
       break;
     }
     if (!found_node) {
       // convert to full op
       LOG(WARNING) << "Failed to find enough temp blocks for cut " << i
                    << " with old dest (graph node " << node
                    << "). Converting to a full op, at the expense of a "
                    << "good compression ratio.";
       TEST_AND_RETURN_FALSE(ConvertCutToFullOp(graph,
                                                cuts[i],
                                                new_root,
                                                data_fd,
                                                data_file_size));
       // move the full op to the back
       vector<Vertex::Index> new_op_indexes;
       for (vector<Vertex::Index>::const_iterator iter_i = op_indexes->begin(),
                iter_e = op_indexes->end(); iter_i != iter_e; ++iter_i) {
         if ((*iter_i == cuts[i].old_dst) || (*iter_i == cuts[i].new_vertex))
           continue;
         new_op_indexes.push_back(*iter_i);
       }
       new_op_indexes.push_back(cuts[i].old_dst);
       op_indexes->swap(new_op_indexes);
-      
+
       GenerateReverseTopoOrderMap(*op_indexes, reverse_op_indexes);
     }
     if (i == e) {
       // break out of for() loop
       break;
     }
   }
   return true;
 }
 
@@ skipping 64 matching lines @@
   }
   return true;
 }
 
 bool DeltaDiffGenerator::ConvertCutToFullOp(Graph* graph,
                                             const CutEdgeVertexes& cut,
                                             const string& new_root,
                                             int data_fd,
                                             off_t* data_file_size) {
   // Drop all incoming edges, keep all outgoing edges
-  
+
   // Keep all outgoing edges
   Vertex::EdgeMap out_edges = (*graph)[cut.old_dst].out_edges;
   graph_utils::DropWriteBeforeDeps(&out_edges);
-  
+
   TEST_AND_RETURN_FALSE(DeltaReadFile(graph,
                                       cut.old_dst,
                                       NULL,
                                       "/-!@:&*nonexistent_path",
                                       new_root,
                                       (*graph)[cut.old_dst].file_name,
                                       data_fd,
                                       data_file_size));
-                                      
+
   (*graph)[cut.old_dst].out_edges = out_edges;
 
   // Right now we don't have doubly-linked edges, so we have to scan
   // the whole graph.
   graph_utils::DropIncomingEdgesTo(graph, cut.old_dst);
 
   // Delete temp node
   (*graph)[cut.old_src].out_edges.erase(cut.new_vertex);
   CHECK((*graph)[cut.old_dst].out_edges.find(cut.new_vertex) ==
         (*graph)[cut.old_dst].out_edges.end());
@@ skipping 53 matching lines @@
     Graph* graph,
     const std::string& new_kernel_part,
     const std::string& new_image,
     int fd,
     off_t* data_file_size,
     off_t chunk_size,
     vector<DeltaArchiveManifest_InstallOperation>* kernel_ops,
     std::vector<Vertex::Index>* final_order) {
   TEST_AND_RETURN_FALSE(chunk_size > 0);
   TEST_AND_RETURN_FALSE((chunk_size % kBlockSize) == 0);
-  
+
   // Get the sizes early in the function, so we can fail fast if the user
   // passed us bad paths.
   const off_t image_size = utils::FileSize(new_image);
   TEST_AND_RETURN_FALSE(image_size >= 0);
   const off_t kernel_size = utils::FileSize(new_kernel_part);
   TEST_AND_RETURN_FALSE(kernel_size >= 0);
 
   off_t part_sizes[] = { image_size, kernel_size };
   string paths[] = { new_image, new_kernel_part };
 
@@ skipping 13 matching lines @@
       if (partition == 0) {
         graph->resize(graph->size() + 1);
         graph->back().file_name = path + StringPrintf("-%" PRIi64, counter);
         op = &graph->back().op;
         final_order->push_back(graph->size() - 1);
       } else {
         kernel_ops->resize(kernel_ops->size() + 1);
         op = &kernel_ops->back();
       }
       LOG(INFO) << "have an op";
-      
+
       vector<char> buf(min(bytes_left, chunk_size));
       LOG(INFO) << "buf size: " << buf.size();
       ssize_t bytes_read = -1;
-      
+
       TEST_AND_RETURN_FALSE(utils::PReadAll(
           in_fd, &buf[0], buf.size(), offset, &bytes_read));
       TEST_AND_RETURN_FALSE(bytes_read == static_cast<ssize_t>(buf.size()));
-      
+
       vector<char> buf_compressed;
-      
+
       TEST_AND_RETURN_FALSE(BzipCompress(buf, &buf_compressed));
       const bool compress = buf_compressed.size() < buf.size();
       const vector<char>& use_buf = compress ? buf_compressed : buf;
       if (compress) {
         op->set_type(DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ);
       } else {
         op->set_type(DeltaArchiveManifest_InstallOperation_Type_REPLACE);
       }
       op->set_data_offset(*data_file_size);
       *data_file_size += use_buf.size();
@@ skipping 184 matching lines @@
                                            &signature_blob_length));
     dummy_op->set_data_length(signature_blob_length);
     manifest.set_signatures_size(signature_blob_length);
     Extent* dummy_extent = dummy_op->add_dst_extents();
     // Tell the dummy op to write this data to a big sparse hole
     dummy_extent->set_start_block(kSparseHole);
     dummy_extent->set_num_blocks((signature_blob_length + kBlockSize - 1) /
                                  kBlockSize);
   }
 
+  TEST_AND_RETURN_FALSE(InitializePartitionInfos(old_kernel_part,
+                                                 new_kernel_part,
+                                                 old_image,
+                                                 new_image,
+                                                 &manifest));
+
   // Serialize protobuf
   string serialized_manifest;
 
   CheckGraph(graph);
   TEST_AND_RETURN_FALSE(manifest.AppendToString(&serialized_manifest));
   CheckGraph(graph);
 
   LOG(INFO) << "Writing final delta file header...";
   DirectFileWriter writer;
   TEST_AND_RETURN_FALSE_ERRNO(writer.Open(output_path.c_str(),
@@ skipping 51 matching lines @@
 
   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