- Linux-kselftest-mirror - lists.linaro.org

[stable-rc-5.4 and 5.5 ] WARNING: CPU: 3 PID: 2548 at /usr/src/kernel/lib/refcount.c:28 refcount_warn_saturate

by Naresh Kamboju

While running selftests binderfs_test on stable rc 5.4 and 5.5 branches the following warning on arm64, arm, x86_64 and i386. This warning was noticed on Linus's tree and reported [1] and then Christian Brauner investigated this problem. FYI, We are running selftests source from stable rc 5.5 branch. [ 224.520090] ------------[ cut here ]------------ [ 224.521202] refcount_t: underflow; use-after-free. [ 224.522284] WARNING: CPU: 3 PID: 2548 at /usr/src/kernel/lib/refcount.c:28 refcount_warn_saturate+0x93/0x100 [ 224.523215] Modules linked in: cls_bpf sch_fq sch_ingress algif_hash af_alg fuse [last unloaded: test_bpf] [ 224.523215] CPU: 3 PID: 2548 Comm: binderfs_test Not tainted 5.5.10-rc1 #1 [ 224.526771] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.12.0-1 04/01/2014 [ 224.526771] RIP: 0010:refcount_warn_saturate+0x93/0x100 [ 224.526771] Code: 38 73 62 01 01 e8 3d c2 b6 ff 0f 0b 5d c3 80 3d 2a 73 62 01 00 75 ab 48 c7 c7 70 b0 00 92 c6 05 1a 73 62 01 01 e8 1d c2 b6 ff <0f> 0b 5d c3 80 3d 0d 73 62 01 00 75 8b 48 c7 c7 f8 af 00 92 c6 05 [ 224.526771] RSP: 0018:ffffaaa081417c58 EFLAGS: 00010286 [ 224.526771] RAX: 0000000000000000 RBX: ffff9e77f1ed2c40 RCX: 0000000000000000 [ 224.526771] RDX: 0000000000000001 RSI: ffff9e77fbd98d48 RDI: ffff9e77fbd98d48 [ 224.526771] RBP: ffffaaa081417c58 R08: 0000000000000000 R09: 0000000000000000 [ 224.526771] R10: 0000000000000000 R11: 0000000000000000 R12: ffff9e77fa99f400 [ 224.526771] R13: ffff9e77ee42bbc0 R14: ffff9e77f1ed2cc8 R15: ffffffff92400300 [ 224.526771] FS: 00007f9e5d8824c0(0000) GS:ffff9e77fbd80000(0000) knlGS:0000000000000000 [ 224.526771] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 224.526771] CR2: 00007f9e5d41ff7c CR3: 000000012cbc2000 CR4: 00000000003406e0 [ 224.526771] Call Trace: [ 224.526771] binderfs_evict_inode+0x9b/0xc0 [ 224.526771] evict+0xc8/0x190 [ 224.526771] iput+0x19c/0x2a0 [ 224.526771] ? shrink_dentry_list+0x29/0x210 [ 224.526771] dentry_unlink_inode+0x104/0x110 [ 224.526771] __dentry_kill+0xda/0x180 [ 224.526771] shrink_dentry_list+0xe3/0x210 [ 224.526771] shrink_dcache_parent+0x11c/0x200 [ 224.526771] do_one_tree+0x12/0x40 [ 224.526771] shrink_dcache_for_umount+0x2d/0x90 [ 224.526771] generic_shutdown_super+0x1f/0x120 [ 224.526771] kill_anon_super+0x12/0x30 [ 224.526771] kill_litter_super+0x23/0x30 [ 224.526771] binderfs_kill_super+0x16/0x40 [ 224.526771] deactivate_locked_super+0x43/0x70 [ 224.526771] deactivate_super+0x40/0x60 [ 224.526771] cleanup_mnt+0xbd/0x150 [ 224.526771] __cleanup_mnt+0x12/0x20 [ 224.526771] task_work_run+0x90/0xc0 [ 224.526771] exit_to_usermode_loop+0xf0/0x100 [ 224.526771] do_syscall_64+0x1bf/0x200 [ 224.526771] entry_SYSCALL_64_after_hwframe+0x49/0xbe [ 224.526771] RIP: 0033:0x7f9e5d3a30c7 [ 224.526771] Code: ad 2b 00 f7 d8 64 89 01 48 83 c8 ff c3 66 0f 1f 44 00 00 31 f6 e9 09 00 00 00 66 0f 1f 84 00 00 00 00 00 b8 a6 00 00 00 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d a1 ad 2b 00 f7 d8 64 89 01 48 [ 224.526771] RSP: 002b:00007ffc35189ee8 EFLAGS: 00000206 ORIG_RAX: 00000000000000a6 [ 224.526771] RAX: 0000000000000000 RBX: 00007f9e5d882440 RCX: 00007f9e5d3a30c7 [ 224.526771] RDX: 0000000000000000 RSI: 0000000000000002 RDI: 000000000040192c [ 224.526771] RBP: 0000000000000002 R08: 0000000000000001 R09: 00007f9e5d3e23e0 [ 224.526771] R10: 000000000000079a R11: 0000000000000206 R12: 0000000000000001 [ 224.526771] R13: 0000000000000000 R14: 0000000000000000 R15: 0000000000000000 [ 224.526771] irq event stamp: 1776 [ 224.526771] hardirqs last enabled at (1775): [<ffffffff909751b8>] console_unlock+0x458/0x5c0 [ 224.526771] hardirqs last disabled at (1776): [<ffffffff90801e9b>] trace_hardirqs_off_thunk+0x1a/0x1c [ 224.526771] softirqs last enabled at (1772): [<ffffffff91a00338>] __do_softirq+0x338/0x43a [ 224.526771] softirqs last disabled at (1761): [<ffffffff90902b28>] irq_exit+0xb8/0xc0 [ 224.526771] ---[ end trace a9ce2ef5cd0b3086 ]--- ref: https://lkft.validation.linaro.org/scheduler/job/1294041#L8703 https://lkft.validation.linaro.org/scheduler/job/1294145#L9569 https://lkft.validation.linaro.org/scheduler/job/1294086#L11063 https://lkft.validation.linaro.org/scheduler/job/1293967#L9551 [1] https://lore.kernel.org/linux-kselftest/CA+G9fYusdfg7PMfC9Xce-xLT7NiyKSbgoj… -- Linaro LKFT https://lkft.linaro.org

5 years, 3 months

3
2
0 0

[PATCH v28 14/22] selftests/x86: Add a selftest for SGX

by Jarkko Sakkinen

Add a selftest for SGX. It is a trivial test where a simple enclave copies one 64-bit word of memory between two memory locations given to the enclave as arguments. Use ENCLS[EENTER] to invoke the enclave. Cc: linux-sgx(a)vger.kernel.org Cc: linux-kselftest(a)vger.kernel.org Signed-off-by: Jarkko Sakkinen <jarkko.sakkinen(a)linux.intel.com> --- tools/testing/selftests/x86/sgx/.gitignore | 3 + tools/testing/selftests/x86/sgx/Makefile | 48 ++ tools/testing/selftests/x86/sgx/defines.h | 17 + tools/testing/selftests/x86/sgx/encl.c | 20 + tools/testing/selftests/x86/sgx/encl.lds | 34 ++ .../selftests/x86/sgx/encl_bootstrap.S | 94 ++++ tools/testing/selftests/x86/sgx/main.c | 247 +++++++++ tools/testing/selftests/x86/sgx/sgx_call.S | 23 + tools/testing/selftests/x86/sgx/sgx_call.h | 11 + tools/testing/selftests/x86/sgx/sgxsign.c | 493 ++++++++++++++++++ .../testing/selftests/x86/sgx/signing_key.pem | 39 ++ 11 files changed, 1029 insertions(+) create mode 100644 tools/testing/selftests/x86/sgx/.gitignore create mode 100644 tools/testing/selftests/x86/sgx/Makefile create mode 100644 tools/testing/selftests/x86/sgx/defines.h create mode 100644 tools/testing/selftests/x86/sgx/encl.c create mode 100644 tools/testing/selftests/x86/sgx/encl.lds create mode 100644 tools/testing/selftests/x86/sgx/encl_bootstrap.S create mode 100644 tools/testing/selftests/x86/sgx/main.c create mode 100644 tools/testing/selftests/x86/sgx/sgx_call.S create mode 100644 tools/testing/selftests/x86/sgx/sgx_call.h create mode 100644 tools/testing/selftests/x86/sgx/sgxsign.c create mode 100644 tools/testing/selftests/x86/sgx/signing_key.pem diff --git a/tools/testing/selftests/x86/sgx/.gitignore b/tools/testing/selftests/x86/sgx/.gitignore new file mode 100644 index 000000000000..98eb2d439606 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/.gitignore @@ -0,0 +1,3 @@ +encl.ss +sgxsign +test_sgx diff --git a/tools/testing/selftests/x86/sgx/Makefile b/tools/testing/selftests/x86/sgx/Makefile new file mode 100644 index 000000000000..f838700029e2 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/Makefile @@ -0,0 +1,48 @@ +top_srcdir = ../../../../.. + +include ../../lib.mk + +ifndef OBJCOPY +OBJCOPY := $(CROSS_COMPILE)objcopy +endif + +INCLUDES := -I$(top_srcdir)/tools/include +HOST_CFLAGS := -Wall -Werror -g $(INCLUDES) -fPIC -z noexecstack +ENCL_CFLAGS := -Wall -Werror -static -nostdlib -nostartfiles -fPIC \ + -fno-stack-protector -mrdrnd $(INCLUDES) + +TEST_CUSTOM_PROGS := $(OUTPUT)/test_sgx $(OUTPUT)/encl.bin $(OUTPUT)/encl.ss + +all: $(TEST_CUSTOM_PROGS) + +$(OUTPUT)/test_sgx: $(OUTPUT)/main.o $(OUTPUT)/sgx_call.o + $(CC) $(HOST_CFLAGS) -o $@ $^ + +$(OUTPUT)/main.o: main.c + $(CC) $(HOST_CFLAGS) -c $< -o $@ + +$(OUTPUT)/sgx_call.o: sgx_call.S + $(CC) $(HOST_CFLAGS) -c $< -o $@ + +$(OUTPUT)/encl.bin: $(OUTPUT)/encl.elf $(OUTPUT)/sgxsign + $(OBJCOPY) -O binary $< $@ + +$(OUTPUT)/encl.elf: encl.lds encl.c encl_bootstrap.S + $(CC) $(ENCL_CFLAGS) -T $^ -o $@ + +$(OUTPUT)/encl.ss: $(OUTPUT)/encl.bin + $(OUTPUT)/sgxsign signing_key.pem $(OUTPUT)/encl.bin $(OUTPUT)/encl.ss + +$(OUTPUT)/sgxsign: sgxsign.c + $(CC) $(INCLUDES) -o $@ $< -lcrypto + +EXTRA_CLEAN := \ + $(OUTPUT)/encl.bin \ + $(OUTPUT)/encl.elf \ + $(OUTPUT)/encl.ss \ + $(OUTPUT)/sgx_call.o \ + $(OUTPUT)/sgxsign \ + $(OUTPUT)/test_sgx \ + $(OUTPUT)/test_sgx.o \ + +.PHONY: clean diff --git a/tools/testing/selftests/x86/sgx/defines.h b/tools/testing/selftests/x86/sgx/defines.h new file mode 100644 index 000000000000..87264f85cb9f --- /dev/null +++ b/tools/testing/selftests/x86/sgx/defines.h @@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright(c) 2016-19 Intel Corporation. + */ + +#ifndef DEFINES_H +#define DEFINES_H + +#include <stdint.h> + +#define __aligned(x) __attribute__((__aligned__(x))) +#define __packed __attribute__((packed)) + +#include "../../../../../arch/x86/kernel/cpu/sgx/arch.h" +#include "../../../../../arch/x86/include/uapi/asm/sgx.h" + +#endif /* DEFINES_H */ diff --git a/tools/testing/selftests/x86/sgx/encl.c b/tools/testing/selftests/x86/sgx/encl.c new file mode 100644 index 000000000000..ede915399742 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/encl.c @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) +// Copyright(c) 2016-18 Intel Corporation. + +#include <stddef.h> +#include "defines.h" + +static void *memcpy(void *dest, const void *src, size_t n) +{ + size_t i; + + for (i = 0; i < n; i++) + ((char *)dest)[i] = ((char *)src)[i]; + + return dest; +} + +void encl_body(void *rdi, void *rsi) +{ + memcpy(rsi, rdi, 8); +} diff --git a/tools/testing/selftests/x86/sgx/encl.lds b/tools/testing/selftests/x86/sgx/encl.lds new file mode 100644 index 000000000000..9a56d3064104 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/encl.lds @@ -0,0 +1,34 @@ +OUTPUT_FORMAT(elf64-x86-64) + +SECTIONS +{ + . = 0; + .tcs : { + *(.tcs*) + } + + . = ALIGN(4096); + .text : { + *(.text*) + *(.rodata*) + } + + . = ALIGN(4096); + .data : { + *(.data*) + } + + /DISCARD/ : { + *(.data*) + *(.comment*) + *(.note*) + *(.debug*) + *(.eh_frame*) + } +} + +ASSERT(!DEFINED(.altinstructions), "ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.altinstr_replacement), "ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.discard.retpoline_safe), "RETPOLINE ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.discard.nospec), "RETPOLINE ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.got.plt), "Libcalls are not supported in enclaves") diff --git a/tools/testing/selftests/x86/sgx/encl_bootstrap.S b/tools/testing/selftests/x86/sgx/encl_bootstrap.S new file mode 100644 index 000000000000..d07f970ccdf9 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/encl_bootstrap.S @@ -0,0 +1,94 @@ +/* SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) */ +/* + * Copyright(c) 2016-18 Intel Corporation. + */ + + .macro ENCLU + .byte 0x0f, 0x01, 0xd7 + .endm + + .section ".tcs", "a" + .balign 4096 + + .fill 1, 8, 0 # STATE (set by CPU) + .fill 1, 8, 0 # FLAGS + .quad encl_ssa # OSSA + .fill 1, 4, 0 # CSSA (set by CPU) + .fill 1, 4, 1 # NSSA + .quad encl_entry # OENTRY + .fill 1, 8, 0 # AEP (set by EENTER and ERESUME) + .fill 1, 8, 0 # OFSBASE + .fill 1, 8, 0 # OGSBASE + .fill 1, 4, 0xFFFFFFFF # FSLIMIT + .fill 1, 4, 0xFFFFFFFF # GSLIMIT + .fill 4024, 1, 0 # Reserved + + .text + +encl_entry: + # RBX contains the base address for TCS, which is also the first address + # inside the enclave. By adding the value of le_stack_end to it, we get + # the absolute address for the stack. + lea (encl_stack)(%rbx), %rax + xchg %rsp, %rax + push %rax + + push %rcx # push the address after EENTER + push %rbx # push the enclave base address + + call encl_body + + pop %rbx # pop the enclave base address + + # Restore XSAVE registers to a synthetic state. + mov $0xFFFFFFFF, %rax + mov $0xFFFFFFFF, %rdx + lea (xsave_area)(%rbx), %rdi + fxrstor (%rdi) + + # Clear GPRs. + xor %rcx, %rcx + xor %rdx, %rdx + xor %rdi, %rdi + xor %rsi, %rsi + xor %r8, %r8 + xor %r9, %r9 + xor %r10, %r10 + xor %r11, %r11 + xor %r12, %r12 + xor %r13, %r13 + xor %r14, %r14 + xor %r15, %r15 + + # Reset status flags. + add %rdx, %rdx # OF = SF = AF = CF = 0; ZF = PF = 1 + + # Prepare EEXIT target by popping the address of the instruction after + # EENTER to RBX. + pop %rbx + + # Restore the caller stack. + pop %rax + mov %rax, %rsp + + # EEXIT + mov $4, %rax + enclu + + .section ".data", "aw" + +encl_ssa: + .space 4096 + +xsave_area: + .fill 1, 4, 0x037F # FCW + .fill 5, 4, 0 + .fill 1, 4, 0x1F80 # MXCSR + .fill 1, 4, 0xFFFF # MXCSR_MASK + .fill 123, 4, 0 + .fill 1, 4, 0x80000000 # XCOMP_BV[63] = 1, compaction mode + .fill 12, 4, 0 + + .balign 4096 + .space 8192 +encl_stack: diff --git a/tools/testing/selftests/x86/sgx/main.c b/tools/testing/selftests/x86/sgx/main.c new file mode 100644 index 000000000000..48ed5fdfb3cb --- /dev/null +++ b/tools/testing/selftests/x86/sgx/main.c @@ -0,0 +1,247 @@ +// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) +// Copyright(c) 2016-18 Intel Corporation. + +#include <elf.h> +#include <errno.h> +#include <fcntl.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <sys/types.h> +#include "defines.h" +#include "sgx_call.h" + +#define PAGE_SIZE 4096 + +static const uint64_t MAGIC = 0x1122334455667788ULL; + +static bool encl_create(int dev_fd, unsigned long bin_size, + struct sgx_secs *secs) +{ + struct sgx_enclave_create ioc; + void *area; + int rc; + + memset(secs, 0, sizeof(*secs)); + secs->ssa_frame_size = 1; + secs->attributes = SGX_ATTR_MODE64BIT; + secs->xfrm = 3; + + for (secs->size = 4096; secs->size < bin_size; ) + secs->size <<= 1; + + area = mmap(NULL, secs->size * 2, PROT_NONE, MAP_SHARED, dev_fd, 0); + if (area == MAP_FAILED) { + perror("mmap"); + return false; + } + + secs->base = ((uint64_t)area + secs->size - 1) & ~(secs->size - 1); + + munmap(area, secs->base - (uint64_t)area); + munmap((void *)(secs->base + secs->size), + (uint64_t)area + secs->size - secs->base); + + ioc.src = (unsigned long)secs; + rc = ioctl(dev_fd, SGX_IOC_ENCLAVE_CREATE, &ioc); + if (rc) { + fprintf(stderr, "ECREATE failed rc=%d, err=%d.\n", rc, errno); + munmap((void *)secs->base, secs->size); + return false; + } + + return true; +} + +static bool encl_add_pages(int dev_fd, unsigned long offset, void *data, + unsigned long length, uint64_t flags) +{ + struct sgx_enclave_add_pages ioc; + struct sgx_secinfo secinfo; + int rc; + + memset(&secinfo, 0, sizeof(secinfo)); + secinfo.flags = flags; + + ioc.src = (uint64_t)data; + ioc.offset = offset; + ioc.length = length; + ioc.secinfo = (unsigned long)&secinfo; + ioc.flags = SGX_PAGE_MEASURE; + + rc = ioctl(dev_fd, SGX_IOC_ENCLAVE_ADD_PAGES, &ioc); + if (rc) { + fprintf(stderr, "EADD failed rc=%d.\n", rc); + return false; + } + + if (ioc.count != ioc.length) { + fprintf(stderr, "Partially processed, update the test.\n"); + return false; + } + + return true; +} + +#define SGX_REG_PAGE_FLAGS \ + (SGX_SECINFO_REG | SGX_SECINFO_R | SGX_SECINFO_W | SGX_SECINFO_X) + +static bool encl_build(struct sgx_secs *secs, void *bin, + unsigned long bin_size, struct sgx_sigstruct *sigstruct) +{ + struct sgx_enclave_init ioc; + void *addr; + int dev_fd; + int rc; + + dev_fd = open("/dev/sgx/enclave", O_RDWR); + if (dev_fd < 0) { + fprintf(stderr, "Unable to open /dev/sgx\n"); + return false; + } + + if (!encl_create(dev_fd, bin_size, secs)) + goto out_dev_fd; + + if (!encl_add_pages(dev_fd, 0, bin, PAGE_SIZE, SGX_SECINFO_TCS)) + goto out_dev_fd; + + if (!encl_add_pages(dev_fd, PAGE_SIZE, bin + PAGE_SIZE, + bin_size - PAGE_SIZE, SGX_REG_PAGE_FLAGS)) + goto out_dev_fd; + + ioc.sigstruct = (uint64_t)sigstruct; + rc = ioctl(dev_fd, SGX_IOC_ENCLAVE_INIT, &ioc); + if (rc) { + printf("EINIT failed rc=%d\n", rc); + goto out_map; + } + + addr = mmap((void *)secs->base, PAGE_SIZE, PROT_READ | PROT_WRITE, + MAP_SHARED | MAP_FIXED, dev_fd, 0); + if (addr == MAP_FAILED) { + fprintf(stderr, "mmap() failed on TCS, errno=%d.\n", errno); + return false; + } + + addr = mmap((void *)(secs->base + PAGE_SIZE), bin_size - PAGE_SIZE, + PROT_READ | PROT_WRITE | PROT_EXEC, + MAP_SHARED | MAP_FIXED, dev_fd, 0); + if (addr == MAP_FAILED) { + fprintf(stderr, "mmap() failed, errno=%d.\n", errno); + return false; + } + + close(dev_fd); + return true; +out_map: + munmap((void *)secs->base, secs->size); +out_dev_fd: + close(dev_fd); + return false; +} + +bool get_file_size(const char *path, off_t *bin_size) +{ + struct stat sb; + int ret; + + ret = stat(path, &sb); + if (ret) { + perror("stat"); + return false; + } + + if (!sb.st_size || sb.st_size & 0xfff) { + fprintf(stderr, "Invalid blob size %lu\n", sb.st_size); + return false; + } + + *bin_size = sb.st_size; + return true; +} + +bool encl_data_map(const char *path, void **bin, off_t *bin_size) +{ + int fd; + + fd = open(path, O_RDONLY); + if (fd == -1) { + fprintf(stderr, "open() %s failed, errno=%d.\n", path, errno); + return false; + } + + if (!get_file_size(path, bin_size)) + goto err_out; + + *bin = mmap(NULL, *bin_size, PROT_READ, MAP_PRIVATE, fd, 0); + if (*bin == MAP_FAILED) { + fprintf(stderr, "mmap() %s failed, errno=%d.\n", path, errno); + goto err_out; + } + + close(fd); + return true; + +err_out: + close(fd); + return false; +} + +bool load_sigstruct(const char *path, void *sigstruct) +{ + int fd; + + fd = open(path, O_RDONLY); + if (fd == -1) { + fprintf(stderr, "open() %s failed, errno=%d.\n", path, errno); + return false; + } + + if (read(fd, sigstruct, sizeof(struct sgx_sigstruct)) != + sizeof(struct sgx_sigstruct)) { + fprintf(stderr, "read() %s failed, errno=%d.\n", path, errno); + close(fd); + return false; + } + + close(fd); + return true; +} + +int main(int argc, char *argv[], char *envp[]) +{ + struct sgx_sigstruct sigstruct; + struct sgx_secs secs; + uint64_t result = 0; + off_t bin_size; + void *bin; + + if (!encl_data_map("encl.bin", &bin, &bin_size)) + exit(1); + + if (!load_sigstruct("encl.ss", &sigstruct)) + exit(1); + + if (!encl_build(&secs, bin, bin_size, &sigstruct)) + exit(1); + + printf("Input: 0x%lx\n", MAGIC); + + sgx_call_eenter((void *)&MAGIC, &result, (void *)secs.base); + if (result != MAGIC) { + fprintf(stderr, "0x%lx != 0x%lx\n", result, MAGIC); + exit(1); + } + + printf("Output: 0x%lx\n", result); + + exit(0); +} diff --git a/tools/testing/selftests/x86/sgx/sgx_call.S b/tools/testing/selftests/x86/sgx/sgx_call.S new file mode 100644 index 000000000000..ca4c7893f9d9 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/sgx_call.S @@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) */ +/** +* Copyright(c) 2016-18 Intel Corporation. +*/ + + .text + + .macro ENCLU + .byte 0x0f, 0x01, 0xd7 + .endm + + .text + + .global sgx_call_eenter +sgx_call_eenter: + push %rbx + mov $0x02, %rax + mov %rdx, %rbx + lea sgx_async_exit(%rip), %rcx +sgx_async_exit: + ENCLU + pop %rbx + ret diff --git a/tools/testing/selftests/x86/sgx/sgx_call.h b/tools/testing/selftests/x86/sgx/sgx_call.h new file mode 100644 index 000000000000..bf72068ada23 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/sgx_call.h @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright(c) 2016-19 Intel Corporation. + */ + +#ifndef SGX_CALL_H +#define SGX_CALL_H + +void sgx_call_eenter(void *rdi, void *rsi, void *entry); + +#endif /* SGX_CALL_H */ diff --git a/tools/testing/selftests/x86/sgx/sgxsign.c b/tools/testing/selftests/x86/sgx/sgxsign.c new file mode 100644 index 000000000000..3d9007af40c9 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/sgxsign.c @@ -0,0 +1,493 @@ +// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) +// Copyright(c) 2016-18 Intel Corporation. + +#define _GNU_SOURCE +#include <getopt.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <unistd.h> +#include <openssl/err.h> +#include <openssl/pem.h> +#include "defines.h" + +struct sgx_sigstruct_payload { + struct sgx_sigstruct_header header; + struct sgx_sigstruct_body body; +}; + +static bool check_crypto_errors(void) +{ + int err; + bool had_errors = false; + const char *filename; + int line; + char str[256]; + + for ( ; ; ) { + if (ERR_peek_error() == 0) + break; + + had_errors = true; + err = ERR_get_error_line(&filename, &line); + ERR_error_string_n(err, str, sizeof(str)); + fprintf(stderr, "crypto: %s: %s:%d\n", str, filename, line); + } + + return had_errors; +} + +static void exit_usage(const char *program) +{ + fprintf(stderr, + "Usage: %s/sign-le <key> <enclave> <sigstruct>\n", program); + exit(1); +} + +static inline const BIGNUM *get_modulus(RSA *key) +{ +#if OPENSSL_VERSION_NUMBER < 0x10100000L + return key->n; +#else + const BIGNUM *n; + + RSA_get0_key(key, &n, NULL, NULL); + return n; +#endif +} + +static RSA *load_sign_key(const char *path) +{ + FILE *f; + RSA *key; + + f = fopen(path, "rb"); + if (!f) { + fprintf(stderr, "Unable to open %s\n", path); + return NULL; + } + key = RSA_new(); + if (!PEM_read_RSAPrivateKey(f, &key, NULL, NULL)) + return NULL; + fclose(f); + + if (BN_num_bytes(get_modulus(key)) != SGX_MODULUS_SIZE) { + fprintf(stderr, "Invalid key size %d\n", + BN_num_bytes(get_modulus(key))); + RSA_free(key); + return NULL; + } + + return key; +} + +static void reverse_bytes(void *data, int length) +{ + int i = 0; + int j = length - 1; + uint8_t temp; + uint8_t *ptr = data; + + while (i < j) { + temp = ptr[i]; + ptr[i] = ptr[j]; + ptr[j] = temp; + i++; + j--; + } +} + +enum mrtags { + MRECREATE = 0x0045544145524345, + MREADD = 0x0000000044444145, + MREEXTEND = 0x00444E4554584545, +}; + +static bool mrenclave_update(EVP_MD_CTX *ctx, const void *data) +{ + if (!EVP_DigestUpdate(ctx, data, 64)) { + fprintf(stderr, "digest update failed\n"); + return false; + } + + return true; +} + +static bool mrenclave_commit(EVP_MD_CTX *ctx, uint8_t *mrenclave) +{ + unsigned int size; + + if (!EVP_DigestFinal_ex(ctx, (unsigned char *)mrenclave, &size)) { + fprintf(stderr, "digest commit failed\n"); + return false; + } + + if (size != 32) { + fprintf(stderr, "invalid digest size = %u\n", size); + return false; + } + + return true; +} + +struct mrecreate { + uint64_t tag; + uint32_t ssaframesize; + uint64_t size; + uint8_t reserved[44]; +} __attribute__((__packed__)); + + +static bool mrenclave_ecreate(EVP_MD_CTX *ctx, uint64_t blob_size) +{ + struct mrecreate mrecreate; + uint64_t encl_size; + + for (encl_size = 0x1000; encl_size < blob_size; ) + encl_size <<= 1; + + memset(&mrecreate, 0, sizeof(mrecreate)); + mrecreate.tag = MRECREATE; + mrecreate.ssaframesize = 1; + mrecreate.size = encl_size; + + if (!EVP_DigestInit_ex(ctx, EVP_sha256(), NULL)) + return false; + + return mrenclave_update(ctx, &mrecreate); +} + +struct mreadd { + uint64_t tag; + uint64_t offset; + uint64_t flags; /* SECINFO flags */ + uint8_t reserved[40]; +} __attribute__((__packed__)); + +static bool mrenclave_eadd(EVP_MD_CTX *ctx, uint64_t offset, uint64_t flags) +{ + struct mreadd mreadd; + + memset(&mreadd, 0, sizeof(mreadd)); + mreadd.tag = MREADD; + mreadd.offset = offset; + mreadd.flags = flags; + + return mrenclave_update(ctx, &mreadd); +} + +struct mreextend { + uint64_t tag; + uint64_t offset; + uint8_t reserved[48]; +} __attribute__((__packed__)); + +static bool mrenclave_eextend(EVP_MD_CTX *ctx, uint64_t offset, uint8_t *data) +{ + struct mreextend mreextend; + int i; + + for (i = 0; i < 0x1000; i += 0x100) { + memset(&mreextend, 0, sizeof(mreextend)); + mreextend.tag = MREEXTEND; + mreextend.offset = offset + i; + + if (!mrenclave_update(ctx, &mreextend)) + return false; + + if (!mrenclave_update(ctx, &data[i + 0x00])) + return false; + + if (!mrenclave_update(ctx, &data[i + 0x40])) + return false; + + if (!mrenclave_update(ctx, &data[i + 0x80])) + return false; + + if (!mrenclave_update(ctx, &data[i + 0xC0])) + return false; + } + + return true; +} + +/** + * measure_encl - measure enclave + * @path: path to the enclave + * @mrenclave: measurement + * + * Calculates MRENCLAVE. Assumes that the very first page is a TCS page and + * following pages are regular pages. Does not measure the contents of the + * enclave as the signing tool is used at the moment only for the launch + * enclave, which is pass-through (everything gets a token). + */ +static bool measure_encl(const char *path, uint8_t *mrenclave) +{ + FILE *file; + struct stat sb; + EVP_MD_CTX *ctx; + uint64_t flags; + uint64_t offset; + uint8_t data[0x1000]; + int rc; + + ctx = EVP_MD_CTX_create(); + if (!ctx) + return false; + + file = fopen(path, "rb"); + if (!file) { + perror("fopen"); + EVP_MD_CTX_destroy(ctx); + return false; + } + + rc = stat(path, &sb); + if (rc) { + perror("stat"); + goto out; + } + + if (!sb.st_size || sb.st_size & 0xfff) { + fprintf(stderr, "Invalid blob size %lu\n", sb.st_size); + goto out; + } + + if (!mrenclave_ecreate(ctx, sb.st_size)) + goto out; + + for (offset = 0; offset < sb.st_size; offset += 0x1000) { + if (!offset) + flags = SGX_SECINFO_TCS; + else + flags = SGX_SECINFO_REG | SGX_SECINFO_R | + SGX_SECINFO_W | SGX_SECINFO_X; + + if (!mrenclave_eadd(ctx, offset, flags)) + goto out; + + rc = fread(data, 1, 0x1000, file); + if (!rc) + break; + if (rc < 0x1000) + goto out; + + if (!mrenclave_eextend(ctx, offset, data)) + goto out; + } + + if (!mrenclave_commit(ctx, mrenclave)) + goto out; + + fclose(file); + EVP_MD_CTX_destroy(ctx); + return true; +out: + fclose(file); + EVP_MD_CTX_destroy(ctx); + return false; +} + +/** + * sign_encl - sign enclave + * @sigstruct: pointer to SIGSTRUCT + * @key: 3072-bit RSA key + * @signature: byte array for the signature + * + * Calculates EMSA-PKCSv1.5 signature for the given SIGSTRUCT. The result is + * stored in big-endian format so that it can be further passed to OpenSSL + * libcrypto functions. + */ +static bool sign_encl(const struct sgx_sigstruct *sigstruct, RSA *key, + uint8_t *signature) +{ + struct sgx_sigstruct_payload payload; + unsigned int siglen; + uint8_t digest[SHA256_DIGEST_LENGTH]; + bool ret; + + memcpy(&payload.header, &sigstruct->header, sizeof(sigstruct->header)); + memcpy(&payload.body, &sigstruct->body, sizeof(sigstruct->body)); + + SHA256((unsigned char *)&payload, sizeof(payload), digest); + + ret = RSA_sign(NID_sha256, digest, SHA256_DIGEST_LENGTH, signature, + &siglen, key); + + return ret; +} + +struct q1q2_ctx { + BN_CTX *bn_ctx; + BIGNUM *m; + BIGNUM *s; + BIGNUM *q1; + BIGNUM *qr; + BIGNUM *q2; +}; + +static void free_q1q2_ctx(struct q1q2_ctx *ctx) +{ + BN_CTX_free(ctx->bn_ctx); + BN_free(ctx->m); + BN_free(ctx->s); + BN_free(ctx->q1); + BN_free(ctx->qr); + BN_free(ctx->q2); +} + +static bool alloc_q1q2_ctx(const uint8_t *s, const uint8_t *m, + struct q1q2_ctx *ctx) +{ + ctx->bn_ctx = BN_CTX_new(); + ctx->s = BN_bin2bn(s, SGX_MODULUS_SIZE, NULL); + ctx->m = BN_bin2bn(m, SGX_MODULUS_SIZE, NULL); + ctx->q1 = BN_new(); + ctx->qr = BN_new(); + ctx->q2 = BN_new(); + + if (!ctx->bn_ctx || !ctx->s || !ctx->m || !ctx->q1 || !ctx->qr || + !ctx->q2) { + free_q1q2_ctx(ctx); + return false; + } + + return true; +} + +static bool calc_q1q2(const uint8_t *s, const uint8_t *m, uint8_t *q1, + uint8_t *q2) +{ + struct q1q2_ctx ctx; + + if (!alloc_q1q2_ctx(s, m, &ctx)) { + fprintf(stderr, "Not enough memory for Q1Q2 calculation\n"); + return false; + } + + if (!BN_mul(ctx.q1, ctx.s, ctx.s, ctx.bn_ctx)) + goto out; + + if (!BN_div(ctx.q1, ctx.qr, ctx.q1, ctx.m, ctx.bn_ctx)) + goto out; + + if (BN_num_bytes(ctx.q1) > SGX_MODULUS_SIZE) { + fprintf(stderr, "Too large Q1 %d bytes\n", + BN_num_bytes(ctx.q1)); + goto out; + } + + if (!BN_mul(ctx.q2, ctx.s, ctx.qr, ctx.bn_ctx)) + goto out; + + if (!BN_div(ctx.q2, NULL, ctx.q2, ctx.m, ctx.bn_ctx)) + goto out; + + if (BN_num_bytes(ctx.q2) > SGX_MODULUS_SIZE) { + fprintf(stderr, "Too large Q2 %d bytes\n", + BN_num_bytes(ctx.q2)); + goto out; + } + + BN_bn2bin(ctx.q1, q1); + BN_bn2bin(ctx.q2, q2); + + free_q1q2_ctx(&ctx); + return true; +out: + free_q1q2_ctx(&ctx); + return false; +} + +static bool save_sigstruct(const struct sgx_sigstruct *sigstruct, + const char *path) +{ + FILE *f = fopen(path, "wb"); + + if (!f) { + fprintf(stderr, "Unable to open %s\n", path); + return false; + } + + fwrite(sigstruct, sizeof(*sigstruct), 1, f); + fclose(f); + return true; +} + +int main(int argc, char **argv) +{ + uint64_t header1[2] = {0x000000E100000006, 0x0000000000010000}; + uint64_t header2[2] = {0x0000006000000101, 0x0000000100000060}; + struct sgx_sigstruct ss; + const char *program; + int opt; + RSA *sign_key; + + memset(&ss, 0, sizeof(ss)); + ss.header.header1[0] = header1[0]; + ss.header.header1[1] = header1[1]; + ss.header.header2[0] = header2[0]; + ss.header.header2[1] = header2[1]; + ss.exponent = 3; + +#ifndef CONFIG_EINITTOKENKEY + ss.body.attributes = SGX_ATTR_MODE64BIT; +#else + ss.body.attributes = SGX_ATTR_MODE64BIT | SGX_ATTR_EINITTOKENKEY; +#endif + ss.body.xfrm = 3, + + program = argv[0]; + + do { + opt = getopt(argc, argv, ""); + switch (opt) { + case -1: + break; + default: + exit_usage(program); + } + } while (opt != -1); + + argc -= optind; + argv += optind; + + if (argc < 3) + exit_usage(program); + + /* sanity check only */ + if (check_crypto_errors()) + exit(1); + + sign_key = load_sign_key(argv[0]); + if (!sign_key) + goto out; + + BN_bn2bin(get_modulus(sign_key), ss.modulus); + + if (!measure_encl(argv[1], ss.body.mrenclave)) + goto out; + + if (!sign_encl(&ss, sign_key, ss.signature)) + goto out; + + if (!calc_q1q2(ss.signature, ss.modulus, ss.q1, ss.q2)) + goto out; + + /* convert to little endian */ + reverse_bytes(ss.signature, SGX_MODULUS_SIZE); + reverse_bytes(ss.modulus, SGX_MODULUS_SIZE); + reverse_bytes(ss.q1, SGX_MODULUS_SIZE); + reverse_bytes(ss.q2, SGX_MODULUS_SIZE); + + if (!save_sigstruct(&ss, argv[2])) + goto out; + exit(0); +out: + check_crypto_errors(); + exit(1); +} diff --git a/tools/testing/selftests/x86/sgx/signing_key.pem b/tools/testing/selftests/x86/sgx/signing_key.pem new file mode 100644 index 000000000000..d76f21f19187 --- /dev/null +++ b/tools/testing/selftests/x86/sgx/signing_key.pem @@ -0,0 +1,39 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIG4wIBAAKCAYEApalGbq7Q+usM91CPtksu3D+b0Prc8gAFL6grM3mg85A5Bx8V +cfMXPgtrw8EYFwQxDAvzZWwl+9VfOX0ECrFRBkOHcOiG0SnADN8+FLj1UiNUQwbp +S6OzhNWuRcSbGraSOyUlVlV0yMQSvewyzGklOaXBe30AJqzIBc8QfdSxKuP8rs0Z +ga6k/Bl73osrYKByILJTUUeZqjLERsE6GebsdzbWgKn8qVqng4ZS4yMNg6LeRlH3 ++9CIPgg4jwpSLHcp7dq2qTIB9a0tGe9ayp+5FbucpB6U7ePold0EeRN6RlJGDF9k +L93v8P5ykz5G5gYZ2g0K1X2sHIWV4huxPgv5PXgdyQYbK+6olqj0d5rjYuwX57Ul +k6SroPS1U6UbdCjG5txM+BNGU0VpD0ZhrIRw0leQdnNcCO9sTJuInZrgYacSVJ7u +mtB+uCt+uzUesc+l+xPRYA+9e14lLkZp7AAmo9FvL816XDI09deehJ3i/LmHKCRN +tuqC5TprRjFwUr6dAgEDAoIBgG5w2Z8fNfycs0+LCnmHdJLVEotR6KFVWMpwHMz7 +wKJgJgS/Y6FMuilc8oKAuroCy11dTO5IGVKOP3uorVx2NgQtBPXwWeDGgAiU1A3Q +o4wXjYIEm4fCd63jyYPYZ2ckYXzDbjmOTdstYdPyzIhGGNEZK6eoqsRzMAPfYFPj +IMdCqHSIu6vJw1K7p+myHOsVoWshjODaZnF3LYSA0WaZ8vokjwBxUxuRxQJZjJds +s60XPtmL+qfgWtQFewoG4XL6GuD8FcXccynRRtzrLtFNPIl9BQfWfjBBhTC1/Te1 +0Z6XbZvpdUTD9OfLB7SbR2OUFNpKQgriO0iYVdbW3cr7uu38Zwp4W1TX73DPjoi6 +KNooP6SGWd4mRJW2+dUmSYS4QNG8eVVZswKcploEIXlAKRsOe4kzJJ1iETugIe85 +uX8nd1WYEp65xwoRUg8hqng0MeyveVbXqNKuJG6tzNDt9kgFYo+hmC/oouAW2Dtc +T9jdRAwKJXqA2Eg6OkgXCEv+kwKBwQDYaQiFMlFhsmLlqI+EzCUh7c941/cL7m6U +7j98+8ngl0HgCEcrc10iJVCKakQW3YbPzAx3XkKTaGjWazvvrFarXIGlOud64B8a +iWyQ7VdlnmZnNEdk+C83tI91OQeaTKqRLDGzKh29Ry/jL8Pcbazt+kDgxa0H7qJp +roADUanLQuNkYubpbhFBh3xpa2EExaVq6rF7nIVsD8W9TrbmPKA4LgH7z0iy544D +kVCNYsTjYDdUWP+WiSor8kCnnpjnN9sCgcEAw/eNezUD1UDf6OYFC9+5JZJFn4Tg +mZMyN93JKIb199ffwnjtHUSjcyiWeesXucpzwtGbTcwQnDisSW4oneYKLSEBlBaq +scqiUugyGZZOthFSCbdXYXMViK2vHrKlkse7GxVlROKcEhM/pRBrmjaGO8eWR+D4 +FO2wCXzVs3KgV6j779frw0vC54oHOxc9+Lu1rSHp4i+600koyvL/zF6U/5tZXIvN +YW2yoiQJnjCmVA1pwbwV6KAUTPDTMnBK+YjnAoHBAJBGBa4hi5Z27JkbCliIGMFJ +NPs6pLKe9GNJf6in2+sPgUAFhMeiPhbDiwbxgrnpBIqICE+ULGJFmzmc0p/IOceT +ARjR76dAFLxbnbXzj5kURETNhO36yiUjCk4mBRGIcbYddndxaSjaH+zKgpLzyJ6m +1esuc1qfFvEfAAI2cTIsl5hB70ZJYNZaUvDyQK3ZGPHxy6e9rkgKg9OJz0QoatAe +q/002yHvtAJg4F5B2JeVejg7VQ8GHB1MKxppu0TP5wKBwQCCpQj8zgKOKz/wmViy +lSYZDC5qWJW7t3bP6TDFr06lOpUsUJ4TgxeiGw778g/RMaKB4RIz3WBoJcgw9BsT +7rFza1ZiucchMcGMmswRDt8kC4wGejpA92Owc8oUdxkMhSdnY5jYlxK2t3/DYEe8 +JFl9L7mFQKVjSSAGUzkiTGrlG1Kf5UfXh9dFBq98uilQfSPIwUaWynyM23CHTKqI +Pw3/vOY9sojrnncWwrEUIG7is5vWfWPwargzSzd29YdRBe8CgcEAuRVewK/YeNOX +B7ZG6gKKsfsvrGtY7FPETzLZAHjoVXYNea4LVZ2kn4hBXXlvw/4HD+YqcTt4wmif +5JQlDvjNobUiKJZpzy7hklVhF7wZFl4pCF7Yh43q9iQ7gKTaeUG7MiaK+G8Zz8aY +HW9rsiihbdZkccMvnPfO9334XMxl3HtBRzLstjUlbLB7Sdh+7tZ3JQidCOFNs5pE +XyWwnASPu4tKfDahH1UUTp1uJcq/6716CSWg080avYxFcn75qqsb +-----END RSA PRIVATE KEY----- -- 2.25.0

