01f42b02e26cbc286e6c91f8ea1e35e0c2d8af5b
1 /* Changes made by Lineo Inc. May 2001
3 * Based on: include/asm-m68knommu/uaccess.h
6 #ifndef __BLACKFIN_UACCESS_H
7 #define __BLACKFIN_UACCESS_H
10 * User space memory access functions
12 #include <linux/sched.h>
14 #include <linux/string.h>
16 #include <asm/segment.h>
17 #ifdef CONFIG_ACCESS_CHECK
18 # include <asm/bfin-global.h>
21 #define get_ds() (KERNEL_DS)
22 #define get_fs() (current_thread_info()->addr_limit)
24 static inline void set_fs(mm_segment_t fs
)
26 current_thread_info()->addr_limit
= fs
;
29 #define segment_eq(a,b) ((a) == (b))
32 #define VERIFY_WRITE 1
34 #define access_ok(type, addr, size) _access_ok((unsigned long)(addr), (size))
36 static inline int is_in_rom(unsigned long addr
)
39 * What we are really trying to do is determine if addr is
40 * in an allocated kernel memory region. If not then assume
41 * we cannot free it or otherwise de-allocate it. Ideally
42 * we could restrict this to really being in a ROM or flash,
43 * but that would need to be done on a board by board basis,
46 if ((addr
< _ramstart
) || (addr
>= _ramend
))
49 /* Default case, not in ROM */
54 * The fs value determines whether argument validity checking should be
55 * performed or not. If get_fs() == USER_DS, checking is performed, with
56 * get_fs() == KERNEL_DS, checking is bypassed.
59 #ifndef CONFIG_ACCESS_CHECK
60 static inline int _access_ok(unsigned long addr
, unsigned long size
) { return 1; }
62 #ifdef CONFIG_ACCESS_OK_L1
63 extern int _access_ok(unsigned long addr
, unsigned long size
)__attribute__((l1_text
));
65 extern int _access_ok(unsigned long addr
, unsigned long size
);
70 * The exception table consists of pairs of addresses: the first is the
71 * address of an instruction that is allowed to fault, and the second is
72 * the address at which the program should continue. No registers are
73 * modified, so it is entirely up to the continuation code to figure out
76 * All the routines below use bits of fixup code that are out of line
77 * with the main instruction path. This means when everything is well,
78 * we don't even have to jump over them. Further, they do not intrude
79 * on our cache or tlb entries.
82 struct exception_table_entry
{
83 unsigned long insn
, fixup
;
87 * These are the main single-value transfer routines. They automatically
88 * use the right size if we just have the right pointer type.
91 #define put_user(x,p) \
94 typeof(*(p)) _x = (x); \
95 typeof(*(p)) *_p = (p); \
96 if (!access_ok(VERIFY_WRITE, _p, sizeof(*(_p)))) {\
100 switch (sizeof (*(_p))) { \
102 __put_user_asm(_x, _p, B); \
105 __put_user_asm(_x, _p, W); \
108 __put_user_asm(_x, _p, ); \
112 _xl = ((long *)&_x)[0]; \
113 _xh = ((long *)&_x)[1]; \
114 __put_user_asm(_xl, ((long *)_p)+0, ); \
115 __put_user_asm(_xh, ((long *)_p)+1, ); \
118 _err = __put_user_bad(); \
125 #define __put_user(x,p) put_user(x,p)
126 static inline int bad_user_access_length(void)
128 panic("bad_user_access_length");
132 #define __put_user_bad() (printk(KERN_INFO "put_user_bad %s:%d %s\n",\
133 __FILE__, __LINE__, __func__),\
134 bad_user_access_length(), (-EFAULT))
137 * Tell gcc we read from memory instead of writing: this is because
138 * we do not write to any memory gcc knows about, so there are no
142 #define __ptr(x) ((unsigned long *)(x))
144 #define __put_user_asm(x,p,bhw) \
145 __asm__ (#bhw"[%1] = %0;\n\t" \
147 :"d" (x),"a" (__ptr(p)) : "memory")
149 #define get_user(x, ptr) \
152 unsigned long _val = 0; \
153 const typeof(*(ptr)) __user *_p = (ptr); \
154 const size_t ptr_size = sizeof(*(_p)); \
155 if (likely(access_ok(VERIFY_READ, _p, ptr_size))) { \
156 BUILD_BUG_ON(ptr_size >= 8); \
157 switch (ptr_size) { \
159 __get_user_asm(_val, _p, B,(Z)); \
162 __get_user_asm(_val, _p, W,(Z)); \
165 __get_user_asm(_val, _p, , ); \
170 x = (typeof(*(ptr)))_val; \
174 #define __get_user(x,p) get_user(x,p)
176 #define __get_user_bad() (bad_user_access_length(), (-EFAULT))
178 #define __get_user_asm(x, ptr, bhw, option) \
180 __asm__ __volatile__ ( \
181 "%0 =" #bhw "[%1]" #option ";" \
183 : "a" (__ptr(ptr))); \
186 #define __copy_from_user(to, from, n) copy_from_user(to, from, n)
187 #define __copy_to_user(to, from, n) copy_to_user(to, from, n)
188 #define __copy_to_user_inatomic __copy_to_user
189 #define __copy_from_user_inatomic __copy_from_user
191 #define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n))\
194 #define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n))\
197 static inline unsigned long __must_check
198 copy_from_user(void *to
, const void __user
*from
, unsigned long n
)
200 if (access_ok(VERIFY_READ
, from
, n
))
207 static inline unsigned long __must_check
208 copy_to_user(void *to
, const void __user
*from
, unsigned long n
)
210 if (access_ok(VERIFY_WRITE
, to
, n
))
218 * Copy a null terminated string from userspace.
221 static inline long __must_check
222 strncpy_from_user(char *dst
, const char *src
, long count
)
225 if (!access_ok(VERIFY_READ
, src
, 1))
227 strncpy(dst
, src
, count
);
228 for (tmp
= dst
; *tmp
&& count
> 0; tmp
++, count
--) ;
233 * Get the size of a string in user space.
234 * src: The string to measure
235 * n: The maximum valid length
237 * Get the size of a NUL-terminated string in user space.
239 * Returns the size of the string INCLUDING the terminating NUL.
240 * On exception, returns 0.
241 * If the string is too long, returns a value greater than n.
243 static inline long __must_check
strnlen_user(const char *src
, long n
)
245 if (!access_ok(VERIFY_READ
, src
, 1))
247 return strnlen(src
, n
) + 1;
250 static inline long __must_check
strlen_user(const char *src
)
252 if (!access_ok(VERIFY_READ
, src
, 1))
254 return strlen(src
) + 1;
261 static inline unsigned long __must_check
262 __clear_user(void *to
, unsigned long n
)
264 if (!access_ok(VERIFY_WRITE
, to
, n
))
270 #define clear_user(to, n) __clear_user(to, n)
272 #endif /* _BLACKFIN_UACCESS_H */
This page took 0.05647 seconds and 4 git commands to generate.