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-mips / uaccess.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  22.0 KB  |  793 lines
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * Copyright (C) 1996, 1997, 1998, 1999, 2000, 03, 04 by Ralf Baechle
  7.  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  8.  */
  9. #ifndef _ASM_UACCESS_H
  10. #define _ASM_UACCESS_H
  11.  
  12. #include <linux/kernel.h>
  13. #include <linux/errno.h>
  14. #include <linux/thread_info.h>
  15. #include <asm-generic/uaccess.h>
  16.  
  17. /*
  18.  * The fs value determines whether argument validity checking should be
  19.  * performed or not.  If get_fs() == USER_DS, checking is performed, with
  20.  * get_fs() == KERNEL_DS, checking is bypassed.
  21.  *
  22.  * For historical reasons, these macros are grossly misnamed.
  23.  */
  24. #ifdef CONFIG_32BIT
  25.  
  26. #define __UA_LIMIT    0x80000000UL
  27.  
  28. #define __UA_ADDR    ".word"
  29. #define __UA_LA        "la"
  30. #define __UA_ADDU    "addu"
  31. #define __UA_t0        "$8"
  32. #define __UA_t1        "$9"
  33.  
  34. #endif /* CONFIG_32BIT */
  35.  
  36. #ifdef CONFIG_64BIT
  37.  
  38. #define __UA_LIMIT    (- TASK_SIZE)
  39.  
  40. #define __UA_ADDR    ".dword"
  41. #define __UA_LA        "dla"
  42. #define __UA_ADDU    "daddu"
  43. #define __UA_t0        "$12"
  44. #define __UA_t1        "$13"
  45.  
  46. #endif /* CONFIG_64BIT */
  47.  
  48. /*
  49.  * USER_DS is a bitmask that has the bits set that may not be set in a valid
  50.  * userspace address.  Note that we limit 32-bit userspace to 0x7fff8000 but
  51.  * the arithmetic we're doing only works if the limit is a power of two, so
  52.  * we use 0x80000000 here on 32-bit kernels.  If a process passes an invalid
  53.  * address in this range it's the process's problem, not ours :-)
  54.  */
  55.  
  56. #define KERNEL_DS    ((mm_segment_t) { 0UL })
  57. #define USER_DS        ((mm_segment_t) { __UA_LIMIT })
  58.  
  59. #define VERIFY_READ    0
  60. #define VERIFY_WRITE   1
  61.  
  62. #define get_ds()    (KERNEL_DS)
  63. #define get_fs()    (current_thread_info()->addr_limit)
  64. #define set_fs(x)    (current_thread_info()->addr_limit = (x))
  65.  
  66. #define segment_eq(a,b)    ((a).seg == (b).seg)
  67.  
  68.  
  69. /*
  70.  * Is a address valid? This does a straighforward calculation rather
  71.  * than tests.
  72.  *
  73.  * Address valid if:
  74.  *  - "addr" doesn't have any high-bits set
  75.  *  - AND "size" doesn't have any high-bits set
  76.  *  - AND "addr+size" doesn't have any high-bits set
  77.  *  - OR we are in kernel mode.
  78.  *
  79.  * __ua_size() is a trick to avoid runtime checking of positive constant
  80.  * sizes; for those we already know at compile time that the size is ok.
  81.  */
  82. #define __ua_size(size)                            \
  83.     ((__builtin_constant_p(size) && (signed long) (size) > 0) ? 0 : (size))
  84.  
  85. /*
  86.  * access_ok: - Checks if a user space pointer is valid
  87.  * @type: Type of access: %VERIFY_READ or %VERIFY_WRITE.  Note that
  88.  *        %VERIFY_WRITE is a superset of %VERIFY_READ - if it is safe
  89.  *        to write to a block, it is always safe to read from it.
  90.  * @addr: User space pointer to start of block to check
  91.  * @size: Size of block to check
  92.  *
  93.  * Context: User context only.  This function may sleep.
  94.  *
  95.  * Checks if a pointer to a block of memory in user space is valid.
  96.  *
  97.  * Returns true (nonzero) if the memory block may be valid, false (zero)
  98.  * if it is definitely invalid.
  99.  *
  100.  * Note that, depending on architecture, this function probably just
  101.  * checks that the pointer is in the user space range - after calling
  102.  * this function, memory access functions may still return -EFAULT.
  103.  */
  104.  
  105. #define __access_mask get_fs().seg
  106.  
  107. #define __access_ok(addr, size, mask)                    \
  108.     (((signed long)((mask) & ((addr) | ((addr) + (size)) | __ua_size(size)))) == 0)
  109.  
  110. #define access_ok(type, addr, size)                    \
  111.     likely(__access_ok((unsigned long)(addr), (size),__access_mask))
  112.  
  113. /*
  114.  * put_user: - Write a simple value into user space.
  115.  * @x:   Value to copy to user space.
  116.  * @ptr: Destination address, in user space.
  117.  *
  118.  * Context: User context only.  This function may sleep.
  119.  *
  120.  * This macro copies a single simple value from kernel space to user
  121.  * space.  It supports simple types like char and int, but not larger
  122.  * data types like structures or arrays.
  123.  *
  124.  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
  125.  * to the result of dereferencing @ptr.
  126.  *
  127.  * Returns zero on success, or -EFAULT on error.
  128.  */
  129. #define put_user(x,ptr)    \
  130.     __put_user_check((x),(ptr),sizeof(*(ptr)))
  131.  
  132. /*
  133.  * get_user: - Get a simple variable from user space.
  134.  * @x:   Variable to store result.
  135.  * @ptr: Source address, in user space.
  136.  *
  137.  * Context: User context only.  This function may sleep.
  138.  *
  139.  * This macro copies a single simple variable from user space to kernel
  140.  * space.  It supports simple types like char and int, but not larger
  141.  * data types like structures or arrays.
  142.  *
  143.  * @ptr must have pointer-to-simple-variable type, and the result of
  144.  * dereferencing @ptr must be assignable to @x without a cast.
  145.  *
  146.  * Returns zero on success, or -EFAULT on error.
  147.  * On error, the variable @x is set to zero.
  148.  */
  149. #define get_user(x,ptr) \
  150.     __get_user_check((x),(ptr),sizeof(*(ptr)))
  151.  
  152. /*
  153.  * __put_user: - Write a simple value into user space, with less checking.
  154.  * @x:   Value to copy to user space.
  155.  * @ptr: Destination address, in user space.
  156.  *
  157.  * Context: User context only.  This function may sleep.
  158.  *
  159.  * This macro copies a single simple value from kernel space to user
  160.  * space.  It supports simple types like char and int, but not larger
  161.  * data types like structures or arrays.
  162.  *
  163.  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
  164.  * to the result of dereferencing @ptr.
  165.  *
  166.  * Caller must check the pointer with access_ok() before calling this
  167.  * function.
  168.  *
  169.  * Returns zero on success, or -EFAULT on error.
  170.  */
  171. #define __put_user(x,ptr) \
  172.     __put_user_nocheck((x),(ptr),sizeof(*(ptr)))
  173.  
  174. /*
  175.  * __get_user: - Get a simple variable from user space, with less checking.
  176.  * @x:   Variable to store result.
  177.  * @ptr: Source address, in user space.
  178.  *
  179.  * Context: User context only.  This function may sleep.
  180.  *
  181.  * This macro copies a single simple variable from user space to kernel
  182.  * space.  It supports simple types like char and int, but not larger
  183.  * data types like structures or arrays.
  184.  *
  185.  * @ptr must have pointer-to-simple-variable type, and the result of
  186.  * dereferencing @ptr must be assignable to @x without a cast.
  187.  *
  188.  * Caller must check the pointer with access_ok() before calling this
  189.  * function.
  190.  *
  191.  * Returns zero on success, or -EFAULT on error.
  192.  * On error, the variable @x is set to zero.
  193.  */
  194. #define __get_user(x,ptr) \
  195.     __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
  196.  
  197. struct __large_struct { unsigned long buf[100]; };
  198. #define __m(x) (*(struct __large_struct __user *)(x))
  199.  
  200. /*
  201.  * Yuck.  We need two variants, one for 64bit operation and one
  202.  * for 32 bit mode and old iron.
  203.  */
  204. #ifdef CONFIG_32BIT
  205. #define __GET_USER_DW(val, ptr) __get_user_asm_ll32(val, ptr)
  206. #endif
  207. #ifdef CONFIG_64BIT
  208. #define __GET_USER_DW(val, ptr) __get_user_asm(val, "ld", ptr)
  209. #endif
  210.  
  211. extern void __get_user_unknown(void);
  212.  
  213. #define __get_user_common(val, size, ptr)                \
  214. do {                                    \
  215.     switch (size) {                            \
  216.     case 1: __get_user_asm(val, "lb", ptr); break;            \
  217.     case 2: __get_user_asm(val, "lh", ptr); break;            \
  218.     case 4: __get_user_asm(val, "lw", ptr); break;            \
  219.     case 8: __GET_USER_DW(val, ptr); break;                \
  220.     default: __get_user_unknown(); break;                \
  221.     }                                \
  222. } while (0)
  223.  
  224. #define __get_user_nocheck(x,ptr,size)                    \
  225. ({                                    \
  226.     long __gu_err;                            \
  227.                                     \
  228.     __get_user_common((x), size, ptr);                \
  229.     __gu_err;                            \
  230. })
  231.  
  232. #define __get_user_check(x,ptr,size)                    \
  233. ({                                    \
  234.     long __gu_err = -EFAULT;                    \
  235.     const __typeof__(*(ptr)) __user * __gu_ptr = (ptr);        \
  236.                                     \
  237.     if (likely(access_ok(VERIFY_READ,  __gu_ptr, size)))        \
  238.         __get_user_common((x), size, __gu_ptr);            \
  239.                                     \
  240.     __gu_err;                            \
  241. })
  242.  
  243. #define __get_user_asm(val, insn, addr)                    \
  244. {                                    \
  245.     long __gu_tmp;                            \
  246.                                     \
  247.     __asm__ __volatile__(                        \
  248.     "1:    " insn "    %1, %3                \n"    \
  249.     "2:                            \n"    \
  250.     "    .section .fixup,\"ax\"                \n"    \
  251.     "3:    li    %0, %4                    \n"    \
  252.     "    j    2b                    \n"    \
  253.     "    .previous                    \n"    \
  254.     "    .section __ex_table,\"a\"            \n"    \
  255.     "    "__UA_ADDR "\t1b, 3b                \n"    \
  256.     "    .previous                    \n"    \
  257.     : "=r" (__gu_err), "=r" (__gu_tmp)                \
  258.     : "0" (0), "o" (__m(addr)), "i" (-EFAULT));            \
  259.                                     \
  260.     (val) = (__typeof__(*(addr))) __gu_tmp;                \
  261. }
  262.  
  263. /*
  264.  * Get a long long 64 using 32 bit registers.
  265.  */
  266. #define __get_user_asm_ll32(val, addr)                    \
  267. {                                    \
  268.         unsigned long long __gu_tmp;                    \
  269.                                     \
  270.     __asm__ __volatile__(                        \
  271.     "1:    lw    %1, (%3)                \n"    \
  272.     "2:    lw    %D1, 4(%3)                \n"    \
  273.     "    move    %0, $0                    \n"    \
  274.     "3:    .section    .fixup,\"ax\"            \n"    \
  275.     "4:    li    %0, %4                    \n"    \
  276.     "    move    %1, $0                    \n"    \
  277.     "    move    %D1, $0                    \n"    \
  278.     "    j    3b                    \n"    \
  279.     "    .previous                    \n"    \
  280.     "    .section    __ex_table,\"a\"        \n"    \
  281.     "    " __UA_ADDR "    1b, 4b                \n"    \
  282.     "    " __UA_ADDR "    2b, 4b                \n"    \
  283.     "    .previous                    \n"    \
  284.     : "=r" (__gu_err), "=&r" (__gu_tmp)                \
  285.     : "0" (0), "r" (addr), "i" (-EFAULT));                \
  286.     (val) = (__typeof__(*(addr))) __gu_tmp;                \
  287. }
  288.  
  289. /*
  290.  * Yuck.  We need two variants, one for 64bit operation and one
  291.  * for 32 bit mode and old iron.
  292.  */
  293. #ifdef CONFIG_32BIT
  294. #define __PUT_USER_DW(ptr) __put_user_asm_ll32(ptr)
  295. #endif
  296. #ifdef CONFIG_64BIT
  297. #define __PUT_USER_DW(ptr) __put_user_asm("sd", ptr)
  298. #endif
  299.  
  300. #define __put_user_nocheck(x,ptr,size)                    \
  301. ({                                    \
  302.     __typeof__(*(ptr)) __pu_val;                    \
  303.     long __pu_err = 0;                        \
  304.                                     \
  305.     __pu_val = (x);                            \
  306.     switch (size) {                            \
  307.     case 1: __put_user_asm("sb", ptr); break;            \
  308.     case 2: __put_user_asm("sh", ptr); break;            \
  309.     case 4: __put_user_asm("sw", ptr); break;            \
  310.     case 8: __PUT_USER_DW(ptr); break;                \
  311.     default: __put_user_unknown(); break;                \
  312.     }                                \
  313.     __pu_err;                            \
  314. })
  315.  
  316. #define __put_user_check(x,ptr,size)                    \
  317. ({                                    \
  318.     __typeof__(*(ptr)) __user *__pu_addr = (ptr);            \
  319.     __typeof__(*(ptr)) __pu_val = (x);                \
  320.     long __pu_err = -EFAULT;                    \
  321.                                     \
  322.     if (likely(access_ok(VERIFY_WRITE,  __pu_addr, size))) {    \
  323.         switch (size) {                        \
  324.         case 1: __put_user_asm("sb", __pu_addr); break;        \
  325.         case 2: __put_user_asm("sh", __pu_addr); break;        \
  326.         case 4: __put_user_asm("sw", __pu_addr); break;        \
  327.         case 8: __PUT_USER_DW(__pu_addr); break;        \
  328.         default: __put_user_unknown(); break;            \
  329.         }                            \
  330.     }                                \
  331.     __pu_err;                            \
  332. })
  333.  
  334. #define __put_user_asm(insn, ptr)                    \
  335. {                                    \
  336.     __asm__ __volatile__(                        \
  337.     "1:    " insn "    %z2, %3        # __put_user_asm\n"    \
  338.     "2:                            \n"    \
  339.     "    .section    .fixup,\"ax\"            \n"    \
  340.     "3:    li    %0, %4                    \n"    \
  341.     "    j    2b                    \n"    \
  342.     "    .previous                    \n"    \
  343.     "    .section    __ex_table,\"a\"        \n"    \
  344.     "    " __UA_ADDR "    1b, 3b                \n"    \
  345.     "    .previous                    \n"    \
  346.     : "=r" (__pu_err)                        \
  347.     : "0" (0), "Jr" (__pu_val), "o" (__m(ptr)),            \
  348.       "i" (-EFAULT));                        \
  349. }
  350.  
  351. #define __put_user_asm_ll32(ptr)                    \
  352. {                                    \
  353.     __asm__ __volatile__(                        \
  354.     "1:    sw    %2, (%3)    # __put_user_asm_ll32    \n"    \
  355.     "2:    sw    %D2, 4(%3)                \n"    \
  356.     "3:                            \n"    \
  357.     "    .section    .fixup,\"ax\"            \n"    \
  358.     "4:    li    %0, %4                    \n"    \
  359.     "    j    3b                    \n"    \
  360.     "    .previous                    \n"    \
  361.     "    .section    __ex_table,\"a\"        \n"    \
  362.     "    " __UA_ADDR "    1b, 4b                \n"    \
  363.     "    " __UA_ADDR "    2b, 4b                \n"    \
  364.     "    .previous"                        \
  365.     : "=r" (__pu_err)                        \
  366.     : "0" (0), "r" (__pu_val), "r" (ptr),                \
  367.       "i" (-EFAULT));                        \
  368. }
  369.  
  370. extern void __put_user_unknown(void);
  371.  
  372. /*
  373.  * We're generating jump to subroutines which will be outside the range of
  374.  * jump instructions
  375.  */
  376. #ifdef MODULE
  377. #define __MODULE_JAL(destination)                    \
  378.     ".set\tnoat\n\t"                        \
  379.     __UA_LA "\t$1, " #destination "\n\t"                 \
  380.     "jalr\t$1\n\t"                            \
  381.     ".set\tat\n\t"
  382. #else
  383. #define __MODULE_JAL(destination)                    \
  384.     "jal\t" #destination "\n\t"
  385. #endif
  386.  
  387. extern size_t __copy_user(void *__to, const void *__from, size_t __n);
  388.  
  389. #define __invoke_copy_to_user(to,from,n)                \
  390. ({                                    \
  391.     register void __user *__cu_to_r __asm__ ("$4");            \
  392.     register const void *__cu_from_r __asm__ ("$5");        \
  393.     register long __cu_len_r __asm__ ("$6");            \
  394.                                     \
  395.     __cu_to_r = (to);                        \
  396.     __cu_from_r = (from);                        \
  397.     __cu_len_r = (n);                        \
  398.     __asm__ __volatile__(                        \
  399.     __MODULE_JAL(__copy_user)                    \
  400.     : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r)    \
  401.     :                                \
  402.     : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31",        \
  403.       "memory");                            \
  404.     __cu_len_r;                            \
  405. })
  406.  
  407. /*
  408.  * __copy_to_user: - Copy a block of data into user space, with less checking.
  409.  * @to:   Destination address, in user space.
  410.  * @from: Source address, in kernel space.
  411.  * @n:    Number of bytes to copy.
  412.  *
  413.  * Context: User context only.  This function may sleep.
  414.  *
  415.  * Copy data from kernel space to user space.  Caller must check
  416.  * the specified block with access_ok() before calling this function.
  417.  *
  418.  * Returns number of bytes that could not be copied.
  419.  * On success, this will be zero.
  420.  */
  421. #define __copy_to_user(to,from,n)                    \
  422. ({                                    \
  423.     void __user *__cu_to;                        \
  424.     const void *__cu_from;                        \
  425.     long __cu_len;                            \
  426.                                     \
  427.     might_sleep();                            \
  428.     __cu_to = (to);                            \
  429.     __cu_from = (from);                        \
  430.     __cu_len = (n);                            \
  431.     __cu_len = __invoke_copy_to_user(__cu_to, __cu_from, __cu_len);    \
  432.     __cu_len;                            \
  433. })
  434.  
  435. #define __copy_to_user_inatomic __copy_to_user
  436. #define __copy_from_user_inatomic __copy_from_user
  437.  
  438. /*
  439.  * copy_to_user: - Copy a block of data into user space.
  440.  * @to:   Destination address, in user space.
  441.  * @from: Source address, in kernel space.
  442.  * @n:    Number of bytes to copy.
  443.  *
  444.  * Context: User context only.  This function may sleep.
  445.  *
  446.  * Copy data from kernel space to user space.
  447.  *
  448.  * Returns number of bytes that could not be copied.
  449.  * On success, this will be zero.
  450.  */
  451. #define copy_to_user(to,from,n)                        \
  452. ({                                    \
  453.     void __user *__cu_to;                        \
  454.     const void *__cu_from;                        \
  455.     long __cu_len;                            \
  456.                                     \
  457.     might_sleep();                            \
  458.     __cu_to = (to);                            \
  459.     __cu_from = (from);                        \
  460.     __cu_len = (n);                            \
  461.     if (access_ok(VERIFY_WRITE, __cu_to, __cu_len))            \
  462.         __cu_len = __invoke_copy_to_user(__cu_to, __cu_from,    \
  463.                                          __cu_len);        \
  464.     __cu_len;                            \
  465. })
  466.  
  467. #define __invoke_copy_from_user(to,from,n)                \
  468. ({                                    \
  469.     register void *__cu_to_r __asm__ ("$4");            \
  470.     register const void __user *__cu_from_r __asm__ ("$5");        \
  471.     register long __cu_len_r __asm__ ("$6");            \
  472.                                     \
  473.     __cu_to_r = (to);                        \
  474.     __cu_from_r = (from);                        \
  475.     __cu_len_r = (n);                        \
  476.     __asm__ __volatile__(                        \
  477.     ".set\tnoreorder\n\t"                        \
  478.     __MODULE_JAL(__copy_user)                    \
  479.     ".set\tnoat\n\t"                        \
  480.     __UA_ADDU "\t$1, %1, %2\n\t"                    \
  481.     ".set\tat\n\t"                            \
  482.     ".set\treorder"                            \
  483.     : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r)    \
  484.     :                                \
  485.     : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31",        \
  486.       "memory");                            \
  487.     __cu_len_r;                            \
  488. })
  489.  
  490. /*
  491.  * __copy_from_user: - Copy a block of data from user space, with less checking. * @to:   Destination address, in kernel space.
  492.  * @from: Source address, in user space.
  493.  * @n:    Number of bytes to copy.
  494.  *
  495.  * Context: User context only.  This function may sleep.
  496.  *
  497.  * Copy data from user space to kernel space.  Caller must check
  498.  * the specified block with access_ok() before calling this function.
  499.  *
  500.  * Returns number of bytes that could not be copied.
  501.  * On success, this will be zero.
  502.  *
  503.  * If some data could not be copied, this function will pad the copied
  504.  * data to the requested size using zero bytes.
  505.  */
  506. #define __copy_from_user(to,from,n)                    \
  507. ({                                    \
  508.     void *__cu_to;                            \
  509.     const void __user *__cu_from;                    \
  510.     long __cu_len;                            \
  511.                                     \
  512.     might_sleep();                            \
  513.     __cu_to = (to);                            \
  514.     __cu_from = (from);                        \
  515.     __cu_len = (n);                            \
  516.     __cu_len = __invoke_copy_from_user(__cu_to, __cu_from,        \
  517.                                        __cu_len);            \
  518.     __cu_len;                            \
  519. })
  520.  
  521. /*
  522.  * copy_from_user: - Copy a block of data from user space.
  523.  * @to:   Destination address, in kernel space.
  524.  * @from: Source address, in user space.
  525.  * @n:    Number of bytes to copy.
  526.  *
  527.  * Context: User context only.  This function may sleep.
  528.  *
  529.  * Copy data from user space to kernel space.
  530.  *
  531.  * Returns number of bytes that could not be copied.
  532.  * On success, this will be zero.
  533.  *
  534.  * If some data could not be copied, this function will pad the copied
  535.  * data to the requested size using zero bytes.
  536.  */
  537. #define copy_from_user(to,from,n)                    \
  538. ({                                    \
  539.     void *__cu_to;                            \
  540.     const void __user *__cu_from;                    \
  541.     long __cu_len;                            \
  542.                                     \
  543.     might_sleep();                            \
  544.     __cu_to = (to);                            \
  545.     __cu_from = (from);                        \
  546.     __cu_len = (n);                            \
  547.     if (access_ok(VERIFY_READ, __cu_from, __cu_len))        \
  548.         __cu_len = __invoke_copy_from_user(__cu_to, __cu_from,    \
  549.                                            __cu_len);        \
  550.     __cu_len;                            \
  551. })
  552.  
  553. #define __copy_in_user(to, from, n)    __copy_from_user(to, from, n)
  554.  
  555. #define copy_in_user(to,from,n)                        \
  556. ({                                    \
  557.     void __user *__cu_to;                        \
  558.     const void __user *__cu_from;                    \
  559.     long __cu_len;                            \
  560.                                     \
  561.     might_sleep();                            \
  562.     __cu_to = (to);                            \
  563.     __cu_from = (from);                        \
  564.     __cu_len = (n);                            \
  565.     if (likely(access_ok(VERIFY_READ, __cu_from, __cu_len) &&    \
  566.                access_ok(VERIFY_WRITE, __cu_to, __cu_len)))        \
  567.         __cu_len = __invoke_copy_from_user(__cu_to, __cu_from,    \
  568.                                            __cu_len);        \
  569.     __cu_len;                            \
  570. })
  571.  
  572. /*
  573.  * __clear_user: - Zero a block of memory in user space, with less checking.
  574.  * @to:   Destination address, in user space.
  575.  * @n:    Number of bytes to zero.
  576.  *
  577.  * Zero a block of memory in user space.  Caller must check
  578.  * the specified block with access_ok() before calling this function.
  579.  *
  580.  * Returns number of bytes that could not be cleared.
  581.  * On success, this will be zero.
  582.  */
  583. static inline __kernel_size_t
  584. __clear_user(void __user *addr, __kernel_size_t size)
  585. {
  586.     __kernel_size_t res;
  587.  
  588.     might_sleep();
  589.     __asm__ __volatile__(
  590.         "move\t$4, %1\n\t"
  591.         "move\t$5, $0\n\t"
  592.         "move\t$6, %2\n\t"
  593.         __MODULE_JAL(__bzero)
  594.         "move\t%0, $6"
  595.         : "=r" (res)
  596.         : "r" (addr), "r" (size)
  597.         : "$4", "$5", "$6", __UA_t0, __UA_t1, "$31");
  598.  
  599.     return res;
  600. }
  601.  
  602. #define clear_user(addr,n)                        \
  603. ({                                    \
  604.     void __user * __cl_addr = (addr);                \
  605.     unsigned long __cl_size = (n);                    \
  606.     if (__cl_size && access_ok(VERIFY_WRITE,            \
  607.         ((unsigned long)(__cl_addr)), __cl_size))        \
  608.         __cl_size = __clear_user(__cl_addr, __cl_size);        \
  609.     __cl_size;                            \
  610. })
  611.  
  612. /*
  613.  * __strncpy_from_user: - Copy a NUL terminated string from userspace, with less checking.
  614.  * @dst:   Destination address, in kernel space.  This buffer must be at
  615.  *         least @count bytes long.
  616.  * @src:   Source address, in user space.
  617.  * @count: Maximum number of bytes to copy, including the trailing NUL.
  618.  *
  619.  * Copies a NUL-terminated string from userspace to kernel space.
  620.  * Caller must check the specified block with access_ok() before calling
  621.  * this function.
  622.  *
  623.  * On success, returns the length of the string (not including the trailing
  624.  * NUL).
  625.  *
  626.  * If access to userspace fails, returns -EFAULT (some data may have been
  627.  * copied).
  628.  *
  629.  * If @count is smaller than the length of the string, copies @count bytes
  630.  * and returns @count.
  631.  */
  632. static inline long
  633. __strncpy_from_user(char *__to, const char __user *__from, long __len)
  634. {
  635.     long res;
  636.  
  637.     might_sleep();
  638.     __asm__ __volatile__(
  639.         "move\t$4, %1\n\t"
  640.         "move\t$5, %2\n\t"
  641.         "move\t$6, %3\n\t"
  642.         __MODULE_JAL(__strncpy_from_user_nocheck_asm)
  643.         "move\t%0, $2"
  644.         : "=r" (res)
  645.         : "r" (__to), "r" (__from), "r" (__len)
  646.         : "$2", "$3", "$4", "$5", "$6", __UA_t0, "$31", "memory");
  647.  
  648.     return res;
  649. }
  650.  
  651. /*
  652.  * strncpy_from_user: - Copy a NUL terminated string from userspace.
  653.  * @dst:   Destination address, in kernel space.  This buffer must be at
  654.  *         least @count bytes long.
  655.  * @src:   Source address, in user space.
  656.  * @count: Maximum number of bytes to copy, including the trailing NUL.
  657.  *
  658.  * Copies a NUL-terminated string from userspace to kernel space.
  659.  *
  660.  * On success, returns the length of the string (not including the trailing
  661.  * NUL).
  662.  *
  663.  * If access to userspace fails, returns -EFAULT (some data may have been
  664.  * copied).
  665.  *
  666.  * If @count is smaller than the length of the string, copies @count bytes
  667.  * and returns @count.
  668.  */
  669. static inline long
  670. strncpy_from_user(char *__to, const char __user *__from, long __len)
  671. {
  672.     long res;
  673.  
  674.     might_sleep();
  675.     __asm__ __volatile__(
  676.         "move\t$4, %1\n\t"
  677.         "move\t$5, %2\n\t"
  678.         "move\t$6, %3\n\t"
  679.         __MODULE_JAL(__strncpy_from_user_asm)
  680.         "move\t%0, $2"
  681.         : "=r" (res)
  682.         : "r" (__to), "r" (__from), "r" (__len)
  683.         : "$2", "$3", "$4", "$5", "$6", __UA_t0, "$31", "memory");
  684.  
  685.     return res;
  686. }
  687.  
  688. /* Returns: 0 if bad, string length+1 (memory size) of string if ok */
  689. static inline long __strlen_user(const char __user *s)
  690. {
  691.     long res;
  692.  
  693.     might_sleep();
  694.     __asm__ __volatile__(
  695.         "move\t$4, %1\n\t"
  696.         __MODULE_JAL(__strlen_user_nocheck_asm)
  697.         "move\t%0, $2"
  698.         : "=r" (res)
  699.         : "r" (s)
  700.         : "$2", "$4", __UA_t0, "$31");
  701.  
  702.     return res;
  703. }
  704.  
  705. /*
  706.  * strlen_user: - Get the size of a string in user space.
  707.  * @str: The string to measure.
  708.  *
  709.  * Context: User context only.  This function may sleep.
  710.  *
  711.  * Get the size of a NUL-terminated string in user space.
  712.  *
  713.  * Returns the size of the string INCLUDING the terminating NUL.
  714.  * On exception, returns 0.
  715.  *
  716.  * If there is a limit on the length of a valid string, you may wish to
  717.  * consider using strnlen_user() instead.
  718.  */
  719. static inline long strlen_user(const char __user *s)
  720. {
  721.     long res;
  722.  
  723.     might_sleep();
  724.     __asm__ __volatile__(
  725.         "move\t$4, %1\n\t"
  726.         __MODULE_JAL(__strlen_user_asm)
  727.         "move\t%0, $2"
  728.         : "=r" (res)
  729.         : "r" (s)
  730.         : "$2", "$4", __UA_t0, "$31");
  731.  
  732.     return res;
  733. }
  734.  
  735. /* Returns: 0 if bad, string length+1 (memory size) of string if ok */
  736. static inline long __strnlen_user(const char __user *s, long n)
  737. {
  738.     long res;
  739.  
  740.     might_sleep();
  741.     __asm__ __volatile__(
  742.         "move\t$4, %1\n\t"
  743.         "move\t$5, %2\n\t"
  744.         __MODULE_JAL(__strnlen_user_nocheck_asm)
  745.         "move\t%0, $2"
  746.         : "=r" (res)
  747.         : "r" (s), "r" (n)
  748.         : "$2", "$4", "$5", __UA_t0, "$31");
  749.  
  750.     return res;
  751. }
  752.  
  753. /*
  754.  * strlen_user: - Get the size of a string in user space.
  755.  * @str: The string to measure.
  756.  *
  757.  * Context: User context only.  This function may sleep.
  758.  *
  759.  * Get the size of a NUL-terminated string in user space.
  760.  *
  761.  * Returns the size of the string INCLUDING the terminating NUL.
  762.  * On exception, returns 0.
  763.  *
  764.  * If there is a limit on the length of a valid string, you may wish to
  765.  * consider using strnlen_user() instead.
  766.  */
  767. static inline long strnlen_user(const char __user *s, long n)
  768. {
  769.     long res;
  770.  
  771.     might_sleep();
  772.     __asm__ __volatile__(
  773.         "move\t$4, %1\n\t"
  774.         "move\t$5, %2\n\t"
  775.         __MODULE_JAL(__strnlen_user_asm)
  776.         "move\t%0, $2"
  777.         : "=r" (res)
  778.         : "r" (s), "r" (n)
  779.         : "$2", "$4", "$5", __UA_t0, "$31");
  780.  
  781.     return res;
  782. }
  783.  
  784. struct exception_table_entry
  785. {
  786.     unsigned long insn;
  787.     unsigned long nextinsn;
  788. };
  789.  
  790. extern int fixup_exception(struct pt_regs *regs);
  791.  
  792. #endif /* _ASM_UACCESS_H */
  793.