1 /* MN10300 userspace access functions
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
11 #ifndef _ASM_UACCESS_H
12 #define _ASM_UACCESS_H
15 * User space memory access functions
17 #include <linux/thread_info.h>
18 #include <linux/kernel.h>
20 #include <asm/errno.h>
23 #define VERIFY_WRITE 1
26 * The fs value determines whether argument validity checking should be
27 * performed or not. If get_fs() == USER_DS, checking is performed, with
28 * get_fs() == KERNEL_DS, checking is bypassed.
30 * For historical reasons, these macros are grossly misnamed.
32 #define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
34 #define KERNEL_XDS MAKE_MM_SEG(0xBFFFFFFF)
35 #define KERNEL_DS MAKE_MM_SEG(0x9FFFFFFF)
36 #define USER_DS MAKE_MM_SEG(TASK_SIZE)
38 #define get_ds() (KERNEL_DS)
39 #define get_fs() (current_thread_info()->addr_limit)
40 #define set_fs(x) (current_thread_info()->addr_limit = (x))
41 #define __kernel_ds_p() (current_thread_info()->addr_limit.seg == 0x9FFFFFFF)
43 #define segment_eq(a, b) ((a).seg == (b).seg)
45 #define __addr_ok(addr) \
46 ((unsigned long)(addr) < (current_thread_info()->addr_limit.seg))
49 * check that a range of addresses falls within the current address limit
51 static inline int ___range_ok(unsigned long addr
, unsigned int size
)
55 asm(" add %3,%1 \n" /* set C-flag if addr + size > 4Gb */
57 " cmp %4,%1 \n" /* jump if addr+size>limit (error) */
59 " clr %0 \n" /* mark okay */
61 : "=r"(flag
), "=&r"(tmp
)
62 : "1"(addr
), "ir"(size
),
63 "r"(current_thread_info()->addr_limit
.seg
), "0"(flag
)
70 #define __range_ok(addr, size) ___range_ok((unsigned long)(addr), (u32)(size))
72 #define access_ok(type, addr, size) (__range_ok((addr), (size)) == 0)
73 #define __access_ok(addr, size) (__range_ok((addr), (size)) == 0)
75 static inline int verify_area(int type
, const void *addr
, unsigned long size
)
77 return access_ok(type
, addr
, size
) ? 0 : -EFAULT
;
82 * The exception table consists of pairs of addresses: the first is the
83 * address of an instruction that is allowed to fault, and the second is
84 * the address at which the program should continue. No registers are
85 * modified, so it is entirely up to the continuation code to figure out
88 * All the routines below use bits of fixup code that are out of line
89 * with the main instruction path. This means when everything is well,
90 * we don't even have to jump over them. Further, they do not intrude
91 * on our cache or tlb entries.
94 struct exception_table_entry
96 unsigned long insn
, fixup
;
99 /* Returns 0 if exception not found and fixup otherwise. */
100 extern int fixup_exception(struct pt_regs
*regs
);
102 #define put_user(x, ptr) __put_user_check((x), (ptr), sizeof(*(ptr)))
103 #define get_user(x, ptr) __get_user_check((x), (ptr), sizeof(*(ptr)))
106 * The "__xxx" versions do not do address space checking, useful when
107 * doing multiple accesses to the same area (the user has to do the
108 * checks by hand with "access_ok()")
110 #define __put_user(x, ptr) __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
111 #define __get_user(x, ptr) __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
113 struct __large_struct
{ unsigned long buf
[100]; };
114 #define __m(x) (*(struct __large_struct *)(x))
116 #define __get_user_nocheck(x, ptr, size) \
118 unsigned long __gu_addr; \
120 __gu_addr = (unsigned long) (ptr); \
123 unsigned char __gu_val; \
124 __get_user_asm("bu"); \
125 (x) = *(__force __typeof__(*(ptr))*) &__gu_val; \
129 unsigned short __gu_val; \
130 __get_user_asm("hu"); \
131 (x) = *(__force __typeof__(*(ptr))*) &__gu_val; \
135 unsigned int __gu_val; \
136 __get_user_asm(""); \
137 (x) = *(__force __typeof__(*(ptr))*) &__gu_val; \
141 __get_user_unknown(); \
147 #define __get_user_check(x, ptr, size) \
149 const __typeof__(*(ptr))* __guc_ptr = (ptr); \
151 if (likely(__access_ok((unsigned long) __guc_ptr, (size)))) \
152 _e = __get_user_nocheck((x), __guc_ptr, (size)); \
155 (x) = (__typeof__(x))0; \
160 #define __get_user_asm(INSN) \
164 " mov"INSN" %2,%1\n" \
167 " .section .fixup,\"ax\"\n" \
172 " .section __ex_table,\"a\"\n" \
176 : "=&r" (__gu_err), "=&r" (__gu_val) \
177 : "m" (__m(__gu_addr)), "i" (-EFAULT)); \
180 extern int __get_user_unknown(void);
182 #define __put_user_nocheck(x, ptr, size) \
185 __typeof__(*(ptr)) val; \
188 unsigned long __pu_addr; \
190 __pu_val.val = (x); \
191 __pu_addr = (unsigned long) (ptr); \
193 case 1: __put_user_asm("bu"); break; \
194 case 2: __put_user_asm("hu"); break; \
195 case 4: __put_user_asm("" ); break; \
196 case 8: __put_user_asm8(); break; \
197 default: __pu_err = __put_user_unknown(); break; \
202 #define __put_user_check(x, ptr, size) \
205 __typeof__(*(ptr)) val; \
208 unsigned long __pu_addr; \
210 __pu_val.val = (x); \
211 __pu_addr = (unsigned long) (ptr); \
212 if (likely(__access_ok(__pu_addr, size))) { \
214 case 1: __put_user_asm("bu"); break; \
215 case 2: __put_user_asm("hu"); break; \
216 case 4: __put_user_asm("" ); break; \
217 case 8: __put_user_asm8(); break; \
218 default: __pu_err = __put_user_unknown(); break; \
222 __pu_err = -EFAULT; \
227 #define __put_user_asm(INSN) \
231 " mov"INSN" %1,%2\n" \
234 " .section .fixup,\"ax\"\n" \
239 " .section __ex_table,\"a\"\n" \
244 : "r" (__pu_val.val), "m" (__m(__pu_addr)), \
249 #define __put_user_asm8() \
256 " .section .fixup,\"ax\" \n" \
261 " .section __ex_table,\"a\"\n" \
267 : "r" (__pu_val.bits[0]), "r" (__pu_val.bits[1]), \
268 "m" (__m(__pu_addr)), "m" (__m(__pu_addr+4)), \
273 extern int __put_user_unknown(void);
277 * Copy To/From Userspace
279 /* Generic arbitrary sized copy. */
280 #define __copy_user(to, from, size) \
284 const void *__from = from; \
287 "0: movbu (%0),%3;\n" \
288 "1: movbu %3,(%1);\n" \
294 " .section .fixup,\"ax\"\n" \
297 " .section __ex_table,\"a\"\n" \
302 : "=a"(__from), "=a"(__to), "=r"(size), "=&r"(w)\
303 : "0"(__from), "1"(__to), "2"(size) \
308 #define __copy_user_zeroing(to, from, size) \
312 const void *__from = from; \
315 "0: movbu (%0),%3;\n" \
316 "1: movbu %3,(%1);\n" \
322 " .section .fixup,\"ax\"\n" \
326 "4: movbu %3,(%1);\n" \
333 " .section __ex_table,\"a\"\n" \
338 : "=a"(__from), "=a"(__to), "=r"(size), "=&r"(w)\
339 : "0"(__from), "1"(__to), "2"(size) \
344 /* We let the __ versions of copy_from/to_user inline, because they're often
345 * used in fast paths and have only a small space overhead.
348 unsigned long __generic_copy_from_user_nocheck(void *to
, const void *from
,
351 __copy_user_zeroing(to
, from
, n
);
356 unsigned long __generic_copy_to_user_nocheck(void *to
, const void *from
,
359 __copy_user(to
, from
, n
);
365 #error "don't use - these macros don't increment to & from pointers"
366 /* Optimize just a little bit when we know the size of the move. */
367 #define __constant_copy_user(to, from, size) \
371 "0: movbu (%1),d3;\n" \
372 "1: movbu d3,(%2);\n" \
376 ".section .fixup,\"ax\"\n" \
379 ".section __ex_table,\"a\"\n" \
385 : "d"(size), "d"(to), "d"(from) \
389 /* Optimize just a little bit when we know the size of the move. */
390 #define __constant_copy_user_zeroing(to, from, size) \
394 "0: movbu (%1),d3;\n" \
395 "1: movbu d3,(%2);\n" \
399 ".section .fixup,\"ax\"\n" \
402 ".section __ex_table,\"a\"\n" \
408 : "d"(size), "d"(to), "d"(from) \
413 unsigned long __constant_copy_to_user(void *to
, const void *from
,
416 if (access_ok(VERIFY_WRITE
, to
, n
))
417 __constant_copy_user(to
, from
, n
);
422 unsigned long __constant_copy_from_user(void *to
, const void *from
,
425 if (access_ok(VERIFY_READ
, from
, n
))
426 __constant_copy_user_zeroing(to
, from
, n
);
431 unsigned long __constant_copy_to_user_nocheck(void *to
, const void *from
,
434 __constant_copy_user(to
, from
, n
);
439 unsigned long __constant_copy_from_user_nocheck(void *to
, const void *from
,
442 __constant_copy_user_zeroing(to
, from
, n
);
447 extern unsigned long __generic_copy_to_user(void __user
*, const void *,
449 extern unsigned long __generic_copy_from_user(void *, const void __user
*,
452 #define __copy_to_user_inatomic(to, from, n) \
453 __generic_copy_to_user_nocheck((to), (from), (n))
454 #define __copy_from_user_inatomic(to, from, n) \
455 __generic_copy_from_user_nocheck((to), (from), (n))
457 #define __copy_to_user(to, from, n) \
460 __copy_to_user_inatomic((to), (from), (n)); \
463 #define __copy_from_user(to, from, n) \
466 __copy_from_user_inatomic((to), (from), (n)); \
470 #define copy_to_user(to, from, n) __generic_copy_to_user((to), (from), (n))
471 #define copy_from_user(to, from, n) __generic_copy_from_user((to), (from), (n))
473 extern long strncpy_from_user(char *dst
, const char __user
*src
, long count
);
474 extern long __strncpy_from_user(char *dst
, const char __user
*src
, long count
);
475 extern long strnlen_user(const char __user
*str
, long n
);
476 #define strlen_user(str) strnlen_user(str, ~0UL >> 1)
477 extern unsigned long clear_user(void __user
*mem
, unsigned long len
);
478 extern unsigned long __clear_user(void __user
*mem
, unsigned long len
);
480 #endif /* _ASM_UACCESS_H */
This page took 0.048218 seconds and 6 git commands to generate.