arm64: untag user pointers passed to the kernel

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 <[email protected]>

Reviewed-by Khalid Aziz <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

include/linux/mm.h +0 -0

index 0e8834ac32b7..949d43e9c0b6 100644

Quoted 20 lines · Andrey Konovalov

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 <[email protected]>

Reviewed-by Khalid Aziz <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

include/linux/mm.h +0 -0

index 0e8834ac32b7..949d43e9c0b6 100644

include/linux/mm.h extern int mmap_rnd_compat_bits __read_mostly; · line 108

Quoted 10 lines

include/linux/mm.h +4 -0

@@ -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/[email protected]/>. Can you coordinate with that patch series?

--
Khalid

Quoted 6 lines · Khalid Aziz

Andrey,

This patch has now become part of the other patch series Chris Hellwig has sent out -
<https://lore.kernel.org/lkml/[email protected]/>. Can you coordinate with that patch series?

Hi!

Yes, I've seen it. How should I coordinate? Rebase this series on top of that one?

Quoted 8 lines · Andrey Konovalov

Quoted 6 lines · Khalid Aziz

Andrey,

This patch has now become part of the other patch series Chris Hellwig has sent out -
<https://lore.kernel.org/lkml/[email protected]/>. Can you coordinate with that patch series?

Quoted 4 lines

Hi!

Yes, I've seen it. How should I coordinate? Rebase this series on top of that one?

That would be one way to do it. Better yet, separate this patch from both patch series, make it standalone and then rebase the two patch series on top of it.

Quoted 14 lines · Khalid Aziz

Quoted 12 lines · Andrey Konovalov

Quoted 6 lines · Khalid Aziz

Andrey,

This patch has now become part of the other patch series Chris Hellwig has sent out -
<https://lore.kernel.org/lkml/[email protected]/>. Can you coordinate with that patch series?

Hi!

Yes, I've seen it. How should I coordinate? Rebase this series on top of that one?

Quoted 3 lines

That would be one way to do it. Better yet, separate this patch from both patch series, make it standalone and then rebase the two patch series on top of it.

I think easiest would be to just ask Linus if he could make an exception and include this trivial prep patch in 5.2-rc.

Quoted 15 lines · Christoph Hellwig

Quoted 14 lines · Khalid Aziz

Quoted 12 lines · Andrey Konovalov

Quoted 6 lines · Khalid Aziz

Andrey,

This patch has now become part of the other patch series Chris Hellwig has sent out -
<https://lore.kernel.org/lkml/[email protected]/>. Can you coordinate with that patch series?

Hi!

Yes, I've seen it. How should I coordinate? Rebase this series on top of that one?

Quoted 7 lines

Quoted 3 lines

That would be one way to do it. Better yet, separate this patch from both patch series, make it standalone and then rebase the two patch series on top of it.

I think easiest would be to just ask Linus if he could make an exception and include this trivial prep patch in 5.2-rc.

Andrey,

Would you mind updating the commit log to make it not arm64 specific and sending this patch out by itself. We can then ask Linus if he can include just this patch in the next rc.

Thanks,
Khalid

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.

copy_from_user (and a few other similar functions) are used to copy data from user memory into the kernel memory or vice versa. Since a user can provided a tagged pointer to one of the syscalls that use copy_from_user, we need to correctly handle such pointers.

Do this by untagging user pointers in access_ok and in __uaccess_mask_ptr, before performing access validity checks.

Note, that this patch only temporarily untags the pointers to perform the checks, but then passes them as is into the kernel internals.

Reviewed-by Catalin Marinas <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

---
 arch/arm64/include/asm/uaccess.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

arch/arm64/include/asm/uaccess.h +6 -4

index e5d5f31c6d36..9164ecb5feca 100644
@@ -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)
 #define user_addr_max			get_fs
 
 #define _ASM_EXTABLE(from, to)						\

@@ -226,7 +226,8 @@ static inline void uaccess_enable_not_uao(void)
 
 /*
  * Sanitise a uaccess pointer such that it becomes NULL if above the
- * current addr_limit.
+ * current addr_limit. In case the pointer is tagged (has the top byte set),
+ * untag the pointer before checking.
  */
 #define uaccess_mask_ptr(ptr) (__typeof__(ptr))__uaccess_mask_ptr(ptr)
 static inline void __user *__uaccess_mask_ptr(const void __user *ptr)

@@ -234,10 +235,11 @@ static inline void __user *__uaccess_mask_ptr(const void __user *ptr)
 	void __user *safe_ptr;
 
 	asm volatile(
-	"	bics	xzr, %1, %2\n"
+	"	bics	xzr, %3, %2\n"
 	"	csel	%0, %1, xzr, eq\n"
 	: "=&r" (safe_ptr)
-	: "r" (ptr), "r" (current_thread_info()->addr_limit)
+	: "r" (ptr), "r" (current_thread_info()->addr_limit),
+	  "r" (untagged_addr(ptr))
 	: "cc");
 
 	csdb();

Signature · 1 line

2.22.0.rc1.311.g5d7573a151-goog

arch/arm64/include/asm/uaccess.h static inline unsigned long __range_ok(const void __user *addr, unsigned long si · line 97

Quoted 10 lines · Andrey Konovalov

arch/arm64/include/asm/uaccess.h +1 -1

index e5d5f31c6d36..9164ecb5feca 100644
@@ -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<---------------------------------------------

arch/arm64/include/asm/processor.h +4 -0

index fcd0e691b1ea..2d4cb7e4edab 100644
@@ -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
  *

arch/arm64/include/asm/thread_info.h +2 -0

index c285d1ce7186..89ce77773c49 100644
@@ -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 | \

arch/arm64/include/asm/uaccess.h +4 -1

index 9164ecb5feca..54f5bbaebbc4 100644
@@ -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)						\

arch/arm64/kernel/process.c +5 -0

index 3767fb21a5b8..fd191c5b92aa 100644
@@ -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)

Quoted 11 lines · Catalin Marinas

Quoted 10 lines · Andrey Konovalov

arch/arm64/include/asm/uaccess.h +1 -1

index e5d5f31c6d36..9164ecb5feca 100644
@@ -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)

Quoted 18 lines

arch/arm64/kernel/process.c +10 -0

index 3767fb21a5b8..fd191c5b92aa 100644
@@ -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;

arch/arm64/kernel/process.c void arch_setup_new_exec(void) · line 569

Quoted 5 lines

arch/arm64/kernel/process.c +5 -0

+
+	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)

Quoted 19 lines · Kees Cook

Quoted 18 lines · Catalin Marinas

arch/arm64/kernel/process.c +10 -0

index 3767fb21a5b8..fd191c5b92aa 100644
@@ -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;

Quoted 8 lines

arch/arm64/kernel/process.c void arch_setup_new_exec(void) · line 569

Quoted 5 lines

arch/arm64/kernel/process.c +5 -0

+
+	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.

Quoted 8 lines · Andrey Konovalov

arch/arm64/include/asm/uaccess.h +0 -0

index e5d5f31c6d36..9164ecb5feca 100644
@@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si
 	return ret;
 }
 

arch/arm64/include/asm/uaccess.h static inline unsigned long __range_ok(const void __user *addr, unsigned long si · line 97

Quoted 2 lines

arch/arm64/include/asm/uaccess.h +1 -1

-#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.

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

---------8<----------------
From 7c624777a4e545522dec1b34e60f0229cb2bd59f Mon Sep 17 00:00:00 2001
From: Catalin Marinas <[email protected]>
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 <[email protected]>

---
 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(-)

arch/arm64/include/asm/processor.h +6 -0

index fcd0e691b1ea..fee457456aa8 100644
@@ -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
  *

arch/arm64/include/asm/thread_info.h +0 -0

index c285d1ce7186..7263d4c973ce 100644

arch/arm64/include/asm/thread_info.h +0 -0

 #define _TIF_SIGPENDING		(1 << TIF_SIGPENDING)
 #define _TIF_NEED_RESCHED	(1 << TIF_NEED_RESCHED)

arch/arm64/include/asm/uaccess.h +4 -1

index 9164ecb5feca..995b9ea11a89 100644
@@ -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)						\

arch/arm64/kernel/process.c +1 -0

index 3767fb21a5b8..69d0be1fc708 100644
@@ -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>

arch/arm64/kernel/process.c +55 -0

 }
 
 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,
+	},
+	{ }

include/uapi/linux/prctl.h +5 -0

index 094bb03b9cc2..2e927b3e9d6c 100644
@@ -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 */

kernel/sys.c +6 -0

index 2969304c29fe..ec48396b4943 100644
@@ -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;

kernel/sys.c +0 -0

 	default:
 		error = -EINVAL;
 		break;

Quoted 12 lines

arch/arm64/kernel/process.c +1 -0

index 3767fb21a5b8..69d0be1fc708 100644
@@ -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>

arch/arm64/kernel/process.c void flush_thread(void) · line 327

Quoted 5 lines

arch/arm64/kernel/process.c +1 -0

@@ -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.

Quoted 40 lines

include/uapi/linux/prctl.h +5 -0

index 094bb03b9cc2..2e927b3e9d6c 100644
@@ -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 */

kernel/sys.c +11 -0

index 2969304c29fe..ec48396b4943 100644
@@ -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;

kernel/sys.c SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, · line 2510

Quoted 5 lines

kernel/sys.c +5 -0

+	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?

Hi Vincenzo,

Quoted 12 lines · Vincenzo Frascino

Quoted 12 lines

arch/arm64/kernel/process.c +1 -0

index 3767fb21a5b8..69d0be1fc708 100644
@@ -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>

Quoted 8 lines

arch/arm64/kernel/process.c void flush_thread(void) · line 327

Quoted 5 lines

arch/arm64/kernel/process.c +1 -0

@@ -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.

Quoted 40 lines

Quoted 40 lines

include/uapi/linux/prctl.h +5 -0

index 094bb03b9cc2..2e927b3e9d6c 100644
@@ -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 */

kernel/sys.c +11 -0

index 2969304c29fe..ec48396b4943 100644
@@ -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;

Quoted 8 lines

kernel/sys.c SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, · line 2510

Quoted 5 lines

kernel/sys.c +5 -0

+	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.

Quoted 9 lines · Catalin Marinas

Quoted 8 lines · Andrey Konovalov

arch/arm64/include/asm/uaccess.h +0 -0

index e5d5f31c6d36..9164ecb5feca 100644
@@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si
    return ret;
 }
 

Quoted 10 lines

arch/arm64/include/asm/uaccess.h static inline unsigned long __range_ok(const void __user *addr, unsigned long si · line 97

Quoted 2 lines

arch/arm64/include/asm/uaccess.h +1 -1

-#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 <[email protected]>
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 <[email protected]>

---
 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(-)

arch/arm64/include/asm/processor.h +6 -0

index fcd0e691b1ea..fee457456aa8 100644
@@ -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
  *

arch/arm64/include/asm/thread_info.h +1 -0

index c285d1ce7186..7263d4c973ce 100644
@@ -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)

arch/arm64/include/asm/uaccess.h +4 -1

index 9164ecb5feca..995b9ea11a89 100644
@@ -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)                                         \

arch/arm64/kernel/process.c +67 -0

index 3767fb21a5b8..69d0be1fc708 100644
@@ -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);

include/uapi/linux/prctl.h +5 -0

index 094bb03b9cc2..2e927b3e9d6c 100644
@@ -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 */

kernel/sys.c +16 -0

index 2969304c29fe..ec48396b4943 100644
@@ -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;

Quoted 29 lines · Catalin Marinas

Quoted 9 lines · Catalin Marinas

Quoted 8 lines · Andrey Konovalov

arch/arm64/include/asm/uaccess.h +0 -0

index e5d5f31c6d36..9164ecb5feca 100644
@@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si
    return ret;
 }
 

