| #ifndef __i386_UACCESS_H |
| #define __i386_UACCESS_H |
| |
| /* |
| * User space memory access functions |
| */ |
| #include <linux/errno.h> |
| #include <linux/thread_info.h> |
| #include <linux/prefetch.h> |
| #include <linux/string.h> |
| #include <asm/asm.h> |
| #include <asm/page.h> |
| |
| /* |
| * movsl can be slow when source and dest are not both 8-byte aligned |
| */ |
| #ifdef CONFIG_X86_INTEL_USERCOPY |
| extern struct movsl_mask { |
| int mask; |
| } ____cacheline_aligned_in_smp movsl_mask; |
| #endif |
| |
| extern void __put_user_bad(void); |
| |
| /* |
| * Strange magic calling convention: pointer in %ecx, |
| * value in %eax(:%edx), return value in %eax, no clobbers. |
| */ |
| extern void __put_user_1(void); |
| extern void __put_user_2(void); |
| extern void __put_user_4(void); |
| extern void __put_user_8(void); |
| |
| #define __put_user_x(size, x, ptr) \ |
| asm volatile("call __put_user_" #size : "=a" (__ret_pu) \ |
| :"0" ((typeof(*(ptr)))(x)), "c" (ptr) : "ebx") |
| |
| #define __put_user_8(x, ptr) \ |
| asm volatile("call __put_user_8" : "=a" (__ret_pu) \ |
| : "A" ((typeof(*(ptr)))(x)), "c" (ptr) : "ebx") |
| |
| |
| /** |
| * put_user: - Write a simple value into user space. |
| * @x: Value to copy to user space. |
| * @ptr: Destination address, in user space. |
| * |
| * Context: User context only. This function may sleep. |
| * |
| * This macro copies a single simple value from kernel space to user |
| * space. It supports simple types like char and int, but not larger |
| * data types like structures or arrays. |
| * |
| * @ptr must have pointer-to-simple-variable type, and @x must be assignable |
| * to the result of dereferencing @ptr. |
| * |
| * Returns zero on success, or -EFAULT on error. |
| */ |
| #ifdef CONFIG_X86_WP_WORKS_OK |
| |
| #define put_user(x, ptr) \ |
| ({ \ |
| int __ret_pu; \ |
| __typeof__(*(ptr)) __pu_val; \ |
| __chk_user_ptr(ptr); \ |
| __pu_val = x; \ |
| switch (sizeof(*(ptr))) { \ |
| case 1: \ |
| __put_user_x(1, __pu_val, ptr); \ |
| break; \ |
| case 2: \ |
| __put_user_x(2, __pu_val, ptr); \ |
| break; \ |
| case 4: \ |
| __put_user_x(4, __pu_val, ptr); \ |
| break; \ |
| case 8: \ |
| __put_user_8(__pu_val, ptr); \ |
| break; \ |
| default: \ |
| __put_user_x(X, __pu_val, ptr); \ |
| break; \ |
| } \ |
| __ret_pu; \ |
| }) |
| |
| #else |
| #define put_user(x, ptr) \ |
| ({ \ |
| int __ret_pu; \ |
| __typeof__(*(ptr))__pus_tmp = x; \ |
| __ret_pu = 0; \ |
| if (unlikely(__copy_to_user_ll(ptr, &__pus_tmp, \ |
| sizeof(*(ptr))) != 0)) \ |
| __ret_pu = -EFAULT; \ |
| __ret_pu; \ |
| }) |
| |
| |
| #endif |
| |
| /** |
| * __get_user: - Get a simple variable from user space, with less checking. |
| * @x: Variable to store result. |
| * @ptr: Source address, in user space. |
| * |
| * Context: User context only. This function may sleep. |
| * |
| * This macro copies a single simple variable from user space to kernel |
| * space. It supports simple types like char and int, but not larger |
| * data types like structures or arrays. |
| * |
| * @ptr must have pointer-to-simple-variable type, and the result of |
| * dereferencing @ptr must be assignable to @x without a cast. |
| * |
| * Caller must check the pointer with access_ok() before calling this |
| * function. |
| * |
| * Returns zero on success, or -EFAULT on error. |
| * On error, the variable @x is set to zero. |
| */ |
| #define __get_user(x, ptr) \ |
| __get_user_nocheck((x), (ptr), sizeof(*(ptr))) |
| |
| |
| /** |
| * __put_user: - Write a simple value into user space, with less checking. |
| * @x: Value to copy to user space. |
| * @ptr: Destination address, in user space. |
| * |
| * Context: User context only. This function may sleep. |
| * |
| * This macro copies a single simple value from kernel space to user |
| * space. It supports simple types like char and int, but not larger |
| * data types like structures or arrays. |
| * |
| * @ptr must have pointer-to-simple-variable type, and @x must be assignable |
| * to the result of dereferencing @ptr. |
| * |
| * Caller must check the pointer with access_ok() before calling this |
| * function. |
| * |
| * Returns zero on success, or -EFAULT on error. |
| */ |
| #define __put_user(x, ptr) \ |
| __put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr))) |
| |
| unsigned long __must_check __copy_to_user_ll |
| (void __user *to, const void *from, unsigned long n); |
| unsigned long __must_check __copy_from_user_ll |
| (void *to, const void __user *from, unsigned long n); |
| unsigned long __must_check __copy_from_user_ll_nozero |
| (void *to, const void __user *from, unsigned long n); |
| unsigned long __must_check __copy_from_user_ll_nocache |
| (void *to, const void __user *from, unsigned long n); |
| unsigned long __must_check __copy_from_user_ll_nocache_nozero |
| (void *to, const void __user *from, unsigned long n); |
| |
| /** |
| * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking. |
| * @to: Destination address, in user space. |
| * @from: Source address, in kernel space. |
| * @n: Number of bytes to copy. |
| * |
| * Context: User context only. |
| * |
| * Copy data from kernel space to user space. Caller must check |
| * the specified block with access_ok() before calling this function. |
| * The caller should also make sure he pins the user space address |
| * so that the we don't result in page fault and sleep. |
| * |
| * Here we special-case 1, 2 and 4-byte copy_*_user invocations. On a fault |
| * we return the initial request size (1, 2 or 4), as copy_*_user should do. |
| * If a store crosses a page boundary and gets a fault, the x86 will not write |
| * anything, so this is accurate. |
| */ |
| |
| static __always_inline unsigned long __must_check |
| __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n) |
| { |
| if (__builtin_constant_p(n)) { |
| unsigned long ret; |
| |
| switch (n) { |
| case 1: |
| __put_user_size(*(u8 *)from, (u8 __user *)to, |
| 1, ret, 1); |
| return ret; |
| case 2: |
| __put_user_size(*(u16 *)from, (u16 __user *)to, |
| 2, ret, 2); |
| return ret; |
| case 4: |
| __put_user_size(*(u32 *)from, (u32 __user *)to, |
| 4, ret, 4); |
| return ret; |
| } |
| } |
| return __copy_to_user_ll(to, from, n); |
| } |
| |
| /** |
| * __copy_to_user: - Copy a block of data into user space, with less checking. |
| * @to: Destination address, in user space. |
| * @from: Source address, in kernel space. |
| * @n: Number of bytes to copy. |
| * |
| * Context: User context only. This function may sleep. |
| * |
| * Copy data from kernel space to user space. Caller must check |
| * the specified block with access_ok() before calling this function. |
| * |
| * Returns number of bytes that could not be copied. |
| * On success, this will be zero. |
| */ |
| static __always_inline unsigned long __must_check |
| __copy_to_user(void __user *to, const void *from, unsigned long n) |
| { |
| might_sleep(); |
| return __copy_to_user_inatomic(to, from, n); |
| } |
| |
| static __always_inline unsigned long |
| __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n) |
| { |
| /* Avoid zeroing the tail if the copy fails.. |
| * If 'n' is constant and 1, 2, or 4, we do still zero on a failure, |
| * but as the zeroing behaviour is only significant when n is not |
| * constant, that shouldn't be a problem. |
| */ |
| if (__builtin_constant_p(n)) { |
| unsigned long ret; |
| |
| switch (n) { |
| case 1: |
| __get_user_size(*(u8 *)to, from, 1, ret, 1); |
| return ret; |
| case 2: |
| __get_user_size(*(u16 *)to, from, 2, ret, 2); |
| return ret; |
| case 4: |
| __get_user_size(*(u32 *)to, from, 4, ret, 4); |
| return ret; |
| } |
| } |
| return __copy_from_user_ll_nozero(to, from, n); |
| } |
| |
| /** |
| * __copy_from_user: - Copy a block of data from user space, with less checking. |
| * @to: Destination address, in kernel space. |
| * @from: Source address, in user space. |
| * @n: Number of bytes to copy. |
| * |
| * Context: User context only. This function may sleep. |
| * |
| * Copy data from user space to kernel space. Caller must check |
| * the specified block with access_ok() before calling this function. |
| * |
| * Returns number of bytes that could not be copied. |
| * On success, this will be zero. |
| * |
| * If some data could not be copied, this function will pad the copied |
| * data to the requested size using zero bytes. |
| * |
| * An alternate version - __copy_from_user_inatomic() - may be called from |
| * atomic context and will fail rather than sleep. In this case the |
| * uncopied bytes will *NOT* be padded with zeros. See fs/filemap.h |
| * for explanation of why this is needed. |
| */ |
| static __always_inline unsigned long |
| __copy_from_user(void *to, const void __user *from, unsigned long n) |
| { |
| might_sleep(); |
| if (__builtin_constant_p(n)) { |
| unsigned long ret; |
| |
| switch (n) { |
| case 1: |
| __get_user_size(*(u8 *)to, from, 1, ret, 1); |
| return ret; |
| case 2: |
| __get_user_size(*(u16 *)to, from, 2, ret, 2); |
| return ret; |
| case 4: |
| __get_user_size(*(u32 *)to, from, 4, ret, 4); |
| return ret; |
| } |
| } |
| return __copy_from_user_ll(to, from, n); |
| } |
| |
| #define ARCH_HAS_NOCACHE_UACCESS |
| |
| static __always_inline unsigned long __copy_from_user_nocache(void *to, |
| const void __user *from, unsigned long n) |
| { |
| might_sleep(); |
| if (__builtin_constant_p(n)) { |
| unsigned long ret; |
| |
| switch (n) { |
| case 1: |
| __get_user_size(*(u8 *)to, from, 1, ret, 1); |
| return ret; |
| case 2: |
| __get_user_size(*(u16 *)to, from, 2, ret, 2); |
| return ret; |
| case 4: |
| __get_user_size(*(u32 *)to, from, 4, ret, 4); |
| return ret; |
| } |
| } |
| return __copy_from_user_ll_nocache(to, from, n); |
| } |
| |
| static __always_inline unsigned long |
| __copy_from_user_inatomic_nocache(void *to, const void __user *from, |
| unsigned long n) |
| { |
| return __copy_from_user_ll_nocache_nozero(to, from, n); |
| } |
| |
| unsigned long __must_check copy_to_user(void __user *to, |
| const void *from, unsigned long n); |
| unsigned long __must_check copy_from_user(void *to, |
| const void __user *from, |
| unsigned long n); |
| long __must_check strncpy_from_user(char *dst, const char __user *src, |
| long count); |
| long __must_check __strncpy_from_user(char *dst, |
| const char __user *src, long count); |
| |
| /** |
| * strlen_user: - Get the size of a string in user space. |
| * @str: The string to measure. |
| * |
| * Context: User context only. This function may sleep. |
| * |
| * Get the size of a NUL-terminated string in user space. |
| * |
| * Returns the size of the string INCLUDING the terminating NUL. |
| * On exception, returns 0. |
| * |
| * If there is a limit on the length of a valid string, you may wish to |
| * consider using strnlen_user() instead. |
| */ |
| #define strlen_user(str) strnlen_user(str, LONG_MAX) |
| |
| long strnlen_user(const char __user *str, long n); |
| unsigned long __must_check clear_user(void __user *mem, unsigned long len); |
| unsigned long __must_check __clear_user(void __user *mem, unsigned long len); |
| |
| #endif /* __i386_UACCESS_H */ |