5 years, 3 months

5
17
0 0

[PATCH v4 0/5] kselftest: add fixture parameters

by Jakub Kicinski

Hi! Shuah please consider applying to the kselftest tree. This set is an attempt to make running tests for different sets of data easier. The direct motivation is the tls test which we'd like to run for TLS 1.2 and TLS 1.3, but currently there is no easy way to invoke the same tests with different parameters. Tested all users of kselftest_harness.h. v2: - don't run tests by fixture - don't pass params as an explicit argument v3: - go back to the orginal implementation with an extra parameter, and running by fixture (Kees); - add LIST_APPEND helper (Kees); - add a dot between fixture and param name (Kees); - rename the params to variants (Tim); v4: - whitespace fixes. v1: https://lore.kernel.org/netdev/20200313031752.2332565-1-kuba@kernel.org/ v2: https://lore.kernel.org/netdev/20200314005501.2446494-1-kuba@kernel.org/ v3: https://lore.kernel.org/netdev/20200316225647.3129354-1-kuba@kernel.org/ Jakub Kicinski (5): kselftest: factor out list manipulation to a helper kselftest: create fixture objects kselftest: run tests by fixture kselftest: add fixture variants selftests: tls: run all tests for TLS 1.2 and TLS 1.3 Documentation/dev-tools/kselftest.rst | 3 +- tools/testing/selftests/kselftest_harness.h | 236 +++++++++++++++----- tools/testing/selftests/net/tls.c | 93 ++------ 3 files changed, 204 insertions(+), 128 deletions(-) -- 2.24.1

5 years, 3 months

1
5
0 0

[PATCH v2 0/4] kselftest: add fixture parameters

by Jakub Kicinski

Hi! This set is an attempt to make running tests for different sets of data easier. The direct motivation is the tls test which we'd like to run for TLS 1.2 and TLS 1.3, but currently there is no easy way to invoke the same tests with different parameters. Tested all users of kselftest_harness.h. v2: - don't run tests by fixture - don't pass params as an explicit argument Note that we loose a little bit of type safety without passing parameters as an explicit argument. If user puts the name of the wrong fixture as argument to CURRENT_FIXTURE() it will happily cast the type. Jakub Kicinski (4): selftests/seccomp: use correct FIXTURE macro kselftest: create fixture objects kselftest: add fixture parameters selftests: tls: run all tests for TLS 1.2 and TLS 1.3 Documentation/dev-tools/kselftest.rst | 3 +- tools/testing/selftests/kselftest_harness.h | 156 ++++++++++++++++-- tools/testing/selftests/net/tls.c | 93 ++--------- tools/testing/selftests/seccomp/seccomp_bpf.c | 10 +- 4 files changed, 168 insertions(+), 94 deletions(-) -- 2.24.1

5 years, 3 months

4
11
0 0

[PATCH v3 1/2] kunit: kunit_parser: make parser more robust

by Heidi Fahim

Previously, kunit_parser did not properly handle kunit TAP output that - had any prefixes (generated from different configs e.g. CONFIG_PRINTK_TIME) - had unrelated kernel output mixed in the middle of it, which has shown up when testing with allyesconfig To remove prefixes, the parser looks for the first line that includes TAP output, "TAP version 14". It then determines the length of the string before this sequence, and strips that number of characters off the beginning of the following lines until the last KUnit output line is reached. These fixes have been tested with additional tests in the KUnitParseTest and their associated logs have also been added. Signed-off-by: Heidi Fahim <heidifahim(a)google.com> --- Changelog v3: - Addressing Shuah's git apply issues with whitespaces. Marked all files in test_data as binaries in new kunit/ .gitattributes file. The irregular whitespaces here are necessary as they are used for testing the KUnit parser. - Important: please note that now git apply works, however the .log files in /test_data/ may get marked as Untracked files. These should be included in the commit as they are required for kunit_tool_test.py. tools/testing/kunit/.gitattributes | 1 + tools/testing/kunit/kunit_parser.py | 40 +++++----- tools/testing/kunit/kunit_tool_test.py | 69 ++++++++++++++++++ .../test_data/test_config_printk_time.log | Bin 0 -> 1584 bytes .../test_data/test_interrupted_tap_output.log | Bin 0 -> 1982 bytes .../test_data/test_kernel_panic_interrupt.log | Bin 0 -> 1321 bytes .../test_data/test_multiple_prefixes.log | Bin 0 -> 1832 bytes ..._output_with_prefix_isolated_correctly.log | Bin 0 -> 1655 bytes .../kunit/test_data/test_pound_no_prefix.log | Bin 0 -> 1193 bytes .../kunit/test_data/test_pound_sign.log | Bin 0 -> 1655 bytes 10 files changed, 90 insertions(+), 20 deletions(-) create mode 100644 tools/testing/kunit/.gitattributes create mode 100644 tools/testing/kunit/test_data/test_config_printk_time.log create mode 100644 tools/testing/kunit/test_data/test_interrupted_tap_output.log create mode 100644 tools/testing/kunit/test_data/test_kernel_panic_interrupt.log create mode 100644 tools/testing/kunit/test_data/test_multiple_prefixes.log create mode 100644 tools/testing/kunit/test_data/test_output_with_prefix_isolated_correctly.log create mode 100644 tools/testing/kunit/test_data/test_pound_no_prefix.log create mode 100644 tools/testing/kunit/test_data/test_pound_sign.log diff --git a/tools/testing/kunit/.gitattributes b/tools/testing/kunit/.gitattributes new file mode 100644 index 000000000000..5b7da1fc3b8f --- /dev/null +++ b/tools/testing/kunit/.gitattributes @@ -0,0 +1 @@ +test_data/* binary diff --git a/tools/testing/kunit/kunit_parser.py b/tools/testing/kunit/kunit_parser.py index 4ffbae0f6732..adf86747b07f 100644 --- a/tools/testing/kunit/kunit_parser.py +++ b/tools/testing/kunit/kunit_parser.py @@ -46,19 +46,21 @@ class TestStatus(Enum): TEST_CRASHED = auto() NO_TESTS = auto() -kunit_start_re = re.compile(r'^TAP version [0-9]+$') -kunit_end_re = re.compile('List of all partitions:') +kunit_start_re = re.compile(r'TAP version [0-9]+$') +kunit_end_re = re.compile('(List of all partitions:|' + 'Kernel panic - not syncing: VFS:|reboot: System halted)') def isolate_kunit_output(kernel_output): started = False for line in kernel_output: - if kunit_start_re.match(line): + if kunit_start_re.search(line): + prefix_len = len(line.split('TAP version')[0]) started = True - yield line - elif kunit_end_re.match(line): + yield line[prefix_len:] if prefix_len > 0 else line + elif kunit_end_re.search(line): break elif started: - yield line + yield line[prefix_len:] if prefix_len > 0 else line def raw_output(kernel_output): for line in kernel_output: @@ -108,18 +110,16 @@ OK_NOT_OK_SUBTEST = re.compile(r'^\t(ok|not ok) [0-9]+ - (.*)$') OK_NOT_OK_MODULE = re.compile(r'^(ok|not ok) [0-9]+ - (.*)$') -def parse_ok_not_ok_test_case(lines: List[str], - test_case: TestCase, - expecting_test_case: bool) -> bool: +def parse_ok_not_ok_test_case(lines: List[str], test_case: TestCase) -> bool: save_non_diagnositic(lines, test_case) if not lines: - if expecting_test_case: - test_case.status = TestStatus.TEST_CRASHED - return True - else: - return False + test_case.status = TestStatus.TEST_CRASHED + return True line = lines[0] match = OK_NOT_OK_SUBTEST.match(line) + while not match and lines: + line = lines.pop(0) + match = OK_NOT_OK_SUBTEST.match(line) if match: test_case.log.append(lines.pop(0)) test_case.name = match.group(2) @@ -150,12 +150,12 @@ def parse_diagnostic(lines: List[str], test_case: TestCase) -> bool: else: return False -def parse_test_case(lines: List[str], expecting_test_case: bool) -> TestCase: +def parse_test_case(lines: List[str]) -> TestCase: test_case = TestCase() save_non_diagnositic(lines, test_case) while parse_diagnostic(lines, test_case): pass - if parse_ok_not_ok_test_case(lines, test_case, expecting_test_case): + if parse_ok_not_ok_test_case(lines, test_case): return test_case else: return None @@ -234,11 +234,11 @@ def parse_test_suite(lines: List[str]) -> TestSuite: expected_test_case_num = parse_subtest_plan(lines) if not expected_test_case_num: return None - test_case = parse_test_case(lines, expected_test_case_num > 0) - expected_test_case_num -= 1 - while test_case: + while expected_test_case_num > 0: + test_case = parse_test_case(lines) + if not test_case: + break test_suite.cases.append(test_case) - test_case = parse_test_case(lines, expected_test_case_num > 0) expected_test_case_num -= 1 if parse_ok_not_ok_test_suite(lines, test_suite): test_suite.status = bubble_up_test_case_errors(test_suite) diff --git a/tools/testing/kunit/kunit_tool_test.py b/tools/testing/kunit/kunit_tool_test.py index cba97756ac4a..0efae697f396 100755 --- a/tools/testing/kunit/kunit_tool_test.py +++ b/tools/testing/kunit/kunit_tool_test.py @@ -108,6 +108,36 @@ class KUnitParserTest(unittest.TestCase): self.assertContains('ok 1 - example', result) file.close() + def test_output_with_prefix_isolated_correctly(self): + log_path = get_absolute_path( + 'test_data/test_pound_sign.log') + with open(log_path) as file: + result = kunit_parser.isolate_kunit_output(file.readlines()) + self.assertContains('TAP version 14\n', result) + self.assertContains(' # Subtest: kunit-resource-test', result) + self.assertContains(' 1..5', result) + self.assertContains(' ok 1 - kunit_resource_test_init_resources', result) + self.assertContains(' ok 2 - kunit_resource_test_alloc_resource', result) + self.assertContains(' ok 3 - kunit_resource_test_destroy_resource', result) + self.assertContains(' foo bar #', result) + self.assertContains(' ok 4 - kunit_resource_test_cleanup_resources', result) + self.assertContains(' ok 5 - kunit_resource_test_proper_free_ordering', result) + self.assertContains('ok 1 - kunit-resource-test', result) + self.assertContains(' foo bar # non-kunit output', result) + self.assertContains(' # Subtest: kunit-try-catch-test', result) + self.assertContains(' 1..2', result) + self.assertContains(' ok 1 - kunit_test_try_catch_successful_try_no_catch', + result) + self.assertContains(' ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch', + result) + self.assertContains('ok 2 - kunit-try-catch-test', result) + self.assertContains(' # Subtest: string-stream-test', result) + self.assertContains(' 1..3', result) + self.assertContains(' ok 1 - string_stream_test_empty_on_creation', result) + self.assertContains(' ok 2 - string_stream_test_not_empty_after_add', result) + self.assertContains(' ok 3 - string_stream_test_get_string', result) + self.assertContains('ok 3 - string-stream-test', result) + def test_parse_successful_test_log(self): all_passed_log = get_absolute_path( 'test_data/test_is_test_passed-all_passed.log') @@ -150,6 +180,45 @@ class KUnitParserTest(unittest.TestCase): result.status) file.close() + def test_ignores_prefix_printk_time(self): + prefix_log = get_absolute_path( + 'test_data/test_config_printk_time.log') + with open(prefix_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_ignores_multiple_prefixes(self): + prefix_log = get_absolute_path( + 'test_data/test_multiple_prefixes.log') + with open(prefix_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_prefix_mixed_kernel_output(self): + mixed_prefix_log = get_absolute_path( + 'test_data/test_interrupted_tap_output.log') + with open(mixed_prefix_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_prefix_poundsign(self): + pound_log = get_absolute_path('test_data/test_pound_sign.log') + with open(pound_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_kernel_panic_end(self): + panic_log = get_absolute_path('test_data/test_kernel_panic_interrupt.log') + with open(panic_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_pound_no_prefix(self): + pound_log = get_absolute_path('test_data/test_pound_no_prefix.log') + with open(pound_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + class StrContains(str): def __eq__(self, other): return self in other diff --git a/tools/testing/kunit/test_data/test_config_printk_time.log b/tools/testing/kunit/test_data/test_config_printk_time.log new file mode 100644 index 0000000000000000000000000000000000000000..c02ca773946d641291e27d44d73174cc16a17d9d GIT binary patch literal 1584 zcmai!-)q}25XYapzv7@T8>=%piIdE*htV+@8zqo+FQEuUKBp$O&PeiF|Mxq^U79*h zs}~FTKHvK#-5Pj_k(dcycTn5H_+1K`jH41^UFj&k12k$=V)kzR(%LGMQI*0Lz3ldK z(|UBERmtX%TdJTig_lINlSTGXJWi5N;&CeAq44*ht=Y<8@I~~se}7%VU$m|u1M#%~ z_u>*(&4yk16m|^@L>3)2R$~+nPt4=dC^<Q#9mEiIy!_A0!0%%^9JwKKe1_!ANgvQ5 za&m^u*s-PdRd#xY)g>y^)CYDj<m3!oTdL8@+#*V{8S)+2_5(kz)f=@wX^ppSq?OnA zXL~d5ySq5{*R_OI<X%O(Mr(8~Z%P>s4Rz;38qZzYxAj@0F+G)x&<*QwC<mG7ja-g$ z=Vo#pBmSVO&SpLtiaOlN4woI?RRF8nw~~z1Ea~}S46z~90oIV09j|iF%~sjTYYsIJ zcXNOa54=0>yL`dCmh7*>d7vEleL$_OFG2z??d#nT<VA_Dbsj4oLrs}MMUC-biTo9C zQ8DXNeUYDN4F)%+(3}wG4z4wt+mXVb@2eDU_wx)q9ce@EfM-o(c7`5IwBcvGd;fWH zB|h}!ua~ze2w493mhu3(riw?Pdr&n$BDi5+Uhxp+@t2IIBN160M_W|mESqbwm?s!z zh4n35o?QBsS9;ga4PYk5Vlm4Xyoon@JQFY%i4ODnu<1v5%!nk{s1K(6ON{kQZ3dVp N(^Ef_;Eh)-{s9AX)U5yj literal 0 HcmV?d00001 diff --git a/tools/testing/kunit/test_data/test_interrupted_tap_output.log b/tools/testing/kunit/test_data/test_interrupted_tap_output.log new file mode 100644 index 0000000000000000000000000000000000000000..5c73fb3a1c6fd13a9b163a48d02eb33b0315a375 GIT binary patch literal 1982 zcmah~-A~&v5PxQW#YsG{v8HoBDUo<!Ff=rT5CvWkvRvoVMoH|*c7W`!-#OVzNz;*+ zIG6kV?)&@*^sqjgGJ2k%Fo|+$2vRGnGla)n27@O+B^DV*pB~?98=)edhp<G)n=@Zj z4lPKLkvhai=a8txajgr>ljtjZ9ZkNm*D-^a#H~OYwd7vmgtfWvPH*5DjZL(I!MOc* zZy)C6f=sy((vk=QgI1SDV&H{a>VtlNvL)0h3?OLm{2!iseC^X(WV?{V9Y~5?%QdtM zIog4Y$gt7XPHcL5F%RLE^7>OapbwB)g37@&>kq)-GO-S+e#?H_>cu=b6LN(iT%(IE z9EjK+tP#FY+EC5piok8`;o%`XoL*g?pWgid?*fpdt@Pa)qRq63FzQiN<!C5Rnpdzy zMPA7sM7SuICtCGDSc}HhM`|}*n#5HB`6p8}wbWo7Q1O$vqR%a3ceg$f7PGi%0E^OT z>XhFU;Fujx0hFd>uD?GdFr`uyIxOliVuJ{_5EAR0Ab2aCJuu!;NtvNgWwEYgCwQ_0 zTo_%T;ob|bO;lI39l>Vje$e?_gW?S3S~$7dIVr=oxxGz$&43UKuUWV)r9^AvGUHyT zbR+NLc$=Ae$lf?g)nbV>+HM|lWla-&5X(mFG+I>QfL<u_oso~ay!Jbyf%695WB~KR zRa`4BiPF)U>cV<gJFrSS-rxoGu;C)w+O0n4ep7Uy{km<$ZIkaX{|oktb_M7dXj?%c zj7xj~Hf-}<YlxE!ZAF_Ur%R#CBFJ?~JI844dO%6VsEulq{6eG9n^B3RfGBpbm6BAB z5FY#_-`BSbIK9CQv`=XBmnv2IMFk65s_EzBS&w~b)1Tekhrr<G@;sz<ex`G}knD>n zXo%pNY&qd~OaznuxX%J32egsIFp7>On;lIsh!W!}*xzdUxf3#N#|AKELpGbnGdc_w rayVsh#3s_;p6f%~!%YmE#1iFNm430IoQg#U=CA6uosqXj&w%{_Pb*9~ literal 0 HcmV?d00001 diff --git a/tools/testing/kunit/test_data/test_kernel_panic_interrupt.log b/tools/testing/kunit/test_data/test_kernel_panic_interrupt.log new file mode 100644 index 0000000000000000000000000000000000000000..c045eee75f27fefaabf3ba073d9e282721c19a67 GIT binary patch literal 1321 zcmai!-)q}25XYapzv7@T8=EuPiIdc@htV+@gAvHOmr#T(%c-%gGm^a2|NYK!=cfMA z>c!%GpYPr2bUFYnwqR>U>mDkTX_rSJQCln&97^f=_n@?h3zfV(y!19gCs;;sRE~Fh z9yd-|kfI=WNDY>d>CAD&%JMAv$R3yBXZE;aaLU{RNTZLub@;-D+P}Z<;IA?^Lk<3F z`1k4>_H|65Tm*Sd0-jM8Ya^A{8b|K_ViAsvn1c^q$MgR@Z~1dhy~$3I!3;^2qwLWs zaydgL6xd+%D!ZCtWub(wtDc=qIh=tjgOxHoHA-<biK07j943BwR&Sj3s5Q<so)k_# z%=RW2hP%3q*R_OH_*sS9T1sVYS{J-EYV7P&8qZxixAj@0)&rFUm7Uh1RC*cjjan{h zr)JVQdh}7EoUMF0m34b7JDhiTcLJ)cT*FawNs^8RW5oVcMymoUp)*Mu8Xee1OUfgH zKi~He+?@v*972h;c3_ZPQVTR>wazu3v=`I;&EMZ_Kd}!({oCDL1PpdRzC|=Sw^-8b z+mop1_P{R^a)MqDn)`6ES}@N@-#aQ1B*{jy?Iu)Sk{Q>)^{Cr>CuANCqrsX5Y`adk qwDDsZtQl-rDBFjs-@L}KFqKO7uB5^OxfbyR^W-{?vuvZ$^4UKw_JoN5 literal 0 HcmV?d00001 diff --git a/tools/testing/kunit/test_data/test_multiple_prefixes.log b/tools/testing/kunit/test_data/test_multiple_prefixes.log new file mode 100644 index 0000000000000000000000000000000000000000..bc48407dcc36c44665c7d2ac620e42e7caf98481 GIT binary patch literal 1832 zcma)-UvJYe5Wt_ur#NXZAeQ2^O;;lEfQFC|XsWc0mua$G=h8(@e39+2<=b;^pet<7 z>X$ed-|znUF1Nr-OvFO)y1NZ;*XbR!wlaR3gC^ssM!0Qs!eTUPU1RZPcka2CRi>aO zhYfl;?B%-m=s>HQ)u6Q0KxHZ~iCQPC;=OpBWgo=jT);!+??GF$k>S865wmgqc?G}F zx{3^>^Vq4AQ@HBZY})6r?HHI?bktdmNf1WW(#a%?exxm=kPJNemnQ>n=ks3V#t730 zfipyUj~FA&B7}k+vD6>Mm`518MrFEo&ln9Qi$GdSEm~PxL`k+lzDt`}K!-U!vPREJ z>usNC<@NomwVlS?I63rVC@E9rjw)TJH9A*zwG2W-gM5tjROQ|Ecw%+tKUzWP#(C`8 z9+w;$>p_nAQgHqgexPbz&CqNts&M-UoE&gNrm$&!FUd&FCOkLh7$b!80>hA(14osf zFOMpsQzq0Z^uP<0Fn9)W%!Pk+k4egp%6Xs?xIdv))>k1wm&f>*1Z7pD>z&7j$7fd; z&`@VQSR#K0TnsE?+A-*Nv<8EDQ)v#Ia|Nz9n#-EQ&#zZG-0bEucsj5Jr30Rko!J_C zFv*(7%l7TZ<(YUFGjp-J$w9#C+n1aN-32u~%H4x%xtZaTZF<E&1s>zsWIhpz)oHRp zH7$yBEtcmQCPig^52w*4yYfnJW3dA)#8fO7<&rn)T2B`O&PArfe`&vod48xXvQneo XtMDf=)eE&A(fy<H-0mz`=aq`zHIoXT literal 0 HcmV?d00001 diff --git a/tools/testing/kunit/test_data/test_output_with_prefix_isolated_correctly.log b/tools/testing/kunit/test_data/test_output_with_prefix_isolated_correctly.log new file mode 100644 index 0000000000000000000000000000000000000000..0f87cdabebb098a6a7132661ab482f273ac6ecfd GIT binary patch literal 1655 zcmah}O^?$s5IvV)F;XueHpOY1wnXB979k<fs!~}l)yi@lryDi#M7BdW|DJIJ-EKY> zUt&$>z4`Rp106PFD@Nx5DwAt>j6tHdSSZ++G6)|)X^|8veY1b*ZG=v-jNzahZ|^*5 zoU$NALGF+lEFssq<A{~zdHS9`Eus(XY02P}yGM{lAGmk;#Jb!+KX2i;GB!sI;j;U8 zGKF28P$(C}u_l7RD2ug`D)7dhdpMg#JtH0=grLRqe|YZk=bSDkJA|B%AgOYc7w8aj zF@j7fu)$^&3mGCL!oXxYM7tcJm4y<zt}e8L)kGuU%3!4o&x}$WO{!=;4&C6_ZG3$U zR~3Lp9h@fzSi7q3kE}OgXPQ6?Cm%;gJnyD9xz4SfEV1x23%9kD%G#_hxHoES?L!>T z!#;1vGe@mEEGa5G%tNVMXoCOLa#cI+1ob?ij}ql*<%^-L{c^W(-oo1ssIqbmN6jTs zI(lD2SfA<uR-@xBUSy6IL!>=X@ICh{K7jT*(VDv<UtnG<_D60VU<UNepc2OAz5p9{ z`R)+1yim5WPL-r)b&*1ewRT_--3?GvRoX>$Nxmzil@FtHNd-~uU>hxI95MX*x{Kld zEQ{dqiW@QuBw4jSYCP#6AvHL@{kXYd@4EE2+xr+8Y`=YpNr!H+Bqg;cQPG2gJBsB5 zX)&p2G+WMCU}P8^l$fXKTC&YLQbC#<*TA&5^gAcyv0EF!ip|+(m2Kz}CUU-Fux63; jvVXaBGrY#ID3eNFT<I5^%auq5Fn?Y9aTY!rosj(j<eKLf literal 0 HcmV?d00001 diff --git a/tools/testing/kunit/test_data/test_pound_no_prefix.log b/tools/testing/kunit/test_data/test_pound_no_prefix.log new file mode 100644 index 0000000000000000000000000000000000000000..2ceb360be7d52cbee4b0a5a426456605ded7466e GIT binary patch literal 1193 zcmZ{kPmh~05XH~sQ;f8iR$Wq)glvk`L$y_<s#O&!-CnB7GG@r4fCt&8yL|f&c$ct$ z!UfCzz0vby254<%{4oPf#!-#%r_pip7tpA@#v%f%OhHWs2lO(mW!`&qpjFKPl$IK( zOywm}>tt2D7x%05gScM{xU2jvXlo8~06vKbetq7-KeVnQ1IapqHy5z)axUjHICc!h z79Dj~V?1m!kSrD{zvu`F#DS5Ij2xJ;_O#^!yFA0PXVMcK*wq=f;Nq7084V>7<jS(` zAYGr4>Kc{l+DZE0Dm{a@mRhv3w1|>yf&57h5zMdrJeHXgFl6E}JD|?D-4NP~RK4wE zt-QXS#kvf4IK?`q$)p@f={l{^xw5O}uxTjl2h}OyXR6LT(-nm7QOQ@Dgz*bcGuNCv zXAtuXRWtLvI(ZI=3`pn%Y+Bz-GE%e5bB~?8zCs)FGALB(Iet}eyAO>vG{h_XFacqE z{5B`*sm&ji^FSqVt3j)*uLdJ7i{K|gS=H!z=ds~=>*@j;>Wl|V<S&7*j71hj@Exte zL2N3`R@f)F-e?XagWq5G8QhG+37%$pC>`)nb>?X3&cr$Q`SI<??WK4Z!S(JY0|C2l zUoxJeYif9&-JNQ=>DZMAulOIpvz#v03lUqL#0ON%qPWsxdzE5bRMz)!!40$bN+0<y xun|kK-IQBiB)ML01YC(!3x1}>Q%a<zMm-&}PAv6C<s<cQ__Ee&sK`$u{sZ*XjN1SJ literal 0 HcmV?d00001 diff --git a/tools/testing/kunit/test_data/test_pound_sign.log b/tools/testing/kunit/test_data/test_pound_sign.log new file mode 100644 index 0000000000000000000000000000000000000000..0f87cdabebb098a6a7132661ab482f273ac6ecfd GIT binary patch literal 1655 zcmah}O^?$s5IvV)F;XueHpOY1wnXB979k<fs!~}l)yi@lryDi#M7BdW|DJIJ-EKY> zUt&$>z4`Rp106PFD@Nx5DwAt>j6tHdSSZ++G6)|)X^|8veY1b*ZG=v-jNzahZ|^*5 zoU$NALGF+lEFssq<A{~zdHS9`Eus(XY02P}yGM{lAGmk;#Jb!+KX2i;GB!sI;j;U8 zGKF28P$(C}u_l7RD2ug`D)7dhdpMg#JtH0=grLRqe|YZk=bSDkJA|B%AgOYc7w8aj zF@j7fu)$^&3mGCL!oXxYM7tcJm4y<zt}e8L)kGuU%3!4o&x}$WO{!=;4&C6_ZG3$U zR~3Lp9h@fzSi7q3kE}OgXPQ6?Cm%;gJnyD9xz4SfEV1x23%9kD%G#_hxHoES?L!>T z!#;1vGe@mEEGa5G%tNVMXoCOLa#cI+1ob?ij}ql*<%^-L{c^W(-oo1ssIqbmN6jTs zI(lD2SfA<uR-@xBUSy6IL!>=X@ICh{K7jT*(VDv<UtnG<_D60VU<UNepc2OAz5p9{ z`R)+1yim5WPL-r)b&*1ewRT_--3?GvRoX>$Nxmzil@FtHNd-~uU>hxI95MX*x{Kld zEQ{dqiW@QuBw4jSYCP#6AvHL@{kXYd@4EE2+xr+8Y`=YpNr!H+Bqg;cQPG2gJBsB5 zX)&p2G+WMCU}P8^l$fXKTC&YLQbC#<*TA&5^gAcyv0EF!ip|+(m2Kz}CUU-Fux63; jvVXaBGrY#ID3eNFT<I5^%auq5Fn?Y9aTY!rosj(j<eKLf literal 0 HcmV?d00001 -- 2.25.1.481.gfbce0eb801-goog

5 years, 3 months

2
3
0 0

[PATCH v2 1/2] kunit: kunit_parser: make parser more robust

by Heidi Fahim

