May 2023 - Linux-kselftest-mirror

[PATCH] selftests/input: Introduce basic tests for evdev ioctls

by eballetbo＠kernel.org

From: Enric Balletbo i Serra <eballetbo(a)kernel.org> This provides a basic infrastructure for the creation of tests for the evdev interface. Most of this is code is adapted from the libevdev wrapper library. While most of evdev ioctls are covered and tested using libevdev tests there are some evdev ioctls that aren't because are not supported (and will not be supported) by libevdev. So, adding, at least those tests, would make sense. The test creates an uinput device (and an evdev device) so you can call the wanted ioctl from userspace. So, to run those tests you need to have support for uinput and evdev as well. Signed-off-by: Enric Balletbo i Serra <eballetbo(a)kernel.org> --- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/input/.gitignore | 2 + tools/testing/selftests/input/Makefile | 5 + tools/testing/selftests/input/config | 3 + tools/testing/selftests/input/evioc-test.c | 282 +++++++++++++++++++++ 5 files changed, 293 insertions(+) create mode 100644 tools/testing/selftests/input/.gitignore create mode 100644 tools/testing/selftests/input/Makefile create mode 100644 tools/testing/selftests/input/config create mode 100644 tools/testing/selftests/input/evioc-test.c diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile index 90a62cf75008..29fc77168aa7 100644 --- a/tools/testing/selftests/Makefile +++ b/tools/testing/selftests/Makefile @@ -28,6 +28,7 @@ TARGETS += futex TARGETS += gpio TARGETS += hid TARGETS += intel_pstate +TARGETS += input TARGETS += iommu TARGETS += ipc TARGETS += ir diff --git a/tools/testing/selftests/input/.gitignore b/tools/testing/selftests/input/.gitignore new file mode 100644 index 000000000000..37f5dff3255b --- /dev/null +++ b/tools/testing/selftests/input/.gitignore @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0 +evioc-test diff --git a/tools/testing/selftests/input/Makefile b/tools/testing/selftests/input/Makefile new file mode 100644 index 000000000000..031729be0628 --- /dev/null +++ b/tools/testing/selftests/input/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 +CFLAGS += -D_GNU_SOURCE -std=gnu99 -Wl,-no-as-needed -Wall $(KHDR_INCLUDES) + +TEST_GEN_PROGS := evioc-test +include ../lib.mk diff --git a/tools/testing/selftests/input/config b/tools/testing/selftests/input/config new file mode 100644 index 000000000000..b7512f3e6d8d --- /dev/null +++ b/tools/testing/selftests/input/config @@ -0,0 +1,3 @@ +CONFIG_INPUT=y +CONFIG_INPUT_EVDEV=y +CONFIG_INPUT_UINPUT=m diff --git a/tools/testing/selftests/input/evioc-test.c b/tools/testing/selftests/input/evioc-test.c new file mode 100644 index 000000000000..4c0c8ebed378 --- /dev/null +++ b/tools/testing/selftests/input/evioc-test.c @@ -0,0 +1,282 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2023 Red Hat, Inc. + * + * Part of the code in this file is inspired and copied from the libevdev wrapper library + * for evdev devices written by Peter Hutterer. + */ + +#include <dirent.h> +#include <errno.h> +#include <fcntl.h> +#include <linux/uinput.h> +#include <poll.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> +#include <time.h> +#include <unistd.h> + +#include "../kselftest_harness.h" + +#define TEST_DEVICE_NAME "selftest input device" + +struct selftest_uinput { + int uinput_fd; /** file descriptor to uinput */ + int evdev_fd; /** file descriptor to evdev */ + char *name; /** device name */ + char *syspath; /** /sys path */ + char *devnode; /** device node */ +}; + +static int is_event_device(const struct dirent *dent) +{ + return strncmp("event", dent->d_name, 5) == 0; +} + +static char *fetch_device_node(const char *path) +{ + struct dirent **namelist; + char *devnode = NULL; + int ndev, i; + + ndev = scandir(path, &namelist, is_event_device, alphasort); + if (ndev <= 0) + return NULL; + + /* ndev should only ever be 1 */ + + for (i = 0; i < ndev; i++) { + if (!devnode && asprintf(&devnode, "/dev/input/%s", + namelist[i]->d_name) == -1) + devnode = NULL; + free(namelist[i]); + } + + free(namelist); + + return devnode; +} + +static int is_input_device(const struct dirent *dent) +{ + return strncmp("input", dent->d_name, 5) == 0; +} + +/* + * Device node is guessed based on the sysfs path, the sysfs path contains a + * eventN file, that corresponds to our /dev/input/eventN number. + */ +static int fetch_syspath_and_devnode(struct selftest_uinput *uidev) +{ +#define SYS_INPUT_DIR "/sys/devices/virtual/input/" + struct dirent **namelist; + int ndev, i; + int rc; + char buf[sizeof(SYS_INPUT_DIR) + 64] = SYS_INPUT_DIR; + + rc = ioctl(uidev->uinput_fd, + UI_GET_SYSNAME(sizeof(buf) - strlen(SYS_INPUT_DIR)), + &buf[strlen(SYS_INPUT_DIR)]); + if (rc != -1) { + uidev->syspath = strdup(buf); + uidev->devnode = fetch_device_node(buf); + return 0; + } + + ndev = scandir(SYS_INPUT_DIR, &namelist, is_input_device, alphasort); + if (ndev <= 0) + return -1; + + for (i = 0; i < ndev; i++) { + int fd, len; + + rc = snprintf(buf, sizeof(buf), "%s%s/name", SYS_INPUT_DIR, + namelist[i]->d_name); + if (rc < 0 || (size_t)rc >= sizeof(buf)) + continue; + + /* created within time frame */ + fd = open(buf, O_RDONLY); + if (fd < 0) + continue; + + len = read(fd, buf, sizeof(buf)); + close(fd); + if (len <= 0) + continue; + + buf[len - 1] = '\0'; /* file contains \n */ + if (strcmp(buf, uidev->name) == 0) { + if (uidev->syspath) { + fprintf(stderr, + "multiple identical devices found. syspath is unreliable\n"); + break; + } + + rc = snprintf(buf, sizeof(buf), "%s%s", SYS_INPUT_DIR, + namelist[i]->d_name); + + if (rc < 0 || (size_t)rc >= sizeof(buf)) { + fprintf(stderr, + "Invalid syspath, syspath is unreliable\n"); + break; + } + + uidev->syspath = strdup(buf); + uidev->devnode = fetch_device_node(buf); + } + } + + for (i = 0; i < ndev; i++) + free(namelist[i]); + free(namelist); + + return uidev->devnode ? 0 : -1; +#undef SYS_INPUT_DIR +} + +void selftest_uinput_destroy(struct selftest_uinput *uidev) +{ + if (!uidev) + return; + + if (uidev->uinput_fd >= 0) + ioctl(uidev->uinput_fd, UI_DEV_DESTROY, NULL); + + close(uidev->evdev_fd); + close(uidev->uinput_fd); + + free(uidev->syspath); + free(uidev->devnode); + free(uidev->name); + free(uidev); +} + +int selftest_uinput_create_device(struct selftest_uinput **uidev, ...) +{ + struct selftest_uinput *new_device; + struct uinput_setup setup; + va_list args; + int rc, fd; + int type; + + new_device = calloc(1, sizeof(struct selftest_uinput)); + if (!new_device) + return -ENOMEM; + + memset(&setup, 0, sizeof(setup)); + strncpy(setup.name, TEST_DEVICE_NAME, UINPUT_MAX_NAME_SIZE - 1); + setup.id.vendor = 0x1234; /* sample vendor */ + setup.id.product = 0x5678; /* sample product */ + setup.id.bustype = BUS_USB; + + fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK); + if (fd < 0) { + fprintf(stderr, "cannot open uinput (%d): %m\n", errno); + goto error; + } + + va_start(args, uidev); + rc = 0; + do { + type = va_arg(args, int); + if (type == -1) + break; + rc = ioctl(fd, UI_SET_EVBIT, type); + } while (rc == 0); + va_end(args); + + rc = ioctl(fd, UI_DEV_SETUP, &setup); + if (rc == -1) + goto error; + + rc = ioctl(fd, UI_DEV_CREATE, NULL); + if (rc == -1) + goto error; + + new_device->name = strdup(TEST_DEVICE_NAME); + new_device->uinput_fd = fd; + + if (fetch_syspath_and_devnode(new_device) == -1) { + fprintf(stderr, "unable to fetch syspath or device node.\n"); + errno = ENODEV; + goto error; + } + + fd = open(new_device->devnode, O_RDONLY); + if (fd < 0) { + fprintf(stderr, "cannot open uinput (%d): %m\n", errno); + goto error; + } + new_device->evdev_fd = fd; + + *uidev = new_device; + + return 0; + +error: + rc = -errno; + selftest_uinput_destroy(new_device); + return rc; +} + +const char *selftest_uinput_get_devnode(struct selftest_uinput *uidev) +{ + return uidev->devnode; +} + +TEST(eviocgname_get_device_name) +{ + struct selftest_uinput *uidev; + char buf[256]; + int rc; + + rc = selftest_uinput_create_device(&uidev); + ASSERT_EQ(0, rc); + ASSERT_NE(NULL, uidev); + + memset(buf, 0, sizeof(buf)); + /* ioctl to get the name */ + rc = ioctl(uidev->evdev_fd, EVIOCGNAME(sizeof(buf) - 1), buf); + ASSERT_GE(rc, 0); + ASSERT_STREQ(TEST_DEVICE_NAME, buf); + + selftest_uinput_destroy(uidev); +} + +TEST(eviocgrep_get_repeat_settings) +{ + struct selftest_uinput *uidev; + int rep_values[2]; + int rc; + + memset(rep_values, 0, sizeof(rep_values)); + + rc = selftest_uinput_create_device(&uidev); + ASSERT_EQ(0, rc); + ASSERT_NE(NULL, uidev); + + /* ioctl to get the repeat rates values */ + rc = ioctl(uidev->evdev_fd, EVIOCSREP, rep_values); + /* should fail because EV_REP is not set */ + ASSERT_EQ(-1, rc); + + selftest_uinput_destroy(uidev); + + rc = selftest_uinput_create_device(&uidev, EV_REP); + ASSERT_EQ(0, rc); + ASSERT_NE(NULL, uidev); + + /* ioctl to get the repeat rates values */ + rc = ioctl(uidev->evdev_fd, EVIOCGREP, rep_values); + ASSERT_EQ(0, rc); + /* should get the default delay an period values set by the kernel */ + ASSERT_EQ(rep_values[0], 250); + ASSERT_EQ(rep_values[1], 33); + + selftest_uinput_destroy(uidev); +} + +TEST_HARNESS_MAIN -- 2.40.1

