Bitops instrumentation for KASAN
Subsystems (5)
v3 cover Bitops instrumentation for KASAN
Previous version of this patch series and discussion can be found here:
http://lkml.kernel.org/r/[email protected]
Marco Elver (3):
lib/test_kasan: Add bitops tests
x86: Use static_cpu_has in uaccess region to avoid instrumentation asm-generic, x86: Add bitops instrumentation for KASAN
Documentation/core-api/kernel-api.rst | 2 +- arch/x86/ia32/ia32_signal.c | 2 +- arch/x86/include/asm/bitops.h | 189 ++++------------ arch/x86/kernel/signal.c | 2 +- include/asm-generic/bitops-instrumented.h | 263 ++++++++++++++++++++++ lib/test_kasan.c | 75 +++++- 6 files changed, 376 insertions(+), 157 deletions(-) create mode 100644 include/asm-generic/bitops-instrumented.h
Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
PATCH v3 1/3 lib/test_kasan: Add bitops tests
This adds bitops tests to the test_kasan module. In a follow-up patch, support for bitops instrumentation will be added.
---
Changes in v3:
* Use kzalloc instead of kmalloc.
* Use sizeof(*bits).
Changes in v2:
* Use BITS_PER_LONG.
* Use heap allocated memory for test, as newer compilers (correctly) warn on OOB stack access.
--- lib/test_kasan.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 72 insertions(+), 3 deletions(-)
lib/test_kasan.c +72 -3
@@ -11,16 +11,17 @@#define pr_fmt (fmt) "kasan test: %s " fmt, __func__ +#include <linux/bitops.h> #include <linux/delay.h> +#include <linux/kasan.h> #include <linux/kernel.h> -#include <linux/mman.h> #include <linux/mm.h> +#include <linux/mman.h> +#include <linux/module.h> #include <linux/printk.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/uaccess.h> -#include <linux/module.h> -#include <linux/kasan.h> /* * Note: test functions are marked noinline so that their names appear in
@@ -623,6 +624,73 @@ static noinline void __init kasan_strings(void)strnlen (ptr,1 ); } +static noinline void __init kasan_bitops(void) +{ +long *bits =kzalloc (sizeof (*bits),GFP_KERNEL ); +if (!bits) +return ; + +pr_info ("within-bounds in set_bit" ); +set_bit (0 , bits); + +pr_info ("within-bounds in set_bit" ); +set_bit (BITS_PER_LONG -1 , bits); + +pr_info ("out-of-bounds in set_bit\n" ); +set_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __set_bit\n" ); +__set_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in clear_bit\n" ); +clear_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __clear_bit\n" ); +__clear_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in clear_bit_unlock\n" ); +clear_bit_unlock (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __clear_bit_unlock\n" ); +__clear_bit_unlock (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in change_bit\n" ); +change_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __change_bit\n" ); +__change_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_and_set_bit\n" ); +test_and_set_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __test_and_set_bit\n" ); +__test_and_set_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_and_set_bit_lock\n" ); +test_and_set_bit_lock (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_and_clear_bit\n" ); +test_and_clear_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __test_and_clear_bit\n" ); +__test_and_clear_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_and_change_bit\n" ); +test_and_change_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __test_and_change_bit\n" ); +__test_and_change_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_bit\n" ); + (void )test_bit (BITS_PER_LONG , bits); + +#if defined(clear_bit_unlock_is_negative_byte) +pr_info ("out-of-bounds in clear_bit_unlock_is_negative_byte\n" ); +clear_bit_unlock_is_negative_byte (BITS_PER_LONG , bits); +#endif +kfree (bits); +} +static int __init kmalloc_tests_init (void ) {/*
@@ -664,6 +732,7 @@ static int __init kmalloc_tests_init(void)kasan_memchr ();kasan_memcmp ();kasan_strings (); +kasan_bitops ();kasan_restore_multi_shot (multishot);
Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Re: [PATCH v3 1/3] lib/test_kasan: Add bitops tests
Quoted 8 lines · Marco Elver
This adds bitops tests to the
test_kasanmodule. In a follow-up patch, support for bitops instrumentation will be added.Signed-off-by Marco Elver <[email protected]>---
Changes in v3:
* Use kzalloc instead of kmalloc.
* Usesizeof(*bits).
Thatnks for cleaning these up! FWIW:
Mark.
Quoted 119 lines
Changes in v2:
* UseBITS_PER_LONG.
* Use heap allocated memory for test, as newer compilers (correctly) warn on OOB stack access.--- lib/test_kasan.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 72 insertions(+), 3 deletions(-)lib/test_kasan.c +72
-3@@ -11,16 +11,17 @@#define pr_fmt (fmt) "kasan test: %s " fmt, __func__ +#include <linux/bitops.h> #include <linux/delay.h> +#include <linux/kasan.h> #include <linux/kernel.h> -#include <linux/mman.h> #include <linux/mm.h> +#include <linux/mman.h> +#include <linux/module.h> #include <linux/printk.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/uaccess.h> -#include <linux/module.h> -#include <linux/kasan.h> /* * Note: test functions are marked noinline so that their names appear in @@ -623,6 +624,73 @@ static noinline void __init kasan_strings(void)strnlen (ptr,1 ); } +static noinline void __init kasan_bitops(void) +{ +long *bits =kzalloc (sizeof (*bits),GFP_KERNEL ); +if (!bits) +return ; + +pr_info ("within-bounds in set_bit" ); +set_bit (0 , bits); + +pr_info ("within-bounds in set_bit" ); +set_bit (BITS_PER_LONG -1 , bits); + +pr_info ("out-of-bounds in set_bit\n" ); +set_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __set_bit\n" ); +__set_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in clear_bit\n" ); +clear_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __clear_bit\n" ); +__clear_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in clear_bit_unlock\n" ); +clear_bit_unlock (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __clear_bit_unlock\n" ); +__clear_bit_unlock (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in change_bit\n" ); +change_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __change_bit\n" ); +__change_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_and_set_bit\n" ); +test_and_set_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __test_and_set_bit\n" ); +__test_and_set_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_and_set_bit_lock\n" ); +test_and_set_bit_lock (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_and_clear_bit\n" ); +test_and_clear_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __test_and_clear_bit\n" ); +__test_and_clear_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_and_change_bit\n" ); +test_and_change_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in __test_and_change_bit\n" ); +__test_and_change_bit (BITS_PER_LONG , bits); + +pr_info ("out-of-bounds in test_bit\n" ); + (void )test_bit (BITS_PER_LONG , bits); + +#if defined(clear_bit_unlock_is_negative_byte) +pr_info ("out-of-bounds in clear_bit_unlock_is_negative_byte\n" ); +clear_bit_unlock_is_negative_byte (BITS_PER_LONG , bits); +#endif +kfree (bits); +} +static int __init kmalloc_tests_init (void ) {/* @@ -664,6 +732,7 @@ static int __init kmalloc_tests_init(void)kasan_memchr ();kasan_memcmp ();kasan_strings (); +kasan_bitops ();kasan_restore_multi_shot (multishot);Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Re: [PATCH v3 1/3] lib/test_kasan: Add bitops tests
In reply to Marco ElverQuoted 43 lines · Marco Elver
This adds bitops tests to the
test_kasanmodule. In a follow-up patch, support for bitops instrumentation will be added.Signed-off-by Marco Elver <[email protected]>---
Changes in v3:
* Use kzalloc instead of kmalloc.
* Usesizeof(*bits).Changes in v2:
* UseBITS_PER_LONG.
* Use heap allocated memory for test, as newer compilers (correctly) warn on OOB stack access.--- lib/test_kasan.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 72 insertions(+), 3 deletions(-)lib/test_kasan.c +4
-3@@ -11,16 +11,17 @@#define pr_fmt (fmt) "kasan test: %s " fmt, __func__ +#include <linux/bitops.h> #include <linux/delay.h> +#include <linux/kasan.h> #include <linux/kernel.h> -#include <linux/mman.h> #include <linux/mm.h> +#include <linux/mman.h> +#include <linux/module.h> #include <linux/printk.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/uaccess.h> -#include <linux/module.h> -#include <linux/kasan.h> /* * Note: test functions are marked noinline so that their names appear in
lib/test_kasan.c static noinline void __init kasan_strings(void) · line 629
Quoted 6 lines
lib/test_kasan.c +3
-0@@ -623,6 +624,73 @@ static noinline void __init kasan_strings(void)strnlen (ptr,1 ); } +static noinline void __init kasan_bitops(void) +{ +long *bits =kzalloc (sizeof (*bits),GFP_KERNEL );
It would be safer to do kzalloc(sizeof(*bits) + 1, GFP_KERNEL) and change tests accordingly to: set_bit(BITS_PER_LONG + 1, bits) ... kmalloc will internally round up allocation to 16-bytes, so we won't be actually corrupting someone elses memory.
lib/test_kasan.c static noinline void __init kasan_strings(void) · line 637
Quoted 8 lines
lib/test_kasan.c +8
-0+if (!bits) +return ; + +pr_info ("within-bounds in set_bit" ); +set_bit (0 , bits); + +pr_info ("within-bounds in set_bit" ); +set_bit (BITS_PER_LONG -1 , bits);
I'd remove these two. There are plenty of within bounds set_bit() in the kernel so they are well tested already.
Re: [PATCH v3 1/3] lib/test_kasan: Add bitops tests
Thanks, I've sent v4.
Quoted 76 lines · Andrey Ryabinin
Quoted 43 lines · Marco Elver
This adds bitops tests to the
test_kasanmodule. In a follow-up patch, support for bitops instrumentation will be added.Signed-off-by Marco Elver <[email protected]>---
Changes in v3:
* Use kzalloc instead of kmalloc.
* Usesizeof(*bits).Changes in v2:
* UseBITS_PER_LONG.
* Use heap allocated memory for test, as newer compilers (correctly) warn on OOB stack access.--- lib/test_kasan.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 72 insertions(+), 3 deletions(-)lib/test_kasan.c +4
-3@@ -11,16 +11,17 @@#define pr_fmt (fmt) "kasan test: %s " fmt, __func__ +#include <linux/bitops.h> #include <linux/delay.h> +#include <linux/kasan.h> #include <linux/kernel.h> -#include <linux/mman.h> #include <linux/mm.h> +#include <linux/mman.h> +#include <linux/module.h> #include <linux/printk.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/uaccess.h> -#include <linux/module.h> -#include <linux/kasan.h> /* * Note: test functions are marked noinline so that their names appear in lib/test_kasan.c static noinline void __init kasan_strings(void) · line 629
Quoted 6 lines
lib/test_kasan.c +3
-0@@ -623,6 +624,73 @@ static noinline void __init kasan_strings(void)strnlen (ptr,1 ); } +static noinline void __init kasan_bitops(void) +{ +long *bits =kzalloc (sizeof (*bits),GFP_KERNEL );It would be safer to do
kzalloc(sizeof(*bits) + 1, GFP_KERNEL)and change tests accordingly to:set_bit(BITS_PER_LONG + 1, bits)... kmalloc will internally round up allocation to 16-bytes, so we won't be actually corrupting someone elses memory.lib/test_kasan.c static noinline void __init kasan_strings(void) · line 637
Quoted 8 lines
lib/test_kasan.c +8
-0+if (!bits) +return ; + +pr_info ("within-bounds in set_bit" ); +set_bit (0 , bits); + +pr_info ("within-bounds in set_bit" ); +set_bit (BITS_PER_LONG -1 , bits);I'd remove these two. There are plenty of within bounds
set_bit()in the kernel so they are well tested already.--
You received this message because you are subscribed to the Google Groups "kasan-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To post to this group, send email to [email protected].
To view this discussion on the web visit https://groups.google.com/d/msgid/kasan-dev/5c35bc08-749f-dbc4-09d0-fcf14b1da1b3%40virtuozzo.com.
For more options, visit https://groups.google.com/d/optout.
PATCH v3 2/3 x86: Use static_cpu_has in uaccess region to avoid instrumentation
In reply to Marco ElverThis patch is a pre-requisite for enabling KASAN bitops instrumentation; using static_cpu_has instead of boot_cpu_has avoids instrumentation of test_bit inside the uaccess region. With instrumentation, the KASAN check would otherwise be flagged by objtool.
For consistency, kernel/signal.c was changed to mirror this change, however, is never instrumented with KASAN (currently unsupported under x86 32bit).
---
Changes in v3:
* Use static_cpu_has instead of moving boot_cpu_has outside uaccess region.
Changes in v2:
* Replaces patch: 'tools/objtool: add kasan_check_* to uaccess whitelist'
--- arch/x86/ia32/ia32_signal.c | 2 +- arch/x86/kernel/signal.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
arch/x86/ia32/ia32_signal.c +1 -1
@@ -358,7 +358,7 @@ int ia32_setup_rt_frame(int sig, struct ksignal *ksig,put_user_ex (ptr_to_compat (&frame->uc), &frame->puc);/* Create the ucontext. */ -if (boot_cpu_has (X86_FEATURE_XSAVE )) +if (static_cpu_has (X86_FEATURE_XSAVE ))put_user_ex (UC_FP_XSTATE , &frame->uc.uc_flags);else put_user_ex (0 , &frame->uc.uc_flags);
arch/x86/kernel/signal.c +1 -1
@@ -391,7 +391,7 @@ static int __setup_rt_frame(int sig, struct ksignal *ksig,put_user_ex (&frame->uc, &frame->puc);/* Create the ucontext. */ -if (boot_cpu_has (X86_FEATURE_XSAVE )) +if (static_cpu_has (X86_FEATURE_XSAVE ))put_user_ex (UC_FP_XSTATE , &frame->uc.uc_flags);else put_user_ex (0 , &frame->uc.uc_flags);
Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Re: [PATCH v3 2/3] x86: Use static_cpu_has in uaccess region to avoid instrumentation
Gentle ping. I would appreciate quick feedback if this approach is reasonable.
Peter: since you suggested that we should not change objtool, did you have a particular approach in mind that is maybe different from v2 and v3? Or is this what you were thinking of?
Many thanks!
Quoted 54 lines · Marco Elver
This patch is a pre-requisite for enabling KASAN bitops instrumentation; using
static_cpu_hasinstead ofboot_cpu_hasavoids instrumentation oftest_bitinside the uaccess region. With instrumentation, the KASAN check would otherwise be flagged by objtool.For consistency,
kernel/signal.cwas changed to mirror this change, however, is never instrumented with KASAN (currently unsupported under x86 32bit).Signed-off-by Marco Elver <[email protected]>Suggested-by H. Peter Anvin <[email protected]>---
Changes in v3:
* Usestatic_cpu_hasinstead of movingboot_cpu_hasoutside uaccess region.Changes in v2:
* Replaces patch: 'tools/objtool: add kasan_check_* to uaccess whitelist'--- arch/x86/ia32/ia32_signal.c | 2 +- arch/x86/kernel/signal.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)arch/x86/ia32/ia32_signal.c +1
-1@@ -358,7 +358,7 @@ int ia32_setup_rt_frame(int sig, struct ksignal *ksig,put_user_ex (ptr_to_compat (&frame->uc), &frame->puc);/* Create the ucontext. */ -if (boot_cpu_has (X86_FEATURE_XSAVE )) +if (static_cpu_has (X86_FEATURE_XSAVE ))put_user_ex (UC_FP_XSTATE , &frame->uc.uc_flags);else put_user_ex (0 , &frame->uc.uc_flags);arch/x86/kernel/signal.c +1
-2@@ -391,7 +391,7 @@ static int __setup_rt_frame(int sig, struct ksignal *ksig,put_user_ex (&frame->uc, &frame->puc);/* Create the ucontext. */ -if (boot_cpu_has (X86_FEATURE_XSAVE )) +if (static_cpu_has (X86_FEATURE_XSAVE ))put_user_ex (UC_FP_XSTATE , &frame->uc.uc_flags);else put_user_ex (0 , &frame->uc.uc_flags); --2.22.0.rc1.257.g3120a18244-goog
Re: [PATCH v3 2/3] x86: Use static_cpu_has in uaccess region to avoid instrumentation
Quoted 42 lines · Marco Elver
Gentle ping. I would appreciate quick feedback if this approach is reasonable.
Peter: since you suggested that we should not change objtool, did you have a particular approach in mind that is maybe different from v2 and v3? Or is this what you were thinking of?
Many thanks!
Quoted 32 lines · Marco Elver
This patch is a pre-requisite for enabling KASAN bitops instrumentation; using
static_cpu_hasinstead ofboot_cpu_hasavoids instrumentation oftest_bitinside the uaccess region. With instrumentation, the KASAN check would otherwise be flagged by objtool.For consistency,
kernel/signal.cwas changed to mirror this change, however, is never instrumented with KASAN (currently unsupported under x86 32bit).Signed-off-by Marco Elver <[email protected]>Suggested-by H. Peter Anvin <[email protected]>---
Changes in v3:
* Usestatic_cpu_hasinstead of movingboot_cpu_hasoutside uaccess region.Changes in v2:
* Replaces patch: 'tools/objtool: add kasan_check_* to uaccess whitelist'--- arch/x86/ia32/ia32_signal.c | 2 +- arch/x86/kernel/signal.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)arch/x86/ia32/ia32_signal.c +0
-0@@ -358,7 +358,7 @@ int ia32_setup_rt_frame(int sig, struct ksignal *ksig,put_user_ex (ptr_to_compat (&frame->uc), &frame->puc);
Quoted 3 lines
arch/x86/ia32/ia32_signal.c int ia32_setup_rt_frame(int sig, struct ksignal *ksig, · line 361
Quoted 3 lines
arch/x86/ia32/ia32_signal.c +1
-1/* Create the ucontext. */ -if (boot_cpu_has (X86_FEATURE_XSAVE )) +if (static_cpu_has (X86_FEATURE_XSAVE ))
Peter Z or A, does it look good to you? Could you please Ack this?
Quoted 19 lines
Quoted 19 lines
arch/x86/ia32/ia32_signal.c +0
-0put_user_ex (UC_FP_XSTATE , &frame->uc.uc_flags); else put_user_ex(0, &frame->uc.uc_flags);arch/x86/kernel/signal.c +1
-2@@ -391,7 +391,7 @@ static int __setup_rt_frame(int sig, struct ksignal *ksig,put_user_ex (&frame->uc, &frame->puc);/* Create the ucontext. */ -if (boot_cpu_has (X86_FEATURE_XSAVE )) +if (static_cpu_has (X86_FEATURE_XSAVE ))put_user_ex (UC_FP_XSTATE , &frame->uc.uc_flags);else put_user_ex (0 , &frame->uc.uc_flags); --2.22.0.rc1.257.g3120a18244-goog
Re: [PATCH v3 2/3] x86: Use static_cpu_has in uaccess region to avoid instrumentation
In reply to Marco ElverQuoted 8 lines · Marco Elver
This patch is a pre-requisite for enabling KASAN bitops instrumentation; using
static_cpu_hasinstead ofboot_cpu_hasavoids instrumentation oftest_bitinside the uaccess region. With instrumentation, the KASAN check would otherwise be flagged by objtool.For consistency,
kernel/signal.cwas changed to mirror this change, however, is never instrumented with KASAN (currently unsupported under x86 32bit).
Thanks!
Quoted 45 lines
Signed-off-by Marco Elver <[email protected]>Suggested-by H. Peter Anvin <[email protected]>---
Changes in v3:
* Usestatic_cpu_hasinstead of movingboot_cpu_hasoutside uaccess region.Changes in v2:
* Replaces patch: 'tools/objtool: add kasan_check_* to uaccess whitelist'--- arch/x86/ia32/ia32_signal.c | 2 +- arch/x86/kernel/signal.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)arch/x86/ia32/ia32_signal.c +1
-1@@ -358,7 +358,7 @@ int ia32_setup_rt_frame(int sig, struct ksignal *ksig,put_user_ex (ptr_to_compat (&frame->uc), &frame->puc);/* Create the ucontext. */ -if (boot_cpu_has (X86_FEATURE_XSAVE )) +if (static_cpu_has (X86_FEATURE_XSAVE ))put_user_ex (UC_FP_XSTATE , &frame->uc.uc_flags);else put_user_ex (0 , &frame->uc.uc_flags);arch/x86/kernel/signal.c +1
-1@@ -391,7 +391,7 @@ static int __setup_rt_frame(int sig, struct ksignal *ksig,put_user_ex (&frame->uc, &frame->puc);/* Create the ucontext. */ -if (boot_cpu_has (X86_FEATURE_XSAVE )) +if (static_cpu_has (X86_FEATURE_XSAVE ))put_user_ex (UC_FP_XSTATE , &frame->uc.uc_flags);else put_user_ex (0 , &frame->uc.uc_flags);Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Re: [PATCH v3 2/3] x86: Use static_cpu_has in uaccess region to avoid instrumentation
In reply to Marco ElverQuoted 11 lines · Marco Elver
This patch is a pre-requisite for enabling KASAN bitops instrumentation; using
static_cpu_hasinstead ofboot_cpu_hasavoids instrumentation oftest_bitinside the uaccess region. With instrumentation, the KASAN check would otherwise be flagged by objtool.For consistency,
kernel/signal.cwas changed to mirror this change, however, is never instrumented with KASAN (currently unsupported under x86 32bit).Signed-off-by Marco Elver <[email protected]>Suggested-by H. Peter Anvin <[email protected]>
PATCH v3 3/3 asm-generic, x86: Add bitops instrumentation for KASAN
In reply to Marco ElverThis adds a new header to asm-generic to allow optionally instrumenting architecture-specific asm implementations of bitops.
This change includes the required change for x86 as reference and changes the kernel API doc to point to bitops-instrumented.h instead.
Rationale: the functions in x86's bitops.h are no longer the kernel API functions, but instead the arch_ prefixed functions, which are then instrumented via bitops-instrumented.h.
Other architectures can similarly add support for asm implementations of bitops.
The documentation text was derived from x86 and existing bitops asm-generic versions: 1) references to x86 have been removed; 2) as a result, some of the text had to be reworded for clarity and consistency.
Tested: using lib/test_kasan with bitops tests (pre-requisite patch).
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=198439
---
Changes in v3:
* Remove references to 'x86' in API documentation; as a result, had to reword doc text for clarify and consistency.
* Remove #ifdef, since it is assumed that if asm-generic bitops implementations are used, bitops-instrumented.h is not needed.
Changes in v2:
* Instrument word-sized accesses, as specified by the interface.
--- Documentation/core-api/kernel-api.rst | 2 +- arch/x86/include/asm/bitops.h | 189 ++++------------ include/asm-generic/bitops-instrumented.h | 263 ++++++++++++++++++++++ 3 files changed, 302 insertions(+), 152 deletions(-) create mode 100644 include/asm-generic/bitops-instrumented.h
Documentation/core-api/kernel-api.rst +1 -1
@@ -51,7 +51,7 @@ The Linux kernel provides more basic utility functions. Bit Operations -------------- -.. kernel-doc:: arch/x86/include/asm/bitops.h +.. kernel-doc:: include/asm-generic/bitops-instrumented.h :internal: Bitmap Operations
arch/x86/include/asm/bitops.h +38 -151
289 lines not on this page · raw message
include/asm-generic/bitops-instrumented.h new file +263 -0
263 lines not on this page · raw message
Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Re: [PATCH v3 3/3] asm-generic, x86: Add bitops instrumentation for KASAN
Quoted 18 lines · Marco Elver
This adds a new header to asm-generic to allow optionally instrumenting architecture-specific asm implementations of bitops.
This change includes the required change for x86 as reference and changes the kernel API doc to point to
bitops-instrumented.hinstead.
Rationale: the functions in x86'sbitops.hare no longer the kernel API functions, but instead thearch_prefixed functions, which are then instrumented viabitops-instrumented.h.Other architectures can similarly add support for asm implementations of bitops.
The documentation text was derived from x86 and existing bitops asm-generic versions: 1) references to x86 have been removed; 2) as a result, some of the text had to be reworded for clarity and consistency.
Tested: using
lib/test_kasanwith bitops tests (pre-requisite patch).
Quoted 8 lines
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=198439
Signed-off-by Marco Elver <[email protected]>---
Changes in v3:
* Remove references to 'x86' in API documentation; as a result, had to reword doc text for clarify and consistency.
* Remove #ifdef, since it is assumed that if asm-generic bitops implementations are used,bitops-instrumented.his not needed.
Thanks for sorting this out. FWIW:
Mark.
Quoted 599 lines
Changes in v2:
* Instrument word-sized accesses, as specified by the interface.--- Documentation/core-api/kernel-api.rst | 2 +- arch/x86/include/asm/bitops.h | 189 ++++------------ include/asm-generic/bitops-instrumented.h | 263 ++++++++++++++++++++++ 3 files changed, 302 insertions(+), 152 deletions(-) create mode 100644 include/asm-generic/bitops-instrumented.hDocumentation/core-api/kernel-api.rst +1
-1@@ -51,7 +51,7 @@ The Linux kernel provides more basic utility functions. Bit Operations -------------- -.. kernel-doc:: arch/x86/include/asm/bitops.h +.. kernel-doc:: include/asm-generic/bitops-instrumented.h :internal: Bitmap Operationsarch/x86/include/asm/bitops.h +38
-151@@ -49,23 +49,8 @@#define CONST_MASK_ADDR (nr, addr) WBYTE_ADDR((void *)(addr) + ((nr)>>3))#define CONST_MASK (nr) (1 << ((nr) & 7)) -/** -* set_bit - Atomically set a bit in memory -* @nr: the bit to set -* @addr: the address to start counting from -* -* This function is atomic and may not be reordered. See __set_bit() -* if you do not require the atomic guarantees. -* -* Note: there are no guarantees that this function will not be reordered -* on non x86 architectures, so if you are writing portable code, -* make sure not to rely on its reordering guarantees. -* -* Note that @nr may be almost arbitrarily large; this function is not -* restricted to acting on a single-word quantity. -*/ static __always_inline void -set_bit (long nr,volatile unsigned long *addr) +arch_set_bit (long nr,volatile unsigned long *addr) {if (IS_IMMEDIATE (nr)) { asm volatile(LOCK_PREFIX "orb %1,%0"@@ -78,32 +63,14 @@ set_bit(long nr, volatile unsigned long *addr) } } -/** -* __set_bit - Set a bit in memory -* @nr: the bit to set -* @addr: the address to start counting from -* -* Unlike set_bit(), this function is non-atomic and may be reordered. -* If it's called on the same region of memory simultaneously, the effect -* may be that only one operation succeeds. -*/ -static __always_inline void __set_bit(long nr, volatile unsigned long *addr) +static __always_inline void +arch___set_bit (long nr,volatile unsigned long *addr) { asm volatile(__ASM_SIZE(bts) " %1,%0" : : ADDR, "Ir" (nr) : "memory"); } -/** -* clear_bit - Clears a bit in memory -* @nr: Bit to clear -* @addr: Address to start counting from -* -* clear_bit() is atomic and may not be reordered. However, it does -* not contain a memory barrier, so if it is used for locking purposes, -* you should call smp_mb__before_atomic() and/or smp_mb__after_atomic() -* in order to ensure changes are visible on other processors. -*/ static __always_inline void -clear_bit (long nr,volatile unsigned long *addr) +arch_clear_bit (long nr,volatile unsigned long *addr) {if (IS_IMMEDIATE (nr)) { asm volatile(LOCK_PREFIX "andb %1,%0"@@ -115,26 +82,21 @@ clear_bit(long nr, volatile unsigned long *addr) } } -/* -* clear_bit_unlock - Clears a bit in memory -* @nr: Bit to clear -* @addr: Address to start counting from -* -* clear_bit() is atomic and implies release semantics before the memory -* operation. It can be used for an unlock. -*/ -static __always_inline void clear_bit_unlock(long nr, volatile unsigned long *addr) +static __always_inline void +arch_clear_bit_unlock (long nr,volatile unsigned long *addr) {barrier (); -clear_bit (nr, addr); +arch_clear_bit (nr, addr); } -static __always_inline void __clear_bit(long nr, volatile unsigned long *addr) +static __always_inline void +arch___clear_bit (long nr,volatile unsigned long *addr) { asm volatile(__ASM_SIZE(btr) " %1,%0" : : ADDR, "Ir" (nr) : "memory"); } -static __always_inline bool clear_bit_unlock_is_negative_byte(long nr, volatile unsigned long *addr) +static __always_inline bool +arch_clear_bit_unlock_is_negative_byte (long nr,volatile unsigned long *addr) {bool negative; asm volatile(LOCK_PREFIX "andb %2,%1"@@ -143,48 +105,23 @@ static __always_inline bool clear_bit_unlock_is_negative_byte(long nr, volatile : "ir" ((char) ~(1 << nr)) : "memory");return negative; } +#define arch_clear_bit_unlock_is_negative_byte \ + arch_clear_bit_unlock_is_negative_byte -// Let everybody know we have it -#define clear_bit_unlock_is_negative_byte clear_bit_unlock_is_negative_byte - -/* -* __clear_bit_unlock - Clears a bit in memory -* @nr: Bit to clear -* @addr: Address to start counting from -* -* __clear_bit() is non-atomic and implies release semantics before the memory -* operation. It can be used for an unlock if no other CPUs can concurrently -* modify other bits in the word. -*/ -static __always_inline void __clear_bit_unlock(long nr, volatile unsigned long *addr) +static __always_inline void +arch___clear_bit_unlock (long nr,volatile unsigned long *addr) { -__clear_bit (nr, addr); +arch___clear_bit (nr, addr); } -/** -* __change_bit - Toggle a bit in memory -* @nr: the bit to change -* @addr: the address to start counting from -* -* Unlike change_bit(), this function is non-atomic and may be reordered. -* If it's called on the same region of memory simultaneously, the effect -* may be that only one operation succeeds. -*/ -static __always_inline void __change_bit(long nr, volatile unsigned long *addr) +static __always_inline void +arch___change_bit (long nr,volatile unsigned long *addr) { asm volatile(__ASM_SIZE(btc) " %1,%0" : : ADDR, "Ir" (nr) : "memory"); } -/** -* change_bit - Toggle a bit in memory -* @nr: Bit to change -* @addr: Address to start counting from -* -* change_bit() is atomic and may not be reordered. -* Note that @nr may be almost arbitrarily large; this function is not -* restricted to acting on a single-word quantity. -*/ -static __always_inline void change_bit(long nr, volatile unsigned long *addr) +static __always_inline void +arch_change_bit (long nr,volatile unsigned long *addr) {if (IS_IMMEDIATE (nr)) { asm volatile(LOCK_PREFIX "xorb %1,%0"@@ -196,42 +133,20 @@ static __always_inline void change_bit(long nr, volatile unsigned long *addr) } } -/** -* test_and_set_bit - Set a bit and return its old value -* @nr: Bit to set -* @addr: Address to count from -* -* This operation is atomic and cannot be reordered. -* It also implies a memory barrier. -*/ -static __always_inline bool test_and_set_bit(long nr, volatile unsigned long *addr) +static __always_inline bool +arch_test_and_set_bit (long nr,volatile unsigned long *addr) { return GEN_BINARY_RMWcc(LOCK_PREFIX __ASM_SIZE(bts), *addr, c, "Ir", nr); } -/** -* test_and_set_bit_lock - Set a bit and return its old value for lock -* @nr: Bit to set -* @addr: Address to count from -* -* This is the same as test_and_set_bit on x86. -*/ static __always_inline bool -test_and_set_bit_lock (long nr,volatile unsigned long *addr) +arch_test_and_set_bit_lock (long nr,volatile unsigned long *addr) { -return test_and_set_bit (nr, addr); +return arch_test_and_set_bit (nr, addr); } -/** -* __test_and_set_bit - Set a bit and return its old value -* @nr: Bit to set -* @addr: Address to count from -* -* This operation is non-atomic and can be reordered. -* If two examples of this operation race, one can appear to succeed -* but actually fail. You must protect multiple accesses with a lock. -*/ -static __always_inline bool __test_and_set_bit(long nr, volatile unsigned long *addr) +static __always_inline bool +arch___test_and_set_bit (long nr,volatile unsigned long *addr) {bool oldbit;@@ -242,28 +157,13 @@ static __always_inline bool __test_and_set_bit(long nr, volatile unsigned long *return oldbit; } -/** -* test_and_clear_bit - Clear a bit and return its old value -* @nr: Bit to clear -* @addr: Address to count from -* -* This operation is atomic and cannot be reordered. -* It also implies a memory barrier. -*/ -static __always_inline bool test_and_clear_bit(long nr, volatile unsigned long *addr) +static __always_inline bool +arch_test_and_clear_bit (long nr,volatile unsigned long *addr) { return GEN_BINARY_RMWcc(LOCK_PREFIX __ASM_SIZE(btr), *addr, c, "Ir", nr); } -/** -* __test_and_clear_bit - Clear a bit and return its old value -* @nr: Bit to clear -* @addr: Address to count from -* -* This operation is non-atomic and can be reordered. -* If two examples of this operation race, one can appear to succeed -* but actually fail. You must protect multiple accesses with a lock. -* +/* * Note: the operation is performed atomically with respect to * the local CPU, but not other CPUs. Portable code should not * rely on this behaviour. @@ -271,7 +171,8 @@ static __always_inline bool test_and_clear_bit(long nr, volatile unsigned long ** accessed from a hypervisor on the same CPU if running in a VM: don't change * this without also updating arch/x86/kernel/kvm.c */ -static __always_inline bool __test_and_clear_bit(long nr, volatile unsigned long *addr) +static __always_inline bool +arch___test_and_clear_bit (long nr,volatile unsigned long *addr) {bool oldbit;@@ -282,8 +183,8 @@ static __always_inline bool __test_and_clear_bit(long nr, volatile unsigned longreturn oldbit; } -/* WARNING: non atomic and it can be reordered! */ -static __always_inline bool __test_and_change_bit(long nr, volatile unsigned long *addr) +static __always_inline bool +arch___test_and_change_bit (long nr,volatile unsigned long *addr) {bool oldbit;@@ -295,15 +196,8 @@ static __always_inline bool __test_and_change_bit(long nr, volatile unsigned lonreturn oldbit; } -/** -* test_and_change_bit - Change a bit and return its old value -* @nr: Bit to change -* @addr: Address to count from -* -* This operation is atomic and cannot be reordered. -* It also implies a memory barrier. -*/ -static __always_inline bool test_and_change_bit(long nr, volatile unsigned long *addr) +static __always_inline bool +arch_test_and_change_bit (long nr,volatile unsigned long *addr) { return GEN_BINARY_RMWcc(LOCK_PREFIX __ASM_SIZE(btc), *addr, c, "Ir", nr); }@@ -326,16 +220,7 @@ static __always_inline bool variable_test_bit(long nr, volatile const unsigned lreturn oldbit; } -#if 0 /* Fool kernel-doc since it doesn't do macros yet */ -/** -* test_bit - Determine whether a bit is set -* @nr: bit number to test -* @addr: Address to start counting from -*/ -static bool test_bit (int nr,const volatile unsigned long *addr); -#endif - -#define test_bit (nr, addr) \ +#define arch_test_bit (nr, addr) \ (__builtin_constant_p((nr)) \ ? constant_test_bit((nr), (addr)) \ : variable_test_bit((nr), (addr)))@@ -504,6 +389,8 @@ static __always_inline int fls64(__u64 x)#include <asm-generic/bitops/const_hweight.h> +#include <asm-generic/bitops-instrumented.h> +#include <asm-generic/bitops/le.h> #include <asm-generic/bitops/ext2-atomic-setbit.h> include/asm-generic/bitops-instrumented.h new file +263
-0@@ -0,0 +1,263 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +/* +* This file provides wrappers with sanitizer instrumentation for bit +* operations. +* +* To use this functionality, an arch's bitops.h file needs to define each of +* the below bit operations with an arch_ prefix (e.g. arch_set_bit(), +* arch___set_bit(), etc.). +*/ +#ifndef _ASM_GENERIC_BITOPS_INSTRUMENTED_H +#define _ASM_GENERIC_BITOPS_INSTRUMENTED_H + +#include <linux/kasan-checks.h> + +/** +* set_bit - Atomically set a bit in memory +* @nr: the bit to set +* @addr: the address to start counting from +* +* This is a relaxed atomic operation (no implied memory barriers). +* +* Note that @nr may be almost arbitrarily large; this function is not +* restricted to acting on a single-word quantity. +*/ +static inline void set_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +arch_set_bit (nr, addr); +} + +/** +* __set_bit - Set a bit in memory +* @nr: the bit to set +* @addr: the address to start counting from +* +* Unlike set_bit(), this function is non-atomic. If it is called on the same +* region of memory concurrently, the effect may be that only one operation +* succeeds. +*/ +static inline void __set_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +arch___set_bit (nr, addr); +} + +/** +* clear_bit - Clears a bit in memory +* @nr: Bit to clear +* @addr: Address to start counting from +* +* This is a relaxed atomic operation (no implied memory barriers). +*/ +static inline void clear_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +arch_clear_bit (nr, addr); +} + +/** +* __clear_bit - Clears a bit in memory +* @nr: the bit to clear +* @addr: the address to start counting from +* +* Unlike clear_bit(), this function is non-atomic. If it is called on the same +* region of memory concurrently, the effect may be that only one operation +* succeeds. +*/ +static inline void __clear_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +arch___clear_bit (nr, addr); +} + +/** +* clear_bit_unlock - Clear a bit in memory, for unlock +* @nr: the bit to set +* @addr: the address to start counting from +* +* This operation is atomic and provides release barrier semantics. +*/ +static inline void clear_bit_unlock (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +arch_clear_bit_unlock (nr, addr); +} + +/** +* __clear_bit_unlock - Clears a bit in memory +* @nr: Bit to clear +* @addr: Address to start counting from +* +* This is a non-atomic operation but implies a release barrier before the +* memory operation. It can be used for an unlock if no other CPUs can +* concurrently modify other bits in the word. +*/ +static inline void __clear_bit_unlock (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +arch___clear_bit_unlock (nr, addr); +} + +/** +* change_bit - Toggle a bit in memory +* @nr: Bit to change +* @addr: Address to start counting from +* +* This is a relaxed atomic operation (no implied memory barriers). +* +* Note that @nr may be almost arbitrarily large; this function is not +* restricted to acting on a single-word quantity. +*/ +static inline void change_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +arch_change_bit (nr, addr); +} + +/** +* __change_bit - Toggle a bit in memory +* @nr: the bit to change +* @addr: the address to start counting from +* +* Unlike change_bit(), this function is non-atomic. If it is called on the same +* region of memory concurrently, the effect may be that only one operation +* succeeds. +*/ +static inline void __change_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +arch___change_bit (nr, addr); +} + +/** +* test_and_set_bit - Set a bit and return its old value +* @nr: Bit to set +* @addr: Address to count from +* +* This is an atomic fully-ordered operation (implied full memory barrier). +*/ +static inline bool test_and_set_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +return arch_test_and_set_bit (nr, addr); +} + +/** +* __test_and_set_bit - Set a bit and return its old value +* @nr: Bit to set +* @addr: Address to count from +* +* This operation is non-atomic. If two instances of this operation race, one +* can appear to succeed but actually fail. +*/ +static inline bool __test_and_set_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +return arch___test_and_set_bit (nr, addr); +} + +/** +* test_and_set_bit_lock - Set a bit and return its old value, for lock +* @nr: Bit to set +* @addr: Address to count from +* +* This operation is atomic and provides acquire barrier semantics if +* the returned value is 0. +* It can be used to implement bit locks. +*/ +static inline bool test_and_set_bit_lock (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +return arch_test_and_set_bit_lock (nr, addr); +} + +/** +* test_and_clear_bit - Clear a bit and return its old value +* @nr: Bit to clear +* @addr: Address to count from +* +* This is an atomic fully-ordered operation (implied full memory barrier). +*/ +static inline bool test_and_clear_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +return arch_test_and_clear_bit (nr, addr); +} + +/** +* __test_and_clear_bit - Clear a bit and return its old value +* @nr: Bit to clear +* @addr: Address to count from +* +* This operation is non-atomic. If two instances of this operation race, one +* can appear to succeed but actually fail. +*/ +static inline bool __test_and_clear_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +return arch___test_and_clear_bit (nr, addr); +} + +/** +* test_and_change_bit - Change a bit and return its old value +* @nr: Bit to change +* @addr: Address to count from +* +* This is an atomic fully-ordered operation (implied full memory barrier). +*/ +static inline bool test_and_change_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +return arch_test_and_change_bit (nr, addr); +} + +/** +* __test_and_change_bit - Change a bit and return its old value +* @nr: Bit to change +* @addr: Address to count from +* +* This operation is non-atomic. If two instances of this operation race, one +* can appear to succeed but actually fail. +*/ +static inline bool __test_and_change_bit (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +return arch___test_and_change_bit (nr, addr); +} + +/** +* test_bit - Determine whether a bit is set +* @nr: bit number to test +* @addr: Address to start counting from +*/ +static inline bool test_bit (long nr,const volatile unsigned long *addr) +{ +kasan_check_read (addr +BIT_WORD (nr),sizeof (long )); +return arch_test_bit (nr, addr); +} + +#if defined(arch_clear_bit_unlock_is_negative_byte) +/** +* clear_bit_unlock_is_negative_byte - Clear a bit in memory and test if bottom +* byte is negative, for unlock. +* @nr: the bit to clear +* @addr: the address to start counting from +* +* This operation is atomic and provides release barrier semantics. +* +* This is a bit of a one-trick-pony for the filemap code, which clears +* PG_locked and tests PG_waiters, +*/ +static inline bool +clear_bit_unlock_is_negative_byte (long nr,volatile unsigned long *addr) +{ +kasan_check_write (addr +BIT_WORD (nr),sizeof (long )); +return arch_clear_bit_unlock_is_negative_byte (nr, addr); +} +/* Let everybody know we have it. */ +#define clear_bit_unlock_is_negative_byte clear_bit_unlock_is_negative_byte +#endif + +#endif /* _ASM_GENERIC_BITOPS_INSTRUMENTED_H */ Signature · 1 line
2.22.0.rc1.257.g3120a18244-goog
Re: [PATCH v3 3/3] asm-generic, x86: Add bitops instrumentation for KASAN
In reply to Marco ElverQuoted 12 lines · Marco Elver
This adds a new header to asm-generic to allow optionally instrumenting architecture-specific asm implementations of bitops.
This change includes the required change for x86 as reference and changes the kernel API doc to point to
bitops-instrumented.hinstead.
Rationale: the functions in x86'sbitops.hare no longer the kernel API functions, but instead thearch_prefixed functions, which are then instrumented viabitops-instrumented.h.Other architectures can similarly add support for asm implementations of bitops.
Quoted 8 lines
The documentation text was derived from x86 and existing bitops asm-generic versions: 1) references to x86 have been removed; 2) as a result, some of the text had to be reworded for clarity and consistency.
Tested: using
lib/test_kasanwith bitops tests (pre-requisite patch).Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=198439
Signed-off-by Marco Elver <[email protected]>