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/string.h> 8 #include <asm/asm.h> 9 #include <asm/page.h> 10 11 unsigned long __must_check __copy_to_user_ll 12 (void __user *to, const void *from, unsigned long n); 13 unsigned long __must_check __copy_from_user_ll 14 (void *to, const void __user *from, unsigned long n); 15 unsigned long __must_check __copy_from_user_ll_nozero 16 (void *to, const void __user *from, unsigned long n); 17 unsigned long __must_check __copy_from_user_ll_nocache 18 (void *to, const void __user *from, unsigned long n); 19 unsigned long __must_check __copy_from_user_ll_nocache_nozero 20 (void *to, const void __user *from, unsigned long n); 21 22 /** 23 * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking. 24 * @to: Destination address, in user space. 25 * @from: Source address, in kernel space. 26 * @n: Number of bytes to copy. 27 * 28 * Context: User context only. 29 * 30 * Copy data from kernel space to user space. Caller must check 31 * the specified block with access_ok() before calling this function. 32 * The caller should also make sure he pins the user space address 33 * so that we don't result in page fault and sleep. 34 */ 35 static __always_inline unsigned long __must_check 36 __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n) 37 { 38 check_object_size(from, n, true); 39 return __copy_to_user_ll(to, from, n); 40 } 41 42 /** 43 * __copy_to_user: - Copy a block of data into user space, with less checking. 44 * @to: Destination address, in user space. 45 * @from: Source address, in kernel space. 46 * @n: Number of bytes to copy. 47 * 48 * Context: User context only. This function may sleep if pagefaults are 49 * enabled. 50 * 51 * Copy data from kernel space to user space. Caller must check 52 * the specified block with access_ok() before calling this function. 53 * 54 * Returns number of bytes that could not be copied. 55 * On success, this will be zero. 56 */ 57 static __always_inline unsigned long __must_check 58 __copy_to_user(void __user *to, const void *from, unsigned long n) 59 { 60 might_fault(); 61 return __copy_to_user_inatomic(to, from, n); 62 } 63 64 static __always_inline unsigned long 65 __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n) 66 { 67 return __copy_from_user_ll_nozero(to, from, n); 68 } 69 70 /** 71 * __copy_from_user: - Copy a block of data from user space, with less checking. 72 * @to: Destination address, in kernel space. 73 * @from: Source address, in user space. 74 * @n: Number of bytes to copy. 75 * 76 * Context: User context only. This function may sleep if pagefaults are 77 * enabled. 78 * 79 * Copy data from user space to kernel space. Caller must check 80 * the specified block with access_ok() before calling this function. 81 * 82 * Returns number of bytes that could not be copied. 83 * On success, this will be zero. 84 * 85 * If some data could not be copied, this function will pad the copied 86 * data to the requested size using zero bytes. 87 * 88 * An alternate version - __copy_from_user_inatomic() - may be called from 89 * atomic context and will fail rather than sleep. In this case the 90 * uncopied bytes will *NOT* be padded with zeros. See fs/filemap.h 91 * for explanation of why this is needed. 92 */ 93 static __always_inline unsigned long 94 __copy_from_user(void *to, const void __user *from, unsigned long n) 95 { 96 might_fault(); 97 check_object_size(to, n, false); 98 if (__builtin_constant_p(n)) { 99 unsigned long ret; 100 101 switch (n) { 102 case 1: 103 __uaccess_begin(); 104 __get_user_size(*(u8 *)to, from, 1, ret, 1); 105 __uaccess_end(); 106 return ret; 107 case 2: 108 __uaccess_begin(); 109 __get_user_size(*(u16 *)to, from, 2, ret, 2); 110 __uaccess_end(); 111 return ret; 112 case 4: 113 __uaccess_begin(); 114 __get_user_size(*(u32 *)to, from, 4, ret, 4); 115 __uaccess_end(); 116 return ret; 117 } 118 } 119 return __copy_from_user_ll(to, from, n); 120 } 121 122 static __always_inline unsigned long __copy_from_user_nocache(void *to, 123 const void __user *from, unsigned long n) 124 { 125 might_fault(); 126 if (__builtin_constant_p(n)) { 127 unsigned long ret; 128 129 switch (n) { 130 case 1: 131 __uaccess_begin(); 132 __get_user_size(*(u8 *)to, from, 1, ret, 1); 133 __uaccess_end(); 134 return ret; 135 case 2: 136 __uaccess_begin(); 137 __get_user_size(*(u16 *)to, from, 2, ret, 2); 138 __uaccess_end(); 139 return ret; 140 case 4: 141 __uaccess_begin(); 142 __get_user_size(*(u32 *)to, from, 4, ret, 4); 143 __uaccess_end(); 144 return ret; 145 } 146 } 147 return __copy_from_user_ll_nocache(to, from, n); 148 } 149 150 static __always_inline unsigned long 151 __copy_from_user_inatomic_nocache(void *to, const void __user *from, 152 unsigned long n) 153 { 154 return __copy_from_user_ll_nocache_nozero(to, from, n); 155 } 156 157 #endif /* _ASM_X86_UACCESS_32_H */ 158