| Message ID | 20210118183033.41764-3-vincenzo.frascino@arm.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | arm64: ARMv8.5-A: MTE: Add async mode support | expand |
On Mon, Jan 18, 2021 at 7:30 PM Vincenzo Frascino <vincenzo.frascino@arm.com> wrote: > --- a/Documentation/dev-tools/kasan.rst > +++ b/Documentation/dev-tools/kasan.rst > @@ -162,6 +162,9 @@ particular KASAN features. > > - ``kasan=off`` or ``=on`` controls whether KASAN is enabled (default: ``on``). > > +- ``kasan.mode=sync`` or ``=async`` controls whether KASAN is configured in > + synchronous or asynchronous mode of execution (default: ``sync``). This needs to be expanded with a short explanation of the difference. > +static inline void hw_enable_tagging_mode(void) > +{ > + if (kasan_arg_mode == KASAN_ARG_MODE_ASYNC) > + hw_enable_tagging_async(); > + else > + hw_enable_tagging_sync(); > +} It's OK to open-code this in kasan_init_hw_tags_cpu(), no need for an additional function. > --- a/mm/kasan/kasan.h > +++ b/mm/kasan/kasan.h > @@ -284,7 +284,8 @@ static inline const void *arch_kasan_set_tag(const void *addr, u8 tag) > #define arch_set_mem_tag_range(addr, size, tag) ((void *)(addr)) > #endif > > -#define hw_enable_tagging() arch_enable_tagging() > +#define hw_enable_tagging_sync() arch_enable_tagging_sync() > +#define hw_enable_tagging_async() arch_enable_tagging_async() This is one of the places that conflicts with the testing patches. You'll need to: add an else case definition of hw_enable_tagging_sync(); change lib/test_kasan.c to use hw_enable_tagging_sync(). I'll later add a patch on top that forbids running the tests with the async mode.
Hi Andrey, On 1/19/21 6:10 PM, Andrey Konovalov wrote: > On Mon, Jan 18, 2021 at 7:30 PM Vincenzo Frascino > <vincenzo.frascino@arm.com> wrote: >> --- a/Documentation/dev-tools/kasan.rst >> +++ b/Documentation/dev-tools/kasan.rst >> @@ -162,6 +162,9 @@ particular KASAN features. >> >> - ``kasan=off`` or ``=on`` controls whether KASAN is enabled (default: ``on``). >> >> +- ``kasan.mode=sync`` or ``=async`` controls whether KASAN is configured in >> + synchronous or asynchronous mode of execution (default: ``sync``). > This needs to be expanded with a short explanation of the difference. > Ok, I will extend it in v5. >> +static inline void hw_enable_tagging_mode(void) >> +{ >> + if (kasan_arg_mode == KASAN_ARG_MODE_ASYNC) >> + hw_enable_tagging_async(); >> + else >> + hw_enable_tagging_sync(); >> +} > It's OK to open-code this in kasan_init_hw_tags_cpu(), no need for an > additional function. > I added the new function to keep the code cleaner, but I do not have strong opinion hence it is fine by me to have open-code here.
Hi Andrey, On 1/19/21 6:10 PM, Andrey Konovalov wrote: > I'll later add a patch on top that forbids running the tests with the > async mode. Sorry, I misread this part, I thought you wanted me to do this. Anyway I added the check to my last series. Please have a look.
diff --git a/Documentation/dev-tools/kasan.rst b/Documentation/dev-tools/kasan.rst index 1651d961f06a..60ad73c2a33c 100644 --- a/Documentation/dev-tools/kasan.rst +++ b/Documentation/dev-tools/kasan.rst @@ -162,6 +162,9 @@ particular KASAN features. - ``kasan=off`` or ``=on`` controls whether KASAN is enabled (default: ``on``). +- ``kasan.mode=sync`` or ``=async`` controls whether KASAN is configured in + synchronous or asynchronous mode of execution (default: ``sync``). + - ``kasan.stacktrace=off`` or ``=on`` disables or enables alloc and free stack traces collection (default: ``on`` for ``CONFIG_DEBUG_KERNEL=y``, otherwise ``off``). diff --git a/mm/kasan/hw_tags.c b/mm/kasan/hw_tags.c index e529428e7a11..344aeec05d43 100644 --- a/mm/kasan/hw_tags.c +++ b/mm/kasan/hw_tags.c @@ -25,6 +25,11 @@ enum kasan_arg { KASAN_ARG_ON, }; +enum kasan_arg_mode { + KASAN_ARG_MODE_SYNC, + KASAN_ARG_MODE_ASYNC, +}; + enum kasan_arg_stacktrace { KASAN_ARG_STACKTRACE_DEFAULT, KASAN_ARG_STACKTRACE_OFF, @@ -38,6 +43,7 @@ enum kasan_arg_fault { }; static enum kasan_arg kasan_arg __ro_after_init; +static enum kasan_arg_mode kasan_arg_mode __ro_after_init; static enum kasan_arg_stacktrace kasan_arg_stacktrace __ro_after_init; static enum kasan_arg_fault kasan_arg_fault __ro_after_init; @@ -68,6 +74,21 @@ static int __init early_kasan_flag(char *arg) } early_param("kasan", early_kasan_flag); +/* kasan.mode=sync/async */ +static int __init early_kasan_mode(char *arg) +{ + /* If arg is not set the default mode is sync */ + if ((!arg) || !strcmp(arg, "sync")) + kasan_arg_mode = KASAN_ARG_MODE_SYNC; + else if (!strcmp(arg, "async")) + kasan_arg_mode = KASAN_ARG_MODE_ASYNC; + else + return -EINVAL; + + return 0; +} +early_param("kasan.mode", early_kasan_mode); + /* kasan.stacktrace=off/on */ static int __init early_kasan_flag_stacktrace(char *arg) { @@ -102,6 +123,14 @@ static int __init early_kasan_fault(char *arg) } early_param("kasan.fault", early_kasan_fault); +static inline void hw_enable_tagging_mode(void) +{ + if (kasan_arg_mode == KASAN_ARG_MODE_ASYNC) + hw_enable_tagging_async(); + else + hw_enable_tagging_sync(); +} + /* kasan_init_hw_tags_cpu() is called for each CPU. */ void kasan_init_hw_tags_cpu(void) { @@ -115,7 +144,7 @@ void kasan_init_hw_tags_cpu(void) return; hw_init_tags(KASAN_TAG_MAX); - hw_enable_tagging(); + hw_enable_tagging_mode(); } /* kasan_init_hw_tags() is called once on boot CPU. */ diff --git a/mm/kasan/kasan.h b/mm/kasan/kasan.h index cc4d9e1d49b1..7db7bd42fe97 100644 --- a/mm/kasan/kasan.h +++ b/mm/kasan/kasan.h @@ -284,7 +284,8 @@ static inline const void *arch_kasan_set_tag(const void *addr, u8 tag) #define arch_set_mem_tag_range(addr, size, tag) ((void *)(addr)) #endif -#define hw_enable_tagging() arch_enable_tagging() +#define hw_enable_tagging_sync() arch_enable_tagging_sync() +#define hw_enable_tagging_async() arch_enable_tagging_async() #define hw_init_tags(max_tag) arch_init_tags(max_tag) #define hw_get_random_tag() arch_get_random_tag() #define hw_get_mem_tag(addr) arch_get_mem_tag(addr)
Architectures supported by KASAN HW can provide a sync or async mode of execution. On an MTE enabled arm64 hw for example this can be identified with the synchronous or asynchronous tagging mode of execution. In synchronous mode, an exception is triggered if a tag check fault occurs. In asynchronous mode, if a tag check fault occurs, the TFSR_EL1 register is updated asynchronously. The kernel checks the corresponding bits periodically. KASAN requires a specific kernel command line parameter to make use of this hw features. Add KASAN HW execution mode kernel command line parameter. Note: This patch adds the kasan.mode kernel parameter and the sync/async kernel command line options to enable the described features. Cc: Dmitry Vyukov <dvyukov@google.com> Cc: Andrey Ryabinin <aryabinin@virtuozzo.com> Cc: Alexander Potapenko <glider@google.com> Cc: Andrey Konovalov <andreyknvl@google.com> Signed-off-by: Vincenzo Frascino <vincenzo.frascino@arm.com> --- Documentation/dev-tools/kasan.rst | 3 +++ mm/kasan/hw_tags.c | 31 ++++++++++++++++++++++++++++++- mm/kasan/kasan.h | 3 ++- 3 files changed, 35 insertions(+), 2 deletions(-)