Merge tag 'linux_kselftest-kunit-6.15-rc1' of git://git.kernel.org/pub/scm/linux...

Pull kunit updates from Shuah Khan:
 "kunit tool:
   - Changes to kunit tool to use qboot on QEMU x86_64, and build GDB
     scripts
   - Fixes kunit tool bug in parsing test plan
   - Adds test to kunit tool to check parsing late test plan

  kunit:
   - Clarifies kunit_skip() argument name
   - Adds Kunit check for the longest symbol length
   - Changes qemu_configs for sparc to use Zilog console"

* tag 'linux_kselftest-kunit-6.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest:
  kunit: tool: add test to check parsing late test plan
  kunit: tool: Fix bug in parsing test plan
  Kunit to check the longest symbol length
  kunit: Clarify kunit_skip() argument name
  kunit: tool: Build GDB scripts
  kunit: qemu_configs: sparc: use Zilog console
  kunit: tool: Use qboot on QEMU x86_64

diff --cc lib/Kconfig.debug
Simple merge

diff --cc lib/tests/Makefile
index a434c7cb733a80708bbd9bfe3079bfde03707d89,8e4f42cb9c54f7e62a8ce3a9015363ec169457ac..5a4794c1826e7edfbf08695a3c8e39adab5bc378
--- 1/lib/tests/Makefile
--- 2/lib/tests/Makefile
+++ b/lib/tests/Makefile
@@@ -1,45 -1,1 +1,49 @@@
 +# SPDX-License-Identifier: GPL-2.0
 +#
 +# Makefile for tests of kernel library functions.
 +
 +# KUnit tests
 +CFLAGS_bitfield_kunit.o := $(DISABLE_STRUCTLEAK_PLUGIN)
 +obj-$(CONFIG_BITFIELD_KUNIT) += bitfield_kunit.o
 +obj-$(CONFIG_BITS_TEST) += test_bits.o
 +obj-$(CONFIG_BLACKHOLE_DEV_KUNIT_TEST) += blackhole_dev_kunit.o
 +obj-$(CONFIG_CHECKSUM_KUNIT) += checksum_kunit.o
 +obj-$(CONFIG_CMDLINE_KUNIT_TEST) += cmdline_kunit.o
 +obj-$(CONFIG_CPUMASK_KUNIT_TEST) += cpumask_kunit.o
 +obj-$(CONFIG_CRC_KUNIT_TEST) += crc_kunit.o
 +CFLAGS_fortify_kunit.o += $(call cc-disable-warning, unsequenced)
 +CFLAGS_fortify_kunit.o += $(call cc-disable-warning, stringop-overread)
 +CFLAGS_fortify_kunit.o += $(call cc-disable-warning, stringop-truncation)
 +CFLAGS_fortify_kunit.o += $(DISABLE_STRUCTLEAK_PLUGIN)
 +obj-$(CONFIG_FORTIFY_KUNIT_TEST) += fortify_kunit.o
 +CFLAGS_test_fprobe.o += $(CC_FLAGS_FTRACE)
 +obj-$(CONFIG_FPROBE_SANITY_TEST) += test_fprobe.o
 +obj-$(CONFIG_HASHTABLE_KUNIT_TEST) += hashtable_test.o
 +obj-$(CONFIG_HASH_KUNIT_TEST) += test_hash.o
 +obj-$(CONFIG_TEST_IOV_ITER) += kunit_iov_iter.o
 +obj-$(CONFIG_IS_SIGNED_TYPE_KUNIT_TEST) += is_signed_type_kunit.o
 +obj-$(CONFIG_KPROBES_SANITY_TEST) += test_kprobes.o
 +obj-$(CONFIG_LIST_KUNIT_TEST) += list-test.o
 +obj-$(CONFIG_KFIFO_KUNIT_TEST) += kfifo_kunit.o
 +obj-$(CONFIG_TEST_LIST_SORT) += test_list_sort.o
 +obj-$(CONFIG_LINEAR_RANGES_TEST) += test_linear_ranges.o
++
++CFLAGS_longest_symbol_kunit.o += $(call cc-disable-warning, missing-prototypes)
++obj-$(CONFIG_LONGEST_SYM_KUNIT_TEST) += longest_symbol_kunit.o
++
 +obj-$(CONFIG_MEMCPY_KUNIT_TEST) += memcpy_kunit.o
 +CFLAGS_overflow_kunit.o = $(call cc-disable-warning, tautological-constant-out-of-range-compare)
 +obj-$(CONFIG_OVERFLOW_KUNIT_TEST) += overflow_kunit.o
 +obj-$(CONFIG_PRINTF_KUNIT_TEST) += printf_kunit.o
 +obj-$(CONFIG_SCANF_KUNIT_TEST) += scanf_kunit.o
 +obj-$(CONFIG_SIPHASH_KUNIT_TEST) += siphash_kunit.o
 +obj-$(CONFIG_SLUB_KUNIT_TEST) += slub_kunit.o
 +obj-$(CONFIG_TEST_SORT) += test_sort.o
 +CFLAGS_stackinit_kunit.o += $(call cc-disable-warning, switch-unreachable)
 +obj-$(CONFIG_STACKINIT_KUNIT_TEST) += stackinit_kunit.o
 +obj-$(CONFIG_STRING_KUNIT_TEST) += string_kunit.o
 +obj-$(CONFIG_STRING_HELPERS_KUNIT_TEST) += string_helpers_kunit.o
 +obj-$(CONFIG_USERCOPY_KUNIT_TEST) += usercopy_kunit.o
 +obj-$(CONFIG_UTIL_MACROS_KUNIT) += util_macros_kunit.o
 +
  obj-$(CONFIG_TEST_RUNTIME_MODULE)             += module/

diff --cc lib/tests/longest_symbol_kunit.c
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..e3c28ff1807f0d31ba123e26c91c2f3ccb4385e9
new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/lib/tests/longest_symbol_kunit.c
@@@ -1,0 -1,0 +1,82 @@@
++// SPDX-License-Identifier: GPL-2.0
++/*
++ * Test the longest symbol length. Execute with:
++ *  ./tools/testing/kunit/kunit.py run longest-symbol
++ *  --arch=x86_64 --kconfig_add CONFIG_KPROBES=y --kconfig_add CONFIG_MODULES=y
++ *  --kconfig_add CONFIG_RETPOLINE=n --kconfig_add CONFIG_CFI_CLANG=n
++ *  --kconfig_add CONFIG_MITIGATION_RETPOLINE=n
++ */
++
++#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
++
++#include <kunit/test.h>
++#include <linux/stringify.h>
++#include <linux/kprobes.h>
++#include <linux/kallsyms.h>
++
++#define DI(name) s##name##name
++#define DDI(name) DI(n##name##name)
++#define DDDI(name) DDI(n##name##name)
++#define DDDDI(name) DDDI(n##name##name)
++#define DDDDDI(name) DDDDI(n##name##name)
++
++/*Generate a symbol whose name length is 511 */
++#define LONGEST_SYM_NAME  DDDDDI(g1h2i3j4k5l6m7n)
++
++#define RETURN_LONGEST_SYM 0xAAAAA
++
++noinline int LONGEST_SYM_NAME(void);
++noinline int LONGEST_SYM_NAME(void)
++{
++      return RETURN_LONGEST_SYM;
++}
++
++_Static_assert(sizeof(__stringify(LONGEST_SYM_NAME)) == KSYM_NAME_LEN,
++"Incorrect symbol length found. Expected KSYM_NAME_LEN: "
++__stringify(KSYM_NAME_LEN) ", but found: "
++__stringify(sizeof(LONGEST_SYM_NAME)));
++
++static void test_longest_symbol(struct kunit *test)
++{
++      KUNIT_EXPECT_EQ(test, RETURN_LONGEST_SYM, LONGEST_SYM_NAME());
++};
++
++static void test_longest_symbol_kallsyms(struct kunit *test)
++{
++      unsigned long (*kallsyms_lookup_name)(const char *name);
++      static int (*longest_sym)(void);
++
++      struct kprobe kp = {
++              .symbol_name = "kallsyms_lookup_name",
++      };
++
++      if (register_kprobe(&kp) < 0) {
++              pr_info("%s: kprobe not registered", __func__);
++              KUNIT_FAIL(test, "test_longest_symbol kallsyms: kprobe not registered\n");
++              return;
++      }
++
++      kunit_warn(test, "test_longest_symbol kallsyms: kprobe registered\n");
++      kallsyms_lookup_name = (unsigned long (*)(const char *name))kp.addr;
++      unregister_kprobe(&kp);
++
++      longest_sym =
++              (void *) kallsyms_lookup_name(__stringify(LONGEST_SYM_NAME));
++      KUNIT_EXPECT_EQ(test, RETURN_LONGEST_SYM, longest_sym());
++};
++
++static struct kunit_case longest_symbol_test_cases[] = {
++      KUNIT_CASE(test_longest_symbol),
++      KUNIT_CASE(test_longest_symbol_kallsyms),
++      {}
++};
++
++static struct kunit_suite longest_symbol_test_suite = {
++      .name = "longest-symbol",
++      .test_cases = longest_symbol_test_cases,
++};
++kunit_test_suite(longest_symbol_test_suite);
++
++MODULE_LICENSE("GPL");
++MODULE_DESCRIPTION("Test the longest symbol length");
++MODULE_AUTHOR("Sergio González Collado");