arch/microblaze/include/asm/uaccess.h

   1 /*
   2  * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
   3  * Copyright (C) 2008-2009 PetaLogix
   4  * Copyright (C) 2006 Atmark Techno, Inc.
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License. See the file "COPYING" in the main directory of this archive
   8  * for more details.
   9  */
  10
  11 #ifndef _ASM_MICROBLAZE_UACCESS_H
  12 #define _ASM_MICROBLAZE_UACCESS_H
  13
  14 #include <linux/kernel.h>
  15 #include <linux/mm.h>
  16
  17 #include <asm/mmu.h>
  18 #include <asm/page.h>
  19 #include <asm/pgtable.h>
  20 #include <asm/extable.h>
  21 #include <linux/string.h>
  22
  23 /*
  24  * On Microblaze the fs value is actually the top of the corresponding
  25  * address space.
  26  *
  27  * The fs value determines whether argument validity checking should be
  28  * performed or not. If get_fs() == USER_DS, checking is performed, with
  29  * get_fs() == KERNEL_DS, checking is bypassed.
  30  *
  31  * For historical reasons, these macros are grossly misnamed.
  32  *
  33  * For non-MMU arch like Microblaze, KERNEL_DS and USER_DS is equal.
  34  */
  35 # define MAKE_MM_SEG(s)       ((mm_segment_t) { (s) })
  36
  37 #  ifndef CONFIG_MMU
  38 #  define KERNEL_DS     MAKE_MM_SEG(0)
  39 #  define USER_DS       KERNEL_DS
  40 #  else
  41 #  define KERNEL_DS     MAKE_MM_SEG(0xFFFFFFFF)
  42 #  define USER_DS       MAKE_MM_SEG(TASK_SIZE - 1)
  43 #  endif
  44
  45 # define get_ds()       (KERNEL_DS)
  46 # define get_fs()       (current_thread_info()->addr_limit)
  47 # define set_fs(val)    (current_thread_info()->addr_limit = (val))
  48
  49 # define segment_eq(a, b)       ((a).seg == (b).seg)
  50
  51 #ifndef CONFIG_MMU
  52
  53 /* Check against bounds of physical memory */
  54 static inline int ___range_ok(unsigned long addr, unsigned long size)
  55 {
  56         return ((addr < memory_start) ||
  57                 ((addr + size - 1) > (memory_start + memory_size - 1)));
  58 }
  59
  60 #define __range_ok(addr, size) \
  61                 ___range_ok((unsigned long)(addr), (unsigned long)(size))
  62
  63 #define access_ok(type, addr, size) (__range_ok((addr), (size)) == 0)
  64
  65 #else
  66
  67 static inline int access_ok(int type, const void __user *addr,
  68                                                         unsigned long size)
  69 {
  70         if (!size)
  71                 goto ok;
  72
  73         if ((get_fs().seg < ((unsigned long)addr)) ||
  74                         (get_fs().seg < ((unsigned long)addr + size - 1))) {
  75                 pr_devel("ACCESS fail: %s at 0x%08x (size 0x%x), seg 0x%08x\n",
  76                         type ? "WRITE" : "READ ", (__force u32)addr, (u32)size,
  77                         (u32)get_fs().seg);
  78                 return 0;
  79         }
  80 ok:
  81         pr_devel("ACCESS OK: %s at 0x%08x (size 0x%x), seg 0x%08x\n",
  82                         type ? "WRITE" : "READ ", (__force u32)addr, (u32)size,
  83                         (u32)get_fs().seg);
  84         return 1;
  85 }
  86 #endif
  87
  88 #ifdef CONFIG_MMU
  89 # define __FIXUP_SECTION        ".section .fixup,\"ax\"\n"
  90 # define __EX_TABLE_SECTION     ".section __ex_table,\"a\"\n"
  91 #else
  92 # define __FIXUP_SECTION        ".section .discard,\"ax\"\n"
  93 # define __EX_TABLE_SECTION     ".section .discard,\"ax\"\n"
  94 #endif
  95
  96 extern unsigned long __copy_tofrom_user(void __user *to,
  97                 const void __user *from, unsigned long size);
  98
  99 /* Return: number of not copied bytes, i.e. 0 if OK or non-zero if fail. */
 100 static inline unsigned long __must_check __clear_user(void __user *to,
 101                                                         unsigned long n)
 102 {
 103         /* normal memset with two words to __ex_table */
 104         __asm__ __volatile__ (                          \
 105                         "1:     sb      r0, %1, r0;"    \
 106                         "       addik   %0, %0, -1;"    \
 107                         "       bneid   %0, 1b;"        \
 108                         "       addik   %1, %1, 1;"     \
 109                         "2:                     "       \
 110                         __EX_TABLE_SECTION              \
 111                         ".word  1b,2b;"                 \
 112                         ".previous;"                    \
 113                 : "=r"(n), "=r"(to)                     \
 114                 : "0"(n), "1"(to)
 115         );
 116         return n;
 117 }
 118
 119 static inline unsigned long __must_check clear_user(void __user *to,
 120                                                         unsigned long n)
 121 {
 122         might_fault();
 123         if (unlikely(!access_ok(VERIFY_WRITE, to, n)))
 124                 return n;
 125
 126         return __clear_user(to, n);
 127 }
 128
 129 /* put_user and get_user macros */
 130 extern long __user_bad(void);
 131
 132 #define __get_user_asm(insn, __gu_ptr, __gu_val, __gu_err)      \
 133 ({                                                              \
 134         __asm__ __volatile__ (                                  \
 135                         "1:"    insn    " %1, %2, r0;"          \
 136                         "       addk    %0, r0, r0;"            \
 137                         "2:                     "               \
 138                         __FIXUP_SECTION                         \
 139                         "3:     brid    2b;"                    \
 140                         "       addik   %0, r0, %3;"            \
 141                         ".previous;"                            \
 142                         __EX_TABLE_SECTION                      \
 143                         ".word  1b,3b;"                         \
 144                         ".previous;"                            \
 145                 : "=&r"(__gu_err), "=r"(__gu_val)               \
 146                 : "r"(__gu_ptr), "i"(-EFAULT)                   \
 147         );                                                      \
 148 })
 149
 150 /**
 151  * get_user: - Get a simple variable from user space.
 152  * @x:   Variable to store result.
 153  * @ptr: Source address, in user space.
 154  *
 155  * Context: User context only. This function may sleep if pagefaults are
 156  *          enabled.
 157  *
 158  * This macro copies a single simple variable from user space to kernel
 159  * space.  It supports simple types like char and int, but not larger
 160  * data types like structures or arrays.
 161  *
 162  * @ptr must have pointer-to-simple-variable type, and the result of
 163  * dereferencing @ptr must be assignable to @x without a cast.
 164  *
 165  * Returns zero on success, or -EFAULT on error.
 166  * On error, the variable @x is set to zero.
 167  */
 168 #define get_user(x, ptr)                                                \
 169         __get_user_check((x), (ptr), sizeof(*(ptr)))
 170
 171 #define __get_user_check(x, ptr, size)                                  \
 172 ({                                                                      \
 173         unsigned long __gu_val = 0;                                     \
 174         const typeof(*(ptr)) __user *__gu_addr = (ptr);                 \
 175         int __gu_err = 0;                                               \
 176                                                                         \
 177         if (access_ok(VERIFY_READ, __gu_addr, size)) {                  \
 178                 switch (size) {                                         \
 179                 case 1:                                                 \
 180                         __get_user_asm("lbu", __gu_addr, __gu_val,      \
 181                                        __gu_err);                       \
 182                         break;                                          \
 183                 case 2:                                                 \
 184                         __get_user_asm("lhu", __gu_addr, __gu_val,      \
 185                                        __gu_err);                       \
 186                         break;                                          \
 187                 case 4:                                                 \
 188                         __get_user_asm("lw", __gu_addr, __gu_val,       \
 189                                        __gu_err);                       \
 190                         break;                                          \
 191                 default:                                                \
 192                         __gu_err = __user_bad();                        \
 193                         break;                                          \
 194                 }                                                       \
 195         } else {                                                        \
 196                 __gu_err = -EFAULT;                                     \
 197         }                                                               \
 198         x = (__force typeof(*(ptr)))__gu_val;                           \
 199         __gu_err;                                                       \
 200 })
 201
 202 #define __get_user(x, ptr)                                              \
 203 ({                                                                      \
 204         unsigned long __gu_val = 0;                                     \
 205         /*unsigned long __gu_ptr = (unsigned long)(ptr);*/              \
 206         long __gu_err;                                                  \
 207         switch (sizeof(*(ptr))) {                                       \
 208         case 1:                                                         \
 209                 __get_user_asm("lbu", (ptr), __gu_val, __gu_err);       \
 210                 break;                                                  \
 211         case 2:                                                         \
 212                 __get_user_asm("lhu", (ptr), __gu_val, __gu_err);       \
 213                 break;                                                  \
 214         case 4:                                                         \
 215                 __get_user_asm("lw", (ptr), __gu_val, __gu_err);        \
 216                 break;                                                  \
 217         default:                                                        \
 218                 /* __gu_val = 0; __gu_err = -EINVAL;*/ __gu_err = __user_bad();\
 219         }                                                               \
 220         x = (__force __typeof__(*(ptr))) __gu_val;                      \
 221         __gu_err;                                                       \
 222 })
 223
 224
 225 #define __put_user_asm(insn, __gu_ptr, __gu_val, __gu_err)      \
 226 ({                                                              \
 227         __asm__ __volatile__ (                                  \
 228                         "1:"    insn    " %1, %2, r0;"          \
 229                         "       addk    %0, r0, r0;"            \
 230                         "2:                     "               \
 231                         __FIXUP_SECTION                         \
 232                         "3:     brid    2b;"                    \
 233                         "       addik   %0, r0, %3;"            \
 234                         ".previous;"                            \
 235                         __EX_TABLE_SECTION                      \
 236                         ".word  1b,3b;"                         \
 237                         ".previous;"                            \
 238                 : "=&r"(__gu_err)                               \
 239                 : "r"(__gu_val), "r"(__gu_ptr), "i"(-EFAULT)    \
 240         );                                                      \
 241 })
 242
 243 #define __put_user_asm_8(__gu_ptr, __gu_val, __gu_err)          \
 244 ({                                                              \
 245         __asm__ __volatile__ (" lwi     %0, %1, 0;"             \
 246                         "1:     swi     %0, %2, 0;"             \
 247                         "       lwi     %0, %1, 4;"             \
 248                         "2:     swi     %0, %2, 4;"             \
 249                         "       addk    %0, r0, r0;"            \
 250                         "3:                     "               \
 251                         __FIXUP_SECTION                         \
 252                         "4:     brid    3b;"                    \
 253                         "       addik   %0, r0, %3;"            \
 254                         ".previous;"                            \
 255                         __EX_TABLE_SECTION                      \
 256                         ".word  1b,4b,2b,4b;"                   \
 257                         ".previous;"                            \
 258                 : "=&r"(__gu_err)                               \
 259                 : "r"(&__gu_val), "r"(__gu_ptr), "i"(-EFAULT)   \
 260                 );                                              \
 261 })
 262
 263 /**
 264  * put_user: - Write a simple value into user space.
 265  * @x:   Value to copy to user space.
 266  * @ptr: Destination address, in user space.
 267  *
 268  * Context: User context only. This function may sleep if pagefaults are
 269  *          enabled.
 270  *
 271  * This macro copies a single simple value from kernel space to user
 272  * space.  It supports simple types like char and int, but not larger
 273  * data types like structures or arrays.
 274  *
 275  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
 276  * to the result of dereferencing @ptr.
 277  *
 278  * Returns zero on success, or -EFAULT on error.
 279  */
 280 #define put_user(x, ptr)                                                \
 281         __put_user_check((x), (ptr), sizeof(*(ptr)))
 282
 283 #define __put_user_check(x, ptr, size)                                  \
 284 ({                                                                      \
 285         typeof(*(ptr)) volatile __pu_val = x;                           \
 286         typeof(*(ptr)) __user *__pu_addr = (ptr);                       \
 287         int __pu_err = 0;                                               \
 288                                                                         \
 289         if (access_ok(VERIFY_WRITE, __pu_addr, size)) {                 \
 290                 switch (size) {                                         \
 291                 case 1:                                                 \
 292                         __put_user_asm("sb", __pu_addr, __pu_val,       \
 293                                        __pu_err);                       \
 294                         break;                                          \
 295                 case 2:                                                 \
 296                         __put_user_asm("sh", __pu_addr, __pu_val,       \
 297                                        __pu_err);                       \
 298                         break;                                          \
 299                 case 4:                                                 \
 300                         __put_user_asm("sw", __pu_addr, __pu_val,       \
 301                                        __pu_err);                       \
 302                         break;                                          \
 303                 case 8:                                                 \
 304                         __put_user_asm_8(__pu_addr, __pu_val, __pu_err);\
 305                         break;                                          \
 306                 default:                                                \
 307                         __pu_err = __user_bad();                        \
 308                         break;                                          \
 309                 }                                                       \
 310         } else {                                                        \
 311                 __pu_err = -EFAULT;                                     \
 312         }                                                               \
 313         __pu_err;                                                       \
 314 })
 315
 316 #define __put_user(x, ptr)                                              \
 317 ({                                                                      \
 318         __typeof__(*(ptr)) volatile __gu_val = (x);                     \
 319         long __gu_err = 0;                                              \
 320         switch (sizeof(__gu_val)) {                                     \
 321         case 1:                                                         \
 322                 __put_user_asm("sb", (ptr), __gu_val, __gu_err);        \
 323                 break;                                                  \
 324         case 2:                                                         \
 325                 __put_user_asm("sh", (ptr), __gu_val, __gu_err);        \
 326                 break;                                                  \
 327         case 4:                                                         \
 328                 __put_user_asm("sw", (ptr), __gu_val, __gu_err);        \
 329                 break;                                                  \
 330         case 8:                                                         \
 331                 __put_user_asm_8((ptr), __gu_val, __gu_err);            \
 332                 break;                                                  \
 333         default:                                                        \
 334                 /*__gu_err = -EINVAL;*/ __gu_err = __user_bad();        \
 335         }                                                               \
 336         __gu_err;                                                       \
 337 })
 338
 339 static inline unsigned long
 340 raw_copy_from_user(void *to, const void __user *from, unsigned long n)
 341 {
 342         return __copy_tofrom_user((__force void __user *)to, from, n);
 343 }
 344
 345 static inline unsigned long
 346 raw_copy_to_user(void __user *to, const void *from, unsigned long n)
 347 {
 348         return __copy_tofrom_user(to, (__force const void __user *)from, n);
 349 }
 350 #define INLINE_COPY_FROM_USER
 351 #define INLINE_COPY_TO_USER
 352
 353 /*
 354  * Copy a null terminated string from userspace.
 355  */
 356 extern int __strncpy_user(char *to, const char __user *from, int len);
 357
 358 static inline long
 359 strncpy_from_user(char *dst, const char __user *src, long count)
 360 {
 361         if (!access_ok(VERIFY_READ, src, 1))
 362                 return -EFAULT;
 363         return __strncpy_user(dst, src, count);
 364 }
 365
 366 /*
 367  * Return the size of a string (including the ending 0)
 368  *
 369  * Return 0 on exception, a value greater than N if too long
 370  */
 371 extern int __strnlen_user(const char __user *sstr, int len);
 372
 373 static inline long strnlen_user(const char __user *src, long n)
 374 {
 375         if (!access_ok(VERIFY_READ, src, 1))
 376                 return 0;
 377         return __strnlen_user(src, n);
 378 }
 379
 380 #endif /* _ASM_MICROBLAZE_UACCESS_H */