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

[PATCH v2 0/3] KVM: selftests: arm64: Make use of sysreg defintions in get-reg-list

by Mark Brown

The system register definitions in the arm64 get-reg-list are all done with directly specified magic numbers rather than using the definitions we import from the main kernel. This is error prone, and requires us to audit the additions to get-reg-list separately to what we do when specifying the registers for the main kernel. Since Marc has indicated that this isn't a deliberate or desired choice let's start using the constants we have defined. We first manually update the data used to filter registers based on ID register fields to use a simplified macro that specifies the register and ID field in a muc more compact fashion. This is done first since there is an error in the ID register field for the S1PIE registers. We then replace all the remaining named system register specifications with use of the existing KVM_ARM64_SYS_REG() macro. This is just a first step, there's a bunch more work we could be doing here, the main thing being making use of the encodings in arch/arm64/tools/sysreg to convert more of the registers (including updating as more registers are converted to use the generator). Signed-off-by: Mark Brown <broonie(a)kernel.org> --- Changes in v2: - Add use of designated initalisers when converting filtering macros. - Manual handling of CNTV_CTL_EL0 and CNTV_CVAL_EL0. - Commit message tweaks. - Link to v1: https://lore.kernel.org/r/20240802-kvm-arm64-get-reg-list-v1-0-3a5bf8f80765… --- Mark Brown (3): KVM: selftests: arm64: Simplify specification of filtered registers KVM: selftests: arm64: Use symbolic definitions for incorrect encodings KVM: selftests: arm64: Use generated defines for named system registers tools/testing/selftests/kvm/aarch64/get-reg-list.c | 244 ++++++++++----------- 1 file changed, 122 insertions(+), 122 deletions(-) --- base-commit: 8400291e289ee6b2bf9779ff1c83a291501f017b change-id: 20240802-kvm-arm64-get-reg-list-a86a37460bdd Best regards, -- Mark Brown <broonie(a)kernel.org>

11 months

1
3
0 0

[PATCH] selftest/perf: Add perf-test to perform perf testcase

by Jeremy Szu

The perf test supports testing many functions and includes a way to detect the prerequisites for each test case. Add a script to launch the perf test. Signed-off-by: Jeremy Szu <jszu(a)nvidia.com> --- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/perf/Makefile | 5 ++++ tools/testing/selftests/perf/perf_test.sh | 30 +++++++++++++++++++++++ tools/testing/selftests/perf/settings | 1 + 4 files changed, 37 insertions(+) create mode 100644 tools/testing/selftests/perf/Makefile create mode 100755 tools/testing/selftests/perf/perf_test.sh create mode 100644 tools/testing/selftests/perf/settings diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile index 9039f3709affb..7598dd39cad28 100644 --- a/tools/testing/selftests/Makefile +++ b/tools/testing/selftests/Makefile @@ -67,6 +67,7 @@ TARGETS += net/openvswitch TARGETS += net/tcp_ao TARGETS += net/netfilter TARGETS += nsfs +TARGETS += perf TARGETS += perf_events TARGETS += pidfd TARGETS += pid_namespace diff --git a/tools/testing/selftests/perf/Makefile b/tools/testing/selftests/perf/Makefile new file mode 100644 index 0000000000000..72d90c71ab290 --- /dev/null +++ b/tools/testing/selftests/perf/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 + +TEST_PROGS := perf_test.sh + +include ../lib.mk diff --git a/tools/testing/selftests/perf/perf_test.sh b/tools/testing/selftests/perf/perf_test.sh new file mode 100755 index 0000000000000..ee78b4f9906cd --- /dev/null +++ b/tools/testing/selftests/perf/perf_test.sh @@ -0,0 +1,30 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0 + +skip() { + echo "SKIP: $1" + exit 4 +} + +fail() { + echo "FAIL: $1" + exit 255 +} + +if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then + [ "$(id -u)" -ne 0 ] && \ + skip "this test must be run as root." + which perf >/dev/null 2>&1 || \ + skip "perf is not installed." + + cmd_output=$(perf test -vv 2>&1) + perf_ret=$? + + if [ $perf_ret -ne 0 ]; then + (IFS='\n'; echo $cmd_output) + fail "perf command returns non-zero." + elif [[ $cmd_output == *"FAILED!"* ]]; then + (IFS='\n'; echo $cmd_output) + fail "perf test got FAILED!" + fi +fi diff --git a/tools/testing/selftests/perf/settings b/tools/testing/selftests/perf/settings new file mode 100644 index 0000000000000..a62d2fa1275c6 --- /dev/null +++ b/tools/testing/selftests/perf/settings @@ -0,0 +1 @@ +timeout=600 -- 2.34.1

