551 lines
23 KiB
Python
551 lines
23 KiB
Python
# Copyright 2020 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, re
|
|
import os
|
|
import six
|
|
|
|
from autotest_lib.client.common_lib import error
|
|
from autotest_lib.client.common_lib import utils
|
|
from autotest_lib.server.cros.faft.firmware_test import FirmwareTest
|
|
|
|
|
|
class firmware_CsmeFwUpdate(FirmwareTest):
|
|
"""
|
|
This tests csme rw firmware update feature by changing the me_rw
|
|
image in firmware main regions with a different version
|
|
|
|
Accepted --args names:
|
|
old_bios = specify this argument to use a different bios
|
|
than shellball default for downgrade
|
|
|
|
"""
|
|
version = 1
|
|
ORIGINAL_BIOS = "/usr/local/tmp/bios_original.bin"
|
|
DOWNGRADE_BIOS = "/usr/local/tmp/bios_downgrade.bin"
|
|
# Region to use for flashrom wp-region commands
|
|
WP_REGION = 'WP_RO'
|
|
MODE = 'recovery'
|
|
CBFSTOOL = 'cbfstool'
|
|
CMPTOOL = 'cmp'
|
|
|
|
def initialize(self, host, cmdline_args, dev_mode = False):
|
|
# Parse arguments from command line
|
|
dict_args = utils.args_to_dict(cmdline_args)
|
|
super(firmware_CsmeFwUpdate, self).initialize(host, cmdline_args)
|
|
|
|
self.bios_input = None
|
|
self.restore_required = False
|
|
self.downgrade_bios = None
|
|
self.spi_bios = None
|
|
self._orig_sw_wp = None
|
|
self._original_hw_wp = None
|
|
arg_name = "old_bios"
|
|
arg_value = dict_args.get(arg_name)
|
|
if arg_value:
|
|
logging.info('%s=%s', arg_name, arg_value)
|
|
image_path = os.path.expanduser(arg_value)
|
|
if not os.path.isfile(image_path):
|
|
raise error.TestError(
|
|
"Specified file does not exist: %s=%s"
|
|
% (arg_name, image_path))
|
|
self.bios_input = image_path
|
|
else:
|
|
logging.info("No bios specified. Using default " \
|
|
"shellball bios for downgrade")
|
|
|
|
self.backup_firmware()
|
|
self.switcher.setup_mode('dev' if dev_mode else 'normal',
|
|
allow_gbb_force=True)
|
|
|
|
# Save write protect configuration and enable it
|
|
logging.info("Enabling Write protection")
|
|
self._orig_sw_wp = self.faft_client.bios.get_write_protect_status()
|
|
self._original_hw_wp = 'on' in self.servo.get('fw_wp_state')
|
|
self.set_ap_write_protect_and_reboot(False)
|
|
self.faft_client.bios.set_write_protect_region(self.WP_REGION, True)
|
|
self.set_ap_write_protect_and_reboot(True)
|
|
|
|
# Make sure that the shellball is retained over subsequent power cycles
|
|
self.blocking_sync()
|
|
|
|
def cleanup(self):
|
|
"""
|
|
Flash the backed up firmware at the end of test
|
|
|
|
"""
|
|
self.faft_client.system.remove_file(self.ORIGINAL_BIOS)
|
|
self.faft_client.system.remove_file(self.DOWNGRADE_BIOS)
|
|
self.set_ap_write_protect_and_reboot(False)
|
|
|
|
try:
|
|
if self.is_firmware_saved() and self.restore_required:
|
|
logging.info("Restoring Original Image")
|
|
self.restore_firmware()
|
|
except (EnvironmentError, six.moves.xmlrpc_client.Fault,
|
|
error.AutoservError, error.TestBaseException):
|
|
logging.error("Problem restoring firmware:", exc_info=True)
|
|
|
|
try:
|
|
# Restore the old write-protection value at the end of the test.
|
|
logging.info("Restoring write protection configuration")
|
|
if self._orig_sw_wp:
|
|
self.faft_client.bios.set_write_protect_range(
|
|
self._orig_sw_wp['start'],
|
|
self._orig_sw_wp['length'],
|
|
self._orig_sw_wp['enabled'])
|
|
except (EnvironmentError, six.moves.xmlrpc_client.Fault,
|
|
error.AutoservError, error.TestBaseException):
|
|
logging.error("Problem restoring software write-protect:",
|
|
exc_info = True)
|
|
|
|
if self._original_hw_wp is not None:
|
|
self.set_ap_write_protect_and_reboot(self._original_hw_wp)
|
|
|
|
self.switcher.mode_aware_reboot(reboot_type = 'cold')
|
|
super(firmware_CsmeFwUpdate, self).cleanup()
|
|
|
|
def read_current_bios_and_save(self):
|
|
"""
|
|
Dumps current bios from spi to two file.(working copy and backup)
|
|
|
|
@returns the working copy file path
|
|
|
|
"""
|
|
# Dump the current spi bios to file
|
|
self.spi_bios = self.ORIGINAL_BIOS
|
|
logging.info("Copying current bios image to %s for upgrade " \
|
|
"test", self.spi_bios)
|
|
self.faft_client.bios.dump_whole(self.spi_bios)
|
|
|
|
# Get the downgrade bios image from user or from shellball
|
|
self.downgrade_bios = self.DOWNGRADE_BIOS
|
|
if self.bios_input:
|
|
logging.info("Copying user given bios image to %s for downgrade " \
|
|
"test", self.downgrade_bios)
|
|
self._client.send_file(self.bios_input, self.downgrade_bios)
|
|
else:
|
|
logging.info("Copying bios image from update shellball to %s " \
|
|
"for downgrade test", self.downgrade_bios)
|
|
self.faft_client.updater.extract_shellball()
|
|
cbfs_work_dir = self.faft_client.updater.cbfs_setup_work_dir()
|
|
shellball_bios = os.path.join(cbfs_work_dir,
|
|
self.faft_client.updater.get_bios_relative_path())
|
|
command = "cp %s %s" % (shellball_bios, self.downgrade_bios)
|
|
self.faft_client.system.run_shell_command(command)
|
|
|
|
def check_fmap_format(self, image_path):
|
|
"""
|
|
Checks FMAP format used by the Image for CSME update
|
|
|
|
@param image_path: path of the image
|
|
@returns the fmap format string
|
|
|
|
"""
|
|
# Check if ME_RW_A is present in the image
|
|
logging.info("Checking if seperate CBFS is used for CSE RW in " \
|
|
"image : %s", image_path)
|
|
command = "futility dump_fmap -F %s | grep ME_RW_A" % image_path
|
|
output = self.faft_client.system.run_shell_command_get_output(
|
|
command, True)
|
|
if output:
|
|
logging.info("Image uses seperate CBFS for CSE RW")
|
|
return "CSE_RW_SEPARATE_CBFS"
|
|
else:
|
|
return "DEFAULT"
|
|
|
|
def check_if_me_blob_exist_in_image(self, image_path):
|
|
"""
|
|
Checks if me_blob exists in FW MAIN section of an image
|
|
|
|
@param image_path: path of the image
|
|
@returns True if present else False
|
|
|
|
"""
|
|
# Check if me_rw.version present FW_MAIN region
|
|
logging.info("Checking if me_rw.version file " \
|
|
"present in image : %s", image_path )
|
|
command = "cbfstool %s print -r FW_MAIN_A " \
|
|
"| grep me_rw.version" % image_path
|
|
output = self.faft_client.system.run_shell_command_get_output(
|
|
command, True)
|
|
if output:
|
|
available = True
|
|
logging.info("me_rw.version present in image")
|
|
else:
|
|
available = False
|
|
logging.info("me_rw.version not present in image")
|
|
|
|
return available
|
|
|
|
def extract_me_rw_version_from_bin(self, me_blob, version_offset = 0):
|
|
"""
|
|
Extract me_rw version from given me_rw blob. Version is first 8
|
|
bytes in the blob
|
|
|
|
@param me_blob: me_rw blob (old fmap) or me_rw.version blob
|
|
@param version_offset: version filed offset in the blob
|
|
@returns the CSME RW version string
|
|
|
|
"""
|
|
ver_res = ""
|
|
logging.info("Extracting version field from ME blob")
|
|
|
|
command = ("hexdump -C %s | cut -c 9- | cut -d'|' -f 2"%me_blob )
|
|
output = self.faft_client.system.run_shell_command_get_output(
|
|
command, True)
|
|
ver_res = output[0].strip(".")
|
|
logging.info("Version : %s", ver_res)
|
|
return ver_res
|
|
|
|
def get_image_fwmain_me_rw_version(self,
|
|
bios,
|
|
region = "FW_MAIN_A"):
|
|
"""
|
|
Extract CSME RW version of the me_rw blob of the given
|
|
region in the given bios
|
|
|
|
@param bios: Bios path
|
|
@param region: region which contains me_rw blob
|
|
@returns the CSME RW version string
|
|
|
|
"""
|
|
# Extract me_rw.version and check version.
|
|
cbfs_name = "me_rw.version"
|
|
temp_dir = self.faft_client.system.create_temp_dir()
|
|
me_blob = os.path.join(temp_dir, cbfs_name)
|
|
|
|
cmd_status = self.faft_client.updater.cbfs_extract(cbfs_name,
|
|
'',(region, ),
|
|
me_blob,'x86',bios)
|
|
|
|
if cmd_status is None:
|
|
self.faft_client.system.remove_dir(temp_dir)
|
|
raise error.TestError("Failed to extract ME blob from " \
|
|
"the given bios : %s" % bios)
|
|
|
|
version = self.extract_me_rw_version_from_bin(me_blob)
|
|
self.faft_client.system.remove_dir(temp_dir)
|
|
return version
|
|
|
|
def get_current_me_rw_version(self):
|
|
"""
|
|
Reads the current active CSME RW Version from coreboot logs
|
|
|
|
@returns the CSME RW version string
|
|
|
|
"""
|
|
logging.info("Extracting cselite version info from coreboot logs")
|
|
command = "cbmem -1 | grep 'cse_lite:'"
|
|
output = self.faft_client.system.run_shell_command_get_output(
|
|
command, True)
|
|
logging.info(output)
|
|
# Offset of rw portion in ME region
|
|
me_cse_rw_info = re.search(r"(cse_lite: RW version = )" \
|
|
"([0-9]*\.[0-9]*\.[0-9]*\.[0-9]*)","".join(output))
|
|
|
|
if me_cse_rw_info:
|
|
me_version = me_cse_rw_info.group(2)
|
|
else:
|
|
raise error.TestError("cse_lite RW info not"
|
|
" found in coreboot logs!")
|
|
return me_version
|
|
|
|
def verify_me_version(self, expected_version, expected_slot):
|
|
"""
|
|
Reads the current active CSME RW Version from coreboot logs
|
|
and compares with expected version
|
|
|
|
@param expected_version: Expected CSME RW Version string
|
|
@returns True is matching else False
|
|
|
|
"""
|
|
me_version = self.get_current_me_rw_version()
|
|
command = "crossystem mainfw_act"
|
|
output = self.faft_client.system.run_shell_command_get_output(
|
|
command, True)
|
|
main_fw_act = output[0]
|
|
|
|
logging.info("Expected mainfw_act : %s\n" \
|
|
"Current mainfw_act : %s\n" \
|
|
"Expected ME RW Version : %s\n" \
|
|
"Current ME RW Version : %s\n",
|
|
expected_slot, main_fw_act, expected_version, me_version)
|
|
|
|
if (expected_version not in me_version) or \
|
|
(expected_slot not in main_fw_act):
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def cmp_local_files(self,
|
|
local_filename_1,
|
|
local_filename_2):
|
|
"""
|
|
Compare two local files
|
|
|
|
@param local_filename_1: Path to first local file to compare
|
|
@param local_filename_2: Path to second local file to compare
|
|
|
|
@returns "None" if files are identical, or
|
|
string response from "cmp" command if files differ.
|
|
"""
|
|
compare_cmd = ('%s %s %s' %
|
|
(self.CMPTOOL, local_filename_1, local_filename_2))
|
|
try:
|
|
return self.faft_client.system.run_shell_command_get_output(
|
|
compare_cmd, True)
|
|
except error.CmdError:
|
|
# already logged by run_shell_command()
|
|
return None
|
|
|
|
def cbfs_read(self,
|
|
filename,
|
|
extension,
|
|
region='ME_RW_A',
|
|
local_filename=None,
|
|
arch=None,
|
|
bios=None):
|
|
"""
|
|
Reads an arbitrary file from cbfs.
|
|
|
|
@param filename: Filename in cbfs, including extension
|
|
@param extension: Extension of the file, including '.'
|
|
@param region: region (the default is just 'ME_RW_A')
|
|
@param local_filename: Path to use on the DUT, overriding the default in
|
|
the cbfs work dir.
|
|
@param arch: Specific machine architecture to extract (default unset)
|
|
@param bios: Image from which the cbfs file to be read
|
|
@return: The full path of the read file, or None
|
|
"""
|
|
if bios is None:
|
|
bios = os.path.join(self._cbfs_work_path, self._bios_path)
|
|
|
|
cbfs_filename = filename + extension
|
|
if local_filename is None:
|
|
local_filename = os.path.join(self._cbfs_work_path,
|
|
filename + extension)
|
|
|
|
extract_cmd = ('%s %s extract -r %s -n %s%s -f %s' %
|
|
(self.CBFSTOOL, bios, region, filename,
|
|
extension, local_filename))
|
|
if arch:
|
|
extract_cmd += ' -m %s' % arch
|
|
|
|
try:
|
|
self.faft_client.system.run_shell_command(extract_cmd)
|
|
return os.path.abspath(local_filename)
|
|
except error.CmdError:
|
|
# already logged by run_shell_command()
|
|
return None
|
|
|
|
def abort_if_me_rw_blobs_identical(self,
|
|
downgrade_bios,
|
|
spi_bios):
|
|
"""
|
|
Determine if the CSME RW blob in the downgrade bios image is
|
|
different from the CSME RW blob in the spi bios image.
|
|
|
|
@param downgrade_bios: Downgrade bios path
|
|
@param spi_bios: Bios from spi flash path
|
|
@returns "None" if CSME RW blobs are identical, or
|
|
string response from "diff" command if blobs differ.
|
|
"""
|
|
# Extract me_rw blobs
|
|
cbfs_name = "me_rw"
|
|
downgrade_name = "me_rw"
|
|
spi_me_a_name = "me_rw_spi_a"
|
|
spi_me_b_name = "me_rw_spi_b"
|
|
temp_dir = self.faft_client.system.create_temp_dir()
|
|
downgrade_me_blob = os.path.join(temp_dir, downgrade_name)
|
|
spi_me_a_blob = os.path.join(temp_dir, spi_me_a_name)
|
|
spi_me_b_blob = os.path.join(temp_dir, spi_me_b_name)
|
|
|
|
downgrade_rw_path = self.cbfs_read(cbfs_name, '','ME_RW_A',
|
|
downgrade_me_blob, 'x86',
|
|
downgrade_bios)
|
|
if downgrade_rw_path is None:
|
|
self.faft_client.system.remove_dir(temp_dir)
|
|
raise error.TestError("Failed to read %s me_rw blob from " \
|
|
"the downgrade bios %s" % (downgrade_me_blob,
|
|
downgrade_bios))
|
|
|
|
spi_rw_a_path = self.cbfs_read(cbfs_name, '','ME_RW_A', spi_me_a_blob,
|
|
'x86', spi_bios)
|
|
if spi_rw_a_path is None:
|
|
self.faft_client.system.remove_dir(temp_dir)
|
|
raise error.TestError("Failed to read %s me_rw_a blob from " \
|
|
"the downgrade bios %s" % (spi_me_a_blob,
|
|
spi_bios))
|
|
|
|
spi_rw_b_path = self.cbfs_read(cbfs_name, '','ME_RW_B', spi_me_b_blob,
|
|
'x86', spi_bios)
|
|
if spi_rw_b_path is None:
|
|
self.faft_client.system.remove_dir(temp_dir)
|
|
raise error.TestError("Failed to read %s me_rw_b blob from " \
|
|
"the spi bios %s" % (spi_me_b_blob, spi_bios))
|
|
|
|
# Are the blobs different?
|
|
diff_a = self.cmp_local_files(downgrade_rw_path, spi_rw_a_path)
|
|
diff_b = self.cmp_local_files(downgrade_rw_path, spi_rw_b_path)
|
|
if diff_a and diff_b:
|
|
logging.info("CSME RW version is same, but downgrade me_rw " \
|
|
"differs from both me_rw blobs in spi flash.")
|
|
elif diff_a:
|
|
logging.info("CSME RW version is same, but downgrade me_rw and " \
|
|
"FW_MAIN_A me_rw differ.")
|
|
elif diff_b:
|
|
logging.info("CSME RW version is same, but downgrade me_rw and " \
|
|
"FW_MAIN_B me_rw differ.")
|
|
else:
|
|
# Blobs are the same
|
|
self.faft_client.system.remove_dir(temp_dir)
|
|
raise error.TestNAError("CSME RW blobs are the same in downgrade " \
|
|
"and spi bios. Test skipped.")
|
|
|
|
self.faft_client.system.remove_dir(temp_dir)
|
|
|
|
def prepare_shellball(self, bios_image, append = None):
|
|
"""Prepare a shellball with the given bios image.
|
|
|
|
@param bios_image: bios image with shellball to be created
|
|
@param append: string to be updated with shellball name
|
|
"""
|
|
logging.info("Preparing shellball with %s", bios_image)
|
|
self.faft_client.updater.reset_shellball()
|
|
# Copy the given bois to shellball
|
|
extract_dir = self.faft_client.updater.get_work_path()
|
|
bios_rel = self.faft_client.updater.get_bios_relative_path()
|
|
bios_shell = os.path.join(extract_dir, bios_rel)
|
|
command = "cp %s %s" % (bios_image, bios_shell)
|
|
output = self.faft_client.system.run_shell_command_get_output(
|
|
command, True)
|
|
if output:
|
|
raise error.TestError("File not found!: %s" % bios_image)
|
|
# Reload and repack the shellball
|
|
self.faft_client.updater.reload_images()
|
|
self.faft_client.updater.repack_shellball(append)
|
|
|
|
def run_shellball(self, append):
|
|
"""Run chromeos-firmwareupdate
|
|
|
|
@param append: additional piece to add to shellball name
|
|
"""
|
|
|
|
# make sure we restore firmware after the test, if it tried to flash.
|
|
self.restore_required = True
|
|
|
|
# Update only host firmware
|
|
options = ['--host_only', '--wp=1']
|
|
logging.info("Updating RW firmware using " \
|
|
"chromeos_firmwareupdate")
|
|
logging.info(
|
|
"Update command : chromeos_firmwareupdate-%s --mode=%s "
|
|
" %s", append, self.MODE, ' '.join(options))
|
|
result = self.run_chromeos_firmwareupdate(
|
|
self.MODE, append, options, ignore_status = True)
|
|
|
|
if result.exit_status == 255:
|
|
raise error.TestError("DUT network dropped during update.")
|
|
elif result.exit_status != 0:
|
|
if ('Good. It seems nothing was changed.' in result.stdout):
|
|
logging.info("DUT already matched the image; updater aborted.")
|
|
else:
|
|
raise error.TestError("Firmware updater unexpectedly" \
|
|
"failed (rc=%s)" % result.exit_status)
|
|
|
|
def run_once(self):
|
|
if not ('x86' in self.faft_config.ec_capability):
|
|
raise error.TestNAError("The firmware_CsmeFwUpdate test is only " \
|
|
"applicable to Intel platforms. Skipping " \
|
|
"test.")
|
|
|
|
# Read current bios from SPI and create a backup copy
|
|
self.read_current_bios_and_save()
|
|
|
|
if not self.check_if_me_blob_exist_in_image(self.spi_bios):
|
|
raise error.TestNAError("The me_rw blob is not present in the " \
|
|
"current bios. Skipping test.")
|
|
|
|
# Check fmap scheme of the bios read from SPI
|
|
spi_bios_fmap_ver = self.check_fmap_format(self.spi_bios)
|
|
|
|
# Check fmap scheme of the default bios in shellball
|
|
downgrade_bios_fmap = self.check_fmap_format(self.downgrade_bios)
|
|
|
|
# Check if me_rw blob is present in FW_MAIN
|
|
if not self.check_if_me_blob_exist_in_image(self.downgrade_bios):
|
|
raise error.TestNAError("Test setup issue : me_rw blob is not " \
|
|
"present in downgrade bios.")
|
|
|
|
# Check if both of the bios versions use same fmap structure for me_rw
|
|
if downgrade_bios_fmap not in spi_bios_fmap_ver:
|
|
raise error.TestError("Test setup issue : FMAP format is " \
|
|
"different in current and downgrade bios.")
|
|
|
|
# Get the version of me_rw in the downgrade bios
|
|
downgrade_me_version = self.get_image_fwmain_me_rw_version( \
|
|
self.downgrade_bios)
|
|
|
|
# Get the version of me_rw in the spi bios
|
|
spi_me_version = self.get_image_fwmain_me_rw_version(self.spi_bios)
|
|
|
|
# Get active CSME RW version from cbmem -1
|
|
active_csme_rw_version = self.get_current_me_rw_version()
|
|
|
|
logging.info("Active CSME RW Version : %s\n" \
|
|
"FW main CSME RW Version SPI Image : %s\n" \
|
|
"FW main CSME RW Version downgrade Image: %s\n",
|
|
active_csme_rw_version, spi_me_version,
|
|
downgrade_me_version)
|
|
|
|
# Abort if downgrade me_rw version is same as spi me_rw version
|
|
if (spi_me_version in downgrade_me_version):
|
|
# Version is the same, abort test if blob content is the same
|
|
self.abort_if_me_rw_blobs_identical(self.downgrade_bios,
|
|
self.spi_bios)
|
|
|
|
for slot in ["A", "B"]:
|
|
operation = "downgrade"
|
|
# Create a shellball with downgrade bios
|
|
self.prepare_shellball(self.downgrade_bios, operation)
|
|
|
|
logging.info("Downgrading RW section. Downgrade ME " \
|
|
"Version: %s", downgrade_me_version)
|
|
# Run firmware updater downgrade the bios RW
|
|
self.run_shellball(operation)
|
|
|
|
# Set fw_try_next to slot and reboot to trigger csme update
|
|
logging.info("Setting fw_try_next to %s: ", slot)
|
|
self.faft_client.system.set_fw_try_next(slot)
|
|
self.switcher.mode_aware_reboot(reboot_type = 'cold')
|
|
|
|
# Check if the Active CSME RW version changed to downgrade version
|
|
if not self.verify_me_version(downgrade_me_version, slot):
|
|
raise error.TestError("CSME RW Downgrade using "
|
|
"FW_MAIN_%s is Failed!" % slot)
|
|
logging.info("CSME RW Downgrade using FW_MAIN_%s is "
|
|
"successful", slot)
|
|
|
|
operation = "upgrade"
|
|
# Create a shellball with the original spi bios
|
|
self.prepare_shellball(self.spi_bios, operation)
|
|
|
|
logging.info("Upgrading RW Section. Upgrade ME " \
|
|
"Version: %s", spi_me_version)
|
|
# Run firmware updater and update RW section with shellball
|
|
self.run_shellball(operation)
|
|
|
|
# Set fw_try_next to slot and reboot to trigger csme update
|
|
logging.info("Setting fw_try_next to %s: ", slot)
|
|
self.faft_client.system.set_fw_try_next(slot)
|
|
self.switcher.mode_aware_reboot(reboot_type = 'cold')
|
|
|
|
# Check if the Active CSME RW version changed to original version
|
|
if not self.verify_me_version(spi_me_version, slot):
|
|
raise error.TestError("CSME RW Upgrade using "
|
|
"FW_MAIN_%s is Failed!" % slot)
|
|
logging.info("CSME RW Upgrade using FW_MAIN_%s is "
|
|
"successful", slot)
|