August 2023 - Linux-kselftest-mirror

[PATCH bpf-next v8] selftests/bpf: trace_helpers.c: optimize kallsyms cache

by Rong Tao

From: Rong Tao <rongtao(a)cestc.cn> Static ksyms often have problems because the number of symbols exceeds the MAX_SYMS limit. Like changing the MAX_SYMS from 300000 to 400000 in commit e76a014334a6("selftests/bpf: Bump and validate MAX_SYMS") solves the problem somewhat, but it's not the perfect way. This commit uses dynamic memory allocation, which completely solves the problem caused by the limitation of the number of kallsyms. Acked-by: Stanislav Fomichev <sdf(a)google.com> Signed-off-by: Rong Tao <rongtao(a)cestc.cn> --- v8: Resolves inter-thread contention for ksyms global variables. v7: https://lore.kernel.org/lkml/tencent_BD6E19C00BF565CD5C36A9A0BD828CFA210A@q… Fix __must_check macro. v6: https://lore.kernel.org/lkml/tencent_4A09A36F883A06EA428A593497642AF8AF08@q… Apply libbpf_ensure_mem() v5: https://lore.kernel.org/lkml/tencent_0E9E1A1C0981678D5E7EA9E4BDBA8EE2200A@q… Release the allocated memory once the load_kallsyms_refresh() upon error given it's dynamically allocated. v4: https://lore.kernel.org/lkml/tencent_59C74613113F0C728524B2A82FE5540A5E09@q… Make sure most cases we don't need the realloc() path to begin with, and check strdup() return value. v3: https://lore.kernel.org/lkml/tencent_50B4B2622FE7546A5FF9464310650C008509@q… Do not use structs and judge ksyms__add_symbol function return value. v2: https://lore.kernel.org/lkml/tencent_B655EE5E5D463110D70CD2846AB3262EED09@q… Do the usual len/capacity scheme here to amortize the cost of realloc, and don't free symbols. v1: https://lore.kernel.org/lkml/tencent_AB461510B10CD484E0B2F62E3754165F2909@q… --- samples/bpf/Makefile | 4 + samples/bpf/offwaketime_user.c | 7 +- samples/bpf/sampleip_user.c | 9 +- samples/bpf/spintest_user.c | 7 +- samples/bpf/task_fd_query_user.c | 13 +- samples/bpf/trace_event_user.c | 7 +- .../selftests/bpf/prog_tests/bpf_cookie.c | 7 +- .../selftests/bpf/prog_tests/fill_link_info.c | 9 +- .../bpf/prog_tests/get_stack_raw_tp.c | 10 +- .../bpf/prog_tests/kprobe_multi_test.c | 13 +- .../prog_tests/kprobe_multi_testmod_test.c | 13 +- tools/testing/selftests/bpf/trace_helpers.c | 116 ++++++++++++------ tools/testing/selftests/bpf/trace_helpers.h | 10 +- 13 files changed, 154 insertions(+), 71 deletions(-) diff --git a/samples/bpf/Makefile b/samples/bpf/Makefile index 4ccf4236031c..6c707ebcebb9 100644 --- a/samples/bpf/Makefile +++ b/samples/bpf/Makefile @@ -175,6 +175,7 @@ TPROGS_CFLAGS += -I$(srctree)/tools/testing/selftests/bpf/ TPROGS_CFLAGS += -I$(LIBBPF_INCLUDE) TPROGS_CFLAGS += -I$(srctree)/tools/include TPROGS_CFLAGS += -I$(srctree)/tools/perf +TPROGS_CFLAGS += -I$(srctree)/tools/lib TPROGS_CFLAGS += -DHAVE_ATTR_TEST=0 ifdef SYSROOT @@ -314,6 +315,9 @@ XDP_SAMPLE_CFLAGS += -Wall -O2 \ $(obj)/$(XDP_SAMPLE): TPROGS_CFLAGS = $(XDP_SAMPLE_CFLAGS) $(obj)/$(XDP_SAMPLE): $(src)/xdp_sample_user.h $(src)/xdp_sample_shared.h +# Override includes for trace_helpers.o because __must_check won't be defined +# in our include path. +$(obj)/$(TRACE_HELPERS): TPROGS_CFLAGS := $(TPROGS_CFLAGS) -D__must_check= -include $(BPF_SAMPLES_PATH)/Makefile.target diff --git a/samples/bpf/offwaketime_user.c b/samples/bpf/offwaketime_user.c index 5557b5393642..53c1a6b4ec44 100644 --- a/samples/bpf/offwaketime_user.c +++ b/samples/bpf/offwaketime_user.c @@ -16,6 +16,7 @@ /* counts, stackmap */ static int map_fd[2]; +struct ksyms *ksyms; static void print_ksym(__u64 addr) { @@ -23,7 +24,7 @@ static void print_ksym(__u64 addr) if (!addr) return; - sym = ksym_search(addr); + sym = ksym_search(ksyms, addr); if (!sym) { printf("ksym not found. Is kallsyms loaded?\n"); return; @@ -100,7 +101,8 @@ int main(int argc, char **argv) int delay = 1, i = 0; char filename[256]; - if (load_kallsyms()) { + ksyms = load_kallsyms(); + if (!ksyms) { printf("failed to process /proc/kallsyms\n"); return 2; } @@ -149,5 +151,6 @@ int main(int argc, char **argv) bpf_link__destroy(links[i]); bpf_object__close(obj); + free_kallsyms(ksyms); return 0; } diff --git a/samples/bpf/sampleip_user.c b/samples/bpf/sampleip_user.c index 9283f47844fb..aec3d557aa6b 100644 --- a/samples/bpf/sampleip_user.c +++ b/samples/bpf/sampleip_user.c @@ -25,6 +25,7 @@ static int map_fd; static int nr_cpus; static long _text_addr; +struct ksyms *ksyms; static void usage(void) { @@ -109,7 +110,7 @@ static void print_ip_map(int fd) qsort(counts, max, sizeof(struct ipcount), count_cmp); for (i = 0; i < max; i++) { if (counts[i].ip > _text_addr) { - sym = ksym_search(counts[i].ip); + sym = ksym_search(ksyms, counts[i].ip); if (!sym) { printf("ksym not found. Is kallsyms loaded?\n"); continue; @@ -164,13 +165,14 @@ int main(int argc, char **argv) } /* initialize kernel symbol translation */ - if (load_kallsyms()) { + ksyms = load_kallsyms(); + if (!ksyms) { fprintf(stderr, "ERROR: loading /proc/kallsyms\n"); return 2; } /* used to determine whether the address is kernel space */ - _text_addr = ksym_get_addr("_text"); + _text_addr = ksym_get_addr(ksyms, "_text"); if (!_text_addr) { fprintf(stderr, "ERROR: no '_text' in /proc/kallsyms\n"); return 3; @@ -230,5 +232,6 @@ int main(int argc, char **argv) free(links); bpf_object__close(obj); + free_kallsyms(ksyms); return error; } diff --git a/samples/bpf/spintest_user.c b/samples/bpf/spintest_user.c index 55971edb1088..db6a3c6d5329 100644 --- a/samples/bpf/spintest_user.c +++ b/samples/bpf/spintest_user.c @@ -16,8 +16,10 @@ int main(int ac, char **argv) int map_fd, i, j = 0; char filename[256]; struct ksym *sym; + struct ksyms *ksyms; - if (load_kallsyms()) { + ksyms = load_kallsyms(); + if (!ksyms) { printf("failed to process /proc/kallsyms\n"); return 2; } @@ -58,7 +60,7 @@ int main(int ac, char **argv) while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) { bpf_map_lookup_elem(map_fd, &next_key, &value); assert(next_key == value); - sym = ksym_search(value); + sym = ksym_search(ksyms, value); key = next_key; if (!sym) { printf("ksym not found. Is kallsyms loaded?\n"); @@ -80,5 +82,6 @@ int main(int ac, char **argv) bpf_link__destroy(links[j]); bpf_object__close(obj); + free_kallsyms(ksyms); return 0; } diff --git a/samples/bpf/task_fd_query_user.c b/samples/bpf/task_fd_query_user.c index 1e61f2180470..6e7710a4a96f 100644 --- a/samples/bpf/task_fd_query_user.c +++ b/samples/bpf/task_fd_query_user.c @@ -315,8 +315,10 @@ int main(int argc, char **argv) struct bpf_program *prog; struct bpf_object *obj; int i = 0, err = -1; + struct ksyms *ksyms; - if (load_kallsyms()) { + ksyms = load_kallsyms(); + if (!ksyms) { printf("failed to process /proc/kallsyms\n"); return err; } @@ -368,22 +370,22 @@ int main(int argc, char **argv) BPF_FD_TYPE_KRETPROBE, buf, sizeof(buf))); CHECK_AND_RET(test_nondebug_fs_probe("kprobe", NULL, 0x0, - ksym_get_addr("bpf_check"), false, + ksym_get_addr(ksyms, "bpf_check"), false, BPF_FD_TYPE_KPROBE, BPF_FD_TYPE_KRETPROBE, buf, sizeof(buf))); CHECK_AND_RET(test_nondebug_fs_probe("kprobe", NULL, 0x0, - ksym_get_addr("bpf_check"), false, + ksym_get_addr(ksyms, "bpf_check"), false, BPF_FD_TYPE_KPROBE, BPF_FD_TYPE_KRETPROBE, NULL, 0)); CHECK_AND_RET(test_nondebug_fs_probe("kprobe", NULL, 0x0, - ksym_get_addr("bpf_check"), true, + ksym_get_addr(ksyms, "bpf_check"), true, BPF_FD_TYPE_KPROBE, BPF_FD_TYPE_KRETPROBE, buf, sizeof(buf))); CHECK_AND_RET(test_nondebug_fs_probe("kprobe", NULL, 0x0, - ksym_get_addr("bpf_check"), true, + ksym_get_addr(ksyms, "bpf_check"), true, BPF_FD_TYPE_KPROBE, BPF_FD_TYPE_KRETPROBE, 0, 0)); @@ -419,5 +421,6 @@ int main(int argc, char **argv) bpf_link__destroy(links[i]); bpf_object__close(obj); + free_kallsyms(ksyms); return err; } diff --git a/samples/bpf/trace_event_user.c b/samples/bpf/trace_event_user.c index 9664749bf618..b4822166182f 100644 --- a/samples/bpf/trace_event_user.c +++ b/samples/bpf/trace_event_user.c @@ -23,6 +23,7 @@ static int pid; static int map_fd[2]; struct bpf_program *prog; static bool sys_read_seen, sys_write_seen; +struct ksyms *ksyms; static void print_ksym(__u64 addr) { @@ -30,7 +31,7 @@ static void print_ksym(__u64 addr) if (!addr) return; - sym = ksym_search(addr); + sym = ksym_search(ksyms, addr); if (!sym) { printf("ksym not found. Is kallsyms loaded?\n"); return; @@ -303,7 +304,8 @@ int main(int argc, char **argv) signal(SIGINT, err_exit); signal(SIGTERM, err_exit); - if (load_kallsyms()) { + ksyms = load_kallsyms(); + if (!ksyms) { printf("failed to process /proc/kallsyms\n"); goto cleanup; } @@ -348,5 +350,6 @@ int main(int argc, char **argv) cleanup: bpf_object__close(obj); + free_kallsyms(ksyms); err_exit(error); } diff --git a/tools/testing/selftests/bpf/prog_tests/bpf_cookie.c b/tools/testing/selftests/bpf/prog_tests/bpf_cookie.c index 1454cebc262b..26bf1f33b8d5 100644 --- a/tools/testing/selftests/bpf/prog_tests/bpf_cookie.c +++ b/tools/testing/selftests/bpf/prog_tests/bpf_cookie.c @@ -104,8 +104,10 @@ static void kprobe_multi_link_api_subtest(void) LIBBPF_OPTS(bpf_link_create_opts, opts); unsigned long long addrs[8]; __u64 cookies[8]; + struct ksyms *ksyms; - if (!ASSERT_OK(load_kallsyms(), "load_kallsyms")) + ksyms = load_kallsyms(); + if (!ASSERT_OK(ksyms != NULL, "load_kallsyms")) goto cleanup; skel = kprobe_multi__open_and_load(); @@ -116,7 +118,7 @@ static void kprobe_multi_link_api_subtest(void) skel->bss->test_cookie = true; #define GET_ADDR(__sym, __addr) ({ \ - __addr = ksym_get_addr(__sym); \ + __addr = ksym_get_addr(ksyms, __sym); \ if (!ASSERT_NEQ(__addr, 0, "ksym_get_addr " #__sym)) \ goto cleanup; \ }) @@ -171,6 +173,7 @@ static void kprobe_multi_link_api_subtest(void) cleanup: close(link1_fd); close(link2_fd); + free_kallsyms(ksyms); kprobe_multi__destroy(skel); } diff --git a/tools/testing/selftests/bpf/prog_tests/fill_link_info.c b/tools/testing/selftests/bpf/prog_tests/fill_link_info.c index 9d768e083714..a134eda17446 100644 --- a/tools/testing/selftests/bpf/prog_tests/fill_link_info.c +++ b/tools/testing/selftests/bpf/prog_tests/fill_link_info.c @@ -302,16 +302,18 @@ void test_fill_link_info(void) { struct test_fill_link_info *skel; int i; + struct ksyms *ksyms; skel = test_fill_link_info__open_and_load(); if (!ASSERT_OK_PTR(skel, "skel_open")) return; /* load kallsyms to compare the addr */ - if (!ASSERT_OK(load_kallsyms_refresh(), "load_kallsyms_refresh")) + ksyms = load_kallsyms_refresh(NULL); + if (!ASSERT_OK(ksyms != NULL, "load_kallsyms_refresh")) goto cleanup; - kprobe_addr = ksym_get_addr(KPROBE_FUNC); + kprobe_addr = ksym_get_addr(ksyms, KPROBE_FUNC); if (test__start_subtest("kprobe_link_info")) test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KPROBE, false); if (test__start_subtest("kretprobe_link_info")) @@ -329,7 +331,7 @@ void test_fill_link_info(void) qsort(kmulti_syms, KMULTI_CNT, sizeof(kmulti_syms[0]), symbols_cmp_r); for (i = 0; i < KMULTI_CNT; i++) - kmulti_addrs[i] = ksym_get_addr(kmulti_syms[i]); + kmulti_addrs[i] = ksym_get_addr(ksyms, kmulti_syms[i]); if (test__start_subtest("kprobe_multi_link_info")) test_kprobe_multi_fill_link_info(skel, false, false); if (test__start_subtest("kretprobe_multi_link_info")) @@ -339,4 +341,5 @@ void test_fill_link_info(void) cleanup: test_fill_link_info__destroy(skel); + free_kallsyms(ksyms); } diff --git a/tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c b/tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c index 858e0575f502..7a5e7741da14 100644 --- a/tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c +++ b/tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c @@ -9,6 +9,7 @@ #define MAX_STACK_RAWTP 100 static int duration = 0; +static struct ksyms *ksyms; struct get_stack_trace_t { int pid; @@ -48,7 +49,7 @@ static void get_stack_print_output(void *ctx, int cpu, void *data, __u32 size) found = num_stack > 0; } else { for (i = 0; i < num_stack; i++) { - ks = ksym_search(raw_data[i]); + ks = ksym_search(ksyms, raw_data[i]); if (ks && (strcmp(ks->name, nonjit_func) == 0)) { found = true; break; @@ -65,7 +66,7 @@ static void get_stack_print_output(void *ctx, int cpu, void *data, __u32 size) good_kern_stack = num_stack > 0; } else { for (i = 0; i < num_stack; i++) { - ks = ksym_search(e.kern_stack[i]); + ks = ksym_search(ksyms, e.kern_stack[i]); if (ks && (strcmp(ks->name, nonjit_func) == 0)) { good_kern_stack = true; break; @@ -112,8 +113,8 @@ void test_get_stack_raw_tp(void) if (CHECK(!map, "bpf_find_map", "not found\n")) goto close_prog; - err = load_kallsyms(); - if (CHECK(err < 0, "load_kallsyms", "err %d errno %d\n", err, errno)) + ksyms = load_kallsyms(); + if (CHECK(!ksyms, "load_kallsyms", "err %d errno %d\n", err, errno)) goto close_prog; CPU_ZERO(&cpu_set); @@ -146,4 +147,5 @@ void test_get_stack_raw_tp(void) bpf_link__destroy(link); perf_buffer__free(pb); bpf_object__close(obj); + free_kallsyms(ksyms); } diff --git a/tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c b/tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c index 179fe300534f..e902ea50de57 100644 --- a/tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c +++ b/tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c @@ -6,6 +6,8 @@ #include "bpf/libbpf_internal.h" #include "bpf/hashmap.h" +static struct ksyms *ksyms; + static void kprobe_multi_test_run(struct kprobe_multi *skel, bool test_return) { LIBBPF_OPTS(bpf_test_run_opts, topts); @@ -89,7 +91,7 @@ static void test_link_api(struct bpf_link_create_opts *opts) } #define GET_ADDR(__sym, __addr) ({ \ - __addr = ksym_get_addr(__sym); \ + __addr = ksym_get_addr(ksyms, __sym); \ if (!ASSERT_NEQ(__addr, 0, "kallsyms load failed for " #__sym)) \ return; \ }) @@ -222,8 +224,8 @@ static void test_attach_api_fails(void) }; __u64 cookies[2]; - addrs[0] = ksym_get_addr("bpf_fentry_test1"); - addrs[1] = ksym_get_addr("bpf_fentry_test2"); + addrs[0] = ksym_get_addr(ksyms, "bpf_fentry_test1"); + addrs[1] = ksym_get_addr(ksyms, "bpf_fentry_test2"); if (!ASSERT_FALSE(!addrs[0] || !addrs[1], "ksym_get_addr")) goto cleanup; @@ -463,7 +465,8 @@ void serial_test_kprobe_multi_bench_attach(void) void test_kprobe_multi_test(void) { - if (!ASSERT_OK(load_kallsyms(), "load_kallsyms")) + ksyms = load_kallsyms(); + if (!ASSERT_OK(ksyms != NULL, "load_kallsyms")) return; if (test__start_subtest("skel_api")) @@ -480,4 +483,6 @@ void test_kprobe_multi_test(void) test_attach_api_syms(); if (test__start_subtest("attach_api_fails")) test_attach_api_fails(); + + free_kallsyms(ksyms); } diff --git a/tools/testing/selftests/bpf/prog_tests/kprobe_multi_testmod_test.c b/tools/testing/selftests/bpf/prog_tests/kprobe_multi_testmod_test.c index 1fbe7e4ac00a..69de53db63fd 100644 --- a/tools/testing/selftests/bpf/prog_tests/kprobe_multi_testmod_test.c +++ b/tools/testing/selftests/bpf/prog_tests/kprobe_multi_testmod_test.c @@ -4,6 +4,8 @@ #include "trace_helpers.h" #include "bpf/libbpf_internal.h" +static struct ksyms *ksyms; + static void kprobe_multi_testmod_check(struct kprobe_multi *skel) { ASSERT_EQ(skel->bss->kprobe_testmod_test1_result, 1, "kprobe_test1_result"); @@ -50,11 +52,11 @@ static void test_testmod_attach_api_addrs(void) LIBBPF_OPTS(bpf_kprobe_multi_opts, opts); unsigned long long addrs[3]; - addrs[0] = ksym_get_addr("bpf_testmod_fentry_test1"); + addrs[0] = ksym_get_addr(ksyms, "bpf_testmod_fentry_test1"); ASSERT_NEQ(addrs[0], 0, "ksym_get_addr"); - addrs[1] = ksym_get_addr("bpf_testmod_fentry_test2"); + addrs[1] = ksym_get_addr(ksyms, "bpf_testmod_fentry_test2"); ASSERT_NEQ(addrs[1], 0, "ksym_get_addr"); - addrs[2] = ksym_get_addr("bpf_testmod_fentry_test3"); + addrs[2] = ksym_get_addr(ksyms, "bpf_testmod_fentry_test3"); ASSERT_NEQ(addrs[2], 0, "ksym_get_addr"); opts.addrs = (const unsigned long *) addrs; @@ -79,11 +81,14 @@ static void test_testmod_attach_api_syms(void) void serial_test_kprobe_multi_testmod_test(void) { - if (!ASSERT_OK(load_kallsyms_refresh(), "load_kallsyms_refresh")) + ksyms = load_kallsyms_refresh(NULL); + if (!ASSERT_OK(ksyms != NULL, "load_kallsyms_refresh")) return; if (test__start_subtest("testmod_attach_api_syms")) test_testmod_attach_api_syms(); if (test__start_subtest("testmod_attach_api_addrs")) test_testmod_attach_api_addrs(); + + free_kallsyms(ksyms); } diff --git a/tools/testing/selftests/bpf/trace_helpers.c b/tools/testing/selftests/bpf/trace_helpers.c index f83d9f65c65b..048522d2ac6e 100644 --- a/tools/testing/selftests/bpf/trace_helpers.c +++ b/tools/testing/selftests/bpf/trace_helpers.c @@ -14,99 +14,143 @@ #include <linux/limits.h> #include <libelf.h> #include <gelf.h> +#include "bpf/libbpf_internal.h" #define TRACEFS_PIPE "/sys/kernel/tracing/trace_pipe" #define DEBUGFS_PIPE "/sys/kernel/debug/tracing/trace_pipe" -#define MAX_SYMS 400000 -static struct ksym syms[MAX_SYMS]; -static int sym_cnt; +struct ksyms { + struct ksym *syms; + size_t sym_cap; + size_t sym_cnt; +}; + +static int ksyms__add_symbol(struct ksyms *ksyms, const char *name, + unsigned long addr) +{ + void *tmp; + + tmp = strdup(name); + if (!tmp) + return -ENOMEM; + ksyms->syms[ksyms->sym_cnt].addr = addr; + ksyms->syms[ksyms->sym_cnt].name = tmp; + + ksyms->sym_cnt++; + + return 0; +} + +void free_kallsyms(struct ksyms *ksyms) +{ + unsigned int i; + + if (!ksyms) + return; + + if (!ksyms->syms) { + free(ksyms); + return; + } + + for (i = 0; i < ksyms->sym_cnt; i++) + free(ksyms->syms[i].name); + free(ksyms->syms); + free(ksyms); +} static int ksym_cmp(const void *p1, const void *p2) { return ((struct ksym *)p1)->addr - ((struct ksym *)p2)->addr; } -int load_kallsyms_refresh(void) +struct ksyms *load_kallsyms_refresh(struct ksyms *ksyms) { FILE *f; char func[256], buf[256]; char symbol; void *addr; - int i = 0; + int ret; - sym_cnt = 0; + /* flush kallsyms, free the previously allocated dynamic memory */ + free_kallsyms(ksyms); f = fopen("/proc/kallsyms", "r"); if (!f) - return -ENOENT; + return NULL; + + ksyms = calloc(1, sizeof(struct ksyms)); + if (!ksyms) + return NULL; while (fgets(buf, sizeof(buf), f)) { if (sscanf(buf, "%p %c %s", &addr, &symbol, func) != 3) break; if (!addr) continue; - if (i >= MAX_SYMS) - return -EFBIG; - syms[i].addr = (long) addr; - syms[i].name = strdup(func); - i++; + ret = libbpf_ensure_mem((void **) &ksyms->syms, &ksyms->sym_cap, + sizeof(struct ksym), ksyms->sym_cnt + 1); + if (ret) + goto error; + ret = ksyms__add_symbol(ksyms, func, (unsigned long)addr); + if (ret) + goto error; } fclose(f); - sym_cnt = i; - qsort(syms, sym_cnt, sizeof(struct ksym), ksym_cmp); - return 0; + qsort(ksyms->syms, ksyms->sym_cnt, sizeof(struct ksym), ksym_cmp); + return ksyms; + +error: + free_kallsyms(ksyms); + return NULL; } -int load_kallsyms(void) +struct ksyms *load_kallsyms(void) { - /* - * This is called/used from multiplace places, - * load symbols just once. - */ - if (sym_cnt) - return 0; - return load_kallsyms_refresh(); + return load_kallsyms_refresh(NULL); } -struct ksym *ksym_search(long key) +struct ksym *ksym_search(struct ksyms *ksyms, long key) { - int start = 0, end = sym_cnt; + int start = 0, end = ksyms->sym_cnt; int result; + if (!ksyms) + return NULL; + /* kallsyms not loaded. return NULL */ - if (sym_cnt <= 0) + if (ksyms->sym_cnt <= 0) return NULL; while (start < end) { size_t mid = start + (end - start) / 2; - result = key - syms[mid].addr; + result = key - ksyms->syms[mid].addr; if (result < 0) end = mid; else if (result > 0) start = mid + 1; else - return &syms[mid]; + return &ksyms->syms[mid]; } - if (start >= 1 && syms[start - 1].addr < key && - key < syms[start].addr) + if (start >= 1 && ksyms->syms[start - 1].addr < key && + key < ksyms->syms[start].addr) /* valid ksym */ - return &syms[start - 1]; + return &ksyms->syms[start - 1]; /* out of range. return _stext */ - return &syms[0]; + return &ksyms->syms[0]; } -long ksym_get_addr(const char *name) +long ksym_get_addr(struct ksyms *ksyms, const char *name) { int i; - for (i = 0; i < sym_cnt; i++) { - if (strcmp(syms[i].name, name) == 0) - return syms[i].addr; + for (i = 0; i < ksyms->sym_cnt; i++) { + if (strcmp(ksyms->syms[i].name, name) == 0) + return ksyms->syms[i].addr; } return 0; diff --git a/tools/testing/selftests/bpf/trace_helpers.h b/tools/testing/selftests/bpf/trace_helpers.h index 876f3e711df6..6be64f44dd76 100644 --- a/tools/testing/selftests/bpf/trace_helpers.h +++ b/tools/testing/selftests/bpf/trace_helpers.h @@ -11,12 +11,14 @@ struct ksym { long addr; char *name; }; +struct ksyms; -int load_kallsyms(void); -int load_kallsyms_refresh(void); +struct ksyms *load_kallsyms(void); +struct ksyms *load_kallsyms_refresh(struct ksyms *ksyms); +void free_kallsyms(struct ksyms *ksyms); -struct ksym *ksym_search(long key); -long ksym_get_addr(const char *name); +struct ksym *ksym_search(struct ksyms *ksyms, long key); +long ksym_get_addr(struct ksyms *ksyms, const char *name); /* open kallsyms and find addresses on the fly, faster than load + search. */ int kallsyms_find(const char *sym, unsigned long long *addr); -- 2.41.0

8 months, 3 weeks

3
6
0 0

[GIT PULL] scftorture changes for v6.4

by Paul E. McKenney

Hello, Linus, Once the merge window opens, please pull these scftorture changes: git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git tags/scftorture.2023.08.15a # HEAD: 3f68f9c822ebe208f961ab0402e49a10465278ca: scftorture: Add CONFIG_PREEMPT_DYNAMIC=n to NOPREEMPT scenario (2023-07-14 15:02:57 -0700) ---------------------------------------------------------------- smp_call_function torture-test updates for v6.6 This pull request prevents some memory-exhaustion false-postitive failures in scftorture testing. ---------------------------------------------------------------- Paul E. McKenney (4): torture: Scale scftorture memory based on number of CPUs scftorture: Forgive memory-allocation failure if KASAN scftorture: Pause testing after memory-allocation failure scftorture: Add CONFIG_PREEMPT_DYNAMIC=n to NOPREEMPT scenario kernel/scftorture.c | 12 +++++++++--- tools/testing/selftests/rcutorture/bin/torture.sh | 4 +++- tools/testing/selftests/rcutorture/configs/scf/NOPREEMPT | 2 ++ 3 files changed, 14 insertions(+), 4 deletions(-)

8 months, 3 weeks

3
3
0 0

[PATCH v5 0/7] Optimize mremap during mutual alignment within PMD