11 months

1
0
0 0

[PATCH 0/2] KVM: selftests: arm64: Make use of sysreg defintions in get-reg-list

by Mark Brown

The system register definitions in the arm64 get-reg-list are all done with directly specified magic numbers rather than using the definitions we import from the main kernel. This is error prone, and requires us to audit the additions to get-reg-list separately to what we do when specifying the registers for the main kernel. Since Marc has indicated that this isn't a deliberate or desired choice let's start using the constants we have defined. We first manually update the data used to filter registers based on ID register fields to use a simplified macro that specifies the register and ID field in a muc more compact fashion. This is done first since there is an error in the ID register field for the S1PIE registers. We then replace all the remaining named system register specifications with use of the existing KVM_ARM64_SYS_REG() macro. Signed-off-by: Mark Brown <broonie(a)kernel.org> --- Mark Brown (2): KVM: selftests: arm64: Simplify specification of filtered registers KVM: selftests: arm64: Use generated defines for named system registers tools/testing/selftests/kvm/aarch64/get-reg-list.c | 237 ++++++++++----------- 1 file changed, 115 insertions(+), 122 deletions(-) --- base-commit: 8400291e289ee6b2bf9779ff1c83a291501f017b change-id: 20240802-kvm-arm64-get-reg-list-a86a37460bdd Best regards, -- Mark Brown <broonie(a)kernel.org>

11 months

3
6
0 0

[PATCH] kunit: Fix kunit_kstrdup_const() with modules

by David Gow

In commit 7d3c33b290b1 ("kunit: Device wrappers should also manage driver name"), the kunit_kstrdup_const() and kunit_kfree_const() were introduced as an optimisation of kunit_kstrdup(), which only copy/free strings from the kernel rodata. However, these are inline functions, and is_kernel_rodata() only works for built-in code. This causes problems in two cases: - If kunit is built as a module, __{start,end}_rodata is not defined. - If a kunit test using these functions is built as a module, it will suffer the same fate. Restrict the is_kernel_rodata() case to when KUnit is built as a module, which fixes the first case, at the cost of losing the optimisation. Also, make kunit_{kstrdup,kfree}_const non-inline, so that other modules using them will not accidentally depend on is_kernel_rodata(). If KUnit is built-in, they'll benefit from the optimisation, if KUnit is not, they won't, but the string will be properly duplicated. (And fix a couple of typos in the doc comment, too.) Reported-by: Nico Pache <npache(a)redhat.com> Closes: https://lore.kernel.org/all/CAA1CXcDKht4vOL-acxrARbm6JhGna8_k8wjYJ-vHONink8… Fixes: 7d3c33b290b1 ("kunit: Device wrappers should also manage driver name") Signed-off-by: David Gow <davidgow(a)google.com> --- include/kunit/test.h | 16 +++------------- lib/kunit/test.c | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+), 13 deletions(-) diff --git a/include/kunit/test.h b/include/kunit/test.h index da9e84de14c0..5ac237c949a0 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -489,11 +489,7 @@ static inline void *kunit_kcalloc(struct kunit *test, size_t n, size_t size, gfp * Calls kunit_kfree() only if @x is not in .rodata section. * See kunit_kstrdup_const() for more information. */ -static inline void kunit_kfree_const(struct kunit *test, const void *x) -{ - if (!is_kernel_rodata((unsigned long)x)) - kunit_kfree(test, x); -} +void kunit_kfree_const(struct kunit *test, const void *x); /** * kunit_kstrdup() - Duplicates a string into a test managed allocation. @@ -527,16 +523,10 @@ static inline char *kunit_kstrdup(struct kunit *test, const char *str, gfp_t gfp * @gfp: flags passed to underlying kmalloc(). * * Calls kunit_kstrdup() only if @str is not in the rodata section. Must be freed with - * kunit_free_const() -- not kunit_free(). + * kunit_kfree_const() -- not kunit_kfree(). * See kstrdup_const() and kunit_kmalloc_array() for more information. */ -static inline const char *kunit_kstrdup_const(struct kunit *test, const char *str, gfp_t gfp) -{ - if (is_kernel_rodata((unsigned long)str)) - return str; - - return kunit_kstrdup(test, str, gfp); -} +const char *kunit_kstrdup_const(struct kunit *test, const char *str, gfp_t gfp); /** * kunit_vm_mmap() - Allocate KUnit-tracked vm_mmap() area diff --git a/lib/kunit/test.c b/lib/kunit/test.c index e8b1b52a19ab..089c832e3cdb 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -874,6 +874,25 @@ void kunit_kfree(struct kunit *test, const void *ptr) } EXPORT_SYMBOL_GPL(kunit_kfree); +void kunit_kfree_const(struct kunit *test, const void *x) +{ +#if !IS_MODULE(CONFIG_KUNIT) + if (!is_kernel_rodata((unsigned long)x)) +#endif + kunit_kfree(test, x); +} +EXPORT_SYMBOL_GPL(kunit_kfree_const); + +const char *kunit_kstrdup_const(struct kunit *test, const char *str, gfp_t gfp) +{ +#if !IS_MODULE(CONFIG_KUNIT) + if (is_kernel_rodata((unsigned long)str)) + return str; +#endif + return kunit_kstrdup(test, str, gfp); +} +EXPORT_SYMBOL_GPL(kunit_kstrdup_const); + void kunit_cleanup(struct kunit *test) { struct kunit_resource *res; -- 2.46.0.rc2.264.g509ed76dc8-goog

