[PATCH] xtensa: replace 'extern inline' with 'static inline'
[linux-2.6.git] / include / asm-xtensa / 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 fuctions 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
21 #define VERIFY_READ    0
22 #define VERIFY_WRITE   1
23
24 #ifdef __ASSEMBLY__
25
26 #define _ASMLANGUAGE
27 #include <asm/current.h>
28 #include <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, (TASK_SIZE+1)
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 /*
158  * verify_area determines whether a memory access is allowed.  It's
159  * mostly an unnecessary wrapper for access_ok, but we provide it as a
160  * duplicate of the verify_area() C inline function below.  See the
161  * equivalent C version below for clarity.
162  *
163  * On error, verify_area branches to a label indicated by parameter
164  * <error>.  This implies that the macro falls through to the next
165  * instruction on success.
166  *
167  * Note that we assume success is the common case, and we optimize the
168  * branch fall-through case on success.
169  *
170  * On Entry:
171  *      <aa>    register containing memory address
172  *      <as>    register containing memory size
173  *      <at>    temp register
174  *      <error> label to branch to on error; implies fall-through
175  *              macro on success
176  * On Exit:
177  *      <aa>    preserved
178  *      <as>    preserved
179  *      <at>    destroyed
180  */
181         .macro  verify_area     aa, as, at, sp, error
182         access_ok  \at, \aa, \as, \sp, \error
183         .endm
184
185
186 #else /* __ASSEMBLY__ not defined */
187
188 #include <linux/sched.h>
189 #include <asm/types.h>
190
191 /*
192  * The fs value determines whether argument validity checking should
193  * be performed or not.  If get_fs() == USER_DS, checking is
194  * performed, with get_fs() == KERNEL_DS, checking is bypassed.
195  *
196  * For historical reasons (Data Segment Register?), these macros are
197  * grossly misnamed.
198  */
199
200 #define KERNEL_DS       ((mm_segment_t) { 0 })
201 #define USER_DS         ((mm_segment_t) { 1 })
202
203 #define get_ds()        (KERNEL_DS)
204 #define get_fs()        (current->thread.current_ds)
205 #define set_fs(val)     (current->thread.current_ds = (val))
206
207 #define segment_eq(a,b) ((a).seg == (b).seg)
208
209 #define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
210 #define __user_ok(addr,size) (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
211 #define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size)))
212 #define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size))
213
214 static inline int verify_area(int type, const void * addr, unsigned long size)
215 {
216         return access_ok(type,addr,size) ? 0 : -EFAULT;
217 }
218
219 /*
220  * These are the main single-value transfer routines.  They
221  * automatically use the right size if we just have the right pointer
222  * type.
223  *
224  * This gets kind of ugly. We want to return _two_ values in
225  * "get_user()" and yet we don't want to do any pointers, because that
226  * is too much of a performance impact. Thus we have a few rather ugly
227  * macros here, and hide all the uglyness from the user.
228  *
229  * Careful to not
230  * (a) re-use the arguments for side effects (sizeof is ok)
231  * (b) require any knowledge of processes at this stage
232  */
233 #define put_user(x,ptr) __put_user_check((x),(ptr),sizeof(*(ptr)))
234 #define get_user(x,ptr) __get_user_check((x),(ptr),sizeof(*(ptr)))
235
236 /*
237  * The "__xxx" versions of the user access functions are versions that
238  * do not verify the address space, that must have been done previously
239  * with a separate "access_ok()" call (this is used when we do multiple
240  * accesses to the same area of user memory).
241  */
242 #define __put_user(x,ptr) __put_user_nocheck((x),(ptr),sizeof(*(ptr)))
243 #define __get_user(x,ptr) __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
244
245
246 extern long __put_user_bad(void);
247
248 #define __put_user_nocheck(x,ptr,size)                  \
249 ({                                                      \
250         long __pu_err;                                  \
251         __put_user_size((x),(ptr),(size),__pu_err);     \
252         __pu_err;                                       \
253 })
254
255 #define __put_user_check(x,ptr,size)                            \
256 ({                                                              \
257         long __pu_err = -EFAULT;                                \
258         __typeof__(*(ptr)) *__pu_addr = (ptr);                  \
259         if (access_ok(VERIFY_WRITE,__pu_addr,size))             \
260                 __put_user_size((x),__pu_addr,(size),__pu_err); \
261         __pu_err;                                               \
262 })
263
264 #define __put_user_size(x,ptr,size,retval)                      \
265 do {                                                            \
266         retval = 0;                                             \
267         switch (size) {                                         \
268         case 1: __put_user_asm(x,ptr,retval,1,"s8i");  break;   \
269         case 2: __put_user_asm(x,ptr,retval,2,"s16i"); break;   \
270         case 4: __put_user_asm(x,ptr,retval,4,"s32i"); break;   \
271         case 8: {                                               \
272                      __typeof__(*ptr) __v64 = x;                \
273                      retval = __copy_to_user(ptr,&__v64,8);     \
274                      break;                                     \
275                 }                                               \
276         default: __put_user_bad();                              \
277         }                                                       \
278 } while (0)
279
280
281 /*
282  * Consider a case of a user single load/store would cause both an
283  * unaligned exception and an MMU-related exception (unaligned
284  * exceptions happen first):
285  *
286  * User code passes a bad variable ptr to a system call.
287  * Kernel tries to access the variable.
288  * Unaligned exception occurs.
289  * Unaligned exception handler tries to make aligned accesses.
290  * Double exception occurs for MMU-related cause (e.g., page not mapped).
291  * do_page_fault() thinks the fault address belongs to the kernel, not the
292  * user, and panics.
293  *
294  * The kernel currently prohibits user unaligned accesses.  We use the
295  * __check_align_* macros to check for unaligned addresses before
296  * accessing user space so we don't crash the kernel.  Both
297  * __put_user_asm and __get_user_asm use these alignment macros, so
298  * macro-specific labels such as 0f, 1f, %0, %2, and %3 must stay in
299  * sync.
300  */
301
302 #define __check_align_1  ""
303
304 #define __check_align_2                         \
305         "   _bbci.l %2,  0, 1f          \n"     \
306         "   movi    %0, %3              \n"     \
307         "   _j      2f                  \n"
308
309 #define __check_align_4                         \
310         "   _bbsi.l %2,  0, 0f          \n"     \
311         "   _bbci.l %2,  1, 1f          \n"     \
312         "0: movi    %0, %3              \n"     \
313         "   _j      2f                  \n"
314
315
316 /*
317  * We don't tell gcc that we are accessing memory, but this is OK
318  * because we do not write to any memory gcc knows about, so there
319  * are no aliasing issues.
320  *
321  * WARNING: If you modify this macro at all, verify that the
322  * __check_align_* macros still work.
323  */
324 #define __put_user_asm(x, addr, err, align, insn) \
325    __asm__ __volatile__(                        \
326         __check_align_##align                   \
327         "1: "insn"  %1, %2, 0           \n"     \
328         "2:                             \n"     \
329         "   .section  .fixup,\"ax\"     \n"     \
330         "   .align 4                    \n"     \
331         "4:                             \n"     \
332         "   .long  2b                   \n"     \
333         "5:                             \n"     \
334         "   l32r   %2, 4b               \n"     \
335         "   movi   %0, %3               \n"     \
336         "   jx     %2                   \n"     \
337         "   .previous                   \n"     \
338         "   .section  __ex_table,\"a\"  \n"     \
339         "   .long       1b, 5b          \n"     \
340         "   .previous"                          \
341         :"=r" (err)                             \
342         :"r" ((int)(x)), "r" (addr), "i" (-EFAULT), "0" (err))
343
344 #define __get_user_nocheck(x,ptr,size)                          \
345 ({                                                              \
346         long __gu_err, __gu_val;                                \
347         __get_user_size(__gu_val,(ptr),(size),__gu_err);        \
348         (x) = (__typeof__(*(ptr)))__gu_val;                     \
349         __gu_err;                                               \
350 })
351
352 #define __get_user_check(x,ptr,size)                                    \
353 ({                                                                      \
354         long __gu_err = -EFAULT, __gu_val = 0;                          \
355         const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
356         if (access_ok(VERIFY_READ,__gu_addr,size))                      \
357                 __get_user_size(__gu_val,__gu_addr,(size),__gu_err);    \
358         (x) = (__typeof__(*(ptr)))__gu_val;                             \
359         __gu_err;                                                       \
360 })
361
362 extern long __get_user_bad(void);
363
364 #define __get_user_size(x,ptr,size,retval)                              \
365 do {                                                                    \
366         retval = 0;                                                     \
367         switch (size) {                                                 \
368           case 1: __get_user_asm(x,ptr,retval,1,"l8ui");  break;        \
369           case 2: __get_user_asm(x,ptr,retval,2,"l16ui"); break;        \
370           case 4: __get_user_asm(x,ptr,retval,4,"l32i");  break;        \
371           case 8: retval = __copy_from_user(&x,ptr,8);    break;        \
372           default: (x) = __get_user_bad();                              \
373         }                                                               \
374 } while (0)
375
376
377 /*
378  * WARNING: If you modify this macro at all, verify that the
379  * __check_align_* macros still work.
380  */
381 #define __get_user_asm(x, addr, err, align, insn) \
382    __asm__ __volatile__(                        \
383         __check_align_##align                   \
384         "1: "insn"  %1, %2, 0           \n"     \
385         "2:                             \n"     \
386         "   .section  .fixup,\"ax\"     \n"     \
387         "   .align 4                    \n"     \
388         "4:                             \n"     \
389         "   .long  2b                   \n"     \
390         "5:                             \n"     \
391         "   l32r   %2, 4b               \n"     \
392         "   movi   %1, 0                \n"     \
393         "   movi   %0, %3               \n"     \
394         "   jx     %2                   \n"     \
395         "   .previous                   \n"     \
396         "   .section  __ex_table,\"a\"  \n"     \
397         "   .long       1b, 5b          \n"     \
398         "   .previous"                          \
399         :"=r" (err), "=r" (x)                   \
400         :"r" (addr), "i" (-EFAULT), "0" (err))
401
402
403 /*
404  * Copy to/from user space
405  */
406
407 /*
408  * We use a generic, arbitrary-sized copy subroutine.  The Xtensa
409  * architecture would cause heavy code bloat if we tried to inline
410  * these functions and provide __constant_copy_* equivalents like the
411  * i386 versions.  __xtensa_copy_user is quite efficient.  See the
412  * .fixup section of __xtensa_copy_user for a discussion on the
413  * X_zeroing equivalents for Xtensa.
414  */
415
416 extern unsigned __xtensa_copy_user(void *to, const void *from, unsigned n);
417 #define __copy_user(to,from,size) __xtensa_copy_user(to,from,size)
418
419
420 static inline unsigned long
421 __generic_copy_from_user_nocheck(void *to, const void *from, unsigned long n)
422 {
423         return __copy_user(to,from,n);
424 }
425
426 static inline unsigned long
427 __generic_copy_to_user_nocheck(void *to, const void *from, unsigned long n)
428 {
429         return __copy_user(to,from,n);
430 }
431
432 static inline unsigned long
433 __generic_copy_to_user(void *to, const void *from, unsigned long n)
434 {
435         prefetch(from);
436         if (access_ok(VERIFY_WRITE, to, n))
437                 return __copy_user(to,from,n);
438         return n;
439 }
440
441 static inline unsigned long
442 __generic_copy_from_user(void *to, const void *from, unsigned long n)
443 {
444         prefetchw(to);
445         if (access_ok(VERIFY_READ, from, n))
446                 return __copy_user(to,from,n);
447         else
448                 memset(to, 0, n);
449         return n;
450 }
451
452 #define copy_to_user(to,from,n) __generic_copy_to_user((to),(from),(n))
453 #define copy_from_user(to,from,n) __generic_copy_from_user((to),(from),(n))
454 #define __copy_to_user(to,from,n) __generic_copy_to_user_nocheck((to),(from),(n))
455 #define __copy_from_user(to,from,n) __generic_copy_from_user_nocheck((to),(from),(n))
456 #define __copy_to_user_inatomic __copy_to_user
457 #define __copy_from_user_inatomic __copy_from_user
458
459
460 /*
461  * We need to return the number of bytes not cleared.  Our memset()
462  * returns zero if a problem occurs while accessing user-space memory.
463  * In that event, return no memory cleared.  Otherwise, zero for
464  * success.
465  */
466
467 static inline unsigned long
468 __xtensa_clear_user(void *addr, unsigned long size)
469 {
470         if ( ! memset(addr, 0, size) )
471                 return size;
472         return 0;
473 }
474
475 static inline unsigned long
476 clear_user(void *addr, unsigned long size)
477 {
478         if (access_ok(VERIFY_WRITE, addr, size))
479                 return __xtensa_clear_user(addr, size);
480         return size ? -EFAULT : 0;
481 }
482
483 #define __clear_user  __xtensa_clear_user
484
485
486 extern long __strncpy_user(char *, const char *, long);
487 #define __strncpy_from_user __strncpy_user
488
489 static inline long
490 strncpy_from_user(char *dst, const char *src, long count)
491 {
492         if (access_ok(VERIFY_READ, src, 1))
493                 return __strncpy_from_user(dst, src, count);
494         return -EFAULT;
495 }
496
497
498 #define strlen_user(str) strnlen_user((str), TASK_SIZE - 1)
499
500 /*
501  * Return the size of a string (including the ending 0!)
502  */
503 extern long __strnlen_user(const char *, long);
504
505 static inline long strnlen_user(const char *str, long len)
506 {
507         unsigned long top = __kernel_ok ? ~0UL : TASK_SIZE - 1;
508
509         if ((unsigned long)str > top)
510                 return 0;
511         return __strnlen_user(str, len);
512 }
513
514
515 struct exception_table_entry
516 {
517         unsigned long insn, fixup;
518 };
519
520 /* Returns 0 if exception not found and fixup.unit otherwise.  */
521
522 extern unsigned long search_exception_table(unsigned long addr);
523 extern void sort_exception_table(void);
524
525 /* Returns the new pc */
526 #define fixup_exception(map_reg, fixup_unit, pc)                \
527 ({                                                              \
528         fixup_unit;                                             \
529 })
530
531 #endif  /* __ASSEMBLY__ */
532 #endif  /* _XTENSA_UACCESS_H */