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