11 months

2
1
0 0

[PATCH] kunit: Device wrappers should also manage driver name

by David Gow

kunit_driver_create() accepts a name for the driver, but does not copy it, so if that name is either on the stack, or otherwise freed, we end up with a use-after-free when the driver is cleaned up. Instead, strdup() the name, and manage it as another KUnit allocation. As there was no existing kunit_kstrdup(), we add one. Further, add a kunit_ variant of strdup_const() and kfree_const(), so we don't need to allocate and manage the string in the majority of cases where it's a constant. This fixes a KASAN splat with overflow.overflow_allocation_test, when built as a module. Fixes: d03c720e03bd ("kunit: Add APIs for managing devices") Reported-by: Nico Pache <npache(a)redhat.com> Closes: https://groups.google.com/g/kunit-dev/c/81V9b9QYON0 Signed-off-by: David Gow <davidgow(a)google.com> Reviewed-by: Kees Cook <kees(a)kernel.org> --- There's some more serious changes since the RFC I sent, so please take a closer look. Thanks, -- David Changes since RFC: https://groups.google.com/g/kunit-dev/c/81V9b9QYON0/m/PFKNKDKAAAAJ - Add and use the kunit_kstrdup_const() and kunit_free_const() functions. - Fix a typo in the doc comments. --- include/kunit/test.h | 58 ++++++++++++++++++++++++++++++++++++++++++++ lib/kunit/device.c | 7 ++++-- 2 files changed, 63 insertions(+), 2 deletions(-) diff --git a/include/kunit/test.h b/include/kunit/test.h index e2a1f0928e8b..da9e84de14c0 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -28,6 +28,7 @@ #include <linux/types.h> #include <asm/rwonce.h> +#include <asm/sections.h> /* Static key: true if any KUnit tests are currently running */ DECLARE_STATIC_KEY_FALSE(kunit_running); @@ -480,6 +481,63 @@ static inline void *kunit_kcalloc(struct kunit *test, size_t n, size_t size, gfp return kunit_kmalloc_array(test, n, size, gfp | __GFP_ZERO); } + +/** + * kunit_kfree_const() - conditionally free test managed memory + * @x: pointer to the memory + * + * Calls kunit_kfree() only if @x is not in .rodata section. + * See kunit_kstrdup_const() for more information. + */ +static inline void kunit_kfree_const(struct kunit *test, const void *x) +{ + if (!is_kernel_rodata((unsigned long)x)) + kunit_kfree(test, x); +} + +/** + * kunit_kstrdup() - Duplicates a string into a test managed allocation. + * + * @test: The test context object. + * @str: The NULL-terminated string to duplicate. + * @gfp: flags passed to underlying kmalloc(). + * + * See kstrdup() and kunit_kmalloc_array() for more information. + */ +static inline char *kunit_kstrdup(struct kunit *test, const char *str, gfp_t gfp) +{ + size_t len; + char *buf; + + if (!str) + return NULL; + + len = strlen(str) + 1; + buf = kunit_kmalloc(test, len, gfp); + if (buf) + memcpy(buf, str, len); + return buf; +} + +/** + * kunit_kstrdup_const() - Conditionally duplicates a string into a test managed allocation. + * + * @test: The test context object. + * @str: The NULL-terminated string to duplicate. + * @gfp: flags passed to underlying kmalloc(). + * + * Calls kunit_kstrdup() only if @str is not in the rodata section. Must be freed with + * kunit_free_const() -- not kunit_free(). + * See kstrdup_const() and kunit_kmalloc_array() for more information. + */ +static inline const char *kunit_kstrdup_const(struct kunit *test, const char *str, gfp_t gfp) +{ + if (is_kernel_rodata((unsigned long)str)) + return str; + + return kunit_kstrdup(test, str, gfp); +} + /** * kunit_vm_mmap() - Allocate KUnit-tracked vm_mmap() area * @test: The test context object. diff --git a/lib/kunit/device.c b/lib/kunit/device.c index 25c81ed465fb..520c1fccee8a 100644 --- a/lib/kunit/device.c +++ b/lib/kunit/device.c @@ -89,7 +89,7 @@ struct device_driver *kunit_driver_create(struct kunit *test, const char *name) if (!driver) return ERR_PTR(err); - driver->name = name; + driver->name = kunit_kstrdup_const(test, name, GFP_KERNEL); driver->bus = &kunit_bus_type; driver->owner = THIS_MODULE; @@ -192,8 +192,11 @@ void kunit_device_unregister(struct kunit *test, struct device *dev) const struct device_driver *driver = to_kunit_device(dev)->driver; kunit_release_action(test, device_unregister_wrapper, dev); - if (driver) + if (driver) { + const char *driver_name = driver->name; kunit_release_action(test, driver_unregister_wrapper, (void *)driver); + kunit_kfree_const(test, driver_name); + } } EXPORT_SYMBOL_GPL(kunit_device_unregister); -- 2.46.0.rc1.232.g9752f9e123-goog

11 months

4
4
0 0

[PATCH RFC 0/5] mm/gup: Introduce exclusive GUP pinning

by Elliot Berman

In arm64 pKVM and QuIC's Gunyah protected VM model, we want to support grabbing shmem user pages instead of using KVM's guestmemfd. These hypervisors provide a different isolation model than the CoCo implementations from x86. KVM's guest_memfd is focused on providing memory that is more isolated than AVF requires. Some specific examples include ability to pre-load data onto guest-private pages, dynamically sharing/isolating guest pages without copy, and (future) migrating guest-private pages. In sum of those differences after a discussion in [1] and at PUCK, we want to try to stick with existing shmem and extend GUP to support the isolation needs for arm64 pKVM and Gunyah. To that end, we introduce the concept of "exclusive GUP pinning", which enforces that only one pin of any kind is allowed when using the FOLL_EXCLUSIVE flag is set. This behavior doesn't affect FOLL_GET or any other folio refcount operations that don't go through the FOLL_PIN path. [1]: https://lore.kernel.org/all/20240319143119.GA2736@willie-the-truck/ Tree with patches at: https://git.codelinaro.org/clo/linux-kernel/gunyah-linux/-/tree/sent/exclus… anup(a)brainfault.org, paul.walmsley(a)sifive.com, palmer(a)dabbelt.com, aou(a)eecs.berkeley.edu, seanjc(a)google.com, viro(a)zeniv.linux.org.uk, brauner(a)kernel.org, willy(a)infradead.org, akpm(a)linux-foundation.org, xiaoyao.li(a)intel.com, yilun.xu(a)intel.com, chao.p.peng(a)linux.intel.com, jarkko(a)kernel.org, amoorthy(a)google.com, dmatlack(a)google.com, yu.c.zhang(a)linux.intel.com, isaku.yamahata(a)intel.com, mic(a)digikod.net, vbabka(a)suse.cz, vannapurve(a)google.com, ackerleytng(a)google.com, mail(a)maciej.szmigiero.name, david(a)redhat.com, michael.roth(a)amd.com, wei.w.wang(a)intel.com, liam.merwick(a)oracle.com, isaku.yamahata(a)gmail.com, kirill.shutemov(a)linux.intel.com, suzuki.poulose(a)arm.com, steven.price(a)arm.com, quic_eberman(a)quicinc.com, quic_mnalajal(a)quicinc.com, quic_tsoni(a)quicinc.com, quic_svaddagi(a)quicinc.com, quic_cvanscha(a)quicinc.com, quic_pderrin(a)quicinc.com, quic_pheragu(a)quicinc.com, catalin.marinas(a)arm.com, james.morse(a)arm.com, yuzenghui(a)huawei.com, oliver.upton(a)linux.dev, maz(a)kernel.org, will(a)kernel.org, qperret(a)google.com, keirf(a)google.com, tabba(a)google.com Signed-off-by: Elliot Berman <quic_eberman(a)quicinc.com> --- Elliot Berman (2): mm/gup-test: Verify exclusive pinned mm/gup_test: Verify GUP grabs same pages twice Fuad Tabba (3): mm/gup: Move GUP_PIN_COUNTING_BIAS to page_ref.h mm/gup: Add an option for obtaining an exclusive pin mm/gup: Add support for re-pinning a normal pinned page as exclusive include/linux/mm.h | 57 ++++---- include/linux/mm_types.h | 2 + include/linux/page_ref.h | 74 ++++++++++ mm/Kconfig | 5 + mm/gup.c | 265 ++++++++++++++++++++++++++++++---- mm/gup_test.c | 108 ++++++++++++++ mm/gup_test.h | 1 + tools/testing/selftests/mm/gup_test.c | 5 +- 8 files changed, 457 insertions(+), 60 deletions(-) --- base-commit: 6ba59ff4227927d3a8530fc2973b80e94b54d58f change-id: 20240509-exclusive-gup-66259138bbff Best regards, -- Elliot Berman <quic_eberman(a)quicinc.com>

11 months

13
68
0 0

[GIT PULL] Kselftest fixes update for Linux 6.11-rc3

by Shuah Khan

Hi Linus, Please pull the kselftest fixes update for Linux 6.11-rc3. This kselftest fixes update consists of a single fix to the conditional in ksft.py script which incorrectly flags a test suite failed when there are skipped tests in the mix. The logic is fixed to take skipped tests into account and report the test as passed. diff is attached. thanks, -- Shuah ---------------------------------------------------------------- The following changes since commit 8400291e289ee6b2bf9779ff1c83a291501f017b: Linux 6.11-rc1 (2024-07-28 14:19:55 -0700) are available in the Git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest tags/linux_kselftest-fixes-6.11-rc3 for you to fetch changes up to 170c966cbe274e664288cfc12ee919d5e706dc50: selftests: ksft: Fix finished() helper exit code on skipped tests (2024-07-31 11:38:56 -0600) ---------------------------------------------------------------- linux_kselftest-fixes-6.11-rc3 This kselftest fixes update consists of a single fix to the conditional in ksft.py script which incorrectly flags a test suite failed when there are skipped tests in the mix. The logic is fixed to take skipped tests into account and report the test as passed. ---------------------------------------------------------------- Laura Nao (1): selftests: ksft: Fix finished() helper exit code on skipped tests tools/testing/selftests/kselftest/ksft.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) ----------------------------------------------------------------

11 months

2
2
0 0

[PATCH v2] kselftest/devices/probe: Fix SyntaxWarning in regex strings for Python 3

by Alessandro Zanni

Insert raw strings to prevent Python3 from interpreting string literals as Unicode strings and, consequently, '\d' as an invalid escaped sequence. Avoid the 'SyntaxWarning: invalid escape sequence '\d'' warning for Python versions greater than 3.6. Fixes: dacf1d7a78bf ("kselftest: Add test to verify probe of devices from discoverable buses") Reviewed-by: Nícolas F. R. A. Prado <nfraprado(a)collabora.com> Signed-off-by: Alessandro Zanni <alessandro.zanni87(a)gmail.com> --- Notes: v2: Imperative mode description for the inserted changes, added previous commit tag fixed by this patch .../selftests/devices/probe/test_discoverable_devices.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/devices/probe/test_discoverable_devices.py b/tools/testing/selftests/devices/probe/test_discoverable_devices.py index d94a74b8a054..d7a2bb91c807 100755 --- a/tools/testing/selftests/devices/probe/test_discoverable_devices.py +++ b/tools/testing/selftests/devices/probe/test_discoverable_devices.py @@ -45,7 +45,7 @@ def find_pci_controller_dirs(): def find_usb_controller_dirs(): - usb_controller_sysfs_dir = "usb[\d]+" + usb_controller_sysfs_dir = r"usb[\d]+" dir_regex = re.compile(usb_controller_sysfs_dir) for d in os.scandir(sysfs_usb_devices): @@ -91,7 +91,7 @@ def get_acpi_uid(sysfs_dev_dir): def get_usb_version(sysfs_dev_dir): - re_usb_version = re.compile("PRODUCT=.*/(\d)/.*") + re_usb_version = re.compile(r"PRODUCT=.*/(\d)/.*") with open(os.path.join(sysfs_dev_dir, "uevent")) as f: return int(re_usb_version.search(f.read()).group(1)) -- 2.43.0

11 months

2
1
0 0

[PATCH v3] Kunit to check the longest symbol length

by Sergio González Collado

The longest length of a symbol (KSYM_NAME_LEN) was increased to 512 in the reference [1]. This patch adds a kunit test to check the longest symbol length. [1] https://lore.kernel.org/lkml/20220802015052.10452-6-ojeda@kernel.org/ Tested-by: Martin Rodriguez Reboredo <yakoyoku(a)gmail.com> Signed-off-by: Sergio González Collado <sergio.collado(a)gmail.com> --- V1 -> V2: corrected CI tests. Added fix proposed at [2] [2] https://lore.kernel.org/lkml/Y9ES4UKl%2F+DtvAVS@gmail.com/T/#m3ef0e12bb834d… --- V2 -> V3: updated base and added MODULE_DESCRIPTION() and MODULE_AUTHOR() --- arch/x86/tools/insn_decoder_test.c | 3 +- lib/Kconfig.debug | 9 +++ lib/Makefile | 2 + lib/longest_symbol_kunit.c | 124 +++++++++++++++++++++++++++++ 4 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 lib/longest_symbol_kunit.c diff --git a/arch/x86/tools/insn_decoder_test.c b/arch/x86/tools/insn_decoder_test.c index 472540aeabc2..3bde35ea4188 100644 --- a/arch/x86/tools/insn_decoder_test.c +++ b/arch/x86/tools/insn_decoder_test.c @@ -10,6 +10,7 @@ #include <assert.h> #include <unistd.h> #include <stdarg.h> +#include <linux/kallsysms.h> #define unlikely(cond) (cond) @@ -106,7 +107,7 @@ static void parse_args(int argc, char **argv) } } -#define BUFSIZE 256 +#define BUFSIZE (256 + KSYM_NAME_LEN) int main(int argc, char **argv) { diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index a30c03a66172..4587466f7d07 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2783,6 +2783,15 @@ config FORTIFY_KUNIT_TEST by the str*() and mem*() family of functions. For testing runtime traps of FORTIFY_SOURCE, see LKDTM's "FORTIFY_*" tests. +config LONGEST_SYM_KUNIT_TEST + tristate "Test the longest symbol possible" if !KUNIT_ALL_TESTS + depends on KUNIT && KPROBES + default KUNIT_ALL_TESTS + help + Tests the longest symbol possible + + If unsure, say N. + config HW_BREAKPOINT_KUNIT_TEST bool "Test hw_breakpoint constraints accounting" if !KUNIT_ALL_TESTS depends on HAVE_HW_BREAKPOINT diff --git a/lib/Makefile b/lib/Makefile index 322bb127b4dc..4241807025b8 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -388,6 +388,8 @@ CFLAGS_fortify_kunit.o += $(DISABLE_STRUCTLEAK_PLUGIN) obj-$(CONFIG_FORTIFY_KUNIT_TEST) += fortify_kunit.o obj-$(CONFIG_SIPHASH_KUNIT_TEST) += siphash_kunit.o obj-$(CONFIG_USERCOPY_KUNIT_TEST) += usercopy_kunit.o +obj-$(CONFIG_LONGEST_SYM_KUNIT_TEST) += longest_symbol_kunit.o +CFLAGS_longest_symbol_kunit.o += $(call cc-disable-warning, missing-prototypes) obj-$(CONFIG_GENERIC_LIB_DEVMEM_IS_ALLOWED) += devmem_is_allowed.o diff --git a/lib/longest_symbol_kunit.c b/lib/longest_symbol_kunit.c new file mode 100644 index 000000000000..557ad6eae56c --- /dev/null +++ b/lib/longest_symbol_kunit.c @@ -0,0 +1,124 @@ +// 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 + */ + +#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) + +#define PLUS1(name) __PASTE(name, e) + +/*Generate a symbol whose name length is 511 */ +#define LONGEST_SYM_NAME DDDDDI(g1h2i3j4k5l6m7n) + +/*Generate a symbol whose name length is 512 */ +#define LONGEST_SYM_NAME_PLUS1 PLUS1(LONGEST_SYM_NAME) + +#define RETURN_LONGEST_SYM 0xAAAAA +#define RETURN_LONGEST_SYM_PLUS1 0x55555 + +noinline int LONGEST_SYM_NAME(void); +noinline int LONGEST_SYM_NAME(void) +{ + return RETURN_LONGEST_SYM; +} + +noinline int LONGEST_SYM_NAME_PLUS1(void); +noinline int LONGEST_SYM_NAME_PLUS1(void) +{ + return RETURN_LONGEST_SYM_PLUS1; +} + +_Static_assert(sizeof(__stringify(LONGEST_SYM_NAME)) == KSYM_NAME_LEN, +"Incorrect symbol length found. Expected KSYM_NAME_LEN: " +__stringify(KSYM_NAME) ", 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\n", __func__); + KUNIT_FAIL(test, "test_longest_symbol kallsysms: 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 void test_longest_symbol_plus1(struct kunit *test) +{ + KUNIT_EXPECT_EQ(test, RETURN_LONGEST_SYM_PLUS1, LONGEST_SYM_NAME_PLUS1()); +}; + +static void test_longest_symbol_plus1_kallsyms(struct kunit *test) +{ + unsigned long (*kallsyms_lookup_name)(const char *name); + static int (*longest_sym_plus1)(void); + + struct kprobe kp = { + .symbol_name = "kallsyms_lookup_name", + }; + + if (register_kprobe(&kp) < 0) { + pr_info("%s: kprobe not registered\n", __func__); + KUNIT_FAIL(test, "test_longest_symbol kallsysms: kprobe not registered\n"); + return; + } + + kunit_warn(test, "test_longest_symbol_plus1 kallsyms: kprobe registered\n"); + kallsyms_lookup_name = (unsigned long (*)(const char *name))kp.addr; + unregister_kprobe(&kp); + + longest_sym_plus1 = + (void *) kallsyms_lookup_name(__stringify(LONGEST_SYM_NAME_PLUS1)); + KUNIT_EXPECT_NULL(test, longest_sym_plus1); +}; + +static struct kunit_case longest_symbol_test_cases[] = { + KUNIT_CASE(test_longest_symbol), + KUNIT_CASE(test_longest_symbol_kallsyms), + KUNIT_CASE(test_longest_symbol_plus1), + KUNIT_CASE(test_longest_symbol_plus1_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"); base-commit: de9c2c66ad8e787abec7c9d7eff4f8c3cdd28aed -- 2.39.2

11 months

1
0
0 0

[PATCH-cgroup 0/5] cgroup/cpuset: Miscellaneous cpuset updates for 6.12

by Waiman Long

The first 2 patches in this series fix cpuset bugs found by Chen Ridong. Patch 3 streamlines the sched domain rebuild process for hotplug operation and eliminates the use of intermediate cpuset states for sched domain generation. Patch 4 modifies generate_sched_domains() to check the correctness of partition roots with non-overlapping CPUs. Patch 5 adds new test cases to cover the bugs fixed in patches 1 and 2. Chen Ridong (1): cgroup/cpuset: fix panic caused by partcmd_update Waiman Long (4): cgroup/cpuset: Clear effective_xcpus on cpus_allowed clearing only if cpus.exclusive not set cgroup/cpuset: Eliminate unncessary sched domains rebuilds in hotplug cgroup/cpuset: Check for partition roots with overlapping CPUs selftest/cgroup: Add new test cases to test_cpuset_prs.sh kernel/cgroup/cpuset.c | 70 ++++++++++--------- .../selftests/cgroup/test_cpuset_prs.sh | 12 +++- 2 files changed, 49 insertions(+), 33 deletions(-) -- 2.43.5

11 months

2
8
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror