Introduce crossystem wrapper in SAFT.

chromeos_interface.py

 #!/usr/bin/python
 # 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.
 
 '''A module to provide interface to ChromeOS services.'''
 
 import datetime
 import os
 import re
 import shutil
 import struct
 import subprocess
 import tempfile
 import time
 
-# Source of ACPI information on ChromeOS machines.
-ACPI_DIR = '/sys/devices/platform/chromeos_acpi'
-
 class ChromeOSInterfaceError(Exception):
     '''ChromeOS interface specific exception.'''
     pass
 
+class Crossystem(object):
+    '''A wrapper for the crossystem utility.'''
+
+    def init(self, cros_if):
+        self.cros_if = cros_if
+
+    def __getattr__(self, name):
+        '''
+        Retrieve a crosssystem attribute.
+
+        Attempt to access crossystemobject.name will invoke `crossystem name'
+        and return the stdout as the value.
+        '''
+        return self.cros_if.run_shell_command_get_output(

[Randall Spangler, 2011/04/18 20:42:54]

What happens if crossystem exits non-zero (for example, if you access a
non-existent attribute)?

+            'crossystem %s' % name)[0]
+
+    def __setattr__(self, name, value):
+        if name in ('cros_if',):
+            self.__dict__[name] = value
+        else:
+            self.cros_if.run_shell_command('crossystem "%s=%s"' % (name, value))
+
+
+    def get_boot_vector_base(self):
+        '''
+        Convert system state into a legacy boot vector base.
+
+        The first three legacy boot vector digits are the boot vector base
+        (the entire vector consists of 5 digits). They used to be reported by
+        the BIOS through ACPI, but that scheme has been superseded by the
+        'crossystem' interface.
+
+        The digits of the boot vector base have the following significance
+
+        - first digit -
+        1 - normal boot
+        2 - developer mode boot
+        3 - recovery initialed by pressing the recovery button
+        4 - recovery from developer mode warning screen
+        5 - recovery caused by both firmware images being invalid
+        6 - recovery caused by both kernel images being invalid
+
+        - second digit -
+        0 - recovery firmware
+        1 - rewritable firmware A
+        2 - rewritable firmware B
+
+        - third digit -
+        0 - Read only (recovery) EC firmware
+        1 - rewritable EC firmware
+
+
+        This function uses a three tuple of dictionaries to map current system
+        state as reported by 'crossystem' into the 'legacy' boot vector
+        digits.
+
+        Each tuple element is a dictionary, where the key is the 'legacy'
+        representation of the state, and the value is a yet another dictionary
+        of name-value pairs.
+
+        If all name-value pairs match those in the crossystem output, the
+        legacy representation number is returned as the appropriate vector
+        number.
+
+        The function returns a list of three digits in symbolic representation.
+
+        Should it be impossible to interpret the state, the function returns a
+        partially built list, which is an indication of a problem for the
+        caller (list shorter than 3 elements).
+        '''
+
+        vector_maps = (
+            { # first vector position
+                '1': {
+                    'devsw_boot': '0',
+                    'recoverysw_boot': '0',
+                    'recovery_reason' : '0',
+                    'tried_fwb' : '0',
+                    },
+                },
+            { # second vector position
+                '0': {'mainfw_type': 'recovery',},
+                '1': {
+                    'mainfw_type': 'normal',
+                    'mainfw_act': 'A'
+                    },
+                '2': {
+                    'mainfw_type': 'normal',
+                    'mainfw_act': 'B'
+                    },
+                },
+            { # third vector position
+                '0': {'ecfw_act': 'RO',},
+                '1': {'ecfw_act': 'RW',},
+                },
+        )
+
+        boot_vector = []
+
+        for vector_map in vector_maps:
+            for (digit, values) in vector_map.iteritems():
+                for (name, value) in values.iteritems():
+                    if self.__getattr__(name) != value:
+                        break
+                else:
+                    boot_vector.append(digit)
+                    break
+
+        return boot_vector
+
+    def dump(self):
+        '''Dump all values as multiline text.'''
+        return '\n'.join(self.cros_if.run_shell_command_get_output(
+            'crossystem'))
+
+
 class ChromeOSInterface(object):
     '''An object to encapsulate OS services functions.'''
 
     def __init__(self, silent):
         '''Object construction time initialization.
 
         The only parameter is the Boolean 'silent', when True the instance
         does not duplicate log messages on the console.
         '''
+
         self.silent = silent
         self.state_dir = None
         self.log_file = None
-        self.acpi_dir = ACPI_DIR
+        self.cs = Crossystem()
 
     def init(self, state_dir=None, log_file=None):
         '''Initialize the ChromeOS interface object.
         Args:
           state_dir - a string, the name of the directory (as defined by the
                       caller). The contents of this directory persist over
                       system restarts and power cycles.
           log_file - a string, the name of the log file kept in the state
                      directory.
 
         Default argument values support unit testing.
         '''
+
+        self.cs.init(self)
         self.state_dir = state_dir
 
         if self.state_dir:
             if not os.path.exists(self.state_dir):
                 try:
                     os.mkdir(self.state_dir)
                 except OSError, err:
                     raise ChromeOSInterfaceError(err)
             if log_file:
                 self.log_file = os.path.join(state_dir, log_file)
 
     def target_hosted(self):
         '''Return True if running on a ChromeOS target.'''
         signature = open('/proc/version_signature', 'r').read()
         return re.search(r'chrom(ium|e)os', signature, re.IGNORECASE) != None
 
     def state_dir_file(self, file_name):
         '''Get a full path of a file in the state directory.'''
         return os.path.join(self.state_dir, file_name)
 
-    def acpi_file(self, file_name):
-        '''Get a full path of a file in the ACPI directory.'''
-        return os.path.join(self.acpi_dir, file_name)
-
     def init_environment(self):
         '''Initialize Chrome OS interface environment.
 
         If state dir was not set up by the constructor, create a temp
         directory, otherwise create the directory defined during construction
         of this object.
 
         Return the state directory name.
         '''
 
-        if self.target_hosted() and not os.path.exists(self.acpi_dir):
-            raise ChromeOSInterfaceError(
-                'ACPI directory %s not found' % self.acpi_dir)
-
         if not self.state_dir:
             self.state_dir = tempfile.mkdtemp(suffix='_saft')
         else:
             # Wipe out state directory, to start the state machine clean.
             shutil.rmtree(self.state_dir)
             # And recreate it
             self.init(self.state_dir, self.log_file)
 
         return self.state_dir
 
@@ skipping 66 matching lines @@
 
     def is_removable_device(self, device):
         '''Check if a certain storage device is removable.
 
         device - a string, file name of a storage device or a device partition
                  (as in /dev/sda[0-9]).
 
         Returns True if the device is removable, False if not.
         '''
 
+        if not self.target_hosted():
+            return False
+
         # Drop trailing digit(s) and letter(s) (if any)
         dev_name_stripper = re.compile('[0-9].*$')
 
         base_dev = dev_name_stripper.sub('', device.split('/')[2])
         removable = int(open('/sys/block/%s/removable' % base_dev, 'r'
                              ).read())
 
         return removable == 1
 
     def get_root_dev(self):
         '''Return a string, the name of the root device'''
         return self.run_shell_command_get_output('rootdev -s')[0]
 
     def run_shell_command_get_output(self, cmd):
         '''Run shell command and return its console output to the caller.
 
       The output is returned as a list of strings stripped of the newline
       characters.'''
 
         process = self.run_shell_command(cmd)
         return [x.rstrip() for x in process.stdout.readlines()]
 
     def boot_state_vector(self):
         '''Read and return to caller a string describing the system state.
 
-        The string has a form of x:x:x:<removable>:<partition_number>, where
-        x' represent contents of the appropriate BINF files as reported by
-        ACPI, <removable> is set to 1 or 0 depending if the root device is
-        removable or not, and <partition number> is the last element of the
-        root device name, designating the partition where the root fs is
-        mounted.
+        The string has a form of x0:x1:x2:<removable>:<partition_number>,
+        where the field meanings of X# are described in the
+        Crossystem.get_boot_vector_base() docstring above.
+
+        <removable> is set to 1 or 0 depending if the root device is removable
+        or not, and <partition number> is the last element of the root device
+        name, designating the partition where the root fs is mounted.
 
         This vector fully describes the way the system came up.
         '''
 
-        binf_fname_template = 'BINF.%d'
-        state = []
-        for index in range(3):
-            fname = os.path.join(self.acpi_dir, binf_fname_template % index)
-            max_wait = 30
-            cycles = 0
-            # In some cases (for instance when running off the flash file
-            # system) the ACPI files go not get created right away. Let's give
-            # it some time to settle.
-            while not os.path.exists(fname):
-                if cycles == max_wait:
-                    self.log('%s is not present' % fname)
-                    raise AssertionError
-                time.sleep(1)
-                cycles += 1
-            if cycles:
-                self.log('ACPI took %d cycles' % cycles)
-            state.append(open(fname, 'r').read())
+        state = self.cs.get_boot_vector_base()
+
+        if len(state) != 3:
+            raise ChromeOSInterfaceError(self.cs.dump())
+
         root_dev = self.get_root_dev()
         state.append('%d' % int(self.is_removable_device(root_dev)))
         state.append('%s' % root_dev[-1])
         state_str = ':'.join(state)
         return state_str
 
     def get_writeable_mount_point(self, dev, tmp_dir):
         '''Get mountpoint of the passed in device mounted in read/write mode.
 
       If the device is already mounted and is writeable - return its mount
@@ skipping 41 matching lines @@
     def read_partition(self, partition, size):
         '''Read the requested partition, up to size bytes.'''
         tmp_file = self.state_dir_file('part.tmp')
         self.run_shell_command('dd if=%s of=%s bs=1 count=%d' % (
                 partition, tmp_file, size))
         fileh = open(tmp_file, 'r')
         data = fileh.read()
         fileh.close()
         os.remove(tmp_file)
         return data