2 * include/asm-xtensa/uaccess.h
4 * User space memory access functions
6 * These routines provide basic accessing functions to the user memory
7 * space for the kernel. This header file provides functions such as:
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
13 * Copyright (C) 2001 - 2005 Tensilica Inc.
16 #ifndef _XTENSA_UACCESS_H
17 #define _XTENSA_UACCESS_H
19 #include <linux/errno.h>
20 #include <linux/prefetch.h>
21 #include <asm/types.h>
24 #define VERIFY_WRITE 1
26 #include <linux/sched.h>
29 * The fs value determines whether argument validity checking should
30 * be performed or not. If get_fs() == USER_DS, checking is
31 * performed, with get_fs() == KERNEL_DS, checking is bypassed.
33 * For historical reasons (Data Segment Register?), these macros are
37 #define KERNEL_DS ((mm_segment_t) { 0 })
38 #define USER_DS ((mm_segment_t) { 1 })
40 #define get_ds() (KERNEL_DS)
41 #define get_fs() (current->thread.current_ds)
42 #define set_fs(val) (current->thread.current_ds = (val))
44 #define segment_eq(a, b) ((a).seg == (b).seg)
46 #define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
47 #define __user_ok(addr, size) \
48 (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
49 #define __access_ok(addr, size) (__kernel_ok || __user_ok((addr), (size)))
50 #define access_ok(type, addr, size) __access_ok((unsigned long)(addr), (size))
53 * These are the main single-value transfer routines. They
54 * automatically use the right size if we just have the right pointer
57 * This gets kind of ugly. We want to return _two_ values in
58 * "get_user()" and yet we don't want to do any pointers, because that
59 * is too much of a performance impact. Thus we have a few rather ugly
60 * macros here, and hide all the uglyness from the user.
63 * (a) re-use the arguments for side effects (sizeof is ok)
64 * (b) require any knowledge of processes at this stage
66 #define put_user(x, ptr) __put_user_check((x), (ptr), sizeof(*(ptr)))
67 #define get_user(x, ptr) __get_user_check((x), (ptr), sizeof(*(ptr)))
70 * The "__xxx" versions of the user access functions are versions that
71 * do not verify the address space, that must have been done previously
72 * with a separate "access_ok()" call (this is used when we do multiple
73 * accesses to the same area of user memory).
75 #define __put_user(x, ptr) __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
76 #define __get_user(x, ptr) __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
79 extern long __put_user_bad(void);
81 #define __put_user_nocheck(x, ptr, size) \
84 __put_user_size((x), (ptr), (size), __pu_err); \
88 #define __put_user_check(x, ptr, size) \
90 long __pu_err = -EFAULT; \
91 __typeof__(*(ptr)) *__pu_addr = (ptr); \
92 if (access_ok(VERIFY_WRITE, __pu_addr, size)) \
93 __put_user_size((x), __pu_addr, (size), __pu_err); \
97 #define __put_user_size(x, ptr, size, retval) \
102 case 1: __put_user_asm(x, ptr, retval, 1, "s8i", __cb); break; \
103 case 2: __put_user_asm(x, ptr, retval, 2, "s16i", __cb); break; \
104 case 4: __put_user_asm(x, ptr, retval, 4, "s32i", __cb); break; \
106 __typeof__(*ptr) __v64 = x; \
107 retval = __copy_to_user(ptr, &__v64, 8); \
110 default: __put_user_bad(); \
116 * Consider a case of a user single load/store would cause both an
117 * unaligned exception and an MMU-related exception (unaligned
118 * exceptions happen first):
120 * User code passes a bad variable ptr to a system call.
121 * Kernel tries to access the variable.
122 * Unaligned exception occurs.
123 * Unaligned exception handler tries to make aligned accesses.
124 * Double exception occurs for MMU-related cause (e.g., page not mapped).
125 * do_page_fault() thinks the fault address belongs to the kernel, not the
128 * The kernel currently prohibits user unaligned accesses. We use the
129 * __check_align_* macros to check for unaligned addresses before
130 * accessing user space so we don't crash the kernel. Both
131 * __put_user_asm and __get_user_asm use these alignment macros, so
132 * macro-specific labels such as 0f, 1f, %0, %2, and %3 must stay in
136 #define __check_align_1 ""
138 #define __check_align_2 \
139 " _bbci.l %3, 0, 1f \n" \
143 #define __check_align_4 \
144 " _bbsi.l %3, 0, 0f \n" \
145 " _bbci.l %3, 1, 1f \n" \
146 "0: movi %0, %4 \n" \
151 * We don't tell gcc that we are accessing memory, but this is OK
152 * because we do not write to any memory gcc knows about, so there
153 * are no aliasing issues.
155 * WARNING: If you modify this macro at all, verify that the
156 * __check_align_* macros still work.
158 #define __put_user_asm(x, addr, err, align, insn, cb) \
159 __asm__ __volatile__( \
160 __check_align_##align \
161 "1: "insn" %2, %3, 0 \n" \
163 " .section .fixup,\"ax\" \n" \
172 " .section __ex_table,\"a\" \n" \
175 :"=r" (err), "=r" (cb) \
176 :"r" ((int)(x)), "r" (addr), "i" (-EFAULT), "0" (err))
178 #define __get_user_nocheck(x, ptr, size) \
180 long __gu_err, __gu_val; \
181 __get_user_size(__gu_val, (ptr), (size), __gu_err); \
182 (x) = (__force __typeof__(*(ptr)))__gu_val; \
186 #define __get_user_check(x, ptr, size) \
188 long __gu_err = -EFAULT, __gu_val = 0; \
189 const __typeof__(*(ptr)) *__gu_addr = (ptr); \
190 if (access_ok(VERIFY_READ, __gu_addr, size)) \
191 __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
192 (x) = (__force __typeof__(*(ptr)))__gu_val; \
196 extern long __get_user_bad(void);
198 #define __get_user_size(x, ptr, size, retval) \
203 case 1: __get_user_asm(x, ptr, retval, 1, "l8ui", __cb); break;\
204 case 2: __get_user_asm(x, ptr, retval, 2, "l16ui", __cb); break;\
205 case 4: __get_user_asm(x, ptr, retval, 4, "l32i", __cb); break;\
206 case 8: retval = __copy_from_user(&x, ptr, 8); break; \
207 default: (x) = __get_user_bad(); \
213 * WARNING: If you modify this macro at all, verify that the
214 * __check_align_* macros still work.
216 #define __get_user_asm(x, addr, err, align, insn, cb) \
217 __asm__ __volatile__( \
218 __check_align_##align \
219 "1: "insn" %2, %3, 0 \n" \
221 " .section .fixup,\"ax\" \n" \
231 " .section __ex_table,\"a\" \n" \
234 :"=r" (err), "=r" (cb), "=r" (x) \
235 :"r" (addr), "i" (-EFAULT), "0" (err))
239 * Copy to/from user space
243 * We use a generic, arbitrary-sized copy subroutine. The Xtensa
244 * architecture would cause heavy code bloat if we tried to inline
245 * these functions and provide __constant_copy_* equivalents like the
246 * i386 versions. __xtensa_copy_user is quite efficient. See the
247 * .fixup section of __xtensa_copy_user for a discussion on the
248 * X_zeroing equivalents for Xtensa.
251 extern unsigned __xtensa_copy_user(void *to, const void *from, unsigned n);
252 #define __copy_user(to, from, size) __xtensa_copy_user(to, from, size)
255 static inline unsigned long
256 __generic_copy_from_user_nocheck(void *to, const void *from, unsigned long n)
258 return __copy_user(to, from, n);
261 static inline unsigned long
262 __generic_copy_to_user_nocheck(void *to, const void *from, unsigned long n)
264 return __copy_user(to, from, n);
267 static inline unsigned long
268 __generic_copy_to_user(void *to, const void *from, unsigned long n)
271 if (access_ok(VERIFY_WRITE, to, n))
272 return __copy_user(to, from, n);
276 static inline unsigned long
277 __generic_copy_from_user(void *to, const void *from, unsigned long n)
280 if (access_ok(VERIFY_READ, from, n))
281 return __copy_user(to, from, n);
287 #define copy_to_user(to, from, n) __generic_copy_to_user((to), (from), (n))
288 #define copy_from_user(to, from, n) __generic_copy_from_user((to), (from), (n))
289 #define __copy_to_user(to, from, n) \
290 __generic_copy_to_user_nocheck((to), (from), (n))
291 #define __copy_from_user(to, from, n) \
292 __generic_copy_from_user_nocheck((to), (from), (n))
293 #define __copy_to_user_inatomic __copy_to_user
294 #define __copy_from_user_inatomic __copy_from_user
298 * We need to return the number of bytes not cleared. Our memset()
299 * returns zero if a problem occurs while accessing user-space memory.
300 * In that event, return no memory cleared. Otherwise, zero for
304 static inline unsigned long
305 __xtensa_clear_user(void *addr, unsigned long size)
307 if ( ! memset(addr, 0, size) )
312 static inline unsigned long
313 clear_user(void *addr, unsigned long size)
315 if (access_ok(VERIFY_WRITE, addr, size))
316 return __xtensa_clear_user(addr, size);
317 return size ? -EFAULT : 0;
320 #define __clear_user __xtensa_clear_user
323 extern long __strncpy_user(char *, const char *, long);
324 #define __strncpy_from_user __strncpy_user
327 strncpy_from_user(char *dst, const char *src, long count)
329 if (access_ok(VERIFY_READ, src, 1))
330 return __strncpy_from_user(dst, src, count);
335 #define strlen_user(str) strnlen_user((str), TASK_SIZE - 1)
338 * Return the size of a string (including the ending 0!)
340 extern long __strnlen_user(const char *, long);
342 static inline long strnlen_user(const char *str, long len)
344 unsigned long top = __kernel_ok ? ~0UL : TASK_SIZE - 1;
346 if ((unsigned long)str > top)
348 return __strnlen_user(str, len);
352 struct exception_table_entry
354 unsigned long insn, fixup;
357 #endif /* _XTENSA_UACCESS_H */