| #!/usr/bin/python |
| # |
| # Copyright 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. |
| # |
| |
| """Generates a report on CKI syscall coverage in VTS LTP. |
| |
| This module generates a report on the syscalls in the Android CKI and |
| their coverage in VTS LTP. |
| |
| The coverage report provides, for each syscall in the CKI, the number of |
| enabled and disabled LTP tests for the syscall in VTS. If VTS test output is |
| supplied, the report instead provides the number of disabled, skipped, failing, |
| and passing tests for each syscall. |
| |
| Assumptions are made about the structure of files in LTP source |
| and the naming convention. |
| """ |
| |
| import argparse |
| import os.path |
| import re |
| import sys |
| import xml.etree.ElementTree as ET |
| import subprocess |
| |
| if "ANDROID_BUILD_TOP" not in os.environ: |
| print ("Please set up your Android build environment by running " |
| "\". build/envsetup.sh\" and \"lunch\".") |
| sys.exit(-1) |
| |
| sys.path.append(os.path.join(os.environ["ANDROID_BUILD_TOP"], |
| "bionic/libc/tools")) |
| import gensyscalls |
| |
| sys.path.append(os.path.join(os.environ["ANDROID_BUILD_TOP"], |
| "test/vts-testcase/kernel/ltp/configs")) |
| import disabled_tests as vts_disabled |
| import stable_tests as vts_stable |
| |
| bionic_libc_root = os.path.join(os.environ["ANDROID_BUILD_TOP"], "bionic/libc") |
| |
| src_url_start = 'https://git.kernel.org/pub/scm/linux/kernel/git/' |
| tip_url = 'torvalds/linux.git/plain/' |
| stable_url = 'stable/linux.git/plain/' |
| unistd_h = 'include/uapi/asm-generic/unistd.h' |
| arm64_unistd32_h = 'arch/arm64/include/asm/unistd32.h' |
| arm_syscall_tbl = 'arch/arm/tools/syscall.tbl' |
| x86_syscall_tbl = 'arch/x86/entry/syscalls/syscall_32.tbl' |
| x86_64_syscall_tbl = 'arch/x86/entry/syscalls/syscall_64.tbl' |
| |
| unistd_h_url = src_url_start |
| arm64_unistd32_h_url = src_url_start |
| arm_syscall_tbl_url = src_url_start |
| x86_syscall_tbl_url = src_url_start |
| x86_64_syscall_tbl_url = src_url_start |
| |
| # Syscalls which are either banned, optional, or deprecated, so not part of the |
| # CKI. |
| CKI_BLACKLIST = [ |
| 'acct', # CONFIG_BSD_PROCESS_ACCT |
| 'fanotify_init', # CONFIG_FANOTIFY |
| 'fanotify_mark', # CONFIG_FANOTIFY |
| 'get_mempolicy', # CONFIG_NUMA |
| 'init_module', # b/112470257 (use finit_module) |
| 'ipc', # CONFIG_SYSVIPC |
| 'kcmp', # CONFIG_CHECKPOINT_RESTORE |
| 'kexec_file_load', # CONFIG_EXEC_FILE |
| 'kexec_load', # CONFIG_KEXEC |
| 'lookup_dcookie', # b/112474343 (requires kernel module) |
| 'mbind', # CONFIG_NUMA |
| 'membarrier', # CONFIG_MEMBARRIER |
| 'migrate_pages', # CONFIG_NUMA |
| 'move_pages', # CONFIG_MIGRATION |
| 'mq_getsetattr', # CONFIG_POSIX_MQUEUE |
| 'mq_notify', # CONFIG_POSIX_MQUEUE |
| 'mq_open', # CONFIG_POSIX_MQUEUE |
| 'mq_timedreceive', # CONFIG_POSIX_MQUEUE |
| 'mq_timedsend', # CONFIG_POSIX_MQUEUE |
| 'mq_unlink', # CONFIG_POSIX_MQUEUE |
| 'msgctl', # CONFIG_SYSVIPC |
| 'msgget', # CONFIG_SYSVIPC |
| 'msgrcv', # CONFIG_SYSVIPC |
| 'msgsnd', # CONFIG_SYSVIPC |
| 'name_to_handle_at', # CONFIG_FHANDLE |
| 'nfsservctl', # not present after 3.1 |
| 'open_by_handle_at', # CONFIG_FHANDLE |
| 'pciconfig_iobase', # not present for arm/x86 |
| 'pciconfig_read', # CONFIG_PCI_SYSCALL |
| 'pciconfig_write', # CONFIG_PCI_SYSCALL |
| 'pkey_alloc', # CONFIG_MMU, added in 4.9 |
| 'pkey_free', # CONFIG_MMU, added in 4.9 |
| 'pkey_mprotect', # CONFIG_MMU, added in 4.9 |
| 'rseq', # CONFIG_RSEQ |
| 'semctl', # CONFIG_SYSVIPC |
| 'semget', # CONFIG_SYSVIPC |
| 'semop', # CONFIG_SYSVIPC |
| 'semtimedop', # CONFIG_SYSVIPC |
| 'set_mempolicy', # CONFIG_NUMA |
| 'sgetmask', # CONFIG_SGETMASK_SYSCALL |
| 'shmat', # CONFIG_SYSVIPC |
| 'shmctl', # CONFIG_SYSVIPC |
| 'shmdt', # CONFIG_SYSVIPC |
| 'shmget', # CONFIG_SYSVIPC |
| 'ssetmask', # CONFIG_SGETMASK_SYSCALL |
| 'stime', # deprecated |
| 'syscall', # deprecated |
| '_sysctl', # CONFIG_SYSCTL_SYSCALL |
| 'sysfs', # CONFIG_SYSFS_SYSCALL |
| 'uselib', # CONFIG_USELIB |
| 'userfaultfd', # CONFIG_USERFAULTFD |
| 'vm86', # CONFIG_X86_LEGACY_VM86 |
| 'vm86old', # CONFIG_X86_LEGACY_VM86 |
| 'vserver', # deprecated |
| ] |
| |
| EXTERNAL_TESTS = [ ("bpf", "libbpf_android/BpfLoadTest.cpp"), |
| ("bpf", "libbpf_android/BpfMapTest.cpp"), |
| ("bpf", "netd/libbpf/BpfMapTest.cpp"), |
| ("bpf", "api/bpf_native_test/BpfTest.cpp"), |
| ("clock_adjtime", "kselftest/timers/valid-adjtimex.c"), |
| ("seccomp", "kselftest/seccomp_bpf") |
| ] |
| |
| class CKI_Coverage(object): |
| """Determines current test coverage of CKI system calls in LTP. |
| |
| Many of the system calls in the CKI are tested by LTP. For a given |
| system call an LTP test may or may not exist, that LTP test may or may |
| not be currently compiling properly for Android, the test may not be |
| stable, the test may not be running due to environment issues or |
| passing. This class looks at various sources of information to determine |
| the current test coverage of system calls in the CKI from LTP. |
| |
| Note that due to some deviations in LTP of tests from the common naming |
| convention there there may be tests that are flagged here as not having |
| coverage when in fact they do. |
| """ |
| |
| LTP_KERNEL_ROOT = os.path.join(os.environ["ANDROID_BUILD_TOP"], |
| "external/ltp/testcases/kernel") |
| LTP_KERNEL_TESTSUITES = ["syscalls", "timers"] |
| DISABLED_IN_LTP_PATH = os.path.join(os.environ["ANDROID_BUILD_TOP"], |
| "external/ltp/android/tools/disabled_tests.txt") |
| |
| ltp_full_set = [] |
| |
| cki_syscalls = [] |
| |
| disabled_in_ltp = [] |
| disabled_in_vts_ltp = vts_disabled.DISABLED_TESTS |
| stable_in_vts_ltp = vts_stable.STABLE_TESTS |
| |
| syscall_tests = {} |
| disabled_tests = {} |
| |
| def __init__(self, arch): |
| self._arch = arch |
| |
| def load_ltp_tests(self): |
| """Load the list of LTP syscall tests. |
| |
| Load the list of all syscall tests existing in LTP. |
| """ |
| for testsuite in self.LTP_KERNEL_TESTSUITES: |
| self.__load_ltp_testsuite(testsuite) |
| |
| def __load_ltp_testsuite(self, testsuite): |
| root = os.path.join(self.LTP_KERNEL_ROOT, testsuite) |
| for path, dirs, files in os.walk(root): |
| for filename in files: |
| basename, ext = os.path.splitext(filename) |
| if ext != ".c": continue |
| self.ltp_full_set.append("%s.%s" % (testsuite, basename)) |
| |
| def load_ltp_disabled_tests(self): |
| """Load the list of LTP tests not being compiled. |
| |
| The LTP repository in Android contains a list of tests which are not |
| compiled due to incompatibilities with Android. |
| """ |
| with open(self.DISABLED_IN_LTP_PATH) as fp: |
| for line in fp: |
| line = line.strip() |
| if not line: continue |
| test_re = re.compile(r"^(\w+)") |
| test_match = re.match(test_re, line) |
| if not test_match: continue |
| self.disabled_in_ltp.append(test_match.group(1)) |
| |
| def ltp_test_special_cases(self, syscall, test): |
| """Detect special cases in syscall to LTP mapping. |
| |
| Most syscall tests in LTP follow a predictable naming |
| convention, but some do not. Detect known special cases. |
| |
| Args: |
| syscall: The name of a syscall. |
| test: The name of a testcase. |
| |
| Returns: |
| A boolean indicating whether the given syscall is tested |
| by the given testcase. |
| """ |
| compat_syscalls = [ "chown32", "fchown32", "getegid32", "geteuid32", |
| "getgid32", "getgroups32", "getresgid32", "getresuid32", |
| "getuid32", "lchown32", "setfsgid32", "setfsuid32", "setgid32", |
| "setgroups32", "setregid32", "setresgid32", "setresuid32", |
| "setreuid32", "setuid32"] |
| if syscall in compat_syscalls: |
| test_re = re.compile(r"^%s\d+$" % syscall[0:-2]) |
| if re.match(test_re, test): |
| return True |
| if syscall == "_llseek" and test.startswith("llseek"): |
| return True |
| if syscall in ("arm_fadvise64_", "fadvise64_") and \ |
| test.startswith("posix_fadvise"): |
| return True |
| if syscall in ("arm_sync_file_range", "sync_file_range2") and \ |
| test.startswith("sync_file_range"): |
| return True |
| if syscall == "clock_nanosleep" and test == "clock_nanosleep2_01": |
| return True |
| if syscall in ("epoll_ctl", "epoll_create") and test == "epoll-ltp": |
| return True |
| if syscall == "futex" and test.startswith("futex_"): |
| return True |
| if syscall == "get_thread_area" and test == "set_thread_area01": |
| return True |
| if syscall == "inotify_add_watch" or syscall == "inotify_rm_watch": |
| test_re = re.compile(r"^inotify\d+$") |
| if re.match(test_re, test): |
| return True |
| inotify_init_tests = [ "inotify01", "inotify02", "inotify03", "inotify04" ] |
| if syscall == "inotify_init" and test in inotify_init_tests: |
| return True |
| if syscall == "lsetxattr" and test.startswith("lgetxattr"): |
| return True |
| if syscall == "newfstatat": |
| test_re = re.compile(r"^fstatat\d+$") |
| if re.match(test_re, test): |
| return True |
| if syscall in ("prlimit", "ugetrlimit") and test == "getrlimit03": |
| return True |
| if syscall == "rt_sigtimedwait" and test == "sigwaitinfo01": |
| return True |
| shutdown_tests = [ "send01", "sendmsg01", "sendto01" ] |
| if syscall == "shutdown" and test in shutdown_tests: |
| return True |
| |
| return False |
| |
| def match_syscalls_to_tests(self, syscalls): |
| """Match syscalls with tests in LTP. |
| |
| Create a mapping from CKI syscalls and tests in LTP. This mapping can |
| largely be determined using a common naming convention in the LTP file |
| hierarchy but there are special cases that have to be taken care of. |
| |
| Args: |
| syscalls: List of syscall structures containing all syscalls |
| in the CKI. |
| """ |
| for syscall in syscalls: |
| if self._arch is not None and self._arch not in syscall: |
| continue |
| self.cki_syscalls.append(syscall) |
| self.syscall_tests[syscall["name"]] = [] |
| # LTP does not use the 64 at the end of syscall names for testcases. |
| ltp_syscall_name = syscall["name"] |
| if ltp_syscall_name.endswith("64"): |
| ltp_syscall_name = ltp_syscall_name[0:-2] |
| # Most LTP syscalls have source files for the tests that follow |
| # a naming convention in the regexp below. Exceptions exist though. |
| # For now those are checked for specifically. |
| test_re = re.compile(r"^%s_?0?\d\d?$" % ltp_syscall_name) |
| for full_test_name in self.ltp_full_set: |
| testsuite, test = full_test_name.split('.') |
| if (re.match(test_re, test) or |
| self.ltp_test_special_cases(ltp_syscall_name, test)): |
| # The filenames of the ioctl tests in LTP do not match the name |
| # of the testcase defined in that source, which is what shows |
| # up in VTS. |
| if testsuite == "syscalls" and ltp_syscall_name == "ioctl": |
| full_test_name = "syscalls.ioctl01_02" |
| # Likewise LTP has a test named epoll01, which is built as an |
| # executable named epoll-ltp, and tests the epoll_{create,ctl} |
| # syscalls. |
| if full_test_name == "syscalls.epoll-ltp": |
| full_test_name = "syscalls.epoll01" |
| self.syscall_tests[syscall["name"]].append(full_test_name) |
| for e in EXTERNAL_TESTS: |
| if e[0] == syscall["name"]: |
| self.syscall_tests[syscall["name"]].append(e[1]) |
| self.cki_syscalls.sort(key=lambda tup: tup["name"]) |
| |
| def update_test_status(self): |
| """Populate test configuration and output for all CKI syscalls. |
| |
| Go through VTS test configuration to populate data for all CKI syscalls. |
| """ |
| for syscall in self.cki_syscalls: |
| self.disabled_tests[syscall["name"]] = [] |
| if not self.syscall_tests[syscall["name"]]: |
| continue |
| for full_test_name in self.syscall_tests[syscall["name"]]: |
| if full_test_name in [t[1] for t in EXTERNAL_TESTS]: |
| continue |
| _, test = full_test_name.split('.') |
| # The VTS LTP stable list is composed of tuples of the test name and |
| # a boolean flag indicating whether it is mandatory. |
| stable_vts_ltp_testnames = [i[0] for i in self.stable_in_vts_ltp] |
| if (test in self.disabled_in_ltp or |
| full_test_name in self.disabled_in_vts_ltp or |
| ("%s_32bit" % full_test_name not in stable_vts_ltp_testnames and |
| "%s_64bit" % full_test_name not in stable_vts_ltp_testnames)): |
| self.disabled_tests[syscall["name"]].append(full_test_name) |
| continue |
| |
| def syscall_arch_string(self, syscall, arch): |
| """Return a string showing whether the arch supports the given syscall.""" |
| if arch not in syscall or not syscall[arch]: |
| return " " |
| else: |
| return "*" |
| |
| def output_results(self): |
| """Pretty print the CKI syscall LTP coverage.""" |
| count = 0 |
| uncovered = 0 |
| |
| print "" |
| print " Covered Syscalls" |
| for syscall in self.cki_syscalls: |
| if (len(self.syscall_tests[syscall["name"]]) - |
| len(self.disabled_tests[syscall["name"]]) <= 0): |
| continue |
| if not count % 20: |
| print ("%25s Disabled Enabled arm64 arm x86_64 x86 -----------" % |
| "-------------") |
| enabled = (len(self.syscall_tests[syscall["name"]]) - |
| len(self.disabled_tests[syscall["name"]])) |
| if enabled > 9: |
| column_sp = " " |
| else: |
| column_sp = " " |
| sys.stdout.write("%25s %s %s%s%s %s %s %s\n" % |
| (syscall["name"], len(self.disabled_tests[syscall["name"]]), |
| enabled, column_sp, |
| self.syscall_arch_string(syscall, "arm64"), |
| self.syscall_arch_string(syscall, "arm"), |
| self.syscall_arch_string(syscall, "x86_64"), |
| self.syscall_arch_string(syscall, "x86"))) |
| count += 1 |
| |
| count = 0 |
| print "\n" |
| print " Uncovered Syscalls" |
| for syscall in self.cki_syscalls: |
| if (len(self.syscall_tests[syscall["name"]]) - |
| len(self.disabled_tests[syscall["name"]]) > 0): |
| continue |
| if not count % 20: |
| print ("%25s Disabled Enabled arm64 arm x86_64 x86 -----------" % |
| "-------------") |
| enabled = (len(self.syscall_tests[syscall["name"]]) - |
| len(self.disabled_tests[syscall["name"]])) |
| if enabled > 9: |
| column_sp = " " |
| else: |
| column_sp = " " |
| sys.stdout.write("%25s %s %s%s%s %s %s %s\n" % |
| (syscall["name"], len(self.disabled_tests[syscall["name"]]), |
| enabled, column_sp, |
| self.syscall_arch_string(syscall, "arm64"), |
| self.syscall_arch_string(syscall, "arm"), |
| self.syscall_arch_string(syscall, "x86_64"), |
| self.syscall_arch_string(syscall, "x86"))) |
| uncovered += 1 |
| count += 1 |
| |
| print "" |
| print ("Total uncovered syscalls: %s out of %s" % |
| (uncovered, len(self.cki_syscalls))) |
| |
| def output_summary(self): |
| """Print a one line summary of the CKI syscall LTP coverage. |
| |
| Pretty prints a one line summary of the CKI syscall coverage in LTP |
| for the specified architecture. |
| """ |
| uncovered_with_test = 0 |
| uncovered_without_test = 0 |
| for syscall in self.cki_syscalls: |
| if (len(self.syscall_tests[syscall["name"]]) - |
| len(self.disabled_tests[syscall["name"]]) > 0): |
| continue |
| if (len(self.disabled_tests[syscall["name"]]) > 0): |
| uncovered_with_test += 1 |
| else: |
| uncovered_without_test += 1 |
| print ("arch, cki syscalls, uncovered with disabled test(s), " |
| "uncovered with no tests, total uncovered") |
| print ("%s, %s, %s, %s, %s" % (self._arch, len(self.cki_syscalls), |
| uncovered_with_test, uncovered_without_test, |
| uncovered_with_test + uncovered_without_test)) |
| |
| def add_syscall(self, cki, syscall, arch): |
| """Note that a syscall has been seen for a particular arch.""" |
| seen = False |
| for s in cki.syscalls: |
| if s["name"] == syscall: |
| s[arch]= True |
| seen = True |
| break |
| if not seen: |
| cki.syscalls.append({"name":syscall, arch:True}) |
| |
| def delete_syscall(self, cki, syscall): |
| cki.syscalls = list(filter(lambda i: i["name"] != syscall, cki.syscalls)) |
| |
| def check_blacklist(self, cki, error_on_match): |
| unlisted_syscalls = [] |
| for s in cki.syscalls: |
| if s["name"] in CKI_BLACKLIST: |
| if error_on_match: |
| print "Syscall %s found in both bionic CKI and blacklist!" % s["name"] |
| sys.exit() |
| else: |
| unlisted_syscalls.append(s) |
| cki.syscalls = unlisted_syscalls |
| |
| def get_x86_64_kernel_syscalls(self, cki): |
| """Retrieve the list of syscalls for x86_64.""" |
| proc = subprocess.Popen(['curl', x86_64_syscall_tbl_url], stdout=subprocess.PIPE) |
| while True: |
| line = proc.stdout.readline() |
| if line != b'': |
| test_re = re.compile(r"^\d+\s+\w+\s+(\w+)\s+(__x64_sys|__x32_compat_sys)") |
| test_match = re.match(test_re, line) |
| if test_match: |
| syscall = test_match.group(1) |
| self.add_syscall(cki, syscall, "x86_64") |
| else: |
| break |
| |
| def get_x86_kernel_syscalls(self, cki): |
| """Retrieve the list of syscalls for x86.""" |
| proc = subprocess.Popen(['curl', x86_syscall_tbl_url], stdout=subprocess.PIPE) |
| while True: |
| line = proc.stdout.readline() |
| if line != b'': |
| test_re = re.compile(r"^\d+\s+i386\s+(\w+)\s+sys_") |
| test_match = re.match(test_re, line) |
| if test_match: |
| syscall = test_match.group(1) |
| self.add_syscall(cki, syscall, "x86") |
| else: |
| break |
| |
| def get_arm_kernel_syscalls(self, cki): |
| """Retrieve the list of syscalls for arm.""" |
| proc = subprocess.Popen(['curl', arm_syscall_tbl_url], stdout=subprocess.PIPE) |
| while True: |
| line = proc.stdout.readline() |
| if line != b'': |
| test_re = re.compile(r"^\d+\s+\w+\s+(\w+)\s+sys_") |
| test_match = re.match(test_re, line) |
| if test_match: |
| syscall = test_match.group(1) |
| self.add_syscall(cki, syscall, "arm") |
| else: |
| break |
| |
| def get_arm64_kernel_syscalls(self, cki): |
| """Retrieve the list of syscalls for arm64.""" |
| # Add AArch64 syscalls |
| proc = subprocess.Popen(['curl', unistd_h_url], stdout=subprocess.PIPE) |
| while True: |
| line = proc.stdout.readline() |
| if line != b'': |
| test_re = re.compile(r"^#define __NR(3264)?_(\w+)\s+(\d+)$") |
| test_match = re.match(test_re, line) |
| if test_match: |
| syscall = test_match.group(2) |
| if (syscall == "sync_file_range2" or |
| syscall == "arch_specific_syscall" or |
| syscall == "syscalls"): |
| continue |
| self.add_syscall(cki, syscall, "arm64") |
| else: |
| break |
| # Add AArch32 syscalls |
| proc = subprocess.Popen(['curl', arm64_unistd32_h_url], stdout=subprocess.PIPE) |
| while True: |
| line = proc.stdout.readline() |
| if line != b'': |
| test_re = re.compile(r"^#define __NR(3264)?_(\w+)\s+(\d+)$") |
| test_match = re.match(test_re, line) |
| if test_match: |
| syscall = test_match.group(2) |
| self.add_syscall(cki, syscall, "arm64") |
| else: |
| break |
| |
| def get_kernel_syscalls(self, cki, arch): |
| self.get_arm64_kernel_syscalls(cki) |
| self.get_arm_kernel_syscalls(cki) |
| self.get_x86_kernel_syscalls(cki) |
| self.get_x86_64_kernel_syscalls(cki) |
| |
| # restart_syscall is a special syscall which the kernel issues internally |
| # when a process is resumed with SIGCONT. seccomp whitelists this syscall, |
| # but it is not part of the CKI or meaningfully testable from userspace. |
| # See restart_syscall(2) for more details. |
| self.delete_syscall(cki, "restart_syscall") |
| |
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser(description="Output list of system calls " |
| "in the Common Kernel Interface and their VTS LTP coverage.") |
| parser.add_argument("-a", "--arch", help="only show syscall CKI for specific arch") |
| parser.add_argument("-l", action="store_true", |
| help="list CKI syscalls only, without coverage") |
| parser.add_argument("-s", action="store_true", |
| help="print one line summary of CKI coverage for arch") |
| parser.add_argument("-f", action="store_true", |
| help="only check syscalls with known Android use") |
| parser.add_argument("-k", action="store_true", |
| help="use lowest supported kernel version instead of tip") |
| |
| args = parser.parse_args() |
| if args.arch is not None and args.arch not in gensyscalls.all_arches: |
| print "Arch must be one of the following:" |
| print gensyscalls.all_arches |
| exit(-1) |
| |
| if args.k: |
| minversion = "4.9" |
| print "Checking kernel version %s" % minversion |
| minversion = "?h=v" + minversion |
| unistd_h_url += stable_url + unistd_h + minversion |
| arm64_unistd32_h_url += stable_url + arm64_unistd32_h + minversion |
| arm_syscall_tbl_url += stable_url + arm_syscall_tbl + minversion |
| x86_syscall_tbl_url += stable_url + x86_syscall_tbl + minversion |
| x86_64_syscall_tbl_url += stable_url + x86_64_syscall_tbl + minversion |
| else: |
| unistd_h_url += tip_url + unistd_h |
| arm64_unistd32_h_url += tip_url + arm64_unistd32_h |
| arm_syscall_tbl_url += tip_url + arm_syscall_tbl |
| x86_syscall_tbl_url += tip_url + x86_syscall_tbl |
| x86_64_syscall_tbl_url += tip_url + x86_64_syscall_tbl |
| |
| cki = gensyscalls.SysCallsTxtParser() |
| cki_cov = CKI_Coverage(args.arch) |
| |
| if args.f: |
| cki.parse_file(os.path.join(bionic_libc_root, "SYSCALLS.TXT")) |
| cki.parse_file(os.path.join(bionic_libc_root, "SECCOMP_WHITELIST_APP.TXT")) |
| cki.parse_file(os.path.join(bionic_libc_root, "SECCOMP_WHITELIST_COMMON.TXT")) |
| cki.parse_file(os.path.join(bionic_libc_root, "SECCOMP_WHITELIST_SYSTEM.TXT")) |
| cki.parse_file(os.path.join(bionic_libc_root, "SECCOMP_WHITELIST_GLOBAL.TXT")) |
| cki_cov.check_blacklist(cki, True) |
| else: |
| cki_cov.get_kernel_syscalls(cki, args.arch) |
| cki_cov.check_blacklist(cki, False) |
| |
| if args.l: |
| for syscall in cki.syscalls: |
| if args.arch is None or syscall[args.arch]: |
| print syscall["name"] |
| exit(0) |
| |
| cki_cov.load_ltp_tests() |
| cki_cov.load_ltp_disabled_tests() |
| cki_cov.match_syscalls_to_tests(cki.syscalls) |
| cki_cov.update_test_status() |
| |
| beta_string = ("*** WARNING: This script is still in development and may\n" |
| "*** report both false positives and negatives.") |
| print beta_string |
| |
| if args.s: |
| cki_cov.output_summary() |
| exit(0) |
| |
| cki_cov.output_results() |
| print beta_string |
