Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-10 06:01:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

arm64: access_ok() optimization

Browse Source 
The TBI setup on arm64 is very strange: HW is set up to always do TBI,
but the kernel enforcement for system calls is purely a software
contract, and user space is supposed to mask off the top bits before the
system call.

Except all the actual brk/mmap/etc() system calls then mask it in kernel
space anyway, and accept any TBI address.

This basically unifies things and makes access_ok() also ignore it.

This is an ABI change, but the current situation is very odd, and this
change avoids the current mess and makes the kernel more permissive, and
as such is unlikely to break anything.

The way forward - for some possible future situation when people want to
use more bits - is probably to introduce a new "I actually want the full
64-bit address space" prctl.  But we should make sure that the software
and hardware rules actually match at that point.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Linus Torvalds 2024-06-09 10:14:24 -07:00
parent 7fd298d4b3
commit d31e86ef63
1 changed files with 10 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
arch/arm64/include/asm/uaccess.h
View File

@ -30,23 +30,20 @@ static inline int __access_ok(const void __user *ptr, unsigned long size);
/* /*
* Test whether a block of memory is a valid user space address. * Test whether a block of memory is a valid user space address.
* Returns 1 if the range is valid, 0 otherwise.
* *
* This is equivalent to the following test: * We only care that the address cannot reach the kernel mapping, and
* (u65)addr + (u65)size <= (u65)TASK_SIZE_MAX * that an invalid address will fault.
*/ */
static inline int access_ok(const void __user *addr, unsigned long size) static inline int access_ok(const void __user *p, unsigned long size)
{ {
/* unsigned long addr = (unsigned long)p;
* Asynchronous I/O running in a kernel thread does not have the
* TIF_TAGGED_ADDR flag of the process owning the mm, so always untag
* the user address before checking.
*/
if (IS_ENABLED(CONFIG_ARM64_TAGGED_ADDR_ABI) &&
(current->flags & PF_KTHREAD || test_thread_flag(TIF_TAGGED_ADDR)))
addr = untagged_addr(addr);
return likely(__access_ok(addr, size)); /* Only bit 55 of the address matters */
addr |= addr+size;
addr = (addr >> 55) & 1;
size >>= 55;
return !(addr | size);
} }
#define access_ok access_ok #define access_ok access_ok