On 6/3/19 10:55 AM, Andrey Konovalov wrote:

To allow arm64 syscalls to accept tagged pointers from userspace, we must untag them when they are passed to the kernel. Since untagging is done in generic parts of the kernel, the untagged_addr macro needs to be defined for all architectures.

Define it as a noop for architectures other than arm64.

Acked-by: Catalin Marinas catalin.marinas@arm.com Reviewed-by: Khalid Aziz khalid.aziz@oracle.com Signed-off-by: Andrey Konovalov andreyknvl@google.com

---

include/linux/mm.h | 4 ++++ 1 file changed, 4 insertions(+)

diff --git a/include/linux/mm.h b/include/linux/mm.h index 0e8834ac32b7..949d43e9c0b6 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -99,6 +99,10 @@ extern int mmap_rnd_compat_bits __read_mostly; #include <asm/pgtable.h> #include <asm/processor.h> +#ifndef untagged_addr +#define untagged_addr(addr) (addr) +#endif

#ifndef __pa_symbol #define __pa_symbol(x) __pa(RELOC_HIDE((unsigned long)(x), 0)) #endif

Andrey,

This patch has now become part of the other patch series Chris Hellwig has sent out - https://lore.kernel.org/lkml/20190601074959.14036-1-hch@lst.de/. Can you coordinate with that patch series?

-- Khalid

On Mon, Jun 03, 2019 at 06:55:04PM +0200, Andrey Konovalov wrote:

diff --git a/arch/arm64/include/asm/uaccess.h b/arch/arm64/include/asm/uaccess.h index e5d5f31c6d36..9164ecb5feca 100644 --- a/arch/arm64/include/asm/uaccess.h +++ b/arch/arm64/include/asm/uaccess.h @@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si return ret; } -#define access_ok(addr, size) __range_ok(addr, size) +#define access_ok(addr, size) __range_ok(untagged_addr(addr), size)

I'm going to propose an opt-in method here (RFC for now). We can't have a check in untagged_addr() since this is already used throughout the kernel for both user and kernel addresses (khwasan) but we can add one in __range_ok(). The same prctl() option will be used for controlling the precise/imprecise mode of MTE later on. We can use a TIF_ flag here assuming that this will be called early on and any cloned thread will inherit this.

Anyway, it's easier to paste some diff than explain but Vincenzo can fold them into his ABI patches that should really go together with these. I added a couple of MTE definitions for prctl() as an example, not used currently:

------------------8<--------------------------------------------- diff --git a/arch/arm64/include/asm/processor.h b/arch/arm64/include/asm/processor.h index fcd0e691b1ea..2d4cb7e4edab 100644 --- a/arch/arm64/include/asm/processor.h +++ b/arch/arm64/include/asm/processor.h @@ -307,6 +307,10 @@ extern void __init minsigstksz_setup(void); /* PR_PAC_RESET_KEYS prctl */ #define PAC_RESET_KEYS(tsk, arg) ptrauth_prctl_reset_keys(tsk, arg)

+/* PR_UNTAGGED_UADDR prctl */ +int untagged_uaddr_set_mode(unsigned long arg); +#define SET_UNTAGGED_UADDR_MODE(arg) untagged_uaddr_set_mode(arg) + /* * For CONFIG_GCC_PLUGIN_STACKLEAK * diff --git a/arch/arm64/include/asm/thread_info.h b/arch/arm64/include/asm/thread_info.h index c285d1ce7186..89ce77773c49 100644 --- a/arch/arm64/include/asm/thread_info.h +++ b/arch/arm64/include/asm/thread_info.h @@ -101,6 +101,7 @@ void arch_release_task_struct(struct task_struct *tsk); #define TIF_SVE 23 /* Scalable Vector Extension in use */ #define TIF_SVE_VL_INHERIT 24 /* Inherit sve_vl_onexec across exec */ #define TIF_SSBD 25 /* Wants SSB mitigation */ +#define TIF_UNTAGGED_UADDR 26

#define _TIF_SIGPENDING (1 << TIF_SIGPENDING) #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) @@ -116,6 +117,7 @@ void arch_release_task_struct(struct task_struct *tsk); #define _TIF_FSCHECK (1 << TIF_FSCHECK) #define _TIF_32BIT (1 << TIF_32BIT) #define _TIF_SVE (1 << TIF_SVE) +#define _TIF_UNTAGGED_UADDR (1 << TIF_UNTAGGED_UADDR)

#define _TIF_WORK_MASK (_TIF_NEED_RESCHED | _TIF_SIGPENDING | \ _TIF_NOTIFY_RESUME | _TIF_FOREIGN_FPSTATE | \ diff --git a/arch/arm64/include/asm/uaccess.h b/arch/arm64/include/asm/uaccess.h index 9164ecb5feca..54f5bbaebbc4 100644 --- a/arch/arm64/include/asm/uaccess.h +++ b/arch/arm64/include/asm/uaccess.h @@ -73,6 +73,9 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si { unsigned long ret, limit = current_thread_info()->addr_limit;

+ if (test_thread_flag(TIF_UNTAGGED_UADDR)) + addr = untagged_addr(addr); + __chk_user_ptr(addr); asm volatile( // A + B <= C + 1 for all A,B,C, in four easy steps: @@ -94,7 +97,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si return ret; }

-#define access_ok(addr, size) __range_ok(untagged_addr(addr), size) +#define access_ok(addr, size) __range_ok(addr, size) #define user_addr_max get_fs

#define _ASM_EXTABLE(from, to) \ diff --git a/arch/arm64/kernel/process.c b/arch/arm64/kernel/process.c index 3767fb21a5b8..fd191c5b92aa 100644 --- a/arch/arm64/kernel/process.c +++ b/arch/arm64/kernel/process.c @@ -552,3 +552,18 @@ void arch_setup_new_exec(void)

ptrauth_thread_init_user(current); } + +/* + * Enable the relaxed ABI allowing tagged user addresses into the kernel. + */ +int untagged_uaddr_set_mode(unsigned long arg) +{ + if (is_compat_task()) + return -ENOTSUPP; + if (arg) + return -EINVAL; + + set_thread_flag(TIF_UNTAGGED_UADDR); + + return 0; +} diff --git a/include/uapi/linux/prctl.h b/include/uapi/linux/prctl.h index 094bb03b9cc2..4afd5e2980ee 100644 --- a/include/uapi/linux/prctl.h +++ b/include/uapi/linux/prctl.h @@ -229,4 +229,9 @@ struct prctl_mm_map { # define PR_PAC_APDBKEY (1UL << 3) # define PR_PAC_APGAKEY (1UL << 4)

+/* Untagged user addresses for arm64 */ +#define PR_UNTAGGED_UADDR 55 +# define PR_MTE_IMPRECISE_CHECK 0 +# define PR_MTE_PRECISE_CHECK 1 + #endif /* _LINUX_PRCTL_H */ diff --git a/kernel/sys.c b/kernel/sys.c index 2969304c29fe..b1f67a8cffc4 100644 --- a/kernel/sys.c +++ b/kernel/sys.c @@ -124,6 +124,9 @@ #ifndef PAC_RESET_KEYS # define PAC_RESET_KEYS(a, b) (-EINVAL) #endif +#ifndef SET_UNTAGGED_UADDR_MODE +# define SET_UNTAGGED_UADDR_MODE (-EINVAL) +#endif

/* * this is where the system-wide overflow UID and GID are defined, for @@ -2492,6 +2495,11 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, return -EINVAL; error = PAC_RESET_KEYS(me, arg2); break; + case PR_UNTAGGED_UADDR: + if (arg3 || arg4 || arg5) + return -EINVAL; + error = SET_UNTAGGED_UADDR_MODE(arg2); + break; default: error = -EINVAL; break; ------------------8<---------------------------------------------

The tag_ptr() function in the test library would become:

static void *tag_ptr(void *ptr) { static int tbi_enabled = 0; unsigned long tag = 0;

if (!tbi_enabled) { if (prctl(PR_UNTAGGED_UADDR, 0, 0, 0, 0) == 0) tbi_enabled = 1; }

if (!ptr) return ptr; if (tbi_enabled) tag = rand() & 0xff;

return (void *)((unsigned long)ptr | (tag << TAG_SHIFT)); }

On Mon, Jun 10, 2019 at 11:07:03AM -0700, Kees Cook wrote:

On Mon, Jun 10, 2019 at 06:53:27PM +0100, Catalin Marinas wrote:

...

On Mon, Jun 03, 2019 at 06:55:04PM +0200, Andrey Konovalov wrote:

...

diff --git a/arch/arm64/include/asm/uaccess.h b/arch/arm64/include/asm/uaccess.h index e5d5f31c6d36..9164ecb5feca 100644 --- a/arch/arm64/include/asm/uaccess.h +++ b/arch/arm64/include/asm/uaccess.h @@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si return ret; } -#define access_ok(addr, size) __range_ok(addr, size) +#define access_ok(addr, size) __range_ok(untagged_addr(addr), size)

[...]

...

diff --git a/arch/arm64/kernel/process.c b/arch/arm64/kernel/process.c index 3767fb21a5b8..fd191c5b92aa 100644 --- a/arch/arm64/kernel/process.c +++ b/arch/arm64/kernel/process.c @@ -552,3 +552,18 @@ void arch_setup_new_exec(void) ptrauth_thread_init_user(current); }

+/*

• • Enable the relaxed ABI allowing tagged user addresses into the kernel.
• */

+int untagged_uaddr_set_mode(unsigned long arg) +{

• if (is_compat_task())

• return -ENOTSUPP;
  

• if (arg)

• return -EINVAL;
  

• set_thread_flag(TIF_UNTAGGED_UADDR);
• return 0;

+}

I think this should be paired with a flag clearing in copy_thread(), yes? (i.e. each binary needs to opt in)

It indeed needs clearing though not in copy_thread() as that's used on clone/fork but rather in flush_thread(), called on the execve() path.

And a note to myself: I think PR_UNTAGGED_ADDR (not UADDR) looks better in a uapi header, the user doesn't differentiate between uaddr and kaddr.

On Mon, Jun 10, 2019 at 06:53:27PM +0100, Catalin Marinas wrote:

On Mon, Jun 03, 2019 at 06:55:04PM +0200, Andrey Konovalov wrote:

...

diff --git a/arch/arm64/include/asm/uaccess.h b/arch/arm64/include/asm/uaccess.h index e5d5f31c6d36..9164ecb5feca 100644 --- a/arch/arm64/include/asm/uaccess.h +++ b/arch/arm64/include/asm/uaccess.h @@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si return ret; } -#define access_ok(addr, size) __range_ok(addr, size) +#define access_ok(addr, size) __range_ok(untagged_addr(addr), size)

I'm going to propose an opt-in method here (RFC for now). We can't have a check in untagged_addr() since this is already used throughout the kernel for both user and kernel addresses (khwasan) but we can add one in __range_ok(). The same prctl() option will be used for controlling the precise/imprecise mode of MTE later on. We can use a TIF_ flag here assuming that this will be called early on and any cloned thread will inherit this.

Updated patch, inlining it below. Once we agreed on the approach, I think Andrey can insert in in this series, probably after patch 2. The differences from the one I posted yesterday:

- renamed PR_* macros together with get/set variants and the possibility to disable the relaxed ABI

- sysctl option - /proc/sys/abi/tagged_addr to disable the ABI globally (just the prctl() opt-in, tasks already using it won't be affected)

And, of course, it needs more testing.

---------8<----------------

From 7c624777a4e545522dec1b34e60f0229cb2bd59f Mon Sep 17 00:00:00 2001

From: Catalin Marinas catalin.marinas@arm.com Date: Tue, 11 Jun 2019 13:03:38 +0100 Subject: [PATCH] arm64: Introduce prctl() options to control the tagged user addresses ABI

It is not desirable to relax the ABI to allow tagged user addresses into the kernel indiscriminately. This patch introduces a prctl() interface for enabling or disabling the tagged ABI with a global sysctl control for preventing applications from enabling the relaxed ABI (meant for testing user-space prctl() return error checking without reconfiguring the kernel). The ABI properties are inherited by threads of the same application and fork()'ed children but cleared on execve().

The PR_SET_TAGGED_ADDR_CTRL will be expanded in the future to handle MTE-specific settings like imprecise vs precise exceptions.

Signed-off-by: Catalin Marinas catalin.marinas@arm.com --- arch/arm64/include/asm/processor.h | 6 +++ arch/arm64/include/asm/thread_info.h | 1 + arch/arm64/include/asm/uaccess.h | 5 ++- arch/arm64/kernel/process.c | 67 ++++++++++++++++++++++++++++ include/uapi/linux/prctl.h | 5 +++ kernel/sys.c | 16 +++++++ 6 files changed, 99 insertions(+), 1 deletion(-)

diff --git a/arch/arm64/include/asm/processor.h b/arch/arm64/include/asm/processor.h index fcd0e691b1ea..fee457456aa8 100644 --- a/arch/arm64/include/asm/processor.h +++ b/arch/arm64/include/asm/processor.h @@ -307,6 +307,12 @@ extern void __init minsigstksz_setup(void); /* PR_PAC_RESET_KEYS prctl */ #define PAC_RESET_KEYS(tsk, arg) ptrauth_prctl_reset_keys(tsk, arg)

+/* PR_TAGGED_ADDR prctl */ +long set_tagged_addr_ctrl(unsigned long arg); +long get_tagged_addr_ctrl(void); +#define SET_TAGGED_ADDR_CTRL(arg) set_tagged_addr_ctrl(arg) +#define GET_TAGGED_ADDR_CTRL() get_tagged_addr_ctrl() + /* * For CONFIG_GCC_PLUGIN_STACKLEAK * diff --git a/arch/arm64/include/asm/thread_info.h b/arch/arm64/include/asm/thread_info.h index c285d1ce7186..7263d4c973ce 100644 --- a/arch/arm64/include/asm/thread_info.h +++ b/arch/arm64/include/asm/thread_info.h @@ -101,6 +101,7 @@ void arch_release_task_struct(struct task_struct *tsk); #define TIF_SVE 23 /* Scalable Vector Extension in use */ #define TIF_SVE_VL_INHERIT 24 /* Inherit sve_vl_onexec across exec */ #define TIF_SSBD 25 /* Wants SSB mitigation */ +#define TIF_TAGGED_ADDR 26

#define _TIF_SIGPENDING (1 << TIF_SIGPENDING) #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) diff --git a/arch/arm64/include/asm/uaccess.h b/arch/arm64/include/asm/uaccess.h index 9164ecb5feca..995b9ea11a89 100644 --- a/arch/arm64/include/asm/uaccess.h +++ b/arch/arm64/include/asm/uaccess.h @@ -73,6 +73,9 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si { unsigned long ret, limit = current_thread_info()->addr_limit;

+ if (test_thread_flag(TIF_TAGGED_ADDR)) + addr = untagged_addr(addr); + __chk_user_ptr(addr); asm volatile( // A + B <= C + 1 for all A,B,C, in four easy steps: @@ -94,7 +97,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si return ret; }

-#define access_ok(addr, size) __range_ok(untagged_addr(addr), size) +#define access_ok(addr, size) __range_ok(addr, size) #define user_addr_max get_fs

#define _ASM_EXTABLE(from, to) \ diff --git a/arch/arm64/kernel/process.c b/arch/arm64/kernel/process.c index 3767fb21a5b8..69d0be1fc708 100644 --- a/arch/arm64/kernel/process.c +++ b/arch/arm64/kernel/process.c @@ -30,6 +30,7 @@ #include <linux/kernel.h> #include <linux/mm.h> #include <linux/stddef.h> +#include <linux/sysctl.h> #include <linux/unistd.h> #include <linux/user.h> #include <linux/delay.h> @@ -323,6 +324,7 @@ void flush_thread(void) fpsimd_flush_thread(); tls_thread_flush(); flush_ptrace_hw_breakpoint(current); + clear_thread_flag(TIF_TAGGED_ADDR); }

void release_thread(struct task_struct *dead_task) @@ -552,3 +554,68 @@ void arch_setup_new_exec(void)

ptrauth_thread_init_user(current); } + +/* + * Control the relaxed ABI allowing tagged user addresses into the kernel. + */ +static unsigned int tagged_addr_prctl_allowed = 1; + +long set_tagged_addr_ctrl(unsigned long arg) +{ + if (!tagged_addr_prctl_allowed) + return -EINVAL; + if (is_compat_task()) + return -EINVAL; + if (arg & ~PR_TAGGED_ADDR_ENABLE) + return -EINVAL; + + if (arg & PR_TAGGED_ADDR_ENABLE) + set_thread_flag(TIF_TAGGED_ADDR); + else + clear_thread_flag(TIF_TAGGED_ADDR); + + return 0; +} + +long get_tagged_addr_ctrl(void) +{ + if (!tagged_addr_prctl_allowed) + return -EINVAL; + if (is_compat_task()) + return -EINVAL; + + if (test_thread_flag(TIF_TAGGED_ADDR)) + return PR_TAGGED_ADDR_ENABLE; + + return 0; +} + +/* + * Global sysctl to disable the tagged user addresses support. This control + * only prevents the tagged address ABI enabling via prctl() and does not + * disable it for tasks that already opted in to the relaxed ABI. + */ +static int zero; +static int one = 1; + +static struct ctl_table tagged_addr_sysctl_table[] = { + { + .procname = "tagged_addr", + .mode = 0644, + .data = &tagged_addr_prctl_allowed, + .maxlen = sizeof(int), + .proc_handler = proc_dointvec_minmax, + .extra1 = &zero, + .extra2 = &one, + }, + { } +}; + +static int __init tagged_addr_init(void) +{ + if (!register_sysctl("abi", tagged_addr_sysctl_table)) + return -EINVAL; + return 0; +} + +core_initcall(tagged_addr_init); diff --git a/include/uapi/linux/prctl.h b/include/uapi/linux/prctl.h index 094bb03b9cc2..2e927b3e9d6c 100644 --- a/include/uapi/linux/prctl.h +++ b/include/uapi/linux/prctl.h @@ -229,4 +229,9 @@ struct prctl_mm_map { # define PR_PAC_APDBKEY (1UL << 3) # define PR_PAC_APGAKEY (1UL << 4)

+/* Tagged user address controls for arm64 */ +#define PR_SET_TAGGED_ADDR_CTRL 55 +#define PR_GET_TAGGED_ADDR_CTRL 56 +# define PR_TAGGED_ADDR_ENABLE (1UL << 0) + #endif /* _LINUX_PRCTL_H */ diff --git a/kernel/sys.c b/kernel/sys.c index 2969304c29fe..ec48396b4943 100644 --- a/kernel/sys.c +++ b/kernel/sys.c @@ -124,6 +124,12 @@ #ifndef PAC_RESET_KEYS # define PAC_RESET_KEYS(a, b) (-EINVAL) #endif +#ifndef SET_TAGGED_ADDR_CTRL +# define SET_TAGGED_ADDR_CTRL(a) (-EINVAL) +#endif +#ifndef GET_TAGGED_ADDR_CTRL +# define GET_TAGGED_ADDR_CTRL() (-EINVAL) +#endif

/* * this is where the system-wide overflow UID and GID are defined, for @@ -2492,6 +2498,16 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, return -EINVAL; error = PAC_RESET_KEYS(me, arg2); break; + case PR_SET_TAGGED_ADDR_CTRL: + if (arg3 || arg4 || arg5) + return -EINVAL; + error = SET_TAGGED_ADDR_CTRL(arg2); + break; + case PR_GET_TAGGED_ADDR_CTRL: + if (arg2 || arg3 || arg4 || arg5) + return -EINVAL; + error = GET_TAGGED_ADDR_CTRL(); + break; default: error = -EINVAL; break;

Hi Vincenzo,

On Tue, Jun 11, 2019 at 06:09:10PM +0100, Vincenzo Frascino wrote:

...

diff --git a/arch/arm64/kernel/process.c b/arch/arm64/kernel/process.c index 3767fb21a5b8..69d0be1fc708 100644 --- a/arch/arm64/kernel/process.c +++ b/arch/arm64/kernel/process.c @@ -30,6 +30,7 @@ #include <linux/kernel.h> #include <linux/mm.h> #include <linux/stddef.h> +#include <linux/sysctl.h> #include <linux/unistd.h> #include <linux/user.h> #include <linux/delay.h> @@ -323,6 +324,7 @@ void flush_thread(void) fpsimd_flush_thread(); tls_thread_flush(); flush_ptrace_hw_breakpoint(current);

• clear_thread_flag(TIF_TAGGED_ADDR);

Nit: in line we the other functions in thread_flush we could have something like "tagged_addr_thread_flush", maybe inlined.

The other functions do a lot more than clearing a TIF flag, so they deserved their own place. We could do this when adding MTE support. I think we also need to check what other TIF flags we may inadvertently pass on execve(), maybe have a mask clearing.

...

diff --git a/include/uapi/linux/prctl.h b/include/uapi/linux/prctl.h index 094bb03b9cc2..2e927b3e9d6c 100644 --- a/include/uapi/linux/prctl.h +++ b/include/uapi/linux/prctl.h @@ -229,4 +229,9 @@ struct prctl_mm_map { # define PR_PAC_APDBKEY (1UL << 3) # define PR_PAC_APGAKEY (1UL << 4) +/* Tagged user address controls for arm64 */ +#define PR_SET_TAGGED_ADDR_CTRL 55 +#define PR_GET_TAGGED_ADDR_CTRL 56 +# define PR_TAGGED_ADDR_ENABLE (1UL << 0)

#endif /* _LINUX_PRCTL_H */ diff --git a/kernel/sys.c b/kernel/sys.c index 2969304c29fe..ec48396b4943 100644 --- a/kernel/sys.c +++ b/kernel/sys.c @@ -124,6 +124,12 @@ #ifndef PAC_RESET_KEYS # define PAC_RESET_KEYS(a, b) (-EINVAL) #endif +#ifndef SET_TAGGED_ADDR_CTRL +# define SET_TAGGED_ADDR_CTRL(a) (-EINVAL) +#endif +#ifndef GET_TAGGED_ADDR_CTRL +# define GET_TAGGED_ADDR_CTRL() (-EINVAL) +#endif /*

• this is where the system-wide overflow UID and GID are defined, for

@@ -2492,6 +2498,16 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, return -EINVAL; error = PAC_RESET_KEYS(me, arg2); break;

• case PR_SET_TAGGED_ADDR_CTRL:

• if (arg3 || arg4 || arg5)
  

• 	return -EINVAL;
  

• error = SET_TAGGED_ADDR_CTRL(arg2);
  

• break;
  

• case PR_GET_TAGGED_ADDR_CTRL:

• if (arg2 || arg3 || arg4 || arg5)
  

• 	return -EINVAL;
  

• error = GET_TAGGED_ADDR_CTRL();
  

• break;
  

Why do we need two prctl here? We could have only one and use arg2 as set/get and arg3 as a parameter. What do you think?

This follows the other PR_* options, e.g. PR_SET_VL/GET_VL, PR_*_FP_MODE. We will use other bits in arg2, for example to set the precise vs imprecise MTE trapping.

On Tue, Jun 11, 2019 at 4:57 PM Catalin Marinas catalin.marinas@arm.com wrote:

On Mon, Jun 10, 2019 at 06:53:27PM +0100, Catalin Marinas wrote:

...

On Mon, Jun 03, 2019 at 06:55:04PM +0200, Andrey Konovalov wrote:

...

diff --git a/arch/arm64/include/asm/uaccess.h b/arch/arm64/include/asm/uaccess.h index e5d5f31c6d36..9164ecb5feca 100644 --- a/arch/arm64/include/asm/uaccess.h +++ b/arch/arm64/include/asm/uaccess.h @@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si return ret; }

-#define access_ok(addr, size) __range_ok(addr, size) +#define access_ok(addr, size) __range_ok(untagged_addr(addr), size)

I'm going to propose an opt-in method here (RFC for now). We can't have a check in untagged_addr() since this is already used throughout the kernel for both user and kernel addresses (khwasan) but we can add one in __range_ok(). The same prctl() option will be used for controlling the precise/imprecise mode of MTE later on. We can use a TIF_ flag here assuming that this will be called early on and any cloned thread will inherit this.

Updated patch, inlining it below. Once we agreed on the approach, I think Andrey can insert in in this series, probably after patch 2. The differences from the one I posted yesterday:

• renamed PR_* macros together with get/set variants and the possibility to disable the relaxed ABI

• sysctl option - /proc/sys/abi/tagged_addr to disable the ABI globally (just the prctl() opt-in, tasks already using it won't be affected)

And, of course, it needs more testing.

Sure, I'll add it to the series.

Should I drop access_ok() change from my patch, since yours just reverts it?

Thanks!

---------8<---------------- From 7c624777a4e545522dec1b34e60f0229cb2bd59f Mon Sep 17 00:00:00 2001 From: Catalin Marinas catalin.marinas@arm.com Date: Tue, 11 Jun 2019 13:03:38 +0100 Subject: [PATCH] arm64: Introduce prctl() options to control the tagged user addresses ABI

It is not desirable to relax the ABI to allow tagged user addresses into the kernel indiscriminately. This patch introduces a prctl() interface for enabling or disabling the tagged ABI with a global sysctl control for preventing applications from enabling the relaxed ABI (meant for testing user-space prctl() return error checking without reconfiguring the kernel). The ABI properties are inherited by threads of the same application and fork()'ed children but cleared on execve().

The PR_SET_TAGGED_ADDR_CTRL will be expanded in the future to handle MTE-specific settings like imprecise vs precise exceptions.

Signed-off-by: Catalin Marinas catalin.marinas@arm.com

arch/arm64/include/asm/processor.h | 6 +++ arch/arm64/include/asm/thread_info.h | 1 + arch/arm64/include/asm/uaccess.h | 5 ++- arch/arm64/kernel/process.c | 67 ++++++++++++++++++++++++++++ include/uapi/linux/prctl.h | 5 +++ kernel/sys.c | 16 +++++++ 6 files changed, 99 insertions(+), 1 deletion(-)

diff --git a/arch/arm64/include/asm/processor.h b/arch/arm64/include/asm/processor.h index fcd0e691b1ea..fee457456aa8 100644 --- a/arch/arm64/include/asm/processor.h +++ b/arch/arm64/include/asm/processor.h @@ -307,6 +307,12 @@ extern void __init minsigstksz_setup(void); /* PR_PAC_RESET_KEYS prctl */ #define PAC_RESET_KEYS(tsk, arg) ptrauth_prctl_reset_keys(tsk, arg)

+/* PR_TAGGED_ADDR prctl */ +long set_tagged_addr_ctrl(unsigned long arg); +long get_tagged_addr_ctrl(void); +#define SET_TAGGED_ADDR_CTRL(arg) set_tagged_addr_ctrl(arg) +#define GET_TAGGED_ADDR_CTRL() get_tagged_addr_ctrl()

/*

• For CONFIG_GCC_PLUGIN_STACKLEAK

diff --git a/arch/arm64/include/asm/thread_info.h b/arch/arm64/include/asm/thread_info.h index c285d1ce7186..7263d4c973ce 100644 --- a/arch/arm64/include/asm/thread_info.h +++ b/arch/arm64/include/asm/thread_info.h @@ -101,6 +101,7 @@ void arch_release_task_struct(struct task_struct *tsk); #define TIF_SVE 23 /* Scalable Vector Extension in use */ #define TIF_SVE_VL_INHERIT 24 /* Inherit sve_vl_onexec across exec */ #define TIF_SSBD 25 /* Wants SSB mitigation */ +#define TIF_TAGGED_ADDR 26

#define _TIF_SIGPENDING (1 << TIF_SIGPENDING) #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) diff --git a/arch/arm64/include/asm/uaccess.h b/arch/arm64/include/asm/uaccess.h index 9164ecb5feca..995b9ea11a89 100644 --- a/arch/arm64/include/asm/uaccess.h +++ b/arch/arm64/include/asm/uaccess.h @@ -73,6 +73,9 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si { unsigned long ret, limit = current_thread_info()->addr_limit;

•   if (test_thread_flag(TIF_TAGGED_ADDR))
  

•           addr = untagged_addr(addr);
  

•   __chk_user_ptr(addr);
    asm volatile(
    // A + B <= C + 1 for all A,B,C, in four easy steps:
  

@@ -94,7 +97,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si return ret; }

-#define access_ok(addr, size) __range_ok(untagged_addr(addr), size) +#define access_ok(addr, size) __range_ok(addr, size) #define user_addr_max get_fs

#define _ASM_EXTABLE(from, to) \ diff --git a/arch/arm64/kernel/process.c b/arch/arm64/kernel/process.c index 3767fb21a5b8..69d0be1fc708 100644 --- a/arch/arm64/kernel/process.c +++ b/arch/arm64/kernel/process.c @@ -30,6 +30,7 @@ #include <linux/kernel.h> #include <linux/mm.h> #include <linux/stddef.h> +#include <linux/sysctl.h> #include <linux/unistd.h> #include <linux/user.h> #include <linux/delay.h> @@ -323,6 +324,7 @@ void flush_thread(void) fpsimd_flush_thread(); tls_thread_flush(); flush_ptrace_hw_breakpoint(current);

•   clear_thread_flag(TIF_TAGGED_ADDR);
  

}

void release_thread(struct task_struct *dead_task) @@ -552,3 +554,68 @@ void arch_setup_new_exec(void)

    ptrauth_thread_init_user(current);

}

+/*

• • Control the relaxed ABI allowing tagged user addresses into the kernel.
• */

+static unsigned int tagged_addr_prctl_allowed = 1;

+long set_tagged_addr_ctrl(unsigned long arg) +{

•   if (!tagged_addr_prctl_allowed)
  

•           return -EINVAL;
  

•   if (is_compat_task())
  

•           return -EINVAL;
  

•   if (arg & ~PR_TAGGED_ADDR_ENABLE)
  

•           return -EINVAL;
  

•   if (arg & PR_TAGGED_ADDR_ENABLE)
  

•           set_thread_flag(TIF_TAGGED_ADDR);
  

•   else
  

•           clear_thread_flag(TIF_TAGGED_ADDR);
  

•   return 0;
  

+}

+long get_tagged_addr_ctrl(void) +{

•   if (!tagged_addr_prctl_allowed)
  

•           return -EINVAL;
  

•   if (is_compat_task())
  

•           return -EINVAL;
  

•   if (test_thread_flag(TIF_TAGGED_ADDR))
  

•           return PR_TAGGED_ADDR_ENABLE;
  

•   return 0;
  

+}

+/*

• • Global sysctl to disable the tagged user addresses support. This control
• • only prevents the tagged address ABI enabling via prctl() and does not
• • disable it for tasks that already opted in to the relaxed ABI.
• */

+static int zero; +static int one = 1;

+static struct ctl_table tagged_addr_sysctl_table[] = {

•   {
  

•           .procname       = "tagged_addr",
  

•           .mode           = 0644,
  

•           .data           = &tagged_addr_prctl_allowed,
  

•           .maxlen         = sizeof(int),
  

•           .proc_handler   = proc_dointvec_minmax,
  

•           .extra1         = &zero,
  

•           .extra2         = &one,
  

•   },
  

•   { }
  

+};

+static int __init tagged_addr_init(void) +{

•   if (!register_sysctl("abi", tagged_addr_sysctl_table))
  

•           return -EINVAL;
  

•   return 0;
  

+}

+core_initcall(tagged_addr_init); diff --git a/include/uapi/linux/prctl.h b/include/uapi/linux/prctl.h index 094bb03b9cc2..2e927b3e9d6c 100644 --- a/include/uapi/linux/prctl.h +++ b/include/uapi/linux/prctl.h @@ -229,4 +229,9 @@ struct prctl_mm_map { # define PR_PAC_APDBKEY (1UL << 3) # define PR_PAC_APGAKEY (1UL << 4)

+/* Tagged user address controls for arm64 */ +#define PR_SET_TAGGED_ADDR_CTRL 55 +#define PR_GET_TAGGED_ADDR_CTRL 56 +# define PR_TAGGED_ADDR_ENABLE (1UL << 0)

#endif /* _LINUX_PRCTL_H */ diff --git a/kernel/sys.c b/kernel/sys.c index 2969304c29fe..ec48396b4943 100644 --- a/kernel/sys.c +++ b/kernel/sys.c @@ -124,6 +124,12 @@ #ifndef PAC_RESET_KEYS # define PAC_RESET_KEYS(a, b) (-EINVAL) #endif +#ifndef SET_TAGGED_ADDR_CTRL +# define SET_TAGGED_ADDR_CTRL(a) (-EINVAL) +#endif +#ifndef GET_TAGGED_ADDR_CTRL +# define GET_TAGGED_ADDR_CTRL() (-EINVAL) +#endif

/*

• this is where the system-wide overflow UID and GID are defined, for

@@ -2492,6 +2498,16 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, return -EINVAL; error = PAC_RESET_KEYS(me, arg2); break;

•   case PR_SET_TAGGED_ADDR_CTRL:
  

•           if (arg3 || arg4 || arg5)
  

•                   return -EINVAL;
  

•           error = SET_TAGGED_ADDR_CTRL(arg2);
  

•           break;
  

•   case PR_GET_TAGGED_ADDR_CTRL:
  

•           if (arg2 || arg3 || arg4 || arg5)
  

•                   return -EINVAL;
  

•           error = GET_TAGGED_ADDR_CTRL();
  

•           break;
    default:
            error = -EINVAL;
            break;
  

On Tue, Jun 11, 2019 at 7:39 PM Catalin Marinas catalin.marinas@arm.com wrote:

On Tue, Jun 11, 2019 at 07:09:46PM +0200, Andrey Konovalov wrote:

...

On Tue, Jun 11, 2019 at 4:57 PM Catalin Marinas catalin.marinas@arm.com wrote:

...

On Mon, Jun 10, 2019 at 06:53:27PM +0100, Catalin Marinas wrote:

...

On Mon, Jun 03, 2019 at 06:55:04PM +0200, Andrey Konovalov wrote:

...

diff --git a/arch/arm64/include/asm/uaccess.h b/arch/arm64/include/asm/uaccess.h index e5d5f31c6d36..9164ecb5feca 100644 --- a/arch/arm64/include/asm/uaccess.h +++ b/arch/arm64/include/asm/uaccess.h @@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si return ret; }

-#define access_ok(addr, size) __range_ok(addr, size) +#define access_ok(addr, size) __range_ok(untagged_addr(addr), size)

I'm going to propose an opt-in method here (RFC for now). We can't have a check in untagged_addr() since this is already used throughout the kernel for both user and kernel addresses (khwasan) but we can add one in __range_ok(). The same prctl() option will be used for controlling the precise/imprecise mode of MTE later on. We can use a TIF_ flag here assuming that this will be called early on and any cloned thread will inherit this.

Updated patch, inlining it below. Once we agreed on the approach, I think Andrey can insert in in this series, probably after patch 2. The differences from the one I posted yesterday:

• renamed PR_* macros together with get/set variants and the possibility to disable the relaxed ABI

• sysctl option - /proc/sys/abi/tagged_addr to disable the ABI globally (just the prctl() opt-in, tasks already using it won't be affected)

And, of course, it needs more testing.

Sure, I'll add it to the series.

Should I drop access_ok() change from my patch, since yours just reverts it?

Not necessary, your patch just relaxes the ABI for all apps, mine tightens it. You could instead move the untagging to __range_ok() and rebase my patch accordingly.

OK, will do. I'll also add a comment next to TIF_TAGGED_ADDR as Vincenzo asked.

-- Catalin

On 6/3/19 10:55 AM, Andrey Konovalov wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

strncpy_from_user and strnlen_user accept user addresses as arguments, and do not go through the same path as copy_from_user and others, so here we need to handle the case of tagged user addresses separately.

Untag user pointers passed to these functions.

Note, that this patch only temporarily untags the pointers to perform validity checks, but then uses them as is to perform user memory accesses.

Reviewed-by: Catalin Marinas catalin.marinas@arm.com Signed-off-by: Andrey Konovalov andreyknvl@google.com

---

lib/strncpy_from_user.c | 3 ++- lib/strnlen_user.c | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-)

Looks good.

Reviewed-by: Khalid Aziz khalid.aziz@oracle.com

diff --git a/lib/strncpy_from_user.c b/lib/strncpy_from_user.c index 023ba9f3b99f..dccb95af6003 100644 --- a/lib/strncpy_from_user.c +++ b/lib/strncpy_from_user.c @@ -6,6 +6,7 @@ #include <linux/uaccess.h> #include <linux/kernel.h> #include <linux/errno.h> +#include <linux/mm.h> #include <asm/byteorder.h> #include <asm/word-at-a-time.h> @@ -108,7 +109,7 @@ long strncpy_from_user(char *dst, const char __user *src, long count) return 0; max_addr = user_addr_max();

• src_addr = (unsigned long)src;

• src_addr = (unsigned long)untagged_addr(src); if (likely(src_addr < max_addr)) { unsigned long max = max_addr - src_addr; long retval;

diff --git a/lib/strnlen_user.c b/lib/strnlen_user.c index 7f2db3fe311f..28ff554a1be8 100644 --- a/lib/strnlen_user.c +++ b/lib/strnlen_user.c @@ -2,6 +2,7 @@ #include <linux/kernel.h> #include <linux/export.h> #include <linux/uaccess.h> +#include <linux/mm.h> #include <asm/word-at-a-time.h> @@ -109,7 +110,7 @@ long strnlen_user(const char __user *str, long count) return 0; max_addr = user_addr_max();

• src_addr = (unsigned long)str;

• src_addr = (unsigned long)untagged_addr(str); if (likely(src_addr < max_addr)) { unsigned long max = max_addr - src_addr; long retval;

On Mon, Jun 03, 2019 at 06:55:06PM +0200, Andrey Konovalov wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

do_pages_move() is used in the implementation of the move_pages syscall.

Untag user pointers in this function.

Reviewed-by: Catalin Marinas catalin.marinas@arm.com Signed-off-by: Andrey Konovalov andreyknvl@google.com

Reviewed-by: Kees Cook keescook@chromium.org

-Kees

---

mm/migrate.c | 1 + 1 file changed, 1 insertion(+)

diff --git a/mm/migrate.c b/mm/migrate.c index f2ecc2855a12..3930bb6fa656 100644 --- a/mm/migrate.c +++ b/mm/migrate.c @@ -1617,6 +1617,7 @@ static int do_pages_move(struct mm_struct *mm, nodemask_t task_nodes, if (get_user(node, nodes + i)) goto out_flush; addr = (unsigned long)p;

• addr = untagged_addr(addr);
  

err = -ENODEV; if (node < 0 || node >= MAX_NUMNODES) -- 2.22.0.rc1.311.g5d7573a151-goog

On Tue, Jun 11, 2019 at 10:18 PM Khalid Aziz khalid.aziz@oracle.com wrote:

On 6/3/19 10:55 AM, Andrey Konovalov wrote:

...

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

do_pages_move() is used in the implementation of the move_pages syscall.

Untag user pointers in this function.

Reviewed-by: Catalin Marinas catalin.marinas@arm.com Signed-off-by: Andrey Konovalov andreyknvl@google.com

---

mm/migrate.c | 1 + 1 file changed, 1 insertion(+)

diff --git a/mm/migrate.c b/mm/migrate.c index f2ecc2855a12..3930bb6fa656 100644 --- a/mm/migrate.c +++ b/mm/migrate.c @@ -1617,6 +1617,7 @@ static int do_pages_move(struct mm_struct *mm, nodemask_t task_nodes, if (get_user(node, nodes + i)) goto out_flush; addr = (unsigned long)p;

•         addr = untagged_addr(addr);
  

Why not just "addr = (unsigned long)untagged_addr(p);"

Will do in the next version. I think I'll also merge this commit into the "untag user pointers passed to memory syscalls" one.

-- Khalid

On Mon, Jun 03, 2019 at 06:55:07PM +0200, Andrey Konovalov wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

This patch allows tagged pointers to be passed to the following memory syscalls: get_mempolicy, madvise, mbind, mincore, mlock, mlock2, mprotect, mremap, msync, munlock.

Signed-off-by: Andrey Konovalov andreyknvl@google.com

Reviewed-by: Kees Cook keescook@chromium.org

-Kees

---

mm/madvise.c | 2 ++ mm/mempolicy.c | 3 +++ mm/mincore.c | 2 ++ mm/mlock.c | 4 ++++ mm/mprotect.c | 2 ++ mm/mremap.c | 2 ++ mm/msync.c | 2 ++ 7 files changed, 17 insertions(+)

diff --git a/mm/madvise.c b/mm/madvise.c index 628022e674a7..39b82f8a698f 100644 --- a/mm/madvise.c +++ b/mm/madvise.c @@ -810,6 +810,8 @@ SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior) size_t len; struct blk_plug plug;

• start = untagged_addr(start);
• if (!madvise_behavior_valid(behavior)) return error;

diff --git a/mm/mempolicy.c b/mm/mempolicy.c index 01600d80ae01..78e0a88b2680 100644 --- a/mm/mempolicy.c +++ b/mm/mempolicy.c @@ -1360,6 +1360,7 @@ static long kernel_mbind(unsigned long start, unsigned long len, int err; unsigned short mode_flags;

• start = untagged_addr(start); mode_flags = mode & MPOL_MODE_FLAGS; mode &= ~MPOL_MODE_FLAGS; if (mode >= MPOL_MAX)

@@ -1517,6 +1518,8 @@ static int kernel_get_mempolicy(int __user *policy, int uninitialized_var(pval); nodemask_t nodes;

• addr = untagged_addr(addr);
• if (nmask != NULL && maxnode < nr_node_ids) return -EINVAL;

diff --git a/mm/mincore.c b/mm/mincore.c index c3f058bd0faf..64c322ed845c 100644 --- a/mm/mincore.c +++ b/mm/mincore.c @@ -249,6 +249,8 @@ SYSCALL_DEFINE3(mincore, unsigned long, start, size_t, len, unsigned long pages; unsigned char *tmp;

• start = untagged_addr(start);
• /* Check the start address: needs to be page-aligned.. */ if (start & ~PAGE_MASK) return -EINVAL;

diff --git a/mm/mlock.c b/mm/mlock.c index 080f3b36415b..e82609eaa428 100644 --- a/mm/mlock.c +++ b/mm/mlock.c @@ -674,6 +674,8 @@ static __must_check int do_mlock(unsigned long start, size_t len, vm_flags_t fla unsigned long lock_limit; int error = -ENOMEM;

• start = untagged_addr(start);
• if (!can_do_mlock()) return -EPERM;

@@ -735,6 +737,8 @@ SYSCALL_DEFINE2(munlock, unsigned long, start, size_t, len) { int ret;

• start = untagged_addr(start);
• len = PAGE_ALIGN(len + (offset_in_page(start))); start &= PAGE_MASK;

diff --git a/mm/mprotect.c b/mm/mprotect.c index bf38dfbbb4b4..19f981b733bc 100644 --- a/mm/mprotect.c +++ b/mm/mprotect.c @@ -465,6 +465,8 @@ static int do_mprotect_pkey(unsigned long start, size_t len, const bool rier = (current->personality & READ_IMPLIES_EXEC) && (prot & PROT_READ);

• start = untagged_addr(start);
• prot &= ~(PROT_GROWSDOWN|PROT_GROWSUP); if (grows == (PROT_GROWSDOWN|PROT_GROWSUP)) /* can't be both */ return -EINVAL;

diff --git a/mm/mremap.c b/mm/mremap.c index fc241d23cd97..1d98281f7204 100644 --- a/mm/mremap.c +++ b/mm/mremap.c @@ -606,6 +606,8 @@ SYSCALL_DEFINE5(mremap, unsigned long, addr, unsigned long, old_len, LIST_HEAD(uf_unmap_early); LIST_HEAD(uf_unmap);

• addr = untagged_addr(addr);
• if (flags & ~(MREMAP_FIXED | MREMAP_MAYMOVE)) return ret;

diff --git a/mm/msync.c b/mm/msync.c index ef30a429623a..c3bd3e75f687 100644 --- a/mm/msync.c +++ b/mm/msync.c @@ -37,6 +37,8 @@ SYSCALL_DEFINE3(msync, unsigned long, start, size_t, len, int, flags) int unmapped_error = 0; int error = -EINVAL;

• start = untagged_addr(start);
• if (flags & ~(MS_ASYNC | MS_INVALIDATE | MS_SYNC)) goto out; if (offset_in_page(start))

-- 2.22.0.rc1.311.g5d7573a151-goog

On Mon, Jun 03, 2019 at 06:55:08PM +0200, Andrey Konovalov wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

mm/gup.c provides a kernel interface that accepts user addresses and manipulates user pages directly (for example get_user_pages, that is used by the futex syscall). Since a user can provided tagged addresses, we need to handle this case.

Add untagging to gup.c functions that use user addresses for vma lookups.

Reviewed-by: Catalin Marinas catalin.marinas@arm.com Signed-off-by: Andrey Konovalov andreyknvl@google.com

Reviewed-by: Kees Cook keescook@chromium.org

-Kees

---

mm/gup.c | 4 ++++ 1 file changed, 4 insertions(+)

diff --git a/mm/gup.c b/mm/gup.c index ddde097cf9e4..c37df3d455a2 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -802,6 +802,8 @@ static long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm, if (!nr_pages) return 0;

• start = untagged_addr(start);
• VM_BUG_ON(!!pages != !!(gup_flags & FOLL_GET));

/* @@ -964,6 +966,8 @@ int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm, struct vm_area_struct *vma; vm_fault_t ret, major = 0;

• address = untagged_addr(address);
• if (unlocked) fault_flags |= FAULT_FLAG_ALLOW_RETRY;

2.22.0.rc1.311.g5d7573a151-goog

On Mon, Jun 03, 2019 at 06:55:09PM +0200, Andrey Konovalov wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

get_vaddr_frames uses provided user pointers for vma lookups, which can only by done with untagged pointers. Instead of locating and changing all callers of this function, perform untagging in it.

Signed-off-by: Andrey Konovalov andreyknvl@google.com

Reviewed-by: Kees Cook keescook@chromium.org

-Kees

---

mm/frame_vector.c | 2 ++ 1 file changed, 2 insertions(+)

diff --git a/mm/frame_vector.c b/mm/frame_vector.c index c64dca6e27c2..c431ca81dad5 100644 --- a/mm/frame_vector.c +++ b/mm/frame_vector.c @@ -46,6 +46,8 @@ int get_vaddr_frames(unsigned long start, unsigned int nr_frames, if (WARN_ON_ONCE(nr_frames > vec->nr_allocated)) nr_frames = vec->nr_allocated;

• start = untagged_addr(start);
• down_read(&mm->mmap_sem); locked = 1; vma = find_vma_intersection(mm, start, start + 1);

-- 2.22.0.rc1.311.g5d7573a151-goog

On Sat, Jun 8, 2019 at 6:02 AM Kees Cook keescook@chromium.org wrote:

On Mon, Jun 03, 2019 at 06:55:10PM +0200, Andrey Konovalov wrote:

...

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

In copy_mount_options a user address is being subtracted from TASK_SIZE. If the address is lower than TASK_SIZE, the size is calculated to not allow the exact_copy_from_user() call to cross TASK_SIZE boundary. However if the address is tagged, then the size will be calculated incorrectly.

Untag the address before subtracting.

Reviewed-by: Catalin Marinas catalin.marinas@arm.com Signed-off-by: Andrey Konovalov andreyknvl@google.com

One thing I just noticed in the commit titles... "arm64" is in the prefix, but these are arch-indep areas. Should the ", arm64" be left out?

I would expect, instead:

    fs/namespace: untag user pointers in copy_mount_options

Hm, I've added the arm64 tag in all of the patches because they are related to changes in arm64 kernel ABI. I can remove it from all the patches that only touch common code if you think that it makes sense.

Thanks!

Reviewed-by: Kees Cook keescook@chromium.org

-Kees

...

---

fs/namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/namespace.c b/fs/namespace.c index b26778bdc236..2e85712a19ed 100644 --- a/fs/namespace.c +++ b/fs/namespace.c @@ -2993,7 +2993,7 @@ void *copy_mount_options(const void __user * data) * the remainder of the page. */ /* copy_from_user cannot cross TASK_SIZE ! */

• size = TASK_SIZE - (unsigned long)data;
  

• size = TASK_SIZE - (unsigned long)untagged_addr(data);
  if (size > PAGE_SIZE)
          size = PAGE_SIZE;
  
  

-- 2.22.0.rc1.311.g5d7573a151-goog

-- Kees Cook

On Mon, Jun 03, 2019 at 06:55:14PM +0200, Andrey Konovalov wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

ib_uverbs_(re)reg_mr() use provided user pointers for vma lookups (through e.g. mlx4_get_umem_mr()), which can only by done with untagged pointers.

Untag user pointers in these functions.

Signed-off-by: Andrey Konovalov andreyknvl@google.com drivers/infiniband/core/uverbs_cmd.c | 4 ++++ 1 file changed, 4 insertions(+)

diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c index 5a3a1780ceea..f88ee733e617 100644 +++ b/drivers/infiniband/core/uverbs_cmd.c @@ -709,6 +709,8 @@ static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) if (ret) return ret;

• cmd.start = untagged_addr(cmd.start);
• if ((cmd.start & ~PAGE_MASK) != (cmd.hca_va & ~PAGE_MASK)) return -EINVAL;

I feel like we shouldn't thave to do this here, surely the cmd.start should flow unmodified to get_user_pages, and gup should untag it?

ie, this sort of direction for the IB code (this would be a giant patch, so I didn't have time to write it all, but I think it is much saner):

diff --git a/drivers/infiniband/core/umem.c b/drivers/infiniband/core/umem.c index 54628ef879f0ce..7b3b736c87c253 100644 --- a/drivers/infiniband/core/umem.c +++ b/drivers/infiniband/core/umem.c @@ -193,7 +193,7 @@ EXPORT_SYMBOL(ib_umem_find_best_pgsz); * @access: IB_ACCESS_xxx flags for memory being pinned * @dmasync: flush in-flight DMA when the memory region is written */ -struct ib_umem *ib_umem_get(struct ib_udata *udata, unsigned long addr, +struct ib_umem *ib_umem_get(struct ib_udata *udata, void __user *addr, size_t size, int access, int dmasync) { struct ib_ucontext *context; @@ -201,7 +201,7 @@ struct ib_umem *ib_umem_get(struct ib_udata *udata, unsigned long addr, struct page **page_list; unsigned long lock_limit; unsigned long new_pinned; - unsigned long cur_base; + void __user *cur_base; struct mm_struct *mm; unsigned long npages; int ret; diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c index 5a3a1780ceea4d..94389e7f12371f 100644 --- a/drivers/infiniband/core/uverbs_cmd.c +++ b/drivers/infiniband/core/uverbs_cmd.c @@ -735,7 +735,8 @@ static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) } }

- mr = pd->device->ops.reg_user_mr(pd, cmd.start, cmd.length, cmd.hca_va, + mr = pd->device->ops.reg_user_mr(pd, u64_to_user_ptr(cmd.start), + cmd.length, cmd.hca_va, cmd.access_flags, &attrs->driver_udata); if (IS_ERR(mr)) { diff --git a/drivers/infiniband/hw/mlx5/mr.c b/drivers/infiniband/hw/mlx5/mr.c index 4d033796dcfcc2..bddbb952082fc5 100644 --- a/drivers/infiniband/hw/mlx5/mr.c +++ b/drivers/infiniband/hw/mlx5/mr.c @@ -786,7 +786,7 @@ static int mr_cache_max_order(struct mlx5_ib_dev *dev) }

static int mr_umem_get(struct mlx5_ib_dev *dev, struct ib_udata *udata, - u64 start, u64 length, int access_flags, + void __user *start, u64 length, int access_flags, struct ib_umem **umem, int *npages, int *page_shift, int *ncont, int *order) { @@ -1262,8 +1262,8 @@ struct ib_mr *mlx5_ib_reg_dm_mr(struct ib_pd *pd, struct ib_dm *dm, attr->access_flags, mode); }

-struct ib_mr *mlx5_ib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length, - u64 virt_addr, int access_flags, +struct ib_mr *mlx5_ib_reg_user_mr(struct ib_pd *pd, void __user *start, + u64 length, u64 virt_addr, int access_flags, struct ib_udata *udata) { struct mlx5_ib_dev *dev = to_mdev(pd->device); diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h index ec6446864b08e9..b3c8eaaa35c760 100644 --- a/include/rdma/ib_verbs.h +++ b/include/rdma/ib_verbs.h @@ -2464,8 +2464,8 @@ struct ib_device_ops { struct ib_mr *(*reg_user_mr)(struct ib_pd *pd, u64 start, u64 length, u64 virt_addr, int mr_access_flags, struct ib_udata *udata); - int (*rereg_user_mr)(struct ib_mr *mr, int flags, u64 start, u64 length, - u64 virt_addr, int mr_access_flags, + int (*rereg_user_mr)(struct ib_mr *mr, int flags, void __user *start, + u64 length, u64 virt_addr, int mr_access_flags, struct ib_pd *pd, struct ib_udata *udata); int (*dereg_mr)(struct ib_mr *mr, struct ib_udata *udata); struct ib_mr *(*alloc_mr)(struct ib_pd *pd, enum ib_mr_type mr_type,

On Tue, Jun 04, 2019 at 02:18:19PM +0200, Andrey Konovalov wrote:

On Mon, Jun 3, 2019 at 7:46 PM Jason Gunthorpe jgg@ziepe.ca wrote:

...

On Mon, Jun 03, 2019 at 06:55:14PM +0200, Andrey Konovalov wrote:

...

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

ib_uverbs_(re)reg_mr() use provided user pointers for vma lookups (through e.g. mlx4_get_umem_mr()), which can only by done with untagged pointers.

Untag user pointers in these functions.

Signed-off-by: Andrey Konovalov andreyknvl@google.com drivers/infiniband/core/uverbs_cmd.c | 4 ++++ 1 file changed, 4 insertions(+)

diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c index 5a3a1780ceea..f88ee733e617 100644 +++ b/drivers/infiniband/core/uverbs_cmd.c @@ -709,6 +709,8 @@ static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) if (ret) return ret;

• cmd.start = untagged_addr(cmd.start);
  

• if ((cmd.start & ~PAGE_MASK) != (cmd.hca_va & ~PAGE_MASK))
          return -EINVAL;
  

I feel like we shouldn't thave to do this here, surely the cmd.start should flow unmodified to get_user_pages, and gup should untag it?

ie, this sort of direction for the IB code (this would be a giant patch, so I didn't have time to write it all, but I think it is much saner):

Hi Jason,

ib_uverbs_reg_mr() passes cmd.start to mlx4_get_umem_mr(), which calls find_vma(), which only accepts untagged addresses. Could you explain how your patch helps?

That mlx4 is just a 'weird duck', it is not the normal flow, and I don't think the core code should be making special consideration for it.

Jason

On Tue, Jun 04, 2019 at 02:45:32PM +0200, Andrey Konovalov wrote:

On Tue, Jun 4, 2019 at 2:27 PM Jason Gunthorpe jgg@ziepe.ca wrote:

...

On Tue, Jun 04, 2019 at 02:18:19PM +0200, Andrey Konovalov wrote:

...

On Mon, Jun 3, 2019 at 7:46 PM Jason Gunthorpe jgg@ziepe.ca wrote:

...

On Mon, Jun 03, 2019 at 06:55:14PM +0200, Andrey Konovalov wrote:

...

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

ib_uverbs_(re)reg_mr() use provided user pointers for vma lookups (through e.g. mlx4_get_umem_mr()), which can only by done with untagged pointers.

Untag user pointers in these functions.

Signed-off-by: Andrey Konovalov andreyknvl@google.com drivers/infiniband/core/uverbs_cmd.c | 4 ++++ 1 file changed, 4 insertions(+)

diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c index 5a3a1780ceea..f88ee733e617 100644 +++ b/drivers/infiniband/core/uverbs_cmd.c @@ -709,6 +709,8 @@ static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) if (ret) return ret;

• cmd.start = untagged_addr(cmd.start);
  

• if ((cmd.start & ~PAGE_MASK) != (cmd.hca_va & ~PAGE_MASK))
          return -EINVAL;
  

I feel like we shouldn't thave to do this here, surely the cmd.start should flow unmodified to get_user_pages, and gup should untag it?

ie, this sort of direction for the IB code (this would be a giant patch, so I didn't have time to write it all, but I think it is much saner):

Hi Jason,

ib_uverbs_reg_mr() passes cmd.start to mlx4_get_umem_mr(), which calls find_vma(), which only accepts untagged addresses. Could you explain how your patch helps?

That mlx4 is just a 'weird duck', it is not the normal flow, and I don't think the core code should be making special consideration for it.

How do you think we should do untagging (or something else) to deal with this 'weird duck' case?

mlx4 should handle it around the call to find_vma like other patches do, ideally as part of the cast from a void __user * to the unsigned long that find_vma needs

Jason

On Tue, Jun 04, 2019 at 03:09:26PM +0200, Andrey Konovalov wrote:

On Tue, Jun 4, 2019 at 3:02 PM Jason Gunthorpe jgg@ziepe.ca wrote:

...

On Tue, Jun 04, 2019 at 02:45:32PM +0200, Andrey Konovalov wrote:

...

On Tue, Jun 4, 2019 at 2:27 PM Jason Gunthorpe jgg@ziepe.ca wrote:

...

On Tue, Jun 04, 2019 at 02:18:19PM +0200, Andrey Konovalov wrote:

...

On Mon, Jun 3, 2019 at 7:46 PM Jason Gunthorpe jgg@ziepe.ca wrote:

...

On Mon, Jun 03, 2019 at 06:55:14PM +0200, Andrey Konovalov wrote: > This patch is a part of a series that extends arm64 kernel ABI to allow to > pass tagged user pointers (with the top byte set to something else other > than 0x00) as syscall arguments. > > ib_uverbs_(re)reg_mr() use provided user pointers for vma lookups (through > e.g. mlx4_get_umem_mr()), which can only by done with untagged pointers. > > Untag user pointers in these functions. > > Signed-off-by: Andrey Konovalov andreyknvl@google.com > drivers/infiniband/core/uverbs_cmd.c | 4 ++++ > 1 file changed, 4 insertions(+) > > diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c > index 5a3a1780ceea..f88ee733e617 100644 > +++ b/drivers/infiniband/core/uverbs_cmd.c > @@ -709,6 +709,8 @@ static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) > if (ret) > return ret; > > + cmd.start = untagged_addr(cmd.start); > + > if ((cmd.start & ~PAGE_MASK) != (cmd.hca_va & ~PAGE_MASK)) > return -EINVAL;

I feel like we shouldn't thave to do this here, surely the cmd.start should flow unmodified to get_user_pages, and gup should untag it?

ie, this sort of direction for the IB code (this would be a giant patch, so I didn't have time to write it all, but I think it is much saner):

ib_uverbs_reg_mr() passes cmd.start to mlx4_get_umem_mr(), which calls find_vma(), which only accepts untagged addresses. Could you explain how your patch helps?

That mlx4 is just a 'weird duck', it is not the normal flow, and I don't think the core code should be making special consideration for it.

How do you think we should do untagging (or something else) to deal with this 'weird duck' case?

mlx4 should handle it around the call to find_vma like other patches do, ideally as part of the cast from a void __user * to the unsigned long that find_vma needs

So essentially what we had a few versions ago (https://lkml.org/lkml/2019/4/30/785) plus changing unsigned longs to __user * across all IB code? I think the second part is something that's not related to this series and needs to be done separately. I can move untagging back to mlx4_get_umem_mr() though.

Catalin, you've initially asked to to move untagging out of mlx4_get_umem_mr(), do you have any comments on this?

It's fine by me either way. My original reasoning was to untag this at the higher level as tags may not be relevant to the mlx4 code. If that's what Jason prefers, go for it.

On Mon, Jun 03, 2019 at 06:55:15PM +0200, Andrey Konovalov wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

videobuf_dma_contig_user_get() uses provided user pointers for vma lookups, which can only by done with untagged pointers.

Untag the pointers in this function.

Acked-by: Mauro Carvalho Chehab mchehab+samsung@kernel.org Signed-off-by: Andrey Konovalov andreyknvl@google.com

Reviewed-by: Kees Cook keescook@chromium.org

-Kees

---

drivers/media/v4l2-core/videobuf-dma-contig.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/drivers/media/v4l2-core/videobuf-dma-contig.c b/drivers/media/v4l2-core/videobuf-dma-contig.c index e1bf50df4c70..8a1ddd146b17 100644 --- a/drivers/media/v4l2-core/videobuf-dma-contig.c +++ b/drivers/media/v4l2-core/videobuf-dma-contig.c @@ -160,6 +160,7 @@ static void videobuf_dma_contig_user_put(struct videobuf_dma_contig_memory *mem) static int videobuf_dma_contig_user_get(struct videobuf_dma_contig_memory *mem, struct videobuf_buffer *vb) {

• unsigned long untagged_baddr = untagged_addr(vb->baddr); struct mm_struct *mm = current->mm; struct vm_area_struct *vma; unsigned long prev_pfn, this_pfn;

@@ -167,22 +168,22 @@ static int videobuf_dma_contig_user_get(struct videobuf_dma_contig_memory *mem, unsigned int offset; int ret;

• offset = vb->baddr & ~PAGE_MASK;

• offset = untagged_baddr & ~PAGE_MASK; mem->size = PAGE_ALIGN(vb->size + offset); ret = -EINVAL;

down_read(&mm->mmap_sem);

• vma = find_vma(mm, vb->baddr);

• vma = find_vma(mm, untagged_baddr); if (!vma) goto out_up;

• if ((vb->baddr + mem->size) > vma->vm_end)

• if ((untagged_baddr + mem->size) > vma->vm_end) goto out_up;

pages_done = 0; prev_pfn = 0; /* kill warning */

• user_address = vb->baddr;

• user_address = untagged_baddr;

while (pages_done < (mem->size >> PAGE_SHIFT)) { ret = follow_pfn(vma, user_address, &this_pfn); -- 2.22.0.rc1.311.g5d7573a151-goog

On Mon, Jun 3, 2019 at 6:56 PM Andrey Konovalov andreyknvl@google.com wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

tee_shm_register()->optee_shm_unregister()->check_mem_type() uses provided user pointers for vma lookups (via __check_mem_type()), which can only by done with untagged pointers.

Untag user pointers in this function.

Signed-off-by: Andrey Konovalov andreyknvl@google.com

Acked-by: Jens Wiklander jens.wiklander@linaro.org

---

drivers/tee/tee_shm.c | 1 + 1 file changed, 1 insertion(+)

diff --git a/drivers/tee/tee_shm.c b/drivers/tee/tee_shm.c index 49fd7312e2aa..96945f4cefb8 100644 --- a/drivers/tee/tee_shm.c +++ b/drivers/tee/tee_shm.c @@ -263,6 +263,7 @@ struct tee_shm *tee_shm_register(struct tee_context *ctx, unsigned long addr, shm->teedev = teedev; shm->ctx = ctx; shm->id = -1;

•   addr = untagged_addr(addr);
    start = rounddown(addr, PAGE_SIZE);
    shm->offset = addr - start;
    shm->size = length;
  

-- 2.22.0.rc1.311.g5d7573a151-goog

On Mon, Jun 03, 2019 at 06:55:18PM +0200, Andrey Konovalov wrote:

This patch is a part of a series that extends arm64 kernel ABI to allow to pass tagged user pointers (with the top byte set to something else other than 0x00) as syscall arguments.

This patch adds a simple test, that calls the uname syscall with a tagged user pointer as an argument. Without the kernel accepting tagged user pointers the test fails with EFAULT.

Signed-off-by: Andrey Konovalov andreyknvl@google.com

I'm adding Shuah to CC in case she has some suggestions about the new selftest.

Reviewed-by: Kees Cook keescook@chromium.org

-Kees

---

tools/testing/selftests/arm64/.gitignore | 1 + tools/testing/selftests/arm64/Makefile | 22 ++++++++++ .../testing/selftests/arm64/run_tags_test.sh | 12 ++++++ tools/testing/selftests/arm64/tags_lib.c | 42 +++++++++++++++++++ tools/testing/selftests/arm64/tags_test.c | 18 ++++++++ 5 files changed, 95 insertions(+) create mode 100644 tools/testing/selftests/arm64/.gitignore create mode 100644 tools/testing/selftests/arm64/Makefile create mode 100755 tools/testing/selftests/arm64/run_tags_test.sh create mode 100644 tools/testing/selftests/arm64/tags_lib.c create mode 100644 tools/testing/selftests/arm64/tags_test.c

diff --git a/tools/testing/selftests/arm64/.gitignore b/tools/testing/selftests/arm64/.gitignore new file mode 100644 index 000000000000..e8fae8d61ed6 --- /dev/null +++ b/tools/testing/selftests/arm64/.gitignore @@ -0,0 +1 @@ +tags_test diff --git a/tools/testing/selftests/arm64/Makefile b/tools/testing/selftests/arm64/Makefile new file mode 100644 index 000000000000..9dee18727923 --- /dev/null +++ b/tools/testing/selftests/arm64/Makefile @@ -0,0 +1,22 @@ +# SPDX-License-Identifier: GPL-2.0

+include ../lib.mk

+# ARCH can be overridden by the user for cross compiling +ARCH ?= $(shell uname -m 2>/dev/null || echo not)

+ifneq (,$(filter $(ARCH),aarch64 arm64))

+TEST_CUSTOM_PROGS := $(OUTPUT)/tags_test

+$(OUTPUT)/tags_test: tags_test.c $(OUTPUT)/tags_lib.so

• $(CC) -o $@ $(CFLAGS) $(LDFLAGS) $<

+$(OUTPUT)/tags_lib.so: tags_lib.c

• $(CC) -o $@ -shared $(CFLAGS) $(LDFLAGS) $^

+TEST_PROGS := run_tags_test.sh

+all: $(TEST_CUSTOM_PROGS)

+endif diff --git a/tools/testing/selftests/arm64/run_tags_test.sh b/tools/testing/selftests/arm64/run_tags_test.sh new file mode 100755 index 000000000000..2bbe0cd4220b --- /dev/null +++ b/tools/testing/selftests/arm64/run_tags_test.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0

+echo "--------------------" +echo "running tags test" +echo "--------------------" +LD_PRELOAD=./tags_lib.so ./tags_test +if [ $? -ne 0 ]; then

• echo "[FAIL]"

+else

• echo "[PASS]"

+fi diff --git a/tools/testing/selftests/arm64/tags_lib.c b/tools/testing/selftests/arm64/tags_lib.c new file mode 100644 index 000000000000..8a674509216e --- /dev/null +++ b/tools/testing/selftests/arm64/tags_lib.c @@ -0,0 +1,42 @@ +#include <stdlib.h>

+#define TAG_SHIFT (56) +#define TAG_MASK (0xffUL << TAG_SHIFT)

+void *__libc_malloc(size_t size); +void __libc_free(void *ptr); +void *__libc_realloc(void *ptr, size_t size); +void *__libc_calloc(size_t nmemb, size_t size);

+static void *tag_ptr(void *ptr) +{

• unsigned long tag = rand() & 0xff;
• if (!ptr)

• return ptr;
  

• return (void *)((unsigned long)ptr | (tag << TAG_SHIFT));

+}

+static void *untag_ptr(void *ptr) +{

• return (void *)((unsigned long)ptr & ~TAG_MASK);

+}

+void *malloc(size_t size) +{

• return tag_ptr(__libc_malloc(size));

+}

+void free(void *ptr) +{

• __libc_free(untag_ptr(ptr));

+}

+void *realloc(void *ptr, size_t size) +{

• return tag_ptr(__libc_realloc(untag_ptr(ptr), size));

+}

+void *calloc(size_t nmemb, size_t size) +{

• return tag_ptr(__libc_calloc(nmemb, size));

+} diff --git a/tools/testing/selftests/arm64/tags_test.c b/tools/testing/selftests/arm64/tags_test.c new file mode 100644 index 000000000000..263b302874ed --- /dev/null +++ b/tools/testing/selftests/arm64/tags_test.c @@ -0,0 +1,18 @@ +// SPDX-License-Identifier: GPL-2.0

+#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <stdint.h> +#include <sys/utsname.h>

+int main(void) +{

• struct utsname *ptr;
• int err;
• ptr = (struct utsname *)malloc(sizeof(*ptr));
• err = uname(ptr);
• free(ptr);
• return err;

+}

2.22.0.rc1.311.g5d7573a151-goog