#!/usr/bin/env python # # Copyright (C) 2017 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import logging from vts.runners.host import asserts from vts.runners.host import base_test from vts.runners.host import const from vts.runners.host import test_runner from vts.testcases.kernel.api.proc import ProcAsoundTests from vts.testcases.kernel.api.proc import ProcCmdlineTest from vts.testcases.kernel.api.proc import ProcCpuFileTests from vts.testcases.kernel.api.proc import ProcFsFileTests from vts.testcases.kernel.api.proc import ProcKmsgTest from vts.testcases.kernel.api.proc import ProcMapsTest from vts.testcases.kernel.api.proc import ProcMiscTest from vts.testcases.kernel.api.proc import ProcMemInfoTest from vts.testcases.kernel.api.proc import ProcModulesTest from vts.testcases.kernel.api.proc import ProcQtaguidCtrlTest from vts.testcases.kernel.api.proc import ProcRemoveUidRangeTest from vts.testcases.kernel.api.proc import ProcSimpleFileTests from vts.testcases.kernel.api.proc import ProcShowUidStatTest from vts.testcases.kernel.api.proc import ProcStatTest from vts.testcases.kernel.api.proc import ProcUidIoStatsTest from vts.testcases.kernel.api.proc import ProcUidTimeInStateTest from vts.testcases.kernel.api.proc import ProcUidConcurrentTimeTests from vts.testcases.kernel.api.proc import ProcUidCpuPowerTests from vts.testcases.kernel.api.proc import ProcVersionTest from vts.testcases.kernel.api.proc import ProcVmallocInfoTest from vts.testcases.kernel.api.proc import ProcVmstatTest from vts.testcases.kernel.api.proc import ProcZoneInfoTest from vts.utils.python.controllers import android_device from vts.utils.python.file import target_file_utils TEST_OBJECTS = { ProcAsoundTests.ProcAsoundCardsTest(), ProcCmdlineTest.ProcCmdlineTest(), ProcCpuFileTests.ProcCpuInfoTest(), ProcCpuFileTests.ProcLoadavgTest(), ProcFsFileTests.ProcDiskstatsTest(), ProcFsFileTests.ProcFilesystemsTest(), ProcFsFileTests.ProcMountsTest(), ProcFsFileTests.ProcSwapsTest(), ProcKmsgTest.ProcKmsgTest(), ProcMapsTest.ProcMapsTest(), ProcMiscTest.ProcMisc(), ProcMemInfoTest.ProcMemInfoTest(), ProcModulesTest.ProcModulesTest(), ProcQtaguidCtrlTest.ProcQtaguidCtrlTest(), ProcRemoveUidRangeTest.ProcRemoveUidRangeTest(), ProcSimpleFileTests.ProcCorePattern(), ProcSimpleFileTests.ProcCorePipeLimit(), ProcSimpleFileTests.ProcDirtyBackgroundBytes(), ProcSimpleFileTests.ProcDirtyBackgroundRatio(), ProcSimpleFileTests.ProcDirtyExpireCentisecs(), ProcSimpleFileTests.ProcDmesgRestrict(), ProcSimpleFileTests.ProcDomainname(), ProcSimpleFileTests.ProcDropCaches(), ProcSimpleFileTests.ProcExtraFreeKbytes(), ProcSimpleFileTests.ProcHostname(), ProcSimpleFileTests.ProcHungTaskTimeoutSecs(), ProcSimpleFileTests.ProcKptrRestrictTest(), ProcSimpleFileTests.ProcMaxMapCount(), ProcSimpleFileTests.ProcMmapMinAddrTest(), ProcSimpleFileTests.ProcMmapRndBitsTest(), ProcSimpleFileTests.ProcModulesDisabled(), ProcSimpleFileTests.ProcOverCommitMemoryTest(), ProcSimpleFileTests.ProcPageCluster(), ProcSimpleFileTests.ProcPanicOnOops(), ProcSimpleFileTests.ProcPerfEventMaxSampleRate(), ProcSimpleFileTests.ProcPerfEventParanoid(), ProcSimpleFileTests.ProcPidMax(), ProcSimpleFileTests.ProcPipeMaxSize(), ProcSimpleFileTests.ProcProtectedHardlinks(), ProcSimpleFileTests.ProcProtectedSymlinks(), ProcSimpleFileTests.ProcRandomizeVaSpaceTest(), ProcSimpleFileTests.ProcSchedChildRunsFirst(), ProcSimpleFileTests.ProcSchedLatencyNS(), ProcSimpleFileTests.ProcSchedRTPeriodUS(), ProcSimpleFileTests.ProcSchedRTRuntimeUS(), ProcSimpleFileTests.ProcSchedTunableScaling(), ProcSimpleFileTests.ProcSchedWakeupGranularityNS(), ProcShowUidStatTest.ProcShowUidStatTest(), ProcSimpleFileTests.ProcSuidDumpable(), ProcSimpleFileTests.ProcSysKernelRandomBootId(), ProcSimpleFileTests.ProcSysRqTest(), ProcSimpleFileTests.ProcUptime(), ProcStatTest.ProcStatTest(), ProcUidIoStatsTest.ProcUidIoStatsTest(), ProcUidTimeInStateTest.ProcUidTimeInStateTest(), ProcUidConcurrentTimeTests.ProcUidConcurrentActiveTimeTest(), ProcUidConcurrentTimeTests.ProcUidConcurrentPolicyTimeTest(), ProcUidCpuPowerTests.ProcUidCpuPowerTimeInStateTest(), ProcUidCpuPowerTests.ProcUidCpuPowerConcurrentActiveTimeTest(), ProcUidCpuPowerTests.ProcUidCpuPowerConcurrentPolicyTimeTest(), ProcVersionTest.ProcVersionTest(), ProcVmallocInfoTest.ProcVmallocInfoTest(), ProcVmstatTest.ProcVmstat(), ProcZoneInfoTest.ProcZoneInfoTest(), } TEST_OBJECTS_64 = { ProcSimpleFileTests.ProcMmapRndCompatBitsTest(), } class VtsKernelProcFileApiTest(base_test.BaseTestClass): """Test cases which check content of proc files. Attributes: _PROC_SYS_ABI_SWP_FILE_PATH: the path of a file which decides behaviour of SWP instruction. """ _PROC_SYS_ABI_SWP_FILE_PATH = "/proc/sys/abi/swp" def setUpClass(self): self.dut = self.android_devices[0] self.shell = self.dut.shell 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.") test_object.set_api_level(self.dut) filepath = test_object.get_path() asserts.skipIf(not target_file_utils.Exists(filepath, self.shell) and test_object.file_optional(shell=self.shell, dut=self.dut), "%s does not exist and is optional." % filepath) 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, self.dut), "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 generateProcFileTests(self): """Run all proc file tests.""" self.runGeneratedTests( test_func=self.runProcFileTest, settings=TEST_OBJECTS.union(TEST_OBJECTS_64), name_func=lambda test_obj: "test" + test_obj.__class__.__name__) def ReadFileContent(self, filepath): """Read the content of a file and perform assertions. Args: filepath: string, path to file Returns: string, content of file """ cmd = "cat %s" % filepath results = self.shell.Execute(cmd) # checks the exit code asserts.assertEqual( results[const.EXIT_CODE][0], 0, "%s: Error happened while reading the file." % filepath) return results[const.STDOUT][0] def testProcPagetypeinfo(self): # TODO(b/109884074): make mandatory once incident_helper is in AOSP. try: self.dut.adb.shell("which incident_helper") except: asserts.skip("incident_helper not present") filepath = "/proc/pagetypeinfo" # Check that incident_helper can parse /proc/pagetypeinfo. result = self.shell.Execute("cat %s | incident_helper -s 2001" % filepath) asserts.assertEqual( result[const.EXIT_CODE][0], 0, "Failed to parse %s." % filepath) def testProcSysrqTrigger(self): filepath = "/proc/sysrq-trigger" # This command only performs a best effort attempt to remount all # filesystems. Check that it doesn't throw an error. self.dut.adb.shell("echo u > %s" % filepath) # Reboot the device. self.dut.adb.shell("echo b > %s" % filepath) asserts.assertFalse(self.dut.hasBooted(), "Device is still alive.") self.dut.waitForBootCompletion() self.dut.rootAdb() def testProcUidProcstatSet(self): def UidIOStats(uid): """Returns I/O stats for a given uid. Args: uid, uid number. Returns: list of I/O numbers. """ stats_path = "/proc/uid_io/stats" result = self.dut.adb.shell( "cat %s | grep '^%d'" % (stats_path, uid), no_except=True) return result[const.STDOUT].split() def CheckStatsInState(state): """Sets VTS (root uid) into a given state and checks the stats. Args: state, boolean. Use False for foreground, and True for background. """ state = 1 if state else 0 filepath = "/proc/uid_procstat/set" root_uid = 0 # fg write chars are at index 2, and bg write chars are at 6. wchar_index = 6 if state else 2 old_wchar = UidIOStats(root_uid)[wchar_index] self.dut.adb.shell("echo %d %s > %s" % (root_uid, state, filepath)) # This should increase the number of write syscalls. self.dut.adb.shell("echo foo") asserts.assertLess( int(old_wchar), int(UidIOStats(root_uid)[wchar_index]), "Number of write syscalls has not increased.") CheckStatsInState(False) CheckStatsInState(True) 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 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)) if __name__ == "__main__": test_runner.main()