Quoted 10 lines

arch/arm64/include/asm/uaccess.h static inline unsigned long __range_ok(const void __user *addr, unsigned long si · line 97

Quoted 2 lines

arch/arm64/include/asm/uaccess.h +1 -1

-#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

Quoted 4 lines

- 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?

Quoted 35 lines · Andrey Konovalov

Quoted 33 lines · Catalin Marinas

Quoted 9 lines · Catalin Marinas

Quoted 8 lines · Andrey Konovalov

arch/arm64/include/asm/uaccess.h +0 -0

index e5d5f31c6d36..9164ecb5feca 100644
@@ -94,7 +94,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si
    return ret;
 }
 

Quoted 10 lines

arch/arm64/include/asm/uaccess.h static inline unsigned long __range_ok(const void __user *addr, unsigned long si · line 97

Quoted 2 lines

arch/arm64/include/asm/uaccess.h +1 -1

-#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.

Quoted 3 lines

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.

--
Catalin

Quoted 6 lines · Catalin Marinas

Quoted 1 line · Andrey Konovalov

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.

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 <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

lib/strncpy_from_user.c +2 -1

index 023ba9f3b99f..dccb95af6003 100644
@@ -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;

lib/strnlen_user.c +2 -1

index 7f2db3fe311f..28ff554a1be8 100644
@@ -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;

Signature · 1 line

2.22.0.rc1.311.g5d7573a151-goog

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 <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

lib/strncpy_from_user.c +2 -1

index 023ba9f3b99f..dccb95af6003 100644
@@ -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;

lib/strnlen_user.c +2 -1

index 7f2db3fe311f..28ff554a1be8 100644
@@ -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;

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 <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

mm/migrate.c +1 -0

index f2ecc2855a12..3930bb6fa656 100644
@@ -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)

Signature · 1 line

2.22.0.rc1.311.g5d7573a151-goog

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 <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

mm/migrate.c +0 -0

index f2ecc2855a12..3930bb6fa656 100644

Quoted 14 lines · Andrey Konovalov

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 <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

mm/migrate.c static int do_pages_move(struct mm_struct *mm, nodemask_t task_nodes, · line 1620

Quoted 9 lines

mm/migrate.c +1 -0

index f2ecc2855a12..3930bb6fa656 100644
@@ -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);"

--
Khalid

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 <[email protected]>

---
 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(+)

mm/madvise.c +2 -0

index 628022e674a7..39b82f8a698f 100644
@@ -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;
 

mm/mempolicy.c +3 -0

index 01600d80ae01..78e0a88b2680 100644
@@ -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;
 

mm/mincore.c +2 -0

index c3f058bd0faf..64c322ed845c 100644
@@ -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;

mm/mlock.c +4 -0

index 080f3b36415b..e82609eaa428 100644
@@ -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;
 

mm/mprotect.c +2 -0

index bf38dfbbb4b4..19f981b733bc 100644
@@ -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;

mm/mremap.c +2 -0

index fc241d23cd97..1d98281f7204 100644
@@ -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;
 

mm/msync.c +2 -0

index ef30a429623a..c3bd3e75f687 100644
@@ -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))

Signature · 1 line

2.22.0.rc1.311.g5d7573a151-goog

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 <[email protected]>

Quoted 8 lines · Andrey Konovalov

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.

Quoted 1 line

Signed-off-by Andrey Konovalov <[email protected]>

I would add in the commit log (and possibly in the code with a comment) that mremap() and mmap() do not currently accept tagged hint addresses. Architectures may interpret the hint tag as a background colour for the corresponding vma. With this:

Reviewed-by Catalin Marinas <[email protected]>

--
Catalin

Quoted 11 lines · Catalin Marinas

Quoted 9 lines · Andrey Konovalov

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 <[email protected]>

Quoted 4 lines

I would add in the commit log (and possibly in the code with a comment) that mremap() and mmap() do not currently accept tagged hint addresses. Architectures may interpret the hint tag as a background colour for the corresponding vma. With this:

I'll change the commit log. Where do you you think I should put this comment? Before mmap and mremap definitions in mm/?

Quoted 17 lines · Andrey Konovalov

Quoted 15 lines · Catalin Marinas

Quoted 9 lines · Andrey Konovalov

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 <[email protected]>

I would add in the commit log (and possibly in the code with a comment) that mremap() and mmap() do not currently accept tagged hint addresses. Architectures may interpret the hint tag as a background colour for the corresponding vma. With this:

Quoted 2 lines

I'll change the commit log. Where do you you think I should put this comment? Before mmap and mremap definitions in mm/?

On arm64 we use our own sys_mmap(). I'd say just add a comment on the generic mremap() just before the untagged_addr() along the lines that new_address is not untagged for preserving similar behaviour to mmap().

--
Catalin

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 <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

mm/gup.c +4 -0

index ddde097cf9e4..c37df3d455a2 100644
@@ -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;
 

Signature · 1 line

2.22.0.rc1.311.g5d7573a151-goog

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 <[email protected]>

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

mm/frame_vector.c +2 -0

index c64dca6e27c2..c431ca81dad5 100644
@@ -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);

Signature · 1 line

2.22.0.rc1.311.g5d7573a151-goog

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 <[email protected]>

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 <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

fs/namespace.c +1 -1

index b26778bdc236..2e85712a19ed 100644
@@ -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;
 

Signature · 1 line

2.22.0.rc1.311.g5d7573a151-goog

Quoted 10 lines · Andrey Konovalov

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.

Quoted 4 lines

Untag the address before subtracting.

Reviewed-by Catalin Marinas <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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

Reviewed-by Kees Cook <[email protected]>

-Kees

Quoted 18 lines

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

fs/namespace.c +1 -2

index b26778bdc236..2e85712a19ed 100644
@@ -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;
 
--

Quoted 2 lines

2.22.0.rc1.311.g5d7573a151-goog

--
Kees Cook

Quoted 21 lines · Kees Cook

Quoted 10 lines · Andrey Konovalov

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.

Quoted 4 lines

Untag the address before subtracting.

Reviewed-by Catalin Marinas <[email protected]>

Signed-off-by Andrey Konovalov <[email protected]>

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?

Quoted 3 lines

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!

Quoted 28 lines

Reviewed-by Kees Cook <[email protected]>

-Kees

Quoted 18 lines

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

fs/namespace.c +1 -2

index b26778bdc236..2e85712a19ed 100644
@@ -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;
 
--

Quoted 2 lines

2.22.0.rc1.311.g5d7573a151-goog

--
Kees Cook

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.

userfaultfd code use provided user pointers for vma lookups, which can only by done with untagged pointers.

Untag user pointers in validate_range().

Signed-off-by Andrey Konovalov <[email protected]>

---
 fs/userfaultfd.c | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

fs/userfaultfd.c +12 -10

index 3b30301c90ec..24d68c3b5ee2 100644
@@ -1263,21 +1263,23 @@ static __always_inline void wake_userfault(struct userfaultfd_ctx *ctx,
 }
 
 static __always_inline int validate_range(struct mm_struct *mm,
-					  __u64 start, __u64 len)
+					  __u64 *start, __u64 len)
 {
 	__u64 task_size = mm->task_size;
 
-	if (start & ~PAGE_MASK)
+	*start = untagged_addr(*start);
+
+	if (*start & ~PAGE_MASK)
 		return -EINVAL;
 	if (len & ~PAGE_MASK)
 		return -EINVAL;
 	if (!len)
 		return -EINVAL;
-	if (start < mmap_min_addr)
+	if (*start < mmap_min_addr)
 		return -EINVAL;
-	if (start >= task_size)
+	if (*start >= task_size)
 		return -EINVAL;
-	if (len > task_size - start)
+	if (len > task_size - *start)
 		return -EINVAL;
 	return 0;
 }

@@ -1327,7 +1329,7 @@ static int userfaultfd_register(struct userfaultfd_ctx *ctx,
 		goto out;
 	}
 
-	ret = validate_range(mm, uffdio_register.range.start,
+	ret = validate_range(mm, &uffdio_register.range.start,
 			     uffdio_register.range.len);
 	if (ret)
 		goto out;

@@ -1516,7 +1518,7 @@ static int userfaultfd_unregister(struct userfaultfd_ctx *ctx,
 	if (copy_from_user(&uffdio_unregister, buf, sizeof(uffdio_unregister)))
 		goto out;
 
-	ret = validate_range(mm, uffdio_unregister.start,
+	ret = validate_range(mm, &uffdio_unregister.start,
 			     uffdio_unregister.len);
 	if (ret)
 		goto out;

@@ -1667,7 +1669,7 @@ static int userfaultfd_wake(struct userfaultfd_ctx *ctx,
 	if (copy_from_user(&uffdio_wake, buf, sizeof(uffdio_wake)))
 		goto out;
 
-	ret = validate_range(ctx->mm, uffdio_wake.start, uffdio_wake.len);
+	ret = validate_range(ctx->mm, &uffdio_wake.start, uffdio_wake.len);
 	if (ret)
 		goto out;
 

@@ -1707,7 +1709,7 @@ static int userfaultfd_copy(struct userfaultfd_ctx *ctx,
 			   sizeof(uffdio_copy)-sizeof(__s64)))
 		goto out;
 
-	ret = validate_range(ctx->mm, uffdio_copy.dst, uffdio_copy.len);
+	ret = validate_range(ctx->mm, &uffdio_copy.dst, uffdio_copy.len);
 	if (ret)
 		goto out;
 	/*

@@ -1763,7 +1765,7 @@ static int userfaultfd_zeropage(struct userfaultfd_ctx *ctx,
 			   sizeof(uffdio_zeropage)-sizeof(__s64)))
 		goto out;
 
-	ret = validate_range(ctx->mm, uffdio_zeropage.range.start,
+	ret = validate_range(ctx->mm, &uffdio_zeropage.range.start,
 			     uffdio_zeropage.range.len);
 	if (ret)
 		goto out;

Signature · 1 line

2.22.0.rc1.311.g5d7573a151-goog

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.

userfaultfd code use provided user pointers for vma lookups, which can only by done with untagged pointers.

Untag user pointers in validate_range().

Signed-off-by Andrey Konovalov <[email protected]>

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 <[email protected]>

 drivers/infiniband/core/uverbs_cmd.c | 4 ++++
 1 file changed, 4 insertions(+)

drivers/infiniband/core/uverbs_cmd.c +1 -0

index 5a3a1780ceea..f88ee733e617 100644
+++ b/drivers/infiniband/core/uverbs_cmd.c

Quoted 17 lines · Andrey Konovalov

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 <[email protected]>

 drivers/infiniband/core/uverbs_cmd.c | 4 ++++
 1 file changed, 4 insertions(+)

drivers/infiniband/core/uverbs_cmd.c +1 -0

index 5a3a1780ceea..f88ee733e617 100644
+++ b/drivers/infiniband/core/uverbs_cmd.c

drivers/infiniband/core/uverbs_cmd.c static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) · line 715

Quoted 7 lines

drivers/infiniband/core/uverbs_cmd.c +2 -0

@@ -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):

drivers/infiniband/core/umem.c +2 -2

index 54628ef879f0ce..7b3b736c87c253 100644
@@ -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;

drivers/infiniband/core/uverbs_cmd.c +2 -1

index 5a3a1780ceea4d..94389e7f12371f 100644
@@ -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)) {

drivers/infiniband/hw/mlx5/mr.c +3 -3

index 4d033796dcfcc2..bddbb952082fc5 100644
@@ -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);

include/rdma/ib_verbs.h +2 -2

index ec6446864b08e9..b3c8eaaa35c760 100644
@@ -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,

Quoted 30 lines · Jason Gunthorpe

Quoted 17 lines · Andrey Konovalov

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 <[email protected]>

 drivers/infiniband/core/uverbs_cmd.c | 4 ++++
 1 file changed, 4 insertions(+)

drivers/infiniband/core/uverbs_cmd.c +1 -0

index 5a3a1780ceea..f88ee733e617 100644
+++ b/drivers/infiniband/core/uverbs_cmd.c

drivers/infiniband/core/uverbs_cmd.c static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) · line 715

Quoted 7 lines

drivers/infiniband/core/uverbs_cmd.c +2 -0

@@ -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?

Quoted 3 lines

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?

Quoted 37 lines · Andrey Konovalov

Quoted 30 lines · Jason Gunthorpe

Quoted 17 lines · Andrey Konovalov

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 <[email protected]>

 drivers/infiniband/core/uverbs_cmd.c | 4 ++++
 1 file changed, 4 insertions(+)

drivers/infiniband/core/uverbs_cmd.c +1 -0

index 5a3a1780ceea..f88ee733e617 100644
+++ b/drivers/infiniband/core/uverbs_cmd.c

drivers/infiniband/core/uverbs_cmd.c static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) · line 715

Quoted 7 lines

drivers/infiniband/core/uverbs_cmd.c +2 -0

@@ -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?

Quoted 3 lines

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,

Quoted 3 lines

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

Quoted 43 lines · Jason Gunthorpe

Quoted 40 lines · Andrey Konovalov

Quoted 30 lines · Jason Gunthorpe

Quoted 17 lines · Andrey Konovalov

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 <[email protected]>

 drivers/infiniband/core/uverbs_cmd.c | 4 ++++
 1 file changed, 4 insertions(+)

drivers/infiniband/core/uverbs_cmd.c +1 -0

index 5a3a1780ceea..f88ee733e617 100644
+++ b/drivers/infiniband/core/uverbs_cmd.c

drivers/infiniband/core/uverbs_cmd.c static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) · line 715

Quoted 7 lines

drivers/infiniband/core/uverbs_cmd.c +2 -0

@@ -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?

Quoted 3 lines

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?

Quoted 3 lines

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?

Quoted 48 lines · Andrey Konovalov

Quoted 46 lines · Jason Gunthorpe

Quoted 35 lines · Andrey Konovalov

Quoted 30 lines · Jason Gunthorpe

Quoted 17 lines · Andrey Konovalov

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 <[email protected]>

 drivers/infiniband/core/uverbs_cmd.c | 4 ++++
 1 file changed, 4 insertions(+)

drivers/infiniband/core/uverbs_cmd.c +1 -0

index 5a3a1780ceea..f88ee733e617 100644
+++ b/drivers/infiniband/core/uverbs_cmd.c

drivers/infiniband/core/uverbs_cmd.c static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) · line 715

Quoted 7 lines

drivers/infiniband/core/uverbs_cmd.c +2 -0

@@ -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?

Quoted 3 lines

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):

Quoted 5 lines

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.

Quoted 2 lines

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

Quoted 45 lines · Jason Gunthorpe

Quoted 44 lines · Andrey Konovalov

Quoted 42 lines · Jason Gunthorpe

Quoted 30 lines · Andrey Konovalov

Quoted 29 lines · Jason Gunthorpe

Quoted 17 lines · Andrey Konovalov

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 <[email protected]>

 drivers/infiniband/core/uverbs_cmd.c | 4 ++++
 1 file changed, 4 insertions(+)

drivers/infiniband/core/uverbs_cmd.c +1 -0

index 5a3a1780ceea..f88ee733e617 100644
+++ b/drivers/infiniband/core/uverbs_cmd.c

drivers/infiniband/core/uverbs_cmd.c static int ib_uverbs_reg_mr(struct uverbs_attr_bundle *attrs) · line 715

Quoted 7 lines

drivers/infiniband/core/uverbs_cmd.c +2 -0

@@ -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?

Quoted 7 lines

Quoted 3 lines

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.

Quoted 6 lines

Quoted 2 lines

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?