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