arch/sh/include/asm/uaccess.h

   1 #ifndef __ASM_SH_UACCESS_H
   2 #define __ASM_SH_UACCESS_H
   3
   4 #include <linux/errno.h>
   5 #include <linux/sched.h>
   6 #include <asm/segment.h>
   7
   8 #define VERIFY_READ    0
   9 #define VERIFY_WRITE   1
  10
  11 #define __addr_ok(addr) \
  12         ((unsigned long __force)(addr) < current_thread_info()->addr_limit.seg)
  13
  14 /*
  15  * __access_ok: Check if address with size is OK or not.
  16  *
  17  * Uhhuh, this needs 33-bit arithmetic. We have a carry..
  18  *
  19  * sum := addr + size;  carry? --> flag = true;
  20  * if (sum >= addr_limit) flag = true;
  21  */
  22 #define __access_ok(addr, size)         \
  23         (__addr_ok((addr) + (size)))
  24 #define access_ok(type, addr, size)     \
  25         (__chk_user_ptr(addr),          \
  26          __access_ok((unsigned long __force)(addr), (size)))
  27
  28 #define user_addr_max() (current_thread_info()->addr_limit.seg)
  29
  30 /*
  31  * Uh, these should become the main single-value transfer routines ...
  32  * They automatically use the right size if we just have the right
  33  * pointer type ...
  34  *
  35  * As SuperH uses the same address space for kernel and user data, we
  36  * can just do these as direct assignments.
  37  *
  38  * Careful to not
  39  * (a) re-use the arguments for side effects (sizeof is ok)
  40  * (b) require any knowledge of processes at this stage
  41  */
  42 #define put_user(x,ptr)         __put_user_check((x), (ptr), sizeof(*(ptr)))
  43 #define get_user(x,ptr)         __get_user_check((x), (ptr), sizeof(*(ptr)))
  44
  45 /*
  46  * The "__xxx" versions do not do address space checking, useful when
  47  * doing multiple accesses to the same area (the user has to do the
  48  * checks by hand with "access_ok()")
  49  */
  50 #define __put_user(x,ptr)       __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
  51 #define __get_user(x,ptr)       __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
  52
  53 struct __large_struct { unsigned long buf[100]; };
  54 #define __m(x) (*(struct __large_struct __user *)(x))
  55
  56 #define __get_user_nocheck(x,ptr,size)                          \
  57 ({                                                              \
  58         long __gu_err;                                          \
  59         unsigned long __gu_val;                                 \
  60         const __typeof__(*(ptr)) __user *__gu_addr = (ptr);     \
  61         __chk_user_ptr(ptr);                                    \
  62         __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
  63         (x) = (__typeof__(*(ptr)))__gu_val;                     \
  64         __gu_err;                                               \
  65 })
  66
  67 #define __get_user_check(x,ptr,size)                                    \
  68 ({                                                                      \
  69         long __gu_err = -EFAULT;                                        \
  70         unsigned long __gu_val = 0;                                     \
  71         const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
  72         if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))          \
  73                 __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
  74         (x) = (__typeof__(*(ptr)))__gu_val;                             \
  75         __gu_err;                                                       \
  76 })
  77
  78 #define __put_user_nocheck(x,ptr,size)                          \
  79 ({                                                              \
  80         long __pu_err;                                          \
  81         __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
  82         __typeof__(*(ptr)) __pu_val = x;                        \
  83         __chk_user_ptr(ptr);                                    \
  84         __put_user_size(__pu_val, __pu_addr, (size), __pu_err); \
  85         __pu_err;                                               \
  86 })
  87
  88 #define __put_user_check(x,ptr,size)                            \
  89 ({                                                              \
  90         long __pu_err = -EFAULT;                                \
  91         __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
  92         __typeof__(*(ptr)) __pu_val = x;                        \
  93         if (likely(access_ok(VERIFY_WRITE, __pu_addr, size)))   \
  94                 __put_user_size(__pu_val, __pu_addr, (size),    \
  95                                 __pu_err);                      \
  96         __pu_err;                                               \
  97 })
  98
  99 #ifdef CONFIG_SUPERH32
 100 # include "uaccess_32.h"
 101 #else
 102 # include "uaccess_64.h"
 103 #endif
 104
 105 extern long strncpy_from_user(char *dest, const char __user *src, long count);
 106
 107 /* Generic arbitrary sized copy.  */
 108 /* Return the number of bytes NOT copied */
 109 __kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);
 110
 111 static __always_inline unsigned long
 112 __copy_from_user(void *to, const void __user *from, unsigned long n)
 113 {
 114         return __copy_user(to, (__force void *)from, n);
 115 }
 116
 117 static __always_inline unsigned long __must_check
 118 __copy_to_user(void __user *to, const void *from, unsigned long n)
 119 {
 120         return __copy_user((__force void *)to, from, n);
 121 }
 122
 123 #define __copy_to_user_inatomic __copy_to_user
 124 #define __copy_from_user_inatomic __copy_from_user
 125
 126 /*
 127  * Clear the area and return remaining number of bytes
 128  * (on failure.  Usually it's 0.)
 129  */
 130 __kernel_size_t __clear_user(void *addr, __kernel_size_t size);
 131
 132 #define clear_user(addr,n)                                              \
 133 ({                                                                      \
 134         void __user * __cl_addr = (addr);                               \
 135         unsigned long __cl_size = (n);                                  \
 136                                                                         \
 137         if (__cl_size && access_ok(VERIFY_WRITE,                        \
 138                 ((unsigned long)(__cl_addr)), __cl_size))               \
 139                 __cl_size = __clear_user(__cl_addr, __cl_size);         \
 140                                                                         \
 141         __cl_size;                                                      \
 142 })
 143
 144 static inline unsigned long
 145 copy_from_user(void *to, const void __user *from, unsigned long n)
 146 {
 147         unsigned long __copy_from = (unsigned long) from;
 148         __kernel_size_t __copy_size = (__kernel_size_t) n;
 149
 150         if (__copy_size && __access_ok(__copy_from, __copy_size))
 151                 return __copy_user(to, from, __copy_size);
 152
 153         return __copy_size;
 154 }
 155
 156 static inline unsigned long
 157 copy_to_user(void __user *to, const void *from, unsigned long n)
 158 {
 159         unsigned long __copy_to = (unsigned long) to;
 160         __kernel_size_t __copy_size = (__kernel_size_t) n;
 161
 162         if (__copy_size && __access_ok(__copy_to, __copy_size))
 163                 return __copy_user(to, from, __copy_size);
 164
 165         return __copy_size;
 166 }
 167
 168 /**
 169  * strnlen_user: - Get the size of a string in user space.
 170  * @s: The string to measure.
 171  * @n: The maximum valid length
 172  *
 173  * Context: User context only.  This function may sleep.
 174  *
 175  * Get the size of a NUL-terminated string in user space.
 176  *
 177  * Returns the size of the string INCLUDING the terminating NUL.
 178  * On exception, returns 0.
 179  * If the string is too long, returns a value greater than @n.
 180  */
 181 static inline long strnlen_user(const char __user *s, long n)
 182 {
 183         if (!__addr_ok(s))
 184                 return 0;
 185         else
 186                 return __strnlen_user(s, n);
 187 }
 188
 189 /**
 190  * strlen_user: - Get the size of a string in user space.
 191  * @str: The string to measure.
 192  *
 193  * Context: User context only.  This function may sleep.
 194  *
 195  * Get the size of a NUL-terminated string in user space.
 196  *
 197  * Returns the size of the string INCLUDING the terminating NUL.
 198  * On exception, returns 0.
 199  *
 200  * If there is a limit on the length of a valid string, you may wish to
 201  * consider using strnlen_user() instead.
 202  */
 203 #define strlen_user(str)        strnlen_user(str, ~0UL >> 1)
 204
 205 /*
 206  * The exception table consists of pairs of addresses: the first is the
 207  * address of an instruction that is allowed to fault, and the second is
 208  * the address at which the program should continue.  No registers are
 209  * modified, so it is entirely up to the continuation code to figure out
 210  * what to do.
 211  *
 212  * All the routines below use bits of fixup code that are out of line
 213  * with the main instruction path.  This means when everything is well,
 214  * we don't even have to jump over them.  Further, they do not intrude
 215  * on our cache or tlb entries.
 216  */
 217 struct exception_table_entry {
 218         unsigned long insn, fixup;
 219 };
 220
 221 #if defined(CONFIG_SUPERH64) && defined(CONFIG_MMU)
 222 #define ARCH_HAS_SEARCH_EXTABLE
 223 #endif
 224
 225 int fixup_exception(struct pt_regs *regs);
 226 /* Returns 0 if exception not found and fixup.unit otherwise.  */
 227 unsigned long search_exception_table(unsigned long addr);
 228 const struct exception_table_entry *search_exception_tables(unsigned long addr);
 229
 230 extern void *set_exception_table_vec(unsigned int vec, void *handler);
 231
 232 static inline void *set_exception_table_evt(unsigned int evt, void *handler)
 233 {
 234         return set_exception_table_vec(evt >> 5, handler);
 235 }
 236
 237 struct mem_access {
 238         unsigned long (*from)(void *dst, const void __user *src, unsigned long cnt);
 239         unsigned long (*to)(void __user *dst, const void *src, unsigned long cnt);
 240 };
 241
 242 int handle_unaligned_access(insn_size_t instruction, struct pt_regs *regs,
 243                             struct mem_access *ma, int, unsigned long address);
 244
 245 #endif /* __ASM_SH_UACCESS_H */