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

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

Version: ~ [ linux-4.16-rc2 ] ~ [ linux-4.15.4 ] ~ [ linux-4.14.20 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.82 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.116 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.49 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.95 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.54 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.99 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ 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  * This file is subject to the terms and conditions of the GNU General Public
  3  * License.  See the file "COPYING" in the main directory of this archive
  4  * for more details.
  5  *
  6  * Copyright (C) 1996, 1997, 1998, 1999, 2000, 03, 04 by Ralf Baechle
  7  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  8  * Copyright (C) 2007  Maciej W. Rozycki
  9  * Copyright (C) 2014, Imagination Technologies Ltd.
 10  */
 11 #ifndef _ASM_UACCESS_H
 12 #define _ASM_UACCESS_H
 13 
 14 #include <linux/kernel.h>
 15 #include <linux/string.h>
 16 #include <asm/asm-eva.h>
 17 #include <asm/extable.h>
 18 
 19 /*
 20  * The fs value determines whether argument validity checking should be
 21  * performed or not.  If get_fs() == USER_DS, checking is performed, with
 22  * get_fs() == KERNEL_DS, checking is bypassed.
 23  *
 24  * For historical reasons, these macros are grossly misnamed.
 25  */
 26 #ifdef CONFIG_32BIT
 27 
 28 #ifdef CONFIG_KVM_GUEST
 29 #define __UA_LIMIT 0x40000000UL
 30 #else
 31 #define __UA_LIMIT 0x80000000UL
 32 #endif
 33 
 34 #define __UA_ADDR       ".word"
 35 #define __UA_LA         "la"
 36 #define __UA_ADDU       "addu"
 37 #define __UA_t0         "$8"
 38 #define __UA_t1         "$9"
 39 
 40 #endif /* CONFIG_32BIT */
 41 
 42 #ifdef CONFIG_64BIT
 43 
 44 extern u64 __ua_limit;
 45 
 46 #define __UA_LIMIT      __ua_limit
 47 
 48 #define __UA_ADDR       ".dword"
 49 #define __UA_LA         "dla"
 50 #define __UA_ADDU       "daddu"
 51 #define __UA_t0         "$12"
 52 #define __UA_t1         "$13"
 53 
 54 #endif /* CONFIG_64BIT */
 55 
 56 /*
 57  * USER_DS is a bitmask that has the bits set that may not be set in a valid
 58  * userspace address.  Note that we limit 32-bit userspace to 0x7fff8000 but
 59  * the arithmetic we're doing only works if the limit is a power of two, so
 60  * we use 0x80000000 here on 32-bit kernels.  If a process passes an invalid
 61  * address in this range it's the process's problem, not ours :-)
 62  */
 63 
 64 #ifdef CONFIG_KVM_GUEST
 65 #define KERNEL_DS       ((mm_segment_t) { 0x80000000UL })
 66 #define USER_DS         ((mm_segment_t) { 0xC0000000UL })
 67 #else
 68 #define KERNEL_DS       ((mm_segment_t) { 0UL })
 69 #define USER_DS         ((mm_segment_t) { __UA_LIMIT })
 70 #endif
 71 
 72 #define get_ds()        (KERNEL_DS)
 73 #define get_fs()        (current_thread_info()->addr_limit)
 74 #define set_fs(x)       (current_thread_info()->addr_limit = (x))
 75 
 76 #define segment_eq(a, b)        ((a).seg == (b).seg)
 77 
 78 /*
 79  * eva_kernel_access() - determine whether kernel memory access on an EVA system
 80  *
 81  * Determines whether memory accesses should be performed to kernel memory
 82  * on a system using Extended Virtual Addressing (EVA).
 83  *
 84  * Return: true if a kernel memory access on an EVA system, else false.
 85  */
 86 static inline bool eva_kernel_access(void)
 87 {
 88         if (!IS_ENABLED(CONFIG_EVA))
 89                 return false;
 90 
 91         return uaccess_kernel();
 92 }
 93 
 94 /*
 95  * Is a address valid? This does a straightforward calculation rather
 96  * than tests.
 97  *
 98  * Address valid if:
 99  *  - "addr" doesn't have any high-bits set
100  *  - AND "size" doesn't have any high-bits set
101  *  - AND "addr+size" doesn't have any high-bits set
102  *  - OR we are in kernel mode.
103  *
104  * __ua_size() is a trick to avoid runtime checking of positive constant
105  * sizes; for those we already know at compile time that the size is ok.
106  */
107 #define __ua_size(size)                                                 \
108         ((__builtin_constant_p(size) && (signed long) (size) > 0) ? 0 : (size))
109 
110 /*
111  * access_ok: - Checks if a user space pointer is valid
112  * @type: Type of access: %VERIFY_READ or %VERIFY_WRITE.  Note that
113  *        %VERIFY_WRITE is a superset of %VERIFY_READ - if it is safe
114  *        to write to a block, it is always safe to read from it.
115  * @addr: User space pointer to start of block to check
116  * @size: Size of block to check
117  *
118  * Context: User context only. This function may sleep if pagefaults are
119  *          enabled.
120  *
121  * Checks if a pointer to a block of memory in user space is valid.
122  *
123  * Returns true (nonzero) if the memory block may be valid, false (zero)
124  * if it is definitely invalid.
125  *
126  * Note that, depending on architecture, this function probably just
127  * checks that the pointer is in the user space range - after calling
128  * this function, memory access functions may still return -EFAULT.
129  */
130 
131 static inline int __access_ok(const void __user *p, unsigned long size)
132 {
133         unsigned long addr = (unsigned long)p;
134         return (get_fs().seg & (addr | (addr + size) | __ua_size(size))) == 0;
135 }
136 
137 #define access_ok(type, addr, size)                                     \
138         likely(__access_ok((addr), (size)))
139 
140 /*
141  * put_user: - Write a simple value into user space.
142  * @x:   Value to copy to user space.
143  * @ptr: Destination address, in user space.
144  *
145  * Context: User context only. This function may sleep if pagefaults are
146  *          enabled.
147  *
148  * This macro copies a single simple value from kernel space to user
149  * space.  It supports simple types like char and int, but not larger
150  * data types like structures or arrays.
151  *
152  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
153  * to the result of dereferencing @ptr.
154  *
155  * Returns zero on success, or -EFAULT on error.
156  */
157 #define put_user(x,ptr) \
158         __put_user_check((x), (ptr), sizeof(*(ptr)))
159 
160 /*
161  * get_user: - Get a simple variable from user space.
162  * @x:   Variable to store result.
163  * @ptr: Source address, in user space.
164  *
165  * Context: User context only. This function may sleep if pagefaults are
166  *          enabled.
167  *
168  * This macro copies a single simple variable from user space to kernel
169  * space.  It supports simple types like char and int, but not larger
170  * data types like structures or arrays.
171  *
172  * @ptr must have pointer-to-simple-variable type, and the result of
173  * dereferencing @ptr must be assignable to @x without a cast.
174  *
175  * Returns zero on success, or -EFAULT on error.
176  * On error, the variable @x is set to zero.
177  */
178 #define get_user(x,ptr) \
179         __get_user_check((x), (ptr), sizeof(*(ptr)))
180 
181 /*
182  * __put_user: - Write a simple value into user space, with less checking.
183  * @x:   Value to copy to user space.
184  * @ptr: Destination address, in user space.
185  *
186  * Context: User context only. This function may sleep if pagefaults are
187  *          enabled.
188  *
189  * This macro copies a single simple value from kernel space to user
190  * space.  It supports simple types like char and int, but not larger
191  * data types like structures or arrays.
192  *
193  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
194  * to the result of dereferencing @ptr.
195  *
196  * Caller must check the pointer with access_ok() before calling this
197  * function.
198  *
199  * Returns zero on success, or -EFAULT on error.
200  */
201 #define __put_user(x,ptr) \
202         __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
203 
204 /*
205  * __get_user: - Get a simple variable from user space, with less checking.
206  * @x:   Variable to store result.
207  * @ptr: Source address, in user space.
208  *
209  * Context: User context only. This function may sleep if pagefaults are
210  *          enabled.
211  *
212  * This macro copies a single simple variable from user space to kernel
213  * space.  It supports simple types like char and int, but not larger
214  * data types like structures or arrays.
215  *
216  * @ptr must have pointer-to-simple-variable type, and the result of
217  * dereferencing @ptr must be assignable to @x without a cast.
218  *
219  * Caller must check the pointer with access_ok() before calling this
220  * function.
221  *
222  * Returns zero on success, or -EFAULT on error.
223  * On error, the variable @x is set to zero.
224  */
225 #define __get_user(x,ptr) \
226         __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
227 
228 struct __large_struct { unsigned long buf[100]; };
229 #define __m(x) (*(struct __large_struct __user *)(x))
230 
231 /*
232  * Yuck.  We need two variants, one for 64bit operation and one
233  * for 32 bit mode and old iron.
234  */
235 #ifndef CONFIG_EVA
236 #define __get_kernel_common(val, size, ptr) __get_user_common(val, size, ptr)
237 #else
238 /*
239  * Kernel specific functions for EVA. We need to use normal load instructions
240  * to read data from kernel when operating in EVA mode. We use these macros to
241  * avoid redefining __get_user_asm for EVA.
242  */
243 #undef _loadd
244 #undef _loadw
245 #undef _loadh
246 #undef _loadb
247 #ifdef CONFIG_32BIT
248 #define _loadd                  _loadw
249 #else
250 #define _loadd(reg, addr)       "ld " reg ", " addr
251 #endif
252 #define _loadw(reg, addr)       "lw " reg ", " addr
253 #define _loadh(reg, addr)       "lh " reg ", " addr
254 #define _loadb(reg, addr)       "lb " reg ", " addr
255 
256 #define __get_kernel_common(val, size, ptr)                             \
257 do {                                                                    \
258         switch (size) {                                                 \
259         case 1: __get_data_asm(val, _loadb, ptr); break;                \
260         case 2: __get_data_asm(val, _loadh, ptr); break;                \
261         case 4: __get_data_asm(val, _loadw, ptr); break;                \
262         case 8: __GET_DW(val, _loadd, ptr); break;                      \
263         default: __get_user_unknown(); break;                           \
264         }                                                               \
265 } while (0)
266 #endif
267 
268 #ifdef CONFIG_32BIT
269 #define __GET_DW(val, insn, ptr) __get_data_asm_ll32(val, insn, ptr)
270 #endif
271 #ifdef CONFIG_64BIT
272 #define __GET_DW(val, insn, ptr) __get_data_asm(val, insn, ptr)
273 #endif
274 
275 extern void __get_user_unknown(void);
276 
277 #define __get_user_common(val, size, ptr)                               \
278 do {                                                                    \
279         switch (size) {                                                 \
280         case 1: __get_data_asm(val, user_lb, ptr); break;               \
281         case 2: __get_data_asm(val, user_lh, ptr); break;               \
282         case 4: __get_data_asm(val, user_lw, ptr); break;               \
283         case 8: __GET_DW(val, user_ld, ptr); break;                     \
284         default: __get_user_unknown(); break;                           \
285         }                                                               \
286 } while (0)
287 
288 #define __get_user_nocheck(x, ptr, size)                                \
289 ({                                                                      \
290         int __gu_err;                                                   \
291                                                                         \
292         if (eva_kernel_access()) {                                      \
293                 __get_kernel_common((x), size, ptr);                    \
294         } else {                                                        \
295                 __chk_user_ptr(ptr);                                    \
296                 __get_user_common((x), size, ptr);                      \
297         }                                                               \
298         __gu_err;                                                       \
299 })
300 
301 #define __get_user_check(x, ptr, size)                                  \
302 ({                                                                      \
303         int __gu_err = -EFAULT;                                         \
304         const __typeof__(*(ptr)) __user * __gu_ptr = (ptr);             \
305                                                                         \
306         might_fault();                                                  \
307         if (likely(access_ok(VERIFY_READ,  __gu_ptr, size))) {          \
308                 if (eva_kernel_access())                                \
309                         __get_kernel_common((x), size, __gu_ptr);       \
310                 else                                                    \
311                         __get_user_common((x), size, __gu_ptr);         \
312         } else                                                          \
313                 (x) = 0;                                                \
314                                                                         \
315         __gu_err;                                                       \
316 })
317 
318 #define __get_data_asm(val, insn, addr)                                 \
319 {                                                                       \
320         long __gu_tmp;                                                  \
321                                                                         \
322         __asm__ __volatile__(                                           \
323         "1:     "insn("%1", "%3")"                              \n"     \
324         "2:                                                     \n"     \
325         "       .insn                                           \n"     \
326         "       .section .fixup,\"ax\"                          \n"     \
327         "3:     li      %0, %4                                  \n"     \
328         "       move    %1, $0                                  \n"     \
329         "       j       2b                                      \n"     \
330         "       .previous                                       \n"     \
331         "       .section __ex_table,\"a\"                       \n"     \
332         "       "__UA_ADDR "\t1b, 3b                            \n"     \
333         "       .previous                                       \n"     \
334         : "=r" (__gu_err), "=r" (__gu_tmp)                              \
335         : "" (0), "o" (__m(addr)), "i" (-EFAULT));                     \
336                                                                         \
337         (val) = (__typeof__(*(addr))) __gu_tmp;                         \
338 }
339 
340 /*
341  * Get a long long 64 using 32 bit registers.
342  */
343 #define __get_data_asm_ll32(val, insn, addr)                            \
344 {                                                                       \
345         union {                                                         \
346                 unsigned long long      l;                              \
347                 __typeof__(*(addr))     t;                              \
348         } __gu_tmp;                                                     \
349                                                                         \
350         __asm__ __volatile__(                                           \
351         "1:     " insn("%1", "(%3)")"                           \n"     \
352         "2:     " insn("%D1", "4(%3)")"                         \n"     \
353         "3:                                                     \n"     \
354         "       .insn                                           \n"     \
355         "       .section        .fixup,\"ax\"                   \n"     \
356         "4:     li      %0, %4                                  \n"     \
357         "       move    %1, $0                                  \n"     \
358         "       move    %D1, $0                                 \n"     \
359         "       j       3b                                      \n"     \
360         "       .previous                                       \n"     \
361         "       .section        __ex_table,\"a\"                \n"     \
362         "       " __UA_ADDR "   1b, 4b                          \n"     \
363         "       " __UA_ADDR "   2b, 4b                          \n"     \
364         "       .previous                                       \n"     \
365         : "=r" (__gu_err), "=&r" (__gu_tmp.l)                           \
366         : "" (0), "r" (addr), "i" (-EFAULT));                          \
367                                                                         \
368         (val) = __gu_tmp.t;                                             \
369 }
370 
371 #ifndef CONFIG_EVA
372 #define __put_kernel_common(ptr, size) __put_user_common(ptr, size)
373 #else
374 /*
375  * Kernel specific functions for EVA. We need to use normal load instructions
376  * to read data from kernel when operating in EVA mode. We use these macros to
377  * avoid redefining __get_data_asm for EVA.
378  */
379 #undef _stored
380 #undef _storew
381 #undef _storeh
382 #undef _storeb
383 #ifdef CONFIG_32BIT
384 #define _stored                 _storew
385 #else
386 #define _stored(reg, addr)      "ld " reg ", " addr
387 #endif
388 
389 #define _storew(reg, addr)      "sw " reg ", " addr
390 #define _storeh(reg, addr)      "sh " reg ", " addr
391 #define _storeb(reg, addr)      "sb " reg ", " addr
392 
393 #define __put_kernel_common(ptr, size)                                  \
394 do {                                                                    \
395         switch (size) {                                                 \
396         case 1: __put_data_asm(_storeb, ptr); break;                    \
397         case 2: __put_data_asm(_storeh, ptr); break;                    \
398         case 4: __put_data_asm(_storew, ptr); break;                    \
399         case 8: __PUT_DW(_stored, ptr); break;                          \
400         default: __put_user_unknown(); break;                           \
401         }                                                               \
402 } while(0)
403 #endif
404 
405 /*
406  * Yuck.  We need two variants, one for 64bit operation and one
407  * for 32 bit mode and old iron.
408  */
409 #ifdef CONFIG_32BIT
410 #define __PUT_DW(insn, ptr) __put_data_asm_ll32(insn, ptr)
411 #endif
412 #ifdef CONFIG_64BIT
413 #define __PUT_DW(insn, ptr) __put_data_asm(insn, ptr)
414 #endif
415 
416 #define __put_user_common(ptr, size)                                    \
417 do {                                                                    \
418         switch (size) {                                                 \
419         case 1: __put_data_asm(user_sb, ptr); break;                    \
420         case 2: __put_data_asm(user_sh, ptr); break;                    \
421         case 4: __put_data_asm(user_sw, ptr); break;                    \
422         case 8: __PUT_DW(user_sd, ptr); break;                          \
423         default: __put_user_unknown(); break;                           \
424         }                                                               \
425 } while (0)
426 
427 #define __put_user_nocheck(x, ptr, size)                                \
428 ({                                                                      \
429         __typeof__(*(ptr)) __pu_val;                                    \
430         int __pu_err = 0;                                               \
431                                                                         \
432         __pu_val = (x);                                                 \
433         if (eva_kernel_access()) {                                      \
434                 __put_kernel_common(ptr, size);                         \
435         } else {                                                        \
436                 __chk_user_ptr(ptr);                                    \
437                 __put_user_common(ptr, size);                           \
438         }                                                               \
439         __pu_err;                                                       \
440 })
441 
442 #define __put_user_check(x, ptr, size)                                  \
443 ({                                                                      \
444         __typeof__(*(ptr)) __user *__pu_addr = (ptr);                   \
445         __typeof__(*(ptr)) __pu_val = (x);                              \
446         int __pu_err = -EFAULT;                                         \
447                                                                         \
448         might_fault();                                                  \
449         if (likely(access_ok(VERIFY_WRITE,  __pu_addr, size))) {        \
450                 if (eva_kernel_access())                                \
451                         __put_kernel_common(__pu_addr, size);           \
452                 else                                                    \
453                         __put_user_common(__pu_addr, size);             \
454         }                                                               \
455                                                                         \
456         __pu_err;                                                       \
457 })
458 
459 #define __put_data_asm(insn, ptr)                                       \
460 {                                                                       \
461         __asm__ __volatile__(                                           \
462         "1:     "insn("%z2", "%3")"     # __put_data_asm        \n"     \
463         "2:                                                     \n"     \
464         "       .insn                                           \n"     \
465         "       .section        .fixup,\"ax\"                   \n"     \
466         "3:     li      %0, %4                                  \n"     \
467         "       j       2b                                      \n"     \
468         "       .previous                                       \n"     \
469         "       .section        __ex_table,\"a\"                \n"     \
470         "       " __UA_ADDR "   1b, 3b                          \n"     \
471         "       .previous                                       \n"     \
472         : "=r" (__pu_err)                                               \
473         : "" (0), "Jr" (__pu_val), "o" (__m(ptr)),                     \
474           "i" (-EFAULT));                                               \
475 }
476 
477 #define __put_data_asm_ll32(insn, ptr)                                  \
478 {                                                                       \
479         __asm__ __volatile__(                                           \
480         "1:     "insn("%2", "(%3)")"    # __put_data_asm_ll32   \n"     \
481         "2:     "insn("%D2", "4(%3)")"                          \n"     \
482         "3:                                                     \n"     \
483         "       .insn                                           \n"     \
484         "       .section        .fixup,\"ax\"                   \n"     \
485         "4:     li      %0, %4                                  \n"     \
486         "       j       3b                                      \n"     \
487         "       .previous                                       \n"     \
488         "       .section        __ex_table,\"a\"                \n"     \
489         "       " __UA_ADDR "   1b, 4b                          \n"     \
490         "       " __UA_ADDR "   2b, 4b                          \n"     \
491         "       .previous"                                              \
492         : "=r" (__pu_err)                                               \
493         : "" (0), "r" (__pu_val), "r" (ptr),                           \
494           "i" (-EFAULT));                                               \
495 }
496 
497 extern void __put_user_unknown(void);
498 
499 /*
500  * We're generating jump to subroutines which will be outside the range of
501  * jump instructions
502  */
503 #ifdef MODULE
504 #define __MODULE_JAL(destination)                                       \
505         ".set\tnoat\n\t"                                                \
506         __UA_LA "\t$1, " #destination "\n\t"                            \
507         "jalr\t$1\n\t"                                                  \
508         ".set\tat\n\t"
509 #else
510 #define __MODULE_JAL(destination)                                       \
511         "jal\t" #destination "\n\t"
512 #endif
513 
514 #if defined(CONFIG_CPU_DADDI_WORKAROUNDS) || (defined(CONFIG_EVA) &&    \
515                                               defined(CONFIG_CPU_HAS_PREFETCH))
516 #define DADDI_SCRATCH "$3"
517 #else
518 #define DADDI_SCRATCH "$0"
519 #endif
520 
521 extern size_t __copy_user(void *__to, const void *__from, size_t __n);
522 
523 #define __invoke_copy_from(func, to, from, n)                           \
524 ({                                                                      \
525         register void *__cu_to_r __asm__("$4");                         \
526         register const void __user *__cu_from_r __asm__("$5");          \
527         register long __cu_len_r __asm__("$6");                         \
528                                                                         \
529         __cu_to_r = (to);                                               \
530         __cu_from_r = (from);                                           \
531         __cu_len_r = (n);                                               \
532         __asm__ __volatile__(                                           \
533         ".set\tnoreorder\n\t"                                           \
534         __MODULE_JAL(func)                                              \
535         ".set\tnoat\n\t"                                                \
536         __UA_ADDU "\t$1, %1, %2\n\t"                                    \
537         ".set\tat\n\t"                                                  \
538         ".set\treorder"                                                 \
539         : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r)       \
540         :                                                               \
541         : "$8", "$9", "$10", "$11", "$12", "$14", "$15", "$24", "$31",  \
542           DADDI_SCRATCH, "memory");                                     \
543         __cu_len_r;                                                     \
544 })
545 
546 #define __invoke_copy_to(func, to, from, n)                             \
547 ({                                                                      \
548         register void __user *__cu_to_r __asm__("$4");                  \
549         register const void *__cu_from_r __asm__("$5");                 \
550         register long __cu_len_r __asm__("$6");                         \
551                                                                         \
552         __cu_to_r = (to);                                               \
553         __cu_from_r = (from);                                           \
554         __cu_len_r = (n);                                               \
555         __asm__ __volatile__(                                           \
556         __MODULE_JAL(func)                                              \
557         : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r)       \
558         :                                                               \
559         : "$8", "$9", "$10", "$11", "$12", "$14", "$15", "$24", "$31",  \
560           DADDI_SCRATCH, "memory");                                     \
561         __cu_len_r;                                                     \
562 })
563 
564 #define __invoke_copy_from_kernel(to, from, n)                          \
565         __invoke_copy_from(__copy_user, to, from, n)
566 
567 #define __invoke_copy_to_kernel(to, from, n)                            \
568         __invoke_copy_to(__copy_user, to, from, n)
569 
570 #define ___invoke_copy_in_kernel(to, from, n)                           \
571         __invoke_copy_from(__copy_user, to, from, n)
572 
573 #ifndef CONFIG_EVA
574 #define __invoke_copy_from_user(to, from, n)                            \
575         __invoke_copy_from(__copy_user, to, from, n)
576 
577 #define __invoke_copy_to_user(to, from, n)                              \
578         __invoke_copy_to(__copy_user, to, from, n)
579 
580 #define ___invoke_copy_in_user(to, from, n)                             \
581         __invoke_copy_from(__copy_user, to, from, n)
582 
583 #else
584 
585 /* EVA specific functions */
586 
587 extern size_t __copy_from_user_eva(void *__to, const void *__from,
588                                    size_t __n);
589 extern size_t __copy_to_user_eva(void *__to, const void *__from,
590                                  size_t __n);
591 extern size_t __copy_in_user_eva(void *__to, const void *__from, size_t __n);
592 
593 /*
594  * Source or destination address is in userland. We need to go through
595  * the TLB
596  */
597 #define __invoke_copy_from_user(to, from, n)                            \
598         __invoke_copy_from(__copy_from_user_eva, to, from, n)
599 
600 #define __invoke_copy_to_user(to, from, n)                              \
601         __invoke_copy_to(__copy_to_user_eva, to, from, n)
602 
603 #define ___invoke_copy_in_user(to, from, n)                             \
604         __invoke_copy_from(__copy_in_user_eva, to, from, n)
605 
606 #endif /* CONFIG_EVA */
607 
608 static inline unsigned long
609 raw_copy_to_user(void __user *to, const void *from, unsigned long n)
610 {
611         if (eva_kernel_access())
612                 return __invoke_copy_to_kernel(to, from, n);
613         else
614                 return __invoke_copy_to_user(to, from, n);
615 }
616 
617 static inline unsigned long
618 raw_copy_from_user(void *to, const void __user *from, unsigned long n)
619 {
620         if (eva_kernel_access())
621                 return __invoke_copy_from_kernel(to, from, n);
622         else
623                 return __invoke_copy_from_user(to, from, n);
624 }
625 
626 #define INLINE_COPY_FROM_USER
627 #define INLINE_COPY_TO_USER
628 
629 static inline unsigned long
630 raw_copy_in_user(void __user*to, const void __user *from, unsigned long n)
631 {
632         if (eva_kernel_access())
633                 return ___invoke_copy_in_kernel(to, from, n);
634         else
635                 return ___invoke_copy_in_user(to, from, n);
636 }
637 
638 extern __kernel_size_t __bzero_kernel(void __user *addr, __kernel_size_t size);
639 extern __kernel_size_t __bzero(void __user *addr, __kernel_size_t size);
640 
641 /*
642  * __clear_user: - Zero a block of memory in user space, with less checking.
643  * @to:   Destination address, in user space.
644  * @n:    Number of bytes to zero.
645  *
646  * Zero a block of memory in user space.  Caller must check
647  * the specified block with access_ok() before calling this function.
648  *
649  * Returns number of bytes that could not be cleared.
650  * On success, this will be zero.
651  */
652 static inline __kernel_size_t
653 __clear_user(void __user *addr, __kernel_size_t size)
654 {
655         __kernel_size_t res;
656 
657         if (eva_kernel_access()) {
658                 __asm__ __volatile__(
659                         "move\t$4, %1\n\t"
660                         "move\t$5, $0\n\t"
661                         "move\t$6, %2\n\t"
662                         __MODULE_JAL(__bzero_kernel)
663                         "move\t%0, $6"
664                         : "=r" (res)
665                         : "r" (addr), "r" (size)
666                         : "$4", "$5", "$6", __UA_t0, __UA_t1, "$31");
667         } else {
668                 might_fault();
669                 __asm__ __volatile__(
670                         "move\t$4, %1\n\t"
671                         "move\t$5, $0\n\t"
672                         "move\t$6, %2\n\t"
673                         __MODULE_JAL(__bzero)
674                         "move\t%0, $6"
675                         : "=r" (res)
676                         : "r" (addr), "r" (size)
677                         : "$4", "$5", "$6", __UA_t0, __UA_t1, "$31");
678         }
679 
680         return res;
681 }
682 
683 #define clear_user(addr,n)                                              \
684 ({                                                                      \
685         void __user * __cl_addr = (addr);                               \
686         unsigned long __cl_size = (n);                                  \
687         if (__cl_size && access_ok(VERIFY_WRITE,                        \
688                                         __cl_addr, __cl_size))          \
689                 __cl_size = __clear_user(__cl_addr, __cl_size);         \
690         __cl_size;                                                      \
691 })
692 
693 extern long __strncpy_from_kernel_asm(char *__to, const char __user *__from, long __len);
694 extern long __strncpy_from_user_asm(char *__to, const char __user *__from, long __len);
695 
696 /*
697  * strncpy_from_user: - Copy a NUL terminated string from userspace.
698  * @dst:   Destination address, in kernel space.  This buffer must be at
699  *         least @count bytes long.
700  * @src:   Source address, in user space.
701  * @count: Maximum number of bytes to copy, including the trailing NUL.
702  *
703  * Copies a NUL-terminated string from userspace to kernel space.
704  *
705  * On success, returns the length of the string (not including the trailing
706  * NUL).
707  *
708  * If access to userspace fails, returns -EFAULT (some data may have been
709  * copied).
710  *
711  * If @count is smaller than the length of the string, copies @count bytes
712  * and returns @count.
713  */
714 static inline long
715 strncpy_from_user(char *__to, const char __user *__from, long __len)
716 {
717         long res;
718 
719         if (eva_kernel_access()) {
720                 __asm__ __volatile__(
721                         "move\t$4, %1\n\t"
722                         "move\t$5, %2\n\t"
723                         "move\t$6, %3\n\t"
724                         __MODULE_JAL(__strncpy_from_kernel_asm)
725                         "move\t%0, $2"
726                         : "=r" (res)
727                         : "r" (__to), "r" (__from), "r" (__len)
728                         : "$2", "$3", "$4", "$5", "$6", __UA_t0, "$31", "memory");
729         } else {
730                 might_fault();
731                 __asm__ __volatile__(
732                         "move\t$4, %1\n\t"
733                         "move\t$5, %2\n\t"
734                         "move\t$6, %3\n\t"
735                         __MODULE_JAL(__strncpy_from_user_asm)
736                         "move\t%0, $2"
737                         : "=r" (res)
738                         : "r" (__to), "r" (__from), "r" (__len)
739                         : "$2", "$3", "$4", "$5", "$6", __UA_t0, "$31", "memory");
740         }
741 
742         return res;
743 }
744 
745 extern long __strnlen_kernel_asm(const char __user *s, long n);
746 extern long __strnlen_user_asm(const char __user *s, long n);
747 
748 /*
749  * strnlen_user: - Get the size of a string in user space.
750  * @str: The string to measure.
751  *
752  * Context: User context only. This function may sleep if pagefaults are
753  *          enabled.
754  *
755  * Get the size of a NUL-terminated string in user space.
756  *
757  * Returns the size of the string INCLUDING the terminating NUL.
758  * On exception, returns 0.
759  * If the string is too long, returns a value greater than @n.
760  */
761 static inline long strnlen_user(const char __user *s, long n)
762 {
763         long res;
764 
765         might_fault();
766         if (eva_kernel_access()) {
767                 __asm__ __volatile__(
768                         "move\t$4, %1\n\t"
769                         "move\t$5, %2\n\t"
770                         __MODULE_JAL(__strnlen_kernel_asm)
771                         "move\t%0, $2"
772                         : "=r" (res)
773                         : "r" (s), "r" (n)
774                         : "$2", "$4", "$5", __UA_t0, "$31");
775         } else {
776                 __asm__ __volatile__(
777                         "move\t$4, %1\n\t"
778                         "move\t$5, %2\n\t"
779                         __MODULE_JAL(__strnlen_user_asm)
780                         "move\t%0, $2"
781                         : "=r" (res)
782                         : "r" (s), "r" (n)
783                         : "$2", "$4", "$5", __UA_t0, "$31");
784         }
785 
786         return res;
787 }
788 
789 #endif /* _ASM_UACCESS_H */
790 

~ [ 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