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 14unsigned long __must_check __copy_to_user_ll 15 (void __user *to, const void *from, unsigned long n); 16unsigned long __must_check __copy_from_user_ll 17 (void *to, const void __user *from, unsigned long n); 18unsigned long __must_check __copy_from_user_ll_nozero 19 (void *to, const void __user *from, unsigned long n); 20unsigned long __must_check __copy_from_user_ll_nocache 21 (void *to, const void __user *from, unsigned long n); 22unsigned 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 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 44static __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 */ 82static __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 89static __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 */ 137static __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 159static __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 181static __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 188unsigned long __must_check copy_to_user(void __user *to, 189 const void *from, unsigned long n); 190unsigned long __must_check _copy_from_user(void *to, 191 const void __user *from, 192 unsigned long n); 193 194 195extern void copy_from_user_overflow(void) 196#ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS 197 __compiletime_error("copy_from_user() buffer size is not provably correct") 198#else 199 __compiletime_warning("copy_from_user() buffer size is not provably correct") 200#endif 201; 202 203static inline unsigned long __must_check copy_from_user(void *to, 204 const void __user *from, 205 unsigned long n) 206{ 207 int sz = __compiletime_object_size(to); 208 209 if (likely(sz == -1 || sz >= n)) 210 n = _copy_from_user(to, from, n); 211 else 212 copy_from_user_overflow(); 213 214 return n; 215} 216 217long __must_check strncpy_from_user(char *dst, const char __user *src, 218 long count); 219long __must_check __strncpy_from_user(char *dst, 220 const char __user *src, long count); 221 222/** 223 * strlen_user: - Get the size of a string in user space. 224 * @str: The string to measure. 225 * 226 * Context: User context only. This function may sleep. 227 * 228 * Get the size of a NUL-terminated string in user space. 229 * 230 * Returns the size of the string INCLUDING the terminating NUL. 231 * On exception, returns 0. 232 * 233 * If there is a limit on the length of a valid string, you may wish to 234 * consider using strnlen_user() instead. 235 */ 236#define strlen_user(str) strnlen_user(str, LONG_MAX) 237 238long strnlen_user(const char __user *str, long n); 239unsigned long __must_check clear_user(void __user *mem, unsigned long len); 240unsigned long __must_check __clear_user(void __user *mem, unsigned long len); 241 242#endif /* _ASM_X86_UACCESS_32_H */ 243