# Copyright 2015 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 import common from autotest_lib.client.common_lib import error from autotest_lib.server import test def _assert_equal(expected, actual): """Compares objects. @param expected: the expected value. @param actual: the actual value. @raises error.TestFail """ if expected != actual: raise error.TestFail('Expected: %r, actual: %r' % (expected, actual)) class brillo_BootLoader(test.test): """A/B tests for boot loader and boot_control HAL implementation.""" version = 1 def get_slots_and_suffix(self): """Gets number of slots supported and slot suffixes used. Prerequisite: The DUT is in ADB mode. """ self.num_slots = int(self.dut.run_output('bootctl get-number-slots')) logging.info('Number of slots: %d', self.num_slots) self.suffix_a = self.dut.run_output('bootctl get-suffix 0') self.suffix_b = self.dut.run_output('bootctl get-suffix 1') logging.info('Slot 0 suffix: "%s"', self.suffix_a) logging.info('Slot 1 suffix: "%s"', self.suffix_b) _assert_equal(2, self.num_slots) # We're going to need the size of the boot partitions later. self.boot_a_size = int(self.dut.run_output( 'blockdev --getsize64 /dev/block/by-name/boot%s' % self.suffix_a)) self.boot_b_size = int(self.dut.run_output( 'blockdev --getsize64 /dev/block/by-name/boot%s' % self.suffix_b)) if self.boot_a_size != self.boot_b_size: raise error.TestFail('boot partitions are not the same size') logging.info('boot partition size: %d bytes', self.boot_a_size) def fastboot_get_var(self, variable_name): """Gets a fastboot variable. Returns a string with the value or the empty string if the variable does not exist. Prerequisite: The DUT is in bootloader mode. @param variable_name: Name of fastboot variable to get. """ cmd_output = self.dut.fastboot_run('getvar %s' % variable_name) # Gah, 'fastboot getvar' prints requested output on stderr # instead of stdout as you'd expect. lines = cmd_output.stderr.split('\n') if lines[0].startswith(variable_name + ': '): return (lines[0])[len(variable_name + ': '):] return '' def check_fastboot_variables(self): """Checks that fastboot bootloader has necessary variables for A/B. Prerequisite: The DUT is in ADB mode. """ logging.info('Checking fastboot-compliant bootloader has necessary ' 'variables for A/B.') self.dut.ensure_bootloader_mode() # The slot-suffixes looks like '_a,_b' and may have a trailing comma. suffixes = self.fastboot_get_var('slot-suffixes') if suffixes.rstrip(',').split(',') != [self.suffix_a, self.suffix_b]: raise error.TestFail('Variable slot-suffixes has unexpected ' 'value "%s"' % suffixes) # Back to ADB mode. self.dut.fastboot_reboot() def get_current_slot(self): """Gets the current slot the DUT is running from. Prerequisite: The DUT is in ADB mode. """ return int(self.dut.run_output('bootctl get-current-slot')) def assert_current_slot(self, slot_number): """Checks that DUT is running from the given slot. Prerequisite: The DUT is in ADB mode. @param slot_number: Zero-based index of slot to be running from. """ _assert_equal(slot_number, self.get_current_slot()) def set_active_slot(self, slot_number): """Instructs the DUT to attempt booting from given slot. Prerequisite: The DUT is in ADB mode. @param slot_number: Zero-based index of slot to make active. """ logging.info('Setting slot %d active.', slot_number) self.dut.run('bootctl set-active-boot-slot %d' % slot_number) def ensure_running_slot(self, slot_number): """Ensures that DUT is running from the given slot. Prerequisite: The DUT is in ADB mode. @param slot_number: Zero-based index of slot to be running from. """ logging.info('Ensuring device is running from slot %d.', slot_number) if self.get_current_slot() != slot_number: logging.info('Rebooting into slot %d', slot_number) self.set_active_slot(slot_number) self.dut.reboot() self.assert_current_slot(slot_number) def copy_a_to_b(self): """Copies contents of slot A to slot B. Prerequisite: The DUT is in ADB mode and booted from slot A. """ self.assert_current_slot(0) for i in ['boot', 'system']: logging.info('Copying %s%s to %s%s.', i, self.suffix_a, i, self.suffix_b) self.dut.run('dd if=/dev/block/by-name/%s%s ' 'of=/dev/block/by-name/%s%s bs=4096' % (i, self.suffix_a, i, self.suffix_b)) def check_bootctl_set_active(self): """Checks that setActiveBootSlot in the boot_control HAL work. Prerequisite: The DUT is in ADB mode with populated A and B slots. """ logging.info('Check setActiveBootSlot() in boot_control HAL.') self.set_active_slot(0) self.dut.reboot() self.assert_current_slot(0) self.set_active_slot(1) self.dut.reboot() self.assert_current_slot(1) def check_fastboot_set_active(self): """Checks that 'fastboot set_active ' work. Prerequisite: The DUT is in ADB mode with populated A and B slots. """ logging.info('Check set_active command in fastboot-compliant bootloader.') self.dut.ensure_bootloader_mode() self.dut.fastboot_run('set_active %s' % self.suffix_a) self.dut.fastboot_reboot() self.dut.adb_run('wait-for-device') self.assert_current_slot(0) self.dut.ensure_bootloader_mode() self.dut.fastboot_run('set_active %s' % self.suffix_b) self.dut.fastboot_reboot() self.dut.adb_run('wait-for-device') self.assert_current_slot(1) def check_bootloader_fallback_on_invalid(self): """Checks bootloader fallback if current slot is invalid. Prerequisite: The DUT is in ADB mode with populated A and B slots. """ logging.info('Checking bootloader fallback if current slot ' 'is invalid.') # Make sure we're in slot B, then zero out boot_b (so slot B # is invalid), reboot and check that the bootloader correctly # fell back to A. self.ensure_running_slot(1) self.dut.run('dd if=/dev/zero of=/dev/block/by-name/boot%s ' 'count=%d bs=4096' % (self.suffix_b, self.boot_b_size/4096)) self.dut.reboot() self.assert_current_slot(0) # Restore boot_b for use in future test cases. self.dut.run('dd if=/dev/block/by-name/boot%s ' 'of=/dev/block/by-name/boot%s bs=4096' % (self.suffix_a, self.suffix_b)) def check_bootloader_fallback_on_retries(self): """Checks bootloader fallback if slot made active runs out of tries. Prerequisite: The DUT is in ADB mode with populated A and B slots. @raises error.TestFail """ logging.info('Checking bootloader fallback if slot made active ' 'runs out of tries.') self.ensure_running_slot(0) self.set_active_slot(1) self.dut.reboot() num_retries = 1 while num_retries < 10 and self.get_current_slot() == 1: logging.info('Still with B after %d retries', num_retries) num_retries += 1 self.dut.reboot() if self.get_current_slot() != 0: raise error.TestFail('Bootloader did not fall back after ' '%d retries without the slot being marked ' 'as GOOD' % num_retries) logging.info('Fell back to A after %d retries.', num_retries) def check_bootloader_mark_successful(self): """Checks bootloader stays with slot after it has been marked good. Prerequisite: The DUT is in ADB mode with populated A and B slots. """ logging.info('Checking bootloader is staying with a slot after it has ' 'been marked as GOOD for at least 10 reboots.') self.ensure_running_slot(0) self.dut.run('bootctl mark-boot-successful') num_reboots = 0 while num_reboots < 10: self.dut.reboot() self.assert_current_slot(0) num_reboots += 1 logging.info('Still with A after %d reboots', num_reboots) def run_once(self, dut=None): """A/B tests for boot loader and boot_control HAL implementation. Verifies that boot loader and boot_control HAL implementation implements A/B correctly. Prerequisite: The DUT is in ADB mode. @param dut: host object representing the device under test. """ self.dut = dut self.get_slots_and_suffix() self.check_fastboot_variables() self.ensure_running_slot(0) self.copy_a_to_b() self.check_bootctl_set_active() self.check_fastboot_set_active() self.check_bootloader_fallback_on_invalid() self.check_bootloader_fallback_on_retries() self.check_bootloader_mark_successful()