1 #ifndef __i386_UACCESS_H
2 #define __i386_UACCESS_H
5 * User space memory access functions
7 #include <linux/errno.h>
8 #include <linux/thread_info.h>
9 #include <linux/prefetch.h>
10 #include <linux/string.h>
15 * movsl can be slow when source and dest are not both 8-byte aligned
17 #ifdef CONFIG_X86_INTEL_USERCOPY
18 extern struct movsl_mask {
20 } ____cacheline_aligned_in_smp movsl_mask;
23 extern void __put_user_bad(void);
26 * Strange magic calling convention: pointer in %ecx,
27 * value in %eax(:%edx), return value in %eax, no clobbers.
29 extern void __put_user_1(void);
30 extern void __put_user_2(void);
31 extern void __put_user_4(void);
32 extern void __put_user_8(void);
34 #define __put_user_x(size, x, ptr) \
35 asm volatile("call __put_user_" #size : "=a" (__ret_pu) \
36 :"0" ((typeof(*(ptr)))(x)), "c" (ptr) : "ebx")
38 #define __put_user_8(x, ptr) \
39 asm volatile("call __put_user_8" : "=a" (__ret_pu) \
40 : "A" ((typeof(*(ptr)))(x)), "c" (ptr) : "ebx")
44 * put_user: - Write a simple value into user space.
45 * @x: Value to copy to user space.
46 * @ptr: Destination address, in user space.
48 * Context: User context only. This function may sleep.
50 * This macro copies a single simple value from kernel space to user
51 * space. It supports simple types like char and int, but not larger
52 * data types like structures or arrays.
54 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
55 * to the result of dereferencing @ptr.
57 * Returns zero on success, or -EFAULT on error.
59 #ifdef CONFIG_X86_WP_WORKS_OK
61 #define put_user(x, ptr) \
64 __typeof__(*(ptr)) __pu_val; \
65 __chk_user_ptr(ptr); \
67 switch (sizeof(*(ptr))) { \
69 __put_user_x(1, __pu_val, ptr); \
72 __put_user_x(2, __pu_val, ptr); \
75 __put_user_x(4, __pu_val, ptr); \
78 __put_user_8(__pu_val, ptr); \
81 __put_user_x(X, __pu_val, ptr); \
88 #define put_user(x, ptr) \
91 __typeof__(*(ptr))__pus_tmp = x; \
93 if (unlikely(__copy_to_user_ll(ptr, &__pus_tmp, \
94 sizeof(*(ptr))) != 0)) \
103 * __get_user: - Get a simple variable from user space, with less checking.
104 * @x: Variable to store result.
105 * @ptr: Source address, in user space.
107 * Context: User context only. This function may sleep.
109 * This macro copies a single simple variable from user space to kernel
110 * space. It supports simple types like char and int, but not larger
111 * data types like structures or arrays.
113 * @ptr must have pointer-to-simple-variable type, and the result of
114 * dereferencing @ptr must be assignable to @x without a cast.
116 * Caller must check the pointer with access_ok() before calling this
119 * Returns zero on success, or -EFAULT on error.
120 * On error, the variable @x is set to zero.
122 #define __get_user(x, ptr) \
123 __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
127 * __put_user: - Write a simple value into user space, with less checking.
128 * @x: Value to copy to user space.
129 * @ptr: Destination address, in user space.
131 * Context: User context only. This function may sleep.
133 * This macro copies a single simple value from kernel space to user
134 * space. It supports simple types like char and int, but not larger
135 * data types like structures or arrays.
137 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
138 * to the result of dereferencing @ptr.
140 * Caller must check the pointer with access_ok() before calling this
143 * Returns zero on success, or -EFAULT on error.
145 #define __put_user(x, ptr) \
146 __put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
148 #define __get_user_nocheck(x, ptr, size) \
151 unsigned long __gu_val; \
152 __get_user_size(__gu_val, (ptr), (size), __gu_err, -EFAULT); \
153 (x) = (__typeof__(*(ptr)))__gu_val; \
157 #define __get_user_size(x, ptr, size, retval, errret) \
160 __chk_user_ptr(ptr); \
163 __get_user_asm(x, ptr, retval, "b", "b", "=q", errret); \
166 __get_user_asm(x, ptr, retval, "w", "w", "=r", errret); \
169 __get_user_asm(x, ptr, retval, "l", "", "=r", errret); \
172 (x) = __get_user_bad(); \
176 #define __get_user_asm(x, addr, err, itype, rtype, ltype, errret) \
177 asm volatile("1: mov"itype" %2,%"rtype"1\n" \
179 ".section .fixup,\"ax\"\n" \
181 " xor"itype" %"rtype"1,%"rtype"1\n" \
184 _ASM_EXTABLE(1b, 3b) \
185 : "=r" (err), ltype (x) \
186 : "m" (__m(addr)), "i" (errret), "0" (err))
189 unsigned long __must_check __copy_to_user_ll
190 (void __user *to, const void *from, unsigned long n);
191 unsigned long __must_check __copy_from_user_ll
192 (void *to, const void __user *from, unsigned long n);
193 unsigned long __must_check __copy_from_user_ll_nozero
194 (void *to, const void __user *from, unsigned long n);
195 unsigned long __must_check __copy_from_user_ll_nocache
196 (void *to, const void __user *from, unsigned long n);
197 unsigned long __must_check __copy_from_user_ll_nocache_nozero
198 (void *to, const void __user *from, unsigned long n);
201 * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking.
202 * @to: Destination address, in user space.
203 * @from: Source address, in kernel space.
204 * @n: Number of bytes to copy.
206 * Context: User context only.
208 * Copy data from kernel space to user space. Caller must check
209 * the specified block with access_ok() before calling this function.
210 * The caller should also make sure he pins the user space address
211 * so that the we don't result in page fault and sleep.
213 * Here we special-case 1, 2 and 4-byte copy_*_user invocations. On a fault
214 * we return the initial request size (1, 2 or 4), as copy_*_user should do.
215 * If a store crosses a page boundary and gets a fault, the x86 will not write
216 * anything, so this is accurate.
219 static __always_inline unsigned long __must_check
220 __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
222 if (__builtin_constant_p(n)) {
227 __put_user_size(*(u8 *)from, (u8 __user *)to,
231 __put_user_size(*(u16 *)from, (u16 __user *)to,
235 __put_user_size(*(u32 *)from, (u32 __user *)to,
240 return __copy_to_user_ll(to, from, n);
244 * __copy_to_user: - Copy a block of data into user space, with less checking.
245 * @to: Destination address, in user space.
246 * @from: Source address, in kernel space.
247 * @n: Number of bytes to copy.
249 * Context: User context only. This function may sleep.
251 * Copy data from kernel space to user space. Caller must check
252 * the specified block with access_ok() before calling this function.
254 * Returns number of bytes that could not be copied.
255 * On success, this will be zero.
257 static __always_inline unsigned long __must_check
258 __copy_to_user(void __user *to, const void *from, unsigned long n)
261 return __copy_to_user_inatomic(to, from, n);
264 static __always_inline unsigned long
265 __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
267 /* Avoid zeroing the tail if the copy fails..
268 * If 'n' is constant and 1, 2, or 4, we do still zero on a failure,
269 * but as the zeroing behaviour is only significant when n is not
270 * constant, that shouldn't be a problem.
272 if (__builtin_constant_p(n)) {
277 __get_user_size(*(u8 *)to, from, 1, ret, 1);
280 __get_user_size(*(u16 *)to, from, 2, ret, 2);
283 __get_user_size(*(u32 *)to, from, 4, ret, 4);
287 return __copy_from_user_ll_nozero(to, from, n);
291 * __copy_from_user: - Copy a block of data from user space, with less checking.
292 * @to: Destination address, in kernel space.
293 * @from: Source address, in user space.
294 * @n: Number of bytes to copy.
296 * Context: User context only. This function may sleep.
298 * Copy data from user space to kernel space. Caller must check
299 * the specified block with access_ok() before calling this function.
301 * Returns number of bytes that could not be copied.
302 * On success, this will be zero.
304 * If some data could not be copied, this function will pad the copied
305 * data to the requested size using zero bytes.
307 * An alternate version - __copy_from_user_inatomic() - may be called from
308 * atomic context and will fail rather than sleep. In this case the
309 * uncopied bytes will *NOT* be padded with zeros. See fs/filemap.h
310 * for explanation of why this is needed.
312 static __always_inline unsigned long
313 __copy_from_user(void *to, const void __user *from, unsigned long n)
316 if (__builtin_constant_p(n)) {
321 __get_user_size(*(u8 *)to, from, 1, ret, 1);
324 __get_user_size(*(u16 *)to, from, 2, ret, 2);
327 __get_user_size(*(u32 *)to, from, 4, ret, 4);
331 return __copy_from_user_ll(to, from, n);
334 #define ARCH_HAS_NOCACHE_UACCESS
336 static __always_inline unsigned long __copy_from_user_nocache(void *to,
337 const void __user *from, unsigned long n)
340 if (__builtin_constant_p(n)) {
345 __get_user_size(*(u8 *)to, from, 1, ret, 1);
348 __get_user_size(*(u16 *)to, from, 2, ret, 2);
351 __get_user_size(*(u32 *)to, from, 4, ret, 4);
355 return __copy_from_user_ll_nocache(to, from, n);
358 static __always_inline unsigned long
359 __copy_from_user_inatomic_nocache(void *to, const void __user *from,
362 return __copy_from_user_ll_nocache_nozero(to, from, n);
365 unsigned long __must_check copy_to_user(void __user *to,
366 const void *from, unsigned long n);
367 unsigned long __must_check copy_from_user(void *to,
368 const void __user *from,
370 long __must_check strncpy_from_user(char *dst, const char __user *src,
372 long __must_check __strncpy_from_user(char *dst,
373 const char __user *src, long count);
376 * strlen_user: - Get the size of a string in user space.
377 * @str: The string to measure.
379 * Context: User context only. This function may sleep.
381 * Get the size of a NUL-terminated string in user space.
383 * Returns the size of the string INCLUDING the terminating NUL.
384 * On exception, returns 0.
386 * If there is a limit on the length of a valid string, you may wish to
387 * consider using strnlen_user() instead.
389 #define strlen_user(str) strnlen_user(str, LONG_MAX)
391 long strnlen_user(const char __user *str, long n);
392 unsigned long __must_check clear_user(void __user *mem, unsigned long len);
393 unsigned long __must_check __clear_user(void __user *mem, unsigned long len);
395 #endif /* __i386_UACCESS_H */