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