Merge branches 'kbuild', 'packaging' and 'misc' of git://git.kernel.org/pub/scm/linux...
[linux-3.10.git] / arch / xtensa / include / asm / uaccess.h
1 /*
2  * include/asm-xtensa/uaccess.h
3  *
4  * User space memory access functions
5  *
6  * These routines provide basic accessing functions to the user memory
7  * space for the kernel. This header file provides functions such as:
8  *
9  * This file is subject to the terms and conditions of the GNU General Public
10  * License.  See the file "COPYING" in the main directory of this archive
11  * for more details.
12  *
13  * Copyright (C) 2001 - 2005 Tensilica Inc.
14  */
15
16 #ifndef _XTENSA_UACCESS_H
17 #define _XTENSA_UACCESS_H
18
19 #include <linux/errno.h>
20 #include <asm/types.h>
21
22 #define VERIFY_READ    0
23 #define VERIFY_WRITE   1
24
25 #ifdef __ASSEMBLY__
26
27 #include <asm/current.h>
28 #include <asm/asm-offsets.h>
29 #include <asm/processor.h>
30
31 /*
32  * These assembly macros mirror the C macros that follow below.  They
33  * should always have identical functionality.  See
34  * arch/xtensa/kernel/sys.S for usage.
35  */
36
37 #define KERNEL_DS       0
38 #define USER_DS         1
39
40 #define get_ds          (KERNEL_DS)
41
42 /*
43  * get_fs reads current->thread.current_ds into a register.
44  * On Entry:
45  *      <ad>    anything
46  *      <sp>    stack
47  * On Exit:
48  *      <ad>    contains current->thread.current_ds
49  */
50         .macro  get_fs  ad, sp
51         GET_CURRENT(\ad,\sp)
52         l32i    \ad, \ad, THREAD_CURRENT_DS
53         .endm
54
55 /*
56  * set_fs sets current->thread.current_ds to some value.
57  * On Entry:
58  *      <at>    anything (temp register)
59  *      <av>    value to write
60  *      <sp>    stack
61  * On Exit:
62  *      <at>    destroyed (actually, current)
63  *      <av>    preserved, value to write
64  */
65         .macro  set_fs  at, av, sp
66         GET_CURRENT(\at,\sp)
67         s32i    \av, \at, THREAD_CURRENT_DS
68         .endm
69
70 /*
71  * kernel_ok determines whether we should bypass addr/size checking.
72  * See the equivalent C-macro version below for clarity.
73  * On success, kernel_ok branches to a label indicated by parameter
74  * <success>.  This implies that the macro falls through to the next
75  * insruction on an error.
76  *
77  * Note that while this macro can be used independently, we designed
78  * in for optimal use in the access_ok macro below (i.e., we fall
79  * through on error).
80  *
81  * On Entry:
82  *      <at>            anything (temp register)
83  *      <success>       label to branch to on success; implies
84  *                      fall-through macro on error
85  *      <sp>            stack pointer
86  * On Exit:
87  *      <at>            destroyed (actually, current->thread.current_ds)
88  */
89
90 #if ((KERNEL_DS != 0) || (USER_DS == 0))
91 # error Assembly macro kernel_ok fails
92 #endif
93         .macro  kernel_ok  at, sp, success
94         get_fs  \at, \sp
95         beqz    \at, \success
96         .endm
97
98 /*
99  * user_ok determines whether the access to user-space memory is allowed.
100  * See the equivalent C-macro version below for clarity.
101  *
102  * On error, user_ok branches to a label indicated by parameter
103  * <error>.  This implies that the macro falls through to the next
104  * instruction on success.
105  *
106  * Note that while this macro can be used independently, we designed
107  * in for optimal use in the access_ok macro below (i.e., we fall
108  * through on success).
109  *
110  * On Entry:
111  *      <aa>    register containing memory address
112  *      <as>    register containing memory size
113  *      <at>    temp register
114  *      <error> label to branch to on error; implies fall-through
115  *              macro on success
116  * On Exit:
117  *      <aa>    preserved
118  *      <as>    preserved
119  *      <at>    destroyed (actually, (TASK_SIZE + 1 - size))
120  */
121         .macro  user_ok aa, as, at, error
122         movi    \at, __XTENSA_UL_CONST(TASK_SIZE)
123         bgeu    \as, \at, \error
124         sub     \at, \at, \as
125         bgeu    \aa, \at, \error
126         .endm
127
128 /*
129  * access_ok determines whether a memory access is allowed.  See the
130  * equivalent C-macro version below for clarity.
131  *
132  * On error, access_ok branches to a label indicated by parameter
133  * <error>.  This implies that the macro falls through to the next
134  * instruction on success.
135  *
136  * Note that we assume success is the common case, and we optimize the
137  * branch fall-through case on success.
138  *
139  * On Entry:
140  *      <aa>    register containing memory address
141  *      <as>    register containing memory size
142  *      <at>    temp register
143  *      <sp>
144  *      <error> label to branch to on error; implies fall-through
145  *              macro on success
146  * On Exit:
147  *      <aa>    preserved
148  *      <as>    preserved
149  *      <at>    destroyed
150  */
151         .macro  access_ok  aa, as, at, sp, error
152         kernel_ok  \at, \sp, .Laccess_ok_\@
153         user_ok    \aa, \as, \at, \error
154 .Laccess_ok_\@:
155         .endm
156
157 #else /* __ASSEMBLY__ not defined */
158
159 #include <linux/sched.h>
160
161 /*
162  * The fs value determines whether argument validity checking should
163  * be performed or not.  If get_fs() == USER_DS, checking is
164  * performed, with get_fs() == KERNEL_DS, checking is bypassed.
165  *
166  * For historical reasons (Data Segment Register?), these macros are
167  * grossly misnamed.
168  */
169
170 #define KERNEL_DS       ((mm_segment_t) { 0 })
171 #define USER_DS         ((mm_segment_t) { 1 })
172
173 #define get_ds()        (KERNEL_DS)
174 #define get_fs()        (current->thread.current_ds)
175 #define set_fs(val)     (current->thread.current_ds = (val))
176
177 #define segment_eq(a,b) ((a).seg == (b).seg)
178
179 #define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
180 #define __user_ok(addr,size) (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
181 #define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size)))
182 #define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size))
183
184 /*
185  * These are the main single-value transfer routines.  They
186  * automatically use the right size if we just have the right pointer
187  * type.
188  *
189  * This gets kind of ugly. We want to return _two_ values in
190  * "get_user()" and yet we don't want to do any pointers, because that
191  * is too much of a performance impact. Thus we have a few rather ugly
192  * macros here, and hide all the uglyness from the user.
193  *
194  * Careful to not
195  * (a) re-use the arguments for side effects (sizeof is ok)
196  * (b) require any knowledge of processes at this stage
197  */
198 #define put_user(x,ptr) __put_user_check((x),(ptr),sizeof(*(ptr)))
199 #define get_user(x,ptr) __get_user_check((x),(ptr),sizeof(*(ptr)))
200
201 /*
202  * The "__xxx" versions of the user access functions are versions that
203  * do not verify the address space, that must have been done previously
204  * with a separate "access_ok()" call (this is used when we do multiple
205  * accesses to the same area of user memory).
206  */
207 #define __put_user(x,ptr) __put_user_nocheck((x),(ptr),sizeof(*(ptr)))
208 #define __get_user(x,ptr) __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
209
210
211 extern long __put_user_bad(void);
212
213 #define __put_user_nocheck(x,ptr,size)                  \
214 ({                                                      \
215         long __pu_err;                                  \
216         __put_user_size((x),(ptr),(size),__pu_err);     \
217         __pu_err;                                       \
218 })
219
220 #define __put_user_check(x,ptr,size)                            \
221 ({                                                              \
222         long __pu_err = -EFAULT;                                \
223         __typeof__(*(ptr)) *__pu_addr = (ptr);                  \
224         if (access_ok(VERIFY_WRITE,__pu_addr,size))             \
225                 __put_user_size((x),__pu_addr,(size),__pu_err); \
226         __pu_err;                                               \
227 })
228
229 #define __put_user_size(x,ptr,size,retval)                              \
230 do {                                                                    \
231         int __cb;                                                       \
232         retval = 0;                                                     \
233         switch (size) {                                                 \
234         case 1: __put_user_asm(x,ptr,retval,1,"s8i",__cb);  break;      \
235         case 2: __put_user_asm(x,ptr,retval,2,"s16i",__cb); break;      \
236         case 4: __put_user_asm(x,ptr,retval,4,"s32i",__cb); break;      \
237         case 8: {                                                       \
238                      __typeof__(*ptr) __v64 = x;                        \
239                      retval = __copy_to_user(ptr,&__v64,8);             \
240                      break;                                             \
241                 }                                                       \
242         default: __put_user_bad();                                      \
243         }                                                               \
244 } while (0)
245
246
247 /*
248  * Consider a case of a user single load/store would cause both an
249  * unaligned exception and an MMU-related exception (unaligned
250  * exceptions happen first):
251  *
252  * User code passes a bad variable ptr to a system call.
253  * Kernel tries to access the variable.
254  * Unaligned exception occurs.
255  * Unaligned exception handler tries to make aligned accesses.
256  * Double exception occurs for MMU-related cause (e.g., page not mapped).
257  * do_page_fault() thinks the fault address belongs to the kernel, not the
258  * user, and panics.
259  *
260  * The kernel currently prohibits user unaligned accesses.  We use the
261  * __check_align_* macros to check for unaligned addresses before
262  * accessing user space so we don't crash the kernel.  Both
263  * __put_user_asm and __get_user_asm use these alignment macros, so
264  * macro-specific labels such as 0f, 1f, %0, %2, and %3 must stay in
265  * sync.
266  */
267
268 #define __check_align_1  ""
269
270 #define __check_align_2                         \
271         "   _bbci.l %3,  0, 1f          \n"     \
272         "   movi    %0, %4              \n"     \
273         "   _j      2f                  \n"
274
275 #define __check_align_4                         \
276         "   _bbsi.l %3,  0, 0f          \n"     \
277         "   _bbci.l %3,  1, 1f          \n"     \
278         "0: movi    %0, %4              \n"     \
279         "   _j      2f                  \n"
280
281
282 /*
283  * We don't tell gcc that we are accessing memory, but this is OK
284  * because we do not write to any memory gcc knows about, so there
285  * are no aliasing issues.
286  *
287  * WARNING: If you modify this macro at all, verify that the
288  * __check_align_* macros still work.
289  */
290 #define __put_user_asm(x, addr, err, align, insn, cb)   \
291    __asm__ __volatile__(                                \
292         __check_align_##align                           \
293         "1: "insn"  %2, %3, 0           \n"             \
294         "2:                             \n"             \
295         "   .section  .fixup,\"ax\"     \n"             \
296         "   .align 4                    \n"             \
297         "4:                             \n"             \
298         "   .long  2b                   \n"             \
299         "5:                             \n"             \
300         "   l32r   %1, 4b               \n"             \
301         "   movi   %0, %4               \n"             \
302         "   jx     %1                   \n"             \
303         "   .previous                   \n"             \
304         "   .section  __ex_table,\"a\"  \n"             \
305         "   .long       1b, 5b          \n"             \
306         "   .previous"                                  \
307         :"=r" (err), "=r" (cb)                          \
308         :"r" ((int)(x)), "r" (addr), "i" (-EFAULT), "0" (err))
309
310 #define __get_user_nocheck(x,ptr,size)                          \
311 ({                                                              \
312         long __gu_err, __gu_val;                                \
313         __get_user_size(__gu_val,(ptr),(size),__gu_err);        \
314         (x) = (__typeof__(*(ptr)))__gu_val;                     \
315         __gu_err;                                               \
316 })
317
318 #define __get_user_check(x,ptr,size)                                    \
319 ({                                                                      \
320         long __gu_err = -EFAULT, __gu_val = 0;                          \
321         const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
322         if (access_ok(VERIFY_READ,__gu_addr,size))                      \
323                 __get_user_size(__gu_val,__gu_addr,(size),__gu_err);    \
324         (x) = (__typeof__(*(ptr)))__gu_val;                             \
325         __gu_err;                                                       \
326 })
327
328 extern long __get_user_bad(void);
329
330 #define __get_user_size(x,ptr,size,retval)                              \
331 do {                                                                    \
332         int __cb;                                                       \
333         retval = 0;                                                     \
334         switch (size) {                                                 \
335           case 1: __get_user_asm(x,ptr,retval,1,"l8ui",__cb);  break;   \
336           case 2: __get_user_asm(x,ptr,retval,2,"l16ui",__cb); break;   \
337           case 4: __get_user_asm(x,ptr,retval,4,"l32i",__cb);  break;   \
338           case 8: retval = __copy_from_user(&x,ptr,8);    break;        \
339           default: (x) = __get_user_bad();                              \
340         }                                                               \
341 } while (0)
342
343
344 /*
345  * WARNING: If you modify this macro at all, verify that the
346  * __check_align_* macros still work.
347  */
348 #define __get_user_asm(x, addr, err, align, insn, cb) \
349    __asm__ __volatile__(                        \
350         __check_align_##align                   \
351         "1: "insn"  %2, %3, 0           \n"     \
352         "2:                             \n"     \
353         "   .section  .fixup,\"ax\"     \n"     \
354         "   .align 4                    \n"     \
355         "4:                             \n"     \
356         "   .long  2b                   \n"     \
357         "5:                             \n"     \
358         "   l32r   %1, 4b               \n"     \
359         "   movi   %2, 0                \n"     \
360         "   movi   %0, %4               \n"     \
361         "   jx     %1                   \n"     \
362         "   .previous                   \n"     \
363         "   .section  __ex_table,\"a\"  \n"     \
364         "   .long       1b, 5b          \n"     \
365         "   .previous"                          \
366         :"=r" (err), "=r" (cb), "=r" (x)        \
367         :"r" (addr), "i" (-EFAULT), "0" (err))
368
369
370 /*
371  * Copy to/from user space
372  */
373
374 /*
375  * We use a generic, arbitrary-sized copy subroutine.  The Xtensa
376  * architecture would cause heavy code bloat if we tried to inline
377  * these functions and provide __constant_copy_* equivalents like the
378  * i386 versions.  __xtensa_copy_user is quite efficient.  See the
379  * .fixup section of __xtensa_copy_user for a discussion on the
380  * X_zeroing equivalents for Xtensa.
381  */
382
383 extern unsigned __xtensa_copy_user(void *to, const void *from, unsigned n);
384 #define __copy_user(to,from,size) __xtensa_copy_user(to,from,size)
385
386
387 static inline unsigned long
388 __generic_copy_from_user_nocheck(void *to, const void *from, unsigned long n)
389 {
390         return __copy_user(to,from,n);
391 }
392
393 static inline unsigned long
394 __generic_copy_to_user_nocheck(void *to, const void *from, unsigned long n)
395 {
396         return __copy_user(to,from,n);
397 }
398
399 static inline unsigned long
400 __generic_copy_to_user(void *to, const void *from, unsigned long n)
401 {
402         prefetch(from);
403         if (access_ok(VERIFY_WRITE, to, n))
404                 return __copy_user(to,from,n);
405         return n;
406 }
407
408 static inline unsigned long
409 __generic_copy_from_user(void *to, const void *from, unsigned long n)
410 {
411         prefetchw(to);
412         if (access_ok(VERIFY_READ, from, n))
413                 return __copy_user(to,from,n);
414         else
415                 memset(to, 0, n);
416         return n;
417 }
418
419 #define copy_to_user(to,from,n) __generic_copy_to_user((to),(from),(n))
420 #define copy_from_user(to,from,n) __generic_copy_from_user((to),(from),(n))
421 #define __copy_to_user(to,from,n) __generic_copy_to_user_nocheck((to),(from),(n))
422 #define __copy_from_user(to,from,n) __generic_copy_from_user_nocheck((to),(from),(n))
423 #define __copy_to_user_inatomic __copy_to_user
424 #define __copy_from_user_inatomic __copy_from_user
425
426
427 /*
428  * We need to return the number of bytes not cleared.  Our memset()
429  * returns zero if a problem occurs while accessing user-space memory.
430  * In that event, return no memory cleared.  Otherwise, zero for
431  * success.
432  */
433
434 static inline unsigned long
435 __xtensa_clear_user(void *addr, unsigned long size)
436 {
437         if ( ! memset(addr, 0, size) )
438                 return size;
439         return 0;
440 }
441
442 static inline unsigned long
443 clear_user(void *addr, unsigned long size)
444 {
445         if (access_ok(VERIFY_WRITE, addr, size))
446                 return __xtensa_clear_user(addr, size);
447         return size ? -EFAULT : 0;
448 }
449
450 #define __clear_user  __xtensa_clear_user
451
452
453 extern long __strncpy_user(char *, const char *, long);
454 #define __strncpy_from_user __strncpy_user
455
456 static inline long
457 strncpy_from_user(char *dst, const char *src, long count)
458 {
459         if (access_ok(VERIFY_READ, src, 1))
460                 return __strncpy_from_user(dst, src, count);
461         return -EFAULT;
462 }
463
464
465 #define strlen_user(str) strnlen_user((str), TASK_SIZE - 1)
466
467 /*
468  * Return the size of a string (including the ending 0!)
469  */
470 extern long __strnlen_user(const char *, long);
471
472 static inline long strnlen_user(const char *str, long len)
473 {
474         unsigned long top = __kernel_ok ? ~0UL : TASK_SIZE - 1;
475
476         if ((unsigned long)str > top)
477                 return 0;
478         return __strnlen_user(str, len);
479 }
480
481
482 struct exception_table_entry
483 {
484         unsigned long insn, fixup;
485 };
486
487 /* Returns 0 if exception not found and fixup.unit otherwise.  */
488
489 extern unsigned long search_exception_table(unsigned long addr);
490 extern void sort_exception_table(void);
491
492 /* Returns the new pc */
493 #define fixup_exception(map_reg, fixup_unit, pc)                \
494 ({                                                              \
495         fixup_unit;                                             \
496 })
497
498 #endif  /* __ASSEMBLY__ */
499 #endif  /* _XTENSA_UACCESS_H */