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_fault(); 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_fault(); 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_fault(); 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