home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / x86 / include / asm / uaccess_32.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  6.5 KB  |  219 lines
  1. #ifndef _ASM_X86_UACCESS_32_H
  2. #define _ASM_X86_UACCESS_32_H
  3.  
  4. /*
  5.  * User space memory access functions
  6.  */
  7. #include <linux/errno.h>
  8. #include <linux/thread_info.h>
  9. #include <linux/prefetch.h>
  10. #include <linux/string.h>
  11. #include <asm/asm.h>
  12. #include <asm/page.h>
  13.  
  14. unsigned long __must_check __copy_to_user_ll
  15.         (void __user *to, const void *from, unsigned long n);
  16. unsigned long __must_check __copy_from_user_ll
  17.         (void *to, const void __user *from, unsigned long n);
  18. unsigned long __must_check __copy_from_user_ll_nozero
  19.         (void *to, const void __user *from, unsigned long n);
  20. unsigned long __must_check __copy_from_user_ll_nocache
  21.         (void *to, const void __user *from, unsigned long n);
  22. unsigned long __must_check __copy_from_user_ll_nocache_nozero
  23.         (void *to, const void __user *from, unsigned long n);
  24.  
  25. /**
  26.  * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking.
  27.  * @to:   Destination address, in user space.
  28.  * @from: Source address, in kernel space.
  29.  * @n:    Number of bytes to copy.
  30.  *
  31.  * Context: User context only.
  32.  *
  33.  * Copy data from kernel space to user space.  Caller must check
  34.  * the specified block with access_ok() before calling this function.
  35.  * The caller should also make sure he pins the user space address
  36.  * so that the we don't result in page fault and sleep.
  37.  *
  38.  * Here we special-case 1, 2 and 4-byte copy_*_user invocations.  On a fault
  39.  * we return the initial request size (1, 2 or 4), as copy_*_user should do.
  40.  * If a store crosses a page boundary and gets a fault, the x86 will not write
  41.  * anything, so this is accurate.
  42.  */
  43.  
  44. static __always_inline unsigned long __must_check
  45. __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
  46. {
  47.     if (__builtin_constant_p(n)) {
  48.         unsigned long ret;
  49.  
  50.         switch (n) {
  51.         case 1:
  52.             __put_user_size(*(u8 *)from, (u8 __user *)to,
  53.                     1, ret, 1);
  54.             return ret;
  55.         case 2:
  56.             __put_user_size(*(u16 *)from, (u16 __user *)to,
  57.                     2, ret, 2);
  58.             return ret;
  59.         case 4:
  60.             __put_user_size(*(u32 *)from, (u32 __user *)to,
  61.                     4, ret, 4);
  62.             return ret;
  63.         }
  64.     }
  65.     return __copy_to_user_ll(to, from, n);
  66. }
  67.  
  68. /**
  69.  * __copy_to_user: - Copy a block of data into user space, with less checking.
  70.  * @to:   Destination address, in user space.
  71.  * @from: Source address, in kernel space.
  72.  * @n:    Number of bytes to copy.
  73.  *
  74.  * Context: User context only.  This function may sleep.
  75.  *
  76.  * Copy data from kernel space to user space.  Caller must check
  77.  * the specified block with access_ok() before calling this function.
  78.  *
  79.  * Returns number of bytes that could not be copied.
  80.  * On success, this will be zero.
  81.  */
  82. static __always_inline unsigned long __must_check
  83. __copy_to_user(void __user *to, const void *from, unsigned long n)
  84. {
  85.        might_sleep();
  86.        return __copy_to_user_inatomic(to, from, n);
  87. }
  88.  
  89. static __always_inline unsigned long
  90. __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
  91. {
  92.     /* Avoid zeroing the tail if the copy fails..
  93.      * If 'n' is constant and 1, 2, or 4, we do still zero on a failure,
  94.      * but as the zeroing behaviour is only significant when n is not
  95.      * constant, that shouldn't be a problem.
  96.      */
  97.     if (__builtin_constant_p(n)) {
  98.         unsigned long ret;
  99.  
  100.         switch (n) {
  101.         case 1:
  102.             __get_user_size(*(u8 *)to, from, 1, ret, 1);
  103.             return ret;
  104.         case 2:
  105.             __get_user_size(*(u16 *)to, from, 2, ret, 2);
  106.             return ret;
  107.         case 4:
  108.             __get_user_size(*(u32 *)to, from, 4, ret, 4);
  109.             return ret;
  110.         }
  111.     }
  112.     return __copy_from_user_ll_nozero(to, from, n);
  113. }
  114.  
  115. /**
  116.  * __copy_from_user: - Copy a block of data from user space, with less checking.
  117.  * @to:   Destination address, in kernel space.
  118.  * @from: Source address, in user space.
  119.  * @n:    Number of bytes to copy.
  120.  *
  121.  * Context: User context only.  This function may sleep.
  122.  *
  123.  * Copy data from user space to kernel space.  Caller must check
  124.  * the specified block with access_ok() before calling this function.
  125.  *
  126.  * Returns number of bytes that could not be copied.
  127.  * On success, this will be zero.
  128.  *
  129.  * If some data could not be copied, this function will pad the copied
  130.  * data to the requested size using zero bytes.
  131.  *
  132.  * An alternate version - __copy_from_user_inatomic() - may be called from
  133.  * atomic context and will fail rather than sleep.  In this case the
  134.  * uncopied bytes will *NOT* be padded with zeros.  See fs/filemap.h
  135.  * for explanation of why this is needed.
  136.  */
  137. static __always_inline unsigned long
  138. __copy_from_user(void *to, const void __user *from, unsigned long n)
  139. {
  140.     might_sleep();
  141.     if (__builtin_constant_p(n)) {
  142.         unsigned long ret;
  143.  
  144.         switch (n) {
  145.         case 1:
  146.             __get_user_size(*(u8 *)to, from, 1, ret, 1);
  147.             return ret;
  148.         case 2:
  149.             __get_user_size(*(u16 *)to, from, 2, ret, 2);
  150.             return ret;
  151.         case 4:
  152.             __get_user_size(*(u32 *)to, from, 4, ret, 4);
  153.             return ret;
  154.         }
  155.     }
  156.     return __copy_from_user_ll(to, from, n);
  157. }
  158.  
  159. static __always_inline unsigned long __copy_from_user_nocache(void *to,
  160.                 const void __user *from, unsigned long n)
  161. {
  162.     might_sleep();
  163.     if (__builtin_constant_p(n)) {
  164.         unsigned long ret;
  165.  
  166.         switch (n) {
  167.         case 1:
  168.             __get_user_size(*(u8 *)to, from, 1, ret, 1);
  169.             return ret;
  170.         case 2:
  171.             __get_user_size(*(u16 *)to, from, 2, ret, 2);
  172.             return ret;
  173.         case 4:
  174.             __get_user_size(*(u32 *)to, from, 4, ret, 4);
  175.             return ret;
  176.         }
  177.     }
  178.     return __copy_from_user_ll_nocache(to, from, n);
  179. }
  180.  
  181. static __always_inline unsigned long
  182. __copy_from_user_inatomic_nocache(void *to, const void __user *from,
  183.                   unsigned long n)
  184. {
  185.        return __copy_from_user_ll_nocache_nozero(to, from, n);
  186. }
  187.  
  188. unsigned long __must_check copy_to_user(void __user *to,
  189.                     const void *from, unsigned long n);
  190. unsigned long __must_check copy_from_user(void *to,
  191.                       const void __user *from,
  192.                       unsigned long n);
  193. long __must_check strncpy_from_user(char *dst, const char __user *src,
  194.                     long count);
  195. long __must_check __strncpy_from_user(char *dst,
  196.                       const char __user *src, long count);
  197.  
  198. /**
  199.  * strlen_user: - Get the size of a string in user space.
  200.  * @str: The string to measure.
  201.  *
  202.  * Context: User context only.  This function may sleep.
  203.  *
  204.  * Get the size of a NUL-terminated string in user space.
  205.  *
  206.  * Returns the size of the string INCLUDING the terminating NUL.
  207.  * On exception, returns 0.
  208.  *
  209.  * If there is a limit on the length of a valid string, you may wish to
  210.  * consider using strnlen_user() instead.
  211.  */
  212. #define strlen_user(str) strnlen_user(str, LONG_MAX)
  213.  
  214. long strnlen_user(const char __user *str, long n);
  215. unsigned long __must_check clear_user(void __user *mem, unsigned long len);
  216. unsigned long __must_check __clear_user(void __user *mem, unsigned long len);
  217.  
  218. #endif /* _ASM_X86_UACCESS_32_H */
  219.