~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/riscv/include/asm/uaccess.h

Version: ~ [ linux-5.17-rc1 ] ~ [ linux-5.16.2 ] ~ [ linux-5.15.16 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.93 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.173 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.225 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.262 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.297 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.299 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (C) 2012 Regents of the University of California
  3  *
  4  *   This program is free software; you can redistribute it and/or
  5  *   modify it under the terms of the GNU General Public License
  6  *   as published by the Free Software Foundation, version 2.
  7  *
  8  *   This program is distributed in the hope that it will be useful,
  9  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 10  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11  *   GNU General Public License for more details.
 12  *
 13  * This file was copied from include/asm-generic/uaccess.h
 14  */
 15 
 16 #ifndef _ASM_RISCV_UACCESS_H
 17 #define _ASM_RISCV_UACCESS_H
 18 
 19 /*
 20  * User space memory access functions
 21  */
 22 #include <linux/errno.h>
 23 #include <linux/compiler.h>
 24 #include <linux/thread_info.h>
 25 #include <asm/byteorder.h>
 26 #include <asm/asm.h>
 27 
 28 #define __enable_user_access()                                                  \
 29         __asm__ __volatile__ ("csrs sstatus, %0" : : "r" (SR_SUM) : "memory")
 30 #define __disable_user_access()                                                 \
 31         __asm__ __volatile__ ("csrc sstatus, %0" : : "r" (SR_SUM) : "memory")
 32 
 33 /*
 34  * The fs value determines whether argument validity checking should be
 35  * performed or not.  If get_fs() == USER_DS, checking is performed, with
 36  * get_fs() == KERNEL_DS, checking is bypassed.
 37  *
 38  * For historical reasons, these macros are grossly misnamed.
 39  */
 40 
 41 #define KERNEL_DS       (~0UL)
 42 #define USER_DS         (TASK_SIZE)
 43 
 44 #define get_fs()        (current_thread_info()->addr_limit)
 45 
 46 static inline void set_fs(mm_segment_t fs)
 47 {
 48         current_thread_info()->addr_limit = fs;
 49 }
 50 
 51 #define segment_eq(a, b) ((a) == (b))
 52 
 53 #define user_addr_max() (get_fs())
 54 
 55 
 56 /**
 57  * access_ok: - Checks if a user space pointer is valid
 58  * @addr: User space pointer to start of block to check
 59  * @size: Size of block to check
 60  *
 61  * Context: User context only.  This function may sleep.
 62  *
 63  * Checks if a pointer to a block of memory in user space is valid.
 64  *
 65  * Returns true (nonzero) if the memory block may be valid, false (zero)
 66  * if it is definitely invalid.
 67  *
 68  * Note that, depending on architecture, this function probably just
 69  * checks that the pointer is in the user space range - after calling
 70  * this function, memory access functions may still return -EFAULT.
 71  */
 72 #define access_ok(addr, size) ({                                        \
 73         __chk_user_ptr(addr);                                           \
 74         likely(__access_ok((unsigned long __force)(addr), (size)));     \
 75 })
 76 
 77 /*
 78  * Ensure that the range [addr, addr+size) is within the process's
 79  * address space
 80  */
 81 static inline int __access_ok(unsigned long addr, unsigned long size)
 82 {
 83         const mm_segment_t fs = get_fs();
 84 
 85         return (size <= fs) && (addr <= (fs - size));
 86 }
 87 
 88 /*
 89  * The exception table consists of pairs of addresses: the first is the
 90  * address of an instruction that is allowed to fault, and the second is
 91  * the address at which the program should continue.  No registers are
 92  * modified, so it is entirely up to the continuation code to figure out
 93  * what to do.
 94  *
 95  * All the routines below use bits of fixup code that are out of line
 96  * with the main instruction path.  This means when everything is well,
 97  * we don't even have to jump over them.  Further, they do not intrude
 98  * on our cache or tlb entries.
 99  */
100 
101 struct exception_table_entry {
102         unsigned long insn, fixup;
103 };
104 
105 extern int fixup_exception(struct pt_regs *state);
106 
107 #if defined(__LITTLE_ENDIAN)
108 #define __MSW   1
109 #define __LSW   0
110 #elif defined(__BIG_ENDIAN)
111 #define __MSW   0
112 #define __LSW   1
113 #else
114 #error "Unknown endianness"
115 #endif
116 
117 /*
118  * The "__xxx" versions of the user access functions do not verify the address
119  * space - it must have been done previously with a separate "access_ok()"
120  * call.
121  */
122 
123 #define __get_user_asm(insn, x, ptr, err)                       \
124 do {                                                            \
125         uintptr_t __tmp;                                        \
126         __typeof__(x) __x;                                      \
127         __enable_user_access();                                 \
128         __asm__ __volatile__ (                                  \
129                 "1:\n"                                          \
130                 "       " insn " %1, %3\n"                      \
131                 "2:\n"                                          \
132                 "       .section .fixup,\"ax\"\n"               \
133                 "       .balign 4\n"                            \
134                 "3:\n"                                          \
135                 "       li %0, %4\n"                            \
136                 "       li %1, 0\n"                             \
137                 "       jump 2b, %2\n"                          \
138                 "       .previous\n"                            \
139                 "       .section __ex_table,\"a\"\n"            \
140                 "       .balign " RISCV_SZPTR "\n"                      \
141                 "       " RISCV_PTR " 1b, 3b\n"                 \
142                 "       .previous"                              \
143                 : "+r" (err), "=&r" (__x), "=r" (__tmp)         \
144                 : "m" (*(ptr)), "i" (-EFAULT));                 \
145         __disable_user_access();                                \
146         (x) = __x;                                              \
147 } while (0)
148 
149 #ifdef CONFIG_64BIT
150 #define __get_user_8(x, ptr, err) \
151         __get_user_asm("ld", x, ptr, err)
152 #else /* !CONFIG_64BIT */
153 #define __get_user_8(x, ptr, err)                               \
154 do {                                                            \
155         u32 __user *__ptr = (u32 __user *)(ptr);                \
156         u32 __lo, __hi;                                         \
157         uintptr_t __tmp;                                        \
158         __enable_user_access();                                 \
159         __asm__ __volatile__ (                                  \
160                 "1:\n"                                          \
161                 "       lw %1, %4\n"                            \
162                 "2:\n"                                          \
163                 "       lw %2, %5\n"                            \
164                 "3:\n"                                          \
165                 "       .section .fixup,\"ax\"\n"               \
166                 "       .balign 4\n"                            \
167                 "4:\n"                                          \
168                 "       li %0, %6\n"                            \
169                 "       li %1, 0\n"                             \
170                 "       li %2, 0\n"                             \
171                 "       jump 3b, %3\n"                          \
172                 "       .previous\n"                            \
173                 "       .section __ex_table,\"a\"\n"            \
174                 "       .balign " RISCV_SZPTR "\n"                      \
175                 "       " RISCV_PTR " 1b, 4b\n"                 \
176                 "       " RISCV_PTR " 2b, 4b\n"                 \
177                 "       .previous"                              \
178                 : "+r" (err), "=&r" (__lo), "=r" (__hi),        \
179                         "=r" (__tmp)                            \
180                 : "m" (__ptr[__LSW]), "m" (__ptr[__MSW]),       \
181                         "i" (-EFAULT));                         \
182         __disable_user_access();                                \
183         (x) = (__typeof__(x))((__typeof__((x)-(x)))(            \
184                 (((u64)__hi << 32) | __lo)));                   \
185 } while (0)
186 #endif /* CONFIG_64BIT */
187 
188 
189 /**
190  * __get_user: - Get a simple variable from user space, with less checking.
191  * @x:   Variable to store result.
192  * @ptr: Source address, in user space.
193  *
194  * Context: User context only.  This function may sleep.
195  *
196  * This macro copies a single simple variable from user space to kernel
197  * space.  It supports simple types like char and int, but not larger
198  * data types like structures or arrays.
199  *
200  * @ptr must have pointer-to-simple-variable type, and the result of
201  * dereferencing @ptr must be assignable to @x without a cast.
202  *
203  * Caller must check the pointer with access_ok() before calling this
204  * function.
205  *
206  * Returns zero on success, or -EFAULT on error.
207  * On error, the variable @x is set to zero.
208  */
209 #define __get_user(x, ptr)                                      \
210 ({                                                              \
211         register long __gu_err = 0;                             \
212         const __typeof__(*(ptr)) __user *__gu_ptr = (ptr);      \
213         __chk_user_ptr(__gu_ptr);                               \
214         switch (sizeof(*__gu_ptr)) {                            \
215         case 1:                                                 \
216                 __get_user_asm("lb", (x), __gu_ptr, __gu_err);  \
217                 break;                                          \
218         case 2:                                                 \
219                 __get_user_asm("lh", (x), __gu_ptr, __gu_err);  \
220                 break;                                          \
221         case 4:                                                 \
222                 __get_user_asm("lw", (x), __gu_ptr, __gu_err);  \
223                 break;                                          \
224         case 8:                                                 \
225                 __get_user_8((x), __gu_ptr, __gu_err);  \
226                 break;                                          \
227         default:                                                \
228                 BUILD_BUG();                                    \
229         }                                                       \
230         __gu_err;                                               \
231 })
232 
233 /**
234  * get_user: - Get a simple variable from user space.
235  * @x:   Variable to store result.
236  * @ptr: Source address, in user space.
237  *
238  * Context: User context only.  This function may sleep.
239  *
240  * This macro copies a single simple variable from user space to kernel
241  * space.  It supports simple types like char and int, but not larger
242  * data types like structures or arrays.
243  *
244  * @ptr must have pointer-to-simple-variable type, and the result of
245  * dereferencing @ptr must be assignable to @x without a cast.
246  *
247  * Returns zero on success, or -EFAULT on error.
248  * On error, the variable @x is set to zero.
249  */
250 #define get_user(x, ptr)                                        \
251 ({                                                              \
252         const __typeof__(*(ptr)) __user *__p = (ptr);           \
253         might_fault();                                          \
254         access_ok(__p, sizeof(*__p)) ?          \
255                 __get_user((x), __p) :                          \
256                 ((x) = 0, -EFAULT);                             \
257 })
258 
259 #define __put_user_asm(insn, x, ptr, err)                       \
260 do {                                                            \
261         uintptr_t __tmp;                                        \
262         __typeof__(*(ptr)) __x = x;                             \
263         __enable_user_access();                                 \
264         __asm__ __volatile__ (                                  \
265                 "1:\n"                                          \
266                 "       " insn " %z3, %2\n"                     \
267                 "2:\n"                                          \
268                 "       .section .fixup,\"ax\"\n"               \
269                 "       .balign 4\n"                            \
270                 "3:\n"                                          \
271                 "       li %0, %4\n"                            \
272                 "       jump 2b, %1\n"                          \
273                 "       .previous\n"                            \
274                 "       .section __ex_table,\"a\"\n"            \
275                 "       .balign " RISCV_SZPTR "\n"                      \
276                 "       " RISCV_PTR " 1b, 3b\n"                 \
277                 "       .previous"                              \
278                 : "+r" (err), "=r" (__tmp), "=m" (*(ptr))       \
279                 : "rJ" (__x), "i" (-EFAULT));                   \
280         __disable_user_access();                                \
281 } while (0)
282 
283 #ifdef CONFIG_64BIT
284 #define __put_user_8(x, ptr, err) \
285         __put_user_asm("sd", x, ptr, err)
286 #else /* !CONFIG_64BIT */
287 #define __put_user_8(x, ptr, err)                               \
288 do {                                                            \
289         u32 __user *__ptr = (u32 __user *)(ptr);                \
290         u64 __x = (__typeof__((x)-(x)))(x);                     \
291         uintptr_t __tmp;                                        \
292         __enable_user_access();                                 \
293         __asm__ __volatile__ (                                  \
294                 "1:\n"                                          \
295                 "       sw %z4, %2\n"                           \
296                 "2:\n"                                          \
297                 "       sw %z5, %3\n"                           \
298                 "3:\n"                                          \
299                 "       .section .fixup,\"ax\"\n"               \
300                 "       .balign 4\n"                            \
301                 "4:\n"                                          \
302                 "       li %0, %6\n"                            \
303                 "       jump 3b, %1\n"                          \
304                 "       .previous\n"                            \
305                 "       .section __ex_table,\"a\"\n"            \
306                 "       .balign " RISCV_SZPTR "\n"                      \
307                 "       " RISCV_PTR " 1b, 4b\n"                 \
308                 "       " RISCV_PTR " 2b, 4b\n"                 \
309                 "       .previous"                              \
310                 : "+r" (err), "=r" (__tmp),                     \
311                         "=m" (__ptr[__LSW]),                    \
312                         "=m" (__ptr[__MSW])                     \
313                 : "rJ" (__x), "rJ" (__x >> 32), "i" (-EFAULT)); \
314         __disable_user_access();                                \
315 } while (0)
316 #endif /* CONFIG_64BIT */
317 
318 
319 /**
320  * __put_user: - Write a simple value into user space, with less checking.
321  * @x:   Value to copy to user space.
322  * @ptr: Destination address, in user space.
323  *
324  * Context: User context only.  This function may sleep.
325  *
326  * This macro copies a single simple value from kernel space to user
327  * space.  It supports simple types like char and int, but not larger
328  * data types like structures or arrays.
329  *
330  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
331  * to the result of dereferencing @ptr.
332  *
333  * Caller must check the pointer with access_ok() before calling this
334  * function.
335  *
336  * Returns zero on success, or -EFAULT on error.
337  */
338 #define __put_user(x, ptr)                                      \
339 ({                                                              \
340         register long __pu_err = 0;                             \
341         __typeof__(*(ptr)) __user *__gu_ptr = (ptr);            \
342         __chk_user_ptr(__gu_ptr);                               \
343         switch (sizeof(*__gu_ptr)) {                            \
344         case 1:                                                 \
345                 __put_user_asm("sb", (x), __gu_ptr, __pu_err);  \
346                 break;                                          \
347         case 2:                                                 \
348                 __put_user_asm("sh", (x), __gu_ptr, __pu_err);  \
349                 break;                                          \
350         case 4:                                                 \
351                 __put_user_asm("sw", (x), __gu_ptr, __pu_err);  \
352                 break;                                          \
353         case 8:                                                 \
354                 __put_user_8((x), __gu_ptr, __pu_err);  \
355                 break;                                          \
356         default:                                                \
357                 BUILD_BUG();                                    \
358         }                                                       \
359         __pu_err;                                               \
360 })
361 
362 /**
363  * put_user: - Write a simple value into user space.
364  * @x:   Value to copy to user space.
365  * @ptr: Destination address, in user space.
366  *
367  * Context: User context only.  This function may sleep.
368  *
369  * This macro copies a single simple value from kernel space to user
370  * space.  It supports simple types like char and int, but not larger
371  * data types like structures or arrays.
372  *
373  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
374  * to the result of dereferencing @ptr.
375  *
376  * Returns zero on success, or -EFAULT on error.
377  */
378 #define put_user(x, ptr)                                        \
379 ({                                                              \
380         __typeof__(*(ptr)) __user *__p = (ptr);                 \
381         might_fault();                                          \
382         access_ok(__p, sizeof(*__p)) ?          \
383                 __put_user((x), __p) :                          \
384                 -EFAULT;                                        \
385 })
386 
387 
388 extern unsigned long __must_check __asm_copy_to_user(void __user *to,
389         const void *from, unsigned long n);
390 extern unsigned long __must_check __asm_copy_from_user(void *to,
391         const void __user *from, unsigned long n);
392 
393 static inline unsigned long
394 raw_copy_from_user(void *to, const void __user *from, unsigned long n)
395 {
396         return __asm_copy_from_user(to, from, n);
397 }
398 
399 static inline unsigned long
400 raw_copy_to_user(void __user *to, const void *from, unsigned long n)
401 {
402         return __asm_copy_to_user(to, from, n);
403 }
404 
405 extern long strncpy_from_user(char *dest, const char __user *src, long count);
406 
407 extern long __must_check strlen_user(const char __user *str);
408 extern long __must_check strnlen_user(const char __user *str, long n);
409 
410 extern
411 unsigned long __must_check __clear_user(void __user *addr, unsigned long n);
412 
413 static inline
414 unsigned long __must_check clear_user(void __user *to, unsigned long n)
415 {
416         might_fault();
417         return access_ok(to, n) ?
418                 __clear_user(to, n) : n;
419 }
420 
421 /*
422  * Atomic compare-and-exchange, but with a fixup for userspace faults.  Faults
423  * will set "err" to -EFAULT, while successful accesses return the previous
424  * value.
425  */
426 #define __cmpxchg_user(ptr, old, new, err, size, lrb, scb)      \
427 ({                                                              \
428         __typeof__(ptr) __ptr = (ptr);                          \
429         __typeof__(*(ptr)) __old = (old);                       \
430         __typeof__(*(ptr)) __new = (new);                       \
431         __typeof__(*(ptr)) __ret;                               \
432         __typeof__(err) __err = 0;                              \
433         register unsigned int __rc;                             \
434         __enable_user_access();                                 \
435         switch (size) {                                         \
436         case 4:                                                 \
437                 __asm__ __volatile__ (                          \
438                 "0:\n"                                          \
439                 "       lr.w" #scb " %[ret], %[ptr]\n"          \
440                 "       bne          %[ret], %z[old], 1f\n"     \
441                 "       sc.w" #lrb " %[rc], %z[new], %[ptr]\n"  \
442                 "       bnez         %[rc], 0b\n"               \
443                 "1:\n"                                          \
444                 ".section .fixup,\"ax\"\n"                      \
445                 ".balign 4\n"                                   \
446                 "2:\n"                                          \
447                 "       li %[err], %[efault]\n"                 \
448                 "       jump 1b, %[rc]\n"                       \
449                 ".previous\n"                                   \
450                 ".section __ex_table,\"a\"\n"                   \
451                 ".balign " RISCV_SZPTR "\n"                     \
452                 "       " RISCV_PTR " 1b, 2b\n"                 \
453                 ".previous\n"                                   \
454                         : [ret] "=&r" (__ret),                  \
455                           [rc]  "=&r" (__rc),                   \
456                           [ptr] "+A" (*__ptr),                  \
457                           [err] "=&r" (__err)                   \
458                         : [old] "rJ" (__old),                   \
459                           [new] "rJ" (__new),                   \
460                           [efault] "i" (-EFAULT));              \
461                 break;                                          \
462         case 8:                                                 \
463                 __asm__ __volatile__ (                          \
464                 "0:\n"                                          \
465                 "       lr.d" #scb " %[ret], %[ptr]\n"          \
466                 "       bne          %[ret], %z[old], 1f\n"     \
467                 "       sc.d" #lrb " %[rc], %z[new], %[ptr]\n"  \
468                 "       bnez         %[rc], 0b\n"               \
469                 "1:\n"                                          \
470                 ".section .fixup,\"ax\"\n"                      \
471                 ".balign 4\n"                                   \
472                 "2:\n"                                          \
473                 "       li %[err], %[efault]\n"                 \
474                 "       jump 1b, %[rc]\n"                       \
475                 ".previous\n"                                   \
476                 ".section __ex_table,\"a\"\n"                   \
477                 ".balign " RISCV_SZPTR "\n"                     \
478                 "       " RISCV_PTR " 1b, 2b\n"                 \
479                 ".previous\n"                                   \
480                         : [ret] "=&r" (__ret),                  \
481                           [rc]  "=&r" (__rc),                   \
482                           [ptr] "+A" (*__ptr),                  \
483                           [err] "=&r" (__err)                   \
484                         : [old] "rJ" (__old),                   \
485                           [new] "rJ" (__new),                   \
486                           [efault] "i" (-EFAULT));              \
487                 break;                                          \
488         default:                                                \
489                 BUILD_BUG();                                    \
490         }                                                       \
491         __disable_user_access();                                \
492         (err) = __err;                                          \
493         __ret;                                                  \
494 })
495 
496 #endif /* _ASM_RISCV_UACCESS_H */
497 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp