arch/sh/include/asm/uaccess.h

   1 #ifndef __ASM_SH_UACCESS_H
   2 #define __ASM_SH_UACCESS_H
   3
   4 #include <asm/segment.h>
   5 #include <asm/extable.h>
   6
   7 #define __addr_ok(addr) \
   8         ((unsigned long __force)(addr) < current_thread_info()->addr_limit.seg)
   9
  10 /*
  11  * __access_ok: Check if address with size is OK or not.
  12  *
  13  * Uhhuh, this needs 33-bit arithmetic. We have a carry..
  14  *
  15  * sum := addr + size;  carry? --> flag = true;
  16  * if (sum >= addr_limit) flag = true;
  17  */
  18 #define __access_ok(addr, size)         \
  19         (__addr_ok((addr) + (size)))
  20 #define access_ok(type, addr, size)     \
  21         (__chk_user_ptr(addr),          \
  22          __access_ok((unsigned long __force)(addr), (size)))
  23
  24 #define user_addr_max() (current_thread_info()->addr_limit.seg)
  25
  26 /*
  27  * Uh, these should become the main single-value transfer routines ...
  28  * They automatically use the right size if we just have the right
  29  * pointer type ...
  30  *
  31  * As SuperH uses the same address space for kernel and user data, we
  32  * can just do these as direct assignments.
  33  *
  34  * Careful to not
  35  * (a) re-use the arguments for side effects (sizeof is ok)
  36  * (b) require any knowledge of processes at this stage
  37  */
  38 #define put_user(x,ptr)         __put_user_check((x), (ptr), sizeof(*(ptr)))
  39 #define get_user(x,ptr)         __get_user_check((x), (ptr), sizeof(*(ptr)))
  40
  41 /*
  42  * The "__xxx" versions do not do address space checking, useful when
  43  * doing multiple accesses to the same area (the user has to do the
  44  * checks by hand with "access_ok()")
  45  */
  46 #define __put_user(x,ptr)       __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
  47 #define __get_user(x,ptr)       __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
  48
  49 struct __large_struct { unsigned long buf[100]; };
  50 #define __m(x) (*(struct __large_struct __user *)(x))
  51
  52 #define __get_user_nocheck(x,ptr,size)                          \
  53 ({                                                              \
  54         long __gu_err;                                          \
  55         unsigned long __gu_val;                                 \
  56         const __typeof__(*(ptr)) __user *__gu_addr = (ptr);     \
  57         __chk_user_ptr(ptr);                                    \
  58         __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
  59         (x) = (__force __typeof__(*(ptr)))__gu_val;             \
  60         __gu_err;                                               \
  61 })
  62
  63 #define __get_user_check(x,ptr,size)                                    \
  64 ({                                                                      \
  65         long __gu_err = -EFAULT;                                        \
  66         unsigned long __gu_val = 0;                                     \
  67         const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
  68         if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))          \
  69                 __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
  70         (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
  71         __gu_err;                                                       \
  72 })
  73
  74 #define __put_user_nocheck(x,ptr,size)                          \
  75 ({                                                              \
  76         long __pu_err;                                          \
  77         __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
  78         __typeof__(*(ptr)) __pu_val = x;                        \
  79         __chk_user_ptr(ptr);                                    \
  80         __put_user_size(__pu_val, __pu_addr, (size), __pu_err); \
  81         __pu_err;                                               \
  82 })
  83
  84 #define __put_user_check(x,ptr,size)                            \
  85 ({                                                              \
  86         long __pu_err = -EFAULT;                                \
  87         __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
  88         __typeof__(*(ptr)) __pu_val = x;                        \
  89         if (likely(access_ok(VERIFY_WRITE, __pu_addr, size)))   \
  90                 __put_user_size(__pu_val, __pu_addr, (size),    \
  91                                 __pu_err);                      \
  92         __pu_err;                                               \
  93 })
  94
  95 #ifdef CONFIG_SUPERH32
  96 # include <asm/uaccess_32.h>
  97 #else
  98 # include <asm/uaccess_64.h>
  99 #endif
 100
 101 extern long strncpy_from_user(char *dest, const char __user *src, long count);
 102
 103 extern __must_check long strlen_user(const char __user *str);
 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 */