Fix SAFT to work on all x86 platforms using crossystem.

saft_utility.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.
 
 '''Test utility for verifying ChromeOS firmware.'''
 
 import datetime
 import functools
 import getopt
@@ skipping 79 matching lines @@
 STEP_FILE = 'fw_test_step'  # The next test step number.
 FW_BACKUP_FILE = 'flashrom.bak'  # Preserved original flashrom contents.
 FW_COPY_FILE = 'flashrom.new'  # A copy of the flashrom contents being tested.
 FWID_BACKUP_FILE = 'fwid.bak'  # FWID reported by the original firmware.
 FWID_NEW_FILE = 'fwid.new'  # FWID reported by the firmware being tested.
 
 BASE_STORAGE_DEVICE = '/dev/sda'
 
 # The list of shell executables necessary for this program to work.
 REQUIRED_PROGRAMS = '''
-cgpt blkid flashrom reboot_mode readlink rootdev vbutil_firmware vbutil_kernel
+cgpt crossystem blkid flashrom readlink rootdev vbutil_firmware vbutil_kernel
 mosys
 '''
 
 
 FLASHROM_HANDLER = flashrom_handler.FlashromHandler()
 CHROS_IF = chromeos_interface.ChromeOSInterface(__name__ != '__main__')
 cgpt_st = cgpt_state.CgptState('COMPLETE', CHROS_IF, BASE_STORAGE_DEVICE)
 
 def allow_multiple_section_input(image_operator):
     @functools.wraps(image_operator)
@@ skipping 57 matching lines @@
         self.window = None
         self.tpm_handler = None
 
     def _verify_fw_id(self, compare_to_file):
         '''Verify if the current firmware ID matches the contents a file.
 
         compare_to_file - a string, name of the file in the state directory.
         '''
         old_fwid = open(
             self.chros_if.state_dir_file(compare_to_file), 'r').read()
-        now_fwid = open(self.chros_if.acpi_file('FWID'), 'r').read()
+        now_fwid = self.chros_if.cs.fwid
         return old_fwid == now_fwid
 
     def _get_step(self):
         '''Set the current value of SAFT step number.'''
         step_file = self.chros_if.state_dir_file(STEP_FILE)
         step = open(step_file, 'r').read().strip()
         return int(step)
 
     def _set_step(self, step):
         '''Set the SAFT step number to control the next test pass.'''
@@ skipping 56 matching lines @@
 
         os.rmdir(tmp_dir)
 
     def _check_runtime_env(self):
         '''Ensure that the script is running in proper environment.
 
       This involves checking that the script is running off a removable
       device, configuring proper file names for logging, etc.
       '''
         line = self.chros_if.run_shell_command_get_output(
-            'df %s' % self.mydir)[-1]
+            'df %s' % self.mydir)[1]
 
         self.base_partition = line.split()[0]
         if self.base_partition == '/dev/root':
             self.base_partition = self.chros_if.get_root_dev()
 
         if not self.chros_if.is_removable_device(self.base_partition):
             raise FwError(
                 'This test must run off a removable device, not %s'
                 % self.base_partition)
 
@@ skipping 70 matching lines @@
                 if self.kern_handler:
                     vers_a = self.kern_handler.get_version('a')
                     vers_b = self.kern_handler.get_version('b')
                     if not self.tpm_handler.kernel_version_good(vers_a, vers_b):
                         raise FwError('TPM kernel version mismatch (%d %d %s)' % (
                                 vers_a, vers_b, self.base_partition))
 
     def set_try_fw_b(self):
         '''Request running firmware B on the next restart.'''
         self.chros_if.log('Requesting restart with FW B')
-        self.chros_if.run_shell_command('reboot_mode --try_firmware_b=1')
+        self.chros_if.cs.fwb_tries = 1
 
     def request_recovery_boot(self):
         '''Request running in recovery mode on the restart.'''
         self.chros_if.log('Requesting restart in recovery mode')
-        self.chros_if.run_shell_command('reboot_mode --recovery=1')
+        self.chros_if.cs.request_recovery()
+
 
     @allow_multiple_section_input
     def restore_firmware(self, section):
         '''Restore the requested firmware section (previously corrupted).'''
         self.chros_if.log('Restoring firmware %s' % section)
         FLASHROM_HANDLER.restore_firmware(section)
 
     @allow_multiple_section_input
     def corrupt_firmware(self, section):
         '''Corrupt the requested firmware section.'''
@@ skipping 160 matching lines @@
                 datetime.datetime.strftime(
                     datetime.datetime.now(), '%b %d %Y')))
         chros_if.log('Original boot state %s' % chros_if.boot_state_vector())
         self.chros_if = chros_if
         fw_image = opt_dictionary['image_file']
         self.new_fw_image()
         FLASHROM_HANDLER.dump_whole(
             self.chros_if.state_dir_file(FW_BACKUP_FILE))
         self.new_fw_image(fw_image)
         self._handle_saft_script(True)
-        shutil.copyfile(self.chros_if.acpi_file('FWID'),
-                        self.chros_if.state_dir_file(FWID_BACKUP_FILE))
+        open(self.chros_if.state_dir_file(FWID_BACKUP_FILE), 'w'
+             ).write(self.chros_if.cs.fwid)
         shutil.copyfile(fw_image, self.chros_if.state_dir_file(FW_COPY_FILE))
 
         self._set_step(0)
         cgpt_st.set_step(0)
 
     def next_step(self):
         '''Function to execute a single SAFT step.
 
       This function is running after each reboot. It determines the current
       step the SAFT is on, executes the appropriate action, increments the
       step value and then restats the machine.
       '''
 
         this_step = self._get_step()
 
         # Import when needed, because otherwise running test generates a
         # warning exception about the unavailable display.
         window = __import__('window')
         self.window = window.GraphThread()
 
         if this_step == 0:
-            shutil.copyfile(self.chros_if.acpi_file('FWID'),
-                            self.chros_if.state_dir_file(FWID_NEW_FILE))
+            open(self.chros_if.state_dir_file(FWID_NEW_FILE), 'w'
+                 ).write(self.chros_if.cs.fwid)
 
             if self._verify_fw_id(FWID_BACKUP_FILE):
           # we expected FWID to change, but it did not - have the firmware
           # been even replaced?
                 self.chros_if.log('New firmware - old FWID')
                 self.finish_saft(False)
         test_state_tuple = self.test_state_sequence[this_step]
         expected_vector = test_state_tuple[0]
         action = test_state_tuple[1]
 
@@ skipping 67 matching lines @@
             # Have chros_if.shutdown move the log into the '/var' directory to
             # make it easier to see SAFT results.
             self.chros_if.shut_down(os.path.join('/var', LOG_FILE))
 
         self.window.stop()
         sys.exit(0)
 
 # Firmware self test instance controlling this module.
 FST = FirmwareTest()
 
-# This is a tuple of tuples controlling the SAFT state machine. The states
-# are expected to be passed strictly in order. The states are identified
-# by the contents of BINF.[012] files in the sys fs ACPI directory. The
-# BINF files store information about the reason for reboot, what
-# firmware/kernel partitions were used, etc.
+# This is a tuple of tuples controlling the SAFT state machine. The states are
+# expected to be passed strictly in order. The states used to be identified by
+# the contents of BINF.[012] files in the sys fs ACPI directory. Now they are
+# derived from the crossystem output to match previously reported states.
 #
 # The first element of each component tuple is the expected state of the
-# machine (a ':' concatenation of the BINF files' contents).
+# machine.
 #
 # The second element of the component tuples is the action to take to
 # advance the test. The action is a function to call. The last line has
 # action set to None, which indicates to the state machine that the test
 # is over.
 #
 # The third component, if present, is the parameter to pass to the action
 # function.
 
 TEST_STATE_SEQUENCE = (
@@ skipping 106 matching lines @@
     if 'next_step' in opt_dictionary:
         if len(opt_dictionary) != 1:
             usage('--next_step (when specified) must be the only parameter', 1)
         try:
             FST.next_step()
         except SystemExit:
             pass  # No real exception, this is just an exit (for whatever
                   # reason), gtk window already closed.
         except:
             # Whatever error that might be, gtk window must be shut.
-            FST.window.stop()
+            if FST.window:
+                FST.window.stop()
 
             # Make sure exception information is saved in the log.
             exc_type, exc_info, exc_trace = sys.exc_info()
             print 'exception type:', str(exc_type)
             print 'exception info:', str(exc_info)
             traceback.print_tb(exc_trace)
         sys.exit(0)
 
     # check if all executables are available
     missing_execs = []
@@ skipping 30 matching lines @@
         main(sys.argv)
     except (getopt.GetoptError, ImportError):
         usage(sys.exc_info()[1], 1)
     except (FwError, flashrom_handler.FlashromHandlerError):
         MSG = 'Error: %s' % str(sys.exc_info()[1])
         print MSG
         CHROS_IF.log(MSG)
         sys.exit(1)
 
     sys.exit(0)