1 year

2
1
0 0

[PATCH v2 0/7] nolibc: add generic part1 of prepare for rv32

by Zhangjin Wu

Hi, All Thanks very much for your review suggestions of the v1 series [1], this is the generic part1 of the v2 revison. * selftests/nolibc: syscall_args: use generic __NR_statx A more generic statx is used instead of fstat (Review suggestions from Willy, Arnd) * selftests/nolibc: allow specify extra arguments for qemu Besides BIOS, QEMU_ARGS_EXTRA is better for more requirements (Review suggestions from Thomas, Willy) * selftests/nolibc: fix up compile warning with glibc on x86_64 Definition of uint64_t differs from glibc and nolibc, use the right print format here * selftests/nolibc: not include limits.h for nolibc Remove the requirement of limits.h for nolibc can let us use older glibc for rv32 (Review suggestions from thomas) * selftests/nolibc: use INT_MAX instead of __INT_MAX__ A trivial cleanup, based on the previous patch * tools/nolibc: arm: add missing my_syscall6 Required by future forced pselect6/pselect6_time64, tested on arm/vexpress-a9 (Review suggestions from Arnd) * tools/nolibc: open: fix up compile warning for arm A trivial fixup based on compiler's suggestion and glibc code Best regards, Zhangjin ---- [1]: https://lore.kernel.org/linux-riscv/20230529113143.GB2762@1wt.eu/T/#t Zhangjin Wu (7): selftests/nolibc: syscall_args: use __NR_statx for rv32 selftests/nolibc: allow specify extra arguments for qemu selftests/nolibc: fix up compile warning with glibc on x86_64 selftests/nolibc: not include limits.h for nolibc selftests/nolibc: use INT_MAX instead of __INT_MAX__ tools/nolibc: arm: add missing my_syscall6 tools/nolibc: open: fix up compile warning for arm tools/include/nolibc/arch-arm.h | 23 ++++++++++++++++++++ tools/include/nolibc/stdint.h | 14 ++++++++++++ tools/include/nolibc/sys.h | 2 +- tools/testing/selftests/nolibc/Makefile | 2 +- tools/testing/selftests/nolibc/nolibc-test.c | 14 +++++++----- 5 files changed, 47 insertions(+), 8 deletions(-) -- 2.25.1

1 year

2
9
0 0

[PATCH] tracing/user_events: Handle matching arguments that is null from dyn_events

by sunliming

When A registering user event from dyn_events has no argments, it will pass the matching check, regardless of whether there is a user event with the same name and arguments. Add the matching check when the arguments of registering user event is null. Signed-off-by: sunliming <sunliming(a)kylinos.cn> --- kernel/trace/trace_events_user.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/kernel/trace/trace_events_user.c b/kernel/trace/trace_events_user.c index e90161294698..0d91dac206ff 100644 --- a/kernel/trace/trace_events_user.c +++ b/kernel/trace/trace_events_user.c @@ -1712,6 +1712,8 @@ static bool user_event_match(const char *system, const char *event, if (match && argc > 0) match = user_fields_match(user, argc, argv); + else if (match && argc == 0) + match = list_empty(&user->fields); return match; } -- 2.25.1

1 year

2
1
0 0

[PATCH 6.1 5.15 5.10 5.4 4.19 4.14] selftests/memfd: Fix unknown type name build failure

by Hardik Garg

Partially backport v6.3 commit 11f75a01448f ("selftests/memfd: add tests for MFD_NOEXEC_SEAL MFD_EXEC") to fix an unknown type name build error. In some systems, the __u64 typedef is not present due to differences in system headers, causing compilation errors like this one: fuse_test.c:64:8: error: unknown type name '__u64' 64 | static __u64 mfd_assert_get_seals(int fd) This header includes the __u64 typedef which increases the likelihood of successful compilation on a wider variety of systems. Signed-off-by: Hardik Garg <hargar(a)linux.microsoft.com> --- tools/testing/selftests/memfd/fuse_test.c | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/testing/selftests/memfd/fuse_test.c b/tools/testing/selftests/memfd/fuse_test.c index be675002f918..93798c8c5d54 100644 --- a/tools/testing/selftests/memfd/fuse_test.c +++ b/tools/testing/selftests/memfd/fuse_test.c @@ -22,6 +22,7 @@ #include <linux/falloc.h> #include <fcntl.h> #include <linux/memfd.h> +#include <linux/types.h> #include <sched.h> #include <stdio.h> #include <stdlib.h> -- 2.25.1

1 year

3
2
0 0

[PATCH v2 0/2] tools/nolibc: avoid coredumps and speed up tests

by Thomas Weißschuh

Small optimization to avoid coredump writing during the stack protector tests. Adds prctl() as prerequisite. This series is based on nolibc/20230524-nolibc-rv32+stkp4 Signed-off-by: Thomas Weißschuh <linux(a)weissschuh.net> --- Changes in v2: - Fix compilation warning in prctl() testcase - Link to v1: https://lore.kernel.org/r/20230526-nolibc-test-no-dump-v1-0-62e724a96db2@we… --- Thomas Weißschuh (2): tools/nolibc: add support for prctl() selftests/nolibc: prevent coredumps during test execution tools/include/nolibc/sys.h | 27 +++++++++++++++++++++++++++ tools/testing/selftests/nolibc/nolibc-test.c | 3 +++ 2 files changed, 30 insertions(+) --- base-commit: 1974a2b5fd434812b32952b09df7b79fdee8104d change-id: 20230526-nolibc-test-no-dump-a1b1d9557df8 Best regards, -- Thomas Weißschuh <linux(a)weissschuh.net>

1 year

2
3
0 0

[PATCH] tools/nolibc: support nanoseconds in stat()

by Thomas Weißschuh

Keep backwards compatibility through unions. The compatibility macros like #define st_atime st_atim.tv_sec as documented in stat(3type) don't work for nolibc because it would break with other stat-like structures that contain the field st_atime. Signed-off-by: Thomas Weißschuh <linux(a)weissschuh.net> --- tools/include/nolibc/sys.h | 29 +++++++++++++++------------- tools/include/nolibc/types.h | 6 +++--- tools/testing/selftests/nolibc/nolibc-test.c | 23 ++++++++++++++++++++++ 3 files changed, 42 insertions(+), 16 deletions(-) diff --git a/tools/include/nolibc/sys.h b/tools/include/nolibc/sys.h index 7874062bea95..11b354e26861 100644 --- a/tools/include/nolibc/sys.h +++ b/tools/include/nolibc/sys.h @@ -1187,19 +1187,22 @@ int sys_stat(const char *path, struct stat *buf) #else #error Neither __NR_newfstatat nor __NR_stat defined, cannot implement sys_stat() #endif - buf->st_dev = stat.st_dev; - buf->st_ino = stat.st_ino; - buf->st_mode = stat.st_mode; - buf->st_nlink = stat.st_nlink; - buf->st_uid = stat.st_uid; - buf->st_gid = stat.st_gid; - buf->st_rdev = stat.st_rdev; - buf->st_size = stat.st_size; - buf->st_blksize = stat.st_blksize; - buf->st_blocks = stat.st_blocks; - buf->st_atime = stat.st_atime; - buf->st_mtime = stat.st_mtime; - buf->st_ctime = stat.st_ctime; + buf->st_dev = stat.st_dev; + buf->st_ino = stat.st_ino; + buf->st_mode = stat.st_mode; + buf->st_nlink = stat.st_nlink; + buf->st_uid = stat.st_uid; + buf->st_gid = stat.st_gid; + buf->st_rdev = stat.st_rdev; + buf->st_size = stat.st_size; + buf->st_blksize = stat.st_blksize; + buf->st_blocks = stat.st_blocks; + buf->st_atim.tv_sec = stat.st_atime; + buf->st_atim.tv_nsec = stat.st_atime_nsec; + buf->st_mtim.tv_sec = stat.st_mtime; + buf->st_mtim.tv_nsec = stat.st_mtime_nsec; + buf->st_ctim.tv_sec = stat.st_ctime; + buf->st_ctim.tv_nsec = stat.st_ctime_nsec; return ret; } #endif diff --git a/tools/include/nolibc/types.h b/tools/include/nolibc/types.h index 15b0baffd336..f96e28bff4ba 100644 --- a/tools/include/nolibc/types.h +++ b/tools/include/nolibc/types.h @@ -198,9 +198,9 @@ struct stat { off_t st_size; /* total size, in bytes */ blksize_t st_blksize; /* blocksize for file system I/O */ blkcnt_t st_blocks; /* number of 512B blocks allocated */ - time_t st_atime; /* time of last access */ - time_t st_mtime; /* time of last modification */ - time_t st_ctime; /* time of last status change */ + union { time_t st_atime; struct timespec st_atim; }; /* time of last access */ + union { time_t st_mtime; struct timespec st_mtim; }; /* time of last modification */ + union { time_t st_ctime; struct timespec st_ctim; }; /* time of last status change */ }; /* WARNING, it only deals with the 4096 first majors and 256 first minors */ diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c index 6e0a4dbe321e..8de72c87b7b7 100644 --- a/tools/testing/selftests/nolibc/nolibc-test.c +++ b/tools/testing/selftests/nolibc/nolibc-test.c @@ -500,6 +500,28 @@ static int test_fork(void) } } +static int test_stat_timestamps(void) +{ + struct stat st; + + if (sizeof(st.st_atim.tv_sec) != sizeof(st.st_atime)) + return 1; + + if (stat("/proc/self/", &st)) + return 1; + + if (st.st_atim.tv_sec != st.st_atime || st.st_atim.tv_nsec > 1000000000) + return 1; + + if (st.st_mtim.tv_sec != st.st_mtime || st.st_mtim.tv_nsec > 1000000000) + return 1; + + if (st.st_ctim.tv_sec != st.st_ctime || st.st_ctim.tv_nsec > 1000000000) + return 1; + + return 0; +} + /* Run syscall tests between IDs <min> and <max>. * Return 0 on success, non-zero on failure. */ @@ -587,6 +609,7 @@ int run_syscall(int min, int max) CASE_TEST(select_fault); EXPECT_SYSER(1, select(1, (void *)1, NULL, NULL, 0), -1, EFAULT); break; CASE_TEST(stat_blah); EXPECT_SYSER(1, stat("/proc/self/blah", &stat_buf), -1, ENOENT); break; CASE_TEST(stat_fault); EXPECT_SYSER(1, stat(NULL, &stat_buf), -1, EFAULT); break; + CASE_TEST(stat_timestamps); EXPECT_SYSZR(1, test_stat_timestamps()); break; CASE_TEST(symlink_root); EXPECT_SYSER(1, symlink("/", "/"), -1, EEXIST); break; CASE_TEST(unlink_root); EXPECT_SYSER(1, unlink("/"), -1, EISDIR); break; CASE_TEST(unlink_blah); EXPECT_SYSER(1, unlink("/proc/self/blah"), -1, ENOENT); break; --- base-commit: 1974a2b5fd434812b32952b09df7b79fdee8104d change-id: 20230527-nolibc-stat-nanoseconds-35de1467a430 Best regards, -- Thomas Weißschuh <linux(a)weissschuh.net>

1 year

2
1
0 0

[PATCH 0/2] tools/nolibc: avoid coredumps and speed up tests

by Thomas Weißschuh

Small optimization to avoid coredump writing during the stack protector tests. Adds prctl() as prerequisite. This series is based on nolibc/20230524-nolibc-rv32+stkp4 Signed-off-by: Thomas Weißschuh <linux(a)weissschuh.net> --- Thomas Weißschuh (2): tools/nolibc: add support for prctl() selftests/nolibc: prevent coredumps during test execution tools/include/nolibc/sys.h | 27 +++++++++++++++++++++++++++ tools/testing/selftests/nolibc/nolibc-test.c | 3 +++ 2 files changed, 30 insertions(+) --- base-commit: 1974a2b5fd434812b32952b09df7b79fdee8104d change-id: 20230526-nolibc-test-no-dump-a1b1d9557df8 Best regards, -- Thomas Weißschuh <linux(a)weissschuh.net>

1 year

2
3
0 0

[RESEND PATCH v5 1/3] test_firmware: prevent race conditions by a correct implementation of locking

by Mirsad Goran Todorovac

Dan Carpenter spotted a race condition in a couple of situations like these in the test_firmware driver: static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { u8 val; int ret; ret = kstrtou8(buf, 10, &val); if (ret) return ret; mutex_lock(&test_fw_mutex); *(u8 *)cfg = val; mutex_unlock(&test_fw_mutex); /* Always return full write size even if we didn't consume all */ return size; } static ssize_t config_num_requests_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int rc; mutex_lock(&test_fw_mutex); if (test_fw_config->reqs) { pr_err("Must call release_all_firmware prior to changing config\n"); rc = -EINVAL; mutex_unlock(&test_fw_mutex); goto out; } mutex_unlock(&test_fw_mutex); rc = test_dev_config_update_u8(buf, count, &test_fw_config->num_requests); out: return rc; } static ssize_t config_read_fw_idx_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { return test_dev_config_update_u8(buf, count, &test_fw_config->read_fw_idx); } The function test_dev_config_update_u8() is called from both the locked and the unlocked context, function config_num_requests_store() and config_read_fw_idx_store() which can both be called asynchronously as they are driver's methods, while test_dev_config_update_u8() and siblings change their argument pointed to by u8 *cfg or similar pointer. To avoid deadlock on test_fw_mutex, the lock is dropped before calling test_dev_config_update_u8() and re-acquired within test_dev_config_update_u8() itself, but alas this creates a race condition. Having two locks wouldn't assure a race-proof mutual exclusion. This situation is best avoided by the introduction of a new, unlocked function __test_dev_config_update_u8() which can be called from the locked context and reducing test_dev_config_update_u8() to: static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { int ret; mutex_lock(&test_fw_mutex); ret = __test_dev_config_update_u8(buf, size, cfg); mutex_unlock(&test_fw_mutex); return ret; } doing the locking and calling the unlocked primitive, which enables both locked and unlocked versions without duplication of code. The similar approach was applied to all functions called from the locked and the unlocked context, which safely mitigates both deadlocks and race conditions in the driver. __test_dev_config_update_bool(), __test_dev_config_update_u8() and __test_dev_config_update_size_t() unlocked versions of the functions were introduced to be called from the locked contexts as a workaround without releasing the main driver's lock and thereof causing a race condition. The test_dev_config_update_bool(), test_dev_config_update_u8() and test_dev_config_update_size_t() locked versions of the functions are being called from driver methods without the unnecessary multiplying of the locking and unlocking code for each method, and complicating the code with saving of the return value across lock. Fixes: 7feebfa487b92 ("test_firmware: add support for request_firmware_into_buf") Cc: Luis Chamberlain <mcgrof(a)kernel.org> Cc: Greg Kroah-Hartman <gregkh(a)linuxfoundation.org> Cc: Russ Weight <russell.h.weight(a)intel.com> Cc: Takashi Iwai <tiwai(a)suse.de> Cc: Tianfei Zhang <tianfei.zhang(a)intel.com> Cc: Shuah Khan <shuah(a)kernel.org> Cc: Colin Ian King <colin.i.king(a)gmail.com> Cc: Randy Dunlap <rdunlap(a)infradead.org> Cc: linux-kselftest(a)vger.kernel.org Cc: stable(a)vger.kernel.org # v5.4 Suggested-by: Dan Carpenter <error27(a)gmail.com> Signed-off-by: Mirsad Goran Todorovac <mirsad.todorovac(a)alu.unizg.hr> --- lib/test_firmware.c | 52 ++++++++++++++++++++++++++++++--------------- 1 file changed, 35 insertions(+), 17 deletions(-) diff --git a/lib/test_firmware.c b/lib/test_firmware.c index 05ed84c2fc4c..35417e0af3f4 100644 --- a/lib/test_firmware.c +++ b/lib/test_firmware.c @@ -353,16 +353,26 @@ static ssize_t config_test_show_str(char *dst, return len; } -static int test_dev_config_update_bool(const char *buf, size_t size, +static inline int __test_dev_config_update_bool(const char *buf, size_t size, bool *cfg) { int ret; - mutex_lock(&test_fw_mutex); if (kstrtobool(buf, cfg) < 0) ret = -EINVAL; else ret = size; + + return ret; +} + +static int test_dev_config_update_bool(const char *buf, size_t size, + bool *cfg) +{ + int ret; + + mutex_lock(&test_fw_mutex); + ret = __test_dev_config_update_bool(buf, size, cfg); mutex_unlock(&test_fw_mutex); return ret; @@ -373,7 +383,8 @@ static ssize_t test_dev_config_show_bool(char *buf, bool val) return snprintf(buf, PAGE_SIZE, "%d\n", val); } -static int test_dev_config_update_size_t(const char *buf, +static int __test_dev_config_update_size_t( + const char *buf, size_t size, size_t *cfg) { @@ -384,9 +395,7 @@ static int test_dev_config_update_size_t(const char *buf, if (ret) return ret; - mutex_lock(&test_fw_mutex); *(size_t *)cfg = new; - mutex_unlock(&test_fw_mutex); /* Always return full write size even if we didn't consume all */ return size; @@ -402,7 +411,7 @@ static ssize_t test_dev_config_show_int(char *buf, int val) return snprintf(buf, PAGE_SIZE, "%d\n", val); } -static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) +static int __test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) { u8 val; int ret; @@ -411,14 +420,23 @@ static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) if (ret) return ret; - mutex_lock(&test_fw_mutex); *(u8 *)cfg = val; - mutex_unlock(&test_fw_mutex); /* Always return full write size even if we didn't consume all */ return size; } +static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg) +{ + int ret; + + mutex_lock(&test_fw_mutex); + ret = __test_dev_config_update_u8(buf, size, cfg); + mutex_unlock(&test_fw_mutex); + + return ret; +} + static ssize_t test_dev_config_show_u8(char *buf, u8 val) { return snprintf(buf, PAGE_SIZE, "%u\n", val); @@ -471,10 +489,10 @@ static ssize_t config_num_requests_store(struct device *dev, mutex_unlock(&test_fw_mutex); goto out; } - mutex_unlock(&test_fw_mutex); - rc = test_dev_config_update_u8(buf, count, - &test_fw_config->num_requests); + rc = __test_dev_config_update_u8(buf, count, + &test_fw_config->num_requests); + mutex_unlock(&test_fw_mutex); out: return rc; @@ -518,10 +536,10 @@ static ssize_t config_buf_size_store(struct device *dev, mutex_unlock(&test_fw_mutex); goto out; } - mutex_unlock(&test_fw_mutex); - rc = test_dev_config_update_size_t(buf, count, - &test_fw_config->buf_size); + rc = __test_dev_config_update_size_t(buf, count, + &test_fw_config->buf_size); + mutex_unlock(&test_fw_mutex); out: return rc; @@ -548,10 +566,10 @@ static ssize_t config_file_offset_store(struct device *dev, mutex_unlock(&test_fw_mutex); goto out; } - mutex_unlock(&test_fw_mutex); - rc = test_dev_config_update_size_t(buf, count, - &test_fw_config->file_offset); + rc = __test_dev_config_update_size_t(buf, count, + &test_fw_config->file_offset); + mutex_unlock(&test_fw_mutex); out: return rc; -- 2.30.2

1 year

4
9
0 0

[RFC PATCH] kunit: Move kunit_abort() call out of kunit_do_failed_assertion()

by David Gow

KUnit aborts the current thread when an assertion fails. Currently, this is done conditionally as part of the kunit_do_failed_assertion() function, but this hides the kunit_abort() call from the compiler (particularly if it's in another module). This, in turn, can lead to both suboptimal code generation (the compiler can't know if kunit_do_failed_assertion() will return), and to static analysis tools like smatch giving false positives. Moving the kunit_abort() call into the macro should give the compiler and tools a better chance at understanding what's going on. Doing so requires exporting kunit_abort(), though it's recommended to continue to use assertions in lieu of aborting directly. Suggested-by: Dan Carpenter <dan.carpenter(a)linaro.org> Signed-off-by: David Gow <davidgow(a)google.com> --- include/kunit/test.h | 4 ++++ lib/kunit/test.c | 5 +---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/include/kunit/test.h b/include/kunit/test.h index 2f23d6efa505..6a35e3e2a1e5 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -481,6 +481,8 @@ void __printf(2, 3) kunit_log_append(char *log, const char *fmt, ...); */ #define KUNIT_SUCCEED(test) do {} while (0) +void __noreturn kunit_abort(struct kunit *test); + void kunit_do_failed_assertion(struct kunit *test, const struct kunit_loc *loc, enum kunit_assert_type type, @@ -498,6 +500,8 @@ void kunit_do_failed_assertion(struct kunit *test, assert_format, \ fmt, \ ##__VA_ARGS__); \ + if (assert_type == KUNIT_ASSERTION) \ + kunit_abort(test); \ } while (0) diff --git a/lib/kunit/test.c b/lib/kunit/test.c index d3fb93a23ccc..3b350e50cab9 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -310,7 +310,7 @@ static void kunit_fail(struct kunit *test, const struct kunit_loc *loc, string_stream_destroy(stream); } -static void __noreturn kunit_abort(struct kunit *test) +void __noreturn kunit_abort(struct kunit *test) { kunit_try_catch_throw(&test->try_catch); /* Does not return. */ @@ -340,9 +340,6 @@ void kunit_do_failed_assertion(struct kunit *test, kunit_fail(test, loc, type, assert, assert_format, &message); va_end(args); - - if (type == KUNIT_ASSERTION) - kunit_abort(test); } EXPORT_SYMBOL_GPL(kunit_do_failed_assertion); -- 2.41.0.rc0.172.g3f132b7071-goog

1 year

3
3
0 0

[PATCH 5.10 0/3] Fix for CVE-2022-4269

by Dragos-Marian Panait

The following commits are needed to fix CVE-2022-4269: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?… https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?… https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?… Davide Caratti (2): net/sched: act_mirred: better wording on protection against excessive stack growth act_mirred: use the backlog for nested calls to mirred ingress wenxu (1): net/sched: act_mirred: refactor the handle of xmit include/net/sch_generic.h | 5 -- net/sched/act_mirred.c | 44 +++++++++++------ .../selftests/net/forwarding/tc_actions.sh | 48 ++++++++++++++++++- 3 files changed, 77 insertions(+), 20 deletions(-) base-commit: f1b32fda06d2cfb8eea9680b0ba7a8b0d5b81eeb -- 2.40.1

1 year

2
4
0 0

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror May 2023