On Wed, Jun 11, 2025 at 4:38 PM Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

Make sure the byte order and ABI of the userprogs matches the one of the kernel, similar to how the bit size is handled. Otherwise the userprogs may not be executable. This happens for example on powerpc little endian, or riscv32.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile index c4293cf91e968ca8ee64452841fb266e24df63f6..b9aa1058321dabd3b3dd5610e45a2807dfa257f4 100644 --- a/Makefile +++ b/Makefile @@ -1129,8 +1129,8 @@ ifneq ($(CONFIG_ARCH_VMLINUX_NEEDS_RELOCS),) LDFLAGS_vmlinux += --emit-relocs --discard-none endif

-# Align the bit size of userspace programs with the kernel -USERFLAGS_FROM_KERNEL := -m32 -m64 --target=% +# Align the bit size, byte order and architecture of userspace programs with the kernel +USERFLAGS_FROM_KERNEL := -m32 -m64 -mlittle-endian -mbig-endian --target=% -march=% -mabi=% KBUILD_USERCFLAGS += $(filter $(USERFLAGS_FROM_KERNEL), $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS)) KBUILD_USERLDFLAGS += $(filter $(USERFLAGS_FROM_KERNEL), $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS))

Why didn't you do like this?

USERFLAGS_FROM_KERNEL := $(filter -m32 -m64 -mlittle-endian -mbig-endian --target=% -march=% -mabi=%, $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS)) KBUILD_USERCFLAGS += $(USERFLAGS_FROM_KERNEL) KBUILD_USERLDFLAGS += $(USERFLAGS_FROM_KERNEL)

-- Best Regards Masahiro Yamada

On Tue, Jun 17, 2025 at 4:39 PM Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

On Mon, Jun 16, 2025 at 11:49:41PM +0900, Masahiro Yamada wrote:

...

On Wed, Jun 11, 2025 at 4:38 PM Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

...

Make sure the byte order and ABI of the userprogs matches the one of the kernel, similar to how the bit size is handled. Otherwise the userprogs may not be executable. This happens for example on powerpc little endian, or riscv32.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile index c4293cf91e968ca8ee64452841fb266e24df63f6..b9aa1058321dabd3b3dd5610e45a2807dfa257f4 100644 --- a/Makefile +++ b/Makefile @@ -1129,8 +1129,8 @@ ifneq ($(CONFIG_ARCH_VMLINUX_NEEDS_RELOCS),) LDFLAGS_vmlinux += --emit-relocs --discard-none endif

-# Align the bit size of userspace programs with the kernel -USERFLAGS_FROM_KERNEL := -m32 -m64 --target=% +# Align the bit size, byte order and architecture of userspace programs with the kernel +USERFLAGS_FROM_KERNEL := -m32 -m64 -mlittle-endian -mbig-endian --target=% -march=% -mabi=% KBUILD_USERCFLAGS += $(filter $(USERFLAGS_FROM_KERNEL), $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS)) KBUILD_USERLDFLAGS += $(filter $(USERFLAGS_FROM_KERNEL), $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS))

Why didn't you do like this?

USERFLAGS_FROM_KERNEL := $(filter -m32 -m64 -mlittle-endian -mbig-endian --target=% -march=% -mabi=%, $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS)) KBUILD_USERCFLAGS += $(USERFLAGS_FROM_KERNEL) KBUILD_USERLDFLAGS += $(USERFLAGS_FROM_KERNEL)

The idea was to keep the USERFLAGS_FROM_KERNEL line free of clutter, as it is probably going to change more often. To improve reviewability and gain some available horizontal space in case it should be needed at some point.

If you prefer the other layout I'll be happy to switch it around.

$(filter ... $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS))

is duplicated in the two lines.

That is the reason for my suggestion.

On Tue, Jun 17, 2025 at 12:35:07AM +0900, Masahiro Yamada wrote:

On Wed, Jun 11, 2025 at 4:38 PM Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

...

Userprogs are built with the regular kernel compiler $CC. A kernel compiler does not necessarily contain a libc which is required for a normal userspace application. However the kernel tree does contain a minimal libc implementation "nolibc" which can be used to build userspace applications.

Introduce support to build userprogs against nolibc instead of the default libc of the compiler, which may not exist.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

---

This could probably be moved out of the generic kbuild makefiles. I think the ergonimics would suffer and this functionality could be used by other users of userprogs.

Also this does currently not support out-of-tree builds. For that tools/include/nolibc/*.h and usr/include/*.h would need to be installed into the build directory.

<snip>

...

--- a/scripts/Makefile.userprogs +++ b/scripts/Makefile.userprogs @@ -16,10 +16,17 @@ user-csingle := $(addprefix $(obj)/, $(user-csingle)) user-cmulti := $(addprefix $(obj)/, $(user-cmulti)) user-cobjs := $(addprefix $(obj)/, $(user-cobjs))

+user_nolibc_ccflags := -nostdlib -nostdinc -static -fno-ident -fno-asynchronous-unwind-tables \

•                 -ffreestanding -fno-stack-protector \
  

•                 -isystem $(objtree)/usr/include -include $(srctree)/tools/include/nolibc/nolibc.h -isystem $(srctree)/tools/include/nolibc/
  

The tools/ directory is a different world, and Kbuild scripts do not know anything about it.

Ack.

How does this statement affect the next patch which creates tools/include/nolibc/Kconfig.nolibc ? Is it fine to create the Kconfig file in tools/ or should I move it? I do want to maintain this file as part of nolibc and not KUnit. The possibilities I see are init/Kconfig.nolibc or lib/Kconfig.nolibc.

And, you do not need to implement this in scripts/Makefile.userprogs because you can move this to lib/kunit/Makefile.kunit-uapi or somewhere.

Understood. This is not unexpected, as hinted in the commit message.

...

+user_nolibc_ldflags := -nostdlib -nostdinc -static

user_ccflags = -Wp,-MMD,$(depfile) $(KBUILD_USERCFLAGS) $(userccflags) \

•                   $($(target-stem)-userccflags)
  

-user_ldflags = $(KBUILD_USERLDFLAGS) $(userldflags) $($(target-stem)-userldflags) -user_ldlibs = $(userldlibs) $($(target-stem)-userldlibs)

•                   $($(target-stem)-userccflags) $(if $($(target-stem)-nolibc),$(user_nolibc_ccflags))
  

+user_ldflags = $(KBUILD_USERLDFLAGS) $(userldflags) $($(target-stem)-userldflags) \

•                   $(if $($(target-stem)-nolibc),$(user_nolibc_ldflags))
  

+user_ldlibs = $(userldlibs) $($(target-stem)-userldlibs) \

•                   $(if $($(target-stem)-nolibc),$(user_nolibc_ldlibs))
  
  

# Create an executable from a single .c file quiet_cmd_user_cc_c = CC [U] $@

Thomas

On Wed, 11 Jun 2025 at 15:38, Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

Currently there is no test validating the result reporting from nested tests. Add one, it will also be used to validate upcoming changes to the nested test parsing.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

This looks good, modulo a couple of minor suggestions below.

Regardless, Reviewed-by: David Gow davidgow@google.com

Cheers, -- David

tools/testing/kunit/kunit_tool_test.py | 9 +++++++++ .../kunit/test_data/test_is_test_passed-failure-nested.log | 7 +++++++ 2 files changed, 16 insertions(+)

diff --git a/tools/testing/kunit/kunit_tool_test.py b/tools/testing/kunit/kunit_tool_test.py index bbba921e0eacb18663abfcabb2bccf330d8666f5..691cde9b030f7729128490c1bdb42ccee1967ad6 100755 --- a/tools/testing/kunit/kunit_tool_test.py +++ b/tools/testing/kunit/kunit_tool_test.py @@ -165,6 +165,15 @@ class KUnitParserTest(unittest.TestCase): self.assertEqual(kunit_parser.TestStatus.FAILURE, result.status) self.assertEqual(result.counts.errors, 0)

•   def test_parse_failed_nested_tests_log(self):
  

•           nested_log = test_data_path('test_is_test_passed-failure-nested.log')
  

•           with open(nested_log) as file:
  

•                   result = kunit_parser.parse_run_tests(file.readlines(), stdout)
  

•           self.assertEqual(kunit_parser.TestStatus.FAILURE, result.status)
  

•           self.assertEqual(result.counts.failed, 2)
  

•           self.assertEqual(kunit_parser.TestStatus.FAILURE, result.subtests[0].status)
  

Is it worth also testing the value of the nested test's result here? i.e., self.assertEqual(kunit_parser.TestStatus.FAILURE, result.subtests[0].subtests[0].status)

•           self.assertEqual(kunit_parser.TestStatus.FAILURE, result.subtests[1].status)
  

•   def test_no_header(self):
            empty_log = test_data_path('test_is_test_passed-no_tests_run_no_header.log')
            with open(empty_log) as file:
  

diff --git a/tools/testing/kunit/test_data/test_is_test_passed-failure-nested.log b/tools/testing/kunit/test_data/test_is_test_passed-failure-nested.log new file mode 100644 index 0000000000000000000000000000000000000000..835816e0a07715a514f5f5afab1b6250037feaf4 --- /dev/null +++ b/tools/testing/kunit/test_data/test_is_test_passed-failure-nested.log @@ -0,0 +1,7 @@ +KTAP version 1 +1..2 +not ok 1 subtest 1

• KTAP version 1
• 1..1

•    not ok 1 test 1
  

+not ok 2 subtest 2

Having these named 'subtest 1' and 'test 1' is a bit confusing to me (as it implies the outer tests are subtests of the inner ones, which isn't right).

Could we either swap 'subtest' and 'test' here, or -- if we want to preserve the match between 'subtest' here and the subtest in the python code -- label the inner one something like 'subsubtest'?

-- 2.49.0

On Fri, Jun 20, 2025 at 05:37:44PM +0800, David Gow wrote:

On Wed, 11 Jun 2025 at 15:38, Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

...

If a subtest itself reports success, but the outer testcase fails, the whole testcase should be reported as a failure. However the status is recalculated based on the test counts, overwriting the outer test result. Synthesize a failed test in this case to make sure the failure is not swallowed.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

Hmm... this is definitely a nasty edge-case. I don't completely like this solution, but none of the other options seem drastically better.

I think the more obvious options are either to _always_ count tests alongside their subtests, or to _never_ do so, but acknowledge that "test failed, but failure count is 0" is a valid option. But neither of those are especially satisfying, either greatly inflating test counts, or creating obvious contradictions.

So I'm tentatively in favour of this, but if anyone has a nicer way of doing it, I'm all ears.

Agreed, it is not great. I'd also be happy for better ideas.

The implementation looks good. If we can add the explicit checks for the sub(sub)test results as mentioned in the previous patch, that'd be even better.

Reviewed-by: David Gow davidgow@google.com

...

tools/testing/kunit/kunit_parser.py | 5 +++++ tools/testing/kunit/kunit_tool_test.py | 2 +- tools/testing/kunit/test_data/test_is_test_passed-failure-nested.log | 3 +++ 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/tools/testing/kunit/kunit_parser.py b/tools/testing/kunit/kunit_parser.py index c176487356e6c94882046b19ea696d750905b8d5..2478beb28fc3db825855ad46200340e884da7df1 100644 --- a/tools/testing/kunit/kunit_parser.py +++ b/tools/testing/kunit/kunit_parser.py @@ -686,6 +686,11 @@ def bubble_up_test_results(test: Test) -> None: counts.add_status(status) elif test.counts.get_status() == TestStatus.TEST_CRASHED: test.status = TestStatus.TEST_CRASHED

•   if not test.ok_status():
  

•           for t in subtests:
  

•                   if not t.ok_status():
  

•                           counts.add_status(t.status)
  

•                           break
  
  

def parse_test(lines: LineStream, expected_num: int, log: List[str], is_subtest: bool, printer: Printer) -> Test: """ diff --git a/tools/testing/kunit/kunit_tool_test.py b/tools/testing/kunit/kunit_tool_test.py index 691cde9b030f7729128490c1bdb42ccee1967ad6..c25f52650837e83325b06bddd2aa665fd29f91d9 100755 --- a/tools/testing/kunit/kunit_tool_test.py +++ b/tools/testing/kunit/kunit_tool_test.py @@ -170,7 +170,7 @@ class KUnitParserTest(unittest.TestCase): with open(nested_log) as file: result = kunit_parser.parse_run_tests(file.readlines(), stdout) self.assertEqual(kunit_parser.TestStatus.FAILURE, result.status)

•           self.assertEqual(result.counts.failed, 2)
  

•           self.assertEqual(result.counts.failed, 3)
            self.assertEqual(kunit_parser.TestStatus.FAILURE, result.subtests[0].status)
  

Could we add: self.assertEqual(kunit_parser.TestStatus.SUCCESS, result.subtests[0].subtests[0].status)

...

            self.assertEqual(kunit_parser.TestStatus.FAILURE, result.subtests[1].status)

Ack.

and

self.assertEqual(kunit_parser.TestStatus.FAILURE, result.subtests[1].subtests[0].status)

This is now already in the previous patch.

...

diff --git a/tools/testing/kunit/test_data/test_is_test_passed-failure-nested.log b/tools/testing/kunit/test_data/test_is_test_passed-failure-nested.log index 835816e0a07715a514f5f5afab1b6250037feaf4..cd9033c464792e6294905a5676346684182874ad 100644 --- a/tools/testing/kunit/test_data/test_is_test_passed-failure-nested.log +++ b/tools/testing/kunit/test_data/test_is_test_passed-failure-nested.log @@ -1,5 +1,8 @@ KTAP version 1 1..2

• KTAP version 1
• 1..1

•    ok 1 test 1
  

not ok 1 subtest 1 KTAP version 1 1..1

-- 2.49.0

On Wed, 11 Jun 2025 at 15:38, Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

Skipped tests reported by kselftest.h use a different format than KTAP, there is no explicit test name. Normally the test name is part of the free-form string after the SKIP keyword:

    ok 3 # SKIP test: some reason

Extend the parser to handle those correctly. Use the free-form string as test name instead.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

Nice: this is a great improvement.

Reviewed-by: David Gow davidgow@google.com

Cheers, -- David

tools/testing/kunit/kunit_parser.py | 8 +++++--- tools/testing/kunit/test_data/test_is_test_passed-kselftest.log | 3 ++- 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/tools/testing/kunit/kunit_parser.py b/tools/testing/kunit/kunit_parser.py index 2478beb28fc3db825855ad46200340e884da7df1..4599d23c79b79f0e219d655c7053c8c3b34f8152 100644 --- a/tools/testing/kunit/kunit_parser.py +++ b/tools/testing/kunit/kunit_parser.py @@ -352,9 +352,9 @@ def parse_test_plan(lines: LineStream, test: Test) -> bool: lines.pop() return True

-TEST_RESULT = re.compile(r'^\s*(ok|not ok) ([0-9]+) (- )?([^#]*)( # .*)?$') +TEST_RESULT = re.compile(r'^\s*(ok|not ok) ([0-9]+)? ?(- )?([^#]*)( # .*)?$')

-TEST_RESULT_SKIP = re.compile(r'^\s*(ok|not ok) ([0-9]+) (- )?(.*) # SKIP(.*)$') +TEST_RESULT_SKIP = re.compile(r'^\s*(ok|not ok) ([0-9]+)? ?(- )?(.*) # SKIP ?(.*)$')

def peek_test_name_match(lines: LineStream, test: Test) -> bool: """ @@ -379,6 +379,8 @@ def peek_test_name_match(lines: LineStream, test: Test) -> bool: if not match: return False name = match.group(4)

•   if not name:
  

•           return False
    return name == test.name
  
  

def parse_test_result(lines: LineStream, test: Test, @@ -416,7 +418,7 @@ def parse_test_result(lines: LineStream, test: Test,

    # Set name of test object
    if skip_match:

•           test.name = skip_match.group(4)
  

•           test.name = skip_match.group(4) or skip_match.group(5)
    else:
            test.name = match.group(4)
  
  

diff --git a/tools/testing/kunit/test_data/test_is_test_passed-kselftest.log b/tools/testing/kunit/test_data/test_is_test_passed-kselftest.log index 65d3f27feaf22a3f47ed831c4c24f6f11c625a92..30d9ef18bcec177067288d5242771236f29b7d56 100644 --- a/tools/testing/kunit/test_data/test_is_test_passed-kselftest.log +++ b/tools/testing/kunit/test_data/test_is_test_passed-kselftest.log @@ -1,5 +1,5 @@ TAP version 13 -1..2 +1..3 # selftests: membarrier: membarrier_test_single_thread # TAP version 13 # 1..2 @@ -12,3 +12,4 @@ ok 1 selftests: membarrier: membarrier_test_single_thread # ok 1 sys_membarrier available # ok 2 sys membarrier invalid command test: command = -1, flags = 0, errno = 22. Failed as expected ok 2 selftests: membarrier: membarrier_test_multi_thread +ok 3 # SKIP selftests: membarrier: membarrier_test_multi_thread

-- 2.49.0

On Wed, 11 Jun 2025 at 15:38, Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

An upcoming change will add 'userprogs' to the kunit subdirectory. For kbuild to properly clean up these build artifacts the subdirectory needs to be always processed.

Pushing the special logic for hook.o into the kunit Makefile also makes the logic easier to understand.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

I'm quite happy with this.

Reviewed-by: David Gow davidgow@google.com

Cheers, -- David

lib/Makefile | 4 ---- lib/kunit/Makefile | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/lib/Makefile b/lib/Makefile index c38582f187dd81916113319072e5cfef26f26c84..698566135091cc3bf0054f1954b434dc3325364a 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -108,11 +108,7 @@ test_fpu-y := test_fpu_glue.o test_fpu_impl.o CFLAGS_test_fpu_impl.o += $(CC_FLAGS_FPU) CFLAGS_REMOVE_test_fpu_impl.o += $(CC_FLAGS_NO_FPU)

-# Some KUnit files (hooks.o) need to be built-in even when KUnit is a module, -# so we can't just use obj-$(CONFIG_KUNIT). -ifdef CONFIG_KUNIT obj-y += kunit/ -endif

ifeq ($(CONFIG_DEBUG_KOBJECT),y) CFLAGS_kobject.o += -DDEBUG diff --git a/lib/kunit/Makefile b/lib/kunit/Makefile index 5aa51978e456ab3bb60c12071a26cf2bdcb1b508..656f1fa35abcc635e67d5b4cb1bc586b48415ac5 100644 --- a/lib/kunit/Makefile +++ b/lib/kunit/Makefile @@ -17,7 +17,7 @@ kunit-objs += debugfs.o endif

# KUnit 'hooks' are built-in even when KUnit is built as a module. -obj-y += hooks.o +obj-$(if $(CONFIG_KUNIT),y) += hooks.o

obj-$(CONFIG_KUNIT_TEST) += kunit-test.o obj-$(CONFIG_KUNIT_TEST) += platform-test.o

-- 2.49.0

-- You received this message because you are subscribed to the Google Groups "KUnit Development" group. To unsubscribe from this group and stop receiving emails from it, send an email to kunit-dev+unsubscribe@googlegroups.com. To view this discussion visit https://groups.google.com/d/msgid/kunit-dev/20250611-kunit-kselftests-v3-11-....

On Wed, 11 Jun 2025 at 15:38, Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

The upcoming kunit UAPI framework will run userspace executables as part of kunit. These may use the LSX or LASX instructions.

Make sure the kunit kernel can handle these instructions.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

Looks fine to me. I confess to not knowing much about the details of Loongarch CPUs, though, so while it hasn't broken anything here, I make no further guarantees.

Reviewed-by: David Gow davidgow@google.com

Cheers, -- David

tools/testing/kunit/qemu_configs/loongarch.py | 2 ++ 1 file changed, 2 insertions(+)

diff --git a/tools/testing/kunit/qemu_configs/loongarch.py b/tools/testing/kunit/qemu_configs/loongarch.py index a92422967d1da9f1658ef1e80d0d7365ddbae307..1dba755284f11ffc94d8946105b0cfa49cb6f604 100644 --- a/tools/testing/kunit/qemu_configs/loongarch.py +++ b/tools/testing/kunit/qemu_configs/loongarch.py @@ -11,6 +11,8 @@ CONFIG_PVPANIC_PCI=y CONFIG_SERIAL_8250=y CONFIG_SERIAL_8250_CONSOLE=y CONFIG_SERIAL_OF_PLATFORM=y +CONFIG_CPU_HAS_LSX=y +CONFIG_CPU_HAS_LASX=y ''', qemu_arch='loongarch64', kernel_path='arch/loongarch/boot/vmlinux.elf',

-- 2.49.0

On Wed, 11 Jun 2025 at 15:38, Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

Enable running UAPI tests as part of kunit. The selftests are embedded into the kernel image and their output is forwarded to kunit for unified reporting.

The implementation reuses parts of usermode drivers and usermode helpers. However these frameworks are not used directly as they make it impossible to retrieve a thread's exit code.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

---

It feels to me like there are three features hidden in here: - KUnit helpers for manipulating vfs files - A way of having KUnit tests run userspace helpers - The full framework for writing/running whole tests in userspace.

It's really the first two which excite me personally most -- as they give us a sort-of inverse to the kselftest "helper module" paradigm -- so we can test things which are impossible to test from within kernelspace. So maybe those APIs should be exposed separately (so a test can be written mostly in kernel-space using the KUnit framework APIs, and just call out to a helper where needed). But I'm happy for them to stay private functions until we have a test which actually needs them.

Currently this depends on CONFIG_KUNIT=y as it uses some non-exported symbols around process management.

That's fine for now, IMHO, but will make it difficult to use this on, e.g., Red Hat setups, where CONFIG_KUNIT=m. Hopefully we can resolve this by exporting some of the symbols?

In general, I'm happy with the implementation here. The fs stuff probably needs a closer look from someone who knows the vfs better than me, though.

Nevertheless, Reviewed-by: David Gow davidgow@google.com

Cheers, -- David

---

Documentation/dev-tools/kunit/api/index.rst | 5 + Documentation/dev-tools/kunit/api/uapi.rst | 12 ++ include/kunit/uapi.h | 24 +++ lib/kunit/Kconfig | 10 + lib/kunit/Makefile | 2 + lib/kunit/uapi.c | 287 ++++++++++++++++++++++++++++ 6 files changed, 340 insertions(+)

diff --git a/Documentation/dev-tools/kunit/api/index.rst b/Documentation/dev-tools/kunit/api/index.rst index 5cdb552a0808f25baeff5e47a9227b7b62c69e40..34d8fee9a97059d6da919a6fb1a7e359b5e0beef 100644 --- a/Documentation/dev-tools/kunit/api/index.rst +++ b/Documentation/dev-tools/kunit/api/index.rst @@ -9,6 +9,7 @@ API Reference test resource functionredirection

•   uapi
    clk
    of
    platformdevice
  

@@ -32,6 +33,10 @@ Documentation/dev-tools/kunit/api/functionredirection.rst

• Documents the KUnit Function Redirection API

+Documentation/dev-tools/kunit/api/uapi.rst

• • Documents the KUnit Userspace testing API

Driver KUnit API

diff --git a/Documentation/dev-tools/kunit/api/uapi.rst b/Documentation/dev-tools/kunit/api/uapi.rst new file mode 100644 index 0000000000000000000000000000000000000000..b4764424c629bf69194cf2786f52aef154b02bf8 --- /dev/null +++ b/Documentation/dev-tools/kunit/api/uapi.rst @@ -0,0 +1,12 @@ +.. SPDX-License-Identifier: GPL-2.0

+================== +Userspace Test API +==================

+This file documents all of the userspace testing API. +Userspace tests should be built as :ref:`userprogs <kbuild_userprogs>` and included into the test +module or kernel as :ref:`blobs <kbuild_blobs>`.

+.. kernel-doc:: include/kunit/uapi.h

• :internal:

diff --git a/include/kunit/uapi.h b/include/kunit/uapi.h new file mode 100644 index 0000000000000000000000000000000000000000..a6181790c96a42df05839097991c1fbfd889cdbe --- /dev/null +++ b/include/kunit/uapi.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/*

• • KUnit Userspace testing API.
• • Copyright (C) 2025, Linutronix GmbH.
• • Author: Thomas Weißschuh thomas.weissschuh@linutronix.de
• */

+#ifndef _KUNIT_UAPI_H +#define _KUNIT_UAPI_H

+struct blob; +struct kunit;

+/**

• • kunit_uapi_run_kselftest() - Run a userspace kselftest as part of kunit
• • @test: The test context object.
• • @executable: kselftest executable to run
• • Runs the kselftest and forwards its TAP output and exit status to kunit.
• */

+void kunit_uapi_run_kselftest(struct kunit *test, const struct blob *executable);

+#endif /* _KUNIT_UAPI_H */ diff --git a/lib/kunit/Kconfig b/lib/kunit/Kconfig index a97897edd9642f3e5df7fdd9dee26ee5cf00d6a4..1f2f5f2213a7d8438cd2683955f22e34f3a036dd 100644 --- a/lib/kunit/Kconfig +++ b/lib/kunit/Kconfig @@ -93,4 +93,14 @@ config KUNIT_AUTORUN_ENABLED In most cases this should be left as Y. Only if additional opt-in behavior is needed should this be set to N.

+config KUNIT_UAPI

•   def_bool y
  

Maybe it's worth making this configurable separately? I could imagine people wanting an easy way to build a kernel without all of the test blobs built-in.

•   depends on KUNIT=y
  

•   depends on CC_CAN_LINK_STATIC || ARCH_HAS_NOLIBC
  

•   select HEADERS_INSTALL
  

•   help
  

•     Enables support for building and running userspace selftests as part of kunit.
  

•     These tests should be statically linked and use kselftest.h or kselftest_harness.h
  

•     for status reporting.
  

endif # KUNIT diff --git a/lib/kunit/Makefile b/lib/kunit/Makefile index 656f1fa35abcc635e67d5b4cb1bc586b48415ac5..dafa09bd4241c24d31c4c19edecb67bf724127d7 100644 --- a/lib/kunit/Makefile +++ b/lib/kunit/Makefile @@ -12,6 +12,8 @@ kunit-objs += test.o \ device.o \ platform.o

+kunit-$(CONFIG_KUNIT_UAPI) += uapi.o

ifeq ($(CONFIG_KUNIT_DEBUGFS),y) kunit-objs += debugfs.o endif diff --git a/lib/kunit/uapi.c b/lib/kunit/uapi.c new file mode 100644 index 0000000000000000000000000000000000000000..121146dda533b3f90aca37c20bd0e7a1d20cb3b5 --- /dev/null +++ b/lib/kunit/uapi.c @@ -0,0 +1,287 @@ +// SPDX-License-Identifier: GPL-2.0 +/*

• • KUnit Userspace testing API.
• • Copyright (C) 2025, Linutronix GmbH.
• • Author: Thomas Weißschuh thomas.weissschuh@linutronix.de
• */

+#include <linux/binfmts.h> +#include <linux/blob.h> +#include <linux/file.h> +#include <linux/fs.h> +#include <linux/fs_struct.h> +#include <linux/pid.h> +#include <linux/pipe_fs_i.h> +#include <linux/sched/task.h> +#include <linux/types.h>

+#include <kunit/test.h> +#include <kunit/uapi.h>

+#define KSFT_PASS 0 +#define KSFT_FAIL 1 +#define KSFT_XFAIL 2 +#define KSFT_XPASS 3 +#define KSFT_SKIP 4

+static struct vfsmount *kunit_uapi_mount_ramfs(void) +{

•   struct file_system_type *type;
  

•   struct vfsmount *mnt;
  

•   type = get_fs_type("ramfs");
  

•   if (!type)
  

•           return ERR_PTR(-ENODEV);
  

•   /* FIXME
  

•    * The mount setup is supposed to look like this:
  

•    * kunit_uapi_mount_ramfs() sets up a private mount,
  

•    * with nothing visible except the new tmpfs.
  

•    * Then each executable execution gets a new namespace on top of that
  

•    * on which it can mount whatever it needs.
  

•    * However I didn't manage to set this up, so keep everything simple
  

•    * for now and let somebody familiar with the VFS figure this out.
  

•    */
  

•   mnt = kern_mount(type);
  

•   put_filesystem(type);
  

•   return mnt;
  

+}

+static int kunit_uapi_write_file(struct vfsmount *mnt, const char *name, mode_t mode,

•                            const u8 *data, size_t size)
  

+{

•   struct file *file;
  

•   ssize_t written;
  

•   file = file_open_root_mnt(mnt, name, O_CREAT | O_WRONLY, mode);
  

•   if (IS_ERR(file))
  

•           return PTR_ERR(file);
  

•   written = kernel_write(file, data, size, NULL);
  

•   filp_close(file, NULL);
  

•   if (written != size) {
  

•           if (written >= 0)
  

•                   return -ENOMEM;
  

•           return written;
  

•   }
  

•   /* Flush delayed fput so exec can open the file read-only */
  

•   flush_delayed_fput();
  

•   return 0;
  

+}

+struct kunit_uapi_user_mode_thread_ctx {

•   const char *executable;
  

•   /* Signals mnt, out, pwd and tgid */
  

•   struct completion setup_done;
  

•   struct vfsmount *mnt;
  

•   struct file *out;
  

•   struct path pwd;
  

•   pid_t tgid;
  

•   /* Valid after wait(tgid) */
  

•   int exec_err;
  

+};

+static int kunit_uapi_user_mode_thread_init(void *data) +{

•   struct kunit_uapi_user_mode_thread_ctx *ctx = data;
  

•   const char *const argv[] = {
  

•           ctx->executable,
  

•           NULL
  

•   };
  

•   struct file *out[2];
  

•   int err;
  

•   err = create_pipe_files(out, 0);
  

•   if (err)
  

•           return err;
  

•   /* stdin, use the *write* end to the pipe to have an unreadable input */
  

•   err = replace_fd(0, out[1], 0);
  

•   if (err < 0) {
  

•           fput(out[0]);
  

•           fput(out[1]);
  

•           return err;
  

•   }
  

•   /* stdout */
  

•   err = replace_fd(1, out[1], 0);
  

•   if (err < 0) {
  

•           replace_fd(0, NULL, 0);
  

•           fput(out[0]);
  

•           fput(out[1]);
  

•           return err;
  

•   }
  

•   /* stderr */
  

•   err = replace_fd(2, out[1], 0);
  

•   if (err < 0) {
  

•           replace_fd(0, NULL, 0);
  

•           replace_fd(1, NULL, 0);
  

•           fput(out[0]);
  

•           fput(out[1]);
  

•           return err;
  

•   }
  

•   fput(out[1]);
  

•   ctx->out = out[0];
  

•   ctx->tgid = current->tgid;
  

•   set_fs_pwd(current->fs, &ctx->pwd);
  

•   kernel_sigaction(SIGKILL, SIG_DFL);
  

•   kernel_sigaction(SIGABRT, SIG_DFL);
  

•   complete(&ctx->setup_done);
  

•   ctx->exec_err = kernel_execve(ctx->executable, argv, NULL);
  

•   if (!ctx->exec_err)
  

•           return 0;
  

•   do_exit(0);
  

+}

+static size_t kunit_uapi_printk_subtest_lines(struct kunit *test, char *buf, size_t s) +{

•   const char *ptr = buf, *newline;
  

•   size_t n;
  

•   while (s) {
  

•           newline = strnchr(ptr, s, '\n');
  

•           if (!newline)
  

•                   break;
  

•           n = newline - ptr + 1;
  

•           kunit_log(KERN_INFO, test, KUNIT_SUBSUBTEST_INDENT "%.*s", (int)n, ptr);
  

•           ptr += n;
  

•           s -= n;
  

•   }
  

•   memmove(buf, ptr, s);
  

•   return s;
  

+}

+static int kunit_uapi_forward_to_printk(struct kunit *test, struct file *output) +{

•   /*
  

•    * printk() automatically adds a newline after each message.
  

•    * Therefore only fully accumulated lines can be forwarded.
  

•    * Each line needs to fit into the buffer below.
  

•    */
  

•   char buf[512];
  

•   size_t s = 0;
  

•   ssize_t n;
  

•   while (1) {
  

•           n = kernel_read(output, buf + s, sizeof(buf) - s, NULL);
  

•           if (n <= 0)
  

•                   return n;
  

•           s = kunit_uapi_printk_subtest_lines(test, buf, s + n);
  

•   }
  

+}

+static void kunit_uapi_kill_pid(pid_t pid) +{

•   struct pid *p;
  

•   p = find_get_pid(pid);
  

•   kill_pid(p, SIGKILL, 1);
  

•   put_pid(p);
  

+}

+static int kunit_uapi_run_executable_in_mount(struct kunit *test, const char *executable,

•                                              struct vfsmount *mnt)
  

+{

•   struct kunit_uapi_user_mode_thread_ctx ctx = {
  

•           .setup_done     = COMPLETION_INITIALIZER_ONSTACK(ctx.setup_done),
  

•           .executable     = executable,
  

•           .pwd            = {
  

•                   .mnt    = mnt,
  

•                   .dentry = mnt->mnt_root,
  

•           },
  

•   };
  

•   int forward_err, wait_err, ret;
  

•   pid_t pid;
  

•   /* If SIGCHLD is ignored do_wait won't populate the status. */
  

•   kernel_sigaction(SIGCHLD, SIG_DFL);
  

•   pid = user_mode_thread(kunit_uapi_user_mode_thread_init, &ctx, SIGCHLD);
  

•   if (pid < 0) {
  

•           kernel_sigaction(SIGCHLD, SIG_IGN);
  

•           return pid;
  

•   }
  

•   wait_for_completion(&ctx.setup_done);
  

•   forward_err = kunit_uapi_forward_to_printk(test, ctx.out);
  

•   if (forward_err)
  

•           kunit_uapi_kill_pid(ctx.tgid);
  

•   wait_err = kernel_wait(ctx.tgid, &ret);
  

•   /* Restore default kernel sig handler */
  

•   kernel_sigaction(SIGCHLD, SIG_IGN);
  

•   if (ctx.exec_err)
  

•           return ctx.exec_err;
  

•   if (forward_err)
  

•           return forward_err;
  

•   if (wait_err < 0)
  

•           return wait_err;
  

•   return ret;
  

+}

+static int kunit_uapi_run_executable(struct kunit *test, const struct blob *executable) +{

•   const char *exe_name = kbasename(executable->path);
  

•   struct vfsmount *mnt;
  

•   int err;
  

•   mnt = kunit_uapi_mount_ramfs();
  

•   if (IS_ERR(mnt))
  

•           return PTR_ERR(mnt);
  

•   err = kunit_uapi_write_file(mnt, exe_name, 0755, executable->data, blob_size(executable));
  

•   if (!err)
  

•           err = kunit_uapi_run_executable_in_mount(test, exe_name, mnt);
  

•   kern_unmount(mnt);
  

•   return err;
  

+}

+void kunit_uapi_run_kselftest(struct kunit *test, const struct blob *executable) +{

•   u8 exit_code, exit_signal;
  

•   int err;
  

•   err = kunit_uapi_run_executable(test, executable);
  

•   if (err < 0)
  

•           KUNIT_FAIL(test, "Could not run test executable: %pe\n", ERR_PTR(err));
  

•   exit_code = err >> 8;
  

•   exit_signal = err & 0xff;
  

•   if (exit_signal)
  

•           KUNIT_FAIL(test, "kselftest exited with signal: %d\n", exit_signal);
  

•   else if (exit_code == KSFT_PASS)
  

•           ; /* Noop */
  

•   else if (exit_code == KSFT_FAIL)
  

•           KUNIT_FAIL(test, "kselftest exited with code KSFT_FAIL\n");
  

•   else if (exit_code == KSFT_XPASS)
  

•           KUNIT_FAIL(test, "kselftest exited with code KSFT_XPASS\n");
  

•   else if (exit_code == KSFT_XFAIL)
  

•           ; /* Noop */
  

•   else if (exit_code == KSFT_SKIP)
  

•           kunit_mark_skipped(test, "kselftest exited with code KSFT_SKIP\n");
  

•   else
  

•           KUNIT_FAIL(test, "kselftest exited with unknown exit code: %d\n", exit_code);
  

+} +EXPORT_SYMBOL_GPL(kunit_uapi_run_kselftest);

-- 2.49.0

On Fri, Jun 20, 2025 at 05:48:07PM +0800, David Gow wrote:

On Wed, 11 Jun 2025 at 15:38, Thomas Weißschuh thomas.weissschuh@linutronix.de wrote:

...

Show that the selftests are executed from a fairly "normal" userspace context.

Signed-off-by: Thomas Weißschuh thomas.weissschuh@linutronix.de

This is good. I'm not 100% sure the example test is the best place for it, though.

Would it make more sense to either have this:

• in the main kunit test (since it's really _verifying_ the KUnit

environment, rather than documenting it)

• in a separate kunit-uapi test (if we want to keep some separation

between the UAPI and entirely in-kernel tests)

• in a separate procfs test (since it tests procfs functionality as

much as it's testing the KUnit environment)

Originally this change was really meant as an example for users. But moving it into the main kunit test probably makes more sense.

Personally, my gut feeling is the main kunit-test is the best place for this, even if it means spinning up a separate file is best here.

Ack.

As for the actual implementation, though, that looks fine to me. A few small comments below, but nothing particularly important.

Reviewed-by: David Gow davidgow@google.com

Cheers, -- David

...

lib/kunit/kunit-example-uapi.c | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/lib/kunit/kunit-example-uapi.c b/lib/kunit/kunit-example-uapi.c index 4ce657050dd4a576632a41ca0309c4cb5134ce14..5e7a0f3b68f182c42b03e667567e66f02d8c2b86 100644 --- a/lib/kunit/kunit-example-uapi.c +++ b/lib/kunit/kunit-example-uapi.c @@ -8,13 +8,45 @@

• This is *userspace* code.

*/

+#include <fcntl.h> +#include <unistd.h> +#include <string.h>

#include "../../tools/testing/selftests/kselftest.h"

+static void test_procfs(void) +{

•   char buf[256];
  

•   ssize_t r;
  

•   int fd;
  

•   fd = open("/proc/self/comm", O_RDONLY);
  

•   if (fd == -1) {
  

•           ksft_test_result_fail("procfs: open() failed: %s\n", strerror(errno));
  

•           return;
  

•   }
  

•   r = read(fd, buf, sizeof(buf));
  

•   close(fd);
  

•   if (r == -1) {
  

•           ksft_test_result_fail("procfs: read() failed: %s\n", strerror(errno));
  

•           return;
  

•   }
  

Do we want to use TASK_COMM_LEN rather than hardcoding 16 below?

(And, if so, do we need something more complicated in case it's not 16?)

TASK_COMM_LEN is not part of the UAPI headers. But I don't think it can ever change.

...

•   if (r != 16 || strncmp("kunit-example-u\n", buf, 16) != 0) {
  

•           ksft_test_result_fail("procfs: incorrect comm\n");
  

•           return;
  

•   }
  

•   ksft_test_result_pass("procfs\n");
  

+}

int main(void) { ksft_print_header(); ksft_set_plan(4);

•   ksft_test_result_pass("userspace test 1\n");
  

•   test_procfs();
    ksft_test_result_pass("userspace test 2\n");
    ksft_test_result_skip("userspace test 3: some reason\n");
    ksft_test_result_pass("userspace test 4\n");
  
  

-- 2.49.0