by Joel Fernandes (Google)

Hello! Here is v5 of the mremap start address optimization / fix for exec warning. Description of patches ====================== These patches optimizes the start addresses in move_page_tables() and tests the changes. It addresses a warning [1] that occurs due to a downward, overlapping move on a mutually-aligned offset within a PMD during exec. By initiating the copy process at the PMD level when such alignment is present, we can prevent this warning and speed up the copying process at the same time. Linus Torvalds suggested this idea. Please check the individual patches for more details. [1] https://lore.kernel.org/all/ZB2GTBD%2FLWTrkOiO@dhcp22.suse.cz/ Link to v4: https://lore.kernel.org/all/20230531220807.2048037-1-joel@joelfernandes.org/ History of patches: v4->v5: 1. Rebased on mainline. 2. Several improvement suggestions from Lorenzo. v3->v4: 1. Care to be taken to move purely within a VMA, in other words this check in call_align_down(): if (vma->vm_start != addr_masked) return false; As an example of why this is needed: Consider the following range which is 2MB aligned and is a part of a larger 10MB range which is not shown. Each character is 256KB below making the source and destination 2MB each. The lower case letters are moved (s to d) and the upper case letters are not moved. |DDDDddddSSSSssss| If we align down 'ssss' to start from the 'SSSS', we will end up destroying SSSS. The above if statement prevents that and I verified it. I also added a test for this in the last patch. 2. Handle the stack case separately. We do not care about #1 for stack movement because the 'SSSS' does not matter during this move. Further we need to do this to prevent the stack move warning. if (!for_stack && vma->vm_start <= addr_masked) return false; v2->v3: 1. Masked address was stored in int, fixed it to unsigned long to avoid truncation. 2. We now handle moves happening purely within a VMA, a new test is added to handle this. 3. More code comments. v1->v2: 1. Trigger the optimization for mremaps smaller than a PMD. I tested by tracing that it works correctly. 2. Fix issue with bogus return value found by Linus if we broke out of the above loop for the first PMD itself. v1: Initial RFC. Joel Fernandes (1): selftests: mm: Add a test for moving from an offset from start of mapping Joel Fernandes (Google) (6): mm/mremap: Optimize the start addresses in move_page_tables() mm/mremap: Allow moves within the same VMA selftests: mm: Fix failure case when new remap region was not found selftests: mm: Add a test for mutually aligned moves > PMD size selftests: mm: Add a test for remapping to area immediately after existing mapping selftests: mm: Add a test for remapping within a range fs/exec.c | 2 +- include/linux/mm.h | 2 +- mm/mremap.c | 69 +++++- tools/testing/selftests/mm/mremap_test.c | 301 +++++++++++++++++++---- 4 files changed, 325 insertions(+), 49 deletions(-) -- 2.42.0.rc1.204.g551eb34607-goog

