]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - arch/score/include/asm/uaccess.h
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branches 'asoc/topic/rt5659', 'asoc/topic/rt5660', 'asoc/topic...
[mirror_ubuntu-hirsute-kernel.git] / arch / score / include / asm / uaccess.h
1 #ifndef __SCORE_UACCESS_H
2 #define __SCORE_UACCESS_H
3
4 #include <linux/kernel.h>
5 #include <linux/errno.h>
6 #include <linux/thread_info.h>
7
8 #define VERIFY_READ 0
9 #define VERIFY_WRITE 1
10
11 #define get_ds() (KERNEL_DS)
12 #define get_fs() (current_thread_info()->addr_limit)
13 #define segment_eq(a, b) ((a).seg == (b).seg)
14
15 /*
16 * Is a address valid? This does a straighforward calculation rather
17 * than tests.
18 *
19 * Address valid if:
20 * - "addr" doesn't have any high-bits set
21 * - AND "size" doesn't have any high-bits set
22 * - AND "addr+size" doesn't have any high-bits set
23 * - OR we are in kernel mode.
24 *
25 * __ua_size() is a trick to avoid runtime checking of positive constant
26 * sizes; for those we already know at compile time that the size is ok.
27 */
28 #define __ua_size(size) \
29 ((__builtin_constant_p(size) && (signed long) (size) > 0) ? 0 : (size))
30
31 /*
32 * access_ok: - Checks if a user space pointer is valid
33 * @type: Type of access: %VERIFY_READ or %VERIFY_WRITE. Note that
34 * %VERIFY_WRITE is a superset of %VERIFY_READ - if it is safe
35 * to write to a block, it is always safe to read from it.
36 * @addr: User space pointer to start of block to check
37 * @size: Size of block to check
38 *
39 * Context: User context only. This function may sleep if pagefaults are
40 * enabled.
41 *
42 * Checks if a pointer to a block of memory in user space is valid.
43 *
44 * Returns true (nonzero) if the memory block may be valid, false (zero)
45 * if it is definitely invalid.
46 *
47 * Note that, depending on architecture, this function probably just
48 * checks that the pointer is in the user space range - after calling
49 * this function, memory access functions may still return -EFAULT.
50 */
51
52 #define __access_ok(addr, size) \
53 (((long)((get_fs().seg) & \
54 ((addr) | ((addr) + (size)) | \
55 __ua_size(size)))) == 0)
56
57 #define access_ok(type, addr, size) \
58 likely(__access_ok((unsigned long)(addr), (size)))
59
60 /*
61 * put_user: - Write a simple value into user space.
62 * @x: Value to copy to user space.
63 * @ptr: Destination address, in user space.
64 *
65 * Context: User context only. This function may sleep if pagefaults are
66 * enabled.
67 *
68 * This macro copies a single simple value from kernel space to user
69 * space. It supports simple types like char and int, but not larger
70 * data types like structures or arrays.
71 *
72 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
73 * to the result of dereferencing @ptr.
74 *
75 * Returns zero on success, or -EFAULT on error.
76 */
77 #define put_user(x, ptr) __put_user_check((x), (ptr), sizeof(*(ptr)))
78
79 /*
80 * get_user: - Get a simple variable from user space.
81 * @x: Variable to store result.
82 * @ptr: Source address, in user space.
83 *
84 * Context: User context only. This function may sleep if pagefaults are
85 * enabled.
86 *
87 * This macro copies a single simple variable from user space to kernel
88 * space. It supports simple types like char and int, but not larger
89 * data types like structures or arrays.
90 *
91 * @ptr must have pointer-to-simple-variable type, and the result of
92 * dereferencing @ptr must be assignable to @x without a cast.
93 *
94 * Returns zero on success, or -EFAULT on error.
95 * On error, the variable @x is set to zero.
96 */
97 #define get_user(x, ptr) __get_user_check((x), (ptr), sizeof(*(ptr)))
98
99 /*
100 * __put_user: - Write a simple value into user space, with less checking.
101 * @x: Value to copy to user space.
102 * @ptr: Destination address, in user space.
103 *
104 * Context: User context only. This function may sleep if pagefaults are
105 * enabled.
106 *
107 * This macro copies a single simple value from kernel space to user
108 * space. It supports simple types like char and int, but not larger
109 * data types like structures or arrays.
110 *
111 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
112 * to the result of dereferencing @ptr.
113 *
114 * Caller must check the pointer with access_ok() before calling this
115 * function.
116 *
117 * Returns zero on success, or -EFAULT on error.
118 */
119 #define __put_user(x, ptr) __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
120
121 /*
122 * __get_user: - Get a simple variable from user space, with less checking.
123 * @x: Variable to store result.
124 * @ptr: Source address, in user space.
125 *
126 * Context: User context only. This function may sleep if pagefaults are
127 * enabled.
128 *
129 * This macro copies a single simple variable from user space to kernel
130 * space. It supports simple types like char and int, but not larger
131 * data types like structures or arrays.
132 *
133 * @ptr must have pointer-to-simple-variable type, and the result of
134 * dereferencing @ptr must be assignable to @x without a cast.
135 *
136 * Caller must check the pointer with access_ok() before calling this
137 * function.
138 *
139 * Returns zero on success, or -EFAULT on error.
140 * On error, the variable @x is set to zero.
141 */
142 #define __get_user(x, ptr) __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
143
144 struct __large_struct { unsigned long buf[100]; };
145 #define __m(x) (*(struct __large_struct __user *)(x))
146
147 /*
148 * Yuck. We need two variants, one for 64bit operation and one
149 * for 32 bit mode and old iron.
150 */
151 extern void __get_user_unknown(void);
152
153 #define __get_user_common(val, size, ptr) \
154 do { \
155 switch (size) { \
156 case 1: \
157 __get_user_asm(val, "lb", ptr); \
158 break; \
159 case 2: \
160 __get_user_asm(val, "lh", ptr); \
161 break; \
162 case 4: \
163 __get_user_asm(val, "lw", ptr); \
164 break; \
165 case 8: \
166 if (__copy_from_user((void *)&val, ptr, 8) == 0) \
167 __gu_err = 0; \
168 else \
169 __gu_err = -EFAULT; \
170 break; \
171 default: \
172 __get_user_unknown(); \
173 break; \
174 } \
175 } while (0)
176
177 #define __get_user_nocheck(x, ptr, size) \
178 ({ \
179 long __gu_err = 0; \
180 __get_user_common((x), size, ptr); \
181 __gu_err; \
182 })
183
184 #define __get_user_check(x, ptr, size) \
185 ({ \
186 long __gu_err = -EFAULT; \
187 const __typeof__(*(ptr)) __user *__gu_ptr = (ptr); \
188 \
189 if (likely(access_ok(VERIFY_READ, __gu_ptr, size))) \
190 __get_user_common((x), size, __gu_ptr); \
191 else \
192 (x) = 0; \
193 \
194 __gu_err; \
195 })
196
197 #define __get_user_asm(val, insn, addr) \
198 { \
199 long __gu_tmp; \
200 \
201 __asm__ __volatile__( \
202 "1:" insn " %1, %3\n" \
203 "2:\n" \
204 ".section .fixup,\"ax\"\n" \
205 "3:li %0, %4\n" \
206 "li %1, 0\n" \
207 "j 2b\n" \
208 ".previous\n" \
209 ".section __ex_table,\"a\"\n" \
210 ".word 1b, 3b\n" \
211 ".previous\n" \
212 : "=r" (__gu_err), "=r" (__gu_tmp) \
213 : "0" (0), "o" (__m(addr)), "i" (-EFAULT)); \
214 \
215 (val) = (__typeof__(*(addr))) __gu_tmp; \
216 }
217
218 /*
219 * Yuck. We need two variants, one for 64bit operation and one
220 * for 32 bit mode and old iron.
221 */
222 #define __put_user_nocheck(val, ptr, size) \
223 ({ \
224 __typeof__(*(ptr)) __pu_val; \
225 long __pu_err = 0; \
226 \
227 __pu_val = (val); \
228 switch (size) { \
229 case 1: \
230 __put_user_asm("sb", ptr); \
231 break; \
232 case 2: \
233 __put_user_asm("sh", ptr); \
234 break; \
235 case 4: \
236 __put_user_asm("sw", ptr); \
237 break; \
238 case 8: \
239 if ((__copy_to_user((void *)ptr, &__pu_val, 8)) == 0) \
240 __pu_err = 0; \
241 else \
242 __pu_err = -EFAULT; \
243 break; \
244 default: \
245 __put_user_unknown(); \
246 break; \
247 } \
248 __pu_err; \
249 })
250
251
252 #define __put_user_check(val, ptr, size) \
253 ({ \
254 __typeof__(*(ptr)) __user *__pu_addr = (ptr); \
255 __typeof__(*(ptr)) __pu_val = (val); \
256 long __pu_err = -EFAULT; \
257 \
258 if (likely(access_ok(VERIFY_WRITE, __pu_addr, size))) { \
259 switch (size) { \
260 case 1: \
261 __put_user_asm("sb", __pu_addr); \
262 break; \
263 case 2: \
264 __put_user_asm("sh", __pu_addr); \
265 break; \
266 case 4: \
267 __put_user_asm("sw", __pu_addr); \
268 break; \
269 case 8: \
270 if ((__copy_to_user((void *)__pu_addr, &__pu_val, 8)) == 0)\
271 __pu_err = 0; \
272 else \
273 __pu_err = -EFAULT; \
274 break; \
275 default: \
276 __put_user_unknown(); \
277 break; \
278 } \
279 } \
280 __pu_err; \
281 })
282
283 #define __put_user_asm(insn, ptr) \
284 __asm__ __volatile__( \
285 "1:" insn " %2, %3\n" \
286 "2:\n" \
287 ".section .fixup,\"ax\"\n" \
288 "3:li %0, %4\n" \
289 "j 2b\n" \
290 ".previous\n" \
291 ".section __ex_table,\"a\"\n" \
292 ".word 1b, 3b\n" \
293 ".previous\n" \
294 : "=r" (__pu_err) \
295 : "0" (0), "r" (__pu_val), "o" (__m(ptr)), \
296 "i" (-EFAULT));
297
298 extern void __put_user_unknown(void);
299 extern int __copy_tofrom_user(void *to, const void *from, unsigned long len);
300
301 static inline unsigned long
302 copy_from_user(void *to, const void *from, unsigned long len)
303 {
304 unsigned long res = len;
305
306 if (likely(access_ok(VERIFY_READ, from, len)))
307 res = __copy_tofrom_user(to, from, len);
308
309 if (unlikely(res))
310 memset(to + (len - res), 0, res);
311
312 return res;
313 }
314
315 static inline unsigned long
316 copy_to_user(void *to, const void *from, unsigned long len)
317 {
318 if (likely(access_ok(VERIFY_WRITE, to, len)))
319 len = __copy_tofrom_user(to, from, len);
320
321 return len;
322 }
323
324 static inline unsigned long
325 __copy_from_user(void *to, const void *from, unsigned long len)
326 {
327 unsigned long left = __copy_tofrom_user(to, from, len);
328 if (unlikely(left))
329 memset(to + (len - left), 0, left);
330 return left;
331 }
332
333 #define __copy_to_user(to, from, len) \
334 __copy_tofrom_user((to), (from), (len))
335
336 static inline unsigned long
337 __copy_to_user_inatomic(void *to, const void *from, unsigned long len)
338 {
339 return __copy_to_user(to, from, len);
340 }
341
342 static inline unsigned long
343 __copy_from_user_inatomic(void *to, const void *from, unsigned long len)
344 {
345 return __copy_tofrom_user(to, from, len);
346 }
347
348 #define __copy_in_user(to, from, len) __copy_tofrom_user(to, from, len)
349
350 static inline unsigned long
351 copy_in_user(void *to, const void *from, unsigned long len)
352 {
353 if (access_ok(VERIFY_READ, from, len) &&
354 access_ok(VERFITY_WRITE, to, len))
355 return __copy_tofrom_user(to, from, len);
356 }
357
358 /*
359 * __clear_user: - Zero a block of memory in user space, with less checking.
360 * @to: Destination address, in user space.
361 * @n: Number of bytes to zero.
362 *
363 * Zero a block of memory in user space. Caller must check
364 * the specified block with access_ok() before calling this function.
365 *
366 * Returns number of bytes that could not be cleared.
367 * On success, this will be zero.
368 */
369 extern unsigned long __clear_user(void __user *src, unsigned long size);
370
371 static inline unsigned long clear_user(char *src, unsigned long size)
372 {
373 if (access_ok(VERIFY_WRITE, src, size))
374 return __clear_user(src, size);
375
376 return -EFAULT;
377 }
378 /*
379 * __strncpy_from_user: - Copy a NUL terminated string from userspace, with less checking.
380 * @dst: Destination address, in kernel space. This buffer must be at
381 * least @count bytes long.
382 * @src: Source address, in user space.
383 * @count: Maximum number of bytes to copy, including the trailing NUL.
384 *
385 * Copies a NUL-terminated string from userspace to kernel space.
386 * Caller must check the specified block with access_ok() before calling
387 * this function.
388 *
389 * On success, returns the length of the string (not including the trailing
390 * NUL).
391 *
392 * If access to userspace fails, returns -EFAULT (some data may have been
393 * copied).
394 *
395 * If @count is smaller than the length of the string, copies @count bytes
396 * and returns @count.
397 */
398 extern int __strncpy_from_user(char *dst, const char *src, long len);
399
400 static inline int strncpy_from_user(char *dst, const char *src, long len)
401 {
402 if (access_ok(VERIFY_READ, src, 1))
403 return __strncpy_from_user(dst, src, len);
404
405 return -EFAULT;
406 }
407
408 extern int __strlen_user(const char *src);
409 static inline long strlen_user(const char __user *src)
410 {
411 return __strlen_user(src);
412 }
413
414 extern int __strnlen_user(const char *str, long len);
415 static inline long strnlen_user(const char __user *str, long len)
416 {
417 if (!access_ok(VERIFY_READ, str, 0))
418 return 0;
419 else
420 return __strnlen_user(str, len);
421 }
422
423 struct exception_table_entry {
424 unsigned long insn;
425 unsigned long fixup;
426 };
427
428 extern int fixup_exception(struct pt_regs *regs);
429
430 #endif /* __SCORE_UACCESS_H */
431
Ubuntu Hirsute Linux kernel mirror