Merge remote branch 'cros/upstream' into tempbranch

client/bin/partition.py

 """
 APIs to write tests and control files that handle partition creation, deletion
 and formatting.
 
 @copyright: Google 2006-2008
 @author: Martin Bligh (mbligh@google.com)
 """
 
 import os, re, string, sys, fcntl, logging
 from autotest_lib.client.bin import os_dep, utils
@@ skipping 158 matching lines @@
 
         if filter_func and not filter_func(partname):
             logging.debug('Skipping %s - Filter func.' % partname)
             continue
 
         partitions.append(partition(job, device))
 
     return partitions
 
 
+def get_mount_info(partition_list):
+    """
+    Picks up mount point information about the machine mounts. By default, we
+    try to associate mount points with UUIDs, because in newer distros the
+    partitions are uniquely identified using them.
+    """
+    mount_info = set()
+    for p in partition_list:
+        try:
+            uuid = utils.system_output('blkid -s UUID -o value %s' % p.device)
+        except error.CmdError:
+            # fall back to using the partition
+            uuid = p.device
+        mount_info.add((uuid, p.get_mountpoint()))
+
+    return mount_info
+
+
 def filter_partition_list(partitions, devnames):
     """
     Pick and choose which partition to keep.
 
     filter_partition_list accepts a list of partition objects and a list
     of strings.  If a partition has the device name of the strings it
     is returned in a list.
 
     @param partitions: A list of L{partition} objects
     @param devnames: A list of devnames of the form '/dev/hdc3' that
@@ skipping 115 matching lines @@
         if not partname[-1].isdigit():
             # Disk name does not end in number, AFAIK
             # so use it as a reference to a disk
             if device.strip("/dev/") == partname:
                 return True
 
     return False
 
 
 def run_test_on_partitions(job, test, partitions, mountpoint_func,
-                           tag, fs_opt, **dargs):
+                           tag, fs_opt, do_fsck=True, **dargs):
     """
     Run a test that requires multiple partitions.  Filesystems will be
     made on the partitions and mounted, then the test will run, then the
-    filesystems will be unmounted and fsck'd.
+    filesystems will be unmounted and optionally fsck'd.
 
     @param job: A job instance to run the test
     @param test: A string containing the name of the test
     @param partitions: A list of partition objects, these are passed to the
             test as partitions=
     @param mountpoint_func: A callable that returns a mountpoint given a
             partition instance
     @param tag: A string tag to make this test unique (Required for control
             files that make multiple calls to this routine with the same value
             of 'test'.)
     @param fs_opt: An FsOptions instance that describes what filesystem to make
+    @param do_fsck: include fsck in post-test partition cleanup.
     @param dargs: Dictionary of arguments to be passed to job.run_test() and
             eventually the test
     """
     # setup the filesystem parameters for all the partitions
     for p in partitions:
         p.set_fs_options(fs_opt)
 
     # make and mount all the partitions in parallel
     parallel(partitions, 'setup_before_test', mountpoint_func=mountpoint_func)
 
     mountpoint = mountpoint_func(partitions[0])
 
     # run the test against all the partitions
     job.run_test(test, tag=tag, partitions=partitions, dir=mountpoint, **dargs)
 
-    # fsck and then remake all the filesystems in parallel
-    parallel(partitions, 'cleanup_after_test')
+    parallel(partitions, 'unmount')  # unmount all partitions in parallel
+    if do_fsck:
+        parallel(partitions, 'fsck')  # fsck all partitions in parallel
+    # else fsck is done by caller
 
 
 class partition(object):
     """
     Class for handling partitions and filesystems
     """
 
     def __init__(self, job, device, loop_size=0, mountpoint=None):
         """
         @param job: A L{client.bin.job} instance.
@@ skipping 66 matching lines @@
         mountpoint = mountpoint_func(self)
         if not mountpoint:
             raise ValueError('Don\'t know where to put this partition')
         self.unmount(ignore_status=True, record=False)
         self.mkfs()
         if not os.path.isdir(mountpoint):
             os.makedirs(mountpoint)
         self.mount(mountpoint)
 
 
-    def cleanup_after_test(self):
-        """
-        Cleans up a partition after running a filesystem test.  The
-        filesystem is unmounted, and then checked for errors.
-        """
-        self.unmount()
-        self.fsck()
-
-
     def run_test_on_partition(self, test, mountpoint_func, **dargs):
         """
         Executes a test fs-style (umount,mkfs,mount,test)
 
         Here we unmarshal the args to set up tags before running the test.
         Tests are also run by first umounting, mkfsing and then mounting
         before executing the test.
 
         @param test: name of test to run
         @param mountpoint_func: function to return mount point string
@@ skipping 11 matching lines @@
         if suffix:
             tag = '%s.%s' % (tag, suffix)
 
         dargs['tag'] = test + '.' + tag
 
         def _make_partition_and_run_test(test_tag, dir=None, **dargs):
             self.setup_before_test(mountpoint_func)
             try:
                 self.job.run_test(test, tag=test_tag, dir=mountpoint, **dargs)
             finally:
-                self.cleanup_after_test()
+                self.unmount()
+                self.fsck()
+
 
         mountpoint = mountpoint_func(self)
 
         # The tag is the tag for the group (get stripped off by run_group)
         # The test_tag is the tag for the test itself
         self.job.run_group(_make_partition_and_run_test,
                            test_tag=tag, dir=mountpoint, **dargs)
 
 
     def get_mountpoint(self, open_func=open, filename=None):
         """
         Find the mount point of this partition object.
 
         @param open_func: the function to use for opening the file containing
                 the mounted partitions information
         @param filename: where to look for the mounted partitions information
                 (default None which means it will search /proc/mounts and/or
                 /etc/mtab)
 
         @returns a string with the mount point of the partition or None if not
                 mounted
         """
         if filename:
             for line in open_func(filename).readlines():
                 parts = line.split()
-                if parts[0] == self.device:
+                if parts[0] == self.device or parts[1] == self.mountpoint:
                     return parts[1] # The mountpoint where it's mounted
             return None
 
         # no specific file given, look in /proc/mounts
         res = self.get_mountpoint(open_func=open_func, filename='/proc/mounts')
         if not res:
             # sometimes the root partition is reported as /dev/root in
             # /proc/mounts in this case, try /etc/mtab
             res = self.get_mountpoint(open_func=open_func, filename='/etc/mtab')
 
@@ skipping 467 matching lines @@
             os.remove(self.img)
         except:
             e_msg = 'Error removing image file %s' % self.img
             raise error.AutotestError(e_msg)
 
 # import a site partition module to allow it to override functions
 try:
     from autotest_lib.client.bin.site_partition import *
 except ImportError:
     pass