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 add_image_to_update_order(self, image_name, image_path, ver=None):
"""Process the image. Add it to the update_order list and images dict.
Copy the image to the DUT and get version information.
Store the image information in the images dictionary and add it to the
update_order list.
@param image_name: string that is what the image should be called. Used
as the key in the images dict.
@param image_path: the path for the image.
@param ver: If the image path isn't specified, this will be used to find
the cr50 image in gs://chromeos-localmirror/distfiles.
"""
tmp_file = '/tmp/%s.bin' % image_name
if not os.path.isfile(image_path):
image_path, ver = self.fetch_image(ver)
else:
_, ver = cr50_utils.InstallImage(self.host, image_path, tmp_file)
ver_str = cr50_utils.GetVersionString(ver)
self.update_order.append(image_name)
self.images[image_name] = (ver, ver_str, image_path)
logging.info("%s stored at %s with version %s", image_name, image_path,
ver_str)
def replace_image_if_newer(self, universal_rw_ver, path):
"""Replace the image at path if it is newer than the universal image
Copy the universal image to path, if the universal image is older than
the image at path.
Args:
universal_rw_ver: The rw version string of the universal image
path: The path of the image that may need to be replaced.
"""
if self.host.path_exists(path):
dut_ver = cr50_utils.GetBinVersion(self.host, path)[1]
# If the universal version is lower than the DUT image, install the
# universal image. It has the lowest version of any image in the
# test, so cr50-update won't try to update cr50 at any point during
# the test.
install_image = (cr50_utils.GetNewestVersion(dut_ver,
universal_rw_ver) == dut_ver)
else:
# If the DUT doesn't have a file at path, install the image.
install_image = True
if install_image:
# Disable rootfs verification so we can copy the image to the DUT
self.rootfs_verification_disable()
# Copy the universal image onto the DUT.
dest, ver = cr50_utils.InstallImage(self.host, self.universal_path,
path)
logging.info('Copied %s to %s', ver, dest)
def restore_original_image(self):
"""Update to the image that was running at the start of the test.
Returns SUCCESS if the update was successful or the update error if it
failed.
"""
rv = self.SUCCESS
original_ver, _, original_path = self.images[self.ORIGINAL_NAME]
original_rw = original_ver[1]
cr50_utils.InstallImage(self.host, original_path)
_, running_rw, is_dev = self.cr50.get_active_version_info()
new_rw = cr50_utils.GetNewestVersion(running_rw, original_rw)
# If Cr50 is running the original image, then no update is needed.
if new_rw is None:
return rv
try:
# If a rollback is needed, update to the dev image so it can
# rollback to the original image.
if new_rw != original_rw and not is_dev:
logging.info("Updating to dev image to enable rollback")
self.cr50_update(self.images[self.DEV_NAME][2])
logging.info("Updating to the original image %s",
original_rw)
self.cr50_update(original_path, rollback=True)
except Exception, e:
logging.info("cleanup update from %s to %s failed", running_rw,
original_rw)
logging.debug(e)
rv = e
def run_update(self, image_name, use_usb_update=False):
"""Copy the image to the DUT and upate to it.
Normal updates will use the cr50-update script to update. If a rollback
is True, use usb_update to flash the image and then use the 'rw'
commands to force a rollback.
@param image_name: the key in the images dict that can be used to
retrieve the image info.
@param use_usb_update: True if usb_updater should be used directly
instead of running the update script.
"""
self.cr50.ccd_disable()
# Get the current update information
image_ver, image_ver_str, image_path = self.images[image_name]
dest, ver = cr50_utils.InstallImage(self.host, image_path)
assert ver == image_ver, "Install failed"
image_rw = image_ver[1]
running_ver = cr50_utils.GetRunningVersion(self.host)
running_ver_str = cr50_utils.GetVersionString(running_ver)
# If the given image is older than the running one, then we will need
# to do a rollback to complete the update.
rollback = (cr50_utils.GetNewestVersion(running_ver[1], image_rw) !=
image_rw)
logging.info("Attempting %s from %s to %s",
"rollback" if rollback else "update", running_ver_str,
image_ver_str)
# If a rollback is needed, flash the image into the inactive partition,
# on or use usb_update to update to the new image if it is requested.
if use_usb_update or rollback:
self.cr50_update(dest, rollback=rollback,
erase_nvmem=self.erase_nvmem)
self.check_state((self.checkers.crossystem_checker,
{'mainfw_type': 'normal'}))
# Running the usb update or rollback will enable ccd. Disable it again.
self.cr50.ccd_disable()
# Get the last cr50 update related message from /var/log/messages
last_message = cr50_utils.CheckForFailures(self.host, '')
# Clear the update state and reboot, so cr50-update will run again.
cr50_utils.ClearUpdateStateAndReboot(self.host)
# Verify the system boots normally after the update
self.check_state((self.checkers.crossystem_checker,
{'mainfw_type': 'normal'}))
# Verify the version has been updated and that there have been no
# unexpected usb_updater exit codes.
cr50_utils.VerifyUpdate(self.host, image_ver, last_message)
logging.info("Successfully updated from %s to %s %s", running_ver_str,
image_name, image_ver_str)
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 get_local_image(self, release_path):
"""Get the version of the local image.
Args:
release_path: The local path to the cr50 image
Returns:
the local path, image version tuple
"""
ver = cr50_utils.InstallImage(self.host, release_path,
'/tmp/release.bin')[1]
return release_path, ver
def _cr50_run_update(self, path):
"""Install the image at path onto cr50
Args:
path: the location of the image to update to
Returns:
the rw version of the image
"""
tmp_dest = '/tmp/' + os.path.basename(path)
dest, image_ver = cr50_utils.InstallImage(self.host, path, tmp_dest)
cr50_utils.UsbUpdater(self.host, ['-s', dest])
return image_ver[1]
def _restore_original_state(self):
"""Restore the original cr50 related device state."""
if not (self._saved_state & self.IMAGES):
logging.warning('Did not save the original images. Cannot restore '
'state')
return
# Remove the prepvt image if the test installed one.
if (not self._original_state['has_prepvt']
and cr50_utils.HasPrepvtImage(self.host)):
self.host.run('rm %s' % cr50_utils.CR50_PREPVT)
# If rootfs verification has been disabled, copy the cr50 device image
# back onto the DUT.
if self._rootfs_verification_is_disabled():
cr50_utils.InstallImage(self.host, self._device_prod_image,
cr50_utils.CR50_PROD)
# Install the prepvt image if there was one.
if self._device_prepvt_image:
cr50_utils.InstallImage(self.host, self._device_prepvt_image,
cr50_utils.CR50_PREPVT)
chip_bid_info = self._original_state['chip_bid']
bid_is_erased = chip_bid_info == cr50_utils.ERASED_CHIP_BID
chip_bid = None if bid_is_erased else chip_bid_info[0]
chip_flags = None if bid_is_erased else chip_bid_info[2]
# Update to the original image and erase the board id
self._restore_original_image(chip_bid, chip_flags)
# Set the RLZ code
cr50_utils.SetRLZ(self.host, self._original_state['rlz'])
# Verify everything is still the same
mismatch = self._check_original_state()
if mismatch:
raise error.TestError('Could not restore state: %s' % mismatch)
logging.info('Successfully restored the original cr50 state')
def run_update(self, image_name, use_usb_update=False):
"""Copy the image to the DUT and upate to it.
Normal updates will use the cr50-update script to update. If a rollback
is True, use usb_update to flash the image and then use the 'rw'
commands to force a rollback.
@param image_name: the key in the images dict that can be used to
retrieve the image info.
@param use_usb_update: True if usb_updater should be used directly
instead of running the update script.
"""
self.cr50.ccd_disable()
# Get the current update information
image_ver, image_ver_str, image_path = self.images[image_name]
dest, ver = cr50_utils.InstallImage(self.host, image_path,
self.device_update_path)
assert ver == image_ver, "Install failed"
image_rw = image_ver[1]
running_ver = cr50_utils.GetRunningVersion(self.host)
running_ver_str = cr50_utils.GetVersionString(running_ver)
# If the given image is older than the running one, then we will need
# to do a rollback to complete the update.
rollback = (cr50_utils.GetNewestVersion(running_ver[1], image_rw) !=
image_rw)
logging.info("Attempting %s from %s to %s",
"rollback" if rollback else "update", running_ver_str,
image_ver_str)
# If a rollback is needed, flash the image into the inactive partition,
# on or use usb_update to update to the new image if it is requested.
if use_usb_update or rollback:
self.cr50_update(image_path,
rollback=rollback,
chip_bid=self.chip_bid,
chip_flags=self.chip_flags)
self.check_state((self.checkers.crossystem_checker, {
'mainfw_type': 'normal'
}))
# Cr50 is going to reject an update if it hasn't been up for more than
# 60 seconds. Wait until that passes before trying to run the update.
self.cr50.wait_until_update_is_allowed()
# Running the usb update or rollback will enable ccd. Disable it again.
self.cr50.ccd_disable()
# Get the last cr50 update related message from /var/log/messages
last_message = cr50_utils.CheckForFailures(self.host, '')
if self.test_post_install:
self.post_install()
else:
self.startup_install()
# The cr50 updates happen over /dev/tpm0. It takes a while. After
# cr50-update has finished, cr50 should reboot. Wait until this happens
# before sending anymore commands.
self.cr50.wait_for_reboot()
# Verify the system boots normally after the update
self.check_state((self.checkers.crossystem_checker, {
'mainfw_type': 'normal'
}))
# Verify the version has been updated and that there have been no
# unexpected usb_updater exit codes.
cr50_utils.VerifyUpdate(self.host, image_ver, last_message)
logging.info("Successfully updated from %s to %s %s", running_ver_str,
image_name, image_ver_str)