def _save_original_images(self, release_path):
"""Use the saved state to find all of the device images.
This will download running cr50 image and the device image.
Args:
release_path: The release path given by test args
"""
# Copy the prod and prepvt images from the DUT
_, prod_rw, prod_bid = self._original_state['device_prod_ver']
filename = 'prod_device_image_' + prod_rw
self._device_prod_image = os.path.join(self.resultsdir, filename)
self.host.get_file(cr50_utils.CR50_PROD, self._device_prod_image)
if cr50_utils.HasPrepvtImage(self.host):
_, prepvt_rw, prepvt_bid = self._original_state[
'device_prepvt_ver']
filename = 'prepvt_device_image_' + prepvt_rw
self._device_prepvt_image = os.path.join(self.resultsdir, filename)
self.host.get_file(cr50_utils.CR50_PREPVT,
self._device_prepvt_image)
prepvt_bid = cr50_utils.GetBoardIdInfoString(prepvt_bid)
else:
self._device_prepvt_image = None
prepvt_rw = None
prepvt_bid = None
if os.path.isfile(release_path):
self._original_cr50_image = release_path
logging.info('using supplied image')
return
# If the running cr50 image version matches the image on the DUT use
# the DUT image as the original image. If the versions don't match
# download the image from google storage
_, running_rw, running_bid = self.get_saved_cr50_original_version()
# Make sure prod_bid and running_bid are in the same format
prod_bid = cr50_utils.GetBoardIdInfoString(prod_bid)
running_bid = cr50_utils.GetBoardIdInfoString(running_bid)
if running_rw == prod_rw and running_bid == prod_bid:
logging.info('Using device cr50 prod image %s %s', prod_rw,
prod_bid)
self._original_cr50_image = self._device_prod_image
elif running_rw == prepvt_rw and running_bid == prepvt_bid:
logging.info('Using device cr50 prepvt image %s %s', prepvt_rw,
prepvt_bid)
self._original_cr50_image = self._device_prepvt_image
else:
logging.info('Downloading cr50 image %s %s', running_rw,
running_bid)
self._original_cr50_image = self.download_cr50_release_image(
running_rw, running_bid)[0]
def check_final_state(self, chip_bid_info):
"""Verify the update checking the chip board id and running image
Args:
chip_bid_info: A tuple of ints: chip_board_id, ~chip_board_id,
and flags.
Raises:
TestFail if the device did not update to the correct state
"""
state = self.get_cr50_device_state()
image_bid = cr50_utils.GetBoardIdInfoString(self.image_bid)
failed = []
if chip_bid_info != state['chip_bid']:
failed.append('cr50 chip board id')
if image_bid != state['cr50_image_bid']:
failed.append('cr50 image board id')
if self.image_rw != state['running_ver'][1]:
failed.append('cr50 image version')
if self.image_ver != state['device_prod_ver']:
failed.append('device prod image')
if self.image_ver != state['device_prepvt_ver']:
failed.append('device prepvt image')
if len(failed):
raise error.TestFail('Update failures: %s', ', '.join(failed))
def initialize(self,
host,
cmdline_args,
full_args,
restore_cr50_state=False,
cr50_dev_path='',
provision_update=False):
self._saved_state = self.NONE
self._raise_error_on_mismatch = not restore_cr50_state
self._provision_update = provision_update
super(Cr50Test, self).initialize(host, cmdline_args)
if not hasattr(self, 'cr50'):
raise error.TestNAError('Test can only be run on devices with '
'access to the Cr50 console')
logging.info('Test Args: %r', full_args)
self.can_set_ccd_level = (not self.cr50.using_ccd()
or self.cr50.testlab_is_on())
self.original_ccd_level = self.cr50.get_ccd_level()
self.original_ccd_settings = self.cr50.get_cap_dict(
info=self.cr50.CAP_SETTING)
self.host = host
tpm_utils.ClearTPMOwnerRequest(self.host, wait_for_ready=True)
# Clear the FWMP, so it can't disable CCD.
self.clear_fwmp()
if self.can_set_ccd_level:
# Lock cr50 so the console will be restricted
self.cr50.set_ccd_level('lock')
elif self.original_ccd_level != 'lock':
raise error.TestNAError(
'Lock the console before running cr50 test')
self._save_original_state()
# Verify cr50 is still running the correct version
cr50_qual_version = full_args.get('cr50_qual_version', '').strip()
if cr50_qual_version:
_, running_rw, running_bid = self.get_saved_cr50_original_version()
expected_rw, expected_bid_sym = cr50_qual_version.split('/')
expected_bid = cr50_utils.GetBoardIdInfoString(expected_bid_sym,
symbolic=False)
logging.debug('Running %s %s Expect %s %s', running_rw,
running_bid, expected_rw, expected_bid)
if running_rw != expected_rw or expected_bid != running_bid:
raise error.TestError('Not running %s' % cr50_qual_version)
# We successfully saved the device state
self._saved_state |= self.INITIAL_STATE
try:
self._save_node_locked_dev_image(cr50_dev_path)
self._save_original_images(full_args.get('release_path', ''))
# We successfully saved the device images
self._saved_state |= self.IMAGES
except:
if restore_cr50_state:
raise
def download_cr50_gs_image(self,
filename,
image_bid='',
bucket=None,
image_type=None):
"""Get the image from gs and save it in the autotest dir.
Args:
filename: The cr50 image basename
image_bid: the board id info list or string. It will be added to the
filename.
bucket: The gs bucket name
image_type: 'debug' or 'release'. This will be used to determine
the bucket if the bucket is not given.
Returns:
A tuple with the local path and version
"""
# Add the image bid string to the filename
if image_bid:
bid_str = cr50_utils.GetBoardIdInfoString(image_bid, symbolic=True)
filename += '.' + bid_str.replace(':', '_')
if not bucket:
bucket, filename = self.find_cr50_gs_image(filename, image_type)
remote_temp_dir = '/tmp/'
src = os.path.join(remote_temp_dir, filename)
dest = os.path.join(self.resultsdir, filename)
# Copy the image to the dut
gsutil_wrapper.copy_private_bucket(host=self.host,
bucket=bucket,
filename=filename,
destination=remote_temp_dir)
self.host.get_file(src, dest)
ver = cr50_utils.GetBinVersion(self.host, src)
# Compare the image board id to the downloaded image to make sure we got
# the right file
downloaded_bid = cr50_utils.GetBoardIdInfoString(ver[2], symbolic=True)
if image_bid and bid_str != downloaded_bid:
raise error.TestError('Could not download image with matching '
'board id wanted %s got %s' %
(bid_str, downloaded_bid))
return dest, ver
def save_board_id_locked_image(self, original_version, bid_path,
release_ver):
"""Get the board id locked image
Save the board id locked image. Try to use the local path or test args
to find the release board id locked image. If those aren't valid,
fallback to using the running cr50 board id locked image or a debug
image with the TEST board id.
Args:
original_version: The (ro ver, rw ver, and bid) of the running cr50
image.
bid_path: the path to the board id locked image
release_ver: If given it will be used to download the release image
with the given rw version and board id
"""
if os.path.isfile(bid_path):
# If the bid_path exists, use that.
self.board_id_locked_path = bid_path
# Install the image on the device to get the image version
dest = os.path.join('/tmp', os.path.basename(bid_path))
ver = cr50_utils.InstallImage(self.host, bid_path, dest)[1]
elif release_ver:
# Only use the release image if the release image is board id
# locked.
if '/' not in release_ver:
raise error.TestNAError(
'Release image is not board id locked.')
# split the release version into the rw string and board id string
release_rw, release_bid = release_ver.split('/', 1)
# Download a release image with the rw_version and board id
logging.info('Using %s %s release image for test', release_rw,
release_bid)
self.board_id_locked_path, ver = self.download_cr50_release_image(
release_rw, release_bid)
elif original_version[2]:
# If no valid board id args are given and the running image is
# board id locked, use it to run the test.
self.board_id_locked_path = self.get_saved_cr50_original_path()
ver = original_version
else:
devid = self.servo.get('cr50_devid')
self.board_id_locked_path, ver = self.download_cr50_debug_image(
devid, self.TEST_IMAGE_BID_INFO)
logging.info('Using %s DBG image for test', ver)
image_bid_info = cr50_utils.GetBoardIdInfoTuple(ver[2])
if not image_bid_info:
raise error.TestError('Need board id locked image to run test')
# Save the image board id info
self.test_bid_int, self.test_mask, self.test_flags = image_bid_info
self.test_bid_sym = cr50_utils.GetSymbolicBoardId(self.test_bid_int)
self.test_bid_str = cr50_utils.GetBoardIdInfoString(ver[2])
logging.info('Running test with bid locked image %s', ver)
self.image_versions[self.BID_LOCKED] = ver
def check_bid_settings(self, chip_bid_info, image_bid_str):
"""Compare the chip and image board ids.
Compare the image and chip board ids before changing the cr50 state.
Raise an error if the image will not be able to run with the requested
chip board id.
Args:
chip_bid_info: The chip board id info tuple
image_bid_str: the image board_id:mask:flags.
Raises:
TestFail if we will not be able to update to the image with the
given chip board id.
"""
# If the image isn't board id locked, it will run on all devices.
if chip_bid_info == cr50_utils.ERASED_CHIP_BID:
logging.info('Chip has no board id. It will run any image.')
return
if not image_bid_str:
logging.info('Image is not board id locked. It will run on all '
'devices.')
return
chip_bid, chip_bid_inv, chip_flags = chip_bid_info
chip_bid_str = cr50_utils.GetBoardIdInfoString(chip_bid_info,
symbolic=True)
image_bid, image_mask, image_flags = image_bid_str.split(':')
# Convert the image board id to integers
image_mask = int(image_mask, 16)
image_bid = cr50_utils.GetIntBoardId(image_bid)
image_flags = int(image_flags, 16)
errors = []
# All bits in the image mask must match between the image and chip board
# ids.
image_bid = image_bid & image_mask
chip_bid = chip_bid & image_mask
if image_bid != chip_bid:
errors.append('board id')
# All 1s in the image flags must also be 1 in the chip flags
chip_flags = chip_flags & image_flags
if image_flags != chip_flags:
errors.append('flags')
if len(errors):
raise error.TestFail('Image will not be able to run with the '
'given %s: chip %s image %s' % (' and '.join(errors),
chip_bid_str, image_bid_str))
def run_once(self):
"""The method called by the control file to start the update."""
chip_bid_info, set_bid = self.get_new_chip_bid()
logging.info('Updating to image %s with chip board id %s',
self.image_ver, cr50_utils.GetBoardIdInfoString(chip_bid_info))
# Make sure the image will be able to run with the given chip board id.
self.check_bid_settings(chip_bid_info, self.image_bid)
# If the release version is not newer than the running rw version, we
# have to do a rollback.
running_rw = cr50_utils.GetRunningVersion(self.host)[1]
rollback = (cr50_utils.GetNewestVersion(running_rw, self.image_rw) !=
self.image_rw)
# You can only update the board id or update to an old image by rolling
# back from a dev image.
need_rollback = rollback or set_bid
if need_rollback and not self.has_saved_cr50_dev_path():
raise error.TestFail('Need a dev image to rollback to %s or update'
'the board id')
# Copy the image onto the DUT. cr50-update uses both cr50.bin.prod and
# cr50.bin.prepvt in /opt/google/cr50/firmware/, so copy it to both
# places. Rootfs verification has to be disabled to do the copy.
self.rootfs_verification_disable()
cr50_utils.InstallImage(self.host, self.local_path,
cr50_utils.CR50_PREPVT)
cr50_utils.InstallImage(self.host, self.local_path,
cr50_utils.CR50_PROD)
# Update to the dev image if there needs to be a rollback.
if need_rollback:
dev_path = self.get_saved_cr50_dev_path()
self.cr50_update(dev_path)
# If we aren't changing the board id, don't pass any values into the bid
# args.
chip_bid = chip_bid_info[0] if need_rollback else None
chip_flags = chip_bid_info[2] if need_rollback else None
# Update to the new image, setting the chip board id and rolling back if
# necessary.
self.cr50_update(self.local_path, rollback=need_rollback,
chip_bid=chip_bid, chip_flags=chip_flags)
cr50_utils.ClearUpdateStateAndReboot(self.host)
# Verify everything updated correctly
self.check_final_state(chip_bid_info)
def is_running_version(self, rw_ver, bid_str):
"""Returns True if the running image has the same rw ver and bid
Args:
rw_ver: rw version string
bid_str: A symbolic or non-smybolic board id
Returns:
True if cr50 is running an image with the given rw version and
board id.
"""
running_rw = self.cr50.get_version()
running_bid = self.cr50.get_active_board_id_str()
# Convert the image board id to a non symbolic board id
bid_str = cr50_utils.GetBoardIdInfoString(bid_str, symbolic=False)
return running_rw == rw_ver and bid_str == running_bid
# supported in board id locked images .22 and above. Any image that is
# board id locked will have support for getting the image board id.
#
# If board id is not supported on the device, return None. This is
# still expected on all current non board id locked release images.
try:
version_info = self.get_version_info(self.ACTIVE_BID)
except error.TestFail, e:
logging.info(str(e))
logging.info('Cannot use the version to get the board id')
return None
if self.BID_ERROR in version_info[4]:
raise error.TestError(version_info)
bid = version_info[4].split()[1]
return cr50_utils.GetBoardIdInfoString(bid)
def get_version(self):
"""Get the RW version"""
return self.get_active_version_info()[1].strip()
def using_servo_v4(self):
"""Returns true if the console is being served using servo v4"""
return 'servo_v4' in self._servo.get_servo_version()
def using_ccd(self):
"""Returns true if the console is being served using CCD"""
return 'ccd_cr50' in self._servo.get_servo_version()
def ccd_is_enabled(self):
"""Return True if ccd is enabled.