def runProcFileTest(self, test_object):
"""Reads from the file and checks that it parses and the content is valid.
Args:
test_object: inherits KernelProcFileTestBase, contains the test functions
"""
asserts.skipIf(test_object in TEST_OBJECTS_64 and not self.dut.is64Bit,
"Skip test for 64-bit kernel.")
filepath = test_object.get_path()
target_file_utils.assertPermissionsAndExistence(
self.shell, filepath, test_object.get_permission_checker())
logging.info("Testing format of %s", filepath)
asserts.assertTrue(
test_object.prepare_test(self.shell), "Setup failed!")
if not test_object.test_format():
return
file_content = self.ReadFileContent(filepath)
try:
parse_result = test_object.parse_contents(file_content)
except (SyntaxError, ValueError, IndexError) as e:
asserts.fail("Failed to parse! " + str(e))
asserts.assertTrue(
test_object.result_correct(parse_result), "Results not valid!")
def testVendorPropertyNamespace(self):
"""Ensures vendor properties have proper namespace.
Vendor or ODM properties must have their own prefix.
"""
logging.info("Checking existence of %s",
self._VENDOR_PROPERTY_CONTEXTS_FILE_PATH)
target_file_utils.assertPermissionsAndExistence(
self.shell, self._VENDOR_PROPERTY_CONTEXTS_FILE_PATH,
target_file_utils.IsReadable)
# Pull vendor property contexts file from device.
self.dut.adb.pull("%s %s" % (self._VENDOR_PROPERTY_CONTEXTS_FILE_PATH,
self._temp_dir))
logging.info("Adb pull %s to %s",
self._VENDOR_PROPERTY_CONTEXTS_FILE_PATH,
self._temp_dir)
with open(os.path.join(self._temp_dir, "vendor_property_contexts"),
"r") as property_contexts_file:
property_dict = self._ParsePropertyDictFromPropertyContextsFile(
property_contexts_file)
logging.info("Found %d property names in vendor property contexts",
len(property_dict))
for name in property_dict:
has_proper_namesapce = False
for prefix in self._VENDOR_OR_ODM_NAMEPACES:
if name.startswith(prefix):
has_proper_namesapce = True
break
asserts.assertTrue(
has_proper_namesapce,
"Vendor property (%s) has wrong namespace" % name)
def testProcPerUidTimes(self):
# TODO: make these files mandatory once they're in AOSP
try:
filepaths = self.dut.adb.shell("find /proc/uid -name time_in_state")
except:
asserts.skip("/proc/uid/ directory does not exist and is optional")
asserts.skipIf(not filepaths,
"per-UID time_in_state files do not exist and are optional")
filepaths = filepaths.splitlines()
for filepath in filepaths:
target_file_utils.assertPermissionsAndExistence(
self.shell, filepath, target_file_utils.IsReadOnly
)
file_content = self.ReadFileContent(filepath)
def testExportedPlatformPropertyIntegrity(self):
"""Ensures public property contexts isn't modified at all.
Public property contexts must not be modified.
"""
logging.info("Checking existence of %s",
self._SYSTEM_PROPERTY_CONTEXTS_FILE_PATH)
target_file_utils.assertPermissionsAndExistence(
self.shell, self._SYSTEM_PROPERTY_CONTEXTS_FILE_PATH,
target_file_utils.IsReadable)
# Pull system property contexts file from device.
self.dut.adb.pull(
"%s %s" %
(self._SYSTEM_PROPERTY_CONTEXTS_FILE_PATH, self._temp_dir))
logging.info("Adb pull %s to %s",
self._SYSTEM_PROPERTY_CONTEXTS_FILE_PATH, self._temp_dir)
with open(os.path.join(self._temp_dir, "plat_property_contexts"),
"r") as property_contexts_file:
sys_property_dict = self._ParsePropertyDictFromPropertyContextsFile(
property_contexts_file, True)
logging.info(
"Found %d exact-matching properties "
"in system property contexts", len(sys_property_dict))
pub_property_contexts_file_path = os.path.join(
self.data_file_path, self._PUBLIC_PROPERTY_CONTEXTS_FILE_PATH)
with open(pub_property_contexts_file_path,
"r") as property_contexts_file:
pub_property_dict = self._ParsePropertyDictFromPropertyContextsFile(
property_contexts_file, True)
for name in pub_property_dict:
public_tokens = pub_property_dict[name]
asserts.assertTrue(name in sys_property_dict,
"Exported property (%s) doesn't exist" % name)
if name in self._MODIFIABLE_PROPERTIES:
continue
system_tokens = sys_property_dict[name]
asserts.assertEqual(public_tokens, system_tokens,
"Exported property (%s) is modified" % name)
def testProcSysAbiSwpInstruction(self):
"""Tests /proc/sys/abi/swp.
/proc/sys/abi/swp sets the execution behaviour for the obsoleted ARM instruction
SWP. As per the setting in /proc/sys/abi/swp, the usage of SWP{B}
can either generate an undefined instruction abort or use software emulation
or hardware execution.
"""
asserts.skipIf(not ("arm" in self.dut.cpu_abi and self.dut.is64Bit),
"file not present on non-ARM64 device")
target_file_utils.assertPermissionsAndExistence(
self.shell, self._PROC_SYS_ABI_SWP_FILE_PATH, target_file_utils.IsReadWrite)
file_content = self.ReadFileContent(self._PROC_SYS_ABI_SWP_FILE_PATH)
try:
swp_state = int(file_content)
except ValueError as e:
asserts.fail("Failed to parse %s" % self._PROC_SYS_ABI_SWP_FILE_PATH)
asserts.assertTrue(swp_state >= 0 and swp_state <= 2,
"%s contains incorrect value: %d" % (self._PROC_SYS_ABI_SWP_FILE_PATH,
swp_state))
def testKernelConfigs(self):
"""Ensures all kernel configs conform to Android requirements.
Detects kernel version of device and validates against appropriate
Common Android Kernel android-base.cfg and Android Treble
requirements.
"""
logging.info("Testing existence of %s" % self.PROC_FILE_PATH)
target_file_utils.assertPermissionsAndExistence(
self.shell, self.PROC_FILE_PATH, target_file_utils.IsReadOnly)
logging.info("Validating kernel version of device.")
kernel_version = self.checkKernelVersion()
# Pull configs from the universal config file.
configs = dict()
config_file_path = os.path.join(self.data_file_path,
self.KERNEL_CONFIG_FILE_PATH,
"android-" + kernel_version,
"android-base.cfg")
with open(config_file_path, 'r') as config_file:
configs = self.parseConfigFileToDict(config_file, configs)
# Pull configs from device.
device_configs = dict()
self.dut.adb.pull("%s %s" % (self.PROC_FILE_PATH, self._temp_dir))
logging.info("Adb pull %s to %s", self.PROC_FILE_PATH, self._temp_dir)
localpath = os.path.join(self._temp_dir, "config.gz")
with gzip.open(localpath, "rb") as device_config_file:
device_configs = self.parseConfigFileToDict(
device_config_file, device_configs)
# Check device architecture and pull arch-specific configs.
kernelArch = self.checkKernelArch(device_configs)
if kernelArch is not "":
config_file_path = os.path.join(self.data_file_path,
self.KERNEL_CONFIG_FILE_PATH,
"android-" + kernel_version,
"android-base-%s.cfg" % kernelArch)
if os.path.isfile(config_file_path):
with open(config_file_path, 'r') as config_file:
configs = self.parseConfigFileToDict(config_file, configs)
# Determine any deviations from the required configs.
should_be_enabled = []
should_not_be_set = []
incorrect_config_state = []
for config_name, config_state in configs.iteritems():
if (config_state == "y"
and (config_name not in device_configs
or device_configs[config_name] not in ("y", "m"))):
should_be_enabled.append(config_name)
elif (config_state == "n" and (config_name in device_configs)
and device_configs[config_name] != "n"):
should_not_be_set.append(config_name + "=" +
device_configs[config_name])
elif (config_name in device_configs
and device_configs[config_name] != config_state):
incorrect_config_state.append(config_name + "=" +
device_configs[config_name])
if ("CONFIG_OF" not in device_configs
and "CONFIG_ACPI" not in device_configs):
should_be_enabled.append("CONFIG_OF | CONFIG_ACPI")
asserts.assertTrue(
len(should_be_enabled) == 0 and len(should_not_be_set) == 0
and len(incorrect_config_state) == 0,
("The following kernel configs should be enabled: [%s]\n"
"The following kernel configs should not be set: [%s]\n"
"THe following kernel configs have incorrect state: [%s]") %
(", ".join(should_be_enabled), ", ".join(should_not_be_set),
", ".join(incorrect_config_state)))