verity: remove the depth parameter from bht_create

file_hasher.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by the GPL v2 license that can
 // be found in the LICENSE file.
 //
 // Implementation of FileHasher
 
 #define __STDC_LIMIT_MACROS 1
 #define __STDC_FORMAT_MACROS 1
 #include <errno.h>
 #include <inttypes.h>
@@ skipping 27 matching lines @@
   if (!f->WriteAt(to_bytes(count), dst, offset)) {
     dm_bht_write_completed(entry, -EIO);
     return -1;
   }
   dm_bht_write_completed(entry, 0);
   return 0;
 }
  
 bool FileHasher::Initialize(simple_file::File *source,
                             simple_file::File *destination,
-                            unsigned int depth,
                             unsigned int blocks,
                             const char *alg) {
   if (!alg || !source || !destination) {
      LOG(ERROR) << "Invalid arguments supplied to Initialize";
-     LOG(INFO) << "depth: " << depth;
      LOG(INFO) << "s: " << source << " d: " << destination;
      return false;
   }
   if (source_ || destination_) {
     LOG(ERROR) << "Initialize called more than once";
     return false;
   }
   if (blocks > source->Size() / PAGE_SIZE) {
     LOG(ERROR) << blocks << " blocks exceeds image size of " << source->Size();
     return false;
   } else if (blocks == 0) {
     blocks = source->Size() / PAGE_SIZE;
     if (source->Size() % PAGE_SIZE) {
       LOG(ERROR) << "The source file size must be divisible by the block size";
       LOG(ERROR) << "Size: " << source->Size();
       LOG(INFO) << "Suggested size: " << ALIGN(source->Size(),PAGE_SIZE);
       return false;
     }
   }
   alg_ = alg;
   source_ = source;
   destination_ = destination;
-  depth_ = depth;
   block_limit_ = blocks;
 
   // Now we initialize the tree
-  if (dm_bht_create(&tree_, depth_, block_limit_, alg_)) {
+  if (dm_bht_create(&tree_, block_limit_, alg_)) {
     LOG(ERROR) << "Could not create the BH tree";
     return false;
   }
   dm_bht_set_write_cb(&tree_, FileHasher::WriteCallback);
   // No reading is needed.
   dm_bht_set_read_cb(&tree_, dm_bht_zeroread_callback);
 
   return true;
 }
 
@@ skipping 22 matching lines @@
 
 void FileHasher::PrintTable(bool colocated) {
   // Grab the digest (up to 1kbit supported)
   uint8_t digest[128];
   dm_bht_root_hexdigest(&tree_, digest, sizeof(digest));
 
   // TODO(wad) later support sizes that need 64-bit sectors.
   unsigned int hash_start = 0;
   unsigned int root_end = to_sector(block_limit_ << PAGE_SHIFT);
   if (colocated) hash_start = root_end;
-  printf("0 %u verity ROOT_DEV HASH_DEV %u %u %s %s\n",
-         root_end, hash_start, depth_, alg_, digest);
+  printf("0 %u verity ROOT_DEV HASH_DEV %u 0 %s %s\n",
+         root_end, hash_start, alg_, digest);

[Paul T, 2011/04/07 21:54:33]

Do you need to keep the 0? or should it just be deleted.

[Will Drewry, 2011/04/07 22:45:17]

It needs to stay for now until we change the kernel interface and update the
install and post-install scripts, as well as the signer and signer scripts :/

 }
 
 }  // namespace verity