github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-06-02 03:24:19 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

powerpc/uaccess: Remove {allow/prevent}_{read/write/read_write}_{from/to/}_user()

Browse Source 
The six following functions have become simple single-line fonctions
that do not have much added value anymore:
- allow_read_from_user()
- allow_write_to_user()
- allow_read_write_user()
- prevent_read_from_user()
- prevent_write_to_user()
- prevent_read_write_user()

Directly call allow_user_access() and prevent_user_access(), it doesn't
reduce the readability and it removes unnecessary middle functions.

Signed-off-by: Christophe Leroy <christophe.leroy@csgroup.eu>
Signed-off-by: Madhavan Srinivasan <maddy@linux.ibm.com>
Link: https://patch.msgid.link/70971f0ba81eab742a120e5bfdeff6b42d08fd98.1766574657.git.chleroy@kernel.org
This commit is contained in:
Christophe Leroy 2025-12-24 12:20:51 +01:00 committed by Madhavan Srinivasan
parent e3efbfbfaa
commit 5458989a0e
2 changed files with 15 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
arch/powerpc/include/asm/kup.h
View File

@ -131,53 +131,6 @@ static __always_inline void kuap_assert_locked(void)
kuap_get_and_assert_locked();
}
static __always_inline void allow_read_from_user(const void __user *from, unsigned long size)
{
allow_user_access(NULL, KUAP_READ);
}
static __always_inline void allow_write_to_user(void __user *to, unsigned long size)
{
allow_user_access(to, KUAP_WRITE);
}
static __always_inline void allow_read_write_user(void __user *to, const void __user *from,
unsigned long size)
{
allow_user_access(to, KUAP_READ_WRITE);
}
static __always_inline void prevent_read_from_user(const void __user *from, unsigned long size)
{
prevent_user_access(KUAP_READ);
}
static __always_inline void prevent_write_to_user(void __user *to, unsigned long size)
{
prevent_user_access(KUAP_WRITE);
}
static __always_inline void prevent_read_write_user(void __user *to, const void __user *from,
unsigned long size)
{
prevent_user_access(KUAP_READ_WRITE);
}
static __always_inline void prevent_current_access_user(void)
{
prevent_user_access(KUAP_READ_WRITE);
}
static __always_inline void prevent_current_read_from_user(void)
{
prevent_user_access(KUAP_READ);
}
static __always_inline void prevent_current_write_to_user(void)
{
prevent_user_access(KUAP_WRITE);
}
#endif /* !__ASSEMBLER__ */
#endif /* _ASM_POWERPC_KUAP_H_ */

30
arch/powerpc/include/asm/uaccess.h
View File

@ -45,14 +45,14 @@
do { \
__label__ __pu_failed; \
\
allow_write_to_user(__pu_addr, __pu_size); \
allow_user_access(__pu_addr, KUAP_WRITE); \
__put_user_size_goto(__pu_val, __pu_addr, __pu_size, __pu_failed); \
prevent_write_to_user(__pu_addr, __pu_size); \
prevent_user_access(KUAP_WRITE); \
__pu_err = 0; \
break; \
\
__pu_failed: \
prevent_write_to_user(__pu_addr, __pu_size); \
prevent_user_access(KUAP_WRITE); \
__pu_err = -EFAULT; \
} while (0); \
\
@ -302,9 +302,9 @@ do { \
\
might_fault(); \
barrier_nospec(); \
allow_read_from_user(__gu_addr, __gu_size); \
allow_user_access(NULL, KUAP_READ); \
__get_user_size_allowed(__gu_val, __gu_addr, __gu_size, __gu_err); \
prevent_read_from_user(__gu_addr, __gu_size); \
prevent_user_access(KUAP_READ); \
(x) = (__typeof__(*(ptr)))__gu_val; \
\
__gu_err; \
@ -331,9 +331,9 @@ raw_copy_in_user(void __user *to, const void __user *from, unsigned long n)
unsigned long ret;
barrier_nospec();
allow_read_write_user(to, from, n);
allow_user_access(to, KUAP_READ_WRITE);
ret = __copy_tofrom_user(to, from, n);
prevent_read_write_user(to, from, n);
prevent_user_access(KUAP_READ_WRITE);
return ret;
}
#endif /* __powerpc64__ */
@ -343,9 +343,9 @@ static inline unsigned long raw_copy_from_user(void *to,
{
unsigned long ret;
allow_read_from_user(from, n);
allow_user_access(NULL, KUAP_READ);
ret = __copy_tofrom_user((__force void __user *)to, from, n);
prevent_read_from_user(from, n);
prevent_user_access(KUAP_READ);
return ret;
}
@ -354,9 +354,9 @@ raw_copy_to_user(void __user *to, const void *from, unsigned long n)
{
unsigned long ret;
allow_write_to_user(to, n);
allow_user_access(to, KUAP_WRITE);
ret = __copy_tofrom_user(to, (__force const void __user *)from, n);
prevent_write_to_user(to, n);
prevent_user_access(KUAP_WRITE);
return ret;
}
@ -367,9 +367,9 @@ static inline unsigned long __clear_user(void __user *addr, unsigned long size)
unsigned long ret;
might_fault();
allow_write_to_user(addr, size);
allow_user_access(addr, KUAP_WRITE);
ret = __arch_clear_user(addr, size);
prevent_write_to_user(addr, size);
prevent_user_access(KUAP_WRITE);
return ret;
}
@ -397,9 +397,9 @@ copy_mc_to_user(void __user *to, const void *from, unsigned long n)
{
if (check_copy_size(from, n, true)) {
if (access_ok(to, n)) {
allow_write_to_user(to, n);
allow_user_access(to, KUAP_WRITE);
n = copy_mc_generic((void __force *)to, from, n);
prevent_write_to_user(to, n);
prevent_user_access(KUAP_WRITE);
}
}