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

selftests: user_events: Test terminated by assertion

by Naresh Kamboju

The selftests: user_events tests failed on all devices and all architectures. Test log: --------- kselftest: Running tests in user_events TAP version 13 1..4 # timeout set to 90 # selftests: user_events: ftrace_test # TAP version 13 # 1..6 # # Starting 6 tests from 1 test cases. # # RUN user.register_events ... # # ftrace_test.c:210:register_events:Expected -1 (-1) != self->status_fd (-1) # # register_events: Test terminated by assertion # # FAIL user.register_events # not ok 1 user.register_events # # RUN user.write_events ... # # ftrace_test.c:210:write_events:Expected -1 (-1) != self->status_fd (-1) # # write_events: Test terminated by assertion # # FAIL user.write_events # not ok 2 user.write_events # # RUN user.write_empty_events ... # # ftrace_test.c:210:write_empty_events:Expected -1 (-1) != self->status_fd (-1) # # write_empty_events: Test terminated by assertion # # FAIL user.write_empty_events # not ok 3 user.write_empty_events # # RUN user.write_fault ... # # ftrace_test.c:210:write_fault:Expected -1 (-1) != self->status_fd (-1) # # write_fault: Test terminated by assertion # # FAIL user.write_fault # not ok 4 user.write_fault # # RUN user.write_validator ... # # ftrace_test.c:210:write_validator:Expected -1 (-1) != self->status_fd (-1) # # write_validator: Test terminated by assertion # # FAIL user.write_validator # not ok 5 user.write_validator # # RUN user.print_fmt ... # # ftrace_test.c:210:print_fmt:Expected -1 (-1) != self->status_fd (-1) # # print_fmt: Test terminated by assertion # # FAIL user.print_fmt # not ok 6 user.print_fmt # # FAILED: 0 / 6 tests passed. # # Totals: pass:0 fail:6 xfail:0 xpass:0 skip:0 error:0 not ok 1 selftests: user_events: ftrace_test # exit=1 # timeout set to 90 # selftests: user_events: dyn_test # TAP version 13 # 1..4 # # Starting 4 tests from 1 test cases. # # RUN user.basic_types ... # # dyn_test.c:157:basic_types:Expected -1 (-1) != parse(&self->check, \"u:__test_event u64 a\") (-1) # # basic_types: Test terminated by assertion # # FAIL user.basic_types # not ok 1 user.basic_types # # RUN user.loc_types ... # # dyn_test.c:181:loc_types:Expected -1 (-1) != parse(&self->check, \"u:__test_event __data_loc char[] a\") (-1) # # loc_types: Test terminated by assertion # # FAIL user.loc_types # not ok 2 user.loc_types # # RUN user.size_types ... # # dyn_test.c:189:size_types:Expected -1 (-1) != parse(&self->check, \"u:__test_event struct custom a 20\") (-1) # # size_types: Test terminated by assertion # # FAIL user.size_types # not ok 3 user.size_types # # RUN user.matching ... # # dyn_test.c:199:matching:Expected -1 (-1) != check_match(&self->check, \"__test_event u32 a\", \"__test_event u32 a\", &match) (-1) # # matching: Test terminated by assertion # # FAIL user.matching # not ok 4 user.matching # # FAILED: 0 / 4 tests passed. # # Totals: pass:0 fail:4 xfail:0 xpass:0 skip:0 error:0 not ok 2 selftests: user_events: dyn_test # exit=1 # timeout set to 90 # selftests: user_events: perf_test # TAP version 13 # 1..2 # # Starting 2 tests from 1 test cases. # # RUN user.perf_write ... # # perf_test.c:117:perf_write:Expected -1 (-1) != self->data_fd (-1) # # perf_write: Test terminated by assertion # # FAIL user.perf_write # not ok 1 user.perf_write # # RUN user.perf_empty_events ... # # perf_test.c:117:perf_empty_events:Expected -1 (-1) != self->data_fd (-1) # # perf_empty_events: Test terminated by assertion # # FAIL user.perf_empty_events # not ok 2 user.perf_empty_events # # FAILED: 0 / 2 tests passed. # # Totals: pass:0 fail:2 xfail:0 xpass:0 skip:0 error:0 not ok 3 selftests: user_events: perf_test # exit=1 # timeout set to 90 # selftests: user_events: abi_test # TAP version 13 # 1..4 # # Starting 4 tests from 1 test cases. # # RUN user.enablement ... # # abi_test.c:106:enablement:Expected 0 (0) == reg_enable(&self->check, sizeof(int), 0) (-1) # # enablement: Test terminated by assertion # # FAIL user.enablement # not ok 1 user.enablement # # RUN user.bit_sizes ... # # abi_test.c:126:bit_sizes:Expected 0 (0) == reg_enable(&self->check, sizeof(int), 0) (-1) # # bit_sizes: Test terminated by assertion # # FAIL user.bit_sizes # not ok 2 user.bit_sizes # # RUN user.forks ... # # abi_test.c:154:forks:Expected 0 (0) == reg_enable(&self->check, sizeof(int), 0) (-1) # # forks: Test terminated by assertion # # FAIL user.forks # not ok 3 user.forks # # RUN user.clones ... # # abi_test.c:212:clones:Expected 0 (0) == reg_enable(&self->check, sizeof(int), 0) (-1) # # clones: Test terminated by assertion # # FAIL user.clones # not ok 4 user.clones # # FAILED: 0 / 4 tests passed. # # Totals: pass:0 fail:4 xfail:0 xpass:0 skip:0 error:0 not ok 4 selftests: user_events: abi_test # exit=1 Links: - https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20230906/te… - https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20230906/te… - https://storage.tuxsuite.com/public/linaro/lkft/builds/2V0Oq00RB2Cvog83Dw4G… -- Linaro LKFT https://lkft.linaro.org

2 years, 2 months

1
0
0 0

Re: [Intel-xe] [PATCH 2/3] drm/tests/drm_exec: Add a test for object freeing within drm_exec_fini()

by Maxime Ripard

On Tue, Sep 05, 2023 at 03:42:58PM +0200, Thomas Hellström wrote: > Hi, Maxime > > On 9/5/23 15:16, Maxime Ripard wrote: > > On Tue, Sep 05, 2023 at 02:32:38PM +0200, Thomas Hellström wrote: > > > Hi, > > > > > > On 9/5/23 14:05, Maxime Ripard wrote: > > > > Hi, > > > > > > > > On Tue, Sep 05, 2023 at 10:58:31AM +0200, Thomas Hellström wrote: > > > > > Check that object freeing from within drm_exec_fini() works as expected > > > > > and doesn't generate any warnings. > > > > > > > > > > Cc: Christian König <christian.koenig(a)amd.com> > > > > > Cc: dri-devel(a)lists.freedesktop.org > > > > > Signed-off-by: Thomas Hellström <thomas.hellstrom(a)linux.intel.com> > > > > > --- > > > > > drivers/gpu/drm/tests/drm_exec_test.c | 47 +++++++++++++++++++++++++++ > > > > > 1 file changed, 47 insertions(+) > > > > > > > > > > diff --git a/drivers/gpu/drm/tests/drm_exec_test.c b/drivers/gpu/drm/tests/drm_exec_test.c > > > > > index 563949d777dd..294c25f49cc7 100644 > > > > > --- a/drivers/gpu/drm/tests/drm_exec_test.c > > > > > +++ b/drivers/gpu/drm/tests/drm_exec_test.c > > > > > @@ -170,6 +170,52 @@ static void test_prepare_array(struct kunit *test) > > > > > drm_gem_private_object_fini(&gobj2); > > > > > } > > > > > +static const struct drm_gem_object_funcs put_funcs = { > > > > > + .free = (void *)kfree, > > > > > +}; > > > > > + > > > > > +/* > > > > > + * Check that freeing objects from within drm_exec_fini() > > > > > + * behaves as expected. > > > > > + */ > > > > > +static void test_early_put(struct kunit *test) > > > > > +{ > > > > > + struct drm_exec_priv *priv = test->priv; > > > > > + struct drm_gem_object *gobj1; > > > > > + struct drm_gem_object *gobj2; > > > > > + struct drm_gem_object *array[2]; > > > > > + struct drm_exec exec; > > > > > + int ret; > > > > > + > > > > > + gobj1 = kzalloc(sizeof(*gobj1), GFP_KERNEL); > > > > > + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, gobj1); > > > > > + if (!gobj1) > > > > > + return; > > > > > + > > > > > + gobj2 = kzalloc(sizeof(*gobj2), GFP_KERNEL); > > > > > + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, gobj2); > > > > > + if (!gobj2) { > > > > > + kfree(gobj1); > > > > > + return; > > > > > + } > > > > > + > > > > > + gobj1->funcs = &put_funcs; > > > > > + gobj2->funcs = &put_funcs; > > > > > + array[0] = gobj1; > > > > > + array[1] = gobj2; > > > > > + drm_gem_private_object_init(priv->drm, gobj1, PAGE_SIZE); > > > > > + drm_gem_private_object_init(priv->drm, gobj2, PAGE_SIZE); > > > > > + > > > > > + drm_exec_init(&exec, DRM_EXEC_INTERRUPTIBLE_WAIT); > > > > > + drm_exec_until_all_locked(&exec) > > > > > + ret = drm_exec_prepare_array(&exec, array, ARRAY_SIZE(array), > > > > > + 1); > > > > > + KUNIT_EXPECT_EQ(test, ret, 0); > > > > > + drm_gem_object_put(gobj1); > > > > > + drm_gem_object_put(gobj2); > > > > > + drm_exec_fini(&exec); > > > > It doesn't look like you actually check that "freeing objects from > > > > within drm_exec_fini() behaves as expected." What is the expectation > > > > here, and how is it checked? > > > Hm. Good question, I've been manually checking dmesg for lockdep splats. Is > > > there a way to automate that? > > I'm not familiar with the drm_exec API, but judging by the code I'd > > assume you want to check that gobj1 and gobj2 are actually freed using > > kfree? > > Actually not. What's important here is that the call to drm_exec_fini(), > which puts the last references to gobj1 and gobj2 doesn't trigger any > lockdep splats, like the one in the commit message of patch 3/3. So to make > more sense, the test could perhaps be conditioned on > CONFIG_DEBUG_LOCK_ALLOC. Still it would require manual checking of dmesg() > after being run. I'm not aware of something to check on lockdep's status when running a kunit test, but I'm not sure anyone is expected to look at the dmesg trace when running kunit to find out whether the test succeeded or not. It looks like there was an attempt at some point to fail the test if there was a lockdep error: https://lore.kernel.org/all/20200814205527.1833459-1-urielguajardojr@gmail.… It doesn't look like it's been merged though. David, Brendan, do you know why it wasn't merged or if there is a good option for us there? At the very least, I think a comment after the call to drm_exec_fini to make it clear that the error would be in the kernel logs, and a better one on the test definition to explicitly say what you want to make sure of, and how one can check it's been done would be great. Maxime

2 years, 2 months

1
0
0 0

[PATCH 1/2] kunit: add parameter generation macro using description from array

by benjamin＠sipsolutions.net

From: Benjamin Berg <benjamin.berg(a)intel.com> The existing KUNIT_ARRAY_PARAM macro requires a separate function to get the description. However, in a lot of cases the description can just be copied directly from the array. Add a second macro that avoids having to write a static function just for a single strscpy. Signed-off-by: Benjamin Berg <benjamin.berg(a)intel.com> --- Documentation/dev-tools/kunit/usage.rst | 7 ++++--- include/kunit/test.h | 19 +++++++++++++++++++ 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/Documentation/dev-tools/kunit/usage.rst b/Documentation/dev-tools/kunit/usage.rst index c27e1646ecd9..fe8c28d66dfe 100644 --- a/Documentation/dev-tools/kunit/usage.rst +++ b/Documentation/dev-tools/kunit/usage.rst @@ -571,8 +571,9 @@ By reusing the same ``cases`` array from above, we can write the test as a { strcpy(desc, t->str); } - // Creates `sha1_gen_params()` to iterate over `cases`. - KUNIT_ARRAY_PARAM(sha1, cases, case_to_desc); + // Creates `sha1_gen_params()` to iterate over `cases` while using + // the struct member `str` for the case description. + KUNIT_ARRAY_PARAM_DESC(sha1, cases, str); // Looks no different from a normal test. static void sha1_test(struct kunit *test) @@ -588,7 +589,7 @@ By reusing the same ``cases`` array from above, we can write the test as a } // Instead of KUNIT_CASE, we use KUNIT_CASE_PARAM and pass in the - // function declared by KUNIT_ARRAY_PARAM. + // function declared by KUNIT_ARRAY_PARAM or KUNIT_ARRAY_PARAM_DESC. static struct kunit_case sha1_test_cases[] = { KUNIT_CASE_PARAM(sha1_test, sha1_gen_params), {} diff --git a/include/kunit/test.h b/include/kunit/test.h index 68ff01aee244..f60d11e41855 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -1516,6 +1516,25 @@ do { \ return NULL; \ } +/** + * KUNIT_ARRAY_PARAM_DESC() - Define test parameter generator from an array. + * @name: prefix for the test parameter generator function. + * @array: array of test parameters. + * @desc_member: structure member from array element to use as description + * + * Define function @name_gen_params which uses @array to generate parameters. + */ +#define KUNIT_ARRAY_PARAM_DESC(name, array, desc_member) \ + static const void *name##_gen_params(const void *prev, char *desc) \ + { \ + typeof((array)[0]) *__next = prev ? ((typeof(__next)) prev) + 1 : (array); \ + if (__next - (array) < ARRAY_SIZE((array))) { \ + strscpy(desc, __next->desc_member, KUNIT_PARAM_DESC_SIZE); \ + return __next; \ + } \ + return NULL; \ + } + // TODO(dlatypov(a)google.com): consider eventually migrating users to explicitly // include resource.h themselves if they need it. #include <kunit/resource.h> -- 2.41.0

2 years, 2 months

3
5
0 0

[PATCH v2 0/5] memfd: cleanups for vm.memfd_noexec

by Aleksa Sarai

The most critical issue with vm.memfd_noexec=2 (the fact that passing MFD_EXEC would bypass it entirely[1]) has been fixed in Andrew's tree[2], but there are still some outstanding issues that need to be addressed: * vm.memfd_noexec=2 shouldn't reject old-style memfd_create(2) syscalls because it will make it far to difficult to ever migrate. Instead it should imply MFD_EXEC. * The dmesg warnings are pr_warn_once(), which on most systems means that they will be used up by systemd or some other boot process and userspace developers will never see it. - For the !(flags & (MFD_EXEC | MFD_NOEXEC_SEAL)) case, outputting a rate-limited message to the kernel log is necessary to tell userspace that they should add the new flags. Arguably the most ideal way to deal with the spam concern[3,4] while still prompting userspace to switch to the new flags would be to only log the warning once per task or something similar. However, adding something to task_struct for tracking this would be needless bloat for a single pr_warn_ratelimited(). So just switch to pr_info_ratelimited() to avoid spamming the log with something that isn't a real warning. There's lots of info-level stuff in dmesg, it seems really unlikely that this should be an actual problem. Most programs are already switching to the new flags anyway. - For the vm.memfd_noexec=2 case, we need to log a warning for every failure because otherwise userspace will have no idea why their previously working program started returning -EACCES (previously -EINVAL) from memfd_create(2). pr_warn_once() is simply wrong here. * The racheting mechanism for vm.memfd_noexec makes it incredibly unappealing for most users to enable the sysctl because enabling it on &init_pid_ns means you need a system reboot to unset it. Given the actual security threat being protected against, CAP_SYS_ADMIN users being restricted in this way makes little sense. The argument for this ratcheting by the original author was that it allows you to have a hierarchical setting that cannot be unset by child pidnses, but this is not accurate -- changing the parent pidns's vm.memfd_noexec setting to be more restrictive didn't affect children. Instead, switch the vm.memfd_noexec sysctl to be properly hierarchical and allow CAP_SYS_ADMIN users (in the pidns's owning userns) to lower the setting as long as it is not lower than the parent's effective setting. This change also makes it so that changing a parent pidns's vm.memfd_noexec will affect all descendants, providing a properly hierarchical setting. The performance impact of this is incredibly minimal since the maximum depth of pidns is 32 and it is only checked during memfd_create(2) and unshare(CLONE_NEWPID). * The memfd selftests would not exit with a non-zero error code when certain tests that ran in a forked process (specifically the ones related to MFD_EXEC and MFD_NOEXEC_SEAL) failed. [1]: https://lore.kernel.org/all/ZJwcsU0vI-nzgOB_@codewreck.org/ [2]: https://lore.kernel.org/all/20230705063315.3680666-1-jeffxu@google.com/ [3]: https://lore.kernel.org/Y5yS8wCnuYGLHMj4@x1n/ [4]: https://lore.kernel.org/f185bb42-b29c-977e-312e-3349eea15383@linuxfoundatio… Signed-off-by: Aleksa Sarai <cyphar(a)cyphar.com> --- Changes in v2: - Make vm.memfd_noexec restrictions properly hierarchical. - Allow vm.memfd_noexec setting to be lowered by CAP_SYS_ADMIN as long as it is not lower than the parent's effective setting. - Fix the logging behaviour related to the new flags and vm.memfd_noexec=2. - Add more thorough tests for vm.memfd_noexec in selftests. - v1: <https://lore.kernel.org/r/20230713143406.14342-1-cyphar@cyphar.com> --- Aleksa Sarai (5): selftests: memfd: error out test process when child test fails memfd: do not -EACCES old memfd_create() users with vm.memfd_noexec=2 memfd: improve userspace warnings for missing exec-related flags memfd: replace ratcheting feature from vm.memfd_noexec with hierarchy selftests: improve vm.memfd_noexec sysctl tests include/linux/pid_namespace.h | 39 ++-- kernel/pid.c | 3 + kernel/pid_namespace.c | 6 +- kernel/pid_sysctl.h | 28 ++- mm/memfd.c | 33 ++- tools/testing/selftests/memfd/memfd_test.c | 332 +++++++++++++++++++++++------ 6 files changed, 322 insertions(+), 119 deletions(-) --- base-commit: 3ff995246e801ea4de0a30860a1d8da4aeb538e7 change-id: 20230803-memfd-vm-noexec-uapi-fixes-ace725c67b0f Best regards, -- Aleksa Sarai <cyphar(a)cyphar.com>

2 years, 2 months

7
17
0 0

[PATCH bpf-next v10 1/2] 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. At the same time, add APIs: load_kallsyms_local() ksym_search_local() ksym_get_addr_local() There are used to solve the problem of selftests/bpf updating kallsyms after attach new symbols during testmod testing. Acked-by: Stanislav Fomichev <sdf(a)google.com> Signed-off-by: Rong Tao <rongtao(a)cestc.cn> --- v10: Keep the original load_kallsyms(). v9: https://lore.kernel.org/lkml/tencent_254B7015EED7A5D112C45E033DA1822CF107@q… Add load_kallsyms_local,ksym_search_local,ksym_get_addr_local functions. v8: https://lore.kernel.org/lkml/tencent_6D23FE187408D965E95DFAA858BC7E8C760A@q… 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 + .../selftests/bpf/prog_tests/fill_link_info.c | 9 +- .../prog_tests/kprobe_multi_testmod_test.c | 24 ++- tools/testing/selftests/bpf/trace_helpers.c | 137 +++++++++++++----- tools/testing/selftests/bpf/trace_helpers.h | 10 +- 5 files changed, 137 insertions(+), 47 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/tools/testing/selftests/bpf/prog_tests/fill_link_info.c b/tools/testing/selftests/bpf/prog_tests/fill_link_info.c index 9d768e083714..13e618317c8b 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_local(); + if (!ASSERT_OK_PTR(ksyms, "load_kallsyms_local")) goto cleanup; - kprobe_addr = ksym_get_addr(KPROBE_FUNC); + kprobe_addr = ksym_get_addr_local(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_local(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_local(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..532b05ae2da4 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,12 +52,12 @@ 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"); - ASSERT_NEQ(addrs[0], 0, "ksym_get_addr"); - addrs[1] = ksym_get_addr("bpf_testmod_fentry_test2"); - ASSERT_NEQ(addrs[1], 0, "ksym_get_addr"); - addrs[2] = ksym_get_addr("bpf_testmod_fentry_test3"); - ASSERT_NEQ(addrs[2], 0, "ksym_get_addr"); + addrs[0] = ksym_get_addr_local(ksyms, "bpf_testmod_fentry_test1"); + ASSERT_NEQ(addrs[0], 0, "ksym_get_addr_local"); + addrs[1] = ksym_get_addr_local(ksyms, "bpf_testmod_fentry_test2"); + ASSERT_NEQ(addrs[1], 0, "ksym_get_addr_local"); + addrs[2] = ksym_get_addr_local(ksyms, "bpf_testmod_fentry_test3"); + ASSERT_NEQ(addrs[2], 0, "ksym_get_addr_local"); opts.addrs = (const unsigned long *) addrs; opts.cnt = ARRAY_SIZE(addrs); @@ -79,11 +81,19 @@ 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_local(); + if (!ASSERT_OK_PTR(ksyms, "load_kallsyms_local")) return; if (test__start_subtest("testmod_attach_api_syms")) test_testmod_attach_api_syms(); + + ksyms = load_kallsyms_refresh(ksyms); + if (!ASSERT_OK_PTR(ksyms, "load_kallsyms_refresh")) + return; + if (test__start_subtest("testmod_attach_api_addrs")) test_testmod_attach_api_addrs(); + + free_kallsyms_local(ksyms); } diff --git a/tools/testing/selftests/bpf/trace_helpers.c b/tools/testing/selftests/bpf/trace_helpers.c index f83d9f65c65b..d64c4ef336e1 100644 --- a/tools/testing/selftests/bpf/trace_helpers.c +++ b/tools/testing/selftests/bpf/trace_helpers.c @@ -14,104 +14,171 @@ #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 struct ksyms *ksyms; + +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_local(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_local(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_local(ksyms); + return NULL; +} + +struct ksyms *load_kallsyms_local(void) +{ + return load_kallsyms_refresh(NULL); } int load_kallsyms(void) { - /* - * This is called/used from multiplace places, - * load symbols just once. - */ - if (sym_cnt) - return 0; - return load_kallsyms_refresh(); + if (!ksyms) + ksyms = load_kallsyms_local(); + return ksyms ? 0 : 1; } -struct ksym *ksym_search(long key) +struct ksym *ksym_search_local(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) +struct ksym *ksym_search(long key) +{ + if (!ksyms) + return NULL; + return ksym_search_local(ksyms, key); +} + +long ksym_get_addr_local(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; } +long ksym_get_addr(const char *name) +{ + if (!ksyms) + return 0; + return ksym_get_addr_local(ksyms, name); +} + /* open kallsyms and read symbol addresses on the fly. Without caching all symbols, * this is faster than load + find. */ diff --git a/tools/testing/selftests/bpf/trace_helpers.h b/tools/testing/selftests/bpf/trace_helpers.h index 876f3e711df6..1449a107240c 100644 --- a/tools/testing/selftests/bpf/trace_helpers.h +++ b/tools/testing/selftests/bpf/trace_helpers.h @@ -11,13 +11,19 @@ struct ksym { long addr; char *name; }; +struct ksyms; int load_kallsyms(void); -int load_kallsyms_refresh(void); - struct ksym *ksym_search(long key); long ksym_get_addr(const char *name); +struct ksyms *load_kallsyms_local(void); +struct ksym *ksym_search_local(struct ksyms *ksyms, long key); +long ksym_get_addr_local(struct ksyms *ksyms, const char *name); + +struct ksyms *load_kallsyms_refresh(struct ksyms *ksyms); +void free_kallsyms_local(struct ksyms *ksyms); + /* 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

2 years, 2 months

2
2
0 0

[PATCH bpf-next v11 2/2] selftests/bpf: trace_helpers.c: Add a global ksyms initialization mutex

by Rong Tao

From: Rong Tao <rongtao(a)cestc.cn> As Jirka said [0], we just need to make sure that global ksyms initialization won't race. [0] https://lore.kernel.org/lkml/ZPCbAs3ItjRd8XVh@krava/ Signed-off-by: Rong Tao <rongtao(a)cestc.cn> --- tools/testing/selftests/bpf/trace_helpers.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tools/testing/selftests/bpf/trace_helpers.c b/tools/testing/selftests/bpf/trace_helpers.c index 7d026c128252..411f87d5aac7 100644 --- a/tools/testing/selftests/bpf/trace_helpers.c +++ b/tools/testing/selftests/bpf/trace_helpers.c @@ -7,6 +7,7 @@ #include <errno.h> #include <fcntl.h> #include <poll.h> +#include <pthread.h> #include <unistd.h> #include <linux/perf_event.h> #include <sys/mman.h> @@ -26,6 +27,7 @@ struct ksyms { }; static struct ksyms *ksyms; +static pthread_mutex_t ksyms_mutex = PTHREAD_MUTEX_INITIALIZER; static int ksyms__add_symbol(struct ksyms *ksyms, const char *name, unsigned long addr) @@ -110,8 +112,10 @@ struct ksyms *load_kallsyms_local(struct ksyms *ksyms) int load_kallsyms(void) { + pthread_mutex_lock(&ksyms_mutex); if (!ksyms) ksyms = load_kallsyms_local(NULL); + pthread_mutex_unlock(&ksyms_mutex); return ksyms ? 0 : 1; } -- 2.41.0

2 years, 2 months

1
0
0 0

[PATCH bpf-next v11 0/2] selftests/bpf: Optimize kallsyms cache

by Rong Tao

From: Rong Tao <rongtao(a)cestc.cn> We need to optimize the kallsyms cache, including optimizations for the number of symbols limit, and, some test cases add new kernel symbols (such as testmods) and we need to refresh kallsyms (reload or refresh). Rong Tao (2): selftests/bpf: trace_helpers.c: optimize kallsyms cache selftests/bpf: trace_helpers.c: Add a global ksyms initialization mutex samples/bpf/Makefile | 4 + .../selftests/bpf/prog_tests/fill_link_info.c | 2 +- .../prog_tests/kprobe_multi_testmod_test.c | 20 ++- tools/testing/selftests/bpf/trace_helpers.c | 136 +++++++++++++----- tools/testing/selftests/bpf/trace_helpers.h | 9 +- 5 files changed, 126 insertions(+), 45 deletions(-) -- 2.41.0

2 years, 2 months

1
0
0 0

Don't fill the kernel log with memfd_create messages

by Alex Xu (Hello71)

Hi all, Recently "memfd: improve userspace warnings for missing exec-related flags" was merged. On my system, this is a regression, not an improvement, because the entire 256k kernel log buffer (default on x86) is filled with these warnings and "__do_sys_memfd_create: 122 callbacks suppressed". I haven't investigated too closely, but the most likely cause is Wayland libraries. This is too serious of a consequence for using an old API, especially considering how recently the flags were added. The vast majority of software has not had time to add the flags: glibc does not define the macros until 2.38 which was released less than one month ago, man-pages does not document the flags, and according to Debian Code Search, only systemd, stress-ng, and strace actually pass either of these flags. Furthermore, since old kernels reject unknown flags, it's not just a matter of defining and passing the flag; every program needs to add logic to handle EINVAL and try again. Some other way needs to be found to encourage userspace to add the flags; otherwise, this message will be patched out because the kernel log becomes unusable after running unupdated programs, which will still exist even after upstreams are fixed. In particular, AppImages, flatpaks, snaps, and similar app bundles contain vendored Wayland libraries which can be difficult or impossible to update. Thanks, Alex.

2 years, 2 months

3
2
0 0

[PATCH iproute2-next v3] iplink: bridge: Add support for bridge FDB learning limits

by Johannes Nixdorf

Support setting the FDB limit through ip link. The arguments is: - fdb_max_learned_entries: A 32-bit unsigned integer specifying the maximum number of learned FDB entries, with 0 disabling the limit. Also support reading back the current number of learned FDB entries in the bridge by this count. The returned value's name is: - fdb_n_learned_entries: A 32-bit unsigned integer specifying the current number of learned FDB entries. Example: # ip -d -j -p link show br0 [ { ... "linkinfo": { "info_kind": "bridge", "info_data": { ... "fdb_n_learned_entries": 2, "fdb_max_learned_entries": 0, ... } }, ... } ] # ip link set br0 type bridge fdb_max_learned_entries 1024 # ip -d -j -p link show br0 [ { ... "linkinfo": { "info_kind": "bridge", "info_data": { ... "fdb_n_learned_entries": 2, "fdb_max_learned_entries": 1024, ... } }, ... } ] Signed-off-by: Johannes Nixdorf <jnixdorf-oss(a)avm.de> --- Changes since v2: - Properly split the net-next and iproute2-next threads. (from review) - Changed to *_n_* instead of *_cur_*. (from review) - Use strcmp() instead of matches(). (from review) - Made names in code and documentation consistent. (from review) - Various documentation fixes. (from review) Changes since v1: - Sent out the first corresponding iproute2 patches. net-next v3: https://lore.kernel.org/netdev/20230905-fdb_limit-v3-0-7597cd500a82@avm.de/ v2: https://lore.kernel.org/netdev/20230619071444.14625-1-jnixdorf-oss@avm.de/ v1: https://lore.kernel.org/netdev/20230515085046.4457-1-jnixdorf-oss@avm.de/ --- include/uapi/linux/if_link.h | 2 ++ ip/iplink_bridge.c | 21 +++++++++++++++++++++ man/man8/ip-link.8.in | 10 ++++++++++ 3 files changed, 33 insertions(+) diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h index c2ca7a6add0e..51cf58e3171c 100644 --- a/include/uapi/linux/if_link.h +++ b/include/uapi/linux/if_link.h @@ -508,6 +508,8 @@ enum { IFLA_BR_VLAN_STATS_PER_PORT, IFLA_BR_MULTI_BOOLOPT, IFLA_BR_MCAST_QUERIER_STATE, + IFLA_BR_FDB_N_LEARNED_ENTRIES, + IFLA_BR_FDB_MAX_LEARNED_ENTRIES, __IFLA_BR_MAX, }; diff --git a/ip/iplink_bridge.c b/ip/iplink_bridge.c index 7e4e62c81c0c..f08754618e0f 100644 --- a/ip/iplink_bridge.c +++ b/ip/iplink_bridge.c @@ -34,6 +34,7 @@ static void print_explain(FILE *f) " [ group_fwd_mask MASK ]\n" " [ group_address ADDRESS ]\n" " [ no_linklocal_learn NO_LINKLOCAL_LEARN ]\n" + " [ fdb_max_learned_entries FDB_MAX_LEARNED_ENTRIES ]\n" " [ vlan_filtering VLAN_FILTERING ]\n" " [ vlan_protocol VLAN_PROTOCOL ]\n" " [ vlan_default_pvid VLAN_DEFAULT_PVID ]\n" @@ -168,6 +169,14 @@ static int bridge_parse_opt(struct link_util *lu, int argc, char **argv, bm.optval |= no_ll_learn_bit; else bm.optval &= ~no_ll_learn_bit; + } else if (strcmp(*argv, "fdb_max_learned_entries") == 0) { + __u32 fdb_max_learned_entries; + + NEXT_ARG(); + if (get_u32(&fdb_max_learned_entries, *argv, 0)) + invarg("invalid fdb_max_learned_entries", *argv); + + addattr32(n, 1024, IFLA_BR_FDB_MAX_LEARNED_ENTRIES, fdb_max_learned_entries); } else if (matches(*argv, "fdb_flush") == 0) { addattr(n, 1024, IFLA_BR_FDB_FLUSH); } else if (matches(*argv, "vlan_default_pvid") == 0) { @@ -544,6 +553,18 @@ static void bridge_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[]) if (tb[IFLA_BR_GC_TIMER]) _bridge_print_timer(f, "gc_timer", tb[IFLA_BR_GC_TIMER]); + if (tb[IFLA_BR_FDB_N_LEARNED_ENTRIES]) + print_uint(PRINT_ANY, + "fdb_n_learned_entries", + "fdb_n_learned_entries %u ", + rta_getattr_u32(tb[IFLA_BR_FDB_N_LEARNED_ENTRIES])); + + if (tb[IFLA_BR_FDB_MAX_LEARNED_ENTRIES]) + print_uint(PRINT_ANY, + "fdb_max_learned_entries", + "fdb_max_learned_entries %u ", + rta_getattr_u32(tb[IFLA_BR_FDB_MAX_LEARNED_ENTRIES])); + if (tb[IFLA_BR_VLAN_DEFAULT_PVID]) print_uint(PRINT_ANY, "vlan_default_pvid", diff --git a/man/man8/ip-link.8.in b/man/man8/ip-link.8.in index 7365d0c6b14f..184ae9183712 100644 --- a/man/man8/ip-link.8.in +++ b/man/man8/ip-link.8.in @@ -1630,6 +1630,8 @@ the following additional arguments are supported: ] [ .BI no_linklocal_learn " NO_LINKLOCAL_LEARN " ] [ +.BI fdb_max_learned_entries " FDB_MAX_LEARNED_ENTRIES " +] [ .BI vlan_filtering " VLAN_FILTERING " ] [ .BI vlan_protocol " VLAN_PROTOCOL " @@ -1741,6 +1743,14 @@ or off When disabled, the bridge will not learn from link-local frames (default: enabled). +.BI fdb_max_learned_entries " FDB_MAX_LEARNED_ENTRIES " +- set the maximum number of learned FDB entries. If +.RI ( FDB_MAX_LEARNED_ENTRIES " == 0) " +the feature is disabled. Default is +.BR 0 . +.I FDB_MAX_LEARNED_ENTRIES +is a 32bit unsigned integer. + .BI vlan_filtering " VLAN_FILTERING " - turn VLAN filtering on .RI ( VLAN_FILTERING " > 0) " --- base-commit: 865dd3ab1580092221c73317a844ee65f032c9e8 change-id: 20230905-fdb_limit-ace1467c6a84 Best regards, -- Johannes Nixdorf <jnixdorf-oss(a)avm.de>

2 years, 2 months

1
0
0 0

[PATCH 0/2] fcntl: add fcntl(F_CHECK_ORIGINAL_MEMFD)

by Michal Clapinski

This change introduces a new fcntl to check if an fd points to a memfd's original open fd (the one created by memfd_create). We encountered an issue with migrating memfds in CRIU (checkpoint restore in userspace - it migrates running processes between machines). Imagine a scenario: 1. Create a memfd. By default it's open with O_RDWR and yet one can exec() to it (unlike with regular files, where one would get ETXTBSY). 2. Reopen that memfd with O_RDWR via /proc/self/fd/<fd>. Now those 2 fds are indistinguishable from userspace. You can't exec() to either of them (since the reopen incremented inode->i_writecount) and their /proc/self/fdinfo/ are exactly the same. Unfortunately they are not the same. If you close the second one, the first one becomes exec()able again. If you close the first one, the other doesn't become exec()able. Therefore during migration it does matter which is recreated first and which is reopened but there is no way for CRIU to tell which was first. Michal Clapinski (2): fcntl: add fcntl(F_CHECK_ORIGINAL_MEMFD) selftests: test fcntl(F_CHECK_ORIGINAL_MEMFD) fs/fcntl.c | 3 ++ include/uapi/linux/fcntl.h | 9 ++++++ tools/testing/selftests/memfd/memfd_test.c | 32 ++++++++++++++++++++++ 3 files changed, 44 insertions(+) -- 2.42.0.283.g2d96d420d3-goog

2 years, 2 months

4
8
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror