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

[PATCH 0/4] kselftests/arm64: add PAuth tests

by Boyan Karatotev

Pointer Authentication (PAuth) is a security feature introduced in ARMv8.3. It introduces instructions to sign addresses and later check for potential corruption using a second modifier value and one of a set of keys. The signature, in the form of the Pointer Authentication Code (PAC), is stored in some of the top unused bits of the virtual address (e.g. [54: 49] if TBID0 is enabled and TnSZ is set to use a 48 bit VA space). A set of controls are present to enable/disable groups of instructions (which use certain keys) for compatibility with libraries that do not utilize the feature. PAuth is used to verify the integrity of return addresses on the stack with less memory than the stack canary. This patchset adds kselftests to verify the kernel's configuration of the feature and its runtime behaviour. There are 7 tests which verify that: * an authentication failure leads to a SIGSEGV * the data/instruction instruction groups are enabled * the generic instructions are enabled * all 5 keys are unique for a single thread * exec() changes all keys to new unique ones * context switching preserves the 4 data/instruction keys * context switching preserves the generic keys The tests have been verified to work on qemu without a working PAUTH Implementation and on ARM's FVP with a full or partial PAuth implementation. Note: This patchset is only verified for ARMv8.3 and there will be some changes required for ARMv8.6. More details can be found here [1]. Once ARMv8.6 PAuth is merged the first test in this series will required to be updated. [1] https://lore.kernel.org/linux-arm-kernel/1597734671-23407-1-git-send-email-… Cc: Shuah Khan <shuah(a)kernel.org> Cc: Catalin Marinas <catalin.marinas(a)arm.com> Cc: Will Deacon <will(a)kernel.org> Signed-off-by: Boyan Karatotev <boyan.karatotev(a)arm.com> Boyan Karatotev (4): kselftests/arm64: add a basic Pointer Authentication test kselftests/arm64: add nop checks for PAuth tests kselftests/arm64: add PAuth test for whether exec() changes keys kselftests/arm64: add PAuth tests for single threaded consistency and key uniqueness tools/testing/selftests/arm64/Makefile | 2 +- .../testing/selftests/arm64/pauth/.gitignore | 2 + tools/testing/selftests/arm64/pauth/Makefile | 29 ++ .../selftests/arm64/pauth/exec_target.c | 35 ++ tools/testing/selftests/arm64/pauth/helper.c | 41 +++ tools/testing/selftests/arm64/pauth/helper.h | 30 ++ tools/testing/selftests/arm64/pauth/pac.c | 347 ++++++++++++++++++ .../selftests/arm64/pauth/pac_corruptor.S | 36 ++ 8 files changed, 521 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/arm64/pauth/.gitignore create mode 100644 tools/testing/selftests/arm64/pauth/Makefile create mode 100644 tools/testing/selftests/arm64/pauth/exec_target.c create mode 100644 tools/testing/selftests/arm64/pauth/helper.c create mode 100644 tools/testing/selftests/arm64/pauth/helper.h create mode 100644 tools/testing/selftests/arm64/pauth/pac.c create mode 100644 tools/testing/selftests/arm64/pauth/pac_corruptor.S -- 2.17.1

4 years, 9 months

5
23
0 0

[PATCH v20 00/12] Landlock LSM

by Mickaël Salaün

Hi, This new patch series mainly replace the landlock(2) command multiplexor with 4 new dedicated syscalls: * landlock_get_features(2) * landlock_create_ruleset(2) * landlock_add_rule(2) * landlock_enforce_ruleset(2) The SLOC count is 1264 for security/landlock/ and 1712 for tools/testing/selftest/landlock/ . Test coverage for security/landlock/ is 93.6% of lines. The code not covered only deals with internal kernel errors (e.g. memory allocation) and race conditions. The compiled documentation is available here: https://landlock.io/linux-doc/landlock-v20/security/landlock/index.html This series can be applied on top of v5.8-rc4 . This can be tested with CONFIG_SECURITY_LANDLOCK and CONFIG_SAMPLE_LANDLOCK. This patch series can be found in a Git repository here: https://github.com/landlock-lsm/linux/commits/landlock-v20 I would really appreciate constructive comments on this patch series. # Landlock LSM The goal of Landlock is to enable to restrict ambient rights (e.g. global filesystem access) for a set of processes. Because Landlock is a stackable LSM [1], it makes possible to create safe security sandboxes as new security layers in addition to the existing system-wide access-controls. This kind of sandbox is expected to help mitigate the security impact of bugs or unexpected/malicious behaviors in user-space applications. Landlock empowers any process, including unprivileged ones, to securely restrict themselves. Landlock is inspired by seccomp-bpf but instead of filtering syscalls and their raw arguments, a Landlock rule can restrict the use of kernel objects like file hierarchies, according to the kernel semantic. Landlock also takes inspiration from other OS sandbox mechanisms: XNU Sandbox, FreeBSD Capsicum or OpenBSD Pledge/Unveil. In this current form, Landlock misses some access-control features. This enables to minimize this patch series and ease review. This series still addresses multiple use cases, especially with the combined use of seccomp-bpf: applications with built-in sandboxing, init systems, security sandbox tools and security-oriented APIs [2]. Previous version: https://lore.kernel.org/lkml/20200707180955.53024-1-mic@digikod.net/ [1] https://lore.kernel.org/lkml/50db058a-7dde-441b-a7f9-f6837fe8b69f@schaufler… [2] https://lore.kernel.org/lkml/f646e1c7-33cf-333f-070c-0a40ad0468cd@digikod.n… Casey Schaufler (1): LSM: Infrastructure management of the superblock Mickaël Salaün (11): landlock: Add object management landlock: Add ruleset and domain management landlock: Set up the security framework and manage credentials landlock: Add ptrace restrictions fs,security: Add sb_delete hook landlock: Support filesystem access-control landlock: Add syscall implementations arch: Wire up Landlock syscalls selftests/landlock: Add initial tests samples/landlock: Add a sandbox manager example landlock: Add user and kernel documentation Documentation/security/index.rst | 1 + Documentation/security/landlock/index.rst | 18 + Documentation/security/landlock/kernel.rst | 69 + Documentation/security/landlock/user.rst | 271 +++ MAINTAINERS | 11 + arch/Kconfig | 7 + arch/alpha/kernel/syscalls/syscall.tbl | 4 + arch/arm/tools/syscall.tbl | 4 + arch/arm64/include/asm/unistd.h | 2 +- arch/arm64/include/asm/unistd32.h | 8 + arch/ia64/kernel/syscalls/syscall.tbl | 4 + arch/m68k/kernel/syscalls/syscall.tbl | 4 + arch/microblaze/kernel/syscalls/syscall.tbl | 4 + arch/mips/kernel/syscalls/syscall_n32.tbl | 4 + arch/mips/kernel/syscalls/syscall_n64.tbl | 4 + arch/mips/kernel/syscalls/syscall_o32.tbl | 4 + arch/parisc/kernel/syscalls/syscall.tbl | 4 + arch/powerpc/kernel/syscalls/syscall.tbl | 4 + arch/s390/kernel/syscalls/syscall.tbl | 4 + arch/sh/kernel/syscalls/syscall.tbl | 4 + arch/sparc/kernel/syscalls/syscall.tbl | 4 + arch/um/Kconfig | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 4 + arch/x86/entry/syscalls/syscall_64.tbl | 4 + arch/xtensa/kernel/syscalls/syscall.tbl | 4 + fs/super.c | 1 + include/linux/lsm_hook_defs.h | 1 + include/linux/lsm_hooks.h | 3 + include/linux/security.h | 4 + include/linux/syscalls.h | 8 + include/uapi/asm-generic/unistd.h | 10 +- include/uapi/linux/landlock.h | 209 ++ kernel/sys_ni.c | 6 + samples/Kconfig | 7 + samples/Makefile | 1 + samples/landlock/.gitignore | 1 + samples/landlock/Makefile | 15 + samples/landlock/sandboxer.c | 248 +++ security/Kconfig | 11 +- security/Makefile | 2 + security/landlock/Kconfig | 18 + security/landlock/Makefile | 4 + security/landlock/common.h | 20 + security/landlock/cred.c | 46 + security/landlock/cred.h | 58 + security/landlock/fs.c | 609 ++++++ security/landlock/fs.h | 60 + security/landlock/object.c | 66 + security/landlock/object.h | 91 + security/landlock/ptrace.c | 120 ++ security/landlock/ptrace.h | 14 + security/landlock/ruleset.c | 342 ++++ security/landlock/ruleset.h | 157 ++ security/landlock/setup.c | 40 + security/landlock/setup.h | 18 + security/landlock/syscall.c | 571 ++++++ security/security.c | 51 +- security/selinux/hooks.c | 58 +- security/selinux/include/objsec.h | 6 + security/selinux/ss/services.c | 3 +- security/smack/smack.h | 6 + security/smack/smack_lsm.c | 35 +- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/landlock/.gitignore | 2 + tools/testing/selftests/landlock/Makefile | 29 + tools/testing/selftests/landlock/base_test.c | 154 ++ tools/testing/selftests/landlock/common.h | 122 ++ tools/testing/selftests/landlock/config | 5 + tools/testing/selftests/landlock/fs_test.c | 1698 +++++++++++++++++ .../testing/selftests/landlock/ptrace_test.c | 310 +++ tools/testing/selftests/landlock/true.c | 5 + 71 files changed, 5621 insertions(+), 77 deletions(-) create mode 100644 Documentation/security/landlock/index.rst create mode 100644 Documentation/security/landlock/kernel.rst create mode 100644 Documentation/security/landlock/user.rst create mode 100644 include/uapi/linux/landlock.h create mode 100644 samples/landlock/.gitignore create mode 100644 samples/landlock/Makefile create mode 100644 samples/landlock/sandboxer.c create mode 100644 security/landlock/Kconfig create mode 100644 security/landlock/Makefile create mode 100644 security/landlock/common.h create mode 100644 security/landlock/cred.c create mode 100644 security/landlock/cred.h create mode 100644 security/landlock/fs.c create mode 100644 security/landlock/fs.h create mode 100644 security/landlock/object.c create mode 100644 security/landlock/object.h create mode 100644 security/landlock/ptrace.c create mode 100644 security/landlock/ptrace.h create mode 100644 security/landlock/ruleset.c create mode 100644 security/landlock/ruleset.h create mode 100644 security/landlock/setup.c create mode 100644 security/landlock/setup.h create mode 100644 security/landlock/syscall.c create mode 100644 tools/testing/selftests/landlock/.gitignore create mode 100644 tools/testing/selftests/landlock/Makefile create mode 100644 tools/testing/selftests/landlock/base_test.c create mode 100644 tools/testing/selftests/landlock/common.h create mode 100644 tools/testing/selftests/landlock/config create mode 100644 tools/testing/selftests/landlock/fs_test.c create mode 100644 tools/testing/selftests/landlock/ptrace_test.c create mode 100644 tools/testing/selftests/landlock/true.c -- 2.28.0.rc2

4 years, 9 months

3
18
0 0

Re: [patch 08/13] sched: Clenaup PREEMPT_COUNT leftovers

by Valentin Schneider

On 14/09/20 21:42, Thomas Gleixner wrote: > CONFIG_PREEMPT_COUNT is now unconditionally enabled and will be > removed. Cleanup the leftovers before doing so. > > Signed-off-by: Thomas Gleixner <tglx(a)linutronix.de> > Cc: Ingo Molnar <mingo(a)redhat.com> > Cc: Peter Zijlstra <peterz(a)infradead.org> > Cc: Juri Lelli <juri.lelli(a)redhat.com> > Cc: Vincent Guittot <vincent.guittot(a)linaro.org> > Cc: Dietmar Eggemann <dietmar.eggemann(a)arm.com> > Cc: Steven Rostedt <rostedt(a)goodmis.org> > Cc: Ben Segall <bsegall(a)google.com> > Cc: Mel Gorman <mgorman(a)suse.de> > Cc: Daniel Bristot de Oliveira <bristot(a)redhat.com> Small nit below; Reviewed-by: Valentin Schneider <valentin.schneider(a)arm.com> > --- > kernel/sched/core.c | 6 +----- > lib/Kconfig.debug | 1 - > 2 files changed, 1 insertion(+), 6 deletions(-) > > --- a/kernel/sched/core.c > +++ b/kernel/sched/core.c > @@ -3706,8 +3706,7 @@ asmlinkage __visible void schedule_tail( > * finish_task_switch() for details. > * > * finish_task_switch() will drop rq->lock() and lower preempt_count > - * and the preempt_enable() will end up enabling preemption (on > - * PREEMPT_COUNT kernels). I suppose this wanted to be s/PREEMPT_COUNT/PREEMPT/ in the first place, which ought to be still relevant. > + * and the preempt_enable() will end up enabling preemption. > */ > > rq = finish_task_switch(prev);

4 years, 9 months

1
0
0 0

Re: [patch 03/13] preempt: Clenaup PREEMPT_COUNT leftovers

by Valentin Schneider

On 14/09/20 21:42, Thomas Gleixner wrote: > CONFIG_PREEMPT_COUNT is now unconditionally enabled and will be > removed. Cleanup the leftovers before doing so. > > Signed-off-by: Thomas Gleixner <tglx(a)linutronix.de> > Cc: Ingo Molnar <mingo(a)kernel.org> > Cc: Peter Zijlstra <peterz(a)infradead.org> > Cc: Juri Lelli <juri.lelli(a)redhat.com> > Cc: Vincent Guittot <vincent.guittot(a)linaro.org> > Cc: Dietmar Eggemann <dietmar.eggemann(a)arm.com> > Cc: Steven Rostedt <rostedt(a)goodmis.org> > Cc: Ben Segall <bsegall(a)google.com> > Cc: Mel Gorman <mgorman(a)suse.de> > Cc: Daniel Bristot de Oliveira <bristot(a)redhat.com> Reviewed-by: Valentin Schneider <valentin.schneider(a)arm.com>

4 years, 9 months

1
0
0 0

Re: [PATCH 2/2 v7] rseq/selftests: test MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ

by Mathieu Desnoyers

[ Adding selftests maintainer and mailing list in CC. You should add them to the CC list of the selftests patches for the next round. ] ----- On Sep 15, 2020, at 2:55 PM, Peter Oskolkov posk(a)google.com wrote: > Based on Google-internal RSEQ work done by > Paul Turner and Andrew Hunter. > > This patch adds a selftest for MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ. > The test quite often fails without the previous patch in this patchset, > but consistently passes with it. Did you consider moving this test into tools/testing/selftests/rseq/param_test.c instead, and update the script "run_param_test.sh" accordingly ? You would leverage for free all the work I have done to insert configurable delay loops into the critical sections, which will very likely increase the likelihood of failure tremendously. Reproducible frequent and fast failure is really something we want to aim for here when a bug is hiding. > > v3: added rseq_offset_deref_addv() to x86_64 to make the test > more explicit; on other architectures I kept using existing > rseq_cmpeqv_cmpeqv_storev() as I have no easy way to test > there. Added a comment explaining why the test works this way. > v4: skipped the test if rseq_offset_deref_addv() is not present > (that is, on all architectures other than x86_64). > > Signed-off-by: Peter Oskolkov <posk(a)google.com> > --- > .../selftests/rseq/basic_percpu_ops_test.c | 187 ++++++++++++++++++ > tools/testing/selftests/rseq/rseq-x86.h | 57 ++++++ > 2 files changed, 244 insertions(+) > > diff --git a/tools/testing/selftests/rseq/basic_percpu_ops_test.c > b/tools/testing/selftests/rseq/basic_percpu_ops_test.c > index eb3f6db36d36..e6e10ba4b9ed 100644 > --- a/tools/testing/selftests/rseq/basic_percpu_ops_test.c > +++ b/tools/testing/selftests/rseq/basic_percpu_ops_test.c > @@ -3,16 +3,24 @@ > #include <assert.h> > #include <pthread.h> > #include <sched.h> > +#include <stdatomic.h> That would be the first time stdatomic.h is included in the kernel selftests. Do we want this dependency ? > #include <stdint.h> > #include <stdio.h> > #include <stdlib.h> > #include <string.h> > #include <stddef.h> > +#include <syscall.h> > +#include <unistd.h> > > #include "rseq.h" > > #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) > > +/* The local <linux/membarrier.h> may not contain the commands below. */ > +#define MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ (1<<7) > +#define MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ (1<<8) > +#define MEMBARRIER_CMD_FLAG_CPU (1<<0) > + The usual way to build and run tests AFAIK is to do "make headers_install" first, and then build the tests against those headers. Therefore, when building the tests, the additional membarrier commands and flags should always be there. Please remove those duplicated preprocessor defines. > struct percpu_lock_entry { > intptr_t v; > } __attribute__((aligned(128))); > @@ -289,6 +297,183 @@ void test_percpu_list(void) > assert(sum == expected_sum); > } > > +struct test_membarrier_thread_args { > + int stop; > + intptr_t percpu_list_ptr; > +}; > + > +/* Worker threads modify data in their "active" percpu lists. */ > +void *test_membarrier_worker_thread(void *arg) > +{ > + struct test_membarrier_thread_args *args = > + (struct test_membarrier_thread_args *)arg; > + const int iters = 10 * 1000 * 1000; > + int i; > + > + if (rseq_register_current_thread()) { > + fprintf(stderr, "Error: rseq_register_current_thread(...) failed(%d): %s\n", > + errno, strerror(errno)); > + abort(); > + } > + > + /* Wait for initialization. */ > + while (!atomic_load(&args->percpu_list_ptr)) {} > + > + for (i = 0; i < iters; ++i) { > + int ret; > + > + do { > + int cpu = rseq_cpu_start(); > + > + ret = rseq_offset_deref_addv(&args->percpu_list_ptr, > + 128 * cpu, 1, cpu); That 128 happens to be related to: struct percpu_list_entry { struct percpu_list_node *head; } __attribute__((aligned(128))); struct percpu_list { struct percpu_list_entry c[CPU_SETSIZE]; }; Please don't hardcode numbers like that. Instead: + ret = rseq_offset_deref_addv(&args->percpu_list_ptr, + sizeof(struct percpu_list_entry) * cpu, 1, cpu); > + } while (rseq_unlikely(ret)); > + } > + > + if (rseq_unregister_current_thread()) { > + fprintf(stderr, "Error: rseq_unregister_current_thread(...) failed(%d): > %s\n", > + errno, strerror(errno)); > + abort(); > + } > + return NULL; > +} > + > +void test_membarrier_init_percpu_list(struct percpu_list *list) > +{ > + int i; > + > + memset(list, 0, sizeof(*list)); > + for (i = 0; i < CPU_SETSIZE; i++) { > + struct percpu_list_node *node; > + > + node = malloc(sizeof(*node)); > + assert(node); > + node->data = 0; > + node->next = NULL; > + list->c[i].head = node; > + } > +} > + > +void test_membarrier_free_percpu_list(struct percpu_list *list) > +{ > + int i; > + > + for (i = 0; i < CPU_SETSIZE; i++) > + free(list->c[i].head); > +} > + > +static int sys_membarrier(int cmd, int flags, int cpu_id) > +{ > + return syscall(__NR_membarrier, cmd, flags, cpu_id); > +} > + > +/* > + * The manager thread swaps per-cpu lists that worker threads see, > + * and validates that there are no unexpected modifications. > + */ > +void *test_membarrier_manager_thread(void *arg) > +{ > + struct test_membarrier_thread_args *args = > + (struct test_membarrier_thread_args *)arg; > + struct percpu_list list_a, list_b; > + intptr_t expect_a = 0, expect_b = 0; > + int cpu_a = 0, cpu_b = 0; > + > + if (rseq_register_current_thread()) { > + fprintf(stderr, "Error: rseq_register_current_thread(...) failed(%d): %s\n", > + errno, strerror(errno)); > + abort(); > + } > + > + /* Init lists. */ > + test_membarrier_init_percpu_list(&list_a); > + test_membarrier_init_percpu_list(&list_b); > + > + atomic_store(&args->percpu_list_ptr, (intptr_t)&list_a); > + > + while (!atomic_load(&args->stop)) { > + /* list_a is "active". */ > + cpu_a = rand() % CPU_SETSIZE; > + /* > + * As list_b is "inactive", we should never see changes > + * to list_b. > + */ > + if (expect_b != atomic_load(&list_b.c[cpu_b].head->data)) { > + fprintf(stderr, "Membarrier test failed\n"); > + abort(); > + } > + > + /* Make list_b "active". */ > + atomic_store(&args->percpu_list_ptr, (intptr_t)&list_b); > + sys_membarrier(MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ, > + MEMBARRIER_CMD_FLAG_CPU, cpu_a); missing error check. > + /* > + * Cpu A should now only modify list_b, so we values we -> the > + * in list_a should be stable. > + */ > + expect_a = atomic_load(&list_a.c[cpu_a].head->data); > + > + cpu_b = rand() % CPU_SETSIZE; > + /* > + * As list_a is "inactive", we should never see changes > + * to list_a. > + */ > + if (expect_a != atomic_load(&list_a.c[cpu_a].head->data)) { > + fprintf(stderr, "Membarrier test failed\n"); > + abort(); > + } > + > + /* Make list_a "active". */ > + atomic_store(&args->percpu_list_ptr, (intptr_t)&list_a); > + sys_membarrier(MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ, > + MEMBARRIER_CMD_FLAG_CPU, cpu_b); missing error check. > + /* Remember a value from list_b. */ > + expect_b = atomic_load(&list_b.c[cpu_b].head->data); > + } > + > + test_membarrier_free_percpu_list(&list_a); > + test_membarrier_free_percpu_list(&list_b); > + > + if (rseq_unregister_current_thread()) { > + fprintf(stderr, "Error: rseq_unregister_current_thread(...) failed(%d): > %s\n", > + errno, strerror(errno)); > + abort(); > + } > + return NULL; > +} > + > +/* Test MEMBARRIER_CMD_PRIVATE_RESTART_RSEQ_ON_CPU membarrier command. */ > +void test_membarrier(void) > +{ > +#ifndef RSEQ_ARCH_HAS_OFFSET_DEREF_ADDV Please lift the preprocessor conditional outside of the function, e.g.: #ifdef RSEQ_ARCH_HAS_OFFSET_DEREF_ADDV void test_membarrier(void) { [... code goes here...] } #else /* RSEQ_ARCH_HAS_OFFSET_DEREF_ADDV /* void test_membarrier(void) { } #endif /* RSEQ_ARCH_HAS_OFFSET_DEREF_ADDV */ > + fprintf(stderr, "rseq_offset_deref_addv is not implemented on this > architecture. " > + "Skipping membarrier test.\n"); > + return; > +#else > + struct test_membarrier_thread_args thread_args; > + pthread_t worker_threads[CPU_SETSIZE]; > + pthread_t manager_thread; > + int i; > + > + sys_membarrier(MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ, 0, 0); Missing error handling. > + > + thread_args.stop = 0; > + thread_args.percpu_list_ptr = 0; > + pthread_create(&manager_thread, NULL, > + test_membarrier_manager_thread, &thread_args); > + > + for (i = 0; i < CPU_SETSIZE; i++) > + pthread_create(&worker_threads[i], NULL, > + test_membarrier_worker_thread, &thread_args); > + > + for (i = 0; i < CPU_SETSIZE; i++) > + pthread_join(worker_threads[i], NULL); > + > + atomic_store(&thread_args.stop, 1); > + pthread_join(manager_thread, NULL); Arguably the existing tests do not check pthread_* errors, but I guess it would not hurt to do so. > +#endif > +} > + > int main(int argc, char **argv) > { > if (rseq_register_current_thread()) { > @@ -300,6 +485,8 @@ int main(int argc, char **argv) > test_percpu_spinlock(); > printf("percpu_list\n"); > test_percpu_list(); > + printf("membarrier\n"); > + test_membarrier(); > if (rseq_unregister_current_thread()) { > fprintf(stderr, "Error: rseq_unregister_current_thread(...) failed(%d): %s\n", > errno, strerror(errno)); > diff --git a/tools/testing/selftests/rseq/rseq-x86.h > b/tools/testing/selftests/rseq/rseq-x86.h > index b2da6004fe30..640411518e46 100644 > --- a/tools/testing/selftests/rseq/rseq-x86.h > +++ b/tools/testing/selftests/rseq/rseq-x86.h > @@ -279,6 +279,63 @@ int rseq_addv(intptr_t *v, intptr_t count, int cpu) > #endif > } > > +#define RSEQ_ARCH_HAS_OFFSET_DEREF_ADDV > + > +/* > + * pval = *(ptr+off) > + * *pval += inc; > + */ Addition to rseq-x86.h should be split into its own commit. Thanks, Mathieu > +static inline __attribute__((always_inline)) > +int rseq_offset_deref_addv(intptr_t *ptr, off_t off, intptr_t inc, int cpu) > +{ > + RSEQ_INJECT_C(9) > + > + __asm__ __volatile__ goto ( > + RSEQ_ASM_DEFINE_TABLE(3, 1f, 2f, 4f) /* start, commit, abort */ > +#ifdef RSEQ_COMPARE_TWICE > + RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[error1]) > +#endif > + /* Start rseq by storing table entry pointer into rseq_cs. */ > + RSEQ_ASM_STORE_RSEQ_CS(1, 3b, RSEQ_CS_OFFSET(%[rseq_abi])) > + RSEQ_ASM_CMP_CPU_ID(cpu_id, RSEQ_CPU_ID_OFFSET(%[rseq_abi]), 4f) > + RSEQ_INJECT_ASM(3) > +#ifdef RSEQ_COMPARE_TWICE > + RSEQ_ASM_CMP_CPU_ID(cpu_id, RSEQ_CPU_ID_OFFSET(%[rseq_abi]), %l[error1]) > +#endif > + /* get p+v */ > + "movq %[ptr], %%rbx\n\t" > + "addq %[off], %%rbx\n\t" > + /* get pv */ > + "movq (%%rbx), %%rcx\n\t" > + /* *pv += inc */ > + "addq %[inc], (%%rcx)\n\t" > + "2:\n\t" > + RSEQ_INJECT_ASM(4) > + RSEQ_ASM_DEFINE_ABORT(4, "", abort) > + : /* gcc asm goto does not allow outputs */ > + : [cpu_id] "r" (cpu), > + [rseq_abi] "r" (&__rseq_abi), > + /* final store input */ > + [ptr] "m" (*ptr), > + [off] "er" (off), > + [inc] "er" (inc) > + : "memory", "cc", "rax", "rbx", "rcx" > + RSEQ_INJECT_CLOBBER > + : abort > +#ifdef RSEQ_COMPARE_TWICE > + , error1 > +#endif > + ); > + return 0; > +abort: > + RSEQ_INJECT_FAILED > + return -1; > +#ifdef RSEQ_COMPARE_TWICE > +error1: > + rseq_bug("cpu_id comparison failed"); > +#endif > +} > + > static inline __attribute__((always_inline)) > int rseq_cmpeqv_trystorev_storev(intptr_t *v, intptr_t expect, > intptr_t *v2, intptr_t newv2, > -- > 2.28.0.618.gf4bc123cb7-goog -- Mathieu Desnoyers EfficiOS Inc. http://www.efficios.com

4 years, 9 months

1
0
0 0

[REGRESSION] kselftest: next-20200915

by LKFT

## Kernel * kernel: 5.9.0-rc5 * git repo: ['https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git', 'https://gitlab.com/Linaro/lkft/mirrors/next/linux-next'] * git branch: master * git commit: 6b02addb1d1748d21dd1261e46029b264be4e5a0 * git describe: next-20200915 * Test details: https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20200915 ## Regressions (compared to build next-20200914) juno-r2: kselftest: * memfd_memfd_test x86: kselftest-vsyscall-mode-native: * kvm_vmx_preemption_timer_test ## Fixes (compared to build next-20200914) x86: kselftest-vsyscall-mode-none: * kvm_vmx_preemption_timer_test ## Summary ### hi6220-hikey, kselftest * total: 161 * pass: 53 * fail: 79 * skip: 29 * xfail: 0 ### i386, kselftest * total: 166 * pass: 35 * fail: 102 * skip: 29 * xfail: 0 ### juno-r2, kselftest * total: 163 * pass: 57 * fail: 77 * skip: 29 * xfail: 0 ### x86, kselftest * total: 167 * pass: 59 * fail: 81 * skip: 27 * xfail: 0 ### x86, kselftest-vsyscall-mode-native * total: 168 * pass: 61 * fail: 80 * skip: 27 * xfail: 0 ### x86, kselftest-vsyscall-mode-none * total: 164 * pass: 58 * fail: 79 * skip: 27 * xfail: 0 ## Environments * dragonboard-410c * hi6220-hikey * i386 * juno-r2 * juno-r2-compat * juno-r2-kasan * nxp-ls2088 * qemu_arm * qemu_arm64 * qemu_i386 * qemu_x86_64 * x15 * x86 * x86-kasan ## Suites * kselftest * kselftest-vsyscall-mode-native * kselftest-vsyscall-mode-none ## Failures ### hi6220-hikey, kselftest * bpf_test_verifier * bpf_test_tag * bpf_test_maps * bpf_test_lpm_map * bpf_test_progs * bpf_test_dev_cgroup * bpf_test_tcpbpf_user * bpf_test_sysctl * bpf_test_progs-no_alu32 * bpf_test_kmod.sh * bpf_test_sock_addr.sh * bpf_test_tunnel.sh * bpf_test_lwt_seg6local.sh * bpf_test_flow_dissector.sh * bpf_test_lwt_ip_encap.sh * bpf_test_tcp_check_syncookie.sh * bpf_test_tc_tunnel.sh * bpf_test_tc_edt.sh * bpf_test_xdping.sh * bpf_test_bpftool.sh * clone3_clone3_cap_checkpoint_restore * core_close_range_test * firmware_fw_run_tests.sh * ftrace_ftracetest * lkdtm_BUG.sh * lkdtm_WARNING.sh * lkdtm_WARNING_MESSAGE.sh * lkdtm_EXCEPTION.sh * lkdtm_CORRUPT_LIST_ADD.sh * lkdtm_CORRUPT_LIST_DEL.sh * lkdtm_STACK_GUARD_PAGE_LEADING.sh * lkdtm_STACK_GUARD_PAGE_TRAILING.sh * lkdtm_UNSET_SMEP.sh * lkdtm_CORRUPT_PAC.sh * lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * lkdtm_READ_AFTER_FREE.sh * lkdtm_READ_BUDDY_AFTER_FREE.sh * lkdtm_SLAB_FREE_DOUBLE.sh * lkdtm_SLAB_FREE_CROSS.sh * lkdtm_SLAB_FREE_PAGE.sh * lkdtm_EXEC_DATA.sh * lkdtm_EXEC_STACK.sh * lkdtm_EXEC_KMALLOC.sh * lkdtm_EXEC_VMALLOC.sh * lkdtm_EXEC_RODATA.sh * lkdtm_EXEC_USERSPACE.sh * lkdtm_EXEC_NULL.sh * lkdtm_ACCESS_USERSPACE.sh * lkdtm_ACCESS_NULL.sh * lkdtm_WRITE_RO.sh * lkdtm_WRITE_RO_AFTER_INIT.sh * lkdtm_WRITE_KERN.sh * lkdtm_REFCOUNT_INC_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_OVERFLOW.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_DEC_ZERO.sh * lkdtm_REFCOUNT_DEC_NEGATIVE.sh * lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_INC_ZERO.sh * lkdtm_REFCOUNT_ADD_ZERO.sh * lkdtm_REFCOUNT_INC_SATURATED.sh * lkdtm_REFCOUNT_DEC_SATURATED.sh * lkdtm_REFCOUNT_ADD_SATURATED.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * lkdtm_USERCOPY_HEAP_SIZE_TO.sh * lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * lkdtm_USERCOPY_STACK_FRAME_TO.sh * lkdtm_USERCOPY_STACK_FRAME_FROM.sh * lkdtm_USERCOPY_STACK_BEYOND.sh * lkdtm_USERCOPY_KERNEL.sh * lkdtm_STACKLEAK_ERASING.sh * lkdtm_CFI_FORWARD_PROTO.sh ### i386, kselftest * bpf_test_progs * bpf_test_dev_cgroup * bpf_test_tcpbpf_user * bpf_get_cgroup_id_user * bpf_test_socket_cookie * bpf_test_netcnt * bpf_test_tcpnotify_user * bpf_test_sock_fields * bpf_test_sysctl * bpf_test_progs-no_alu32 * bpf_test_sock_addr.sh * bpf_test_tunnel.sh * bpf_test_lwt_seg6local.sh * bpf_test_flow_dissector.sh * bpf_test_tc_tunnel.sh * bpf_test_xdping.sh * bpf_test_bpftool.sh * clone3_clone3_clear_sighand * clone3_clone3_cap_checkpoint_restore * core_close_range_test * firmware_fw_run_tests.sh * ftrace_ftracetest * intel_pstate_run.sh * kvm_cr4_cpuid_sync_test * kvm_evmcs_test * kvm_hyperv_cpuid * kvm_mmio_warning_test * kvm_platform_info_test * kvm_set_sregs_test * kvm_smm_test * kvm_state_test * kvm_vmx_preemption_timer_test * kvm_svm_vmcall_test * kvm_sync_regs_test * kvm_vmx_close_while_nested_test * kvm_vmx_dirty_log_test * kvm_vmx_set_nested_state_test * kvm_vmx_tsc_adjust_test * kvm_xss_msr_test * kvm_debug_regs * kvm_clear_dirty_log_test * kvm_demand_paging_test * kvm_dirty_log_test * kvm_kvm_create_max_vcpus * kvm_set_memory_region_test * kvm_steal_time * lkdtm_BUG.sh * lkdtm_WARNING.sh * lkdtm_WARNING_MESSAGE.sh * lkdtm_EXCEPTION.sh * lkdtm_CORRUPT_LIST_ADD.sh * lkdtm_CORRUPT_LIST_DEL.sh * lkdtm_STACK_GUARD_PAGE_LEADING.sh * lkdtm_STACK_GUARD_PAGE_TRAILING.sh * lkdtm_UNSET_SMEP.sh * lkdtm_DOUBLE_FAULT.sh * lkdtm_CORRUPT_PAC.sh * lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * lkdtm_READ_AFTER_FREE.sh * lkdtm_READ_BUDDY_AFTER_FREE.sh * lkdtm_SLAB_FREE_DOUBLE.sh * lkdtm_SLAB_FREE_CROSS.sh * lkdtm_SLAB_FREE_PAGE.sh * lkdtm_EXEC_DATA.sh * lkdtm_EXEC_STACK.sh * lkdtm_EXEC_KMALLOC.sh * lkdtm_EXEC_VMALLOC.sh * lkdtm_EXEC_RODATA.sh * lkdtm_EXEC_USERSPACE.sh * lkdtm_EXEC_NULL.sh * lkdtm_ACCESS_USERSPACE.sh * lkdtm_ACCESS_NULL.sh * lkdtm_WRITE_RO.sh * lkdtm_WRITE_RO_AFTER_INIT.sh * lkdtm_WRITE_KERN.sh * lkdtm_REFCOUNT_INC_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_OVERFLOW.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_DEC_ZERO.sh * lkdtm_REFCOUNT_DEC_NEGATIVE.sh * lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_INC_ZERO.sh * lkdtm_REFCOUNT_ADD_ZERO.sh * lkdtm_REFCOUNT_INC_SATURATED.sh * lkdtm_REFCOUNT_DEC_SATURATED.sh * lkdtm_REFCOUNT_ADD_SATURATED.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * lkdtm_USERCOPY_HEAP_SIZE_TO.sh * lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * lkdtm_USERCOPY_STACK_FRAME_TO.sh * lkdtm_USERCOPY_STACK_FRAME_FROM.sh * lkdtm_USERCOPY_STACK_BEYOND.sh * lkdtm_USERCOPY_KERNEL.sh * lkdtm_STACKLEAK_ERASING.sh * lkdtm_CFI_FORWARD_PROTO.sh ### juno-r2, kselftest * bpf_test_maps * bpf_get_cgroup_id_user * bpf_test_socket_cookie * bpf_test_netcnt * bpf_test_tcpnotify_user * bpf_test_sysctl * bpf_test_progs-no_alu32 * bpf_test_sock_addr.sh * bpf_test_tunnel.sh * bpf_test_lwt_seg6local.sh * bpf_test_flow_dissector.sh * bpf_test_lwt_ip_encap.sh * bpf_test_tcp_check_syncookie.sh * bpf_test_tc_tunnel.sh * bpf_test_tc_edt.sh * bpf_test_xdping.sh * bpf_test_bpftool.sh * clone3_clone3_cap_checkpoint_restore * core_close_range_test * cpufreq_main.sh * firmware_fw_run_tests.sh * ftrace_ftracetest * lkdtm_BUG.sh * lkdtm_WARNING.sh * lkdtm_WARNING_MESSAGE.sh * lkdtm_EXCEPTION.sh * lkdtm_CORRUPT_LIST_ADD.sh * lkdtm_CORRUPT_LIST_DEL.sh * lkdtm_STACK_GUARD_PAGE_LEADING.sh * lkdtm_STACK_GUARD_PAGE_TRAILING.sh * lkdtm_UNSET_SMEP.sh * lkdtm_CORRUPT_PAC.sh * lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * lkdtm_READ_AFTER_FREE.sh * lkdtm_READ_BUDDY_AFTER_FREE.sh * lkdtm_SLAB_FREE_DOUBLE.sh * lkdtm_SLAB_FREE_CROSS.sh * lkdtm_SLAB_FREE_PAGE.sh * lkdtm_EXEC_DATA.sh * lkdtm_EXEC_STACK.sh * lkdtm_EXEC_KMALLOC.sh * lkdtm_EXEC_VMALLOC.sh * lkdtm_EXEC_RODATA.sh * lkdtm_EXEC_USERSPACE.sh * lkdtm_EXEC_NULL.sh * lkdtm_ACCESS_USERSPACE.sh * lkdtm_ACCESS_NULL.sh * lkdtm_WRITE_RO.sh * lkdtm_WRITE_RO_AFTER_INIT.sh * lkdtm_WRITE_KERN.sh * lkdtm_REFCOUNT_INC_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_OVERFLOW.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_DEC_ZERO.sh * lkdtm_REFCOUNT_DEC_NEGATIVE.sh * lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_INC_ZERO.sh * lkdtm_REFCOUNT_ADD_ZERO.sh * lkdtm_REFCOUNT_INC_SATURATED.sh * lkdtm_REFCOUNT_DEC_SATURATED.sh * lkdtm_REFCOUNT_ADD_SATURATED.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * lkdtm_USERCOPY_HEAP_SIZE_TO.sh * lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * lkdtm_USERCOPY_STACK_FRAME_TO.sh * lkdtm_USERCOPY_STACK_FRAME_FROM.sh * lkdtm_USERCOPY_STACK_BEYOND.sh * lkdtm_USERCOPY_KERNEL.sh * lkdtm_STACKLEAK_ERASING.sh * lkdtm_CFI_FORWARD_PROTO.sh ### x86, kselftest * bpf_test_progs * bpf_test_dev_cgroup * bpf_test_tcpbpf_user * bpf_get_cgroup_id_user * bpf_test_socket_cookie * bpf_test_netcnt * bpf_test_tcpnotify_user * bpf_test_sock_fields * bpf_test_sysctl * bpf_test_progs-no_alu32 * bpf_test_sock_addr.sh * bpf_test_tunnel.sh * bpf_test_lwt_seg6local.sh * bpf_test_flow_dissector.sh * bpf_test_lwt_ip_encap.sh * bpf_test_tc_tunnel.sh * bpf_test_tc_edt.sh * bpf_test_xdping.sh * bpf_test_bpftool.sh * clone3_clone3_cap_checkpoint_restore * core_close_range_test * firmware_fw_run_tests.sh * ftrace_ftracetest * intel_pstate_run.sh * kvm_vmx_preemption_timer_test * kvm_debug_regs * lkdtm_BUG.sh * lkdtm_WARNING.sh * lkdtm_WARNING_MESSAGE.sh * lkdtm_EXCEPTION.sh * lkdtm_CORRUPT_LIST_ADD.sh * lkdtm_CORRUPT_LIST_DEL.sh * lkdtm_STACK_GUARD_PAGE_LEADING.sh * lkdtm_STACK_GUARD_PAGE_TRAILING.sh * lkdtm_UNSET_SMEP.sh * lkdtm_CORRUPT_PAC.sh * lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * lkdtm_READ_AFTER_FREE.sh * lkdtm_READ_BUDDY_AFTER_FREE.sh * lkdtm_SLAB_FREE_DOUBLE.sh * lkdtm_SLAB_FREE_CROSS.sh * lkdtm_SLAB_FREE_PAGE.sh * lkdtm_EXEC_DATA.sh * lkdtm_EXEC_STACK.sh * lkdtm_EXEC_KMALLOC.sh * lkdtm_EXEC_VMALLOC.sh * lkdtm_EXEC_RODATA.sh * lkdtm_EXEC_USERSPACE.sh * lkdtm_EXEC_NULL.sh * lkdtm_ACCESS_USERSPACE.sh * lkdtm_ACCESS_NULL.sh * lkdtm_WRITE_RO.sh * lkdtm_WRITE_RO_AFTER_INIT.sh * lkdtm_WRITE_KERN.sh * lkdtm_REFCOUNT_INC_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_OVERFLOW.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_DEC_ZERO.sh * lkdtm_REFCOUNT_DEC_NEGATIVE.sh * lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_INC_ZERO.sh * lkdtm_REFCOUNT_ADD_ZERO.sh * lkdtm_REFCOUNT_INC_SATURATED.sh * lkdtm_REFCOUNT_DEC_SATURATED.sh * lkdtm_REFCOUNT_ADD_SATURATED.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * lkdtm_USERCOPY_HEAP_SIZE_TO.sh * lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * lkdtm_USERCOPY_STACK_FRAME_TO.sh * lkdtm_USERCOPY_STACK_FRAME_FROM.sh * lkdtm_USERCOPY_STACK_BEYOND.sh * lkdtm_USERCOPY_KERNEL.sh * lkdtm_STACKLEAK_ERASING.sh * lkdtm_CFI_FORWARD_PROTO.sh ### x86, kselftest-vsyscall-mode-native * bpf_test_progs * bpf_test_dev_cgroup * bpf_test_tcpbpf_user * bpf_get_cgroup_id_user * bpf_test_socket_cookie * bpf_test_netcnt * bpf_test_tcpnotify_user * bpf_test_sock_fields * bpf_test_sysctl * bpf_test_progs-no_alu32 * bpf_test_sock_addr.sh * bpf_test_tunnel.sh * bpf_test_lwt_seg6local.sh * bpf_test_flow_dissector.sh * bpf_test_lwt_ip_encap.sh * bpf_test_tc_tunnel.sh * bpf_test_tc_edt.sh * bpf_test_xdping.sh * bpf_test_bpftool.sh * clone3_clone3_cap_checkpoint_restore * core_close_range_test * firmware_fw_run_tests.sh * ftrace_ftracetest * intel_pstate_run.sh * kvm_debug_regs * lkdtm_BUG.sh * lkdtm_WARNING.sh * lkdtm_WARNING_MESSAGE.sh * lkdtm_EXCEPTION.sh * lkdtm_CORRUPT_LIST_ADD.sh * lkdtm_CORRUPT_LIST_DEL.sh * lkdtm_STACK_GUARD_PAGE_LEADING.sh * lkdtm_STACK_GUARD_PAGE_TRAILING.sh * lkdtm_UNSET_SMEP.sh * lkdtm_CORRUPT_PAC.sh * lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * lkdtm_READ_AFTER_FREE.sh * lkdtm_READ_BUDDY_AFTER_FREE.sh * lkdtm_SLAB_FREE_DOUBLE.sh * lkdtm_SLAB_FREE_CROSS.sh * lkdtm_SLAB_FREE_PAGE.sh * lkdtm_EXEC_DATA.sh * lkdtm_EXEC_STACK.sh * lkdtm_EXEC_KMALLOC.sh * lkdtm_EXEC_VMALLOC.sh * lkdtm_EXEC_RODATA.sh * lkdtm_EXEC_USERSPACE.sh * lkdtm_EXEC_NULL.sh * lkdtm_ACCESS_USERSPACE.sh * lkdtm_ACCESS_NULL.sh * lkdtm_WRITE_RO.sh * lkdtm_WRITE_RO_AFTER_INIT.sh * lkdtm_WRITE_KERN.sh * lkdtm_REFCOUNT_INC_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_OVERFLOW.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_DEC_ZERO.sh * lkdtm_REFCOUNT_DEC_NEGATIVE.sh * lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_INC_ZERO.sh * lkdtm_REFCOUNT_ADD_ZERO.sh * lkdtm_REFCOUNT_INC_SATURATED.sh * lkdtm_REFCOUNT_DEC_SATURATED.sh * lkdtm_REFCOUNT_ADD_SATURATED.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * lkdtm_USERCOPY_HEAP_SIZE_TO.sh * lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * lkdtm_USERCOPY_STACK_FRAME_TO.sh * lkdtm_USERCOPY_STACK_FRAME_FROM.sh * lkdtm_USERCOPY_STACK_BEYOND.sh * lkdtm_USERCOPY_KERNEL.sh * lkdtm_STACKLEAK_ERASING.sh * lkdtm_CFI_FORWARD_PROTO.sh ### x86, kselftest-vsyscall-mode-none * bpf_test_progs * bpf_test_dev_cgroup * bpf_test_tcpbpf_user * bpf_get_cgroup_id_user * bpf_test_tcpnotify_user * bpf_test_sock_fields * bpf_test_sysctl * bpf_test_progs-no_alu32 * bpf_test_sock_addr.sh * bpf_test_tunnel.sh * bpf_test_lwt_seg6local.sh * bpf_test_flow_dissector.sh * bpf_test_lwt_ip_encap.sh * bpf_test_tc_tunnel.sh * bpf_test_tc_edt.sh * bpf_test_xdping.sh * bpf_test_bpftool.sh * clone3_clone3_cap_checkpoint_restore * core_close_range_test * firmware_fw_run_tests.sh * ftrace_ftracetest * intel_pstate_run.sh * kvm_vmx_preemption_timer_test * kvm_debug_regs * lkdtm_BUG.sh * lkdtm_WARNING.sh * lkdtm_WARNING_MESSAGE.sh * lkdtm_EXCEPTION.sh * lkdtm_CORRUPT_LIST_ADD.sh * lkdtm_CORRUPT_LIST_DEL.sh * lkdtm_STACK_GUARD_PAGE_LEADING.sh * lkdtm_STACK_GUARD_PAGE_TRAILING.sh * lkdtm_UNSET_SMEP.sh * lkdtm_CORRUPT_PAC.sh * lkdtm_UNALIGNED_LOAD_STORE_WRITE.sh * lkdtm_READ_AFTER_FREE.sh * lkdtm_READ_BUDDY_AFTER_FREE.sh * lkdtm_SLAB_FREE_DOUBLE.sh * lkdtm_SLAB_FREE_CROSS.sh * lkdtm_SLAB_FREE_PAGE.sh * lkdtm_EXEC_DATA.sh * lkdtm_EXEC_STACK.sh * lkdtm_EXEC_KMALLOC.sh * lkdtm_EXEC_VMALLOC.sh * lkdtm_EXEC_RODATA.sh * lkdtm_EXEC_USERSPACE.sh * lkdtm_EXEC_NULL.sh * lkdtm_ACCESS_USERSPACE.sh * lkdtm_ACCESS_NULL.sh * lkdtm_WRITE_RO.sh * lkdtm_WRITE_RO_AFTER_INIT.sh * lkdtm_WRITE_KERN.sh * lkdtm_REFCOUNT_INC_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_OVERFLOW.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_OVERFLOW.sh * lkdtm_REFCOUNT_DEC_ZERO.sh * lkdtm_REFCOUNT_DEC_NEGATIVE.sh * lkdtm_REFCOUNT_DEC_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_SUB_AND_TEST_NEGATIVE.sh * lkdtm_REFCOUNT_INC_ZERO.sh * lkdtm_REFCOUNT_ADD_ZERO.sh * lkdtm_REFCOUNT_INC_SATURATED.sh * lkdtm_REFCOUNT_DEC_SATURATED.sh * lkdtm_REFCOUNT_ADD_SATURATED.sh * lkdtm_REFCOUNT_INC_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_ADD_NOT_ZERO_SATURATED.sh * lkdtm_REFCOUNT_DEC_AND_TEST_SATURATED.sh * lkdtm_REFCOUNT_SUB_AND_TEST_SATURATED.sh * lkdtm_USERCOPY_HEAP_SIZE_TO.sh * lkdtm_USERCOPY_HEAP_SIZE_FROM.sh * lkdtm_USERCOPY_HEAP_WHITELIST_TO.sh * lkdtm_USERCOPY_HEAP_WHITELIST_FROM.sh * lkdtm_USERCOPY_STACK_FRAME_TO.sh * lkdtm_USERCOPY_STACK_FRAME_FROM.sh * lkdtm_USERCOPY_STACK_BEYOND.sh * lkdtm_USERCOPY_KERNEL.sh * lkdtm_STACKLEAK_ERASING.sh * lkdtm_CFI_FORWARD_PROTO.sh ## Skips ### hi6220-hikey, kselftest * bpf_test_xdp_veth.sh * cgroup_test_memcontrol * cgroup_test_kmem * cgroup_test_core * cgroup_test_stress.sh * efivarfs_efivarfs.sh * fpu_run_test_fpu.sh * intel_pstate_run.sh * ir_ir_loopback.sh * livepatch_test-livepatch.sh * livepatch_test-callbacks.sh * livepatch_test-shadow-vars.sh * livepatch_test-state.sh * livepatch_test-ftrace.sh * lkdtm_PANIC.sh * lkdtm_LOOP.sh * lkdtm_EXHAUST_STACK.sh * lkdtm_CORRUPT_STACK.sh * lkdtm_CORRUPT_STACK_STRONG.sh * lkdtm_DOUBLE_FAULT.sh * lkdtm_OVERWRITE_ALLOCATION.sh * lkdtm_WRITE_AFTER_FREE.sh * lkdtm_WRITE_BUDDY_AFTER_FREE.sh * lkdtm_SOFTLOCKUP.sh * lkdtm_HARDLOCKUP.sh * lkdtm_SPINLOCKUP.sh * lkdtm_HUNG_TASK.sh * lkdtm_REFCOUNT_TIMING.sh * lkdtm_ATOMIC_TIMING.sh ### i386, kselftest * bpf_test_xdp_veth.sh * cgroup_test_memcontrol * cgroup_test_kmem * cgroup_test_core * cgroup_test_stress.sh * efivarfs_efivarfs.sh * fpu_run_test_fpu.sh * ir_ir_loopback.sh * kexec_test_kexec_load.sh * kexec_test_kexec_file_load.sh * livepatch_test-livepatch.sh * livepatch_test-callbacks.sh * livepatch_test-shadow-vars.sh * livepatch_test-state.sh * livepatch_test-ftrace.sh * lkdtm_PANIC.sh * lkdtm_LOOP.sh * lkdtm_EXHAUST_STACK.sh * lkdtm_CORRUPT_STACK.sh * lkdtm_CORRUPT_STACK_STRONG.sh * lkdtm_OVERWRITE_ALLOCATION.sh * lkdtm_WRITE_AFTER_FREE.sh * lkdtm_WRITE_BUDDY_AFTER_FREE.sh * lkdtm_SOFTLOCKUP.sh * lkdtm_HARDLOCKUP.sh * lkdtm_SPINLOCKUP.sh * lkdtm_HUNG_TASK.sh * lkdtm_REFCOUNT_TIMING.sh * lkdtm_ATOMIC_TIMING.sh ### juno-r2, kselftest * bpf_test_xdp_veth.sh * cgroup_test_memcontrol * cgroup_test_kmem * cgroup_test_core * cgroup_test_stress.sh * efivarfs_efivarfs.sh * fpu_run_test_fpu.sh * intel_pstate_run.sh * ir_ir_loopback.sh * livepatch_test-livepatch.sh * livepatch_test-callbacks.sh * livepatch_test-shadow-vars.sh * livepatch_test-state.sh * livepatch_test-ftrace.sh * lkdtm_PANIC.sh * lkdtm_LOOP.sh * lkdtm_EXHAUST_STACK.sh * lkdtm_CORRUPT_STACK.sh * lkdtm_CORRUPT_STACK_STRONG.sh * lkdtm_DOUBLE_FAULT.sh * lkdtm_OVERWRITE_ALLOCATION.sh * lkdtm_WRITE_AFTER_FREE.sh * lkdtm_WRITE_BUDDY_AFTER_FREE.sh * lkdtm_SOFTLOCKUP.sh * lkdtm_HARDLOCKUP.sh * lkdtm_SPINLOCKUP.sh * lkdtm_HUNG_TASK.sh * lkdtm_REFCOUNT_TIMING.sh * lkdtm_ATOMIC_TIMING.sh ### x86, kselftest * bpf_test_xdp_veth.sh * cgroup_test_memcontrol * cgroup_test_kmem * cgroup_test_core * cgroup_test_stress.sh * efivarfs_efivarfs.sh * fpu_run_test_fpu.sh * ir_ir_loopback.sh * kexec_test_kexec_load.sh * kexec_test_kexec_file_load.sh * kvm_mmio_warning_test * kvm_svm_vmcall_test * lkdtm_PANIC.sh * lkdtm_LOOP.sh * lkdtm_EXHAUST_STACK.sh * lkdtm_CORRUPT_STACK.sh * lkdtm_CORRUPT_STACK_STRONG.sh * lkdtm_DOUBLE_FAULT.sh * lkdtm_OVERWRITE_ALLOCATION.sh * lkdtm_WRITE_AFTER_FREE.sh * lkdtm_WRITE_BUDDY_AFTER_FREE.sh * lkdtm_SOFTLOCKUP.sh * lkdtm_HARDLOCKUP.sh * lkdtm_SPINLOCKUP.sh * lkdtm_HUNG_TASK.sh * lkdtm_REFCOUNT_TIMING.sh * lkdtm_ATOMIC_TIMING.sh ### x86, kselftest-vsyscall-mode-native * bpf_test_xdp_veth.sh * cgroup_test_memcontrol * cgroup_test_kmem * cgroup_test_core * cgroup_test_stress.sh * efivarfs_efivarfs.sh * fpu_run_test_fpu.sh * ir_ir_loopback.sh * kexec_test_kexec_load.sh * kexec_test_kexec_file_load.sh * kvm_mmio_warning_test * kvm_svm_vmcall_test * lkdtm_PANIC.sh * lkdtm_LOOP.sh * lkdtm_EXHAUST_STACK.sh * lkdtm_CORRUPT_STACK.sh * lkdtm_CORRUPT_STACK_STRONG.sh * lkdtm_DOUBLE_FAULT.sh * lkdtm_OVERWRITE_ALLOCATION.sh * lkdtm_WRITE_AFTER_FREE.sh * lkdtm_WRITE_BUDDY_AFTER_FREE.sh * lkdtm_SOFTLOCKUP.sh * lkdtm_HARDLOCKUP.sh * lkdtm_SPINLOCKUP.sh * lkdtm_HUNG_TASK.sh * lkdtm_REFCOUNT_TIMING.sh * lkdtm_ATOMIC_TIMING.sh ### x86, kselftest-vsyscall-mode-none * bpf_test_xdp_veth.sh * cgroup_test_memcontrol * cgroup_test_kmem * cgroup_test_core * cgroup_test_stress.sh * efivarfs_efivarfs.sh * fpu_run_test_fpu.sh * ir_ir_loopback.sh * kexec_test_kexec_load.sh * kexec_test_kexec_file_load.sh * kvm_mmio_warning_test * kvm_svm_vmcall_test * lkdtm_PANIC.sh * lkdtm_LOOP.sh * lkdtm_EXHAUST_STACK.sh * lkdtm_CORRUPT_STACK.sh * lkdtm_CORRUPT_STACK_STRONG.sh * lkdtm_DOUBLE_FAULT.sh * lkdtm_OVERWRITE_ALLOCATION.sh * lkdtm_WRITE_AFTER_FREE.sh * lkdtm_WRITE_BUDDY_AFTER_FREE.sh * lkdtm_SOFTLOCKUP.sh * lkdtm_HARDLOCKUP.sh * lkdtm_SPINLOCKUP.sh * lkdtm_HUNG_TASK.sh * lkdtm_REFCOUNT_TIMING.sh * lkdtm_ATOMIC_TIMING.sh -- Linaro LKFT https://lkft.linaro.org

4 years, 9 months

2
1
0 0

Re: [patch 00/13] preempt: Make preempt count unconditional

by Paul E. McKenney

On Mon, Sep 14, 2020 at 01:59:15PM -0700, Linus Torvalds wrote: > On Mon, Sep 14, 2020 at 1:45 PM Thomas Gleixner <tglx(a)linutronix.de> wrote: > > > > Recently merged code does: > > > > gfp = preemptible() ? GFP_KERNEL : GFP_ATOMIC; > > > > Looks obviously correct, except for the fact that preemptible() is > > unconditionally false for CONFIF_PREEMPT_COUNT=n, i.e. all allocations in > > that code use GFP_ATOMIC on such kernels. > > I don't think this is a good reason to entirely get rid of the no-preempt thing. > > The above is just garbage. It's bogus. You can't do it. > > Blaming the no-preempt code for this bug is extremely unfair, imho. > > And the no-preempt code does help make for much better code generation > for simple spinlocks. > > Where is that horribly buggy recent code? It's not in that exact > format, certainly, since 'grep' doesn't find it. It would be convenient for that "gfp =" code to work, as this would allow better cache locality while invoking RCU callbacks, and would further provide better robustness to callback floods. The full story is quite long, but here are alternatives have not yet been proven to be abject failures: 1. Use workqueues to do the allocations in a clean context. While waiting for the allocations, the callbacks are queued in the old cache-busting manner. This functions correctly, but in the meantime (which on busy systems can be some time) the cache locality and robustness are lost. 2. Provide the ability to allocate memory in raw atomic context. This is extremely effective, especially when used in combination with #1 above, but as you might suspect, the MM guys don't like it much. In contrast, with Thomas's patch series, call_rcu() and kvfree_rcu() could just look at preemptible() to see whether or not it was safe to allocate memory, even in !PREEMPT kernels -- and in the common case, it almost always would be safe. It is quite possible that this approach would work in isolation, or failing that, that adding #1 above would do the trick. I understand that this is all very hand-wavy, and I do apologize for that. If you really want the full sad story with performance numbers and the works, let me know! Thanx, Paul

4 years, 9 months

1
0
0 0

[PATCH 0/2] selftests/vm: fix some minor aggravating factors in the Makefile

by John Hubbard

Hi, This fixes a couple of minor aggravating factors that I ran across while trying to do some changes in selftests/vm. These are simple things, but like most things with GNU Make, it's rarely obvious what's wrong until you understand *the entire Makefile and all of its includes*. So while there is, of course, joy in learning those details, I thought I'd fix these little things, so as to allow others to skip out on the Joy if they so choose. :) First of all, if you have an item (let's choose userfaultfd for an example) that fails to build, you might do this: $ make -j32 # ...you observe a failed item in the threaded output # OK, let's get a closer look $ make # ...but now the build quietly "succeeds". That's what Patch 0001 fixes. Second, if you instead attempt this approach for your closer look (a casual mistake, as it's not supported): $ make userfaultfd # ...userfaultfd fails to link, due to incomplete LDLIBS That's what Patch 0002 fixes. John Hubbard (2): selftests/vm: fix false build success on the second and later attempts selftests/vm: fix incorrect gcc invocation in some cases tools/testing/selftests/vm/Makefile | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) -- 2.28.0

4 years, 9 months

2
3
0 0

[PATCH bpf-next v2 4/5] bpf: selftests: add MPTCP test base

by Nicolas Rybowski

This patch adds a base for MPTCP specific tests. It is currently limited to the is_mptcp field in case of plain TCP connection because for the moment there is no easy way to get the subflow sk from a msk in userspace. This implies that we cannot lookup the sk_storage attached to the subflow sk in the sockops program. Acked-by: Matthieu Baerts <matthieu.baerts(a)tessares.net> Signed-off-by: Nicolas Rybowski <nicolas.rybowski(a)tessares.net> --- Notes: v1 -> v2: - new patch: mandatory selftests (Alexei) tools/testing/selftests/bpf/config | 1 + tools/testing/selftests/bpf/network_helpers.c | 37 +++++- tools/testing/selftests/bpf/network_helpers.h | 3 + .../testing/selftests/bpf/prog_tests/mptcp.c | 119 ++++++++++++++++++ tools/testing/selftests/bpf/progs/mptcp.c | 48 +++++++ 5 files changed, 203 insertions(+), 5 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/mptcp.c create mode 100644 tools/testing/selftests/bpf/progs/mptcp.c diff --git a/tools/testing/selftests/bpf/config b/tools/testing/selftests/bpf/config index 2118e23ac07a..8377836ea976 100644 --- a/tools/testing/selftests/bpf/config +++ b/tools/testing/selftests/bpf/config @@ -39,3 +39,4 @@ CONFIG_BPF_JIT=y CONFIG_BPF_LSM=y CONFIG_SECURITY=y CONFIG_LIRC=y +CONFIG_MPTCP=y diff --git a/tools/testing/selftests/bpf/network_helpers.c b/tools/testing/selftests/bpf/network_helpers.c index 12ee40284da0..85cbb683965c 100644 --- a/tools/testing/selftests/bpf/network_helpers.c +++ b/tools/testing/selftests/bpf/network_helpers.c @@ -14,6 +14,10 @@ #include "bpf_util.h" #include "network_helpers.h" +#ifndef IPPROTO_MPTCP +#define IPPROTO_MPTCP 262 +#endif + #define clean_errno() (errno == 0 ? "None" : strerror(errno)) #define log_err(MSG, ...) ({ \ int __save = errno; \ @@ -66,8 +70,8 @@ static int settimeo(int fd, int timeout_ms) #define save_errno_close(fd) ({ int __save = errno; close(fd); errno = __save; }) -int start_server(int family, int type, const char *addr_str, __u16 port, - int timeout_ms) +static int start_server_proto(int family, int type, int protocol, + const char *addr_str, __u16 port, int timeout_ms) { struct sockaddr_storage addr = {}; socklen_t len; @@ -76,7 +80,7 @@ int start_server(int family, int type, const char *addr_str, __u16 port, if (make_sockaddr(family, addr_str, port, &addr, &len)) return -1; - fd = socket(family, type, 0); + fd = socket(family, type, protocol); if (fd < 0) { log_err("Failed to create server socket"); return -1; @@ -104,6 +108,19 @@ int start_server(int family, int type, const char *addr_str, __u16 port, return -1; } +int start_server(int family, int type, const char *addr_str, __u16 port, + int timeout_ms) +{ + return start_server_proto(family, type, 0, addr_str, port, timeout_ms); +} + +int start_mptcp_server(int family, const char *addr_str, __u16 port, + int timeout_ms) +{ + return start_server_proto(family, SOCK_STREAM, IPPROTO_MPTCP, addr_str, + port, timeout_ms); +} + int fastopen_connect(int server_fd, const char *data, unsigned int data_len, int timeout_ms) { @@ -153,7 +170,7 @@ static int connect_fd_to_addr(int fd, return 0; } -int connect_to_fd(int server_fd, int timeout_ms) +static int connect_to_fd_proto(int server_fd, int protocol, int timeout_ms) { struct sockaddr_storage addr; struct sockaddr_in *addr_in; @@ -173,7 +190,7 @@ int connect_to_fd(int server_fd, int timeout_ms) } addr_in = (struct sockaddr_in *)&addr; - fd = socket(addr_in->sin_family, type, 0); + fd = socket(addr_in->sin_family, type, protocol); if (fd < 0) { log_err("Failed to create client socket"); return -1; @@ -192,6 +209,16 @@ int connect_to_fd(int server_fd, int timeout_ms) return -1; } +int connect_to_fd(int server_fd, int timeout_ms) +{ + return connect_to_fd_proto(server_fd, 0, timeout_ms); +} + +int connect_to_mptcp_fd(int server_fd, int timeout_ms) +{ + return connect_to_fd_proto(server_fd, IPPROTO_MPTCP, timeout_ms); +} + int connect_fd_to_fd(int client_fd, int server_fd, int timeout_ms) { struct sockaddr_storage addr; diff --git a/tools/testing/selftests/bpf/network_helpers.h b/tools/testing/selftests/bpf/network_helpers.h index 7205f8afdba1..336423a789e9 100644 --- a/tools/testing/selftests/bpf/network_helpers.h +++ b/tools/testing/selftests/bpf/network_helpers.h @@ -35,7 +35,10 @@ extern struct ipv6_packet pkt_v6; int start_server(int family, int type, const char *addr, __u16 port, int timeout_ms); +int start_mptcp_server(int family, const char *addr, __u16 port, + int timeout_ms); int connect_to_fd(int server_fd, int timeout_ms); +int connect_to_mptcp_fd(int server_fd, int timeout_ms); int connect_fd_to_fd(int client_fd, int server_fd, int timeout_ms); int fastopen_connect(int server_fd, const char *data, unsigned int data_len, int timeout_ms); diff --git a/tools/testing/selftests/bpf/prog_tests/mptcp.c b/tools/testing/selftests/bpf/prog_tests/mptcp.c new file mode 100644 index 000000000000..0e65d64868e9 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/mptcp.c @@ -0,0 +1,119 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <test_progs.h> +#include "cgroup_helpers.h" +#include "network_helpers.h" + +struct mptcp_storage { + __u32 invoked; + __u32 is_mptcp; +}; + +static int verify_sk(int map_fd, int client_fd, const char *msg, __u32 is_mptcp) +{ + int err = 0, cfd = client_fd; + struct mptcp_storage val; + + /* Currently there is no easy way to get back the subflow sk from the MPTCP + * sk, thus we cannot access here the sk_storage associated to the subflow + * sk. Also, there is no sk_storage associated with the MPTCP sk since it + * does not trigger sockops events. + * We silently pass this situation at the moment. + */ + if (is_mptcp == 1) + return 0; + + if (CHECK_FAIL(bpf_map_lookup_elem(map_fd, &cfd, &val) < 0)) { + perror("Failed to read socket storage"); + return -1; + } + + if (val.invoked != 1) { + log_err("%s: unexpected invoked count %d != %d", + msg, val.invoked, 1); + err++; + } + + if (val.is_mptcp != is_mptcp) { + log_err("%s: unexpected bpf_tcp_sock.is_mptcp %d != %d", + msg, val.is_mptcp, is_mptcp); + err++; + } + + return err; +} + +static int run_test(int cgroup_fd, int server_fd, bool is_mptcp) +{ + int client_fd, prog_fd, map_fd, err; + struct bpf_object *obj; + struct bpf_map *map; + + struct bpf_prog_load_attr attr = { + .prog_type = BPF_PROG_TYPE_SOCK_OPS, + .file = "./mptcp.o", + .expected_attach_type = BPF_CGROUP_SOCK_OPS, + }; + + err = bpf_prog_load_xattr(&attr, &obj, &prog_fd); + if (err) { + log_err("Failed to load BPF object"); + return -1; + } + + map = bpf_map__next(NULL, obj); + map_fd = bpf_map__fd(map); + + err = bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SOCK_OPS, 0); + if (err) { + log_err("Failed to attach BPF program"); + goto close_bpf_object; + } + + client_fd = is_mptcp ? connect_to_mptcp_fd(server_fd, 0) : + connect_to_fd(server_fd, 0); + if (client_fd < 0) { + err = -1; + goto close_client_fd; + } + + err += is_mptcp ? verify_sk(map_fd, client_fd, "MPTCP subflow socket", 1) : + verify_sk(map_fd, client_fd, "plain TCP socket", 0); + +close_client_fd: + close(client_fd); + +close_bpf_object: + bpf_object__close(obj); + return err; +} + +void test_mptcp(void) +{ + int server_fd, cgroup_fd; + + cgroup_fd = test__join_cgroup("/mptcp"); + if (CHECK_FAIL(cgroup_fd < 0)) + return; + + /* without MPTCP */ + server_fd = start_server(AF_INET, SOCK_STREAM, NULL, 0, 0); + if (CHECK_FAIL(server_fd < 0)) + goto with_mptcp; + + CHECK_FAIL(run_test(cgroup_fd, server_fd, false)); + + close(server_fd); + +with_mptcp: + /* with MPTCP */ + server_fd = start_mptcp_server(AF_INET, NULL, 0, 0); + if (CHECK_FAIL(server_fd < 0)) + goto close_cgroup_fd; + + CHECK_FAIL(run_test(cgroup_fd, server_fd, true)); + + close(server_fd); + +close_cgroup_fd: + close(cgroup_fd); +} diff --git a/tools/testing/selftests/bpf/progs/mptcp.c b/tools/testing/selftests/bpf/progs/mptcp.c new file mode 100644 index 000000000000..be5ee8dac2b3 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/mptcp.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bpf.h> +#include <bpf/bpf_helpers.h> + +char _license[] SEC("license") = "GPL"; +__u32 _version SEC("version") = 1; + +struct mptcp_storage { + __u32 invoked; + __u32 is_mptcp; +}; + +struct { + __uint(type, BPF_MAP_TYPE_SK_STORAGE); + __uint(map_flags, BPF_F_NO_PREALLOC); + __type(key, int); + __type(value, struct mptcp_storage); +} socket_storage_map SEC(".maps"); + +SEC("sockops") +int _sockops(struct bpf_sock_ops *ctx) +{ + struct mptcp_storage *storage; + struct bpf_tcp_sock *tcp_sk; + int op = (int)ctx->op; + struct bpf_sock *sk; + + sk = ctx->sk; + if (!sk) + return 1; + + storage = bpf_sk_storage_get(&socket_storage_map, sk, 0, + BPF_SK_STORAGE_GET_F_CREATE); + if (!storage) + return 1; + + if (op != BPF_SOCK_OPS_TCP_CONNECT_CB) + return 1; + + tcp_sk = bpf_tcp_sock(sk); + if (!tcp_sk) + return 1; + + storage->invoked++; + storage->is_mptcp = tcp_sk->is_mptcp; + + return 1; +} -- 2.28.0

4 years, 9 months

3
3
0 0

Re: [patch 04/13] lockdep: Clenaup PREEMPT_COUNT leftovers

by Will Deacon

On Mon, Sep 14, 2020 at 10:42:13PM +0200, Thomas Gleixner wrote: > CONFIG_PREEMPT_COUNT is now unconditionally enabled and will be > removed. Cleanup the leftovers before doing so. > > Signed-off-by: Thomas Gleixner <tglx(a)linutronix.de> > Cc: Peter Zijlstra <peterz(a)infradead.org> > Cc: Ingo Molnar <mingo(a)kernel.org> > Cc: Will Deacon <will(a)kernel.org> > --- > include/linux/lockdep.h | 6 ++---- > lib/Kconfig.debug | 1 - > 2 files changed, 2 insertions(+), 5 deletions(-) > > --- a/include/linux/lockdep.h > +++ b/include/linux/lockdep.h > @@ -585,16 +585,14 @@ do { \ > > #define lockdep_assert_preemption_enabled() \ > do { \ > - WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_COUNT) && \ > - debug_locks && \ > + WARN_ON_ONCE(debug_locks && \ > (preempt_count() != 0 || \ > !raw_cpu_read(hardirqs_enabled))); \ > } while (0) > > #define lockdep_assert_preemption_disabled() \ > do { \ > - WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_COUNT) && \ > - debug_locks && \ > + WARN_ON_ONCE(debug_locks && \ > (preempt_count() == 0 && \ > raw_cpu_read(hardirqs_enabled))); \ > } while (0) > --- a/lib/Kconfig.debug > +++ b/lib/Kconfig.debug > @@ -1161,7 +1161,6 @@ config PROVE_LOCKING > select DEBUG_RWSEMS > select DEBUG_WW_MUTEX_SLOWPATH > select DEBUG_LOCK_ALLOC > - select PREEMPT_COUNT > select TRACE_IRQFLAGS > default n > help Acked-by: Will Deacon <will(a)kernel.org> Will

4 years, 9 months

1
0
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror