1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __ASM_GENERIC_UACCESS_H
3 #define __ASM_GENERIC_UACCESS_H
4
5 /*
6 * User space memory access functions, these should work
7 * on any machine that has kernel and user data in the same
8 * address space, e.g. all NOMMU machines.
9 */
10 #include <linux/string.h>
11
12 #ifdef CONFIG_UACCESS_MEMCPY
13 #include <asm/unaligned.h>
14
15 static __always_inline int
__get_user_fn(size_t size,const void __user * from,void * to)16 __get_user_fn(size_t size, const void __user *from, void *to)
17 {
18 BUILD_BUG_ON(!__builtin_constant_p(size));
19
20 switch (size) {
21 case 1:
22 *(u8 *)to = get_unaligned((u8 __force *)from);
23 return 0;
24 case 2:
25 *(u16 *)to = get_unaligned((u16 __force *)from);
26 return 0;
27 case 4:
28 *(u32 *)to = get_unaligned((u32 __force *)from);
29 return 0;
30 case 8:
31 *(u64 *)to = get_unaligned((u64 __force *)from);
32 return 0;
33 default:
34 BUILD_BUG();
35 return 0;
36 }
37
38 }
39 #define __get_user_fn(sz, u, k) __get_user_fn(sz, u, k)
40
41 static __always_inline int
__put_user_fn(size_t size,void __user * to,void * from)42 __put_user_fn(size_t size, void __user *to, void *from)
43 {
44 BUILD_BUG_ON(!__builtin_constant_p(size));
45
46 switch (size) {
47 case 1:
48 put_unaligned(*(u8 *)from, (u8 __force *)to);
49 return 0;
50 case 2:
51 put_unaligned(*(u16 *)from, (u16 __force *)to);
52 return 0;
53 case 4:
54 put_unaligned(*(u32 *)from, (u32 __force *)to);
55 return 0;
56 case 8:
57 put_unaligned(*(u64 *)from, (u64 __force *)to);
58 return 0;
59 default:
60 BUILD_BUG();
61 return 0;
62 }
63 }
64 #define __put_user_fn(sz, u, k) __put_user_fn(sz, u, k)
65
66 #define __get_kernel_nofault(dst, src, type, err_label) \
67 do { \
68 *((type *)dst) = get_unaligned((type *)(src)); \
69 if (0) /* make sure the label looks used to the compiler */ \
70 goto err_label; \
71 } while (0)
72
73 #define __put_kernel_nofault(dst, src, type, err_label) \
74 do { \
75 put_unaligned(*((type *)src), (type *)(dst)); \
76 if (0) /* make sure the label looks used to the compiler */ \
77 goto err_label; \
78 } while (0)
79
80 #define HAVE_GET_KERNEL_NOFAULT 1
81
82 static inline __must_check unsigned long
raw_copy_from_user(void * to,const void __user * from,unsigned long n)83 raw_copy_from_user(void *to, const void __user * from, unsigned long n)
84 {
85 memcpy(to, (const void __force *)from, n);
86 return 0;
87 }
88
89 static inline __must_check unsigned long
raw_copy_to_user(void __user * to,const void * from,unsigned long n)90 raw_copy_to_user(void __user *to, const void *from, unsigned long n)
91 {
92 memcpy((void __force *)to, from, n);
93 return 0;
94 }
95 #define INLINE_COPY_FROM_USER
96 #define INLINE_COPY_TO_USER
97 #endif /* CONFIG_UACCESS_MEMCPY */
98
99 #ifdef CONFIG_SET_FS
100 #define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
101
102 #ifndef KERNEL_DS
103 #define KERNEL_DS MAKE_MM_SEG(~0UL)
104 #endif
105
106 #ifndef USER_DS
107 #define USER_DS MAKE_MM_SEG(TASK_SIZE - 1)
108 #endif
109
110 #ifndef get_fs
111 #define get_fs() (current_thread_info()->addr_limit)
112
set_fs(mm_segment_t fs)113 static inline void set_fs(mm_segment_t fs)
114 {
115 current_thread_info()->addr_limit = fs;
116 }
117 #endif
118
119 #ifndef uaccess_kernel
120 #define uaccess_kernel() (get_fs().seg == KERNEL_DS.seg)
121 #endif
122 #endif /* CONFIG_SET_FS */
123
124 #define access_ok(addr, size) __access_ok((unsigned long)(addr),(size))
125
126 /*
127 * The architecture should really override this if possible, at least
128 * doing a check on the get_fs()
129 */
130 #ifndef __access_ok
__access_ok(unsigned long addr,unsigned long size)131 static inline int __access_ok(unsigned long addr, unsigned long size)
132 {
133 return 1;
134 }
135 #endif
136
137 /*
138 * These are the main single-value transfer routines. They automatically
139 * use the right size if we just have the right pointer type.
140 * This version just falls back to copy_{from,to}_user, which should
141 * provide a fast-path for small values.
142 */
143 #define __put_user(x, ptr) \
144 ({ \
145 __typeof__(*(ptr)) __x = (x); \
146 int __pu_err = -EFAULT; \
147 __chk_user_ptr(ptr); \
148 switch (sizeof (*(ptr))) { \
149 case 1: \
150 case 2: \
151 case 4: \
152 case 8: \
153 __pu_err = __put_user_fn(sizeof (*(ptr)), \
154 ptr, &__x); \
155 break; \
156 default: \
157 __put_user_bad(); \
158 break; \
159 } \
160 __pu_err; \
161 })
162
163 #define put_user(x, ptr) \
164 ({ \
165 void __user *__p = (ptr); \
166 might_fault(); \
167 access_ok(__p, sizeof(*ptr)) ? \
168 __put_user((x), ((__typeof__(*(ptr)) __user *)__p)) : \
169 -EFAULT; \
170 })
171
172 #ifndef __put_user_fn
173
__put_user_fn(size_t size,void __user * ptr,void * x)174 static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
175 {
176 return unlikely(raw_copy_to_user(ptr, x, size)) ? -EFAULT : 0;
177 }
178
179 #define __put_user_fn(sz, u, k) __put_user_fn(sz, u, k)
180
181 #endif
182
183 extern int __put_user_bad(void) __attribute__((noreturn));
184
185 #define __get_user(x, ptr) \
186 ({ \
187 int __gu_err = -EFAULT; \
188 __chk_user_ptr(ptr); \
189 switch (sizeof(*(ptr))) { \
190 case 1: { \
191 unsigned char __x = 0; \
192 __gu_err = __get_user_fn(sizeof (*(ptr)), \
193 ptr, &__x); \
194 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
195 break; \
196 }; \
197 case 2: { \
198 unsigned short __x = 0; \
199 __gu_err = __get_user_fn(sizeof (*(ptr)), \
200 ptr, &__x); \
201 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
202 break; \
203 }; \
204 case 4: { \
205 unsigned int __x = 0; \
206 __gu_err = __get_user_fn(sizeof (*(ptr)), \
207 ptr, &__x); \
208 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
209 break; \
210 }; \
211 case 8: { \
212 unsigned long long __x = 0; \
213 __gu_err = __get_user_fn(sizeof (*(ptr)), \
214 ptr, &__x); \
215 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
216 break; \
217 }; \
218 default: \
219 __get_user_bad(); \
220 break; \
221 } \
222 __gu_err; \
223 })
224
225 #define get_user(x, ptr) \
226 ({ \
227 const void __user *__p = (ptr); \
228 might_fault(); \
229 access_ok(__p, sizeof(*ptr)) ? \
230 __get_user((x), (__typeof__(*(ptr)) __user *)__p) :\
231 ((x) = (__typeof__(*(ptr)))0,-EFAULT); \
232 })
233
234 #ifndef __get_user_fn
__get_user_fn(size_t size,const void __user * ptr,void * x)235 static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
236 {
237 return unlikely(raw_copy_from_user(x, ptr, size)) ? -EFAULT : 0;
238 }
239
240 #define __get_user_fn(sz, u, k) __get_user_fn(sz, u, k)
241
242 #endif
243
244 extern int __get_user_bad(void) __attribute__((noreturn));
245
246 /*
247 * Copy a null terminated string from userspace.
248 */
249 #ifndef __strncpy_from_user
250 static inline long
__strncpy_from_user(char * dst,const char __user * src,long count)251 __strncpy_from_user(char *dst, const char __user *src, long count)
252 {
253 char *tmp;
254 strncpy(dst, (const char __force *)src, count);
255 for (tmp = dst; *tmp && count > 0; tmp++, count--)
256 ;
257 return (tmp - dst);
258 }
259 #endif
260
261 static inline long
strncpy_from_user(char * dst,const char __user * src,long count)262 strncpy_from_user(char *dst, const char __user *src, long count)
263 {
264 if (!access_ok(src, 1))
265 return -EFAULT;
266 return __strncpy_from_user(dst, src, count);
267 }
268
269 /*
270 * Return the size of a string (including the ending 0)
271 *
272 * Return 0 on exception, a value greater than N if too long
273 */
274 #ifndef __strnlen_user
275 #define __strnlen_user(s, n) (strnlen((s), (n)) + 1)
276 #endif
277
278 /*
279 * Unlike strnlen, strnlen_user includes the nul terminator in
280 * its returned count. Callers should check for a returned value
281 * greater than N as an indication the string is too long.
282 */
strnlen_user(const char __user * src,long n)283 static inline long strnlen_user(const char __user *src, long n)
284 {
285 if (!access_ok(src, 1))
286 return 0;
287 return __strnlen_user(src, n);
288 }
289
290 /*
291 * Zero Userspace
292 */
293 #ifndef __clear_user
294 static inline __must_check unsigned long
__clear_user(void __user * to,unsigned long n)295 __clear_user(void __user *to, unsigned long n)
296 {
297 memset((void __force *)to, 0, n);
298 return 0;
299 }
300 #endif
301
302 static inline __must_check unsigned long
clear_user(void __user * to,unsigned long n)303 clear_user(void __user *to, unsigned long n)
304 {
305 might_fault();
306 if (!access_ok(to, n))
307 return n;
308
309 return __clear_user(to, n);
310 }
311
312 #include <asm/extable.h>
313
314 #endif /* __ASM_GENERIC_UACCESS_H */
315