powerpc: Simplify access_ok()

With the implementation of masked user access, we always have a memory
gap between user memory space and kernel memory space, so use it to
simplify access_ok() by relying on access fault in case of an access
in the gap.

Most of the time the size is known at build time.

On powerpc64, the kernel space starts at 0x8000000000000000 which is
always more than two times TASK_USER_MAX so when the size is known at
build time and lower than TASK_USER_MAX, only the address needs to be
verified. If not, a binary or of address and size must be lower than
TASK_USER_MAX. As TASK_USER_MAX is a power of 2, just check that
there is no bit set outside of TASK_USER_MAX - 1 mask.

On powerpc32, there is a garanteed gap of 128KB so when the size is
known at build time and not greater than 128KB, just check that the
address is below TASK_SIZE. Otherwise use the original formula.

Signed-off-by: Christophe Leroy (CS GROUP) <chleroy@kernel.org>
Signed-off-by: Madhavan Srinivasan <maddy@linux.ibm.com>
Link: https://patch.msgid.link/f496ba4f309a2fb9fd0d8811e941bbcaf5d196cf.1780482002.git.chleroy@kernel.org

diff --git a/arch/powerpc/include/asm/uaccess.h b/arch/powerpc/include/asm/uaccess.h
index e98c628e3899384db2d1312ba2772327e084efac..7b8c56962c3111cbab086d2a3fc4241e52169623 100644 (file)
--- a/arch/powerpc/include/asm/uaccess.h
+++ b/arch/powerpc/include/asm/uaccess.h
@@ -18,8 +18,34 @@
 /* Threshold above which VMX copy path is used */
 #define VMX_COPY_THRESHOLD 3328
 
+#define __access_ok __access_ok
+
 #include <asm-generic/access_ok.h>
 
+/*
+ * On powerpc64, TASK_SIZE_MAX is 0x0010000000000000 then even if both ptr and size
+ * are TASK_SIZE_MAX we are still inside the memory gap. So make it simple.
+ */
+static __always_inline int __access_ok(const void __user *ptr, unsigned long size)
+{
+       unsigned long addr = (unsigned long)ptr;
+
+       if (IS_ENABLED(CONFIG_PPC64)) {
+               BUILD_BUG_ON(!is_power_of_2(TASK_SIZE_MAX));
+               BUILD_BUG_ON(TASK_SIZE_MAX > 0x0010000000000000);
+
+               if (statically_true(size > TASK_SIZE_MAX))
+                       return false;
+               if (statically_true(size <= TASK_SIZE_MAX))
+                       return !(addr & ~(TASK_SIZE_MAX - 1));
+               return !((size | addr) & ~(TASK_SIZE_MAX - 1));
+       } else {
+               if (statically_true(size <= SZ_128K))
+                       return addr < TASK_SIZE;
+               return size <= TASK_SIZE && addr <= TASK_SIZE - size;
+       }
+}
+
 /*
  * These are the main single-value transfer routines.  They automatically
  * use the right size if we just have the right pointer type.