Loading...
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
13unsigned long __must_check __copy_to_user_ll
14 (void __user *to, const void *from, unsigned long n);
15unsigned long __must_check __copy_from_user_ll
16 (void *to, const void __user *from, unsigned long n);
17unsigned long __must_check __copy_from_user_ll_nozero
18 (void *to, const void __user *from, unsigned long n);
19unsigned long __must_check __copy_from_user_ll_nocache
20 (void *to, const void __user *from, unsigned long n);
21unsigned 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
43static __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 */
94static __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
101static __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 */
156static __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
184static __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
212static __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 */
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _ASM_X86_UACCESS_32_H
3#define _ASM_X86_UACCESS_32_H
4
5/*
6 * User space memory access functions
7 */
8#include <linux/string.h>
9#include <asm/asm.h>
10#include <asm/page.h>
11
12unsigned long __must_check __copy_user_ll
13 (void *to, const void *from, unsigned long n);
14unsigned long __must_check __copy_from_user_ll_nocache_nozero
15 (void *to, const void __user *from, unsigned long n);
16
17static __always_inline unsigned long __must_check
18raw_copy_to_user(void __user *to, const void *from, unsigned long n)
19{
20 return __copy_user_ll((__force void *)to, from, n);
21}
22
23static __always_inline unsigned long
24raw_copy_from_user(void *to, const void __user *from, unsigned long n)
25{
26 return __copy_user_ll(to, (__force const void *)from, n);
27}
28
29static __always_inline unsigned long
30__copy_from_user_inatomic_nocache(void *to, const void __user *from,
31 unsigned long n)
32{
33 return __copy_from_user_ll_nocache_nozero(to, from, n);
34}
35
36unsigned long __must_check clear_user(void __user *mem, unsigned long len);
37unsigned long __must_check __clear_user(void __user *mem, unsigned long len);
38
39#endif /* _ASM_X86_UACCESS_32_H */