arch/sh/include/asm/uaccess.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __ASM_SH_UACCESS_H
   3 #define __ASM_SH_UACCESS_H
   4
   5 #include <asm/segment.h>
   6 #include <asm/extable.h>
   7
   8 #define __addr_ok(addr) \
   9         ((unsigned long __force)(addr) < current_thread_info()->addr_limit.seg)
  10
  11 /*
  12  * __access_ok: Check if address with size is OK or not.
  13  *
  14  * Uhhuh, this needs 33-bit arithmetic. We have a carry..
  15  *
  16  * sum := addr + size;  carry? --> flag = true;
  17  * if (sum >= addr_limit) flag = true;
  18  */
  19 #define __access_ok(addr, size)         \
  20         (__addr_ok((addr) + (size)))
  21 #define access_ok(type, addr, size)     \
  22         (__chk_user_ptr(addr),          \
  23          __access_ok((unsigned long __force)(addr), (size)))
  24
  25 #define user_addr_max() (current_thread_info()->addr_limit.seg)
  26
  27 /*
  28  * Uh, these should become the main single-value transfer routines ...
  29  * They automatically use the right size if we just have the right
  30  * pointer type ...
  31  *
  32  * As SuperH uses the same address space for kernel and user data, we
  33  * can just do these as direct assignments.
  34  *
  35  * Careful to not
  36  * (a) re-use the arguments for side effects (sizeof is ok)
  37  * (b) require any knowledge of processes at this stage
  38  */
  39 #define put_user(x,ptr)         __put_user_check((x), (ptr), sizeof(*(ptr)))
  40 #define get_user(x,ptr)         __get_user_check((x), (ptr), sizeof(*(ptr)))
  41
  42 /*
  43  * The "__xxx" versions do not do address space checking, useful when
  44  * doing multiple accesses to the same area (the user has to do the
  45  * checks by hand with "access_ok()")
  46  */
  47 #define __put_user(x,ptr)       __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
  48 #define __get_user(x,ptr)       __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
  49
  50 struct __large_struct { unsigned long buf[100]; };
  51 #define __m(x) (*(struct __large_struct __user *)(x))
  52
  53 #define __get_user_nocheck(x,ptr,size)                          \
  54 ({                                                              \
  55         long __gu_err;                                          \
  56         unsigned long __gu_val;                                 \
  57         const __typeof__(*(ptr)) __user *__gu_addr = (ptr);     \
  58         __chk_user_ptr(ptr);                                    \
  59         __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
  60         (x) = (__force __typeof__(*(ptr)))__gu_val;             \
  61         __gu_err;                                               \
  62 })
  63
  64 #define __get_user_check(x,ptr,size)                                    \
  65 ({                                                                      \
  66         long __gu_err = -EFAULT;                                        \
  67         unsigned long __gu_val = 0;                                     \
  68         const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
  69         if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))          \
  70                 __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
  71         (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
  72         __gu_err;                                                       \
  73 })
  74
  75 #define __put_user_nocheck(x,ptr,size)                          \
  76 ({                                                              \
  77         long __pu_err;                                          \
  78         __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
  79         __typeof__(*(ptr)) __pu_val = x;                        \
  80         __chk_user_ptr(ptr);                                    \
  81         __put_user_size(__pu_val, __pu_addr, (size), __pu_err); \
  82         __pu_err;                                               \
  83 })
  84
  85 #define __put_user_check(x,ptr,size)                            \
  86 ({                                                              \
  87         long __pu_err = -EFAULT;                                \
  88         __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
  89         __typeof__(*(ptr)) __pu_val = x;                        \
  90         if (likely(access_ok(VERIFY_WRITE, __pu_addr, size)))   \
  91                 __put_user_size(__pu_val, __pu_addr, (size),    \
  92                                 __pu_err);                      \
  93         __pu_err;                                               \
  94 })
  95
  96 #ifdef CONFIG_SUPERH32
  97 # include <asm/uaccess_32.h>
  98 #else
  99 # include <asm/uaccess_64.h>
 100 #endif
 101
 102 extern long strncpy_from_user(char *dest, const char __user *src, long count);
 103
 104 extern __must_check long strnlen_user(const char __user *str, long n);
 105
 106 /* Generic arbitrary sized copy.  */
 107 /* Return the number of bytes NOT copied */
 108 __kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);
 109
 110 static __always_inline unsigned long
 111 raw_copy_from_user(void *to, const void __user *from, unsigned long n)
 112 {
 113         return __copy_user(to, (__force void *)from, n);
 114 }
 115
 116 static __always_inline unsigned long __must_check
 117 raw_copy_to_user(void __user *to, const void *from, unsigned long n)
 118 {
 119         return __copy_user((__force void *)to, from, n);
 120 }
 121 #define INLINE_COPY_FROM_USER
 122 #define INLINE_COPY_TO_USER
 123
 124 /*
 125  * Clear the area and return remaining number of bytes
 126  * (on failure.  Usually it's 0.)
 127  */
 128 __kernel_size_t __clear_user(void *addr, __kernel_size_t size);
 129
 130 #define clear_user(addr,n)                                              \
 131 ({                                                                      \
 132         void __user * __cl_addr = (addr);                               \
 133         unsigned long __cl_size = (n);                                  \
 134                                                                         \
 135         if (__cl_size && access_ok(VERIFY_WRITE,                        \
 136                 ((unsigned long)(__cl_addr)), __cl_size))               \
 137                 __cl_size = __clear_user(__cl_addr, __cl_size);         \
 138                                                                         \
 139         __cl_size;                                                      \
 140 })
 141
 142 extern void *set_exception_table_vec(unsigned int vec, void *handler);
 143
 144 static inline void *set_exception_table_evt(unsigned int evt, void *handler)
 145 {
 146         return set_exception_table_vec(evt >> 5, handler);
 147 }
 148
 149 struct mem_access {
 150         unsigned long (*from)(void *dst, const void __user *src, unsigned long cnt);
 151         unsigned long (*to)(void __user *dst, const void *src, unsigned long cnt);
 152 };
 153
 154 int handle_unaligned_access(insn_size_t instruction, struct pt_regs *regs,
 155                             struct mem_access *ma, int, unsigned long address);
 156
 157 #endif /* __ASM_SH_UACCESS_H */