2 * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
3 * Copyright (C) 2008-2009 PetaLogix
4 * Copyright (C) 2006 Atmark Techno, Inc.
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
11 #ifndef _ASM_MICROBLAZE_UACCESS_H
12 #define _ASM_MICROBLAZE_UACCESS_H
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/sched.h> /* RLIMIT_FSIZE */
24 #include <asm/pgtable.h>
25 #include <linux/string.h>
28 #define VERIFY_WRITE 1
31 * On Microblaze the fs value is actually the top of the corresponding
34 * The fs value determines whether argument validity checking should be
35 * performed or not. If get_fs() == USER_DS, checking is performed, with
36 * get_fs() == KERNEL_DS, checking is bypassed.
38 * For historical reasons, these macros are grossly misnamed.
40 * For non-MMU arch like Microblaze, KERNEL_DS and USER_DS is equal.
42 # define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
45 # define KERNEL_DS MAKE_MM_SEG(0)
46 # define USER_DS KERNEL_DS
48 # define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
49 # define USER_DS MAKE_MM_SEG(TASK_SIZE - 1)
52 # define get_ds() (KERNEL_DS)
53 # define get_fs() (current_thread_info()->addr_limit)
54 # define set_fs(val) (current_thread_info()->addr_limit = (val))
56 # define segment_eq(a, b) ((a).seg == (b).seg)
59 * The exception table consists of pairs of addresses: the first is the
60 * address of an instruction that is allowed to fault, and the second is
61 * the address at which the program should continue. No registers are
62 * modified, so it is entirely up to the continuation code to figure out
65 * All the routines below use bits of fixup code that are out of line
66 * with the main instruction path. This means when everything is well,
67 * we don't even have to jump over them. Further, they do not intrude
68 * on our cache or tlb entries.
70 struct exception_table_entry {
71 unsigned long insn, fixup;
74 /* Returns 0 if exception not found and fixup otherwise. */
75 extern unsigned long search_exception_table(unsigned long);
79 /* Check against bounds of physical memory */
80 static inline int ___range_ok(unsigned long addr, unsigned long size)
82 return ((addr < memory_start) ||
83 ((addr + size) > memory_end));
86 #define __range_ok(addr, size) \
87 ___range_ok((unsigned long)(addr), (unsigned long)(size))
89 #define access_ok(type, addr, size) (__range_ok((addr), (size)) == 0)
94 * Address is valid if:
95 * - "addr", "addr + size" and "size" are all below the limit
97 #define access_ok(type, addr, size) \
98 (get_fs().seg > (((unsigned long)(addr)) | \
99 (size) | ((unsigned long)(addr) + (size))))
101 /* || printk("access_ok failed for %s at 0x%08lx (size %d), seg 0x%08x\n",
102 type?"WRITE":"READ",addr,size,get_fs().seg)) */
107 # define __FIXUP_SECTION ".section .fixup,\"ax\"\n"
108 # define __EX_TABLE_SECTION ".section __ex_table,\"a\"\n"
110 # define __FIXUP_SECTION ".section .discard,\"ax\"\n"
111 # define __EX_TABLE_SECTION ".section .discard,\"a\"\n"
114 extern unsigned long __copy_tofrom_user(void __user *to,
115 const void __user *from, unsigned long size);
117 /* Return: number of not copied bytes, i.e. 0 if OK or non-zero if fail. */
118 static inline unsigned long __must_check __clear_user(void __user *to,
121 /* normal memset with two words to __ex_table */
122 __asm__ __volatile__ ( \
123 "1: sb r0, %2, r0;" \
124 " addik %0, %0, -1;" \
126 " addik %2, %2, 1;" \
137 static inline unsigned long __must_check clear_user(void __user *to,
141 if (unlikely(!access_ok(VERIFY_WRITE, to, n)))
144 return __clear_user(to, n);
149 extern long __user_bad(void);
151 #define __get_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \
153 __asm__ __volatile__ ( \
154 "1:" insn " %1, %2, r0;" \
155 " addk %0, r0, r0;" \
159 " addik %0, r0, %3;" \
164 : "=&r"(__gu_err), "=r"(__gu_val) \
165 : "r"(__gu_ptr), "i"(-EFAULT) \
170 * get_user: - Get a simple variable from user space.
171 * @x: Variable to store result.
172 * @ptr: Source address, in user space.
174 * Context: User context only. This function may sleep.
176 * This macro copies a single simple variable from user space to kernel
177 * space. It supports simple types like char and int, but not larger
178 * data types like structures or arrays.
180 * @ptr must have pointer-to-simple-variable type, and the result of
181 * dereferencing @ptr must be assignable to @x without a cast.
183 * Returns zero on success, or -EFAULT on error.
184 * On error, the variable @x is set to zero.
187 #define __get_user(x, ptr) \
189 unsigned long __gu_val; \
190 /*unsigned long __gu_ptr = (unsigned long)(ptr);*/ \
192 switch (sizeof(*(ptr))) { \
194 __get_user_asm("lbu", (ptr), __gu_val, __gu_err); \
197 __get_user_asm("lhu", (ptr), __gu_val, __gu_err); \
200 __get_user_asm("lw", (ptr), __gu_val, __gu_err); \
203 /* __gu_val = 0; __gu_err = -EINVAL;*/ __gu_err = __user_bad();\
205 x = (__typeof__(*(ptr))) __gu_val; \
210 #define get_user(x, ptr) \
212 access_ok(VERIFY_READ, (ptr), sizeof(*(ptr))) \
213 ? __get_user((x), (ptr)) : -EFAULT; \
216 #define __put_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \
218 __asm__ __volatile__ ( \
219 "1:" insn " %1, %2, r0;" \
220 " addk %0, r0, r0;" \
224 " addik %0, r0, %3;" \
230 : "r"(__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \
234 #define __put_user_asm_8(__gu_ptr, __gu_val, __gu_err) \
236 __asm__ __volatile__ (" lwi %0, %1, 0;" \
237 "1: swi %0, %2, 0;" \
239 "2: swi %0, %2, 4;" \
240 " addk %0, r0, r0;" \
244 " addik %0, r0, %3;" \
247 ".word 1b,4b,2b,4b;" \
250 : "r"(&__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \
254 #define __put_user(x, ptr) \
256 __typeof__(*(ptr)) volatile __gu_val = (x); \
258 switch (sizeof(__gu_val)) { \
260 __put_user_asm("sb", (ptr), __gu_val, __gu_err); \
263 __put_user_asm("sh", (ptr), __gu_val, __gu_err); \
266 __put_user_asm("sw", (ptr), __gu_val, __gu_err); \
269 __put_user_asm_8((ptr), __gu_val, __gu_err); \
272 /*__gu_err = -EINVAL;*/ __gu_err = __user_bad(); \
277 #define put_user(x, ptr) __put_user((x), (ptr))
279 #define copy_to_user(to, from, n) (memcpy((to), (from), (n)), 0)
280 #define copy_from_user(to, from, n) (memcpy((to), (from), (n)), 0)
282 #define __copy_to_user(to, from, n) (copy_to_user((to), (from), (n)))
283 #define __copy_from_user(to, from, n) (copy_from_user((to), (from), (n)))
284 #define __copy_to_user_inatomic(to, from, n) \
285 (__copy_to_user((to), (from), (n)))
286 #define __copy_from_user_inatomic(to, from, n) \
287 (__copy_from_user((to), (from), (n)))
289 extern long strncpy_from_user(char *dst, const char *src, long count);
290 extern long strnlen_user(const char *src, long count);
292 #else /* CONFIG_MMU */
294 /* put_user and get_user macros */
296 extern long __user_bad(void);
298 #define __get_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \
300 __asm__ __volatile__ ( \
301 "1:" insn " %1, %2, r0;" \
302 " addk %0, r0, r0;" \
306 " addik %0, r0, %3;" \
311 : "=&r"(__gu_err), "=r"(__gu_val) \
312 : "r"(__gu_ptr), "i"(-EFAULT) \
316 #define __get_user(x, ptr) \
318 unsigned long __gu_val; \
319 /*unsigned long __gu_ptr = (unsigned long)(ptr);*/ \
321 switch (sizeof(*(ptr))) { \
323 __get_user_asm("lbu", (ptr), __gu_val, __gu_err); \
326 __get_user_asm("lhu", (ptr), __gu_val, __gu_err); \
329 __get_user_asm("lw", (ptr), __gu_val, __gu_err); \
332 /* __gu_val = 0; __gu_err = -EINVAL;*/ __gu_err = __user_bad();\
334 x = (__typeof__(*(ptr))) __gu_val; \
339 * get_user: - Get a simple variable from user space.
340 * @x: Variable to store result.
341 * @ptr: Source address, in user space.
343 * Context: User context only. This function may sleep.
345 * This macro copies a single simple variable from user space to kernel
346 * space. It supports simple types like char and int, but not larger
347 * data types like structures or arrays.
349 * @ptr must have pointer-to-simple-variable type, and the result of
350 * dereferencing @ptr must be assignable to @x without a cast.
352 * Returns zero on success, or -EFAULT on error.
353 * On error, the variable @x is set to zero.
356 #define get_user(x, ptr) \
358 access_ok(VERIFY_READ, (ptr), sizeof(*(ptr))) \
359 ? __get_user((x), (ptr)) : -EFAULT; \
363 * put_user: - Write a simple value into user space.
364 * @x: Value to copy to user space.
365 * @ptr: Destination address, in user space.
367 * Context: User context only. This function may sleep.
369 * This macro copies a single simple value from kernel space to user
370 * space. It supports simple types like char and int, but not larger
371 * data types like structures or arrays.
373 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
374 * to the result of dereferencing @ptr.
376 * Returns zero on success, or -EFAULT on error.
379 #define __put_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \
381 __asm__ __volatile__ ( \
382 "1:" insn " %1, %2, r0;" \
383 " addk %0, r0, r0;" \
387 " addik %0, r0, %3;" \
393 : "r"(__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \
397 #define __put_user_asm_8(__gu_ptr, __gu_val, __gu_err) \
399 __asm__ __volatile__ (" lwi %0, %1, 0;" \
400 "1: swi %0, %2, 0;" \
402 "2: swi %0, %2, 4;" \
403 " addk %0, r0, r0;" \
407 " addik %0, r0, %3;" \
410 ".word 1b,4b,2b,4b;" \
413 : "r"(&__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \
417 #define __put_user(x, ptr) \
419 __typeof__(*(ptr)) volatile __gu_val = (x); \
421 switch (sizeof(__gu_val)) { \
423 __put_user_asm("sb", (ptr), __gu_val, __gu_err); \
426 __put_user_asm("sh", (ptr), __gu_val, __gu_err); \
429 __put_user_asm("sw", (ptr), __gu_val, __gu_err); \
432 __put_user_asm_8((ptr), __gu_val, __gu_err); \
435 /*__gu_err = -EINVAL;*/ __gu_err = __user_bad(); \
440 #define put_user(x, ptr) \
442 access_ok(VERIFY_WRITE, (ptr), sizeof(*(ptr))) \
443 ? __put_user((x), (ptr)) : -EFAULT; \
446 #define __copy_from_user(to, from, n) \
447 __copy_tofrom_user((__force void __user *)(to), \
448 (void __user *)(from), (n))
449 #define __copy_from_user_inatomic(to, from, n) \
450 copy_from_user((to), (from), (n))
452 static inline long copy_from_user(void *to,
453 const void __user *from, unsigned long n)
456 if (access_ok(VERIFY_READ, from, n))
457 return __copy_from_user(to, from, n);
462 #define __copy_to_user(to, from, n) \
463 __copy_tofrom_user((void __user *)(to), \
464 (__force const void __user *)(from), (n))
465 #define __copy_to_user_inatomic(to, from, n) copy_to_user((to), (from), (n))
467 static inline long copy_to_user(void __user *to,
468 const void *from, unsigned long n)
471 if (access_ok(VERIFY_WRITE, to, n))
472 return __copy_to_user(to, from, n);
477 extern int __strncpy_user(char *to, const char __user *from, int len);
479 #define __strncpy_from_user __strncpy_user
482 strncpy_from_user(char *dst, const char __user *src, long count)
484 if (!access_ok(VERIFY_READ, src, 1))
486 return __strncpy_from_user(dst, src, count);
489 extern int __strnlen_user(const char __user *sstr, int len);
491 #define strnlen_user(str, len) \
492 (access_ok(VERIFY_READ, str, 1) ? __strnlen_user(str, len) : 0)
494 #endif /* CONFIG_MMU */
496 #endif /* __ASSEMBLY__ */
497 #endif /* __KERNEL__ */
499 #endif /* _ASM_MICROBLAZE_UACCESS_H */