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

WARNING: at refcount.c:190 refcount_sub_and_test_checked+0xac/0xc8 - refcount_t: underflow; use-after-free.

by Naresh Kamboju

While running selftest binderfs_test on linux mainline the following warning on arm64, arm, x86_64 and i386. [ 329.383391] refcount_t: underflow; use-after-free. [ 329.391025] WARNING: CPU: 0 PID: 2604 at /usr/src/kernel/lib/refcount.c:28 refcount_warn_saturate+0xd4/0x150 [ 329.403319] Modules linked in: cls_bpf sch_fq algif_hash af_alg rfkill tda998x drm_kms_helper drm crct10dif_ce fuse [ 329.413828] CPU: 0 PID: 2604 Comm: binderfs_test Not tainted 5.6.0-rc5 #1 [ 329.420640] Hardware name: ARM Juno development board (r2) (DT) [ 329.426584] pstate: 40000005 (nZcv daif -PAN -UAO) [ 329.431402] pc : refcount_warn_saturate+0xd4/0x150 [ 329.436216] lr : refcount_warn_saturate+0xd4/0x150 [ 329.441026] sp : ffff800013d03a70 [ 329.444356] x29: ffff800013d03a70 x28: ffff00092c3f8000 [ 329.449694] x27: 0000000000000000 x26: ffff80001236f000 [ 329.455033] x25: ffff800012656000 x24: 0000000000000001 [ 329.460371] x23: ffff800012656f76 x22: ffff80001265b2c0 [ 329.465709] x21: ffff000929035c00 x20: ffff00095cd8ce00 [ 329.471048] x19: ffff80001261c848 x18: ffffffffffffffff [ 329.476386] x17: 0000000000000000 x16: 0000000000000000 [ 329.481724] x15: ffff80001236fa88 x14: ffff800093d03767 [ 329.487062] x13: ffff800013d03775 x12: ffff80001239e000 [ 329.492400] x11: 0000000005f5e0ff x10: ffff800013d03700 [ 329.497738] x9 : ffff8000126ddc68 x8 : 0000000000000028 [ 329.503076] x7 : ffff800010190a5c x6 : ffff00097ef0b428 [ 329.508414] x5 : ffff00097ef0b428 x4 : ffff00092c3f8000 [ 329.513752] x3 : ffff800012370000 x2 : 0000000000000000 [ 329.519090] x1 : 295161095161e100 x0 : 0000000000000000 [ 329.524429] Call trace: [ 329.526894] refcount_warn_saturate+0xd4/0x150 [ 329.531362] binderfs_evict_inode+0xcc/0xe8 [ 329.535567] evict+0xa8/0x188 [ 329.538552] iput+0x278/0x318 [ 329.541537] dentry_unlink_inode+0x154/0x170 [ 329.545827] __dentry_kill+0xc4/0x1d8 [ 329.549509] shrink_dentry_list+0xf4/0x210 [ 329.553625] shrink_dcache_parent+0x124/0x210 [ 329.558002] do_one_tree+0x20/0x50 [ 329.561423] shrink_dcache_for_umount+0x30/0x98 [ 329.565975] generic_shutdown_super+0x2c/0xf8 [ 329.570354] kill_anon_super+0x24/0x48 [ 329.574122] kill_litter_super+0x2c/0x38 [ 329.578065] binderfs_kill_super+0x24/0x48 [ 329.582182] deactivate_locked_super+0x74/0xa0 [ 329.586647] deactivate_super+0x8c/0x98 [ 329.590502] cleanup_mnt+0xd8/0x130 [ 329.594008] __cleanup_mnt+0x20/0x30 [ 329.597605] task_work_run+0x90/0x150 [ 329.601287] do_notify_resume+0x130/0x498 [ 329.605317] work_pending+0x8/0x14 [ 329.608736] irq event stamp: 1612 [ 329.612072] hardirqs last enabled at (1611): [<ffff800010190bf4>] console_unlock+0x514/0x5d8 [ 329.620631] hardirqs last disabled at (1612): [<ffff8000100a904c>] debug_exception_enter+0xac/0xe8 [ 329.629622] softirqs last enabled at (1608): [<ffff8000100818bc>] __do_softirq+0x4c4/0x578 [ 329.638005] softirqs last disabled at (1561): [<ffff80001010b6ac>] irq_exit+0x144/0x150 [ 329.646035] ---[ end trace bac6584738d9306f ]--- Metadata: --------------- git branch: master git repo: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git git describe: v5.6-rc5 kernel-config: http://snapshots.linaro.org/openembedded/lkft/lkft/sumo/intel-corei7-64/lkf… Full test log, https://lkft.validation.linaro.org/scheduler/job/1273667#L6591 https://lkft.validation.linaro.org/scheduler/job/1273569#L6222 https://lkft.validation.linaro.org/scheduler/job/1273548#L6126 https://lkft.validation.linaro.org/scheduler/job/1273596#L4687 -- Linaro LKFT https://lkft.linaro.org

5 years, 3 months

6
26
0 0

[PATCH] dma-buf: heaps: bugfix for selftest failure

by Leon He

If the 'name' array in check_vgem() was not initialized to null, the value of name[4] may be random. Which will cause strcmp(name, "vgem") failed. Signed-off-by: Leon He <leon.he(a)unisoc.com> --- tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c index cd5e1f6..21f3d19 100644 --- a/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c +++ b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c @@ -22,7 +22,7 @@ static int check_vgem(int fd) { drm_version_t version = { 0 }; - char name[5]; + char name[5] = { 0 }; int ret; version.name_len = 4; -- 2.7.4

5 years, 3 months

3
2
0 0

[PATCH v3 0/6] 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); v1: https://lore.kernel.org/netdev/20200313031752.2332565-1-kuba@kernel.org/ v2: https://lore.kernel.org/netdev/20200314005501.2446494-1-kuba@kernel.org/ Jakub Kicinski (6): selftests/seccomp: use correct FIXTURE macro 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 | 233 ++++++++++++++---- tools/testing/selftests/net/tls.c | 93 ++----- tools/testing/selftests/seccomp/seccomp_bpf.c | 10 +- 4 files changed, 206 insertions(+), 133 deletions(-) -- 2.24.1

5 years, 3 months

2
16
0 0

[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

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror