include/asm-cris/uaccess.h

   1 /*
   2  * Authors:    Bjorn Wesen (bjornw@axis.com)
   3  *             Hans-Peter Nilsson (hp@axis.com)
   4  *
   5  * $Log: uaccess.h,v $
   6  * Revision 1.8  2001/10/29 13:01:48  bjornw
   7  * Removed unused variable tmp2 in strnlen_user
   8  *
   9  * Revision 1.7  2001/10/02 12:44:52  hp
  10  * Add support for 64-bit put_user/get_user
  11  *
  12  * Revision 1.6  2001/10/01 14:51:17  bjornw
  13  * Added register prefixes and removed underscores
  14  *
  15  * Revision 1.5  2000/10/25 03:33:21  hp
  16  * - Provide implementation for everything else but get_user and put_user;
  17  *   copying inline to/from user for constant length 0..16, 20, 24, and
  18  *   clearing for 0..4, 8, 12, 16, 20, 24, strncpy_from_user and strnlen_user
  19  *   always inline.
  20  * - Constraints for destination addr in get_user cannot be memory, only reg.
  21  * - Correct labels for PC at expected fault points.
  22  * - Nits with assembly code.
  23  * - Don't use statement expressions without value; use "do {} while (0)".
  24  * - Return correct values from __generic_... functions.
  25  *
  26  * Revision 1.4  2000/09/12 16:28:25  bjornw
  27  * * Removed comments from the get/put user asm code
  28  * * Constrains for destination addr in put_user cannot be memory, only reg
  29  *
  30  * Revision 1.3  2000/09/12 14:30:20  bjornw
  31  * MAX_ADDR_USER does not exist anymore
  32  *
  33  * Revision 1.2  2000/07/13 15:52:48  bjornw
  34  * New user-access functions
  35  *
  36  * Revision 1.1.1.1  2000/07/10 16:32:31  bjornw
  37  * CRIS architecture, working draft
  38  *
  39  *
  40  *
  41  */
  42
  43 /* Asm:s have been tweaked (within the domain of correctness) to give
  44    satisfactory results for "gcc version 2.96 20000427 (experimental)".
  45
  46    Check regularly...
  47
  48    Register $r9 is chosen for temporaries, being a call-clobbered register
  49    first in line to be used (notably for local blocks), not colliding with
  50    parameter registers.  */
  51
  52 #ifndef _CRIS_UACCESS_H
  53 #define _CRIS_UACCESS_H
  54
  55 #ifndef __ASSEMBLY__
  56 #include <linux/sched.h>
  57 #include <linux/errno.h>
  58 #include <asm/processor.h>
  59 #include <asm/page.h>
  60
  61 #define VERIFY_READ     0
  62 #define VERIFY_WRITE    1
  63
  64 /*
  65  * The fs value determines whether argument validity checking should be
  66  * performed or not.  If get_fs() == USER_DS, checking is performed, with
  67  * get_fs() == KERNEL_DS, checking is bypassed.
  68  *
  69  * For historical reasons, these macros are grossly misnamed.
  70  */
  71
  72 #define MAKE_MM_SEG(s)  ((mm_segment_t) { (s) })
  73
  74 /* addr_limit is the maximum accessible address for the task. we misuse
  75  * the KERNEL_DS and USER_DS values to both assign and compare the
  76  * addr_limit values through the equally misnamed get/set_fs macros.
  77  * (see above)
  78  */
  79
  80 #define KERNEL_DS       MAKE_MM_SEG(0xFFFFFFFF)
  81 #define USER_DS         MAKE_MM_SEG(TASK_SIZE)
  82
  83 #define get_ds()        (KERNEL_DS)
  84 #define get_fs()        (current_thread_info()->addr_limit)
  85 #define set_fs(x)       (current_thread_info()->addr_limit = (x))
  86
  87 #define segment_eq(a,b) ((a).seg == (b).seg)
  88
  89 #define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
  90 #define __user_ok(addr,size) (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
  91 #define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size)))
  92 #define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size))
  93
  94 extern inline int verify_area(int type, const void __user * addr, unsigned long size)
  95 {
  96         return access_ok(type,addr,size) ? 0 : -EFAULT;
  97 }
  98
  99
 100 #include <asm/arch/uaccess.h>
 101
 102 /*
 103  * The exception table consists of pairs of addresses: the first is the
 104  * address of an instruction that is allowed to fault, and the second is
 105  * the address at which the program should continue.  No registers are
 106  * modified, so it is entirely up to the continuation code to figure out
 107  * what to do.
 108  *
 109  * All the routines below use bits of fixup code that are out of line
 110  * with the main instruction path.  This means when everything is well,
 111  * we don't even have to jump over them.  Further, they do not intrude
 112  * on our cache or tlb entries.
 113  */
 114
 115 struct exception_table_entry
 116 {
 117         unsigned long insn, fixup;
 118 };
 119
 120 /*
 121  * These are the main single-value transfer routines.  They automatically
 122  * use the right size if we just have the right pointer type.
 123  *
 124  * This gets kind of ugly. We want to return _two_ values in "get_user()"
 125  * and yet we don't want to do any pointers, because that is too much
 126  * of a performance impact. Thus we have a few rather ugly macros here,
 127  * and hide all the ugliness from the user.
 128  *
 129  * The "__xxx" versions of the user access functions are versions that
 130  * do not verify the address space, that must have been done previously
 131  * with a separate "access_ok()" call (this is used when we do multiple
 132  * accesses to the same area of user memory).
 133  *
 134  * As we use the same address space for kernel and user data on
 135  * CRIS, we can just do these as direct assignments.  (Of course, the
 136  * exception handling means that it's no longer "just"...)
 137  */
 138 #define get_user(x,ptr) \
 139   __get_user_check((x),(ptr),sizeof(*(ptr)))
 140 #define put_user(x,ptr) \
 141   __put_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
 142
 143 #define __get_user(x,ptr) \
 144   __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
 145 #define __put_user(x,ptr) \
 146   __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
 147
 148 extern long __put_user_bad(void);
 149
 150 #define __put_user_size(x,ptr,size,retval)                      \
 151 do {                                                            \
 152         retval = 0;                                             \
 153         switch (size) {                                         \
 154           case 1: __put_user_asm(x,ptr,retval,"move.b"); break; \
 155           case 2: __put_user_asm(x,ptr,retval,"move.w"); break; \
 156           case 4: __put_user_asm(x,ptr,retval,"move.d"); break; \
 157           case 8: __put_user_asm_64(x,ptr,retval); break;       \
 158           default: __put_user_bad();                            \
 159         }                                                       \
 160 } while (0)
 161
 162 #define __get_user_size(x,ptr,size,retval)                      \
 163 do {                                                            \
 164         retval = 0;                                             \
 165         switch (size) {                                         \
 166           case 1: __get_user_asm(x,ptr,retval,"move.b"); break; \
 167           case 2: __get_user_asm(x,ptr,retval,"move.w"); break; \
 168           case 4: __get_user_asm(x,ptr,retval,"move.d"); break; \
 169           case 8: __get_user_asm_64(x,ptr,retval); break;       \
 170           default: (x) = __get_user_bad();                      \
 171         }                                                       \
 172 } while (0)
 173
 174 #define __put_user_nocheck(x,ptr,size)                  \
 175 ({                                                      \
 176         long __pu_err;                                  \
 177         __put_user_size((x),(ptr),(size),__pu_err);     \
 178         __pu_err;                                       \
 179 })
 180
 181 #define __put_user_check(x,ptr,size)                            \
 182 ({                                                              \
 183         long __pu_err = -EFAULT;                                \
 184         __typeof__(*(ptr)) *__pu_addr = (ptr);                  \
 185         if (access_ok(VERIFY_WRITE,__pu_addr,size))             \
 186                 __put_user_size((x),__pu_addr,(size),__pu_err); \
 187         __pu_err;                                               \
 188 })
 189
 190 struct __large_struct { unsigned long buf[100]; };
 191 #define __m(x) (*(struct __large_struct *)(x))
 192
 193
 194
 195 #define __get_user_nocheck(x,ptr,size)                          \
 196 ({                                                              \
 197         long __gu_err, __gu_val;                                \
 198         __get_user_size(__gu_val,(ptr),(size),__gu_err);        \
 199         (x) = (__typeof__(*(ptr)))__gu_val;                     \
 200         __gu_err;                                               \
 201 })
 202
 203 #define __get_user_check(x,ptr,size)                                    \
 204 ({                                                                      \
 205         long __gu_err = -EFAULT, __gu_val = 0;                          \
 206         const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
 207         if (access_ok(VERIFY_READ,__gu_addr,size))                      \
 208                 __get_user_size(__gu_val,__gu_addr,(size),__gu_err);    \
 209         (x) = (__typeof__(*(ptr)))__gu_val;                             \
 210         __gu_err;                                                       \
 211 })
 212
 213 extern long __get_user_bad(void);
 214
 215 /* More complex functions.  Most are inline, but some call functions that
 216    live in lib/usercopy.c  */
 217
 218 extern unsigned long __copy_user(void *to, const void *from, unsigned long n);
 219 extern unsigned long __copy_user_zeroing(void *to, const void *from, unsigned long n);
 220 extern unsigned long __do_clear_user(void *to, unsigned long n);
 221
 222 extern inline unsigned long
 223 __generic_copy_to_user(void __user *to, const void *from, unsigned long n)
 224 {
 225         if (access_ok(VERIFY_WRITE, to, n))
 226                 return __copy_user(to,from,n);
 227         return n;
 228 }
 229
 230 extern inline unsigned long
 231 __generic_copy_from_user(void *to, const void __user *from, unsigned long n)
 232 {
 233         if (access_ok(VERIFY_READ, from, n))
 234                 return __copy_user_zeroing(to,from,n);
 235         return n;
 236 }
 237
 238 extern inline unsigned long
 239 __generic_clear_user(void __user *to, unsigned long n)
 240 {
 241         if (access_ok(VERIFY_WRITE, to, n))
 242                 return __do_clear_user(to,n);
 243         return n;
 244 }
 245
 246 extern inline long
 247 __strncpy_from_user(char *dst, const char __user *src, long count)
 248 {
 249         return __do_strncpy_from_user(dst, src, count);
 250 }
 251
 252 extern inline long
 253 strncpy_from_user(char *dst, const char __user *src, long count)
 254 {
 255         long res = -EFAULT;
 256         if (access_ok(VERIFY_READ, src, 1))
 257                 res = __do_strncpy_from_user(dst, src, count);
 258         return res;
 259 }
 260
 261
 262 /* Note that if these expand awfully if made into switch constructs, so
 263    don't do that.  */
 264
 265 extern inline unsigned long
 266 __constant_copy_from_user(void *to, const void __user *from, unsigned long n)
 267 {
 268         unsigned long ret = 0;
 269         if (n == 0)
 270                 ;
 271         else if (n == 1)
 272                 __asm_copy_from_user_1(to, from, ret);
 273         else if (n == 2)
 274                 __asm_copy_from_user_2(to, from, ret);
 275         else if (n == 3)
 276                 __asm_copy_from_user_3(to, from, ret);
 277         else if (n == 4)
 278                 __asm_copy_from_user_4(to, from, ret);
 279         else if (n == 5)
 280                 __asm_copy_from_user_5(to, from, ret);
 281         else if (n == 6)
 282                 __asm_copy_from_user_6(to, from, ret);
 283         else if (n == 7)
 284                 __asm_copy_from_user_7(to, from, ret);
 285         else if (n == 8)
 286                 __asm_copy_from_user_8(to, from, ret);
 287         else if (n == 9)
 288                 __asm_copy_from_user_9(to, from, ret);
 289         else if (n == 10)
 290                 __asm_copy_from_user_10(to, from, ret);
 291         else if (n == 11)
 292                 __asm_copy_from_user_11(to, from, ret);
 293         else if (n == 12)
 294                 __asm_copy_from_user_12(to, from, ret);
 295         else if (n == 13)
 296                 __asm_copy_from_user_13(to, from, ret);
 297         else if (n == 14)
 298                 __asm_copy_from_user_14(to, from, ret);
 299         else if (n == 15)
 300                 __asm_copy_from_user_15(to, from, ret);
 301         else if (n == 16)
 302                 __asm_copy_from_user_16(to, from, ret);
 303         else if (n == 20)
 304                 __asm_copy_from_user_20(to, from, ret);
 305         else if (n == 24)
 306                 __asm_copy_from_user_24(to, from, ret);
 307         else
 308                 ret = __generic_copy_from_user(to, from, n);
 309
 310         return ret;
 311 }
 312
 313 /* Ditto, don't make a switch out of this.  */
 314
 315 extern inline unsigned long
 316 __constant_copy_to_user(void __user *to, const void *from, unsigned long n)
 317 {
 318         unsigned long ret = 0;
 319         if (n == 0)
 320                 ;
 321         else if (n == 1)
 322                 __asm_copy_to_user_1(to, from, ret);
 323         else if (n == 2)
 324                 __asm_copy_to_user_2(to, from, ret);
 325         else if (n == 3)
 326                 __asm_copy_to_user_3(to, from, ret);
 327         else if (n == 4)
 328                 __asm_copy_to_user_4(to, from, ret);
 329         else if (n == 5)
 330                 __asm_copy_to_user_5(to, from, ret);
 331         else if (n == 6)
 332                 __asm_copy_to_user_6(to, from, ret);
 333         else if (n == 7)
 334                 __asm_copy_to_user_7(to, from, ret);
 335         else if (n == 8)
 336                 __asm_copy_to_user_8(to, from, ret);
 337         else if (n == 9)
 338                 __asm_copy_to_user_9(to, from, ret);
 339         else if (n == 10)
 340                 __asm_copy_to_user_10(to, from, ret);
 341         else if (n == 11)
 342                 __asm_copy_to_user_11(to, from, ret);
 343         else if (n == 12)
 344                 __asm_copy_to_user_12(to, from, ret);
 345         else if (n == 13)
 346                 __asm_copy_to_user_13(to, from, ret);
 347         else if (n == 14)
 348                 __asm_copy_to_user_14(to, from, ret);
 349         else if (n == 15)
 350                 __asm_copy_to_user_15(to, from, ret);
 351         else if (n == 16)
 352                 __asm_copy_to_user_16(to, from, ret);
 353         else if (n == 20)
 354                 __asm_copy_to_user_20(to, from, ret);
 355         else if (n == 24)
 356                 __asm_copy_to_user_24(to, from, ret);
 357         else
 358                 ret = __generic_copy_to_user(to, from, n);
 359
 360         return ret;
 361 }
 362
 363 /* No switch, please.  */
 364
 365 extern inline unsigned long
 366 __constant_clear_user(void __user *to, unsigned long n)
 367 {
 368         unsigned long ret = 0;
 369         if (n == 0)
 370                 ;
 371         else if (n == 1)
 372                 __asm_clear_1(to, ret);
 373         else if (n == 2)
 374                 __asm_clear_2(to, ret);
 375         else if (n == 3)
 376                 __asm_clear_3(to, ret);
 377         else if (n == 4)
 378                 __asm_clear_4(to, ret);
 379         else if (n == 8)
 380                 __asm_clear_8(to, ret);
 381         else if (n == 12)
 382                 __asm_clear_12(to, ret);
 383         else if (n == 16)
 384                 __asm_clear_16(to, ret);
 385         else if (n == 20)
 386                 __asm_clear_20(to, ret);
 387         else if (n == 24)
 388                 __asm_clear_24(to, ret);
 389         else
 390                 ret = __generic_clear_user(to, n);
 391
 392         return ret;
 393 }
 394
 395
 396 #define clear_user(to, n)                       \
 397 (__builtin_constant_p(n) ?                      \
 398  __constant_clear_user(to, n) :                 \
 399  __generic_clear_user(to, n))
 400
 401 #define copy_from_user(to, from, n)             \
 402 (__builtin_constant_p(n) ?                      \
 403  __constant_copy_from_user(to, from, n) :       \
 404  __generic_copy_from_user(to, from, n))
 405
 406 #define copy_to_user(to, from, n)               \
 407 (__builtin_constant_p(n) ?                      \
 408  __constant_copy_to_user(to, from, n) :         \
 409  __generic_copy_to_user(to, from, n))
 410
 411 /* We let the __ versions of copy_from/to_user inline, because they're often
 412  * used in fast paths and have only a small space overhead.
 413  */
 414
 415 extern inline unsigned long
 416 __generic_copy_from_user_nocheck(void *to, const void *from, unsigned long n)
 417 {
 418         return __copy_user_zeroing(to,from,n);
 419 }
 420
 421 extern inline unsigned long
 422 __generic_copy_to_user_nocheck(void *to, const void *from, unsigned long n)
 423 {
 424         return __copy_user(to,from,n);
 425 }
 426
 427 extern inline unsigned long
 428 __generic_clear_user_nocheck(void *to, unsigned long n)
 429 {
 430         return __do_clear_user(to,n);
 431 }
 432
 433 /* without checking */
 434
 435 #define __copy_to_user(to,from,n)   __generic_copy_to_user_nocheck((to),(from),(n))
 436 #define __copy_from_user(to,from,n) __generic_copy_from_user_nocheck((to),(from),(n))
 437 #define __clear_user(to,n) __generic_clear_user_nocheck((to),(n))
 438
 439 #define strlen_user(str)        strnlen_user((str), 0x7ffffffe)
 440
 441 #endif  /* __ASSEMBLY__ */
 442
 443 #endif  /* _CRIS_UACCESS_H */