uaccess_32.h 7.0 KB
Newer Older
H
H. Peter Anvin 已提交
1 2
#ifndef _ASM_X86_UACCESS_32_H
#define _ASM_X86_UACCESS_32_H
L
Linus Torvalds 已提交
3 4 5 6 7 8 9 10

/*
 * User space memory access functions
 */
#include <linux/errno.h>
#include <linux/thread_info.h>
#include <linux/prefetch.h>
#include <linux/string.h>
11
#include <asm/asm.h>
L
Linus Torvalds 已提交
12 13
#include <asm/page.h>

14 15 16 17 18 19 20 21 22 23
unsigned long __must_check __copy_to_user_ll
		(void __user *to, const void *from, unsigned long n);
unsigned long __must_check __copy_from_user_ll
		(void *to, const void __user *from, unsigned long n);
unsigned long __must_check __copy_from_user_ll_nozero
		(void *to, const void __user *from, unsigned long n);
unsigned long __must_check __copy_from_user_ll_nocache
		(void *to, const void __user *from, unsigned long n);
unsigned long __must_check __copy_from_user_ll_nocache_nozero
		(void *to, const void __user *from, unsigned long n);
L
Linus Torvalds 已提交
24

25 26 27 28 29 30 31 32 33 34 35
/**
 * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking.
 * @to:   Destination address, in user space.
 * @from: Source address, in kernel space.
 * @n:    Number of bytes to copy.
 *
 * Context: User context only.
 *
 * Copy data from kernel space to user space.  Caller must check
 * the specified block with access_ok() before calling this function.
 * The caller should also make sure he pins the user space address
S
Sergey Senozhatsky 已提交
36
 * so that we don't result in page fault and sleep.
37
 *
L
Linus Torvalds 已提交
38 39 40 41 42 43
 * Here we special-case 1, 2 and 4-byte copy_*_user invocations.  On a fault
 * we return the initial request size (1, 2 or 4), as copy_*_user should do.
 * If a store crosses a page boundary and gets a fault, the x86 will not write
 * anything, so this is accurate.
 */

44
static __always_inline unsigned long __must_check
L
Linus Torvalds 已提交
45 46 47 48 49 50 51
__copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
{
	if (__builtin_constant_p(n)) {
		unsigned long ret;

		switch (n) {
		case 1:
52 53
			__put_user_size(*(u8 *)from, (u8 __user *)to,
					1, ret, 1);
L
Linus Torvalds 已提交
54 55
			return ret;
		case 2:
56 57
			__put_user_size(*(u16 *)from, (u16 __user *)to,
					2, ret, 2);
L
Linus Torvalds 已提交
58 59
			return ret;
		case 4:
60 61
			__put_user_size(*(u32 *)from, (u32 __user *)to,
					4, ret, 4);
L
Linus Torvalds 已提交
62 63 64 65 66 67 68
			return ret;
		}
	}
	return __copy_to_user_ll(to, from, n);
}

/**
69 70 71
 * __copy_to_user: - Copy a block of data into user space, with less checking.
 * @to:   Destination address, in user space.
 * @from: Source address, in kernel space.
L
Linus Torvalds 已提交
72 73 74 75
 * @n:    Number of bytes to copy.
 *
 * Context: User context only.  This function may sleep.
 *
76
 * Copy data from kernel space to user space.  Caller must check
L
Linus Torvalds 已提交
77 78 79 80 81
 * the specified block with access_ok() before calling this function.
 *
 * Returns number of bytes that could not be copied.
 * On success, this will be zero.
 */
82 83 84
static __always_inline unsigned long __must_check
__copy_to_user(void __user *to, const void *from, unsigned long n)
{
85
	might_fault();
86
	return __copy_to_user_inatomic(to, from, n);
87 88
}

89
static __always_inline unsigned long
L
Linus Torvalds 已提交
90 91
__copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
{
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
	/* Avoid zeroing the tail if the copy fails..
	 * If 'n' is constant and 1, 2, or 4, we do still zero on a failure,
	 * but as the zeroing behaviour is only significant when n is not
	 * constant, that shouldn't be a problem.
	 */
	if (__builtin_constant_p(n)) {
		unsigned long ret;

		switch (n) {
		case 1:
			__get_user_size(*(u8 *)to, from, 1, ret, 1);
			return ret;
		case 2:
			__get_user_size(*(u16 *)to, from, 2, ret, 2);
			return ret;
		case 4:
			__get_user_size(*(u32 *)to, from, 4, ret, 4);
			return ret;
		}
	}
	return __copy_from_user_ll_nozero(to, from, n);
}
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136

/**
 * __copy_from_user: - Copy a block of data from user space, with less checking.
 * @to:   Destination address, in kernel space.
 * @from: Source address, in user space.
 * @n:    Number of bytes to copy.
 *
 * Context: User context only.  This function may sleep.
 *
 * Copy data from user space to kernel space.  Caller must check
 * the specified block with access_ok() before calling this function.
 *
 * Returns number of bytes that could not be copied.
 * On success, this will be zero.
 *
 * If some data could not be copied, this function will pad the copied
 * data to the requested size using zero bytes.
 *
 * An alternate version - __copy_from_user_inatomic() - may be called from
 * atomic context and will fail rather than sleep.  In this case the
 * uncopied bytes will *NOT* be padded with zeros.  See fs/filemap.h
 * for explanation of why this is needed.
 */
137 138 139
static __always_inline unsigned long
__copy_from_user(void *to, const void __user *from, unsigned long n)
{
140
	might_fault();
L
Linus Torvalds 已提交
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
	if (__builtin_constant_p(n)) {
		unsigned long ret;

		switch (n) {
		case 1:
			__get_user_size(*(u8 *)to, from, 1, ret, 1);
			return ret;
		case 2:
			__get_user_size(*(u16 *)to, from, 2, ret, 2);
			return ret;
		case 4:
			__get_user_size(*(u32 *)to, from, 4, ret, 4);
			return ret;
		}
	}
	return __copy_from_user_ll(to, from, n);
}

159
static __always_inline unsigned long __copy_from_user_nocache(void *to,
160 161
				const void __user *from, unsigned long n)
{
162
	might_fault();
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
	if (__builtin_constant_p(n)) {
		unsigned long ret;

		switch (n) {
		case 1:
			__get_user_size(*(u8 *)to, from, 1, ret, 1);
			return ret;
		case 2:
			__get_user_size(*(u16 *)to, from, 2, ret, 2);
			return ret;
		case 4:
			__get_user_size(*(u32 *)to, from, 4, ret, 4);
			return ret;
		}
	}
	return __copy_from_user_ll_nocache(to, from, n);
}

181
static __always_inline unsigned long
182 183
__copy_from_user_inatomic_nocache(void *to, const void __user *from,
				  unsigned long n)
L
Linus Torvalds 已提交
184
{
185
       return __copy_from_user_ll_nocache_nozero(to, from, n);
186 187
}

L
Linus Torvalds 已提交
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 192
					  const void __user *from,
					  unsigned long n);
193

194 195

extern void copy_from_user_overflow(void)
196 197 198
#ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS
	__compiletime_error("copy_from_user() buffer size is not provably correct")
#else
199 200 201 202
	__compiletime_warning("copy_from_user() buffer size is not provably correct")
#endif
;

203 204 205 206 207 208 209 210 211 212
static inline unsigned long __must_check copy_from_user(void *to,
					  const void __user *from,
					  unsigned long n)
{
	int sz = __compiletime_object_size(to);
	int ret = -EFAULT;

	if (likely(sz == -1 || sz >= n))
		ret = _copy_from_user(to, from, n);
	else
213 214
		copy_from_user_overflow();

215 216 217
	return ret;
}

L
Linus Torvalds 已提交
218
long __must_check strncpy_from_user(char *dst, const char __user *src,
219
				    long count);
L
Linus Torvalds 已提交
220
long __must_check __strncpy_from_user(char *dst,
221
				      const char __user *src, long count);
L
Linus Torvalds 已提交
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236

/**
 * strlen_user: - Get the size of a string in user space.
 * @str: The string to measure.
 *
 * Context: User context only.  This function may sleep.
 *
 * Get the size of a NUL-terminated string in user space.
 *
 * Returns the size of the string INCLUDING the terminating NUL.
 * On exception, returns 0.
 *
 * If there is a limit on the length of a valid string, you may wish to
 * consider using strnlen_user() instead.
 */
237
#define strlen_user(str) strnlen_user(str, LONG_MAX)
L
Linus Torvalds 已提交
238 239 240 241 242

long strnlen_user(const char __user *str, long n);
unsigned long __must_check clear_user(void __user *mem, unsigned long len);
unsigned long __must_check __clear_user(void __user *mem, unsigned long len);

H
H. Peter Anvin 已提交
243
#endif /* _ASM_X86_UACCESS_32_H */