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

Re: [PATCH v2 01/10] lib/min_heap: Introduce non-inline versions of min heap API functions

by Geert Uytterhoeven

Hi Kuan-Wei, On Sun, Oct 20, 2024 at 6:02 AM Kuan-Wei Chiu <visitorckw(a)gmail.com> wrote: > All current min heap API functions are marked with '__always_inline'. > However, as the number of users increases, inlining these functions > everywhere leads to a increase in kernel size. > > In performance-critical paths, such as when perf events are enabled and > min heap functions are called on every context switch, it is important > to retain the inline versions for optimal performance. To balance this, > the original inline functions are kept, and additional non-inline > versions of the functions have been added in lib/min_heap.c. > > Link: https://lore.kernel.org/20240522161048.8d8bbc7b153b4ecd92c50666@linux-found… > Suggested-by: Andrew Morton <akpm(a)linux-foundation.org> > Signed-off-by: Kuan-Wei Chiu <visitorckw(a)gmail.com> Thanks for your patch, which is now commit 92a8b224b833e82d ("lib/min_heap: introduce non-inline versions of min heap API functions") upstream. > --- a/include/linux/min_heap.h > +++ b/include/linux/min_heap.h > @@ -50,33 +50,33 @@ void __min_heap_init(min_heap_char *heap, void *data, int size) > heap->data = heap->preallocated; > } > > -#define min_heap_init(_heap, _data, _size) \ > - __min_heap_init((min_heap_char *)_heap, _data, _size) > +#define min_heap_init_inline(_heap, _data, _size) \ > + __min_heap_init_inline((min_heap_char *)_heap, _data, _size) Casting macro parameters without any further checks prevents the compiler from detecting silly mistakes. Would it be possible to add safety-nets here and below, using e.g. container_of() or typeof() checks? > --- a/lib/Kconfig > +++ b/lib/Kconfig > @@ -777,3 +777,6 @@ config POLYNOMIAL > > config FIRMWARE_TABLE > bool > + > +config MIN_HEAP > + bool Perhaps tristate? See also below. > --- a/lib/Kconfig.debug > +++ b/lib/Kconfig.debug > @@ -2279,6 +2279,7 @@ config TEST_LIST_SORT > config TEST_MIN_HEAP > tristate "Min heap test" > depends on DEBUG_KERNEL || m > + select MIN_HEAP Ideally, tests should not select functionality, to prevent increasing the attack vector by merely enabling (modular) tests. In this particular case, just using "depends on MIN_HEAP" is not an option, as MIN_HEAP is not user-visible, and thus cannot be enabled by the user on its own. However, making MIN_HEAP tristate could be a first step for the modular case. The builtin case is harder to fix, as e.g. depends on MIN_HEAP || COMPILE_TEST select MIN_HEAP if COMPILE_TEST would still trigger a recursive dependency error. Alternatively, the test could just keep on using the inline variants, unless CONFIG_MIN_HEAP=y? Or event test both for the latter? > help > Enable this to turn on min heap function tests. This test is > executed only once during system boot (so affects only boot time), Gr{oetje,eeting}s, Geert -- Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- geert(a)linux-m68k.org In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that. -- Linus Torvalds

1 year

2
2
0 0

[PATCH v2 0/9] initramfs: kunit tests and cleanups

by David Disseldorp

This patchset adds basic kunit test coverage for initramfs unpacking and cleans up some minor buffer handling issues / inefficiencies. Changes since v2 (patch 2 only): - fix !CONFIG_INITRAMFS_PRESERVE_MTIME kunit test checks - add test MODULE_DESCRIPTION(), as suggested by Jeff Johnson - add some missing headers, reported by kernel test robot Changes since v1 (RFC): - rebase atop v6.12-rc6 and filename field overrun fix from https://lore.kernel.org/r/20241030035509.20194-2-ddiss@suse.de - add unit test coverage (new patches 1 and 2) - add patch: fix hardlink hash leak without TRAILER - rework patch: avoid static buffer for error message + drop unnecessary message propagation - drop patch: cpio_buf reuse for built-in and bootloader initramfs + no good justification for the change Feedback appreciated. David Disseldorp (9): init: add initramfs_internal.h initramfs_test: kunit tests for initramfs unpacking vsprintf: add simple_strntoul initramfs: avoid memcpy for hex header fields initramfs: remove extra symlink path buffer initramfs: merge header_buf and name_buf initramfs: reuse name_len for dir mtime tracking initramfs: fix hardlink hash leak without TRAILER initramfs: avoid static buffer for error message include/linux/kstrtox.h | 1 + init/.kunitconfig | 3 + init/Kconfig | 7 + init/Makefile | 1 + init/initramfs.c | 73 +++++---- init/initramfs_internal.h | 8 + init/initramfs_test.c | 403 ++++++++++++++++++++++++++++++++++++++++++++++ lib/vsprintf.c | 7 + 8 files changed, 471 insertions(+), 32 deletions(-) create mode 100644 init/.kunitconfig create mode 100644 init/initramfs_internal.h create mode 100644 init/initramfs_test.c

1 year

2
11
0 0

[PATCH bpf] selftests/bpf: Check for PREEMPTION instead of PREEMPT

by Sebastian Andrzej Siewior

CONFIG_PREEMPT is a preemtion model the so called "Low-Latency Desktop". A different preemption model is PREEMPT_RT the so called "Real-Time". Both implement preemption in kernel and set CONFIG_PREEMPTION. There is also the so called "LAZY PREEMPT" which the "Scheduler controlled preemption model". Here we have also preemption in the kernel the rules are slightly different. Therefore the testsuite should not check for CONFIG_PREEMPT (as one model) but for CONFIG_PREEMPTION to figure out if preemption in the kernel is possible. Signed-off-by: Sebastian Andrzej Siewior <bigeasy(a)linutronix.de> --- tools/testing/selftests/bpf/map_tests/task_storage_map.c | 4 ++-- tools/testing/selftests/bpf/prog_tests/task_local_storage.c | 2 +- .../testing/selftests/bpf/progs/read_bpf_task_storage_busy.c | 4 ++-- tools/testing/selftests/bpf/progs/task_storage_nodeadlock.c | 4 ++-- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/tools/testing/selftests/bpf/map_tests/task_storage_map.c b/tools/testing/selftests/bpf/map_tests/task_storage_map.c index 7d050364efca1..5fd7c923544c3 100644 --- a/tools/testing/selftests/bpf/map_tests/task_storage_map.c +++ b/tools/testing/selftests/bpf/map_tests/task_storage_map.c @@ -77,8 +77,8 @@ void test_task_storage_map_stress_lookup(void) CHECK(err, "open_and_load", "error %d\n", err); /* Only for a fully preemptible kernel */ - if (!skel->kconfig->CONFIG_PREEMPT) { - printf("%s SKIP (no CONFIG_PREEMPT)\n", __func__); + if (!skel->kconfig->CONFIG_PREEMPTION) { + printf("%s SKIP (no CONFIG_PREEMPTION)\n", __func__); read_bpf_task_storage_busy__destroy(skel); skips++; return; diff --git a/tools/testing/selftests/bpf/prog_tests/task_local_storage.c b/tools/testing/selftests/bpf/prog_tests/task_local_storage.c index c33c05161a9ea..acaeebf83f3ee 100644 --- a/tools/testing/selftests/bpf/prog_tests/task_local_storage.c +++ b/tools/testing/selftests/bpf/prog_tests/task_local_storage.c @@ -189,7 +189,7 @@ static void test_nodeadlock(void) /* Unnecessary recursion and deadlock detection are reproducible * in the preemptible kernel. */ - if (!skel->kconfig->CONFIG_PREEMPT) { + if (!skel->kconfig->CONFIG_PREEMPTION) { test__skip(); goto done; } diff --git a/tools/testing/selftests/bpf/progs/read_bpf_task_storage_busy.c b/tools/testing/selftests/bpf/progs/read_bpf_task_storage_busy.c index 76556e0b42b24..69da05bb6c63e 100644 --- a/tools/testing/selftests/bpf/progs/read_bpf_task_storage_busy.c +++ b/tools/testing/selftests/bpf/progs/read_bpf_task_storage_busy.c @@ -4,7 +4,7 @@ #include <bpf/bpf_helpers.h> #include <bpf/bpf_tracing.h> -extern bool CONFIG_PREEMPT __kconfig __weak; +extern bool CONFIG_PREEMPTION __kconfig __weak; extern const int bpf_task_storage_busy __ksym; char _license[] SEC("license") = "GPL"; @@ -24,7 +24,7 @@ int BPF_PROG(read_bpf_task_storage_busy) { int *value; - if (!CONFIG_PREEMPT) + if (!CONFIG_PREEMPTION) return 0; if (bpf_get_current_pid_tgid() >> 32 != pid) diff --git a/tools/testing/selftests/bpf/progs/task_storage_nodeadlock.c b/tools/testing/selftests/bpf/progs/task_storage_nodeadlock.c index ea2dbb80f7b3e..986829aaf73a6 100644 --- a/tools/testing/selftests/bpf/progs/task_storage_nodeadlock.c +++ b/tools/testing/selftests/bpf/progs/task_storage_nodeadlock.c @@ -10,7 +10,7 @@ char _license[] SEC("license") = "GPL"; #define EBUSY 16 #endif -extern bool CONFIG_PREEMPT __kconfig __weak; +extern bool CONFIG_PREEMPTION __kconfig __weak; int nr_get_errs = 0; int nr_del_errs = 0; @@ -29,7 +29,7 @@ int BPF_PROG(socket_post_create, struct socket *sock, int family, int type, int ret, zero = 0; int *value; - if (!CONFIG_PREEMPT) + if (!CONFIG_PREEMPTION) return 0; task = bpf_get_current_task_btf(); -- 2.45.2

1 year

2
1
0 0

[PATCH bpf-next v3 00/14] selftests/bpf: migrate test_flow_dissector.sh to test_progs

by Alexis Lothoré (eBPF Foundation)

Hello, this is the revision 3 of test_flow_dissector_migration.sh into test_progs. This revision addresses comments from Stanislas, especially about proper reuse of pseudo-header checksuming in new network helpers. There are 2 "main" parts in test_flow_dissector.sh: - a set of tests checking flow_dissector programs attachment to either root namespace or non-root namespace - dissection test The first set is integrated in flow_dissector.c, which already contains some existing tests for flow_dissector programs. This series uses the opportunity to update a bit this file (use new assert, re-split tests, etc) The second part is migrated into a new file under test_progs, flow_dissector_classification.c. It uses the same eBPF programs as flow_dissector.c, but the difference is rather about how those program are executed: - flow_dissector.c manually runs programs with BPF_PROG_RUN - flow_dissector_classification.c sends real packets to be dissected, and so it also executes kernel code related to eBPF flow dissector (eg: __skb_flow_bpf_to_target) --- Changes in v3: - Keep new helpers name in sync with kernel ones - Document some existing network helpers - Properly reuse pseudo-header csum helper in transport layer csum helper - Drop duplicate assert - Use const for test structure in the migrated test - Simplify shutdown callchain for basic test - collect Acked-by - Link to v2: https://lore.kernel.org/r/20241114-flow_dissector-v2-0-ee4a3be3de65@bootlin… Changes in v2: - allow tests to run in parallel - move some generic helpers to network_helpers.h - define proper function for ASSERT_MEMEQ - fetch acked-by tags - Link to v1: https://lore.kernel.org/r/20241113-flow_dissector-v1-0-27c4df0592dc@bootlin… --- Alexis Lothoré (eBPF Foundation) (14): selftests/bpf: add a macro to compare raw memory selftests/bpf: use ASSERT_MEMEQ to compare bpf flow keys selftests/bpf: replace CHECK calls with ASSERT macros in flow_dissector test selftests/bpf: re-split main function into dedicated tests selftests/bpf: expose all subtests from flow_dissector selftests/bpf: add gre packets testing to flow_dissector selftests/bpf: migrate flow_dissector namespace exclusivity test selftests/bpf: Enable generic tc actions in selftests config selftests/bpf: move ip checksum helper to network helpers selftests/bpf: document pseudo-header checksum helpers selftests/bpf: use the same udp and tcp headers in tests under test_progs selftests/bpf: add network helpers to generate udp checksums selftests/bpf: migrate bpf flow dissectors tests to test_progs selftests/bpf: remove test_flow_dissector.sh tools/testing/selftests/bpf/.gitignore | 1 - tools/testing/selftests/bpf/Makefile | 3 +- tools/testing/selftests/bpf/config | 1 + tools/testing/selftests/bpf/network_helpers.c | 2 +- tools/testing/selftests/bpf/network_helpers.h | 96 +++ .../selftests/bpf/prog_tests/flow_dissector.c | 323 +++++++-- .../bpf/prog_tests/flow_dissector_classification.c | 792 +++++++++++++++++++++ .../testing/selftests/bpf/prog_tests/sockopt_sk.c | 2 +- .../testing/selftests/bpf/prog_tests/xdp_bonding.c | 2 +- .../selftests/bpf/prog_tests/xdp_do_redirect.c | 2 +- .../selftests/bpf/prog_tests/xdp_flowtable.c | 2 +- .../selftests/bpf/prog_tests/xdp_metadata.c | 21 +- .../selftests/bpf/progs/test_cls_redirect.c | 2 +- .../selftests/bpf/progs/test_cls_redirect.h | 2 +- .../selftests/bpf/progs/test_cls_redirect_dynptr.c | 2 +- tools/testing/selftests/bpf/test_flow_dissector.c | 780 -------------------- tools/testing/selftests/bpf/test_flow_dissector.sh | 178 ----- tools/testing/selftests/bpf/test_progs.c | 15 + tools/testing/selftests/bpf/test_progs.h | 15 + tools/testing/selftests/bpf/xdp_hw_metadata.c | 2 +- 20 files changed, 1176 insertions(+), 1067 deletions(-) --- base-commit: 8e403f7465a7c73e3a8ef62bba8cd75ef525e4b1 change-id: 20241019-flow_dissector-3eb0c07fc163 Best regards, -- Alexis Lothoré, Bootlin Embedded Linux and Kernel engineering https://bootlin.com

1 year

4
21
0 0

[PATCH printk v1] printk: ringbuffer: Add KUnit test

by John Ogness

From: Thomas Weißschuh <thomas.weissschuh(a)linutronix.de> The KUnit test validates the correct operation of the ringbuffer. A separate dedicated ringbuffer is used so that the global printk ringbuffer is not touched. Co-developed-by: John Ogness <john.ogness(a)linutronix.de> Signed-off-by: John Ogness <john.ogness(a)linutronix.de> Signed-off-by: Thomas Weißschuh <thomas.weissschuh(a)linutronix.de> --- For those not familiar with KUnit, you can easily run this test doing something like this: $ ./tools/testing/kunit/kunit.py run \ --arch=x86_64 \ --qemu_args "-enable-kvm -smp 8" \ --kunitconfig kernel/printk init/Kconfig | 12 + kernel/printk/.kunitconfig | 3 + kernel/printk/Makefile | 2 + kernel/printk/printk_ringbuffer.c | 4 + kernel/printk/printk_ringbuffer_test.c | 350 +++++++++++++++++++++++++ 5 files changed, 371 insertions(+) create mode 100644 kernel/printk/.kunitconfig create mode 100644 kernel/printk/printk_ringbuffer_test.c diff --git a/init/Kconfig b/init/Kconfig index 3b6ca7cce03b..46d144908191 100644 --- a/init/Kconfig +++ b/init/Kconfig @@ -1576,6 +1576,18 @@ config PRINTK very difficult to diagnose system problems, saying N here is strongly discouraged. +config PRINTK_RINGBUFFER_TEST + tristate "Test for the printk ringbuffer" if !KUNIT_ALL_TESTS + depends on PRINTK && KUNIT + default KUNIT_ALL_TESTS + help + This builds the printk ringbuffer KUnit test suite. + + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation. + + If unsure, say N. + config BUG bool "BUG() support" if EXPERT default y diff --git a/kernel/printk/.kunitconfig b/kernel/printk/.kunitconfig new file mode 100644 index 000000000000..8d31a5c19053 --- /dev/null +++ b/kernel/printk/.kunitconfig @@ -0,0 +1,3 @@ +CONFIG_KUNIT=y +CONFIG_SMP=y +CONFIG_PRINTK_RINGBUFFER_TEST=y diff --git a/kernel/printk/Makefile b/kernel/printk/Makefile index 39a2b61c7232..edb5a4cacf67 100644 --- a/kernel/printk/Makefile +++ b/kernel/printk/Makefile @@ -7,3 +7,5 @@ obj-$(CONFIG_PRINTK_INDEX) += index.o obj-$(CONFIG_PRINTK) += printk_support.o printk_support-y := printk_ringbuffer.o printk_support-$(CONFIG_SYSCTL) += sysctl.o + +obj-$(CONFIG_PRINTK_RINGBUFFER_TEST) += printk_ringbuffer_test.o diff --git a/kernel/printk/printk_ringbuffer.c b/kernel/printk/printk_ringbuffer.c index 88e8f3a61922..57b80d262cb7 100644 --- a/kernel/printk/printk_ringbuffer.c +++ b/kernel/printk/printk_ringbuffer.c @@ -1,5 +1,6 @@ // SPDX-License-Identifier: GPL-2.0 +#include <kunit/visibility.h> #include <linux/kernel.h> #include <linux/irqflags.h> #include <linux/string.h> @@ -1685,6 +1686,7 @@ bool prb_reserve(struct prb_reserved_entry *e, struct printk_ringbuffer *rb, memset(r, 0, sizeof(*r)); return false; } +EXPORT_SYMBOL_IF_KUNIT(prb_reserve); /* Commit the data (possibly finalizing it) and restore interrupts. */ static void _prb_commit(struct prb_reserved_entry *e, unsigned long state_val) @@ -1759,6 +1761,7 @@ void prb_commit(struct prb_reserved_entry *e) if (head_id != e->id) desc_make_final(e->rb, e->id); } +EXPORT_SYMBOL_IF_KUNIT(prb_commit); /** * prb_final_commit() - Commit and finalize (previously reserved) data to @@ -2181,6 +2184,7 @@ bool prb_read_valid(struct printk_ringbuffer *rb, u64 seq, { return _prb_read_valid(rb, &seq, r, NULL); } +EXPORT_SYMBOL_IF_KUNIT(prb_read_valid); /** * prb_read_valid_info() - Non-blocking read of meta data for a requested diff --git a/kernel/printk/printk_ringbuffer_test.c b/kernel/printk/printk_ringbuffer_test.c new file mode 100644 index 000000000000..79331ea2b739 --- /dev/null +++ b/kernel/printk/printk_ringbuffer_test.c @@ -0,0 +1,350 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <linux/delay.h> +#include <linux/init.h> +#include <linux/kthread.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/random.h> +#include <linux/sched/clock.h> +#include <linux/slab.h> +#include <linux/wait.h> + +#include <kunit/test.h> + +#include "printk_ringbuffer.h" + +/* + * This KUnit tests the data integrity of the lockless printk_ringbuffer. + * From multiple CPUs it writes messages of varying length and content while + * a reader validates the correctness of the messages. + * + * IMPORTANT: The more CPUs you can use for this KUnit, the better! + * + * The test works by starting "num_online_cpus() - 1" writer threads, each + * pinned to their own CPU. Each writer thread loops, writing data of varying + * length into a printk_ringbuffer as fast as possible. The data content is + * an embedded data struct followed by string content repeating the byte: + * + * 'A' + CPUID + * + * A reader thread is started on the remaining online CPU and ensures that + * embedded struct content is consistent with the string and that the string + * is terminated and is composed of the same repeating byte as its first byte. + * + * Because the threads are running in such tight loops, they will call + * schedule() from time to time so the system stays functional. + * + * If the reader encounters an error, the test is aborted and some + * information about the error is provided via printk. The runtime of + * the test can be configured with the runtime_ms module parameter. + * + * Note that the test is performed on a separate printk_ringbuffer instance + * and not the instance used by printk(). + */ + +static unsigned long runtime_ms = 10000; +module_param(runtime_ms, ulong, 0400); + +/* used by writers to signal reader of new records */ +static DECLARE_WAIT_QUEUE_HEAD(test_wait); + +/* test data structure */ +struct rbdata { + unsigned int len; + char text[] __counted_by(len); +}; + +#define MAX_RBDATA_LEN (0x7f + 1) +#define MAX_RECORD_SIZE (sizeof(struct rbdata) + MAX_RBDATA_LEN + 1) + +static struct test_running { + int runstate; + unsigned long num; + struct kunit *test; +} *test_running; +static int halt_test; + +static void fail_record(struct kunit *test, struct rbdata *dat, u64 seq) +{ + char buf[MAX_RBDATA_LEN + 1]; + + snprintf(buf, sizeof(buf), "%s", dat->text); + buf[sizeof(buf) - 1] = 0; + + KUNIT_FAIL(test, "BAD RECORD: seq=%llu len=%u text=%s\n", + seq, dat->len, dat->len < sizeof(buf) ? buf : "<invalid>"); +} + +static bool check_data(struct rbdata *dat) +{ + unsigned int len; + + len = strnlen(dat->text, MAX_RBDATA_LEN + 1); + + /* Sane length? */ + if (len != dat->len || !len || len > MAX_RBDATA_LEN) + return false; + + /* String repeats with the same character? */ + while (len) { + len--; + if (dat->text[len] != dat->text[0]) + return false; + } + + return true; +} + +/* Equivalent to CONFIG_LOG_BUF_SHIFT=13 */ +DEFINE_PRINTKRB(test_rb, 8, 5); + +static int prbtest_writer(void *data) +{ + struct test_running *tr = data; + char text_id = 'A' + tr->num; + struct prb_reserved_entry e; + unsigned long count = 0; + struct printk_record r; + u64 min_ns = (u64)-1; + struct rbdata *dat; + u64 total_ns = 0; + u64 max_ns = 0; + u64 post_ns; + u64 pre_ns; + int len; + + set_cpus_allowed_ptr(current, cpumask_of(tr->num)); + + kunit_info(tr->test, "start thread %03lu (writer)\n", tr->num); + + tr->runstate = 1; + + for (;;) { + /* +2 to ensure at least 1 character + terminator. */ + len = sizeof(struct rbdata) + (get_random_u32() & 0x7f) + 2; + + /* specify the text sizes for reservation */ + prb_rec_init_wr(&r, len); + + pre_ns = local_clock(); + + if (prb_reserve(&e, &test_rb, &r)) { + r.info->text_len = len; + + len -= sizeof(struct rbdata) + 1; + + dat = (struct rbdata *)&r.text_buf[0]; + dat->len = len; + memset(&dat->text[0], text_id, len); + dat->text[len] = 0; + + prb_commit(&e); + + post_ns = local_clock(); + + wake_up_interruptible(&test_wait); + + post_ns -= pre_ns; + if (post_ns < min_ns) + min_ns = post_ns; + if (post_ns > max_ns) + max_ns = post_ns; + total_ns += post_ns; + } + + if ((count++ & 0x3fff) == 0) + schedule(); + + if (READ_ONCE(halt_test) == 1) + break; + } + + kunit_info(tr->test, "end thread %03lu: wrote=%lu min_ns=%llu avg_ns=%llu max_ns=%llu\n", + tr->num, count, min_ns, total_ns / (u64)count, max_ns); + + tr->runstate = 2; + + return 0; +} + +static int prbtest_reader(void *data) +{ + struct test_running *tr = data; + char text_buf[MAX_RECORD_SIZE]; + unsigned long total_lost = 0; + unsigned long max_lost = 0; + unsigned long count = 0; + struct printk_info info; + struct printk_record r; + int did_sched = 1; + u64 seq = 0; + + set_cpus_allowed_ptr(current, cpumask_of(tr->num)); + + prb_rec_init_rd(&r, &info, &text_buf[0], sizeof(text_buf)); + + kunit_info(tr->test, "start thread %03lu (reader)\n", tr->num); + + tr->runstate = 1; + + while (!wait_event_interruptible(test_wait, + kthread_should_stop() || + prb_read_valid(&test_rb, seq, &r))) { + bool error = false; + + if (kthread_should_stop()) + break; + /* check/track the sequence */ + if (info.seq < seq) { + KUNIT_FAIL(tr->test, "BAD SEQ READ: request=%llu read=%llu\n", + seq, info.seq); + error = true; + } else if (info.seq != seq && !did_sched) { + total_lost += info.seq - seq; + if (max_lost < info.seq - seq) + max_lost = info.seq - seq; + } + + if (!check_data((struct rbdata *)&r.text_buf[0])) { + fail_record(tr->test, (struct rbdata *)&r.text_buf[0], info.seq); + error = true; + } + + if (error) + WRITE_ONCE(halt_test, 1); + + did_sched = 0; + if ((count++ & 0x3fff) == 0) { + did_sched = 1; + schedule(); + } + + if (READ_ONCE(halt_test) == 1) + break; + + seq = info.seq + 1; + } + + kunit_info(tr->test, + "end thread %03lu: read=%lu seq=%llu total_lost=%lu max_lost=%lu\n", + tr->num, count, info.seq, total_lost, max_lost); + + while (!kthread_should_stop()) + msleep(1000); + tr->runstate = 2; + + return 0; +} + +static int module_test_running; +static struct task_struct *reader_thread; + +static int start_test(void *arg) +{ + struct kunit *test = arg; + struct task_struct *thread; + unsigned long i; + int num_cpus; + + num_cpus = num_online_cpus(); + if (num_cpus == 1) + kunit_skip(test, "need >1 CPUs for at least one reader and writer"); + + test_running = kcalloc(num_cpus, sizeof(*test_running), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, test_running); + + module_test_running = 1; + + kunit_info(test, "starting test\n"); + + for (i = 0; i < num_cpus; i++) { + test_running[i].test = test; + test_running[i].num = i; + if (i < num_cpus - 1) { + thread = kthread_run(prbtest_writer, &test_running[i], + "prbtest writer"); + } else { + thread = kthread_run(prbtest_reader, &test_running[i], + "prbtest reader"); + reader_thread = thread; + } + if (IS_ERR(thread)) { + kunit_err(test, "unable to create thread %lu\n", i); + test_running[i].runstate = 2; + } + } + + /* wait until all threads finish */ + for (;;) { + msleep(1000); + + for (i = 0; i < num_cpus; i++) { + if (test_running[i].runstate < 2) + break; + } + if (i == num_cpus) + break; + } + + kunit_info(test, "completed test\n"); + + module_test_running = 0; + + return 0; +} + +static void test_readerwriter(struct kunit *test) +{ + static bool already_run; + int num_cpus; + int i; + + if (already_run) + KUNIT_FAIL_AND_ABORT(test, "test can only be run once"); + already_run = true; + + kunit_info(test, "running for %lu ms\n", runtime_ms); + + kthread_run(start_test, test, "prbtest"); + + /* wait until all threads active */ + num_cpus = num_online_cpus(); + for (;;) { + msleep(1000); + + for (i = 0; i < num_cpus; i++) { + if (test_running[i].runstate == 0) + break; + } + if (i == num_cpus) + break; + } + + msleep(runtime_ms); + + if (reader_thread && !IS_ERR(reader_thread)) + kthread_stop(reader_thread); + + WRITE_ONCE(halt_test, 1); + + while (module_test_running) + msleep(1000); + kfree(test_running); +} + +static struct kunit_case prb_test_cases[] = { + KUNIT_CASE_SLOW(test_readerwriter), + {} +}; + +static struct kunit_suite prb_test_suite = { + .name = "printk-ringbuffer", + .test_cases = prb_test_cases, +}; +kunit_test_suite(prb_test_suite); + +MODULE_IMPORT_NS(EXPORTED_FOR_KUNIT_TESTING); +MODULE_AUTHOR("John Ogness <john.ogness(a)linutronix.de>"); +MODULE_DESCRIPTION("printk_ringbuffer test"); +MODULE_LICENSE("GPL"); base-commit: 4022ef25504db2fb79a2acac0afe9bac934f8dd6 -- 2.39.5

1 year

4
4
0 0

[PATCHv2 net 0/2] ipv6: fix temporary address not removed correctly

by Hangbin Liu

Currently the temporary address is not removed when mngtmpaddr is deleted or becomes unmanaged. The patch set fixed this issue and add a related test. v2: 1) delete the tempaddrs directly instead of remove them in addrconf_verify_rtnl(Sam Edwards) 2) Update the test case by checking the address including, add Sam in SOB (Sam Edwards) Hangbin Liu (2): net/ipv6: delete temporary address if mngtmpaddr is removed or unmanaged selftests/rtnetlink.sh: add mngtempaddr test net/ipv6/addrconf.c | 41 +++++++--- tools/testing/selftests/net/rtnetlink.sh | 95 ++++++++++++++++++++++++ 2 files changed, 124 insertions(+), 12 deletions(-) -- 2.46.0

1 year

3
5
0 0

[PATCH v2] selftests: Warn about skipped tests in result summary

by Laura Nao

Update the functions that print the test totals at the end of a selftest to include a warning message when skipped tests are detected. The message advises users that skipped tests may indicate missing configuration options and suggests enabling them to improve coverage. Signed-off-by: Laura Nao <laura.nao(a)collabora.com> --- Changes in v2: - Included count of skipped tests in the warning message --- tools/testing/selftests/kselftest.h | 5 +++++ tools/testing/selftests/kselftest/ksft.py | 3 +++ tools/testing/selftests/kselftest/ktap_helpers.sh | 4 ++++ 3 files changed, 12 insertions(+) diff --git a/tools/testing/selftests/kselftest.h b/tools/testing/selftests/kselftest.h index 29fedf609611..249201664bcb 100644 --- a/tools/testing/selftests/kselftest.h +++ b/tools/testing/selftests/kselftest.h @@ -147,6 +147,11 @@ static inline void ksft_set_plan(unsigned int plan) static inline void ksft_print_cnts(void) { + if (ksft_cnt.ksft_xskip > 0) + printf( + "# %u skipped test(s) detected. Consider enabling relevant config options to improve coverage.\n", + ksft_cnt.ksft_xskip + ); if (ksft_plan != ksft_test_num()) printf("# Planned tests != run tests (%u != %u)\n", ksft_plan, ksft_test_num()); diff --git a/tools/testing/selftests/kselftest/ksft.py b/tools/testing/selftests/kselftest/ksft.py index bf215790a89d..0e030837fc17 100644 --- a/tools/testing/selftests/kselftest/ksft.py +++ b/tools/testing/selftests/kselftest/ksft.py @@ -27,6 +27,9 @@ def set_plan(num_tests): def print_cnts(): + if ksft_cnt['skip'] > 0: + print(f"# {ksft_cnt['skip']} skipped test(s) detected. Consider enabling relevant config options to improve coverage.") + print( f"# Totals: pass:{ksft_cnt['pass']} fail:{ksft_cnt['fail']} xfail:0 xpass:0 skip:{ksft_cnt['skip']} error:0" ) diff --git a/tools/testing/selftests/kselftest/ktap_helpers.sh b/tools/testing/selftests/kselftest/ktap_helpers.sh index 79a125eb24c2..531094d81f03 100644 --- a/tools/testing/selftests/kselftest/ktap_helpers.sh +++ b/tools/testing/selftests/kselftest/ktap_helpers.sh @@ -107,5 +107,9 @@ ktap_finished() { } ktap_print_totals() { + if [ "$KTAP_CNT_SKIP" -gt 0 ]; then + echo "# $KTAP_CNT_SKIP skipped test(s) detected. " \ + "Consider enabling relevant config options to improve coverage." + fi echo "# Totals: pass:$KTAP_CNT_PASS fail:$KTAP_CNT_FAIL xfail:0 xpass:0 skip:$KTAP_CNT_SKIP error:0" } -- 2.30.2

1 year

1
0
0 0

[PATCH v1] selftests/bpf: Fix unnecessary conversion to bool in 'run_subtest'

by guanjing

Fixes the following coccicheck: tools/testing/selftests/bpf/test_loader.c:1033:64-69: WARNING: conversion to bool not needed here Fixes: 80a4129fcf20 ("selftests/bpf: Add unit tests for bpf_arena_alloc/free_pages") Signed-off-by: guanjing <guanjing(a)cmss.chinamobile.com> --- tools/testing/selftests/bpf/test_loader.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/bpf/test_loader.c b/tools/testing/selftests/bpf/test_loader.c index 3e9b009580d4..400f56f81272 100644 --- a/tools/testing/selftests/bpf/test_loader.c +++ b/tools/testing/selftests/bpf/test_loader.c @@ -1030,7 +1030,7 @@ void run_subtest(struct test_loader *tester, } do_prog_test_run(bpf_program__fd(tprog), &retval, - bpf_program__type(tprog) == BPF_PROG_TYPE_SYSCALL ? true : false); + bpf_program__type(tprog) == BPF_PROG_TYPE_SYSCALL); if (retval != subspec->retval && subspec->retval != POINTER_VALUE) { PRINT_FAIL("Unexpected retval: %d != %d\n", retval, subspec->retval); goto tobj_cleanup; -- 2.33.0

1 year

3
2
0 0

[PATCH bpf 0/4] bpf, vsock: Fix poll() and close()

by Michal Luczaj

Two small fixes for vsock: poll() missing a queue check, and close() not invoking sockmap cleanup. Signed-off-by: Michal Luczaj <mhal(a)rbox.co> --- Michal Luczaj (4): bpf, vsock: Fix poll() missing a queue selftest/bpf: Add test for af_vsock poll() bpf, vsock: Invoke proto::close on close() selftest/bpf: Add test for vsock removal from sockmap on close() net/vmw_vsock/af_vsock.c | 70 ++++++++++++-------- .../selftests/bpf/prog_tests/sockmap_basic.c | 77 ++++++++++++++++++++++ 2 files changed, 120 insertions(+), 27 deletions(-) --- base-commit: 6c4139b0f19b7397286897caee379f8321e78272 change-id: 20241118-vsock-bpf-poll-close-64f432e682ec Best regards, -- Michal Luczaj <mhal(a)rbox.co>

1 year

5
17
0 0

[PATCH for-next v3] selftests/mm: Add a few missing gitignore files

by Li Zhijian

Compiled binary files should be added to .gitignore 'git status' complains: Untracked files: (use "git add <file>..." to include in what will be committed) mm/hugetlb_dio mm/pkey_sighandler_tests_32 mm/pkey_sighandler_tests_64 Cc: Donet Tom <donettom(a)linux.ibm.com> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Shuah Khan <shuah(a)kernel.org> Signed-off-by: Li Zhijian <lizhijian(a)fujitsu.com> --- Cc: linux-mm(a)kvack.org --- Hello, Cover letter is here. This patch set aims to make 'git status' clear after 'make' and 'make run_tests' for kselftests. --- V3: nothing change, just resend it (This .gitignore have not sorted, so I appended new files to the end) V2: split as seperate patch from a small one [0] [0] https://lore.kernel.org/linux-kselftest/20241015010817.453539-1-lizhijian@f… --- tools/testing/selftests/mm/.gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tools/testing/selftests/mm/.gitignore b/tools/testing/selftests/mm/.gitignore index da030b43e43b..2ac11b7fcb26 100644 --- a/tools/testing/selftests/mm/.gitignore +++ b/tools/testing/selftests/mm/.gitignore @@ -51,3 +51,5 @@ hugetlb_madv_vs_map mseal_test seal_elf droppable +hugetlb_dio +pkey_sighandler_tests* -- 2.44.0

1 year

3
4
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror