December 2018 - Linux-kselftest-mirror

[PATCH 1/2] selftests: rtc: rtctest: fix alarm tests

by Alexandre Belloni

Return values for select are not checked properly and timeouts may not be detected. Signed-off-by: Alexandre Belloni <alexandre.belloni(a)bootlin.com> --- tools/testing/selftests/rtc/rtctest.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/tools/testing/selftests/rtc/rtctest.c b/tools/testing/selftests/rtc/rtctest.c index e20b017e7073..dea4e3d6d9e1 100644 --- a/tools/testing/selftests/rtc/rtctest.c +++ b/tools/testing/selftests/rtc/rtctest.c @@ -145,15 +145,12 @@ TEST_F(rtc, alarm_alm_set) { rc = select(self->fd + 1, &readfds, NULL, NULL, &tv); ASSERT_NE(-1, rc); - EXPECT_NE(0, rc); + ASSERT_NE(0, rc); /* Disable alarm interrupts */ rc = ioctl(self->fd, RTC_AIE_OFF, 0); ASSERT_NE(-1, rc); - if (rc == 0) - return; - rc = read(self->fd, &data, sizeof(unsigned long)); ASSERT_NE(-1, rc); TH_LOG("data: %lx", data); @@ -202,7 +199,7 @@ TEST_F(rtc, alarm_wkalm_set) { rc = select(self->fd + 1, &readfds, NULL, NULL, &tv); ASSERT_NE(-1, rc); - EXPECT_NE(0, rc); + ASSERT_NE(0, rc); rc = read(self->fd, &data, sizeof(unsigned long)); ASSERT_NE(-1, rc); -- 2.20.0

5 years, 11 months

2
2
0 0

[PATCH bpf-next] selftests/bpf: fix error printing in test_devmap()

by Xiaozhou Liu

As a simple fix, just print the correct map type. Signed-off-by: Xiaozhou Liu <liuxiaozhou(a)bytedance.com> --- tools/testing/selftests/bpf/test_maps.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/bpf/test_maps.c b/tools/testing/selftests/bpf/test_maps.c index 9c79ee017df3..e2b9eee37187 100644 --- a/tools/testing/selftests/bpf/test_maps.c +++ b/tools/testing/selftests/bpf/test_maps.c @@ -510,7 +510,7 @@ static void test_devmap(int task, void *data) fd = bpf_create_map(BPF_MAP_TYPE_DEVMAP, sizeof(key), sizeof(value), 2, 0); if (fd < 0) { - printf("Failed to create arraymap '%s'!\n", strerror(errno)); + printf("Failed to create devmap '%s'!\n", strerror(errno)); exit(1); } -- 2.11.0

5 years, 11 months

2
1
0 0

[GIT PULL] kselftest update for Linux 4.21-rc1

by shuah

Hi Linus, Please pull the following Kselftest update for Linux 4.21-rc1. This Kselftest update for Linux 4.21-rc1 consists of: - fixes, and improvements to the framework, and individual tests. - a new media test for IR encoders from Sean Young. - a new watchdog test option to find time left on a timer. diff is attached. thanks, -- Shuah ---------------------------------------------------------------- The following changes since commit 651022382c7f8da46cb4872a545ee1da6d097d2a: Linux 4.20-rc1 (2018-11-04 15:37:52 -0800) are available in the Git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest tags/linux-kselftest-4.21-rc1 for you to fetch changes up to 283ac6d5fb2a47f12bcef7806b78acf6ad89907e: selftests: Fix test errors related to lib.mk khdr target (2018-12-17 09:17:55 -0700) ---------------------------------------------------------------- linux-kselftest-4.21-rc1 This Kselftest update for Linux 4.21-rc1 consists of: - fixes, and improvements to the framework, and individual tests. - a new media test for IR encoders from Sean Young. - a new watchdog test option to find time left on a timer. ---------------------------------------------------------------- Colin Ian King (1): selftests: watchdog: fix spelling mistake "experies" -> "expires" Dan Rue (2): selftests: firmware: remove use of non-standard diff -Z option selftests: firmware: add CONFIG_FW_LOADER_USER_HELPER_FALLBACK to config Daniel Díaz (1): selftests: gpio: Find libmount with pkg-config if available Dmitry V. Levin (1): selftests: do not macro-expand failed assertion expressions Jerry Hoemann (1): selftests: watchdog: Add gettimeleft command line arg Sean Young (1): media: rc: self test for IR encoders and decoders Shuah Khan (1): selftests: Fix test errors related to lib.mk khdr target Thomas Gleixner (1): selftests/ftrace: Fix invalid SPDX identifiers Tom Murphy (1): fix dma-buf/udmabuf selftest tools/testing/selftests/Makefile | 2 + tools/testing/selftests/android/Makefile | 2 +- tools/testing/selftests/drivers/dma-buf/Makefile | 2 + tools/testing/selftests/drivers/dma-buf/udmabuf.c | 11 +- tools/testing/selftests/firmware/config | 1 + tools/testing/selftests/firmware/fw_filesystem.sh | 9 +- .../ftrace/test.d/ftrace/func-filter-stacktrace.tc | 2 +- .../selftests/ftrace/test.d/ftrace/func_cpumask.tc | 2 +- tools/testing/selftests/ftrace/test.d/template | 2 +- .../selftests/ftrace/test.d/tracer/wakeup.tc | 2 +- .../selftests/ftrace/test.d/tracer/wakeup_rt.tc | 2 +- tools/testing/selftests/futex/functional/Makefile | 1 + tools/testing/selftests/gpio/Makefile | 16 +- tools/testing/selftests/ir/.gitignore | 1 + tools/testing/selftests/ir/Makefile | 5 + tools/testing/selftests/ir/ir_loopback.c | 199 +++++++++++++++++++++ tools/testing/selftests/ir/ir_loopback.sh | 20 +++ tools/testing/selftests/kselftest_harness.h | 42 ++--- tools/testing/selftests/kvm/Makefile | 2 +- tools/testing/selftests/lib.mk | 8 +- .../selftests/networking/timestamping/Makefile | 1 + tools/testing/selftests/tc-testing/bpf/Makefile | 1 + tools/testing/selftests/vm/Makefile | 1 + tools/testing/selftests/watchdog/watchdog-test.c | 13 +- 24 files changed, 301 insertions(+), 46 deletions(-) create mode 100644 tools/testing/selftests/ir/.gitignore create mode 100644 tools/testing/selftests/ir/Makefile create mode 100644 tools/testing/selftests/ir/ir_loopback.c create mode 100755 tools/testing/selftests/ir/ir_loopback.sh ----------------------------------------------------------------

5 years, 12 months

2
1
0 0

[PATCH 1/2] test_sysctl: add tests for >32-bit values written to 32-bit integers

by Zev Weiss

At present this exposes a bug in do_proc_dointvec_minmax_conv() (it fails to check for values that are too wide to fit in an int). Signed-off-by: Zev Weiss <zev(a)bewilderbeest.net> --- tools/testing/selftests/sysctl/sysctl.sh | 37 ++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/tools/testing/selftests/sysctl/sysctl.sh b/tools/testing/selftests/sysctl/sysctl.sh index 584eb8ea780a..a7d0da25975c 100755 --- a/tools/testing/selftests/sysctl/sysctl.sh +++ b/tools/testing/selftests/sysctl/sysctl.sh @@ -290,6 +290,40 @@ run_numerictests() test_rc } +check_failure() +{ + echo -n "Testing that $1 fails as expected..." + reset_vals + TEST_STR="$1" + orig="$(cat $TARGET)" + echo -n "$TEST_STR" > $TARGET 2> /dev/null + + # write should fail and $TARGET should retain its original value + if [ $? = 0 ] || [ "$(cat $TARGET)" != "$orig" ]; then + echo "FAIL" >&2 + rc=1 + else + echo "ok" + fi + test_rc +} + +run_wideint_tests() +{ + # check negative and positive 64-bit values, with and without + # bits set in the lower 31, and with and without bit 31 (sign + # bit of a 32-bit int) set. None of these are representable + # in 32 bits, and hence all should fail. + check_failure 0x0000010000000000 + check_failure 0x0000010080000000 + check_failure 0x000001ff7fffffff + check_failure 0x000001ffffffffff + check_failure 0xffffffff7fffffff + check_failure 0xffffffffffffffff + check_failure 0xffffff0000000000 + check_failure 0xffffff0080000000 +} + # Your test must accept digits 3 and 4 to use this run_limit_digit() { @@ -556,6 +590,7 @@ sysctl_test_0001() TEST_STR=$(( $ORIG + 1 )) run_numerictests + run_wideint_tests run_limit_digit } @@ -580,6 +615,7 @@ sysctl_test_0003() TEST_STR=$(( $ORIG + 1 )) run_numerictests + run_wideint_tests run_limit_digit run_limit_digit_int } @@ -592,6 +628,7 @@ sysctl_test_0004() TEST_STR=$(( $ORIG + 1 )) run_numerictests + run_wideint_tests run_limit_digit run_limit_digit_uint } -- 2.20.1

5 years, 12 months

1
0
0 0

[PATCH] selftests/efivarfs: clean up test files from test_create*()

by Po-Hsu Lin

Test files created by test_create*() tests will stay in the $efivarfs_mount directory until next reboot. When the tester tries to run this efivarfs test again on the same system, the immutable characteristics in that directory with those previously generated files will cause some "Permission denied" noises and a false-positive test result to the test_create_read() test. Remove those test files in the end of each test to solve this issue. Link: https://bugs.launchpad.net/bugs/1809704 Signed-off-by: Po-Hsu Lin <po-hsu.lin(a)canonical.com> --- tools/testing/selftests/efivarfs/efivarfs.sh | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tools/testing/selftests/efivarfs/efivarfs.sh b/tools/testing/selftests/efivarfs/efivarfs.sh index a47029a..ea2e2a0 100755 --- a/tools/testing/selftests/efivarfs/efivarfs.sh +++ b/tools/testing/selftests/efivarfs/efivarfs.sh @@ -60,6 +60,12 @@ test_create() echo "$file has invalid size" >&2 exit 1 fi + + rm $file 2>/dev/null + if [ $? -ne 0 ]; then + chattr -i $file + rm $file + fi } test_create_empty() @@ -72,12 +78,24 @@ test_create_empty() echo "$file can not be created without writing" >&2 exit 1 fi + + rm $file 2>/dev/null + if [ $? -ne 0 ]; then + chattr -i $file + rm $file + fi } test_create_read() { local file=$efivarfs_mount/$FUNCNAME-$test_guid ./create-read $file + + rm $file 2>/dev/null + if [ $? -ne 0 ]; then + chattr -i $file + rm $file + fi } test_delete() -- 2.7.4

5 years, 12 months

1
0
0 0

ir test compile errors

by shuah

Hi Sean, I started to see compile errors on ir test. Could you please take a look and see if you can fix them. ir_loopback.c:32:16: error: field ‘proto’ has incomplete type enum rc_proto proto; ^~~~~ ir_loopback.c:37:4: error: ‘RC_PROTO_RC5’ undeclared here (not in a function) { RC_PROTO_RC5, "rc-5", 0x1f7f, "rc-5" }, ^~~~~~~~~~~~ ir_loopback.c:38:4: error: ‘RC_PROTO_RC5X_20’ undeclared here (not in a function); did you mean ‘RC_PROTO_RC5’? { RC_PROTO_RC5X_20, "rc-5x-20", 0x1f7f3f, "rc-5" }, ^~~~~~~~~~~~~~~~ RC_PROTO_RC5 ir_loopback.c:39:4: error: ‘RC_PROTO_RC5_SZ’ undeclared here (not in a function); did you mean ‘RC_PROTO_RC5X_20’? { RC_PROTO_RC5_SZ, "rc-5-sz", 0x2fff, "rc-5-sz" }, ^~~~~~~~~~~~~~~ RC_PROTO_RC5X_20 ir_loopback.c:40:4: error: ‘RC_PROTO_JVC’ undeclared here (not in a function); did you mean ‘RC_PROTO_RC5’? { RC_PROTO_JVC, "jvc", 0xffff, "jvc" }, ^~~~~~~~~~~~ RC_PROTO_RC5 ir_loopback.c:41:4: error: ‘RC_PROTO_SONY12’ undeclared here (not in a function); did you mean ‘RC_PROTO_JVC’? { RC_PROTO_SONY12, "sony-12", 0x1f007f, "sony" }, ^~~~~~~~~~~~~~~ RC_PROTO_JVC ir_loopback.c:42:4: error: ‘RC_PROTO_SONY15’ undeclared here (not in a function); did you mean ‘RC_PROTO_SONY12’? { RC_PROTO_SONY15, "sony-15", 0xff007f, "sony" }, ^~~~~~~~~~~~~~~ RC_PROTO_SONY12 ir_loopback.c:43:4: error: ‘RC_PROTO_SONY20’ undeclared here (not in a function); did you mean ‘RC_PROTO_SONY15’? { RC_PROTO_SONY20, "sony-20", 0x1fff7f, "sony" }, ^~~~~~~~~~~~~~~ RC_PROTO_SONY15 ir_loopback.c:44:4: error: ‘RC_PROTO_NEC’ undeclared here (not in a function); did you mean ‘RC_PROTO_JVC’? { RC_PROTO_NEC, "nec", 0xffff, "nec" }, ^~~~~~~~~~~~ RC_PROTO_JVC ir_loopback.c:45:4: error: ‘RC_PROTO_NECX’ undeclared here (not in a function); did you mean ‘RC_PROTO_NEC’? { RC_PROTO_NECX, "nec-x", 0xffffff, "nec" }, ^~~~~~~~~~~~~ RC_PROTO_NEC ir_loopback.c:46:4: error: ‘RC_PROTO_NEC32’ undeclared here (not in a function); did you mean ‘RC_PROTO_NECX’? { RC_PROTO_NEC32, "nec-32", 0xffffffff, "nec" }, ^~~~~~~~~~~~~~ RC_PROTO_NECX ir_loopback.c:47:4: error: ‘RC_PROTO_SANYO’ undeclared here (not in a function); did you mean ‘RC_PROTO_SONY20’? { RC_PROTO_SANYO, "sanyo", 0x1fffff, "sanyo" }, ^~~~~~~~~~~~~~ RC_PROTO_SONY20 ir_loopback.c:48:4: error: ‘RC_PROTO_RC6_0’ undeclared here (not in a function); did you mean ‘RC_PROTO_RC5_SZ’? { RC_PROTO_RC6_0, "rc-6-0", 0xffff, "rc-6" }, ^~~~~~~~~~~~~~ RC_PROTO_RC5_SZ ir_loopback.c:49:4: error: ‘RC_PROTO_RC6_6A_20’ undeclared here (not in a function); did you mean ‘RC_PROTO_RC6_0’? { RC_PROTO_RC6_6A_20, "rc-6-6a-20", 0xfffff, "rc-6" }, ^~~~~~~~~~~~~~~~~~ RC_PROTO_RC6_0 ir_loopback.c:50:4: error: ‘RC_PROTO_RC6_6A_24’ undeclared here (not in a function); did you mean ‘RC_PROTO_RC6_6A_20’? { RC_PROTO_RC6_6A_24, "rc-6-6a-24", 0xffffff, "rc-6" }, ^~~~~~~~~~~~~~~~~~ RC_PROTO_RC6_6A_20 ir_loopback.c:51:4: error: ‘RC_PROTO_RC6_6A_32’ undeclared here (not in a function); did you mean ‘RC_PROTO_RC6_6A_24’? { RC_PROTO_RC6_6A_32, "rc-6-6a-32", 0xffffffff, "rc-6" }, ^~~~~~~~~~~~~~~~~~ RC_PROTO_RC6_6A_24 ir_loopback.c:52:4: error: ‘RC_PROTO_RC6_MCE’ undeclared here (not in a function); did you mean ‘RC_PROTO_RC6_0’? { RC_PROTO_RC6_MCE, "rc-6-mce", 0x00007fff, "rc-6" }, ^~~~~~~~~~~~~~~~ RC_PROTO_RC6_0 ir_loopback.c:53:4: error: ‘RC_PROTO_SHARP’ undeclared here (not in a function); did you mean ‘RC_PROTO_SANYO’? { RC_PROTO_SHARP, "sharp", 0x1fff, "sharp" }, ^~~~~~~~~~~~~~ RC_PROTO_SANYO ir_loopback.c: In function ‘main’: ir_loopback.c:101:9: error: ‘LIRC_MODE_SCANCODE’ undeclared (first use in this function); did you mean ‘LIRC_MODE_LIRCCODE’? mode = LIRC_MODE_SCANCODE; ^~~~~~~~~~~~~~~~~~ LIRC_MODE_LIRCCODE ir_loopback.c:101:9: note: each undeclared identifier is reported only once for each function it appears in thanks, -- Shuah

6 years

2
1
0 0

[PATCH v6 6/7] kselftests: cgroup: add freezer controller self-tests

by Roman Gushchin

This patch implements 8 tests for the freezer controller for cgroup v2: 1) a simple test, which aims to freeze and unfreeze a cgroup with 100 processes 2) a more complicated tree test, which creates a hierarchy of cgroups, puts some processes in some cgroups, and tries to freeze and unfreeze different parts of the subtree 3) a forkbomb test: the test aims to freeze a forkbomb running in a cgroup, kill all tasks in the cgroup and remove the cgroup without the unfreezing. 4) rmdir test: the test creates two nested cgroups, freezes the parent one, checks that the child can be successfully removed, and a new child can be created 5) migration tests: the test checks migration of a task between frozen cgroups: from a frozen to a running, from a running to a frozen, and from a frozen to a frozen. 6) ptrace test: the test checks that it's possible to attach to a process in a frozen cgroup, get some information and detach, and the cgroup will remain frozen. 7) stopped test: the test checks that it's possible to freeze a cgroup with a stopped task 8) ptraced test: the test checks that it's possible to freeze a cgroup with a ptraced task Expected output: $ ./test_freezer ok 1 test_cgfreezer_simple ok 2 test_cgfreezer_tree ok 3 test_cgfreezer_forkbomb ok 4 test_cgrreezer_rmdir ok 5 test_cgfreezer_migrate ok 6 test_cgfreezer_ptrace ok 7 test_cgfreezer_stopped ok 8 test_cgfreezer_ptraced Signed-off-by: Roman Gushchin <guro(a)fb.com> Cc: Shuah Khan <shuah(a)kernel.org> Cc: Tejun Heo <tj(a)kernel.org> Cc: kernel-team(a)fb.com Cc: linux-kselftest(a)vger.kernel.org --- tools/testing/selftests/cgroup/.gitignore | 1 + tools/testing/selftests/cgroup/Makefile | 2 + tools/testing/selftests/cgroup/cgroup_util.c | 81 +- tools/testing/selftests/cgroup/cgroup_util.h | 7 + tools/testing/selftests/cgroup/test_freezer.c | 821 ++++++++++++++++++ 5 files changed, 911 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/cgroup/test_freezer.c diff --git a/tools/testing/selftests/cgroup/.gitignore b/tools/testing/selftests/cgroup/.gitignore index adacda50a4b2..7f9835624793 100644 --- a/tools/testing/selftests/cgroup/.gitignore +++ b/tools/testing/selftests/cgroup/.gitignore @@ -1,2 +1,3 @@ test_memcontrol test_core +test_freezer diff --git a/tools/testing/selftests/cgroup/Makefile b/tools/testing/selftests/cgroup/Makefile index 23fbaa4a9630..8d369b6a2069 100644 --- a/tools/testing/selftests/cgroup/Makefile +++ b/tools/testing/selftests/cgroup/Makefile @@ -5,8 +5,10 @@ all: TEST_GEN_PROGS = test_memcontrol TEST_GEN_PROGS += test_core +TEST_GEN_PROGS += test_freezer include ../lib.mk $(OUTPUT)/test_memcontrol: cgroup_util.c $(OUTPUT)/test_core: cgroup_util.c +$(OUTPUT)/test_freezer: cgroup_util.c diff --git a/tools/testing/selftests/cgroup/cgroup_util.c b/tools/testing/selftests/cgroup/cgroup_util.c index eba06f94433b..e9cdad673901 100644 --- a/tools/testing/selftests/cgroup/cgroup_util.c +++ b/tools/testing/selftests/cgroup/cgroup_util.c @@ -74,6 +74,16 @@ char *cg_name_indexed(const char *root, const char *name, int index) return ret; } +char *cg_control(const char *cgroup, const char *control) +{ + size_t len = strlen(cgroup) + strlen(control) + 2; + char *ret = malloc(len); + + snprintf(ret, len, "%s/%s", cgroup, control); + + return ret; +} + int cg_read(const char *cgroup, const char *control, char *buf, size_t len) { char path[PATH_MAX]; @@ -196,7 +206,59 @@ int cg_create(const char *cgroup) return mkdir(cgroup, 0644); } -static int cg_killall(const char *cgroup) +int cg_for_all_procs(const char *cgroup, int (*fn)(int pid, void *arg), + void *arg) +{ + char buf[PAGE_SIZE]; + char *ptr = buf; + int ret; + + if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf))) + return -1; + + while (ptr < buf + sizeof(buf)) { + int pid = strtol(ptr, &ptr, 10); + + if (pid == 0) + break; + if (*ptr) + ptr++; + else + break; + ret = fn(pid, arg); + if (ret) + return ret; + } + + return 0; +} + +int cg_wait_for_proc_count(const char *cgroup, int count) +{ + char buf[10 * PAGE_SIZE] = {0}; + int attempts; + char *ptr; + + for (attempts = 10; attempts >= 0; attempts--) { + int nr = 0; + + if (cg_read(cgroup, "cgroup.procs", buf, sizeof(buf))) + break; + + for (ptr = buf; *ptr; ptr++) + if (*ptr == '\n') + nr++; + + if (nr >= count) + return 0; + + usleep(100000); + } + + return -1; +} + +int cg_killall(const char *cgroup) { char buf[PAGE_SIZE]; char *ptr = buf; @@ -238,6 +300,14 @@ int cg_destroy(const char *cgroup) return ret; } +int cg_enter(const char *cgroup, int pid) +{ + char pidbuf[64]; + + snprintf(pidbuf, sizeof(pidbuf), "%d", pid); + return cg_write(cgroup, "cgroup.procs", pidbuf); +} + int cg_enter_current(const char *cgroup) { char pidbuf[64]; @@ -367,3 +437,12 @@ int set_oom_adj_score(int pid, int score) close(fd); return 0; } + +char proc_read_text(int pid, const char *item, char *buf, size_t size) +{ + char path[PATH_MAX]; + + snprintf(path, sizeof(path), "/proc/%d/%s", pid, item); + + return read_text(path, buf, size); +} diff --git a/tools/testing/selftests/cgroup/cgroup_util.h b/tools/testing/selftests/cgroup/cgroup_util.h index 9ac8b7958f83..8ee63c00a668 100644 --- a/tools/testing/selftests/cgroup/cgroup_util.h +++ b/tools/testing/selftests/cgroup/cgroup_util.h @@ -18,6 +18,7 @@ static inline int values_close(long a, long b, int err) extern int cg_find_unified_root(char *root, size_t len); extern char *cg_name(const char *root, const char *name); extern char *cg_name_indexed(const char *root, const char *name, int index); +extern char *cg_control(const char *cgroup, const char *control); extern int cg_create(const char *cgroup); extern int cg_destroy(const char *cgroup); extern int cg_read(const char *cgroup, const char *control, @@ -32,6 +33,7 @@ extern int cg_write(const char *cgroup, const char *control, char *buf); extern int cg_run(const char *cgroup, int (*fn)(const char *cgroup, void *arg), void *arg); +extern int cg_enter(const char *cgroup, int pid); extern int cg_enter_current(const char *cgroup); extern int cg_run_nowait(const char *cgroup, int (*fn)(const char *cgroup, void *arg), @@ -41,3 +43,8 @@ extern int alloc_pagecache(int fd, size_t size); extern int alloc_anon(const char *cgroup, void *arg); extern int is_swap_enabled(void); extern int set_oom_adj_score(int pid, int score); +extern int cg_for_all_procs(const char *cgroup, int (*fn)(int pid, void *arg), + void *arg); +extern int cg_wait_for_proc_count(const char *cgroup, int count); +extern int cg_killall(const char *cgroup); +extern char proc_read_text(int pid, const char *item, char *buf, size_t size); diff --git a/tools/testing/selftests/cgroup/test_freezer.c b/tools/testing/selftests/cgroup/test_freezer.c new file mode 100644 index 000000000000..4fcec4f04af4 --- /dev/null +++ b/tools/testing/selftests/cgroup/test_freezer.c @@ -0,0 +1,821 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#include <stdbool.h> +#include <linux/limits.h> +#include <sys/ptrace.h> +#include <sys/types.h> +#include <sys/mman.h> +#include <unistd.h> +#include <stdio.h> +#include <errno.h> +#include <poll.h> +#include <stdlib.h> +#include <sys/inotify.h> +#include <string.h> +#include <sys/types.h> +#include <sys/wait.h> + +#include "../kselftest.h" +#include "cgroup_util.h" + +#define DEBUG +#ifdef DEBUG +#define debug(args...) fprintf(stderr, args) +#else +#define debug(args...) +#endif + +/* + * Freeze the given cgroup and wait for the inotify signal. + * If there is no signal in 10 seconds, treat this as an error. + */ +static int cg_freeze_wait(const char *cgroup, bool freeze) +{ + int fd, wd; + struct pollfd fds; + int ret = -1; + + fd = inotify_init1(IN_NONBLOCK); + if (fd == -1) + return fd; + + wd = inotify_add_watch(fd, cg_control(cgroup, "cgroup.events"), + IN_MODIFY); + if (wd == -1) { + close(fd); + return wd; + } + fds.fd = fd; + fds.events = POLLIN; + + ret = cg_write(cgroup, "cgroup.freeze", freeze ? "1" : "0"); + if (ret) { + close(fd); + return ret; + } + + while (true) { + wd = poll(&fds, 1, 10000); + + if (wd == -1 && errno == EINTR) + continue; + + if (wd == 1 && fds.revents & POLLIN) + ret = 0; + + break; + } + + close(fd); + + return ret; +} + +/* + * Check if the process is frozen and parked in a proper place. + */ +static int proc_check_frozen(int pid, void *arg) +{ + char buf[PAGE_SIZE]; + int len; + + len = proc_read_text(pid, "stat", buf, sizeof(buf)); + if (len == -1) { + debug("Can't get %d stat\n", pid); + return -1; + } + + if (strstr(buf, "(test_freezer) S ") == NULL) { + debug("Process %d in the unexpected state: %s\n", pid, buf); + return -1; + } + + len = proc_read_text(pid, "stack", buf, sizeof(buf)); + if (len == -1) { + debug("Can't get stack of the process %d\n", pid); + return -1; + } + + if (strstr(buf, "[<0>] get_signal") != buf) { + debug("Process %d has unexpected stacktrace: %s\n", pid, buf); + return -1; + } + + return 0; +} + +/* + * Check if the cgroup is frozen and all belonging processes are + * parked in a proper place. + */ +static int cg_check_frozen(const char *cgroup, bool frozen) +{ + if (frozen) { + /* + * Check the cgroup.events::frozen value. + */ + if (cg_read_strstr(cgroup, "cgroup.events", "frozen 1") != 0) { + debug("Cgroup %s isn't unexpectedly frozen\n", cgroup); + return -1; + } + + /* + * Check that all processes are parked in the proper place. + */ + if (cg_for_all_procs(cgroup, proc_check_frozen, NULL)) { + debug("Some processes of cgroup %s are not frozen\n", + cgroup); + return -1; + } + } else { + /* + * Check the cgroup.events::frozen value. + */ + if (cg_read_strstr(cgroup, "cgroup.events", "frozen 0") != 0) { + debug("Cgroup %s is unexpectedly frozen\n", cgroup); + return -1; + } + } + + return 0; +} + +/* + * A simple process running in a sleep loop until being + * re-parented. + */ +static int child_fn(const char *cgroup, void *arg) +{ + int ppid = getppid(); + + while (getppid() == ppid) + usleep(1000); + + return getppid() == ppid; +} + +/* + * A simple test for the cgroup freezer: populated the cgroup with 100 + * running processes and freeze it. Then unfreeze it. Then it kills all + * processes and destroys the cgroup. + */ +static int test_cgfreezer_simple(const char *root) +{ + int ret = KSFT_FAIL; + char *cgroup = NULL; + int i; + + cgroup = cg_name(root, "cg_test"); + if (!cgroup) + goto cleanup; + + if (cg_create(cgroup)) + goto cleanup; + + for (i = 0; i < 100; i++) + cg_run_nowait(cgroup, child_fn, NULL); + + if (cg_wait_for_proc_count(cgroup, 100)) + goto cleanup; + + if (cg_check_frozen(cgroup, false)) + goto cleanup; + + if (cg_freeze_wait(cgroup, true)) + goto cleanup; + + if (cg_check_frozen(cgroup, true)) + goto cleanup; + + if (cg_freeze_wait(cgroup, false)) + goto cleanup; + + if (cg_check_frozen(cgroup, false)) + goto cleanup; + + ret = KSFT_PASS; + +cleanup: + if (cgroup) + cg_destroy(cgroup); + free(cgroup); + return ret; +} + +/* + * The test creates the following hierarchy: + * A + * / / \ \ + * B E I K + * /\ | + * C D F + * | + * G + * | + * H + * + * with a process in C, H and 3 processes in K. + * Then it tries to freeze and unfreeze the whole tree. + */ +static int test_cgfreezer_tree(const char *root) +{ + char *cgroup[10] = {0}; + int ret = KSFT_FAIL; + int i; + + cgroup[0] = cg_name(root, "cg_test_A"); + if (!cgroup[0]) + goto cleanup; + + cgroup[1] = cg_name(cgroup[0], "cg_test_B"); + if (!cgroup[1]) + goto cleanup; + + cgroup[2] = cg_name(cgroup[1], "cg_test_C"); + if (!cgroup[2]) + goto cleanup; + + cgroup[3] = cg_name(cgroup[1], "cg_test_D"); + if (!cgroup[3]) + goto cleanup; + + cgroup[4] = cg_name(cgroup[0], "cg_test_E"); + if (!cgroup[4]) + goto cleanup; + + cgroup[5] = cg_name(cgroup[4], "cg_test_F"); + if (!cgroup[5]) + goto cleanup; + + cgroup[6] = cg_name(cgroup[5], "cg_test_G"); + if (!cgroup[6]) + goto cleanup; + + cgroup[7] = cg_name(cgroup[6], "cg_test_H"); + if (!cgroup[7]) + goto cleanup; + + cgroup[8] = cg_name(cgroup[0], "cg_test_I"); + if (!cgroup[8]) + goto cleanup; + + cgroup[9] = cg_name(cgroup[0], "cg_test_K"); + if (!cgroup[9]) + goto cleanup; + + for (i = 0; i < 10; i++) + if (cg_create(cgroup[i])) + goto cleanup; + + cg_run_nowait(cgroup[2], child_fn, NULL); + cg_run_nowait(cgroup[7], child_fn, NULL); + cg_run_nowait(cgroup[9], child_fn, NULL); + cg_run_nowait(cgroup[9], child_fn, NULL); + cg_run_nowait(cgroup[9], child_fn, NULL); + + /* + * Wait until all child processes will enter + * corresponding cgroups. + */ + + if (cg_wait_for_proc_count(cgroup[2], 1) || + cg_wait_for_proc_count(cgroup[7], 1) || + cg_wait_for_proc_count(cgroup[9], 3)) + goto cleanup; + + /* + * Freeze B. + */ + if (cg_freeze_wait(cgroup[1], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[1], true)) + goto cleanup; + + /* + * Freeze F. + */ + if (cg_freeze_wait(cgroup[5], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[5], true)) + goto cleanup; + + /* + * Freeze G. + */ + if (cg_freeze_wait(cgroup[6], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[6], true)) + goto cleanup; + + /* + * Check that A and E are not frozen. + */ + if (cg_check_frozen(cgroup[0], false)) + goto cleanup; + + if (cg_check_frozen(cgroup[4], false)) + goto cleanup; + + /* + * Freeze A. Check that A, B and E are frozen. + */ + if (cg_freeze_wait(cgroup[0], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[0], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[1], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[4], true)) + goto cleanup; + + /* + * Unfreeze B, F and G + */ + if (cg_freeze_wait(cgroup[1], false)) + goto cleanup; + + if (cg_freeze_wait(cgroup[5], false)) + goto cleanup; + + if (cg_freeze_wait(cgroup[6], false)) + goto cleanup; + + /* + * Check that C and H are still frozen. + */ + if (cg_check_frozen(cgroup[2], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[7], true)) + goto cleanup; + + /* + * Unfreezing A failed. Check that A, C and K are not frozen. + */ + if (cg_freeze_wait(cgroup[0], false)) + goto cleanup; + + if (cg_check_frozen(cgroup[0], false)) + goto cleanup; + + if (cg_check_frozen(cgroup[2], false)) + goto cleanup; + + if (cg_check_frozen(cgroup[9], false)) + goto cleanup; + + ret = KSFT_PASS; + +cleanup: + for (i = 9; i >= 0 && cgroup[i]; i--) { + cg_destroy(cgroup[i]); + free(cgroup[i]); + } + + return ret; +} + +/* + * A fork bomb emulator. + */ +static int forkbomb_fn(const char *cgroup, void *arg) +{ + int ppid; + + fork(); + fork(); + + ppid = getppid(); + + while (getppid() == ppid) + usleep(1000); + + return getppid() == ppid; +} + +/* + * The test runs a fork bomb in a cgroup and tries to freeze it. + * Then it kills all processes and checks that cgroup isn't populated + * anymore. + */ +static int test_cgfreezer_forkbomb(const char *root) +{ + int ret = KSFT_FAIL; + char *cgroup = NULL; + + cgroup = cg_name(root, "cg_forkbomb_test"); + if (!cgroup) + goto cleanup; + + if (cg_create(cgroup)) + goto cleanup; + + cg_run_nowait(cgroup, forkbomb_fn, NULL); + + usleep(100000); + + if (cg_freeze_wait(cgroup, true)) + goto cleanup; + + if (cg_check_frozen(cgroup, true)) + goto cleanup; + + if (cg_killall(cgroup)) + goto cleanup; + + if (cg_wait_for_proc_count(cgroup, 0)) + goto cleanup; + + ret = KSFT_PASS; + +cleanup: + if (cgroup) + cg_destroy(cgroup); + free(cgroup); + return ret; +} + +/* + * The test creates two nested cgroups, freezes the parent + * and removes the child. Then it checks that the parent cgroup + * remains frozen and it's possible to create a new child + * without unfreezing. The new child is frozen too. + */ +static int test_cgfreezer_rmdir(const char *root) +{ + int ret = KSFT_FAIL; + char *parent, *child = NULL; + + parent = cg_name(root, "cg_test_A"); + if (!parent) + goto cleanup; + + child = cg_name(parent, "cg_test_B"); + if (!child) + goto cleanup; + + if (cg_create(parent)) + goto cleanup; + + if (cg_create(child)) + goto cleanup; + + if (cg_freeze_wait(parent, true)) + goto cleanup; + + if (cg_check_frozen(parent, true)) + goto cleanup; + + if (cg_destroy(child)) + goto cleanup; + + if (cg_check_frozen(parent, true)) + goto cleanup; + + if (cg_create(child)) + goto cleanup; + + if (cg_check_frozen(child, true)) + goto cleanup; + + ret = KSFT_PASS; + +cleanup: + if (child) + cg_destroy(child); + free(child); + if (parent) + cg_destroy(parent); + free(parent); + return ret; +} + +/* + * The test creates two cgroups: A and B. The it runs a process in A, + * and performs several migrations: + * 1) A (running) -> B (frozen) + * 2) B (frozen) -> A (running) + * 3) A (frozen) -> B (frozen) + * + * One each step it checks that the actual state of cgroups matches + * the expected state. + */ +static int test_cgfreezer_migrate(const char *root) +{ + int ret = KSFT_FAIL; + char *cgroup[2] = {0}; + int pid; + + cgroup[0] = cg_name(root, "cg_test_A"); + if (!cgroup[0]) + goto cleanup; + + cgroup[1] = cg_name(root, "cg_test_B"); + if (!cgroup[1]) + goto cleanup; + + if (cg_create(cgroup[0])) + goto cleanup; + + if (cg_create(cgroup[1])) + goto cleanup; + + pid = cg_run_nowait(cgroup[0], child_fn, NULL); + if (pid < 0) + goto cleanup; + + if (cg_wait_for_proc_count(cgroup[0], 1)) + goto cleanup; + + /* + * Migrate from A (running) to B (frozen) + */ + if (cg_freeze_wait(cgroup[1], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[1], true)) + goto cleanup; + + if (cg_enter(cgroup[1], pid)) + goto cleanup; + + if (cg_check_frozen(cgroup[0], false)) + goto cleanup; + + if (cg_check_frozen(cgroup[1], true)) + goto cleanup; + + /* + * Migrate from B (frozen) to A (running) + */ + if (cg_enter(cgroup[0], pid)) + goto cleanup; + + if (cg_check_frozen(cgroup[0], false)) + goto cleanup; + + if (cg_check_frozen(cgroup[1], true)) + goto cleanup; + + /* + * Migrate from A (frozen) to B (frozen) + */ + if (cg_freeze_wait(cgroup[0], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[0], true)) + goto cleanup; + + if (cg_enter(cgroup[1], pid)) + goto cleanup; + + if (cg_check_frozen(cgroup[0], true)) + goto cleanup; + + if (cg_check_frozen(cgroup[1], true)) + goto cleanup; + + ret = KSFT_PASS; + +cleanup: + if (cgroup[0]) + cg_destroy(cgroup[0]); + free(cgroup[0]); + if (cgroup[1]) + cg_destroy(cgroup[1]); + free(cgroup[1]); + return ret; +} + +/* + * The test checks that ptrace works with a tracing process in a frozen cgroup. + */ +static int test_cgfreezer_ptrace(const char *root) +{ + int ret = KSFT_FAIL; + char *cgroup = NULL; + siginfo_t siginfo; + int pid; + + cgroup = cg_name(root, "cg_test"); + if (!cgroup) + goto cleanup; + + if (cg_create(cgroup)) + goto cleanup; + + pid = cg_run_nowait(cgroup, child_fn, NULL); + if (pid < 0) + goto cleanup; + + if (cg_wait_for_proc_count(cgroup, 1)) + goto cleanup; + + if (cg_freeze_wait(cgroup, true)) + goto cleanup; + + if (cg_check_frozen(cgroup, true)) + goto cleanup; + + if (ptrace(PTRACE_SEIZE, pid, NULL, NULL)) + goto cleanup; + + if (ptrace(PTRACE_INTERRUPT, pid, NULL, NULL)) + goto cleanup; + + waitpid(pid, NULL, 0); + + if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo)) + goto cleanup; + + if (ptrace(PTRACE_DETACH, pid, NULL, NULL)) + goto cleanup; + + ret = KSFT_PASS; + +cleanup: + if (cgroup) + cg_destroy(cgroup); + free(cgroup); + return ret; +} + +/* + * Check if the process is stopped. + */ +static int proc_check_stopped(int pid) +{ + char buf[PAGE_SIZE]; + int len; + + len = proc_read_text(pid, "stat", buf, sizeof(buf)); + if (len == -1) { + debug("Can't get %d stat\n", pid); + return -1; + } + + if (strstr(buf, "(test_freezer) T ") == NULL) { + debug("Process %d in the unexpected state: %s\n", pid, buf); + return -1; + } + + return 0; +} + +/* + * Test that it's possible to freeze a cgroup with a stopped process. + */ +static int test_cgfreezer_stopped(const char *root) +{ + int pid, ret = KSFT_FAIL; + char *cgroup = NULL; + + cgroup = cg_name(root, "cg_test"); + if (!cgroup) + goto cleanup; + + if (cg_create(cgroup)) + goto cleanup; + + pid = cg_run_nowait(cgroup, child_fn, NULL); + + if (cg_wait_for_proc_count(cgroup, 1)) + goto cleanup; + + if (kill(pid, SIGSTOP)) + goto cleanup; + + if (cg_check_frozen(cgroup, false)) + goto cleanup; + + if (cg_freeze_wait(cgroup, true)) + goto cleanup; + + /* + * cg_check_frozen(cgroup, true) will fail here, + * because the task in in the STOPped state. + */ + + if (cg_freeze_wait(cgroup, false)) + goto cleanup; + + if (cg_check_frozen(cgroup, false)) + goto cleanup; + + if (proc_check_stopped(pid)) + goto cleanup; + + ret = KSFT_PASS; + +cleanup: + if (cgroup) + cg_destroy(cgroup); + free(cgroup); + return ret; +} + +/* + * Test that it's possible to freeze a cgroup with a ptraced process. + */ +static int test_cgfreezer_ptraced(const char *root) +{ + int pid, ret = KSFT_FAIL; + char *cgroup = NULL; + siginfo_t siginfo; + + cgroup = cg_name(root, "cg_test"); + if (!cgroup) + goto cleanup; + + if (cg_create(cgroup)) + goto cleanup; + + pid = cg_run_nowait(cgroup, child_fn, NULL); + + if (cg_wait_for_proc_count(cgroup, 1)) + goto cleanup; + + if (ptrace(PTRACE_SEIZE, pid, NULL, NULL)) + goto cleanup; + + if (ptrace(PTRACE_INTERRUPT, pid, NULL, NULL)) + goto cleanup; + + waitpid(pid, NULL, 0); + + if (cg_check_frozen(cgroup, false)) + goto cleanup; + + if (cg_freeze_wait(cgroup, true)) + goto cleanup; + + /* + * cg_check_frozen(cgroup, true) will fail here, + * because the task in in the TRACEd state. + */ + if (cg_freeze_wait(cgroup, false)) + goto cleanup; + + if (cg_check_frozen(cgroup, false)) + goto cleanup; + + if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo)) + goto cleanup; + + if (ptrace(PTRACE_DETACH, pid, NULL, NULL)) + goto cleanup; + + ret = KSFT_PASS; + +cleanup: + if (cgroup) + cg_destroy(cgroup); + free(cgroup); + return ret; +} + +#define T(x) { x, #x } +struct cgfreezer_test { + int (*fn)(const char *root); + const char *name; +} tests[] = { + T(test_cgfreezer_simple), + T(test_cgfreezer_tree), + T(test_cgfreezer_forkbomb), + T(test_cgfreezer_rmdir), + T(test_cgfreezer_migrate), + T(test_cgfreezer_ptrace), + T(test_cgfreezer_stopped), + T(test_cgfreezer_ptraced), +}; +#undef T + +int main(int argc, char *argv[]) +{ + char root[PATH_MAX]; + int i, ret = EXIT_SUCCESS; + + if (cg_find_unified_root(root, sizeof(root))) + ksft_exit_skip("cgroup v2 isn't mounted\n"); + for (i = 0; i < ARRAY_SIZE(tests); i++) { + switch (tests[i].fn(root)) { + case KSFT_PASS: + ksft_test_result_pass("%s\n", tests[i].name); + break; + case KSFT_SKIP: + ksft_test_result_skip("%s\n", tests[i].name); + break; + default: + ret = EXIT_FAILURE; + ksft_test_result_fail("%s\n", tests[i].name); + break; + } + } + + return ret; +} -- 2.19.2

6 years

1
0
0 0

[PATCH v6 5/7] kselftests: cgroup: don't fail on cg_kill_all() error in cg_destroy()

by Roman Gushchin

If the cgroup destruction races with an exit() of a belonging process(es), cg_kill_all() may fail. It's not a good reason to make cg_destroy() fail and leave the cgroup in place, potentially causing next test runs to fail. Signed-off-by: Roman Gushchin <guro(a)fb.com> Cc: Shuah Khan <shuah(a)kernel.org> Cc: Tejun Heo <tj(a)kernel.org> Cc: kernel-team(a)fb.com Cc: linux-kselftest(a)vger.kernel.org --- tools/testing/selftests/cgroup/cgroup_util.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tools/testing/selftests/cgroup/cgroup_util.c b/tools/testing/selftests/cgroup/cgroup_util.c index 14c9fe284806..eba06f94433b 100644 --- a/tools/testing/selftests/cgroup/cgroup_util.c +++ b/tools/testing/selftests/cgroup/cgroup_util.c @@ -227,9 +227,7 @@ int cg_destroy(const char *cgroup) retry: ret = rmdir(cgroup); if (ret && errno == EBUSY) { - ret = cg_killall(cgroup); - if (ret) - return ret; + cg_killall(cgroup); usleep(100); goto retry; } -- 2.19.2