Previously, kunit_parser did not properly handle kunit TAP output that - had any prefixes (generated from different configs e.g. CONFIG_PRINTK_TIME) - had unrelated kernel output mixed in the middle of it, which has shown up when testing with allyesconfig To remove prefixes, the parser looks for the first line that includes TAP output, "TAP version 14". It then determines the length of the string before this sequence, and strips that number of characters off the beginning of the following lines until the last KUnit output line is reached. These fixes have been tested with additional tests in the KUnitParseTest and their associated logs have also been added. Signed-off-by: Heidi Fahim <heidifahim(a)google.com> --- Changelog: v2: - addressed Brendan's comments regarding the commit message. Reverted some of the regex where possible. tools/testing/kunit/kunit_parser.py | 40 +++++------ tools/testing/kunit/kunit_tool_test.py | 69 +++++++++++++++++++ .../test_data/test_config_printk_time.log | 31 +++++++++ .../test_data/test_interrupted_tap_output.log | 37 ++++++++++ .../test_data/test_kernel_panic_interrupt.log | 25 +++++++ .../test_data/test_multiple_prefixes.log | 31 +++++++++ ..._output_with_prefix_isolated_correctly.log | 33 +++++++++ .../kunit/test_data/test_pound_no_prefix.log | 33 +++++++++ .../kunit/test_data/test_pound_sign.log | 33 +++++++++ 9 files changed, 312 insertions(+), 20 deletions(-) create mode 100644 tools/testing/kunit/test_data/test_config_printk_time.log create mode 100644 tools/testing/kunit/test_data/test_interrupted_tap_output.log create mode 100644 tools/testing/kunit/test_data/test_kernel_panic_interrupt.log create mode 100644 tools/testing/kunit/test_data/test_multiple_prefixes.log create mode 100644 tools/testing/kunit/test_data/test_output_with_prefix_isolated_correctly.log create mode 100644 tools/testing/kunit/test_data/test_pound_no_prefix.log create mode 100644 tools/testing/kunit/test_data/test_pound_sign.log diff --git a/tools/testing/kunit/kunit_parser.py b/tools/testing/kunit/kunit_parser.py index 4ffbae0f6732..adf86747b07f 100644 --- a/tools/testing/kunit/kunit_parser.py +++ b/tools/testing/kunit/kunit_parser.py @@ -46,19 +46,21 @@ class TestStatus(Enum): TEST_CRASHED = auto() NO_TESTS = auto() -kunit_start_re = re.compile(r'^TAP version [0-9]+$') -kunit_end_re = re.compile('List of all partitions:') +kunit_start_re = re.compile(r'TAP version [0-9]+$') +kunit_end_re = re.compile('(List of all partitions:|' + 'Kernel panic - not syncing: VFS:|reboot: System halted)') def isolate_kunit_output(kernel_output): started = False for line in kernel_output: - if kunit_start_re.match(line): + if kunit_start_re.search(line): + prefix_len = len(line.split('TAP version')[0]) started = True - yield line - elif kunit_end_re.match(line): + yield line[prefix_len:] if prefix_len > 0 else line + elif kunit_end_re.search(line): break elif started: - yield line + yield line[prefix_len:] if prefix_len > 0 else line def raw_output(kernel_output): for line in kernel_output: @@ -108,18 +110,16 @@ OK_NOT_OK_SUBTEST = re.compile(r'^\t(ok|not ok) [0-9]+ - (.*)$') OK_NOT_OK_MODULE = re.compile(r'^(ok|not ok) [0-9]+ - (.*)$') -def parse_ok_not_ok_test_case(lines: List[str], - test_case: TestCase, - expecting_test_case: bool) -> bool: +def parse_ok_not_ok_test_case(lines: List[str], test_case: TestCase) -> bool: save_non_diagnositic(lines, test_case) if not lines: - if expecting_test_case: - test_case.status = TestStatus.TEST_CRASHED - return True - else: - return False + test_case.status = TestStatus.TEST_CRASHED + return True line = lines[0] match = OK_NOT_OK_SUBTEST.match(line) + while not match and lines: + line = lines.pop(0) + match = OK_NOT_OK_SUBTEST.match(line) if match: test_case.log.append(lines.pop(0)) test_case.name = match.group(2) @@ -150,12 +150,12 @@ def parse_diagnostic(lines: List[str], test_case: TestCase) -> bool: else: return False -def parse_test_case(lines: List[str], expecting_test_case: bool) -> TestCase: +def parse_test_case(lines: List[str]) -> TestCase: test_case = TestCase() save_non_diagnositic(lines, test_case) while parse_diagnostic(lines, test_case): pass - if parse_ok_not_ok_test_case(lines, test_case, expecting_test_case): + if parse_ok_not_ok_test_case(lines, test_case): return test_case else: return None @@ -234,11 +234,11 @@ def parse_test_suite(lines: List[str]) -> TestSuite: expected_test_case_num = parse_subtest_plan(lines) if not expected_test_case_num: return None - test_case = parse_test_case(lines, expected_test_case_num > 0) - expected_test_case_num -= 1 - while test_case: + while expected_test_case_num > 0: + test_case = parse_test_case(lines) + if not test_case: + break test_suite.cases.append(test_case) - test_case = parse_test_case(lines, expected_test_case_num > 0) expected_test_case_num -= 1 if parse_ok_not_ok_test_suite(lines, test_suite): test_suite.status = bubble_up_test_case_errors(test_suite) diff --git a/tools/testing/kunit/kunit_tool_test.py b/tools/testing/kunit/kunit_tool_test.py index cba97756ac4a..0efae697f396 100755 --- a/tools/testing/kunit/kunit_tool_test.py +++ b/tools/testing/kunit/kunit_tool_test.py @@ -108,6 +108,36 @@ class KUnitParserTest(unittest.TestCase): self.assertContains('ok 1 - example', result) file.close() + def test_output_with_prefix_isolated_correctly(self): + log_path = get_absolute_path( + 'test_data/test_pound_sign.log') + with open(log_path) as file: + result = kunit_parser.isolate_kunit_output(file.readlines()) + self.assertContains('TAP version 14\n', result) + self.assertContains(' # Subtest: kunit-resource-test', result) + self.assertContains(' 1..5', result) + self.assertContains(' ok 1 - kunit_resource_test_init_resources', result) + self.assertContains(' ok 2 - kunit_resource_test_alloc_resource', result) + self.assertContains(' ok 3 - kunit_resource_test_destroy_resource', result) + self.assertContains(' foo bar #', result) + self.assertContains(' ok 4 - kunit_resource_test_cleanup_resources', result) + self.assertContains(' ok 5 - kunit_resource_test_proper_free_ordering', result) + self.assertContains('ok 1 - kunit-resource-test', result) + self.assertContains(' foo bar # non-kunit output', result) + self.assertContains(' # Subtest: kunit-try-catch-test', result) + self.assertContains(' 1..2', result) + self.assertContains(' ok 1 - kunit_test_try_catch_successful_try_no_catch', + result) + self.assertContains(' ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch', + result) + self.assertContains('ok 2 - kunit-try-catch-test', result) + self.assertContains(' # Subtest: string-stream-test', result) + self.assertContains(' 1..3', result) + self.assertContains(' ok 1 - string_stream_test_empty_on_creation', result) + self.assertContains(' ok 2 - string_stream_test_not_empty_after_add', result) + self.assertContains(' ok 3 - string_stream_test_get_string', result) + self.assertContains('ok 3 - string-stream-test', result) + def test_parse_successful_test_log(self): all_passed_log = get_absolute_path( 'test_data/test_is_test_passed-all_passed.log') @@ -150,6 +180,45 @@ class KUnitParserTest(unittest.TestCase): result.status) file.close() + def test_ignores_prefix_printk_time(self): + prefix_log = get_absolute_path( + 'test_data/test_config_printk_time.log') + with open(prefix_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_ignores_multiple_prefixes(self): + prefix_log = get_absolute_path( + 'test_data/test_multiple_prefixes.log') + with open(prefix_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_prefix_mixed_kernel_output(self): + mixed_prefix_log = get_absolute_path( + 'test_data/test_interrupted_tap_output.log') + with open(mixed_prefix_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_prefix_poundsign(self): + pound_log = get_absolute_path('test_data/test_pound_sign.log') + with open(pound_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_kernel_panic_end(self): + panic_log = get_absolute_path('test_data/test_kernel_panic_interrupt.log') + with open(panic_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + + def test_pound_no_prefix(self): + pound_log = get_absolute_path('test_data/test_pound_no_prefix.log') + with open(pound_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) + self.assertEqual('kunit-resource-test', result.suites[0].name) + class StrContains(str): def __eq__(self, other): return self in other diff --git a/tools/testing/kunit/test_data/test_config_printk_time.log b/tools/testing/kunit/test_data/test_config_printk_time.log new file mode 100644 index 000000000000..c02ca773946d --- /dev/null +++ b/tools/testing/kunit/test_data/test_config_printk_time.log @@ -0,0 +1,31 @@ +[ 0.060000] printk: console [mc-1] enabled +[ 0.060000] random: get_random_bytes called from init_oops_id+0x35/0x40 with crng_init=0 +[ 0.060000] TAP version 14 +[ 0.060000] # Subtest: kunit-resource-test +[ 0.060000] 1..5 +[ 0.060000] ok 1 - kunit_resource_test_init_resources +[ 0.060000] ok 2 - kunit_resource_test_alloc_resource +[ 0.060000] ok 3 - kunit_resource_test_destroy_resource +[ 0.060000] ok 4 - kunit_resource_test_cleanup_resources +[ 0.060000] ok 5 - kunit_resource_test_proper_free_ordering +[ 0.060000] ok 1 - kunit-resource-test +[ 0.060000] # Subtest: kunit-try-catch-test +[ 0.060000] 1..2 +[ 0.060000] ok 1 - kunit_test_try_catch_successful_try_no_catch +[ 0.060000] ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch +[ 0.060000] ok 2 - kunit-try-catch-test +[ 0.060000] # Subtest: string-stream-test +[ 0.060000] 1..3 +[ 0.060000] ok 1 - string_stream_test_empty_on_creation +[ 0.060000] ok 2 - string_stream_test_not_empty_after_add +[ 0.060000] ok 3 - string_stream_test_get_string +[ 0.060000] ok 3 - string-stream-test +[ 0.060000] List of all partitions: +[ 0.060000] No filesystem could mount root, tried: +[ 0.060000] +[ 0.060000] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(98,0) +[ 0.060000] CPU: 0 PID: 1 Comm: swapper Not tainted 5.4.0-rc1-gea2dd7c0875e-dirty #2 +[ 0.060000] Stack: +[ 0.060000] 602086f8 601bc260 705c0000 705c0000 +[ 0.060000] 602086f8 6005fcec 705c0000 6002c6ab +[ 0.060000] 6005fcec 601bc260 705c0000 3000000010 \ No newline at end of file diff --git a/tools/testing/kunit/test_data/test_interrupted_tap_output.log b/tools/testing/kunit/test_data/test_interrupted_tap_output.log new file mode 100644 index 000000000000..5c73fb3a1c6f --- /dev/null +++ b/tools/testing/kunit/test_data/test_interrupted_tap_output.log @@ -0,0 +1,37 @@ +[ 0.060000] printk: console [mc-1] enabled +[ 0.060000] random: get_random_bytes called from init_oops_id+0x35/0x40 with crng_init=0 +[ 0.060000] TAP version 14 +[ 0.060000] # Subtest: kunit-resource-test +[ 0.060000] 1..5 +[ 0.060000] ok 1 - kunit_resource_test_init_resources +[ 0.060000] ok 2 - kunit_resource_test_alloc_resource +[ 0.060000] ok 3 - kunit_resource_test_destroy_resource +[ 0.060000] kAFS: Red Hat AFS client v0.1 registering. +[ 0.060000] FS-Cache: Netfs 'afs' registered for caching +[ 0.060000] *** VALIDATE kAFS *** +[ 0.060000] Btrfs loaded, crc32c=crc32c-generic, debug=on, assert=on, integrity-checker=on, ref-verify=on +[ 0.060000] BTRFS: selftest: sectorsize: 4096 nodesize: 4096 +[ 0.060000] BTRFS: selftest: running btrfs free space cache tests +[ 0.060000] ok 4 - kunit_resource_test_cleanup_resources +[ 0.060000] ok 5 - kunit_resource_test_proper_free_ordering +[ 0.060000] ok 1 - kunit-resource-test +[ 0.060000] # Subtest: kunit-try-catch-test +[ 0.060000] 1..2 +[ 0.060000] ok 1 - kunit_test_try_catch_successful_try_no_catch +[ 0.060000] ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch +[ 0.060000] ok 2 - kunit-try-catch-test +[ 0.060000] # Subtest: string-stream-test +[ 0.060000] 1..3 +[ 0.060000] ok 1 - string_stream_test_empty_on_creation +[ 0.060000] ok 2 - string_stream_test_not_empty_after_add +[ 0.060000] ok 3 - string_stream_test_get_string +[ 0.060000] ok 3 - string-stream-test +[ 0.060000] List of all partitions: +[ 0.060000] No filesystem could mount root, tried: +[ 0.060000] +[ 0.060000] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(98,0) +[ 0.060000] CPU: 0 PID: 1 Comm: swapper Not tainted 5.4.0-rc1-gea2dd7c0875e-dirty #2 +[ 0.060000] Stack: +[ 0.060000] 602086f8 601bc260 705c0000 705c0000 +[ 0.060000] 602086f8 6005fcec 705c0000 6002c6ab +[ 0.060000] 6005fcec 601bc260 705c0000 3000000010 \ No newline at end of file diff --git a/tools/testing/kunit/test_data/test_kernel_panic_interrupt.log b/tools/testing/kunit/test_data/test_kernel_panic_interrupt.log new file mode 100644 index 000000000000..c045eee75f27 --- /dev/null +++ b/tools/testing/kunit/test_data/test_kernel_panic_interrupt.log @@ -0,0 +1,25 @@ +[ 0.060000] printk: console [mc-1] enabled +[ 0.060000] random: get_random_bytes called from init_oops_id+0x35/0x40 with crng_init=0 +[ 0.060000] TAP version 14 +[ 0.060000] # Subtest: kunit-resource-test +[ 0.060000] 1..5 +[ 0.060000] ok 1 - kunit_resource_test_init_resources +[ 0.060000] ok 2 - kunit_resource_test_alloc_resource +[ 0.060000] ok 3 - kunit_resource_test_destroy_resource +[ 0.060000] ok 4 - kunit_resource_test_cleanup_resources +[ 0.060000] ok 5 - kunit_resource_test_proper_free_ordering +[ 0.060000] ok 1 - kunit-resource-test +[ 0.060000] # Subtest: kunit-try-catch-test +[ 0.060000] 1..2 +[ 0.060000] ok 1 - kunit_test_try_catch_successful_try_no_catch +[ 0.060000] ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch +[ 0.060000] ok 2 - kunit-try-catch-test +[ 0.060000] # Subtest: string-stream-test +[ 0.060000] 1..3 +[ 0.060000] ok 1 - string_stream_test_empty_on_creation +[ 0.060000] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(98,0) +[ 0.060000] CPU: 0 PID: 1 Comm: swapper Not tainted 5.4.0-rc1-gea2dd7c0875e-dirty #2 +[ 0.060000] Stack: +[ 0.060000] 602086f8 601bc260 705c0000 705c0000 +[ 0.060000] 602086f8 6005fcec 705c0000 6002c6ab +[ 0.060000] 6005fcec 601bc260 705c0000 3000000010 \ No newline at end of file diff --git a/tools/testing/kunit/test_data/test_multiple_prefixes.log b/tools/testing/kunit/test_data/test_multiple_prefixes.log new file mode 100644 index 000000000000..bc48407dcc36 --- /dev/null +++ b/tools/testing/kunit/test_data/test_multiple_prefixes.log @@ -0,0 +1,31 @@ +[ 0.060000][ T1] printk: console [mc-1] enabled +[ 0.060000][ T1] random: get_random_bytes called from init_oops_id+0x35/0x40 with crng_init=0 +[ 0.060000][ T1] TAP version 14 +[ 0.060000][ T1] # Subtest: kunit-resource-test +[ 0.060000][ T1] 1..5 +[ 0.060000][ T1] ok 1 - kunit_resource_test_init_resources +[ 0.060000][ T1] ok 2 - kunit_resource_test_alloc_resource +[ 0.060000][ T1] ok 3 - kunit_resource_test_destroy_resource +[ 0.060000][ T1] ok 4 - kunit_resource_test_cleanup_resources +[ 0.060000][ T1] ok 5 - kunit_resource_test_proper_free_ordering +[ 0.060000][ T1] ok 1 - kunit-resource-test +[ 0.060000][ T1] # Subtest: kunit-try-catch-test +[ 0.060000][ T1] 1..2 +[ 0.060000][ T1] ok 1 - kunit_test_try_catch_successful_try_no_catch +[ 0.060000][ T1] ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch +[ 0.060000][ T1] ok 2 - kunit-try-catch-test +[ 0.060000][ T1] # Subtest: string-stream-test +[ 0.060000][ T1] 1..3 +[ 0.060000][ T1] ok 1 - string_stream_test_empty_on_creation +[ 0.060000][ T1] ok 2 - string_stream_test_not_empty_after_add +[ 0.060000][ T1] ok 3 - string_stream_test_get_string +[ 0.060000][ T1] ok 3 - string-stream-test +[ 0.060000][ T1] List of all partitions: +[ 0.060000][ T1] No filesystem could mount root, tried: +[ 0.060000][ T1] +[ 0.060000][ T1] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(98,0) +[ 0.060000][ T1] CPU: 0 PID: 1 Comm: swapper Not tainted 5.4.0-rc1-gea2dd7c0875e-dirty #2 +[ 0.060000][ T1] Stack: +[ 0.060000][ T1] 602086f8 601bc260 705c0000 705c0000 +[ 0.060000][ T1] 602086f8 6005fcec 705c0000 6002c6ab +[ 0.060000][ T1] 6005fcec 601bc260 705c0000 3000000010 \ No newline at end of file diff --git a/tools/testing/kunit/test_data/test_output_with_prefix_isolated_correctly.log b/tools/testing/kunit/test_data/test_output_with_prefix_isolated_correctly.log new file mode 100644 index 000000000000..0f87cdabebb0 --- /dev/null +++ b/tools/testing/kunit/test_data/test_output_with_prefix_isolated_correctly.log @@ -0,0 +1,33 @@ +[ 0.060000] printk: console [mc-1] enabled +[ 0.060000] random: get_random_bytes called from init_oops_id+0x35/0x40 with crng_init=0 +[ 0.060000] TAP version 14 +[ 0.060000] # Subtest: kunit-resource-test +[ 0.060000] 1..5 +[ 0.060000] ok 1 - kunit_resource_test_init_resources +[ 0.060000] ok 2 - kunit_resource_test_alloc_resource +[ 0.060000] ok 3 - kunit_resource_test_destroy_resource +[ 0.060000] foo bar # +[ 0.060000] ok 4 - kunit_resource_test_cleanup_resources +[ 0.060000] ok 5 - kunit_resource_test_proper_free_ordering +[ 0.060000] ok 1 - kunit-resource-test +[ 0.060000] foo bar # non-kunit output +[ 0.060000] # Subtest: kunit-try-catch-test +[ 0.060000] 1..2 +[ 0.060000] ok 1 - kunit_test_try_catch_successful_try_no_catch +[ 0.060000] ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch +[ 0.060000] ok 2 - kunit-try-catch-test +[ 0.060000] # Subtest: string-stream-test +[ 0.060000] 1..3 +[ 0.060000] ok 1 - string_stream_test_empty_on_creation +[ 0.060000] ok 2 - string_stream_test_not_empty_after_add +[ 0.060000] ok 3 - string_stream_test_get_string +[ 0.060000] ok 3 - string-stream-test +[ 0.060000] List of all partitions: +[ 0.060000] No filesystem could mount root, tried: +[ 0.060000] +[ 0.060000] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(98,0) +[ 0.060000] CPU: 0 PID: 1 Comm: swapper Not tainted 5.4.0-rc1-gea2dd7c0875e-dirty #2 +[ 0.060000] Stack: +[ 0.060000] 602086f8 601bc260 705c0000 705c0000 +[ 0.060000] 602086f8 6005fcec 705c0000 6002c6ab +[ 0.060000] 6005fcec 601bc260 705c0000 3000000010 \ No newline at end of file diff --git a/tools/testing/kunit/test_data/test_pound_no_prefix.log b/tools/testing/kunit/test_data/test_pound_no_prefix.log new file mode 100644 index 000000000000..2ceb360be7d5 --- /dev/null +++ b/tools/testing/kunit/test_data/test_pound_no_prefix.log @@ -0,0 +1,33 @@ + printk: console [mc-1] enabled + random: get_random_bytes called from init_oops_id+0x35/0x40 with crng_init=0 + TAP version 14 + # Subtest: kunit-resource-test + 1..5 + ok 1 - kunit_resource_test_init_resources + ok 2 - kunit_resource_test_alloc_resource + ok 3 - kunit_resource_test_destroy_resource + foo bar # + ok 4 - kunit_resource_test_cleanup_resources + ok 5 - kunit_resource_test_proper_free_ordering + ok 1 - kunit-resource-test + foo bar # non-kunit output + # Subtest: kunit-try-catch-test + 1..2 + ok 1 - kunit_test_try_catch_successful_try_no_catch + ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch + ok 2 - kunit-try-catch-test + # Subtest: string-stream-test + 1..3 + ok 1 - string_stream_test_empty_on_creation + ok 2 - string_stream_test_not_empty_after_add + ok 3 - string_stream_test_get_string + ok 3 - string-stream-test + List of all partitions: + No filesystem could mount root, tried: + + Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(98,0) + CPU: 0 PID: 1 Comm: swapper Not tainted 5.4.0-rc1-gea2dd7c0875e-dirty #2 + Stack: + 602086f8 601bc260 705c0000 705c0000 + 602086f8 6005fcec 705c0000 6002c6ab + 6005fcec 601bc260 705c0000 3000000010 \ No newline at end of file diff --git a/tools/testing/kunit/test_data/test_pound_sign.log b/tools/testing/kunit/test_data/test_pound_sign.log new file mode 100644 index 000000000000..0f87cdabebb0 --- /dev/null +++ b/tools/testing/kunit/test_data/test_pound_sign.log @@ -0,0 +1,33 @@ +[ 0.060000] printk: console [mc-1] enabled +[ 0.060000] random: get_random_bytes called from init_oops_id+0x35/0x40 with crng_init=0 +[ 0.060000] TAP version 14 +[ 0.060000] # Subtest: kunit-resource-test +[ 0.060000] 1..5 +[ 0.060000] ok 1 - kunit_resource_test_init_resources +[ 0.060000] ok 2 - kunit_resource_test_alloc_resource +[ 0.060000] ok 3 - kunit_resource_test_destroy_resource +[ 0.060000] foo bar # +[ 0.060000] ok 4 - kunit_resource_test_cleanup_resources +[ 0.060000] ok 5 - kunit_resource_test_proper_free_ordering +[ 0.060000] ok 1 - kunit-resource-test +[ 0.060000] foo bar # non-kunit output +[ 0.060000] # Subtest: kunit-try-catch-test +[ 0.060000] 1..2 +[ 0.060000] ok 1 - kunit_test_try_catch_successful_try_no_catch +[ 0.060000] ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch +[ 0.060000] ok 2 - kunit-try-catch-test +[ 0.060000] # Subtest: string-stream-test +[ 0.060000] 1..3 +[ 0.060000] ok 1 - string_stream_test_empty_on_creation +[ 0.060000] ok 2 - string_stream_test_not_empty_after_add +[ 0.060000] ok 3 - string_stream_test_get_string +[ 0.060000] ok 3 - string-stream-test +[ 0.060000] List of all partitions: +[ 0.060000] No filesystem could mount root, tried: +[ 0.060000] +[ 0.060000] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(98,0) +[ 0.060000] CPU: 0 PID: 1 Comm: swapper Not tainted 5.4.0-rc1-gea2dd7c0875e-dirty #2 +[ 0.060000] Stack: +[ 0.060000] 602086f8 601bc260 705c0000 705c0000 +[ 0.060000] 602086f8 6005fcec 705c0000 6002c6ab +[ 0.060000] 6005fcec 601bc260 705c0000 3000000010 \ No newline at end of file -- 2.25.0.265.gbab2e86ba0-goog

5 years, 3 months

3
5
0 0

next-20200316 kselftest results

by ci_notify＠linaro.org

