verity_utils: always pass depth of 0

client/cros/verity_utils.py

 # 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.
 
 import logging
 import mmap
 import os
 import time
 from autotest_lib.client.bin import os_dep, test
 from autotest_lib.client.common_lib import error, utils
 
 """ a wrapper for using verity/dm-verity with a test backing store """
 
 # enum for the 3 possible values of the module parameter.
 ERROR_BEHAVIOR_ERROR = 'eio'
 ERROR_BEHAVIOR_REBOOT = 'panic'
 ERROR_BEHAVIOR_IGNORE = 'none'
 ERROR_BEHAVIOR_NOTIFIER = 'notify'  # for platform specific behavior.
 
 # Default configuration for verity_image
 DEFAULT_TARGET_NAME = 'verity_image'
-DEFAULT_DEPTH = 1
 DEFAULT_ALG = 'sha1'
 DEFAULT_IMAGE_SIZE_IN_BLOCKS = 100
 DEFAULT_ERROR_BEHAVIOR = ERROR_BEHAVIOR_ERROR
 # TODO(wad) make this configurable when dm-verity doesn't hard-code 4096.
 BLOCK_SIZE = 4096
 
 class verity_image(object):
     """ a helper for creating dm-verity targets for testing.
 
         To use,
           vi = verity_image()
           vi.initialize(self.tmpdir, "dmveritytesta")
           # Create a 409600 byte image with /bin/ls on it
           # The size in bytes is returned.
           backing_path = vi.create_backing_image(100, copy_files=['/bin/ls'])
           # Performs hashing of the backing_path and sets up a device.
           loop_dev = vi.prepare_backing_device()
           # Sets up the mapped device and returns the path:
           # E.g., /dev/mapper/autotest_dmveritytesta
           dev = vi.create_verity_device()
           # Access the mapped device using the returned string.
 
        TODO(wad) add direct verified and backing store access functions
                  to make writing modifiers easier (e.g., mmap).
     """
     # Define the command template constants.
-    verity_cmd = 'verity create %d %s %s %d %s'
+    verity_cmd = 'verity create 0 %s %s %d %s'
     dd_cmd = 'dd if=/dev/zero of=%s bs=4096 count=0 seek=%d'
     mkfs_cmd = 'mkfs.ext3 -b 4096 -F %s'
     dmsetup_cmd = "dmsetup -r create autotest_%s --table '%s'"
 
     def reset(self):
         """Idempotent call which will free any claimed system resources"""
         # Pre-initialize these values to None
         for attr in ['mountpoint', 'device', 'loop', 'file', 'hash_file']:
             if not hasattr(self, attr):
                 setattr(self, attr, None)
@@ skipping 14 matching lines @@
 
         if self.file is not None:
             os.remove(self.file)
             self.file = None
 
         if self.hash_file is not None:
             os.remove(self.hash_file)
             self.hash_file = None
 
         self.alg = DEFAULT_ALG
-        self.depth = DEFAULT_DEPTH
         self.error_behavior = DEFAULT_ERROR_BEHAVIOR
         self.blocks = DEFAULT_IMAGE_SIZE_IN_BLOCKS
         self.file = None
         self.has_fs = False
         self.hash_file = None
         self.table = None
         self.target_name = DEFAULT_TARGET_NAME
 
         self.__initialized = False
 
@@ skipping 14 matching lines @@
     def _create_fs(self, copy_files):
         """sets up ext3 on the image"""
         self.has_fs = True
         utils.system(self.mkfs_cmd % self.file)
         if type(copy_files) is list:
           for file in copy_files:
               pass  # TODO(wad)
 
     def _hash_image(self):
         """runs verity over the image and saves the device mapper table"""
-        self.table = utils.system_output(self.verity_cmd % (self.depth,
-                                                            self.alg,
+        self.table = utils.system_output(self.verity_cmd % (self.alg,
                                                             self.file,
                                                             self.blocks,
                                                             self.hash_file))
         # The verity tool doesn't include a templated error value.
         # For now, we add one.
         self.table += " ERROR_BEHAVIOR"
         logging.info("table is %s" % self.table)
 
     def _append_hash(self):
         # TODO(wad) use native python file I/O
         utils.system('cat %s >> %s' % (self.hash_file, self.file))
 
     def _setup_loop(self):
         # Setup a loop device
         self.loop = utils.system_output('losetup -f')
         utils.system('losetup %s %s' % (self.loop, self.file))
 
     def _setup_target(self):
         # Update the table with the loop dev
         self.table = self.table.replace('HASH_DEV', self.loop)
         self.table = self.table.replace('ROOT_DEV', self.loop)
         self.table = self.table.replace('ERROR_BEHAVIOR', self.error_behavior)
 
         utils.system(self.dmsetup_cmd % (self.target_name, self.table))
         self.device = "/dev/mapper/autotest_%s" % self.target_name
 
     def initialize(self,
                    tmpdir,
                    target_name,
-                   depth=DEFAULT_DEPTH,
                    alg=DEFAULT_ALG,
                    size_in_blocks=DEFAULT_IMAGE_SIZE_IN_BLOCKS,
                    error_behavior=DEFAULT_ERROR_BEHAVIOR):
         """Performs any required system-level initialization before use.
         """
         try:
             os_dep.commands('losetup', 'mkfs.ext3', 'dmsetup', 'verity', 'dd',
                             'dumpe2fs')
         except ValueError, e:
             logging.error('verity_image cannot be used without: %s' % e)
             return False
 
         # Used for the mapper device name and the tmpfile names.
         self.target_name = target_name
 
         # Reserve some files to use.
         self.file = os.tempnam(tmpdir, '%s.img.' % self.target_name)
         self.hash_file = os.tempnam(tmpdir, '%s.hash.' % self.target_name)
 
         # Set up the configurable bits.
         self.alg = alg
-        self.depth = depth
         self.error_behavior = error_behavior
         self.blocks = size_in_blocks
 
         self.__initialized = True
         return True
 
     def create_backing_image(self, size_in_blocks, with_fs=True,
                              copy_files=None):
         """Creates an image file of the given number of blocks and if specified
            will create a filesystem and copy any files in a copy_files list to
@@ skipping 75 matching lines @@
 
             mapped_dev = self.verity.create_verity_device()
 
             # Now check for failure.
             if self.verity.verifiable() is not expected:
                 raise error.TestFail(
                     '%s: verity.verifiable() not as expected (%s)' %
                     (modifier.__name__, expected))
             tries += 1