blob: 82d4e3815c898a589bfc2dc0378d1a8d6c82129f [file] [log] [blame]
Chris Zankel9a8fd552005-06-23 22:01:26 -07001/*
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
Stefan Weileef35c22010-08-06 21:11:15 +02007 * space for the kernel. This header file provides functions such as:
Chris Zankel9a8fd552005-06-23 22:01:26 -07008 *
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>
Vitaliy Ivanove44ba032011-06-20 16:08:07 +020020#include <asm/types.h>
Chris Zankel9a8fd552005-06-23 22:01:26 -070021
22#define VERIFY_READ 0
23#define VERIFY_WRITE 1
24
25#ifdef __ASSEMBLY__
26
Chris Zankel9a8fd552005-06-23 22:01:26 -070027#include <asm/current.h>
Sam Ravnborg0013a852005-09-09 20:57:26 +020028#include <asm/asm-offsets.h>
Chris Zankel9a8fd552005-06-23 22:01:26 -070029#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
Chris Zankel70e137e2007-10-23 10:58:53 -0700122 movi \at, __XTENSA_UL_CONST(TASK_SIZE)
Chris Zankel9a8fd552005-06-23 22:01:26 -0700123 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
Chris Zankel9a8fd552005-06-23 22:01:26 -0700157#else /* __ASSEMBLY__ not defined */
158
159#include <linux/sched.h>
Chris Zankel9a8fd552005-06-23 22:01:26 -0700160
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
Chris Zankel9a8fd552005-06-23 22:01:26 -0700184/*
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
211extern 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
Chris Zankel70e137e2007-10-23 10:58:53 -0700229#define __put_user_size(x,ptr,size,retval) \
230do { \
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 } \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700244} 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 \
Chris Zankel70e137e2007-10-23 10:58:53 -0700271 " _bbci.l %3, 0, 1f \n" \
272 " movi %0, %4 \n" \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700273 " _j 2f \n"
274
275#define __check_align_4 \
Chris Zankel70e137e2007-10-23 10:58:53 -0700276 " _bbsi.l %3, 0, 0f \n" \
277 " _bbci.l %3, 1, 1f \n" \
278 "0: movi %0, %4 \n" \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700279 " _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 */
Chris Zankel70e137e2007-10-23 10:58:53 -0700290#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) \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700308 :"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
328extern long __get_user_bad(void);
329
330#define __get_user_size(x,ptr,size,retval) \
331do { \
Chris Zankel70e137e2007-10-23 10:58:53 -0700332 int __cb; \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700333 retval = 0; \
334 switch (size) { \
Chris Zankel70e137e2007-10-23 10:58:53 -0700335 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; \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700338 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 */
Chris Zankel70e137e2007-10-23 10:58:53 -0700348#define __get_user_asm(x, addr, err, align, insn, cb) \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700349 __asm__ __volatile__( \
350 __check_align_##align \
Chris Zankel70e137e2007-10-23 10:58:53 -0700351 "1: "insn" %2, %3, 0 \n" \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700352 "2: \n" \
353 " .section .fixup,\"ax\" \n" \
354 " .align 4 \n" \
355 "4: \n" \
356 " .long 2b \n" \
357 "5: \n" \
Chris Zankel70e137e2007-10-23 10:58:53 -0700358 " l32r %1, 4b \n" \
359 " movi %2, 0 \n" \
360 " movi %0, %4 \n" \
361 " jx %1 \n" \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700362 " .previous \n" \
363 " .section __ex_table,\"a\" \n" \
364 " .long 1b, 5b \n" \
365 " .previous" \
Chris Zankel70e137e2007-10-23 10:58:53 -0700366 :"=r" (err), "=r" (cb), "=r" (x) \
Chris Zankel9a8fd552005-06-23 22:01:26 -0700367 :"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
383extern 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
387static 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
393static 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
399static 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
408static 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
Adrian Bunkd99cf712005-09-03 15:57:53 -0700434static inline unsigned long
Chris Zankel9a8fd552005-06-23 22:01:26 -0700435__xtensa_clear_user(void *addr, unsigned long size)
436{
437 if ( ! memset(addr, 0, size) )
438 return size;
439 return 0;
440}
441
Adrian Bunkd99cf712005-09-03 15:57:53 -0700442static inline unsigned long
Chris Zankel9a8fd552005-06-23 22:01:26 -0700443clear_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
453extern long __strncpy_user(char *, const char *, long);
454#define __strncpy_from_user __strncpy_user
455
Adrian Bunkd99cf712005-09-03 15:57:53 -0700456static inline long
Chris Zankel9a8fd552005-06-23 22:01:26 -0700457strncpy_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 */
470extern long __strnlen_user(const char *, long);
471
Adrian Bunkd99cf712005-09-03 15:57:53 -0700472static inline long strnlen_user(const char *str, long len)
Chris Zankel9a8fd552005-06-23 22:01:26 -0700473{
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
482struct exception_table_entry
483{
484 unsigned long insn, fixup;
485};
486
487/* Returns 0 if exception not found and fixup.unit otherwise. */
488
489extern unsigned long search_exception_table(unsigned long addr);
490extern 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 */