6 years

1
0
0 0

selftests/net: udpgso: LTS kernels supportability ?

by Rafael David Tinoco

Shuah, I was recently investigating some errors coming out of our functional tests and we, Dan and I, came up with a discussion that might not be new for you, but, interests us, in defining how to better use kselftests as a regression mechanism/tool in our LKFT (https://lkft.linaro.org). David / Willem, I'm only using udpgso as an example for what I'd like to ask Shuah. Feel free to jump in in the discussion if you think its worth. All, Regarding: udpgso AND https://bugs.linaro.org/show_bug.cgi?id=3980 udpgso tests are failing in kernels bellow 4.18 because of 2 main reasons: 1) udp4_ufo_fragment does not seem to demand the GSO SKB to be > than the MTU for older kernels (4th test case in udpgso.c). 2) setsockopt(...UDP_SEGMENT) support is not present for older kernels. (commits "udp: generate gso with UDP_SEGMENT" and its fixes seem to be needed). With that explained, finally the question/discussion: Shouldn't we enforce a versioning mechanism for tests that are testing recently added features ? I mean, some of the tests inside udpgso selftest are good enough for older kernels... But, because we have no control over "kernel features" and "supported test cases", we, Linaro, have to end up blacklisting all selftests that have new feature oriented tests, because one or two test cases only. This has already been solved in other functional tests projects: allowing to check the running kernel version and deciding which test cases to run. Would that be something we should pursue ? (We could try to make patches here and there, like this case, whenever we face this). Or... should we stick with mainline/next only when talking about kselftest and forget about LTS kernels ? OBS: Situations like this are very time consuming before we can tell if there was a regression or the older kernel did not support the test case. Thank you for the attention. Rafael -- Rafael D. Tinoco Linaro - Kernel Validation

6 years

2
4
0 0

selftests/bpf/test_progs: 32-bit: Unable to handle kernel NULL pointer dereference at virtual address 00000000

by Naresh Kamboju

Unable to handle kernel NULL pointer dereference at virtual address 00000000 While running test case selftests: bpf: test_progs on arm32 x15 device running Linux -next, mainline and 4.19 kernel. steps to reproduce, cd tools/testing/selftests/bpf ./test_progs Test log ---------- selftests: bpf: test_progs libbpf: object file doesn't contain bpf program libbpf: object file doesn't contain bpf program libbpf: object file doesn't contain bpf program libbpf: object file doesn't contain bpf program libbpf: object file doesn't contain bpf program libbpf: ./test_tcp_estats.o doesn't provide kernel version [ 132.402282] Unable to handle kernel NULL pointer dereference at virtual address 00000000 [ 132.410971] pgd = a200d8e2 [ 132.413703] [00000000] *pgd=abd21003, *pmd=f1e93003 [ 132.418711] Internal error: Oops: 207 [#1] SMP ARM [ 132.423536] Modules linked in: sha1_generic sha1_arm_neon sha1_arm algif_hash af_alg snd_soc_simple_card snd_soc_simple_card_utils snd_soc_core ac97_bus snd_pcm_dmaengine snd_pcm snd_timer snd soundcore fuse [ 132.442171] CPU: 0 PID: 513 Comm: dd Not tainted 4.19.10-rc1 #1 [ 132.448121] Hardware name: Generic DRA74X (Flattened Device Tree) [ 132.454257] PC is at stack_map_get_build_id_offset+0x124/0x45c [ 132.460125] LR is at mark_held_locks+0x54/0x78 [ 132.464595] pc : [<c05941cc>] lr : [<c04bc8b4>] psr: 20060013 [ 132.470894] sp : ebff9b78 ip : 00000002 fp : ebff9bac [ 132.476144] r10: ffffe000 r9 : f5018c00 r8 : ec562018 [ 132.481396] r7 : ebba5750 r6 : effe2400 r5 : ec562010 r4 : f5018c14 [ 132.487958] r3 : ebff8000 r2 : 00000004 r1 : c240a758 r0 : 00000000 [ 132.494521] Flags: nzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment user [ 132.501691] Control: 30c5387d Table: abd3b280 DAC: fffffffd [ 132.507469] Process dd (pid: 513, stack limit = 0x0c814d44) [ 132.513072] Stack: (0xebff9b78 to 0xebffa000) [ 132.517453] 9b60: 00000002 00000000 [ 132.525674] 9b80: c1e08488 256dbf98 ebfe2c84 00000018 ebfe2cec 00000001 f5018c00 00000000 [ 132.533894] 9ba0: ebff9bfc ebff9bb0 c05948e4 c05940b4 0000007f 00000000 00000000 ec0156e0 [ 132.542114] 9bc0: ffefe180 f59bc75f ec562008 00000002 60060013 00000000 00000000 00000100 [ 132.550332] 9be0: 00000000 00000000 c1418258 c05704d0 ebff9c34 ebff9c00 c0564410 c0594510 [ 132.558552] 9c00: 00000100 00000000 00000000 00000000 00000000 00000000 f50db0b0 ebff9cd0 [ 132.566770] 9c20: c05643d8 00000000 ebff9cac ebff9c38 c0570c28 c05643e4 00000100 00000000 [ 132.574991] 9c40: ffffe000 00000000 60060013 ff7e0868 ebdf72c0 ec2f7900 00000a07 c1e08488 [ 132.583211] 9c60: 00000100 00000000 ff7e0868 00000000 ebdf77b0 00000000 aa61b412 b921aec2 [ 132.591429] 9c80: 00000001 c1e08488 ebd3bd48 c1da5160 ff7e0868 c1da5164 00000000 c0aaec90 [ 132.599648] 9ca0: ebff9d44 ebff9cb0 c0572b74 c057061c c04bcb6c c04bc0c4 ebdf72c0 b921aec2 [ 132.607868] 9cc0: 00000001 00000000 00000000 00000000 ed7b4e90 00000000 ff7e0868 00000000 [ 132.616087] 9ce0: ebfe2c00 00000000 00000100 00000000 ffffe000 00000000 60060013 ff7e0868 [ 132.624305] 9d00: ff7e0868 00000000 00000000 00000000 c04b9e14 c04b9d08 c1fa7f7e ebd3bd40 [ 132.632523] 9d20: ebff9cd0 00000000 ebff9d44 b921aec2 c04dcf54 00000001 ebff9d7c ebff9d48 [ 132.640742] 9d40: c05635a8 c0572b34 00000000 00000000 c05634bc 60060093 c1f4e428 c1f4ecb0 [ 132.648962] 9d60: ff7e0868 00000000 eef92230 00000014 ebff9dbc ebff9d80 c05a8938 c0563460 [ 132.657180] 9d80: 00000001 c1fa9750 ffffe000 ebff9e34 ebff9dbc ebff9da0 c055ccfc c1e08488 [ 132.665401] 9da0: 00000000 ff7df4ac 000007b4 00000001 ebff9e14 ebff9dc0 c0aab0b8 c05a8904 [ 132.673621] 9dc0: 00000001 00000000 eef92230 ff7df4ac 00000000 ebff9e34 ebff9dfc eef92230 [ 132.681839] 9de0: 00000000 b921aec2 ebff9e54 c1fab6cc c1e084c0 ebd3bc88 00000200 c0aaafcc [ 132.690060] 9e00: 000007b4 00001000 ebff9ea4 ebff9e18 c0aaec90 c0aaafd8 0003258c ebdf72c0 [ 132.698279] 9e20: c1e08488 00000200 c1e08488 c187b204 00000001 00000000 00000000 00000000 [ 132.706498] 9e40: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 [ 132.714718] 9e60: 00000000 00000000 00000000 00000000 00000000 b921aec2 ebff9e9c c1e08488 [ 132.722937] 9e80: c0aae980 ec7dda00 ebff9f58 00000000 00030000 00000200 ebff9f24 ebff9ea8 [ 132.731154] 9ea0: c06412f8 c0aae98c c04bea54 c04be3b8 c1fa8059 00000000 00000000 00000800 [ 132.739374] 9ec0: 00000000 00000055 c1e084c0 c1e08488 00000a07 0003258c c1e10eb0 ebff9fb0 [ 132.747594] 9ee0: b6fbacc0 00001208 ebff9fac ebff9ef8 c041a73c b921aec2 00000000 00000200 [ 132.755812] 9f00: ec7dda00 00030000 ebff9f58 00000000 00030000 00000200 ebff9f54 ebff9f28 [ 132.764032] 9f20: c06414b4 c06412bc ec7dd640 c0666714 c1e08488 ec7dda00 00000000 00000000 [ 132.772253] 9f40: ec7dda00 00030000 ebff9f94 ebff9f58 c06419f8 c0641428 00000000 00000000 [ 132.780471] 9f60: ebff9f94 b921aec2 c1da4e48 00014080 00000200 00030000 00000003 c04011c4 [ 132.788691] 9f80: ebff8000 00000003 ebff9fa4 ebff9f98 c0641a70 c06419a8 00000000 ebff9fa8 [ 132.796911] 9fa0: c0401000 c0641a64 00014080 00000200 00000000 00030000 00000200 00000000 [ 132.805131] 9fc0: 00014080 00000200 00030000 00000003 0002e1f0 00000000 b6fbacd0 0002e160 [ 132.813353] 9fe0: b6f0d130 bed4a9d8 000140bc b6f0d150 60060010 00000000 00000000 00000000 [ 132.821579] [<c05941cc>] (stack_map_get_build_id_offset) from [<c05948e4>] (bpf_get_stackid+0x3e0/0x45c) [ 132.831113] [<c05948e4>] (bpf_get_stackid) from [<c0564410>] (bpf_get_stackid_tp+0x38/0x40) [ 132.839513] [<c0564410>] (bpf_get_stackid_tp) from [<c0570c28>] (___bpf_prog_run+0x618/0x1650) [ 132.848173] [<c0570c28>] (___bpf_prog_run) from [<c0572b74>] (__bpf_prog_run32+0x4c/0x68) [ 132.856398] [<c0572b74>] (__bpf_prog_run32) from [<c05635a8>] (trace_call_bpf+0x154/0x298) [ 132.864709] [<c05635a8>] (trace_call_bpf) from [<c05a8938>] (perf_trace_run_bpf_submit+0x40/0xb0) [ 132.873634] [<c05a8938>] (perf_trace_run_bpf_submit) from [<c0aab0b8>] (perf_trace_urandom_read+0xec/0xf4) [ 132.883340] [<c0aab0b8>] (perf_trace_urandom_read) from [<c0aaec90>] (urandom_read+0x310/0x3a8) [ 132.892088] [<c0aaec90>] (urandom_read) from [<c06412f8>] (__vfs_read+0x48/0x16c) [ 132.899612] [<c06412f8>] (__vfs_read) from [<c06414b4>] (vfs_read+0x98/0x11c) [ 132.906785] [<c06414b4>] (vfs_read) from [<c06419f8>] (ksys_read+0x5c/0xbc) [ 132.913786] [<c06419f8>] (ksys_read) from [<c0641a70>] (sys_read+0x18/0x1c) [ 132.920789] [<c0641a70>] (sys_read) from [<c0401000>] (ret_fast_syscall+0x0/0x28) [ 132.928308] Exception stack(0xebff9fa8 to 0xebff9ff0) [ 132.933386] 9fa0: 00014080 00000200 00000000 00030000 00000200 00000000 [ 132.941605] 9fc0: 00014080 00000200 00030000 00000003 0002e1f0 00000000 b6fbacd0 0002e160 [ 132.949824] 9fe0: b6f0d130 bed4a9d8 000140bc b6f0d150 [ 132.954906] Code: eb00807f e2506000 0a00002c eb017c95 (e5d03000) Broadcast message from systemd-journald@am57xx-evm (Tue 2018[ 132.961142] ---[ end trace 1c5735a4a3de9954 ]--- -12-04 10:50:54 UTC): kernel[162]: [ 132.418711] Internal [ 132.971394] note: dd[513] exited with preempt_count 4 error: Oops: 207 [#1] SMP ARM libbpf: object file doesn't contain bpf program sh: line 1: 513 Segmentation fault dd if=/dev/urandom of=/dev/zero count=4 2> /dev/null test_progs: test_progs.c:1202: test_stacktrace_build_id: Assertion `system(\"dd if=/dev/urandom of=/dev/zero count=4 2> /dev/null\") == 0' failed. test_xdp_adjust_tail:FAIL:ipv4 err 0 errno 2 retval 1 size 54 test_xdp_adjust_tail:FAIL:ipv6 err 0 errno 2 retval 3 size 54 test_tcp_estats:FAIL: err -2 errno 2 Full test log, https://lkft.validation.linaro.org/scheduler/job/547076#L2539 metadata: git branch: linux-4.19.y git repo: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git git commit: 4875bf1f86d7bdc8dbf3222ab4028239446fab3f git describe: v4.19.9-143-g4875bf1f86d7 make_kernelversion: 4.19.10-rc1 kernel-config: http://snapshots.linaro.org/openembedded/lkft/rocko/am57xx-evm/rpb/linux-st… build-url: https://ci.linaro.org/job/openembedded-lkft-linux-stable-rc-4.19/DISTRO=rpb… build-location: http://snapshots.linaro.org/openembedded/lkft/rocko/am57xx-evm/rpb/linux-st… kselftest__url: https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.19.tar.xz kselftest__version: '4.19' kselftest__revision: '4.19' Best regards Naresh Kamboju

6 years

3
5
0 0

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror December 2018