Summary ------------------------------------------------------------------------ kernel: 5.6.0-rc5 git repo: https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git git branch: master git commit: 8548fd2f20ed19b0e8c0585b71fdfde1ae00ae3c git describe: next-20200316 Test details: https://qa-reports.linaro.org/lkft/linux-next-oe/build/next-20200316 Regressions (compared to build next-20200313) ------------------------------------------------------------------------ x86: kselftest: * rtc_rtctest Fixes (compared to build next-20200313) ------------------------------------------------------------------------ qemu_x86_64: kselftest: * rtc_rtctest juno-r2: kselftest: * cgroup_test_freezer In total: ------------------------------------------------------------------------ Ran 1847 total tests in the following environments and test suites. pass 716 fail 909 xfail 0 skip 222 Environments -------------- - dragonboard-410c - arm64 - hi6220-hikey - arm64 - i386 - juno-r2 - arm64 - qemu_arm64 - qemu_i386 - qemu_x86_64 - x15 - arm - x86_64 Test Suites ----------- * kselftest * kselftest/filesystems * kselftest/drivers * kselftest/net * kselftest/networking * kselftest-vsyscall-mode-native * kselftest-vsyscall-mode-native/drivers * kselftest-vsyscall-mode-native/filesystems * kselftest-vsyscall-mode-native/net * kselftest-vsyscall-mode-native/networking * kselftest-vsyscall-mode-none * kselftest-vsyscall-mode-none/drivers * kselftest-vsyscall-mode-none/filesystems * kselftest-vsyscall-mode-none/net * kselftest-vsyscall-mode-none/networking Failures ------------------------------------------------------------------------ qemu_i386: * kselftest/bpf_get_cgroup_id_user * kselftest/bpf_test_bpftool.sh * kselftest/bpf_test_dev_cgroup * kselftest/bpf_test_flow_dissector.sh * kselftest/bpf_test_hashmap * kselftest/bpf_test_lwt_ip_encap.sh * kselftest/bpf_test_lwt_seg6local.sh * kselftest/bpf_test_maps * kselftest/bpf_test_netcnt * kselftest/bpf_test_progs * kselftest/bpf_test_progs-no_alu32 * kselftest/bpf_test_skb_cgroup_id.sh * kselftest/bpf_test_sock_addr.sh * kselftest/bpf_test_socket_cookie * kselftest/bpf_test_sock_fields * kselftest/bpf_test_sockmap * kselftest/bpf_test_sysctl * kselftest/bpf_test_tc_edt.sh * kselftest/bpf_test_tcpbpf_user * kselftest/bpf_test_tcp_check_syncookie.sh * kselftest/bpf_test_tcpnotify_user * kselftest/bpf_test_tc_tunnel.sh * kselftest/bpf_test_tunnel.sh * kselftest/bpf_test_xdping.sh * kselftest/bpf_test_xdp_meta.sh * kselftest/bpf_test_xdp_redirect.sh * kselftest/bpf_test_xdp_vlan_mode_generic.sh * kselftest/bpf_test_xdp_vlan_mode_native.sh * kselftest/clone3_clone3_clear_sighand * kselftest/cpufreq_main.sh * kselftest/firmware_fw_run_tests.sh * kselftest/ftrace_ftracetest * kselftest/kvm_clear_dirty_log_test * kselftest/kvm_cr4_cpuid_sync_test * kselftest/kvm_dirty_log_test * kselftest/kvm_evmcs_test * kselftest/kvm_hyperv_cpuid * kselftest/kvm_kvm_create_max_vcpus * kselftest/kvm_mmio_warning_test * kselftest/kvm_platform_info_test * kselftest/kvm_set_sregs_test * kselftest/kvm_smm_test * kselftest/kvm_state_test * kselftest/kvm_svm_vmcall_test * kselftest/kvm_sync_regs_test * kselftest/kvm_vmx_close_while_nested_test * kselftest/kvm_vmx_dirty_log_test * kselftest/kvm_vmx_set_nested_state_test * kselftest/kvm_vmx_tsc_adjust_test * kselftest/kvm_xss_msr_test * kselftest/lib_printf.sh * kselftest/lkdtm_ACCESS_NULL.sh * kselftest/lkdtm_ACCESS_USERSPACE.sh * kselftest/lkdtm_BUG.sh * kselftest/lkdtm_CFI_FORWARD_PROTO.sh * kselftest/lkdtm_CORRUPT_LIST_ADD.sh * kselftest/lkdtm_CORRUPT_LIST_DEL.sh * kselftest/lkdtm_CORRUPT_USER_DS.sh * kselftest/lkdtm_DOUBLE_FAULT.sh * kselftest/lkdtm_EXCEPTION.sh * kselftest/lkdtm_EXEC_DATA.sh * kselftest/lkdtm_EXEC_KMALLOC.sh * kselftest/lkdtm_EXEC_NULL.sh * kselftest/lkdtm_EXEC_RODATA.sh * kselftest/lkdtm_EXEC_STACK.sh * kselftest/lkdtm_EXEC_USERSPACE.sh * kselftest/lkdtm_EXEC_VMALLOC.sh * kselftest/lkdtm_READ_AFTER_FREE.sh * kselftest/lkdtm_READ_BUDDY_AFTER_FREE.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_ZERO.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_ZERO.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_ZERO.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * kselftest/lkdtm_SLAB_FREE_CROSS.sh * kselftest/lkdtm_SLAB_FREE_DOUBLE.sh * kselftest/lkdtm_SLAB_FREE_PAGE.sh * kselftest/lkdtm_STACK_GUARD_PAGE_LEADING.sh * kselftest/lkdtm_STACK_GUARD_PAGE_TRAILING.sh * kselftest/lkdtm_STACKLEAK_ERASING.sh * kselftest/lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * kselftest/lkdtm_UNSET_SMEP.sh * kselftest/lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * kselftest/lkdtm_USERCOPY_HEAP_SIZE_TO.sh * kselftest/lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * kselftest/lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * kselftest/lkdtm_USERCOPY_KERNEL_DS.sh * kselftest/lkdtm_USERCOPY_KERNEL.sh * kselftest/lkdtm_USERCOPY_STACK_BEYOND.sh * kselftest/lkdtm_USERCOPY_STACK_FRAME_FROM.sh * kselftest/lkdtm_USERCOPY_STACK_FRAME_TO.sh * kselftest/lkdtm_WARNING_MESSAGE.sh * kselftest/lkdtm_WARNING.sh * kselftest/lkdtm_WRITE_KERN.sh * kselftest/lkdtm_WRITE_RO_AFTER_INIT.sh * kselftest/lkdtm_WRITE_RO.sh juno-r2: * kselftest/bpf_get_cgroup_id_user * kselftest/bpf_test_bpftool.sh * kselftest/bpf_test_dev_cgroup * kselftest/bpf_test_flow_dissector.sh * kselftest/bpf_test_lwt_ip_encap.sh * kselftest/bpf_test_lwt_seg6local.sh * kselftest/bpf_test_maps * kselftest/bpf_test_netcnt * kselftest/bpf_test_progs * kselftest/bpf_test_progs-no_alu32 * kselftest/bpf_test_skb_cgroup_id.sh * kselftest/bpf_test_sock_addr.sh * kselftest/bpf_test_socket_cookie * kselftest/bpf_test_sock_fields * kselftest/bpf_test_sockmap * kselftest/bpf_test_sysctl * kselftest/bpf_test_tag * kselftest/bpf_test_tc_edt.sh * kselftest/bpf_test_tcpbpf_user * kselftest/bpf_test_tcp_check_syncookie.sh * kselftest/bpf_test_tcpnotify_user * kselftest/bpf_test_tc_tunnel.sh * kselftest/bpf_test_tunnel.sh * kselftest/bpf_test_verifier * kselftest/bpf_test_xdping.sh * kselftest/bpf_test_xdp_meta.sh * kselftest/bpf_test_xdp_redirect.sh * kselftest/bpf_test_xdp_vlan_mode_generic.sh * kselftest/bpf_test_xdp_vlan_mode_native.sh * kselftest/cpufreq_main.sh * kselftest/firmware_fw_run_tests.sh * kselftest/ftrace_ftracetest * kselftest/kvm_clear_dirty_log_test * kselftest/kvm_cr4_cpuid_sync_test * kselftest/kvm_dirty_log_test * kselftest/kvm_evmcs_test * kselftest/kvm_hyperv_cpuid * kselftest/kvm_kvm_create_max_vcpus * kselftest/kvm_mmio_warning_test * kselftest/kvm_platform_info_test * kselftest/kvm_set_sregs_test * kselftest/kvm_smm_test * kselftest/kvm_state_test * kselftest/kvm_svm_vmcall_test * kselftest/kvm_sync_regs_test * kselftest/kvm_vmx_close_while_nested_test * kselftest/kvm_vmx_dirty_log_test * kselftest/kvm_vmx_set_nested_state_test * kselftest/kvm_vmx_tsc_adjust_test * kselftest/kvm_xss_msr_test * kselftest/lib_printf.sh * kselftest/lkdtm_ACCESS_NULL.sh * kselftest/lkdtm_ACCESS_USERSPACE.sh * kselftest/lkdtm_BUG.sh * kselftest/lkdtm_CFI_FORWARD_PROTO.sh * kselftest/lkdtm_CORRUPT_LIST_ADD.sh * kselftest/lkdtm_CORRUPT_LIST_DEL.sh * kselftest/lkdtm_CORRUPT_USER_DS.sh * kselftest/lkdtm_EXCEPTION.sh * kselftest/lkdtm_EXEC_DATA.sh * kselftest/lkdtm_EXEC_KMALLOC.sh * kselftest/lkdtm_EXEC_NULL.sh * kselftest/lkdtm_EXEC_RODATA.sh * kselftest/lkdtm_EXEC_STACK.sh * kselftest/lkdtm_EXEC_USERSPACE.sh * kselftest/lkdtm_EXEC_VMALLOC.sh * kselftest/lkdtm_READ_AFTER_FREE.sh * kselftest/lkdtm_READ_BUDDY_AFTER_FREE.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_ZERO.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_ZERO.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_ZERO.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * kselftest/lkdtm_SLAB_FREE_CROSS.sh * kselftest/lkdtm_SLAB_FREE_DOUBLE.sh * kselftest/lkdtm_SLAB_FREE_PAGE.sh * kselftest/lkdtm_STACK_GUARD_PAGE_LEADING.sh * kselftest/lkdtm_STACK_GUARD_PAGE_TRAILING.sh * kselftest/lkdtm_STACKLEAK_ERASING.sh * kselftest/lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * kselftest/lkdtm_UNSET_SMEP.sh * kselftest/lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * kselftest/lkdtm_USERCOPY_HEAP_SIZE_TO.sh * kselftest/lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * kselftest/lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * kselftest/lkdtm_USERCOPY_KERNEL_DS.sh * kselftest/lkdtm_USERCOPY_KERNEL.sh * kselftest/lkdtm_USERCOPY_STACK_BEYOND.sh * kselftest/lkdtm_USERCOPY_STACK_FRAME_FROM.sh * kselftest/lkdtm_USERCOPY_STACK_FRAME_TO.sh * kselftest/lkdtm_WARNING_MESSAGE.sh * kselftest/lkdtm_WARNING.sh * kselftest/lkdtm_WRITE_KERN.sh * kselftest/lkdtm_WRITE_RO_AFTER_INIT.sh * kselftest/lkdtm_WRITE_RO.sh * kselftest/memory-hotplug_mem-on-off-test.sh * kselftest/net_fib-onlink-tests.sh * kselftest/net_fib_rule_tests.sh * kselftest/net_fib_tests.sh * kselftest/netfilter_conntrack_icmp_related.sh * kselftest/netfilter_nft_concat_range.sh * kselftest/netfilter_nft_nat.sh * kselftest/net_ip_defrag.sh * kselftest/net_l2tp.sh * kselftest/net_pmtu.sh * kselftest/net_psock_snd.sh * kselftest/net_run_netsocktests * kselftest/net_tcp_fastopen_backup_key.sh * kselftest/net_test_vxlan_under_vrf.sh * kselftest/net_udpgro_bench.sh * kselftest/net_udpgro.sh * kselftest/net_udpgso_bench.sh * kselftest/pidfd_pidfd_fdinfo_test * kselftest/pidfd_pidfd_open_test * kselftest/pidfd_pidfd_poll_test * kselftest/pidfd_pidfd_test i386: * kselftest/bpf_get_cgroup_id_user * kselftest/bpf_test_bpftool.sh * kselftest/bpf_test_dev_cgroup * kselftest/bpf_test_flow_dissector.sh * kselftest/bpf_test_hashmap * kselftest/bpf_test_lwt_ip_encap.sh * kselftest/bpf_test_lwt_seg6local.sh * kselftest/bpf_test_netcnt * kselftest/bpf_test_progs * kselftest/bpf_test_progs-no_alu32 * kselftest/bpf_test_skb_cgroup_id.sh * kselftest/bpf_test_sock_addr.sh * kselftest/bpf_test_socket_cookie * kselftest/bpf_test_sock_fields * kselftest/bpf_test_sockmap * kselftest/bpf_test_sysctl * kselftest/bpf_test_tc_edt.sh * kselftest/bpf_test_tcpbpf_user * kselftest/bpf_test_tcp_check_syncookie.sh * kselftest/bpf_test_tcpnotify_user * kselftest/bpf_test_tc_tunnel.sh * kselftest/bpf_test_tunnel.sh * kselftest/bpf_test_xdping.sh * kselftest/bpf_test_xdp_meta.sh * kselftest/bpf_test_xdp_vlan_mode_generic.sh * kselftest/bpf_test_xdp_vlan_mode_native.sh * kselftest/clone3_clone3_clear_sighand * kselftest/firmware_fw_run_tests.sh * kselftest/ftrace_ftracetest * kselftest/intel_pstate_run.sh * kselftest/kvm_clear_dirty_log_test * kselftest/kvm_cr4_cpuid_sync_test * kselftest/kvm_dirty_log_test * kselftest/kvm_evmcs_test * kselftest/kvm_hyperv_cpuid * kselftest/kvm_kvm_create_max_vcpus * kselftest/kvm_mmio_warning_test * kselftest/kvm_platform_info_test * kselftest/kvm_set_sregs_test * kselftest/kvm_smm_test * kselftest/kvm_state_test * kselftest/kvm_svm_vmcall_test * kselftest/kvm_sync_regs_test * kselftest/kvm_vmx_close_while_nested_test * kselftest/kvm_vmx_dirty_log_test * kselftest/kvm_vmx_set_nested_state_test * kselftest/kvm_vmx_tsc_adjust_test * kselftest/kvm_xss_msr_test * kselftest/lib_printf.sh * kselftest/lkdtm_ACCESS_NULL.sh * kselftest/lkdtm_ACCESS_USERSPACE.sh * kselftest/lkdtm_BUG.sh * kselftest/lkdtm_CORRUPT_LIST_ADD.sh * kselftest/lkdtm_CORRUPT_LIST_DEL.sh * kselftest/lkdtm_CORRUPT_USER_DS.sh * kselftest/lkdtm_DOUBLE_FAULT.sh * kselftest/lkdtm_EXCEPTION.sh * kselftest/lkdtm_EXEC_DATA.sh * kselftest/lkdtm_EXEC_KMALLOC.sh * kselftest/lkdtm_EXEC_NULL.sh * kselftest/lkdtm_EXEC_RODATA.sh * kselftest/lkdtm_EXEC_STACK.sh * kselftest/lkdtm_EXEC_USERSPACE.sh * kselftest/lkdtm_EXEC_VMALLOC.sh * kselftest/lkdtm_READ_AFTER_FREE.sh * kselftest/lkdtm_READ_BUDDY_AFTER_FREE.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_ZERO.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_ZERO.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_ZERO.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * kselftest/lkdtm_SLAB_FREE_CROSS.sh * kselftest/lkdtm_SLAB_FREE_DOUBLE.sh * kselftest/lkdtm_SLAB_FREE_PAGE.sh * kselftest/lkdtm_STACK_GUARD_PAGE_LEADING.sh * kselftest/lkdtm_STACK_GUARD_PAGE_TRAILING.sh * kselftest/lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * kselftest/lkdtm_UNSET_SMEP.sh * kselftest/lkdtm_WARNING_MESSAGE.sh * kselftest/lkdtm_WARNING.sh * kselftest/lkdtm_WRITE_KERN.sh * kselftest/lkdtm_WRITE_RO_AFTER_INIT.sh * kselftest/lkdtm_WRITE_RO.sh qemu_arm64: * kselftest/bpf_get_cgroup_id_user * kselftest/bpf_test_bpftool.sh * kselftest/bpf_test_dev_cgroup * kselftest/bpf_test_flow_dissector.sh * kselftest/bpf_test_kmod.sh * kselftest/bpf_test_lpm_map * kselftest/bpf_test_lwt_ip_encap.sh * kselftest/bpf_test_lwt_seg6local.sh * kselftest/bpf_test_maps * kselftest/bpf_test_netcnt * kselftest/bpf_test_progs * kselftest/bpf_test_progs-no_alu32 * kselftest/bpf_test_skb_cgroup_id.sh * kselftest/bpf_test_sock_addr.sh * kselftest/bpf_test_socket_cookie * kselftest/bpf_test_sock_fields * kselftest/bpf_test_sockmap * kselftest/bpf_test_sysctl * kselftest/bpf_test_tag * kselftest/bpf_test_tc_edt.sh * kselftest/bpf_test_tcpbpf_user * kselftest/bpf_test_tcp_check_syncookie.sh * kselftest/bpf_test_tcpnotify_user * kselftest/bpf_test_tc_tunnel.sh * kselftest/bpf_test_tunnel.sh * kselftest/bpf_test_verifier * kselftest/bpf_test_xdping.sh * kselftest/bpf_test_xdp_meta.sh * kselftest/bpf_test_xdp_redirect.sh * kselftest/bpf_test_xdp_vlan_mode_generic.sh * kselftest/bpf_test_xdp_vlan_mode_native.sh * kselftest/cpufreq_main.sh x15: dragonboard-410c: qemu_x86_64: * kselftest/bpf_get_cgroup_id_user * kselftest/bpf_test_bpftool.sh * kselftest/bpf_test_dev_cgroup * kselftest/bpf_test_flow_dissector.sh * kselftest/bpf_test_lwt_ip_encap.sh * kselftest/bpf_test_lwt_seg6local.sh * kselftest/bpf_test_maps * kselftest/bpf_test_netcnt * kselftest/bpf_test_progs * kselftest/bpf_test_progs-no_alu32 * kselftest/bpf_test_skb_cgroup_id.sh * kselftest/bpf_test_sock_addr.sh * kselftest/bpf_test_socket_cookie * kselftest/bpf_test_sock_fields * kselftest/bpf_test_sockmap * kselftest/bpf_test_sysctl * kselftest/bpf_test_tc_edt.sh * kselftest/bpf_test_tcpbpf_user * kselftest/bpf_test_tcp_check_syncookie.sh * kselftest/bpf_test_tcpnotify_user * kselftest/bpf_test_tc_tunnel.sh * kselftest/bpf_test_tunnel.sh * kselftest/bpf_test_xdping.sh * kselftest/bpf_test_xdp_meta.sh * kselftest/bpf_test_xdp_redirect.sh * kselftest/bpf_test_xdp_vlan_mode_generic.sh * kselftest/bpf_test_xdp_vlan_mode_native.sh * kselftest/cpufreq_main.sh * kselftest/firmware_fw_run_tests.sh * kselftest/ftrace_ftracetest * kselftest/kvm_clear_dirty_log_test * kselftest/kvm_cr4_cpuid_sync_test * kselftest/kvm_dirty_log_test * kselftest/kvm_evmcs_test * kselftest/kvm_hyperv_cpuid * kselftest/kvm_kvm_create_max_vcpus * kselftest/kvm_platform_info_test * kselftest/kvm_set_sregs_test * kselftest/kvm_smm_test * kselftest/kvm_state_test * kselftest/kvm_svm_vmcall_test * kselftest/kvm_sync_regs_test * kselftest/kvm_xss_msr_test * kselftest/lib_printf.sh * kselftest/lkdtm_ACCESS_NULL.sh * kselftest/lkdtm_ACCESS_USERSPACE.sh * kselftest/lkdtm_BUG.sh * kselftest/lkdtm_CFI_FORWARD_PROTO.sh * kselftest/lkdtm_CORRUPT_LIST_ADD.sh * kselftest/lkdtm_CORRUPT_LIST_DEL.sh * kselftest/lkdtm_CORRUPT_USER_DS.sh * kselftest/lkdtm_EXCEPTION.sh * kselftest/lkdtm_EXEC_DATA.sh * kselftest/lkdtm_EXEC_KMALLOC.sh * kselftest/lkdtm_EXEC_NULL.sh * kselftest/lkdtm_EXEC_RODATA.sh * kselftest/lkdtm_EXEC_STACK.sh * kselftest/lkdtm_EXEC_USERSPACE.sh * kselftest/lkdtm_EXEC_VMALLOC.sh * kselftest/lkdtm_READ_AFTER_FREE.sh * kselftest/lkdtm_READ_BUDDY_AFTER_FREE.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_ZERO.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_ZERO.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_ZERO.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * kselftest/lkdtm_SLAB_FREE_CROSS.sh * kselftest/lkdtm_SLAB_FREE_DOUBLE.sh * kselftest/lkdtm_SLAB_FREE_PAGE.sh * kselftest/lkdtm_STACK_GUARD_PAGE_LEADING.sh * kselftest/lkdtm_STACK_GUARD_PAGE_TRAILING.sh * kselftest/lkdtm_STACKLEAK_ERASING.sh * kselftest/lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * kselftest/lkdtm_UNSET_SMEP.sh * kselftest/lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * kselftest/lkdtm_USERCOPY_HEAP_SIZE_TO.sh * kselftest/lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * kselftest/lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * kselftest/lkdtm_USERCOPY_KERNEL_DS.sh * kselftest/lkdtm_USERCOPY_KERNEL.sh * kselftest/lkdtm_USERCOPY_STACK_BEYOND.sh * kselftest/lkdtm_USERCOPY_STACK_FRAME_FROM.sh * kselftest/lkdtm_USERCOPY_STACK_FRAME_TO.sh * kselftest/lkdtm_WARNING_MESSAGE.sh * kselftest/lkdtm_WARNING.sh * kselftest/lkdtm_WRITE_KERN.sh * kselftest/lkdtm_WRITE_RO_AFTER_INIT.sh * kselftest/lkdtm_WRITE_RO.sh * kselftest/mqueue_mq_perf_tests * kselftest/net_fib-onlink-tests.sh * kselftest/net_fib_tests.sh * kselftest/netfilter_nft_concat_range.sh * kselftest/net_ip_defrag.sh * kselftest/net_l2tp.sh * kselftest/net_pmtu.sh * kselftest/net_psock_snd.sh * kselftest/net_run_netsocktests * kselftest/net_test_vxlan_under_vrf.sh * kselftest/net_udpgro_bench.sh * kselftest/net_udpgro.sh * kselftest/net_udpgso_bench.sh * kselftest/net_xfrm_policy.sh * kselftest/openat2_openat2_test * kselftest/openat2_rename_attack_test * kselftest/openat2_resolve_test * kselftest/pidfd_pidfd_open_test * kselftest/pidfd_pidfd_poll_test * kselftest/pstore_pstore_tests * kselftest/seccomp_seccomp_bpf * kselftest/timers_inconsistency-check * kselftest/timers_nsleep-lat * kselftest/timers_raw_skew * kselftest/timers_set-timer-lat * kselftest/networking/timestamping_txtimestamp.sh * kselftest/vm_run_vmtests * kselftest/x86_fsgsbase_64 x86: * kselftest-vsyscall-mode-none/bpf_get_cgroup_id_user * kselftest-vsyscall-mode-native/bpf_get_cgroup_id_user * kselftest/bpf_get_cgroup_id_user * kselftest-vsyscall-mode-native/bpf_test_bpftool.sh * kselftest/bpf_test_bpftool.sh * kselftest-vsyscall-mode-native/bpf_test_dev_cgroup * kselftest-vsyscall-mode-none/bpf_test_dev_cgroup * kselftest/bpf_test_dev_cgroup * kselftest/bpf_test_flow_dissector.sh * kselftest-vsyscall-mode-native/bpf_test_flow_dissector.sh * kselftest-vsyscall-mode-none/bpf_test_flow_dissector.sh * kselftest-vsyscall-mode-native/bpf_test_lwt_ip_encap.sh * kselftest-vsyscall-mode-none/bpf_test_lwt_ip_encap.sh * kselftest/bpf_test_lwt_ip_encap.sh * kselftest-vsyscall-mode-native/bpf_test_lwt_seg6local.sh * kselftest-vsyscall-mode-none/bpf_test_lwt_seg6local.sh * kselftest/bpf_test_lwt_seg6local.sh * kselftest/bpf_test_netcnt * kselftest-vsyscall-mode-none/bpf_test_netcnt * kselftest-vsyscall-mode-native/bpf_test_netcnt * kselftest/bpf_test_progs-no_alu32 * kselftest-vsyscall-mode-native/bpf_test_progs-no_alu32 * kselftest-vsyscall-mode-none/bpf_test_progs-no_alu32 * kselftest-vsyscall-mode-native/bpf_test_skb_cgroup_id.sh * kselftest-vsyscall-mode-none/bpf_test_skb_cgroup_id.sh * kselftest/bpf_test_skb_cgroup_id.sh * kselftest-vsyscall-mode-native/bpf_test_sock_addr.sh * kselftest-vsyscall-mode-none/bpf_test_sock_addr.sh * kselftest/bpf_test_sock_addr.sh * kselftest-vsyscall-mode-native/bpf_test_socket_cookie * kselftest/bpf_test_socket_cookie * kselftest-vsyscall-mode-none/bpf_test_socket_cookie * kselftest-vsyscall-mode-none/bpf_test_sock_fields * kselftest-vsyscall-mode-native/bpf_test_sock_fields * kselftest/bpf_test_sock_fields * kselftest/bpf_test_sockmap * kselftest-vsyscall-mode-none/bpf_test_sockmap * kselftest-vsyscall-mode-native/bpf_test_sockmap * kselftest-vsyscall-mode-none/bpf_test_sysctl * kselftest-vsyscall-mode-native/bpf_test_sysctl * kselftest/bpf_test_sysctl * kselftest/bpf_test_tc_edt.sh * kselftest-vsyscall-mode-native/bpf_test_tc_edt.sh * kselftest-vsyscall-mode-none/bpf_test_tc_edt.sh * kselftest-vsyscall-mode-none/bpf_test_tcpbpf_user * kselftest-vsyscall-mode-native/bpf_test_tcpbpf_user * kselftest-vsyscall-mode-native/bpf_test_tcp_check_syncookie.sh * kselftest/bpf_test_tcp_check_syncookie.sh * kselftest-vsyscall-mode-none/bpf_test_tcp_check_syncookie.sh * kselftest-vsyscall-mode-native/bpf_test_tcpnotify_user * kselftest/bpf_test_tcpnotify_user * kselftest-vsyscall-mode-none/bpf_test_tcpnotify_user * kselftest-vsyscall-mode-native/bpf_test_tc_tunnel.sh * kselftest/bpf_test_tc_tunnel.sh * kselftest-vsyscall-mode-none/bpf_test_tc_tunnel.sh * kselftest-vsyscall-mode-none/bpf_test_tunnel.sh * kselftest-vsyscall-mode-native/bpf_test_tunnel.sh * kselftest/bpf_test_tunnel.sh * kselftest/bpf_test_xdping.sh * kselftest-vsyscall-mode-native/bpf_test_xdping.sh * kselftest-vsyscall-mode-none/bpf_test_xdping.sh * kselftest-vsyscall-mode-none/bpf_test_xdp_meta.sh * kselftest-vsyscall-mode-native/bpf_test_xdp_meta.sh * kselftest/bpf_test_xdp_meta.sh * kselftest/bpf_test_xdp_redirect.sh * kselftest-vsyscall-mode-native/bpf_test_xdp_redirect.sh * kselftest-vsyscall-mode-none/bpf_test_xdp_redirect.sh * kselftest/bpf_test_xdp_vlan_mode_generic.sh * kselftest-vsyscall-mode-native/bpf_test_xdp_vlan_mode_generic.sh * kselftest-vsyscall-mode-none/bpf_test_xdp_vlan_mode_generic.sh * kselftest-vsyscall-mode-none/bpf_test_xdp_vlan_mode_native.sh * kselftest-vsyscall-mode-native/bpf_test_xdp_vlan_mode_native.sh * kselftest/bpf_test_xdp_vlan_mode_native.sh * kselftest-vsyscall-mode-native/firmware_fw_run_tests.sh * kselftest/firmware_fw_run_tests.sh * kselftest-vsyscall-mode-none/firmware_fw_run_tests.sh * kselftest-vsyscall-mode-none/ftrace_ftracetest * kselftest/ftrace_ftracetest * kselftest-vsyscall-mode-native/ftrace_ftracetest * kselftest-vsyscall-mode-none/intel_pstate_run.sh * kselftest/intel_pstate_run.sh * kselftest-vsyscall-mode-native/intel_pstate_run.sh * kselftest/kvm_clear_dirty_log_test * kselftest-vsyscall-mode-native/kvm_clear_dirty_log_test * kselftest-vsyscall-mode-none/kvm_clear_dirty_log_test * kselftest-vsyscall-mode-none/kvm_cr4_cpuid_sync_test * kselftest/kvm_cr4_cpuid_sync_test * kselftest-vsyscall-mode-native/kvm_cr4_cpuid_sync_test * kselftest/kvm_dirty_log_test * kselftest-vsyscall-mode-none/kvm_dirty_log_test * kselftest-vsyscall-mode-native/kvm_dirty_log_test * kselftest/kvm_evmcs_test * kselftest-vsyscall-mode-none/kvm_evmcs_test * kselftest-vsyscall-mode-native/kvm_evmcs_test * kselftest/kvm_hyperv_cpuid * kselftest-vsyscall-mode-none/kvm_hyperv_cpuid * kselftest-vsyscall-mode-native/kvm_hyperv_cpuid * kselftest-vsyscall-mode-native/kvm_kvm_create_max_vcpus * kselftest/kvm_kvm_create_max_vcpus * kselftest-vsyscall-mode-none/kvm_kvm_create_max_vcpus * kselftest-vsyscall-mode-native/kvm_platform_info_test * kselftest/kvm_platform_info_test * kselftest-vsyscall-mode-none/kvm_platform_info_test * kselftest-vsyscall-mode-native/kvm_set_sregs_test * kselftest/kvm_set_sregs_test * kselftest-vsyscall-mode-none/kvm_set_sregs_test * kselftest-vsyscall-mode-native/kvm_smm_test * kselftest/kvm_smm_test * kselftest-vsyscall-mode-none/kvm_smm_test * kselftest/kvm_state_test * kselftest-vsyscall-mode-native/kvm_state_test * kselftest-vsyscall-mode-none/kvm_state_test * kselftest-vsyscall-mode-native/kvm_sync_regs_test * kselftest/kvm_sync_regs_test * kselftest-vsyscall-mode-none/kvm_sync_regs_test * kselftest-vsyscall-mode-native/kvm_vmx_close_while_nested_test * kselftest-vsyscall-mode-none/kvm_vmx_close_while_nested_test * kselftest/kvm_vmx_close_while_nested_test * kselftest-vsyscall-mode-none/kvm_vmx_dirty_log_test * kselftest/kvm_vmx_dirty_log_test * kselftest-vsyscall-mode-native/kvm_vmx_dirty_log_test * kselftest-vsyscall-mode-none/kvm_vmx_set_nested_state_test * kselftest/kvm_vmx_set_nested_state_test * kselftest-vsyscall-mode-native/kvm_vmx_set_nested_state_test * kselftest-vsyscall-mode-none/kvm_vmx_tsc_adjust_test * kselftest/kvm_vmx_tsc_adjust_test * kselftest-vsyscall-mode-native/kvm_vmx_tsc_adjust_test * kselftest/kvm_xss_msr_test * kselftest-vsyscall-mode-native/kvm_xss_msr_test * kselftest-vsyscall-mode-none/kvm_xss_msr_test * kselftest-vsyscall-mode-native/lib_printf.sh * kselftest-vsyscall-mode-none/lib_printf.sh * kselftest/lib_printf.sh * kselftest-vsyscall-mode-native/lkdtm_ACCESS_NULL.sh * kselftest/lkdtm_ACCESS_NULL.sh * kselftest-vsyscall-mode-none/lkdtm_ACCESS_NULL.sh * kselftest-vsyscall-mode-native/lkdtm_ACCESS_USERSPACE.sh * kselftest-vsyscall-mode-none/lkdtm_ACCESS_USERSPACE.sh * kselftest/lkdtm_ACCESS_USERSPACE.sh * kselftest-vsyscall-mode-native/lkdtm_BUG.sh * kselftest-vsyscall-mode-none/lkdtm_BUG.sh * kselftest/lkdtm_BUG.sh * kselftest-vsyscall-mode-none/lkdtm_CFI_FORWARD_PROTO.sh * kselftest/lkdtm_CFI_FORWARD_PROTO.sh * kselftest-vsyscall-mode-native/lkdtm_CFI_FORWARD_PROTO.sh * kselftest-vsyscall-mode-native/lkdtm_CORRUPT_LIST_ADD.sh * kselftest/lkdtm_CORRUPT_LIST_ADD.sh * kselftest-vsyscall-mode-none/lkdtm_CORRUPT_LIST_ADD.sh * kselftest/lkdtm_CORRUPT_LIST_DEL.sh * kselftest-vsyscall-mode-native/lkdtm_CORRUPT_LIST_DEL.sh * kselftest-vsyscall-mode-none/lkdtm_CORRUPT_LIST_DEL.sh * kselftest/lkdtm_CORRUPT_USER_DS.sh * kselftest-vsyscall-mode-none/lkdtm_CORRUPT_USER_DS.sh * kselftest-vsyscall-mode-native/lkdtm_CORRUPT_USER_DS.sh * kselftest/lkdtm_EXCEPTION.sh * kselftest-vsyscall-mode-none/lkdtm_EXCEPTION.sh * kselftest-vsyscall-mode-native/lkdtm_EXCEPTION.sh * kselftest-vsyscall-mode-none/lkdtm_EXEC_DATA.sh * kselftest/lkdtm_EXEC_DATA.sh * kselftest-vsyscall-mode-native/lkdtm_EXEC_DATA.sh * kselftest/lkdtm_EXEC_KMALLOC.sh * kselftest-vsyscall-mode-native/lkdtm_EXEC_KMALLOC.sh * kselftest-vsyscall-mode-none/lkdtm_EXEC_KMALLOC.sh * kselftest-vsyscall-mode-none/lkdtm_EXEC_NULL.sh * kselftest-vsyscall-mode-native/lkdtm_EXEC_NULL.sh * kselftest/lkdtm_EXEC_NULL.sh * kselftest-vsyscall-mode-native/lkdtm_EXEC_RODATA.sh * kselftest/lkdtm_EXEC_RODATA.sh * kselftest-vsyscall-mode-none/lkdtm_EXEC_RODATA.sh * kselftest-vsyscall-mode-none/lkdtm_EXEC_STACK.sh * kselftest/lkdtm_EXEC_STACK.sh * kselftest-vsyscall-mode-native/lkdtm_EXEC_STACK.sh * kselftest-vsyscall-mode-native/lkdtm_EXEC_USERSPACE.sh * kselftest/lkdtm_EXEC_USERSPACE.sh * kselftest-vsyscall-mode-none/lkdtm_EXEC_USERSPACE.sh * kselftest-vsyscall-mode-native/lkdtm_EXEC_VMALLOC.sh * kselftest-vsyscall-mode-none/lkdtm_EXEC_VMALLOC.sh * kselftest/lkdtm_EXEC_VMALLOC.sh * kselftest-vsyscall-mode-native/lkdtm_READ_AFTER_FREE.sh * kselftest-vsyscall-mode-none/lkdtm_READ_AFTER_FREE.sh * kselftest/lkdtm_READ_AFTER_FREE.sh * kselftest-vsyscall-mode-native/lkdtm_READ_BUDDY_AFTER_FREE.sh * kselftest/lkdtm_READ_BUDDY_AFTER_FREE.sh * kselftest-vsyscall-mode-none/lkdtm_READ_BUDDY_AFTER_FREE.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_ADD_OVERFLOW.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_ADD_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_ADD_SATURATED.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_ADD_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_ADD_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_ADD_ZERO.sh * kselftest/lkdtm_REFCOUNT_ADD_ZERO.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_ADD_ZERO.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * kselftest/lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_DEC_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_NEGATIVE.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_DEC_NEGATIVE.sh * kselftest/lkdtm_REFCOUNT_DEC_SATURATED.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_DEC_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_DEC_SATURATED.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_DEC_ZERO.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_DEC_ZERO.sh * kselftest/lkdtm_REFCOUNT_DEC_ZERO.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_INC_OVERFLOW.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_INC_OVERFLOW.sh * kselftest/lkdtm_REFCOUNT_INC_OVERFLOW.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_INC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_SATURATED.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_INC_SATURATED.sh * kselftest/lkdtm_REFCOUNT_INC_ZERO.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_INC_ZERO.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_INC_ZERO.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * kselftest-vsyscall-mode-none/lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * kselftest-vsyscall-mode-native/lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * kselftest/lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * kselftest-vsyscall-mode-none/lkdtm_SLAB_FREE_CROSS.sh * kselftest-vsyscall-mode-native/lkdtm_SLAB_FREE_CROSS.sh * kselftest/lkdtm_SLAB_FREE_CROSS.sh * kselftest-vsyscall-mode-none/lkdtm_SLAB_FREE_DOUBLE.sh * kselftest/lkdtm_SLAB_FREE_DOUBLE.sh * kselftest-vsyscall-mode-native/lkdtm_SLAB_FREE_DOUBLE.sh * kselftest-vsyscall-mode-native/lkdtm_SLAB_FREE_PAGE.sh * kselftest-vsyscall-mode-none/lkdtm_SLAB_FREE_PAGE.sh * kselftest/lkdtm_SLAB_FREE_PAGE.sh * kselftest-vsyscall-mode-none/lkdtm_STACK_GUARD_PAGE_LEADING.sh * kselftest/lkdtm_STACK_GUARD_PAGE_LEADING.sh * kselftest-vsyscall-mode-native/lkdtm_STACK_GUARD_PAGE_LEADING.sh * kselftest-vsyscall-mode-none/lkdtm_STACK_GUARD_PAGE_TRAILING.sh * kselftest-vsyscall-mode-native/lkdtm_STACK_GUARD_PAGE_TRAILING.sh * kselftest/lkdtm_STACK_GUARD_PAGE_TRAILING.sh * kselftest-vsyscall-mode-none/lkdtm_STACKLEAK_ERASING.sh * kselftest-vsyscall-mode-native/lkdtm_STACKLEAK_ERASING.sh * kselftest/lkdtm_STACKLEAK_ERASING.sh * kselftest-vsyscall-mode-none/lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * kselftest-vsyscall-mode-native/lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * kselftest/lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * kselftest-vsyscall-mode-none/lkdtm_UNSET_SMEP.sh * kselftest-vsyscall-mode-native/lkdtm_UNSET_SMEP.sh * kselftest/lkdtm_UNSET_SMEP.sh * kselftest/lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_HEAP_SIZE_TO.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_HEAP_SIZE_TO.sh * kselftest/lkdtm_USERCOPY_HEAP_SIZE_TO.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * kselftest/lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * kselftest/lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * kselftest/lkdtm_USERCOPY_KERNEL_DS.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_KERNEL_DS.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_KERNEL_DS.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_KERNEL.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_KERNEL.sh * kselftest/lkdtm_USERCOPY_KERNEL.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_STACK_BEYOND.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_STACK_BEYOND.sh * kselftest/lkdtm_USERCOPY_STACK_BEYOND.sh * kselftest/lkdtm_USERCOPY_STACK_FRAME_FROM.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_STACK_FRAME_FROM.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_STACK_FRAME_FROM.sh * kselftest-vsyscall-mode-none/lkdtm_USERCOPY_STACK_FRAME_TO.sh * kselftest/lkdtm_USERCOPY_STACK_FRAME_TO.sh * kselftest-vsyscall-mode-native/lkdtm_USERCOPY_STACK_FRAME_TO.sh * kselftest-vsyscall-mode-none/lkdtm_WARNING_MESSAGE.sh * kselftest-vsyscall-mode-native/lkdtm_WARNING_MESSAGE.sh * kselftest/lkdtm_WARNING_MESSAGE.sh * kselftest-vsyscall-mode-native/lkdtm_WARNING.sh * kselftest/lkdtm_WARNING.sh * kselftest-vsyscall-mode-none/lkdtm_WARNING.sh * kselftest-vsyscall-mode-native/lkdtm_WRITE_KERN.sh * kselftest/lkdtm_WRITE_KERN.sh * kselftest-vsyscall-mode-none/lkdtm_WRITE_KERN.sh * kselftest-vsyscall-mode-none/lkdtm_WRITE_RO_AFTER_INIT.sh * kselftest-vsyscall-mode-native/lkdtm_WRITE_RO_AFTER_INIT.sh * kselftest/lkdtm_WRITE_RO_AFTER_INIT.sh * kselftest/lkdtm_WRITE_RO.sh * kselftest-vsyscall-mode-native/lkdtm_WRITE_RO.sh * kselftest-vsyscall-mode-none/lkdtm_WRITE_RO.sh * kselftest-vsyscall-mode-native/mqueue_mq_perf_tests * kselftest-vsyscall-mode-none/mqueue_mq_perf_tests * kselftest/mqueue_mq_perf_tests * kselftest/net_fib-onlink-tests.sh * kselftest-vsyscall-mode-native/net_fib-onlink-tests.sh * kselftest-vsyscall-mode-none/net_fib-onlink-tests.sh * kselftest/net_fib_tests.sh * kselftest-vsyscall-mode-native/net_fib_tests.sh * kselftest-vsyscall-mode-none/net_fib_tests.sh * kselftest-vsyscall-mode-native/netfilter_nft_concat_range.sh * kselftest-vsyscall-mode-none/netfilter_nft_concat_range.sh * kselftest/netfilter_nft_concat_range.sh * kselftest/net_ip_defrag.sh * kselftest-vsyscall-mode-native/net_ip_defrag.sh * kselftest-vsyscall-mode-none/net_ip_defrag.sh * kselftest-vsyscall-mode-native/net_l2tp.sh * kselftest-vsyscall-mode-none/net_l2tp.sh * kselftest/net_l2tp.sh * kselftest-vsyscall-mode-none/net_pmtu.sh * kselftest/net_pmtu.sh * kselftest-vsyscall-mode-native/net_pmtu.sh * kselftest/net_psock_snd.sh * kselftest-vsyscall-mode-native/net_psock_snd.sh * kselftest-vsyscall-mode-none/net_psock_snd.sh * kselftest/net_run_netsocktests * kselftest-vsyscall-mode-none/net_run_netsocktests * kselftest-vsyscall-mode-native/net_run_netsocktests * kselftest/net_test_vxlan_under_vrf.sh * kselftest-vsyscall-mode-none/net_test_vxlan_under_vrf.sh * kselftest-vsyscall-mode-native/net_test_vxlan_under_vrf.sh * kselftest-vsyscall-mode-none/net_traceroute.sh * kselftest/net_traceroute.sh * kselftest-vsyscall-mode-native/net_traceroute.sh * kselftest/net_udpgro_bench.sh * kselftest-vsyscall-mode-none/net_udpgro_bench.sh * kselftest-vsyscall-mode-native/net_udpgro_bench.sh * kselftest-vsyscall-mode-native/net_udpgro.sh * kselftest/net_udpgro.sh * kselftest-vsyscall-mode-none/net_udpgro.sh * kselftest/net_udpgso_bench.sh * kselftest-vsyscall-mode-native/net_udpgso_bench.sh * kselftest-vsyscall-mode-none/net_udpgso_bench.sh * kselftest-vsyscall-mode-native/net_xfrm_policy.sh * kselftest/net_xfrm_policy.sh * kselftest-vsyscall-mode-none/net_xfrm_policy.sh * kselftest-vsyscall-mode-native/openat2_openat2_test * kselftest-vsyscall-mode-none/openat2_openat2_test * kselftest/openat2_openat2_test * kselftest-vsyscall-mode-none/openat2_rename_attack_test * kselftest/openat2_rename_attack_test * kselftest-vsyscall-mode-native/openat2_rename_attack_test * kselftest/openat2_resolve_test * kselftest-vsyscall-mode-native/openat2_resolve_test * kselftest-vsyscall-mode-none/openat2_resolve_test * kselftest-vsyscall-mode-none/pidfd_pidfd_open_test * kselftest/pidfd_pidfd_open_test * kselftest-vsyscall-mode-native/pidfd_pidfd_open_test * kselftest/pidfd_pidfd_poll_test * kselftest-vsyscall-mode-none/pidfd_pidfd_poll_test * kselftest-vsyscall-mode-native/pidfd_pidfd_poll_test * kselftest/pstore_pstore_tests * kselftest-vsyscall-mode-none/pstore_pstore_tests * kselftest-vsyscall-mode-native/pstore_pstore_tests * kselftest-vsyscall-mode-none/rtc_rtctest * kselftest/rtc_rtctest * kselftest-vsyscall-mode-native/rtc_rtctest * kselftest-vsyscall-mode-native/seccomp_seccomp_bpf * kselftest/seccomp_seccomp_bpf * kselftest-vsyscall-mode-none/seccomp_seccomp_bpf * kselftest-vsyscall-mode-native/timers_inconsistency-check * kselftest/timers_inconsistency-check * kselftest-vsyscall-mode-none/timers_inconsistency-check * kselftest/timers_nsleep-lat * kselftest-vsyscall-mode-native/timers_nsleep-lat * kselftest-vsyscall-mode-none/timers_nsleep-lat * kselftest-vsyscall-mode-native/timers_raw_skew * kselftest-vsyscall-mode-none/timers_raw_skew * kselftest/timers_raw_skew * kselftest-vsyscall-mode-none/timers_set-timer-lat * kselftest-vsyscall-mode-native/timers_set-timer-lat * kselftest/timers_set-timer-lat * kselftest-vsyscall-mode-native/networking/timestamping_txtimestamp.sh * kselftest-vsyscall-mode-none/networking/timestamping_txtimestamp.sh * kselftest/networking/timestamping_txtimestamp.sh * kselftest-vsyscall-mode-none/vm_run_vmtests * kselftest/vm_run_vmtests * kselftest-vsyscall-mode-native/vm_run_vmtests hi6220-hikey: * kselftest/bpf_get_cgroup_id_user * kselftest/bpf_test_bpftool.sh * kselftest/bpf_test_dev_cgroup * kselftest/bpf_test_flow_dissector.sh * kselftest/bpf_test_kmod.sh * kselftest/bpf_test_lpm_map * kselftest/bpf_test_lwt_ip_encap.sh * kselftest/bpf_test_lwt_seg6local.sh * kselftest/bpf_test_maps * kselftest/bpf_test_netcnt * kselftest/bpf_test_progs * kselftest/bpf_test_progs-no_alu32 * kselftest/bpf_test_skb_cgroup_id.sh * kselftest/bpf_test_sock_addr.sh * kselftest/bpf_test_socket_cookie * kselftest/bpf_test_sock_fields * kselftest/bpf_test_sockmap * kselftest/bpf_test_sysctl * kselftest/bpf_test_tag * kselftest/bpf_test_tc_edt.sh * kselftest/bpf_test_tcpbpf_user * kselftest/bpf_test_tcp_check_syncookie.sh * kselftest/bpf_test_tcpnotify_user * kselftest/bpf_test_tc_tunnel.sh * kselftest/bpf_test_tunnel.sh * kselftest/bpf_test_verifier * kselftest/bpf_test_xdping.sh * kselftest/bpf_test_xdp_meta.sh * kselftest/bpf_test_xdp_redirect.sh * kselftest/bpf_test_xdp_vlan_mode_generic.sh * kselftest/bpf_test_xdp_vlan_mode_native.sh Skips ------------------------------------------------------------------------ No skips -- Linaro LKFT https://lkft.linaro.org

5 years, 3 months

1
0
0 0

[PATCH v2 0/2] kvm: selftests: Introduce TEST_FAIL and convert

by Wainer dos Santos Moschetta

Introduce the TEST_FAIL macro and change the tests/utilities to use it. v1 -> v2: - Completed the conversion to TEST_FAIL. v1: - [RFC PATCH 0/1] kvm: selftests: Add TEST_FAIL macro https://lore.kernel.org/kvm/20200305172532.9360-1-wainersm@redhat.com/ Wainer dos Santos Moschetta (2): selftests: kvm: Introduce the TEST_FAIL macro selftests: kvm: Uses TEST_FAIL in tests/utilities tools/testing/selftests/kvm/dirty_log_test.c | 7 +++---- .../testing/selftests/kvm/include/test_util.h | 3 +++ .../selftests/kvm/lib/aarch64/processor.c | 17 +++++++-------- .../testing/selftests/kvm/lib/aarch64/ucall.c | 2 +- tools/testing/selftests/kvm/lib/io.c | 12 +++++------ tools/testing/selftests/kvm/lib/kvm_util.c | 21 ++++++++----------- .../selftests/kvm/lib/x86_64/processor.c | 5 ++--- .../kvm/x86_64/cr4_cpuid_sync_test.c | 4 ++-- .../testing/selftests/kvm/x86_64/evmcs_test.c | 6 +++--- .../testing/selftests/kvm/x86_64/state_test.c | 6 +++--- .../selftests/kvm/x86_64/svm_vmcall_test.c | 6 ++---- .../kvm/x86_64/vmx_close_while_nested_test.c | 4 ++-- .../selftests/kvm/x86_64/vmx_dirty_log_test.c | 6 +++--- .../kvm/x86_64/vmx_tsc_adjust_test.c | 4 ++-- 14 files changed, 49 insertions(+), 54 deletions(-) -- 2.17.2

5 years, 3 months

2
3
0 0

[PATCH 0/5] kselftest: add fixture parameters

by Jakub Kicinski

Hi! This set is an attempt to make running tests for different sets of data easier. The direct motivation is the tls test which we'd like to run for TLS 1.2 and TLS 1.3, but currently there is no easy way to invoke the same tests with different parameters. Tested all users of kselftest_harness.h. Jakub Kicinski (5): selftests/seccomp: use correct FIXTURE macro kselftest: create fixture objects kselftest: run tests by fixture kselftest: add fixture parameters selftests: tls: run all tests for TLS 1.2 and TLS 1.3 Documentation/dev-tools/kselftest.rst | 3 +- tools/testing/selftests/kselftest_harness.h | 228 +++++++++++++++--- tools/testing/selftests/net/tls.c | 93 ++----- tools/testing/selftests/seccomp/seccomp_bpf.c | 10 +- 4 files changed, 213 insertions(+), 121 deletions(-) -- 2.24.1

5 years, 3 months

2
13
0 0

[PATCH v4] Documentation: kunit: Make the KUnit documentation less UML-specific

by David Gow

Remove some of the outmoded "Why KUnit" rationale, and move some UML-specific information to the kunit_tool page. Also update the Getting Started guide to mention running tests without the kunit_tool wrapper. Signed-off-by: David Gow <davidgow(a)google.com> Reviewed-by: Frank Rowand <frank.rowand(a)sony.com> --- Sorry: I missed a couple of issues in the last version. They're fixed here, and I think this should be ready to go. Changelog: v4: - Fix typo: s/offsers/offers - Talk about KUnit tests running on most "architectures" instead of "kernel configurations. v3: https://lore.kernel.org/linux-kselftest/20200214235723.254228-1-davidgow@go… - Added a note that KUnit can be used with UML, both with and without kunit_tool to replace the section moved to kunit_tool. v2: https://lore.kernel.org/linux-kselftest/f99a3d4d-ad65-5fd1-3407-db33f378b1f… - Reinstated the "Why Kunit?" section, minus the comparison with other testing frameworks (covered in the FAQ), and the description of UML. - Moved the description of UML into to kunit_tool page. - Tidied up the wording around how KUnit is built and run to make it work without the UML description. v1: https://lore.kernel.org/linux-kselftest/9c703dea-a9e1-94e2-c12d-3cb0a09e75a… - Initial patch Documentation/dev-tools/kunit/index.rst | 40 ++++++---- Documentation/dev-tools/kunit/kunit-tool.rst | 7 ++ Documentation/dev-tools/kunit/start.rst | 80 ++++++++++++++++---- 3 files changed, 99 insertions(+), 28 deletions(-) diff --git a/Documentation/dev-tools/kunit/index.rst b/Documentation/dev-tools/kunit/index.rst index d16a4d2c3a41..e93606ecfb01 100644 --- a/Documentation/dev-tools/kunit/index.rst +++ b/Documentation/dev-tools/kunit/index.rst @@ -17,14 +17,23 @@ What is KUnit? ============== KUnit is a lightweight unit testing and mocking framework for the Linux kernel. -These tests are able to be run locally on a developer's workstation without a VM -or special hardware. KUnit is heavily inspired by JUnit, Python's unittest.mock, and Googletest/Googlemock for C++. KUnit provides facilities for defining unit test cases, grouping related test cases into test suites, providing common infrastructure for running tests, and much more. +KUnit consists of a kernel component, which provides a set of macros for easily +writing unit tests. Tests written against KUnit will run on kernel boot if +built-in, or when loaded if built as a module. These tests write out results to +the kernel log in `TAP <https://testanything.org/>`_ format. + +To make running these tests (and reading the results) easier, KUnit offers +:doc:`kunit_tool <kunit-tool>`, which builds a `User Mode Linux +<http://user-mode-linux.sourceforge.net>`_ kernel, runs it, and parses the test +results. This provides a quick way of running KUnit tests during development, +without requiring a virtual machine or separate hardware. + Get started now: :doc:`start` Why KUnit? @@ -36,21 +45,20 @@ allow all possible code paths to be tested in the code under test; this is only possible if the code under test is very small and does not have any external dependencies outside of the test's control like hardware. -Outside of KUnit, there are no testing frameworks currently -available for the kernel that do not require installing the kernel on a test -machine or in a VM and all require tests to be written in userspace running on -the kernel; this is true for Autotest, and kselftest, disqualifying -any of them from being considered unit testing frameworks. +KUnit provides a common framework for unit tests within the kernel. + +KUnit tests can be run on most architectures, and most tests are architecture +independent. All built-in KUnit tests run on kernel startup. Alternatively, +KUnit and KUnit tests can be built as modules and tests will run when the test +module is loaded. -KUnit addresses the problem of being able to run tests without needing a virtual -machine or actual hardware with User Mode Linux. User Mode Linux is a Linux -architecture, like ARM or x86; however, unlike other architectures it compiles -to a standalone program that can be run like any other program directly inside -of a host operating system; to be clear, it does not require any virtualization -support; it is just a regular program. +.. note:: -Alternatively, kunit and kunit tests can be built as modules and tests will -run when the test module is loaded. + KUnit can also run tests without needing a virtual machine or actual + hardware under User Mode Linux. User Mode Linux is a Linux architecture, + like ARM or x86, which compiles the kernel as a Linux executable. KUnit + can be used with UML either by building with ``ARCH=um`` (like any other + architecture), or by using :doc:`kunit_tool <kunit-tool>`. KUnit is fast. Excluding build time, from invocation to completion KUnit can run several dozen tests in only 10 to 20 seconds; this might not sound like a big @@ -81,3 +89,5 @@ How do I use it? * :doc:`start` - for new users of KUnit * :doc:`usage` - for a more detailed explanation of KUnit features * :doc:`api/index` - for the list of KUnit APIs used for testing +* :doc:`kunit-tool` - for more information on the kunit_tool helper script +* :doc:`faq` - for answers to some common questions about KUnit diff --git a/Documentation/dev-tools/kunit/kunit-tool.rst b/Documentation/dev-tools/kunit/kunit-tool.rst index 50d46394e97e..949af2da81e5 100644 --- a/Documentation/dev-tools/kunit/kunit-tool.rst +++ b/Documentation/dev-tools/kunit/kunit-tool.rst @@ -12,6 +12,13 @@ the Linux kernel as UML (`User Mode Linux <http://user-mode-linux.sourceforge.net/>`_), running KUnit tests, parsing the test results and displaying them in a user friendly manner. +kunit_tool addresses the problem of being able to run tests without needing a +virtual machine or actual hardware with User Mode Linux. User Mode Linux is a +Linux architecture, like ARM or x86; however, unlike other architectures it +compiles the kernel as a standalone Linux executable that can be run like any +other program directly inside of a host operating system. To be clear, it does +not require any virtualization support: it is just a regular program. + What is a kunitconfig? ====================== diff --git a/Documentation/dev-tools/kunit/start.rst b/Documentation/dev-tools/kunit/start.rst index 4e1d24db6b13..e1c5ce80ce12 100644 --- a/Documentation/dev-tools/kunit/start.rst +++ b/Documentation/dev-tools/kunit/start.rst @@ -9,11 +9,10 @@ Installing dependencies KUnit has the same dependencies as the Linux kernel. As long as you can build the kernel, you can run KUnit. -KUnit Wrapper -============= -Included with KUnit is a simple Python wrapper that helps format the output to -easily use and read KUnit output. It handles building and running the kernel, as -well as formatting the output. +Running tests with the KUnit Wrapper +==================================== +Included with KUnit is a simple Python wrapper which runs tests under User Mode +Linux, and formats the test results. The wrapper can be run with: @@ -21,22 +20,42 @@ The wrapper can be run with: ./tools/testing/kunit/kunit.py run --defconfig -For more information on this wrapper (also called kunit_tool) checkout the +For more information on this wrapper (also called kunit_tool) check out the :doc:`kunit-tool` page. Creating a .kunitconfig -======================= -The Python script is a thin wrapper around Kbuild. As such, it needs to be -configured with a ``.kunitconfig`` file. This file essentially contains the -regular Kernel config, with the specific test targets as well. - +----------------------- +If you want to run a specific set of tests (rather than those listed in the +KUnit defconfig), you can provide Kconfig options in the ``.kunitconfig`` file. +This file essentially contains the regular Kernel config, with the specific +test targets as well. The ``.kunitconfig`` should also contain any other config +options required by the tests. + +A good starting point for a ``.kunitconfig`` is the KUnit defconfig: .. code-block:: bash cd $PATH_TO_LINUX_REPO cp arch/um/configs/kunit_defconfig .kunitconfig -Verifying KUnit Works ---------------------- +You can then add any other Kconfig options you wish, e.g.: +.. code-block:: none + + CONFIG_LIST_KUNIT_TEST=y + +:doc:`kunit_tool <kunit-tool>` will ensure that all config options set in +``.kunitconfig`` are set in the kernel ``.config`` before running the tests. +It'll warn you if you haven't included the dependencies of the options you're +using. + +.. note:: + Note that removing something from the ``.kunitconfig`` will not trigger a + rebuild of the ``.config`` file: the configuration is only updated if the + ``.kunitconfig`` is not a subset of ``.config``. This means that you can use + other tools (such as make menuconfig) to adjust other config options. + + +Running the tests +----------------- To make sure that everything is set up correctly, simply invoke the Python wrapper from your kernel repo: @@ -62,6 +81,41 @@ followed by a list of tests that are run. All of them should be passing. Because it is building a lot of sources for the first time, the ``Building KUnit kernel`` step may take a while. +Running tests without the KUnit Wrapper +======================================= + +If you'd rather not use the KUnit Wrapper (if, for example, you need to +integrate with other systems, or use an architecture other than UML), KUnit can +be included in any kernel, and the results read out and parsed manually. + +.. note:: + KUnit is not designed for use in a production system, and it's possible that + tests may reduce the stability or security of the system. + + + +Configuring the kernel +---------------------- + +In order to enable KUnit itself, you simply need to enable the ``CONFIG_KUNIT`` +Kconfig option (it's under Kernel Hacking/Kernel Testing and Coverage in +menuconfig). From there, you can enable any KUnit tests you want: they usually +have config options ending in ``_KUNIT_TEST``. + +KUnit and KUnit tests can be compiled as modules: in this case the tests in a +module will be run when the module is loaded. + +Running the tests +----------------- + +Build and run your kernel as usual. Test output will be written to the kernel +log in `TAP <https://testanything.org/>`_ format. + +.. note:: + It's possible that there will be other lines and/or data interspersed in the + TAP output. + + Writing your first test ======================= -- 2.25.1.481.gfbce0eb801-goog

5 years, 3 months

4
4
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror