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