1# Copyright (c) 2012 The Chromium OS Authors. All rights reserved. 2# Use of this source code is governed by a BSD-style license that can be 3# found in the LICENSE file. 4 5import re 6import logging 7 8from autotest_lib.client.common_lib import error 9 10 11class FAFTCheckers(object): 12 """Class that contains FAFT checkers.""" 13 version = 1 14 15 def __init__(self, faft_framework): 16 self.faft_framework = faft_framework 17 self.faft_client = faft_framework.faft_client 18 self.faft_config = faft_framework.faft_config 19 self.fw_vboot2 = self.faft_client.system.get_fw_vboot2() 20 21 def _parse_crossystem_output(self, lines): 22 """Parse the crossystem output into a dict. 23 24 @param lines: The list of crossystem output strings. 25 @return: A dict which contains the crossystem keys/values. 26 @raise TestError: If wrong format in crossystem output. 27 28 >>> seq = FAFTSequence() 29 >>> seq._parse_crossystem_output([ \ 30 "arch = x86 # Platform architecture", \ 31 "cros_debug = 1 # OS should allow debug", \ 32 ]) 33 {'cros_debug': '1', 'arch': 'x86'} 34 >>> seq._parse_crossystem_output([ \ 35 "arch=x86", \ 36 ]) 37 Traceback (most recent call last): 38 ... 39 TestError: Failed to parse crossystem output: arch=x86 40 >>> seq._parse_crossystem_output([ \ 41 "arch = x86 # Platform architecture", \ 42 "arch = arm # Platform architecture", \ 43 ]) 44 Traceback (most recent call last): 45 ... 46 TestError: Duplicated crossystem key: arch 47 """ 48 pattern = "^([^ =]*) *= *(.*[^ ]) *# [^#]*$" 49 parsed_list = {} 50 for line in lines: 51 matched = re.match(pattern, line.strip()) 52 if not matched: 53 raise error.TestError("Failed to parse crossystem output: %s" 54 % line) 55 (name, value) = (matched.group(1), matched.group(2)) 56 if name in parsed_list: 57 raise error.TestError("Duplicated crossystem key: %s" % name) 58 parsed_list[name] = value 59 return parsed_list 60 61 def crossystem_checker(self, expected_dict, suppress_logging=False): 62 """Check the crossystem values matched. 63 64 Given an expect_dict which describes the expected crossystem values, 65 this function check the current crossystem values are matched or not. 66 67 @param expected_dict: A dict which contains the expected values. 68 @param suppress_logging: True to suppress any logging messages. 69 @return: True if the crossystem value matched; otherwise, False. 70 """ 71 succeed = True 72 lines = self.faft_client.system.run_shell_command_get_output( 73 'crossystem') 74 got_dict = self._parse_crossystem_output(lines) 75 for key in expected_dict: 76 if key not in got_dict: 77 logging.warn('Expected key %r not in crossystem result', key) 78 succeed = False 79 continue 80 if isinstance(expected_dict[key], str): 81 if got_dict[key] != expected_dict[key]: 82 message = ('Expected %r value %r but got %r' % ( 83 key, expected_dict[key], got_dict[key])) 84 succeed = False 85 else: 86 message = ('Expected %r value %r == real value %r' % ( 87 key, expected_dict[key], got_dict[key])) 88 89 elif isinstance(expected_dict[key], tuple): 90 # Expected value is a tuple of possible actual values. 91 if got_dict[key] not in expected_dict[key]: 92 message = ('Expected %r values %r but got %r' % ( 93 key, expected_dict[key], got_dict[key])) 94 succeed = False 95 else: 96 message = ('Expected %r values %r == real value %r' % ( 97 key, expected_dict[key], got_dict[key])) 98 else: 99 logging.warn('The expected value of %r is neither a str nor a ' 100 'dict: %r', key, expected_dict[key]) 101 succeed = False 102 continue 103 if not suppress_logging: 104 logging.info(message) 105 return succeed 106 107 def mode_checker(self, mode): 108 """Check the current system in the given mode. 109 110 @param mode: A string of mode, one of 'normal', 'dev', or 'rec'. 111 @return: True if the system in the given mode; otherwise, False. 112 """ 113 if mode == 'normal': 114 return self.crossystem_checker( 115 {'devsw_boot': '0', 116 'mainfw_type': 'normal'}, 117 suppress_logging=True) 118 elif mode == 'dev': 119 return self.crossystem_checker( 120 {'devsw_boot': '1', 121 'mainfw_type': 'developer'}, 122 suppress_logging=True) 123 elif mode == 'rec': 124 return self.crossystem_checker( 125 {'mainfw_type': 'recovery'}, 126 suppress_logging=True) 127 else: 128 raise NotImplementedError('The given mode %s not supported' % mode) 129 130 def fw_tries_checker(self, 131 expected_mainfw_act, 132 expected_fw_tried=True, 133 expected_try_count=0): 134 """Check the current FW booted and try_count 135 136 Mainly for dealing with the vboot1-specific flags fwb_tries and 137 tried_fwb fields in crossystem. In vboot2, fwb_tries is meaningless and 138 is ignored while tried_fwb is translated into fw_try_count. 139 140 @param expected_mainfw_act: A string of expected firmware, 'A', 'B', or 141 None if don't care. 142 @param expected_fw_tried: True if tried expected FW at last boot. 143 This means that mainfw_act=A,tried_fwb=0 or 144 mainfw_act=B,tried_fwb=1. Set to False if want to 145 check the opposite case for the mainfw_act. This 146 check is only performed in vboot1 as tried_fwb is 147 never set in vboot2. 148 @param expected_try_count: Number of times to try a FW slot. 149 150 @return: True if the correct boot firmware fields matched. Otherwise, 151 False. 152 """ 153 crossystem_dict = {'mainfw_act': expected_mainfw_act.upper()} 154 155 if not self.fw_vboot2: 156 if expected_mainfw_act == 'B': 157 tried_fwb_val = True 158 else: 159 tried_fwb_val = False 160 if not expected_fw_tried: 161 tried_fwb_val = not tried_fwb_val 162 crossystem_dict['tried_fwb'] = '1' if tried_fwb_val else '0' 163 164 crossystem_dict['fwb_tries'] = str(expected_try_count) 165 else: 166 crossystem_dict['fw_try_count'] = str(expected_try_count) 167 return self.crossystem_checker(crossystem_dict) 168 169 def dev_boot_usb_checker(self, dev_boot_usb=True, kernel_key_hash=False): 170 """Check the current boot is from a developer USB (Ctrl-U trigger). 171 172 @param dev_boot_usb: True to expect an USB boot; 173 False to expect an internal device boot. 174 @param kernel_key_hash: True to expect an USB boot with kernkey_vfy 175 value as 'hash'; 176 False to expect kernkey_vfy value as 'sig'. 177 @return: True if the current boot device matched; otherwise, False. 178 """ 179 assert (dev_boot_usb or not kernel_key_hash), ("Invalid condition " 180 "dev_boot_usb_checker(%s, %s). kernel_key_hash should not be " 181 "True in internal disk boot.") % (dev_boot_usb, kernel_key_hash) 182 # kernkey_vfy value will be 'sig', when device booted in internal 183 # disk or booted in USB image signed with SSD key(Ctrl-U trigger). 184 expected_kernkey_vfy = 'sig' 185 if kernel_key_hash: 186 expected_kernkey_vfy = 'hash' 187 return (self.crossystem_checker({'mainfw_type': 'developer', 188 'kernkey_vfy': 189 expected_kernkey_vfy}) and 190 self.faft_client.system.is_removable_device_boot() == 191 dev_boot_usb) 192 193 def root_part_checker(self, expected_part): 194 """Check the partition number of the root device matched. 195 196 @param expected_part: A string containing the number of the expected 197 root partition. 198 @return: True if the currect root partition number matched; 199 otherwise, False. 200 """ 201 part = self.faft_client.system.get_root_part()[-1] 202 if self.faft_framework.ROOTFS_MAP[expected_part] != part: 203 logging.info("Expected root part %s but got %s", 204 self.faft_framework.ROOTFS_MAP[expected_part], part) 205 return False 206 return True 207 208 def ec_act_copy_checker(self, expected_copy): 209 """Check the EC running firmware copy matches. 210 211 @param expected_copy: A string containing 'RO', 'A', or 'B' indicating 212 the expected copy of EC running firmware. 213 @return: True if the current EC running copy matches; otherwise, False. 214 """ 215 cmd = 'ectool version' 216 lines = self.faft_client.system.run_shell_command_get_output(cmd) 217 pattern = re.compile("Firmware copy: (.*)") 218 for line in lines: 219 matched = pattern.match(line) 220 if matched: 221 if matched.group(1) == expected_copy: 222 return True 223 else: 224 logging.info("Expected EC in %s but now in %s", 225 expected_copy, matched.group(1)) 226 return False 227 logging.info("Wrong output format of '%s':\n%s", cmd, '\n'.join(lines)) 228 return False 229