home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-xtensa / uaccess.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  14.8 KB  |  533 lines
  1. /*
  2.  * include/asm-xtensa/uaccess.h
  3.  *
  4.  * User space memory access functions
  5.  *
  6.  * These routines provide basic accessing functions to the user memory
  7.  * space for the kernel. This header file provides fuctions such as:
  8.  *
  9.  * This file is subject to the terms and conditions of the GNU General Public
  10.  * License.  See the file "COPYING" in the main directory of this archive
  11.  * for more details.
  12.  *
  13.  * Copyright (C) 2001 - 2005 Tensilica Inc.
  14.  */
  15.  
  16. #ifndef _XTENSA_UACCESS_H
  17. #define _XTENSA_UACCESS_H
  18.  
  19. #include <linux/errno.h>
  20.  
  21. #define VERIFY_READ    0
  22. #define VERIFY_WRITE   1
  23.  
  24. #ifdef __ASSEMBLY__
  25.  
  26. #define _ASMLANGUAGE
  27. #include <asm/current.h>
  28. #include <asm/asm-offsets.h>
  29. #include <asm/processor.h>
  30.  
  31. /*
  32.  * These assembly macros mirror the C macros that follow below.  They
  33.  * should always have identical functionality.  See
  34.  * arch/xtensa/kernel/sys.S for usage.
  35.  */
  36.  
  37. #define KERNEL_DS    0
  38. #define USER_DS        1
  39.  
  40. #define get_ds        (KERNEL_DS)
  41.  
  42. /*
  43.  * get_fs reads current->thread.current_ds into a register.
  44.  * On Entry:
  45.  *     <ad>    anything
  46.  *     <sp>    stack
  47.  * On Exit:
  48.  *     <ad>    contains current->thread.current_ds
  49.  */
  50.     .macro    get_fs    ad, sp
  51.     GET_CURRENT(\ad,\sp)
  52.     l32i    \ad, \ad, THREAD_CURRENT_DS
  53.     .endm
  54.  
  55. /*
  56.  * set_fs sets current->thread.current_ds to some value.
  57.  * On Entry:
  58.  *    <at>    anything (temp register)
  59.  *    <av>    value to write
  60.  *    <sp>    stack
  61.  * On Exit:
  62.  *    <at>    destroyed (actually, current)
  63.  *    <av>    preserved, value to write
  64.  */
  65.     .macro    set_fs    at, av, sp
  66.     GET_CURRENT(\at,\sp)
  67.     s32i    \av, \at, THREAD_CURRENT_DS
  68.     .endm
  69.  
  70. /*
  71.  * kernel_ok determines whether we should bypass addr/size checking.
  72.  * See the equivalent C-macro version below for clarity.
  73.  * On success, kernel_ok branches to a label indicated by parameter
  74.  * <success>.  This implies that the macro falls through to the next
  75.  * insruction on an error.
  76.  *
  77.  * Note that while this macro can be used independently, we designed
  78.  * in for optimal use in the access_ok macro below (i.e., we fall
  79.  * through on error).
  80.  *
  81.  * On Entry:
  82.  *     <at>        anything (temp register)
  83.  *     <success>    label to branch to on success; implies
  84.  *             fall-through macro on error
  85.  *     <sp>        stack pointer
  86.  * On Exit:
  87.  *     <at>        destroyed (actually, current->thread.current_ds)
  88.  */
  89.  
  90. #if ((KERNEL_DS != 0) || (USER_DS == 0))
  91. # error Assembly macro kernel_ok fails
  92. #endif
  93.     .macro    kernel_ok  at, sp, success
  94.     get_fs    \at, \sp
  95.     beqz    \at, \success
  96.     .endm
  97.  
  98. /*
  99.  * user_ok determines whether the access to user-space memory is allowed.
  100.  * See the equivalent C-macro version below for clarity.
  101.  *
  102.  * On error, user_ok branches to a label indicated by parameter
  103.  * <error>.  This implies that the macro falls through to the next
  104.  * instruction on success.
  105.  *
  106.  * Note that while this macro can be used independently, we designed
  107.  * in for optimal use in the access_ok macro below (i.e., we fall
  108.  * through on success).
  109.  *
  110.  * On Entry:
  111.  *     <aa>    register containing memory address
  112.  *     <as>    register containing memory size
  113.  *     <at>    temp register
  114.  *     <error>    label to branch to on error; implies fall-through
  115.  *         macro on success
  116.  * On Exit:
  117.  *     <aa>    preserved
  118.  *     <as>    preserved
  119.  *     <at>    destroyed (actually, (TASK_SIZE + 1 - size))
  120.  */
  121.     .macro    user_ok    aa, as, at, error
  122.     movi    \at, (TASK_SIZE+1)
  123.     bgeu    \as, \at, \error
  124.     sub    \at, \at, \as
  125.     bgeu    \aa, \at, \error
  126.     .endm
  127.  
  128. /*
  129.  * access_ok determines whether a memory access is allowed.  See the
  130.  * equivalent C-macro version below for clarity.
  131.  *
  132.  * On error, access_ok branches to a label indicated by parameter
  133.  * <error>.  This implies that the macro falls through to the next
  134.  * instruction on success.
  135.  *
  136.  * Note that we assume success is the common case, and we optimize the
  137.  * branch fall-through case on success.
  138.  *
  139.  * On Entry:
  140.  *     <aa>    register containing memory address
  141.  *     <as>    register containing memory size
  142.  *     <at>    temp register
  143.  *     <sp>
  144.  *     <error>    label to branch to on error; implies fall-through
  145.  *         macro on success
  146.  * On Exit:
  147.  *     <aa>    preserved
  148.  *     <as>    preserved
  149.  *     <at>    destroyed
  150.  */
  151.     .macro    access_ok  aa, as, at, sp, error
  152.     kernel_ok  \at, \sp, .Laccess_ok_\@
  153.     user_ok    \aa, \as, \at, \error
  154. .Laccess_ok_\@:
  155.     .endm
  156.  
  157. /*
  158.  * verify_area determines whether a memory access is allowed.  It's
  159.  * mostly an unnecessary wrapper for access_ok, but we provide it as a
  160.  * duplicate of the verify_area() C inline function below.  See the
  161.  * equivalent C version below for clarity.
  162.  *
  163.  * On error, verify_area branches to a label indicated by parameter
  164.  * <error>.  This implies that the macro falls through to the next
  165.  * instruction on success.
  166.  *
  167.  * Note that we assume success is the common case, and we optimize the
  168.  * branch fall-through case on success.
  169.  *
  170.  * On Entry:
  171.  *     <aa>    register containing memory address
  172.  *     <as>    register containing memory size
  173.  *     <at>    temp register
  174.  *     <error>    label to branch to on error; implies fall-through
  175.  *         macro on success
  176.  * On Exit:
  177.  *     <aa>    preserved
  178.  *     <as>    preserved
  179.  *     <at>    destroyed
  180.  */
  181.     .macro    verify_area    aa, as, at, sp, error
  182.     access_ok  \at, \aa, \as, \sp, \error
  183.     .endm
  184.  
  185.  
  186. #else /* __ASSEMBLY__ not defined */
  187.  
  188. #include <linux/sched.h>
  189. #include <asm/types.h>
  190.  
  191. /*
  192.  * The fs value determines whether argument validity checking should
  193.  * be performed or not.  If get_fs() == USER_DS, checking is
  194.  * performed, with get_fs() == KERNEL_DS, checking is bypassed.
  195.  *
  196.  * For historical reasons (Data Segment Register?), these macros are
  197.  * grossly misnamed.
  198.  */
  199.  
  200. #define KERNEL_DS    ((mm_segment_t) { 0 })
  201. #define USER_DS        ((mm_segment_t) { 1 })
  202.  
  203. #define get_ds()    (KERNEL_DS)
  204. #define get_fs()    (current->thread.current_ds)
  205. #define set_fs(val)    (current->thread.current_ds = (val))
  206.  
  207. #define segment_eq(a,b)    ((a).seg == (b).seg)
  208.  
  209. #define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
  210. #define __user_ok(addr,size) (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
  211. #define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size)))
  212. #define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size))
  213.  
  214. static inline int verify_area(int type, const void * addr, unsigned long size)
  215. {
  216.     return access_ok(type,addr,size) ? 0 : -EFAULT;
  217. }
  218.  
  219. /*
  220.  * These are the main single-value transfer routines.  They
  221.  * automatically use the right size if we just have the right pointer
  222.  * type.
  223.  *
  224.  * This gets kind of ugly. We want to return _two_ values in
  225.  * "get_user()" and yet we don't want to do any pointers, because that
  226.  * is too much of a performance impact. Thus we have a few rather ugly
  227.  * macros here, and hide all the uglyness from the user.
  228.  *
  229.  * Careful to not
  230.  * (a) re-use the arguments for side effects (sizeof is ok)
  231.  * (b) require any knowledge of processes at this stage
  232.  */
  233. #define put_user(x,ptr)    __put_user_check((x),(ptr),sizeof(*(ptr)))
  234. #define get_user(x,ptr) __get_user_check((x),(ptr),sizeof(*(ptr)))
  235.  
  236. /*
  237.  * The "__xxx" versions of the user access functions are versions that
  238.  * do not verify the address space, that must have been done previously
  239.  * with a separate "access_ok()" call (this is used when we do multiple
  240.  * accesses to the same area of user memory).
  241.  */
  242. #define __put_user(x,ptr) __put_user_nocheck((x),(ptr),sizeof(*(ptr)))
  243. #define __get_user(x,ptr) __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
  244.  
  245.  
  246. extern long __put_user_bad(void);
  247.  
  248. #define __put_user_nocheck(x,ptr,size)            \
  249. ({                            \
  250.     long __pu_err;                    \
  251.     __put_user_size((x),(ptr),(size),__pu_err);    \
  252.     __pu_err;                    \
  253. })
  254.  
  255. #define __put_user_check(x,ptr,size)                \
  256. ({                                \
  257.     long __pu_err = -EFAULT;                \
  258.     __typeof__(*(ptr)) *__pu_addr = (ptr);            \
  259.     if (access_ok(VERIFY_WRITE,__pu_addr,size))        \
  260.         __put_user_size((x),__pu_addr,(size),__pu_err);    \
  261.     __pu_err;                        \
  262. })
  263.  
  264. #define __put_user_size(x,ptr,size,retval)            \
  265. do {                                \
  266.     retval = 0;                        \
  267.     switch (size) {                        \
  268.         case 1: __put_user_asm(x,ptr,retval,1,"s8i");  break;    \
  269.         case 2: __put_user_asm(x,ptr,retval,2,"s16i"); break;   \
  270.         case 4: __put_user_asm(x,ptr,retval,4,"s32i"); break;   \
  271.         case 8: {                        \
  272.              __typeof__(*ptr) __v64 = x;        \
  273.              retval = __copy_to_user(ptr,&__v64,8);    \
  274.              break;                    \
  275.             }                        \
  276.     default: __put_user_bad();                \
  277.     }                            \
  278. } while (0)
  279.  
  280.  
  281. /*
  282.  * Consider a case of a user single load/store would cause both an
  283.  * unaligned exception and an MMU-related exception (unaligned
  284.  * exceptions happen first):
  285.  *
  286.  * User code passes a bad variable ptr to a system call.
  287.  * Kernel tries to access the variable.
  288.  * Unaligned exception occurs.
  289.  * Unaligned exception handler tries to make aligned accesses.
  290.  * Double exception occurs for MMU-related cause (e.g., page not mapped).
  291.  * do_page_fault() thinks the fault address belongs to the kernel, not the
  292.  * user, and panics.
  293.  *
  294.  * The kernel currently prohibits user unaligned accesses.  We use the
  295.  * __check_align_* macros to check for unaligned addresses before
  296.  * accessing user space so we don't crash the kernel.  Both
  297.  * __put_user_asm and __get_user_asm use these alignment macros, so
  298.  * macro-specific labels such as 0f, 1f, %0, %2, and %3 must stay in
  299.  * sync.
  300.  */
  301.  
  302. #define __check_align_1  ""
  303.  
  304. #define __check_align_2                \
  305.     "   _bbci.l %2,  0, 1f        \n"    \
  306.     "   movi    %0, %3        \n"    \
  307.     "   _j      2f            \n"
  308.  
  309. #define __check_align_4                \
  310.     "   _bbsi.l %2,  0, 0f        \n"    \
  311.     "   _bbci.l %2,  1, 1f        \n"    \
  312.     "0: movi    %0, %3        \n"    \
  313.     "   _j      2f            \n"
  314.  
  315.  
  316. /*
  317.  * We don't tell gcc that we are accessing memory, but this is OK
  318.  * because we do not write to any memory gcc knows about, so there
  319.  * are no aliasing issues.
  320.  *
  321.  * WARNING: If you modify this macro at all, verify that the
  322.  * __check_align_* macros still work.
  323.  */
  324. #define __put_user_asm(x, addr, err, align, insn) \
  325.    __asm__ __volatile__(            \
  326.     __check_align_##align            \
  327.     "1: "insn"  %1, %2, 0        \n"    \
  328.     "2:                \n"    \
  329.     "   .section  .fixup,\"ax\"    \n"    \
  330.     "   .align 4            \n"    \
  331.     "4:                \n"    \
  332.     "   .long  2b            \n"    \
  333.     "5:                \n"    \
  334.     "   l32r   %2, 4b        \n"    \
  335.         "   movi   %0, %3        \n"    \
  336.         "   jx     %2            \n"    \
  337.     "   .previous            \n"    \
  338.     "   .section  __ex_table,\"a\"    \n"    \
  339.     "   .long    1b, 5b        \n"    \
  340.     "   .previous"                \
  341.     :"=r" (err)                \
  342.     :"r" ((int)(x)), "r" (addr), "i" (-EFAULT), "0" (err))
  343.  
  344. #define __get_user_nocheck(x,ptr,size)                \
  345. ({                                \
  346.     long __gu_err, __gu_val;                \
  347.     __get_user_size(__gu_val,(ptr),(size),__gu_err);    \
  348.     (x) = (__typeof__(*(ptr)))__gu_val;            \
  349.     __gu_err;                        \
  350. })
  351.  
  352. #define __get_user_check(x,ptr,size)                    \
  353. ({                                    \
  354.     long __gu_err = -EFAULT, __gu_val = 0;                \
  355.     const __typeof__(*(ptr)) *__gu_addr = (ptr);            \
  356.     if (access_ok(VERIFY_READ,__gu_addr,size))            \
  357.         __get_user_size(__gu_val,__gu_addr,(size),__gu_err);    \
  358.     (x) = (__typeof__(*(ptr)))__gu_val;                \
  359.     __gu_err;                            \
  360. })
  361.  
  362. extern long __get_user_bad(void);
  363.  
  364. #define __get_user_size(x,ptr,size,retval)                \
  365. do {                                    \
  366.     retval = 0;                            \
  367.         switch (size) {                            \
  368.           case 1: __get_user_asm(x,ptr,retval,1,"l8ui");  break;    \
  369.           case 2: __get_user_asm(x,ptr,retval,2,"l16ui"); break;    \
  370.           case 4: __get_user_asm(x,ptr,retval,4,"l32i");  break;    \
  371.           case 8: retval = __copy_from_user(&x,ptr,8);    break;    \
  372.           default: (x) = __get_user_bad();                \
  373.         }                                \
  374. } while (0)
  375.  
  376.  
  377. /*
  378.  * WARNING: If you modify this macro at all, verify that the
  379.  * __check_align_* macros still work.
  380.  */
  381. #define __get_user_asm(x, addr, err, align, insn) \
  382.    __asm__ __volatile__(            \
  383.     __check_align_##align            \
  384.     "1: "insn"  %1, %2, 0        \n"    \
  385.     "2:                \n"    \
  386.     "   .section  .fixup,\"ax\"    \n"    \
  387.     "   .align 4            \n"    \
  388.     "4:                \n"    \
  389.     "   .long  2b            \n"    \
  390.     "5:                \n"    \
  391.     "   l32r   %2, 4b        \n"    \
  392.     "   movi   %1, 0        \n"    \
  393.         "   movi   %0, %3        \n"    \
  394.         "   jx     %2            \n"    \
  395.     "   .previous            \n"    \
  396.     "   .section  __ex_table,\"a\"    \n"    \
  397.     "   .long    1b, 5b        \n"    \
  398.     "   .previous"                \
  399.     :"=r" (err), "=r" (x)            \
  400.     :"r" (addr), "i" (-EFAULT), "0" (err))
  401.  
  402.  
  403. /*
  404.  * Copy to/from user space
  405.  */
  406.  
  407. /*
  408.  * We use a generic, arbitrary-sized copy subroutine.  The Xtensa
  409.  * architecture would cause heavy code bloat if we tried to inline
  410.  * these functions and provide __constant_copy_* equivalents like the
  411.  * i386 versions.  __xtensa_copy_user is quite efficient.  See the
  412.  * .fixup section of __xtensa_copy_user for a discussion on the
  413.  * X_zeroing equivalents for Xtensa.
  414.  */
  415.  
  416. extern unsigned __xtensa_copy_user(void *to, const void *from, unsigned n);
  417. #define __copy_user(to,from,size) __xtensa_copy_user(to,from,size)
  418.  
  419.  
  420. static inline unsigned long
  421. __generic_copy_from_user_nocheck(void *to, const void *from, unsigned long n)
  422. {
  423.     return __copy_user(to,from,n);
  424. }
  425.  
  426. static inline unsigned long
  427. __generic_copy_to_user_nocheck(void *to, const void *from, unsigned long n)
  428. {
  429.     return __copy_user(to,from,n);
  430. }
  431.  
  432. static inline unsigned long
  433. __generic_copy_to_user(void *to, const void *from, unsigned long n)
  434. {
  435.     prefetch(from);
  436.     if (access_ok(VERIFY_WRITE, to, n))
  437.         return __copy_user(to,from,n);
  438.     return n;
  439. }
  440.  
  441. static inline unsigned long
  442. __generic_copy_from_user(void *to, const void *from, unsigned long n)
  443. {
  444.     prefetchw(to);
  445.     if (access_ok(VERIFY_READ, from, n))
  446.         return __copy_user(to,from,n);
  447.     else
  448.         memset(to, 0, n);
  449.     return n;
  450. }
  451.  
  452. #define copy_to_user(to,from,n) __generic_copy_to_user((to),(from),(n))
  453. #define copy_from_user(to,from,n) __generic_copy_from_user((to),(from),(n))
  454. #define __copy_to_user(to,from,n) __generic_copy_to_user_nocheck((to),(from),(n))
  455. #define __copy_from_user(to,from,n) __generic_copy_from_user_nocheck((to),(from),(n))
  456. #define __copy_to_user_inatomic __copy_to_user
  457. #define __copy_from_user_inatomic __copy_from_user
  458.  
  459.  
  460. /*
  461.  * We need to return the number of bytes not cleared.  Our memset()
  462.  * returns zero if a problem occurs while accessing user-space memory.
  463.  * In that event, return no memory cleared.  Otherwise, zero for
  464.  * success.
  465.  */
  466.  
  467. static inline unsigned long
  468. __xtensa_clear_user(void *addr, unsigned long size)
  469. {
  470.     if ( ! memset(addr, 0, size) )
  471.         return size;
  472.     return 0;
  473. }
  474.  
  475. static inline unsigned long
  476. clear_user(void *addr, unsigned long size)
  477. {
  478.     if (access_ok(VERIFY_WRITE, addr, size))
  479.         return __xtensa_clear_user(addr, size);
  480.     return size ? -EFAULT : 0;
  481. }
  482.  
  483. #define __clear_user  __xtensa_clear_user
  484.  
  485.  
  486. extern long __strncpy_user(char *, const char *, long);
  487. #define __strncpy_from_user __strncpy_user
  488.  
  489. static inline long
  490. strncpy_from_user(char *dst, const char *src, long count)
  491. {
  492.     if (access_ok(VERIFY_READ, src, 1))
  493.         return __strncpy_from_user(dst, src, count);
  494.     return -EFAULT;
  495. }
  496.  
  497.  
  498. #define strlen_user(str) strnlen_user((str), TASK_SIZE - 1)
  499.  
  500. /*
  501.  * Return the size of a string (including the ending 0!)
  502.  */
  503. extern long __strnlen_user(const char *, long);
  504.  
  505. static inline long strnlen_user(const char *str, long len)
  506. {
  507.     unsigned long top = __kernel_ok ? ~0UL : TASK_SIZE - 1;
  508.  
  509.     if ((unsigned long)str > top)
  510.         return 0;
  511.     return __strnlen_user(str, len);
  512. }
  513.  
  514.  
  515. struct exception_table_entry
  516. {
  517.     unsigned long insn, fixup;
  518. };
  519.  
  520. /* Returns 0 if exception not found and fixup.unit otherwise.  */
  521.  
  522. extern unsigned long search_exception_table(unsigned long addr);
  523. extern void sort_exception_table(void);
  524.  
  525. /* Returns the new pc */
  526. #define fixup_exception(map_reg, fixup_unit, pc)                \
  527. ({                                                              \
  528.     fixup_unit;                                             \
  529. })
  530.  
  531. #endif    /* __ASSEMBLY__ */
  532. #endif    /* _XTENSA_UACCESS_H */
  533.