powerpc: Add a framework for user access tracking

Backported from commit de78a9c42a79 ("powerpc: Add a framework
for Kernel Userspace Access Protection"). Here we don't try to
add the KUAP framework, we just want the helper functions
because we want to put uaccess flush helpers in them.

In terms of fixes, we don't need commit 1d8f739b07bd ("powerpc/kuap:
Fix set direction in allow/prevent_user_access()") as we don't have
real KUAP. Likewise as all our allows are noops and all our prevents
are just flushes, we don't need commit 9dc086f1e9ef ("powerpc/futex:
Fix incorrect user access blocking") The other 2 fixes we do need.

The original description is:

This patch implements a framework for Kernel Userspace Access
Protection.

Then subarches will have the possibility to provide their own
implementation by providing setup_kuap() and
allow/prevent_user_access().

Some platforms will need to know the area accessed and whether it is
accessed from read, write or both. Therefore source, destination and
size and handed over to the two functions.

mpe: Rename to allow/prevent rather than unlock/lock, and add
read/write wrappers. Drop the 32-bit code for now until we have an
implementation for it. Add kuap to pt_regs for 64-bit as well as
32-bit. Don't split strings, use pr_crit_ratelimited().

Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Signed-off-by: Russell Currey <ruscur@russell.cc>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Signed-off-by: Daniel Axtens <dja@axtens.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/arch/powerpc/include/asm/futex.h b/arch/powerpc/include/asm/futex.h
index b73ab8a7ebc3ff22d16305beb5aed29a419752a6..10746519b351ba4d0a60b704eae18532b0ae9b70 100644 (file)
--- a/arch/powerpc/include/asm/futex.h
+++ b/arch/powerpc/include/asm/futex.h
@@ -36,6 +36,7 @@ static inline int arch_futex_atomic_op_inuser(int op, int oparg, int *oval,
 {
        int oldval = 0, ret;
 
+       allow_write_to_user(uaddr, sizeof(*uaddr));
        pagefault_disable();
 
        switch (op) {
@@ -62,6 +63,7 @@ static inline int arch_futex_atomic_op_inuser(int op, int oparg, int *oval,
 
        *oval = oldval;
 
+       prevent_write_to_user(uaddr, sizeof(*uaddr));
        return ret;
 }
 
@@ -75,6 +77,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
                return -EFAULT;
 
+       allow_write_to_user(uaddr, sizeof(*uaddr));
         __asm__ __volatile__ (
         PPC_ATOMIC_ENTRY_BARRIER
 "1:     lwarx   %1,0,%3         # futex_atomic_cmpxchg_inatomic\n\
@@ -97,6 +100,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
         : "cc", "memory");
 
        *uval = prev;
+       prevent_write_to_user(uaddr, sizeof(*uaddr));
         return ret;
 }
 

diff --git a/arch/powerpc/include/asm/kup.h b/arch/powerpc/include/asm/kup.h
new file mode 100644 (file)
index 0000000..7895d5e
--- /dev/null
+++ b/arch/powerpc/include/asm/kup.h
@@ -0,0 +1,36 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_POWERPC_KUP_H_
+#define _ASM_POWERPC_KUP_H_
+
+#ifndef __ASSEMBLY__
+
+#include <asm/pgtable.h>
+
+static inline void allow_user_access(void __user *to, const void __user *from,
+                                    unsigned long size) { }
+static inline void prevent_user_access(void __user *to, const void __user *from,
+                                      unsigned long size) { }
+
+static inline void allow_read_from_user(const void __user *from, unsigned long size)
+{
+       allow_user_access(NULL, from, size);
+}
+
+static inline void allow_write_to_user(void __user *to, unsigned long size)
+{
+       allow_user_access(to, NULL, size);
+}
+
+static inline void prevent_read_from_user(const void __user *from, unsigned long size)
+{
+       prevent_user_access(NULL, from, size);
+}
+
+static inline void prevent_write_to_user(void __user *to, unsigned long size)
+{
+       prevent_user_access(to, NULL, size);
+}
+
+#endif /* !__ASSEMBLY__ */
+
+#endif /* _ASM_POWERPC_KUP_H_ */

diff --git a/arch/powerpc/include/asm/uaccess.h b/arch/powerpc/include/asm/uaccess.h
index e51ce5a0e22148d6927d852669d4763fadf9b6a5..50d3c953b33e745114ef954c1a9cb8d02113e68a 100644 (file)
--- a/arch/powerpc/include/asm/uaccess.h
+++ b/arch/powerpc/include/asm/uaccess.h
@@ -9,6 +9,7 @@
 #include <asm/asm-compat.h>
 #include <asm/processor.h>
 #include <asm/page.h>
+#include <asm/kup.h>
 
 #define VERIFY_READ    0
 #define VERIFY_WRITE   1
@@ -164,6 +165,7 @@ extern long __put_user_bad(void);
 #define __put_user_size(x, ptr, size, retval)                  \
 do {                                                           \
        retval = 0;                                             \
+       allow_write_to_user(ptr, size);                         \
        switch (size) {                                         \
          case 1: __put_user_asm(x, ptr, retval, "stb"); break; \
          case 2: __put_user_asm(x, ptr, retval, "sth"); break; \
@@ -171,6 +173,7 @@ do {                                                                \
          case 8: __put_user_asm2(x, ptr, retval); break;       \
          default: __put_user_bad();                            \
        }                                                       \
+       prevent_write_to_user(ptr, size);                       \
 } while (0)
 
 #define __put_user_nocheck(x, ptr, size)                       \
@@ -252,6 +255,7 @@ do {                                                                \
        __chk_user_ptr(ptr);                                    \
        if (size > sizeof(x))                                   \
                (x) = __get_user_bad();                         \
+       allow_read_from_user(ptr, size);                        \
        switch (size) {                                         \
        case 1: __get_user_asm(x, ptr, retval, "lbz"); break;   \
        case 2: __get_user_asm(x, ptr, retval, "lhz"); break;   \
@@ -259,6 +263,7 @@ do {                                                                \
        case 8: __get_user_asm2(x, ptr, retval);  break;        \
        default: (x) = __get_user_bad();                        \
        }                                                       \
+       prevent_read_from_user(ptr, size);                      \
 } while (0)
 
 #define __get_user_nocheck(x, ptr, size)                       \
@@ -328,9 +333,14 @@ extern unsigned long __copy_tofrom_user(void __user *to,
 static inline unsigned long copy_from_user(void *to,
                const void __user *from, unsigned long n)
 {
+       unsigned long ret;
+
        if (likely(access_ok(VERIFY_READ, from, n))) {
+               allow_user_access(to, from, n);
                barrier_nospec();
-               return __copy_tofrom_user((__force void __user *)to, from, n);
+               ret = __copy_tofrom_user((__force void __user *)to, from, n);
+               prevent_user_access(to, from, n);
+               return ret;
        }
        memset(to, 0, n);
        return n;
@@ -361,8 +371,9 @@ extern unsigned long copy_in_user(void __user *to, const void __user *from,
 static inline unsigned long __copy_from_user_inatomic(void *to,
                const void __user *from, unsigned long n)
 {
+       unsigned long ret;
        if (__builtin_constant_p(n) && (n <= 8)) {
-               unsigned long ret = 1;
+               ret = 1;
 
                switch (n) {
                case 1:
@@ -387,14 +398,18 @@ static inline unsigned long __copy_from_user_inatomic(void *to,
        }
 
        barrier_nospec();
-       return __copy_tofrom_user((__force void __user *)to, from, n);
+       allow_read_from_user(from, n);
+       ret = __copy_tofrom_user((__force void __user *)to, from, n);
+       prevent_read_from_user(from, n);
+       return ret;
 }
 
 static inline unsigned long __copy_to_user_inatomic(void __user *to,
                const void *from, unsigned long n)
 {
+       unsigned long ret;
        if (__builtin_constant_p(n) && (n <= 8)) {
-               unsigned long ret = 1;
+               ret = 1;
 
                switch (n) {
                case 1:
@@ -414,7 +429,10 @@ static inline unsigned long __copy_to_user_inatomic(void __user *to,
                        return 0;
        }
 
-       return __copy_tofrom_user(to, (__force const void __user *)from, n);
+       allow_write_to_user(to, n);
+       ret = __copy_tofrom_user(to, (__force const void __user *)from, n);
+       prevent_write_to_user(to, n);
+       return ret;
 }
 
 static inline unsigned long __copy_from_user(void *to,
@@ -435,10 +453,14 @@ extern unsigned long __clear_user(void __user *addr, unsigned long size);
 
 static inline unsigned long clear_user(void __user *addr, unsigned long size)
 {
+       unsigned long ret = size;
        might_fault();
-       if (likely(access_ok(VERIFY_WRITE, addr, size)))
-               return __clear_user(addr, size);
-       return size;
+       if (likely(access_ok(VERIFY_WRITE, addr, size))) {
+               allow_write_to_user(addr, size);
+               ret = __clear_user(addr, size);
+               prevent_write_to_user(addr, size);
+       }
+       return ret;
 }
 
 extern long strncpy_from_user(char *dst, const char __user *src, long count);

diff --git a/arch/powerpc/lib/checksum_wrappers_64.c b/arch/powerpc/lib/checksum_wrappers_64.c
index 08e3a3356c402f02145ef3f3c55a9627fb2cda1c..11b58949eb62830e5981d32c6daa85660c993ae7 100644 (file)
--- a/arch/powerpc/lib/checksum_wrappers_64.c
+++ b/arch/powerpc/lib/checksum_wrappers_64.c
@@ -29,6 +29,7 @@ __wsum csum_and_copy_from_user(const void __user *src, void *dst,
        unsigned int csum;
 
        might_sleep();
+       allow_read_from_user(src, len);
 
        *err_ptr = 0;
 
@@ -60,6 +61,7 @@ __wsum csum_and_copy_from_user(const void __user *src, void *dst,
        }
 
 out:
+       prevent_read_from_user(src, len);
        return (__force __wsum)csum;
 }
 EXPORT_SYMBOL(csum_and_copy_from_user);
@@ -70,6 +72,7 @@ __wsum csum_and_copy_to_user(const void *src, void __user *dst, int len,
        unsigned int csum;
 
        might_sleep();
+       allow_write_to_user(dst, len);
 
        *err_ptr = 0;
 
@@ -97,6 +100,7 @@ __wsum csum_and_copy_to_user(const void *src, void __user *dst, int len,
        }
 
 out:
+       prevent_write_to_user(dst, len);
        return (__force __wsum)csum;
 }
 EXPORT_SYMBOL(csum_and_copy_to_user);