8 months, 3 weeks

3
24
0 0

[PATCH 0/3] selftests/hid: assorted fixes

by Benjamin Tissoires

These fixes have been triggered by [0]: basically, if you do not recompile the kernel first, and are running on an old kernel, vmlinux.h doesn't have the required symbols and the compilation fails. The tests will fail if you run them on that very same machine, of course, but the binary should compile. And while I was sorting out why it was failing, I realized I could do a couple of improvements on the Makefile. [0] https://lore.kernel.org/linux-input/56ba8125-2c6f-a9c9-d498-0ca1c153dcb2@re… Signed-off-by: Benjamin Tissoires <bentiss(a)kernel.org> --- Benjamin Tissoires (3): selftests/hid: ensure we can compile the tests on kernels pre-6.3 selftests/hid: do not manually call headers_install selftests/hid: force using our compiled libbpf headers tools/testing/selftests/hid/Makefile | 10 ++++------ tools/testing/selftests/hid/progs/hid.c | 3 --- tools/testing/selftests/hid/progs/hid_bpf_helpers.h | 20 ++++++++++++++++++++ 3 files changed, 24 insertions(+), 9 deletions(-) --- base-commit: 1d7546042f8fdc4bc39ab91ec966203e2d64f8bd change-id: 20230825-wip-selftests-9a7502b56542 Best regards, -- Benjamin Tissoires <bentiss(a)kernel.org>

8 months, 3 weeks

3
6
0 0

[PATCH v2 0/3] Add a test to catch unprobed Devicetree devices

by Nícolas F. R. A. Prado

Regressions that cause a device to no longer be probed by a driver can have a big impact on the platform's functionality, and despite being relatively common there isn't currently any generic test to detect them. As an example, bootrr [1] does test for device probe, but it requires defining the expected probed devices for each platform. Given that the Devicetree already provides a static description of devices on the system, it is a good basis for building such a test on top. This series introduces a test to catch regressions that prevent devices from probing. Patches 1 and 2 extend the existing dt-extract-compatibles to be able to output only the compatibles that can be expected to match a Devicetree node to a driver. Patch 2 adds a kselftest that walks over the Devicetree nodes on the current platform and compares the compatibles to the ones on the list, and on an ignore list, to point out devices that failed to be probed. A compatible list is needed because not all compatibles that can show up in a Devicetree node can be used to match to a driver, for example the code for that compatible might use "OF_DECLARE" type macros and avoid the driver framework, or the node might be controlled by a driver that was bound to a different node. An ignore list is needed for the few cases where it's common for a driver to match a device but not probe, like for the "simple-mfd" compatible, where the driver only probes if that compatible is the node's first compatible. The reason for parsing the kernel source instead of relying on information exposed by the kernel at runtime (say, looking at modaliases or introducing some other mechanism), is to be able to catch issues where a config was renamed or a driver moved across configs, and the .config used by the kernel not updated accordingly. We need to parse the source to find all compatibles present in the kernel independent of the current config being run. [1] https://github.com/kernelci/bootrr Changes in v2: - Extended dt-extract-compatibles script to be able to extract driver matching compatibles, instead of adding a new one in Coccinelle - Made kselftest output in the KTAP format Nícolas F. R. A. Prado (3): dt: dt-extract-compatibles: Handle cfile arguments in generator function dt: dt-extract-compatibles: Add flag for driver matching compatibles kselftest: Add new test for detecting unprobed Devicetree devices scripts/dtc/dt-extract-compatibles | 74 +++++++++++++---- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/dt/.gitignore | 1 + tools/testing/selftests/dt/Makefile | 21 +++++ .../selftests/dt/compatible_ignore_list | 1 + tools/testing/selftests/dt/ktap_helpers.sh | 57 +++++++++++++ .../selftests/dt/test_unprobed_devices.sh | 79 +++++++++++++++++++ 7 files changed, 218 insertions(+), 16 deletions(-) create mode 100644 tools/testing/selftests/dt/.gitignore create mode 100644 tools/testing/selftests/dt/Makefile create mode 100644 tools/testing/selftests/dt/compatible_ignore_list create mode 100644 tools/testing/selftests/dt/ktap_helpers.sh create mode 100755 tools/testing/selftests/dt/test_unprobed_devices.sh -- 2.41.0

8 months, 3 weeks

4
7
0 0

[PATCH v2 1/2] selftests: Provide local define of min() and max()

by Mahmoud Maatuq

to avoid manual calculation of min and max values and fix coccinelle warnings such WARNING opportunity for min()/max() adding one common definition that could be used in multiple files under selftests. there are also some defines for min/max scattered locally inside sources under selftests. this also prepares for cleaning up those redundant defines and include kselftest.h instead. Signed-off-by: Mahmoud Maatuq <mahmoudmatook.mm(a)gmail.com> Suggested-by: David Laight <David.Laight(a)aculab.com> --- changes in v2: redefine min/max in a more strict way to avoid signedness mismatch and multiple evaluation. is_signed_type() moved from selftests/kselftest_harness.h to selftests/kselftest.h. --- tools/testing/selftests/kselftest.h | 24 +++++++++++++++++++++ tools/testing/selftests/kselftest_harness.h | 2 -- 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/kselftest.h b/tools/testing/selftests/kselftest.h index 829be379545a..93d029471cc9 100644 --- a/tools/testing/selftests/kselftest.h +++ b/tools/testing/selftests/kselftest.h @@ -55,6 +55,30 @@ #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) #endif +#ifndef is_signed_type +#define is_signed_type(var) (!!(((__typeof__(var))(-1)) < (__typeof__(var))1)) +#endif + +#ifndef min +#define min(x, y) ({ \ + _Static_assert(is_signed_type(typeof(x)) == is_signed_type(typeof(y)), \ + "min: signedness mismatch"); \ + typeof(x) _x = (x); \ + typeof(y) _y = (y); \ + _x < _y ? _x : _y; \ +}) +#endif + +#ifndef max +#define max(x, y) ({ \ + _Static_assert(is_signed_type(typeof(x)) == is_signed_type(typeof(y)), \ + "max: signedness mismatch"); \ + typeof(x) _x = (x); \ + typeof(y) _y = (y); \ + _x > _y ? _x : _y; \ +}) +#endif + /* * gcc cpuid.h provides __cpuid_count() since v4.4. * Clang/LLVM cpuid.h provides __cpuid_count() since v3.4.0. diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h index 5fd49ad0c696..e4e310815226 100644 --- a/tools/testing/selftests/kselftest_harness.h +++ b/tools/testing/selftests/kselftest_harness.h @@ -699,8 +699,6 @@ if (_metadata->passed && _metadata->step < 253) \ _metadata->step++; -#define is_signed_type(var) (!!(((__typeof__(var))(-1)) < (__typeof__(var))1)) - #define __EXPECT(_expected, _expected_str, _seen, _seen_str, _t, _assert) do { \ /* Avoid multiple evaluation of the cases */ \ __typeof__(_expected) __exp = (_expected); \ -- 2.34.1

8 months, 3 weeks

5
8
0 0

[PATCH 4.14 34/57] test_firmware: prevent race conditions by a correct implementation of locking

by Greg Kroah-Hartman

4.14-stable review patch. If anyone has any objections, please let me know. ------------------ From: Mirsad Goran Todorovac <mirsad.todorovac(a)alu.unizg.hr> commit 4acfe3dfde685a5a9eaec5555351918e2d7266a1 upstream. Dan Carpenter spotted a race condition in a couple of situations like these in the test_firmware driver: static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { u8 val; int ret; ret = kstrtou8(buf, 10, &val); if (ret) return ret; mutex_lock(&test_fw_mutex); *(u8 *)cfg = val; mutex_unlock(&test_fw_mutex); /* Always return full write size even if we didn't consume all */ return size; } static ssize_t config_num_requests_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int rc; mutex_lock(&test_fw_mutex); if (test_fw_config->reqs) { pr_err("Must call release_all_firmware prior to changing config\n"); rc = -EINVAL; mutex_unlock(&test_fw_mutex); goto out; } mutex_unlock(&test_fw_mutex); rc = test_dev_config_update_u8(buf, count, &test_fw_config->num_requests); out: return rc; } static ssize_t config_read_fw_idx_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return test_dev_config_update_u8(buf, count, &test_fw_config->read_fw_idx); } The function test_dev_config_update_u8() is called from both the locked and the unlocked context, function config_num_requests_store() and config_read_fw_idx_store() which can both be called asynchronously as they are driver's methods, while test_dev_config_update_u8() and siblings change their argument pointed to by u8 *cfg or similar pointer. To avoid deadlock on test_fw_mutex, the lock is dropped before calling test_dev_config_update_u8() and re-acquired within test_dev_config_update_u8() itself, but alas this creates a race condition. Having two locks wouldn't assure a race-proof mutual exclusion. This situation is best avoided by the introduction of a new, unlocked function __test_dev_config_update_u8() which can be called from the locked context and reducing test_dev_config_update_u8() to: static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { int ret; mutex_lock(&test_fw_mutex); ret = __test_dev_config_update_u8(buf, size, cfg); mutex_unlock(&test_fw_mutex); return ret; } doing the locking and calling the unlocked primitive, which enables both locked and unlocked versions without duplication of code. The similar approach was applied to all functions called from the locked and the unlocked context, which safely mitigates both deadlocks and race conditions in the driver. __test_dev_config_update_bool(), __test_dev_config_update_u8() and __test_dev_config_update_size_t() unlocked versions of the functions were introduced to be called from the locked contexts as a workaround without releasing the main driver's lock and thereof causing a race condition. The test_dev_config_update_bool(), test_dev_config_update_u8() and test_dev_config_update_size_t() locked versions of the functions are being called from driver methods without the unnecessary multiplying of the locking and unlocking code for each method, and complicating the code with saving of the return value across lock. Fixes: 7feebfa487b92 ("test_firmware: add support for request_firmware_into_buf") Cc: Luis Chamberlain <mcgrof(a)kernel.org> Cc: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> Cc: Russ Weight <russell.h.weight(a)intel.com> Cc: Takashi Iwai <tiwai(a)suse.de> Cc: Tianfei Zhang <tianfei.zhang(a)intel.com> Cc: Shuah Khan <shuah(a)kernel.org> Cc: Colin Ian King <colin.i.king(a)gmail.com> Cc: Randy Dunlap <rdunlap(a)infradead.org> Cc: linux-kselftest(a)vger.kernel.org Cc: stable(a)vger.kernel.org # v5.4 Suggested-by: Dan Carpenter <error27(a)gmail.com> Signed-off-by: Mirsad Goran Todorovac <mirsad.todorovac(a)alu.unizg.hr> Link: https://lore.kernel.org/r/20230509084746.48259-1-mirsad.todorovac@alu.unizg… Signed-off-by: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> --- lib/test_firmware.c | 37 ++++++++++++++++++++++++++++--------- 1 file changed, 28 insertions(+), 9 deletions(-) --- a/lib/test_firmware.c +++ b/lib/test_firmware.c @@ -283,16 +283,26 @@ static ssize_t config_test_show_str(char return len; } -static int test_dev_config_update_bool(const char *buf, size_t size, - bool *cfg) +static inline int __test_dev_config_update_bool(const char *buf, size_t size, + bool *cfg) { int ret; - mutex_lock(&test_fw_mutex); if (strtobool(buf, cfg) < 0) ret = -EINVAL; else ret = size; + + return ret; +} + +static int test_dev_config_update_bool(const char *buf, size_t size, + bool *cfg) +{ + int ret; + + mutex_lock(&test_fw_mutex); + ret = __test_dev_config_update_bool(buf, size, cfg); mutex_unlock(&test_fw_mutex); return ret; @@ -322,7 +332,7 @@ static ssize_t test_dev_config_show_int( return snprintf(buf, PAGE_SIZE, "%d\n", val); } -static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) +static inline int __test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { int ret; long new; @@ -334,14 +344,23 @@ static int test_dev_config_update_u8(con if (new > U8_MAX) return -EINVAL; - mutex_lock(&test_fw_mutex); *(u8 *)cfg = new; - mutex_unlock(&test_fw_mutex); /* Always return full write size even if we didn't consume all */ return size; } +static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) +{ + int ret; + + mutex_lock(&test_fw_mutex); + ret = __test_dev_config_update_u8(buf, size, cfg); + mutex_unlock(&test_fw_mutex); + + return ret; +} + static ssize_t test_dev_config_show_u8(char *buf, u8 cfg) { u8 val; @@ -374,10 +393,10 @@ static ssize_t config_num_requests_store mutex_unlock(&test_fw_mutex); goto out; } - mutex_unlock(&test_fw_mutex); - rc = test_dev_config_update_u8(buf, count, - &test_fw_config->num_requests); + rc = __test_dev_config_update_u8(buf, count, + &test_fw_config->num_requests); + mutex_unlock(&test_fw_mutex); out: return rc;

8 months, 3 weeks

1
0
0 0

[PATCH 4.19 071/129] test_firmware: prevent race conditions by a correct implementation of locking

by Greg Kroah-Hartman

4.19-stable review patch. If anyone has any objections, please let me know. ------------------ From: Mirsad Goran Todorovac <mirsad.todorovac(a)alu.unizg.hr> commit 4acfe3dfde685a5a9eaec5555351918e2d7266a1 upstream. Dan Carpenter spotted a race condition in a couple of situations like these in the test_firmware driver: static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { u8 val; int ret; ret = kstrtou8(buf, 10, &val); if (ret) return ret; mutex_lock(&test_fw_mutex); *(u8 *)cfg = val; mutex_unlock(&test_fw_mutex); /* Always return full write size even if we didn't consume all */ return size; } static ssize_t config_num_requests_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int rc; mutex_lock(&test_fw_mutex); if (test_fw_config->reqs) { pr_err("Must call release_all_firmware prior to changing config\n"); rc = -EINVAL; mutex_unlock(&test_fw_mutex); goto out; } mutex_unlock(&test_fw_mutex); rc = test_dev_config_update_u8(buf, count, &test_fw_config->num_requests); out: return rc; } static ssize_t config_read_fw_idx_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return test_dev_config_update_u8(buf, count, &test_fw_config->read_fw_idx); } The function test_dev_config_update_u8() is called from both the locked and the unlocked context, function config_num_requests_store() and config_read_fw_idx_store() which can both be called asynchronously as they are driver's methods, while test_dev_config_update_u8() and siblings change their argument pointed to by u8 *cfg or similar pointer. To avoid deadlock on test_fw_mutex, the lock is dropped before calling test_dev_config_update_u8() and re-acquired within test_dev_config_update_u8() itself, but alas this creates a race condition. Having two locks wouldn't assure a race-proof mutual exclusion. This situation is best avoided by the introduction of a new, unlocked function __test_dev_config_update_u8() which can be called from the locked context and reducing test_dev_config_update_u8() to: static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { int ret; mutex_lock(&test_fw_mutex); ret = __test_dev_config_update_u8(buf, size, cfg); mutex_unlock(&test_fw_mutex); return ret; } doing the locking and calling the unlocked primitive, which enables both locked and unlocked versions without duplication of code. The similar approach was applied to all functions called from the locked and the unlocked context, which safely mitigates both deadlocks and race conditions in the driver. __test_dev_config_update_bool(), __test_dev_config_update_u8() and __test_dev_config_update_size_t() unlocked versions of the functions were introduced to be called from the locked contexts as a workaround without releasing the main driver's lock and thereof causing a race condition. The test_dev_config_update_bool(), test_dev_config_update_u8() and test_dev_config_update_size_t() locked versions of the functions are being called from driver methods without the unnecessary multiplying of the locking and unlocking code for each method, and complicating the code with saving of the return value across lock. Fixes: 7feebfa487b92 ("test_firmware: add support for request_firmware_into_buf") Cc: Luis Chamberlain <mcgrof(a)kernel.org> Cc: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> Cc: Russ Weight <russell.h.weight(a)intel.com> Cc: Takashi Iwai <tiwai(a)suse.de> Cc: Tianfei Zhang <tianfei.zhang(a)intel.com> Cc: Shuah Khan <shuah(a)kernel.org> Cc: Colin Ian King <colin.i.king(a)gmail.com> Cc: Randy Dunlap <rdunlap(a)infradead.org> Cc: linux-kselftest(a)vger.kernel.org Cc: stable(a)vger.kernel.org # v5.4 Suggested-by: Dan Carpenter <error27(a)gmail.com> Signed-off-by: Mirsad Goran Todorovac <mirsad.todorovac(a)alu.unizg.hr> Link: https://lore.kernel.org/r/20230509084746.48259-1-mirsad.todorovac@alu.unizg… Signed-off-by: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> --- lib/test_firmware.c | 37 ++++++++++++++++++++++++++++--------- 1 file changed, 28 insertions(+), 9 deletions(-) --- a/lib/test_firmware.c +++ b/lib/test_firmware.c @@ -284,16 +284,26 @@ static ssize_t config_test_show_str(char return len; } -static int test_dev_config_update_bool(const char *buf, size_t size, - bool *cfg) +static inline int __test_dev_config_update_bool(const char *buf, size_t size, + bool *cfg) { int ret; - mutex_lock(&test_fw_mutex); if (strtobool(buf, cfg) < 0) ret = -EINVAL; else ret = size; + + return ret; +} + +static int test_dev_config_update_bool(const char *buf, size_t size, + bool *cfg) +{ + int ret; + + mutex_lock(&test_fw_mutex); + ret = __test_dev_config_update_bool(buf, size, cfg); mutex_unlock(&test_fw_mutex); return ret; @@ -323,7 +333,7 @@ static ssize_t test_dev_config_show_int( return snprintf(buf, PAGE_SIZE, "%d\n", val); } -static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) +static inline int __test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { int ret; long new; @@ -335,14 +345,23 @@ static int test_dev_config_update_u8(con if (new > U8_MAX) return -EINVAL; - mutex_lock(&test_fw_mutex); *(u8 *)cfg = new; - mutex_unlock(&test_fw_mutex); /* Always return full write size even if we didn't consume all */ return size; } +static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) +{ + int ret; + + mutex_lock(&test_fw_mutex); + ret = __test_dev_config_update_u8(buf, size, cfg); + mutex_unlock(&test_fw_mutex); + + return ret; +} + static ssize_t test_dev_config_show_u8(char *buf, u8 cfg) { u8 val; @@ -375,10 +394,10 @@ static ssize_t config_num_requests_store mutex_unlock(&test_fw_mutex); goto out; } - mutex_unlock(&test_fw_mutex); - rc = test_dev_config_update_u8(buf, count, - &test_fw_config->num_requests); + rc = __test_dev_config_update_u8(buf, count, + &test_fw_config->num_requests); + mutex_unlock(&test_fw_mutex); out: return rc;

8 months, 3 weeks

1
0
0 0

[PATCH 5.15 1/2] torture: Avoid torture-test reboot loops

by Joel Fernandes (Google)

From: "Paul E. McKenney" <paulmck(a)kernel.org> [ Upstream commit 10f84c2cfb5045e37d78cb5d4c8e8321e06ae18f ] Currently, the various torture tests sometimes react to an early-boot bug by rebooting. This is almost always counterproductive, needlessly consuming CPU time and bloating the console log. This commit therefore adds the "-no-reboot" argument to qemu so that reboot requests will cause qemu to exit. Signed-off-by: Paul E. McKenney <paulmck(a)kernel.org> Signed-off-by: Joel Fernandes (Google) <joel(a)joelfernandes.org> --- tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh index f4c8055dbf7a..c57be9563214 100755 --- a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh +++ b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh @@ -9,9 +9,10 @@ # # Usage: kvm-test-1-run.sh config resdir seconds qemu-args boot_args_in # -# qemu-args defaults to "-enable-kvm -nographic", along with arguments -# specifying the number of CPUs and other options -# generated from the underlying CPU architecture. +# qemu-args defaults to "-enable-kvm -nographic -no-reboot", along with +# arguments specifying the number of CPUs and +# other options generated from the underlying +# CPU architecture. # boot_args_in defaults to value returned by the per_version_boot_params # shell function. # @@ -141,7 +142,7 @@ then fi # Generate -smp qemu argument. -qemu_args="-enable-kvm -nographic $qemu_args" +qemu_args="-enable-kvm -nographic -no-reboot $qemu_args" cpu_count=`configNR_CPUS.sh $resdir/ConfigFragment` cpu_count=`configfrag_boot_cpus "$boot_args_in" "$config_template" "$cpu_count"` if test "$cpu_count" -gt "$TORTURE_ALLOTED_CPUS" -- 2.42.0.rc1.204.g551eb34607-goog

8 months, 3 weeks

3
3
0 0

[PATCH net-next,v3] selftests: bonding: create directly devices in the target namespaces

by Zhengchao Shao

If failed to set link1_1 to netns client, we should delete link1_1 in the cleanup path. But if set link1_1 to netns client successfully, delete link1_1 will report warning. So it will be safer creating directly the devices in the target namespaces. Reported-by: Hangbin Liu <liuhangbin(a)gmail.com> Closes: https://lore.kernel.org/all/ZNyJx1HtXaUzOkNA@Laptop-X1/ Signed-off-by: Zhengchao Shao <shaozhengchao(a)huawei.com> --- v3: create the eth0 in the namespace v2: create directly devices in the target namespaces --- .../drivers/net/bonding/bond-arp-interval-causes-panic.sh | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/tools/testing/selftests/drivers/net/bonding/bond-arp-interval-causes-panic.sh b/tools/testing/selftests/drivers/net/bonding/bond-arp-interval-causes-panic.sh index 7b2d421f09cf..4917dbb35a44 100755 --- a/tools/testing/selftests/drivers/net/bonding/bond-arp-interval-causes-panic.sh +++ b/tools/testing/selftests/drivers/net/bonding/bond-arp-interval-causes-panic.sh @@ -22,14 +22,12 @@ server_ip4=192.168.1.254 echo 180 >/proc/sys/kernel/panic # build namespaces -ip link add dev link1_1 type veth peer name link1_2 - ip netns add "server" -ip link set dev link1_2 netns server up name eth0 +ip netns add "client" +ip -n client link add eth0 type veth peer name eth0 netns server +ip netns exec server ip link set dev eth0 up ip netns exec server ip addr add ${server_ip4}/24 dev eth0 -ip netns add "client" -ip link set dev link1_1 netns client down name eth0 ip netns exec client ip link add dev bond0 down type bond mode 1 \ miimon 100 all_slaves_active 1 ip netns exec client ip link set dev eth0 down master bond0 -- 2.34.1

8 months, 3 weeks

3
2
0 0

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror August 2023