?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added 2.6.29.6 aldebaran kernel
[nao-ulib.git] / kernel / 2.6.29.6-aldebaran-rt / arch / arm / include / asm / uaccess.h
blob7897464e0c24260fe002e0ffac839444c35d5079
1 /*
2 * arch/arm/include/asm/uaccess.h
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 */
8 #ifndef _ASMARM_UACCESS_H
9 #define _ASMARM_UACCESS_H
10
11 /*
12 * User space memory access functions
13 */
14 #include <linux/string.h>
15 #include <linux/thread_info.h>
16 #include <asm/errno.h>
17 #include <asm/memory.h>
18 #include <asm/domain.h>
19 #include <asm/system.h>
20
21 #define VERIFY_READ 0
22 #define VERIFY_WRITE 1
23
24 /*
25 * The exception table consists of pairs of addresses: the first is the
26 * address of an instruction that is allowed to fault, and the second is
27 * the address at which the program should continue. No registers are
28 * modified, so it is entirely up to the continuation code to figure out
29 * what to do.
30 *
31 * All the routines below use bits of fixup code that are out of line
32 * with the main instruction path. This means when everything is well,
33 * we don't even have to jump over them. Further, they do not intrude
34 * on our cache or tlb entries.
35 */
36
37 struct exception_table_entry
38 {
39 unsigned long insn, fixup;
40 };
41
42 extern int fixup_exception(struct pt_regs *regs);
43
44 /*
45 * These two are intentionally not defined anywhere - if the kernel
46 * code generates any references to them, that's a bug.
47 */
48 extern int __get_user_bad(void);
49 extern int __put_user_bad(void);
50
51 /*
52 * Note that this is actually 0x1,0000,0000
53 */
54 #define KERNEL_DS 0x00000000
55 #define get_ds() (KERNEL_DS)
56
57 #ifdef CONFIG_MMU
58
59 #define USER_DS TASK_SIZE
60 #define get_fs() (current_thread_info()->addr_limit)
61
62 static inline void set_fs(mm_segment_t fs)
63 {
64 current_thread_info()->addr_limit = fs;
65 modify_domain(DOMAIN_KERNEL, fs ? DOMAIN_CLIENT : DOMAIN_MANAGER);
66 }
67
68 #define segment_eq(a,b) ((a) == (b))
69
70 #define __addr_ok(addr) ({ \
71 unsigned long flag; \
72 __asm__("cmp %2, %0; movlo %0, #0" \
73 : "=&r" (flag) \
74 : "0" (current_thread_info()->addr_limit), "r" (addr) \
75 : "cc"); \
76 (flag == 0); })
77
78 /* We use 33-bit arithmetic here... */
79 #define __range_ok(addr,size) ({ \
80 unsigned long flag, roksum; \
81 __chk_user_ptr(addr); \
82 __asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" \
83 : "=&r" (flag), "=&r" (roksum) \
84 : "r" (addr), "Ir" (size), "0" (current_thread_info()->addr_limit) \
85 : "cc"); \
86 flag; })
87
88 /*
89 * Single-value transfer routines. They automatically use the right
90 * size if we just have the right pointer type. Note that the functions
91 * which read from user space (*get_*) need to take care not to leak
92 * kernel data even if the calling code is buggy and fails to check
93 * the return value. This means zeroing out the destination variable
94 * or buffer on error. Normally this is done out of line by the
95 * fixup code, but there are a few places where it intrudes on the
96 * main code path. When we only write to user space, there is no
97 * problem.
98 */
99 extern int __get_user_1(void *);
100 extern int __get_user_2(void *);
101 extern int __get_user_4(void *);
102
103 #define __get_user_x(__r2,__p,__e,__s,__i...) \
104 __asm__ __volatile__ ( \
105 __asmeq("%0", "r0") __asmeq("%1", "r2") \
106 "bl __get_user_" #__s \
107 : "=&r" (__e), "=r" (__r2) \
108 : "0" (__p) \
109 : __i, "cc")
110
111 #define get_user(x,p) \
112 ({ \
113 register const typeof(*(p)) __user *__p asm("r0") = (p);\
114 register unsigned long __r2 asm("r2"); \
115 register int __e asm("r0"); \
116 switch (sizeof(*(__p))) { \
117 case 1: \
118 __get_user_x(__r2, __p, __e, 1, "lr"); \
119 break; \
120 case 2: \
121 __get_user_x(__r2, __p, __e, 2, "r3", "lr"); \
122 break; \
123 case 4: \
124 __get_user_x(__r2, __p, __e, 4, "lr"); \
125 break; \
126 default: __e = __get_user_bad(); break; \
127 } \
128 x = (typeof(*(p))) __r2; \
129 __e; \
130 })
131
132 extern int __put_user_1(void *, unsigned int);
133 extern int __put_user_2(void *, unsigned int);
134 extern int __put_user_4(void *, unsigned int);
135 extern int __put_user_8(void *, unsigned long long);
136
137 #define __put_user_x(__r2,__p,__e,__s) \
138 __asm__ __volatile__ ( \
139 __asmeq("%0", "r0") __asmeq("%2", "r2") \
140 "bl __put_user_" #__s \
141 : "=&r" (__e) \
142 : "0" (__p), "r" (__r2) \
143 : "ip", "lr", "cc")
144
145 #define put_user(x,p) \
146 ({ \
147 register const typeof(*(p)) __r2 asm("r2") = (x); \
148 register const typeof(*(p)) __user *__p asm("r0") = (p);\
149 register int __e asm("r0"); \
150 switch (sizeof(*(__p))) { \
151 case 1: \
152 __put_user_x(__r2, __p, __e, 1); \
153 break; \
154 case 2: \
155 __put_user_x(__r2, __p, __e, 2); \
156 break; \
157 case 4: \
158 __put_user_x(__r2, __p, __e, 4); \
159 break; \
160 case 8: \
161 __put_user_x(__r2, __p, __e, 8); \
162 break; \
163 default: __e = __put_user_bad(); break; \
164 } \
165 __e; \
166 })
167
168 #else /* CONFIG_MMU */
169
170 /*
171 * uClinux has only one addr space, so has simplified address limits.
172 */
173 #define USER_DS KERNEL_DS
174
175 #define segment_eq(a,b) (1)
176 #define __addr_ok(addr) (1)
177 #define __range_ok(addr,size) (0)
178 #define get_fs() (KERNEL_DS)
179
180 static inline void set_fs(mm_segment_t fs)
181 {
182 }
183
184 #define get_user(x,p) __get_user(x,p)
185 #define put_user(x,p) __put_user(x,p)
186
187 #endif /* CONFIG_MMU */
188
189 #define access_ok(type,addr,size) (__range_ok(addr,size) == 0)
190
191 /*
192 * The "__xxx" versions of the user access functions do not verify the
193 * address space - it must have been done previously with a separate
194 * "access_ok()" call.
195 *
196 * The "xxx_error" versions set the third argument to EFAULT if an
197 * error occurs, and leave it unchanged on success. Note that these
198 * versions are void (ie, don't return a value as such).
199 */
200 #define __get_user(x,ptr) \
201 ({ \
202 long __gu_err = 0; \
203 __get_user_err((x),(ptr),__gu_err); \
204 __gu_err; \
205 })
206
207 #define __get_user_error(x,ptr,err) \
208 ({ \
209 __get_user_err((x),(ptr),err); \
210 (void) 0; \
211 })
212
213 #define __get_user_err(x,ptr,err) \
214 do { \
215 unsigned long __gu_addr = (unsigned long)(ptr); \
216 unsigned long __gu_val; \
217 __chk_user_ptr(ptr); \
218 switch (sizeof(*(ptr))) { \
219 case 1: __get_user_asm_byte(__gu_val,__gu_addr,err); break; \
220 case 2: __get_user_asm_half(__gu_val,__gu_addr,err); break; \
221 case 4: __get_user_asm_word(__gu_val,__gu_addr,err); break; \
222 default: (__gu_val) = __get_user_bad(); \
223 } \
224 (x) = (__typeof__(*(ptr)))__gu_val; \
225 } while (0)
226
227 #define __get_user_asm_byte(x,addr,err) \
228 __asm__ __volatile__( \
229 "1: ldrbt %1,[%2]\n" \
230 "2:\n" \
231 " .section .fixup,\"ax\"\n" \
232 " .align 2\n" \
233 "3: mov %0, %3\n" \
234 " mov %1, #0\n" \
235 " b 2b\n" \
236 " .previous\n" \
237 " .section __ex_table,\"a\"\n" \
238 " .align 3\n" \
239 " .long 1b, 3b\n" \
240 " .previous" \
241 : "+r" (err), "=&r" (x) \
242 : "r" (addr), "i" (-EFAULT) \
243 : "cc")
244
245 #ifndef __ARMEB__
246 #define __get_user_asm_half(x,__gu_addr,err) \
247 ({ \
248 unsigned long __b1, __b2; \
249 __get_user_asm_byte(__b1, __gu_addr, err); \
250 __get_user_asm_byte(__b2, __gu_addr + 1, err); \
251 (x) = __b1 | (__b2 << 8); \
252 })
253 #else
254 #define __get_user_asm_half(x,__gu_addr,err) \
255 ({ \
256 unsigned long __b1, __b2; \
257 __get_user_asm_byte(__b1, __gu_addr, err); \
258 __get_user_asm_byte(__b2, __gu_addr + 1, err); \
259 (x) = (__b1 << 8) | __b2; \
260 })
261 #endif
262
263 #define __get_user_asm_word(x,addr,err) \
264 __asm__ __volatile__( \
265 "1: ldrt %1,[%2]\n" \
266 "2:\n" \
267 " .section .fixup,\"ax\"\n" \
268 " .align 2\n" \
269 "3: mov %0, %3\n" \
270 " mov %1, #0\n" \
271 " b 2b\n" \
272 " .previous\n" \
273 " .section __ex_table,\"a\"\n" \
274 " .align 3\n" \
275 " .long 1b, 3b\n" \
276 " .previous" \
277 : "+r" (err), "=&r" (x) \
278 : "r" (addr), "i" (-EFAULT) \
279 : "cc")
280
281 #define __put_user(x,ptr) \
282 ({ \
283 long __pu_err = 0; \
284 __put_user_err((x),(ptr),__pu_err); \
285 __pu_err; \
286 })
287
288 #define __put_user_error(x,ptr,err) \
289 ({ \
290 __put_user_err((x),(ptr),err); \
291 (void) 0; \
292 })
293
294 #define __put_user_err(x,ptr,err) \
295 do { \
296 unsigned long __pu_addr = (unsigned long)(ptr); \
297 __typeof__(*(ptr)) __pu_val = (x); \
298 __chk_user_ptr(ptr); \
299 switch (sizeof(*(ptr))) { \
300 case 1: __put_user_asm_byte(__pu_val,__pu_addr,err); break; \
301 case 2: __put_user_asm_half(__pu_val,__pu_addr,err); break; \
302 case 4: __put_user_asm_word(__pu_val,__pu_addr,err); break; \
303 case 8: __put_user_asm_dword(__pu_val,__pu_addr,err); break; \
304 default: __put_user_bad(); \
305 } \
306 } while (0)
307
308 #define __put_user_asm_byte(x,__pu_addr,err) \
309 __asm__ __volatile__( \
310 "1: strbt %1,[%2]\n" \
311 "2:\n" \
312 " .section .fixup,\"ax\"\n" \
313 " .align 2\n" \
314 "3: mov %0, %3\n" \
315 " b 2b\n" \
316 " .previous\n" \
317 " .section __ex_table,\"a\"\n" \
318 " .align 3\n" \
319 " .long 1b, 3b\n" \
320 " .previous" \
321 : "+r" (err) \
322 : "r" (x), "r" (__pu_addr), "i" (-EFAULT) \
323 : "cc")
324
325 #ifndef __ARMEB__
326 #define __put_user_asm_half(x,__pu_addr,err) \
327 ({ \
328 unsigned long __temp = (unsigned long)(x); \
329 __put_user_asm_byte(__temp, __pu_addr, err); \
330 __put_user_asm_byte(__temp >> 8, __pu_addr + 1, err); \
331 })
332 #else
333 #define __put_user_asm_half(x,__pu_addr,err) \
334 ({ \
335 unsigned long __temp = (unsigned long)(x); \
336 __put_user_asm_byte(__temp >> 8, __pu_addr, err); \
337 __put_user_asm_byte(__temp, __pu_addr + 1, err); \
338 })
339 #endif
340
341 #define __put_user_asm_word(x,__pu_addr,err) \
342 __asm__ __volatile__( \
343 "1: strt %1,[%2]\n" \
344 "2:\n" \
345 " .section .fixup,\"ax\"\n" \
346 " .align 2\n" \
347 "3: mov %0, %3\n" \
348 " b 2b\n" \
349 " .previous\n" \
350 " .section __ex_table,\"a\"\n" \
351 " .align 3\n" \
352 " .long 1b, 3b\n" \
353 " .previous" \
354 : "+r" (err) \
355 : "r" (x), "r" (__pu_addr), "i" (-EFAULT) \
356 : "cc")
357
358 #ifndef __ARMEB__
359 #define __reg_oper0 "%R2"
360 #define __reg_oper1 "%Q2"
361 #else
362 #define __reg_oper0 "%Q2"
363 #define __reg_oper1 "%R2"
364 #endif
365
366 #define __put_user_asm_dword(x,__pu_addr,err) \
367 __asm__ __volatile__( \
368 "1: strt " __reg_oper1 ", [%1], #4\n" \
369 "2: strt " __reg_oper0 ", [%1]\n" \
370 "3:\n" \
371 " .section .fixup,\"ax\"\n" \
372 " .align 2\n" \
373 "4: mov %0, %3\n" \
374 " b 3b\n" \
375 " .previous\n" \
376 " .section __ex_table,\"a\"\n" \
377 " .align 3\n" \
378 " .long 1b, 4b\n" \
379 " .long 2b, 4b\n" \
380 " .previous" \
381 : "+r" (err), "+r" (__pu_addr) \
382 : "r" (x), "i" (-EFAULT) \
383 : "cc")
384
385
386 #ifdef CONFIG_MMU
387 extern unsigned long __must_check __copy_from_user(void *to, const void __user *from, unsigned long n);
388 extern unsigned long __must_check __copy_to_user(void __user *to, const void *from, unsigned long n);
389 extern unsigned long __must_check __clear_user(void __user *addr, unsigned long n);
390 #else
391 #define __copy_from_user(to,from,n) (memcpy(to, (void __force *)from, n), 0)
392 #define __copy_to_user(to,from,n) (memcpy((void __force *)to, from, n), 0)
393 #define __clear_user(addr,n) (memset((void __force *)addr, 0, n), 0)
394 #endif
395
396 extern unsigned long __must_check __strncpy_from_user(char *to, const char __user *from, unsigned long count);
397 extern unsigned long __must_check __strnlen_user(const char __user *s, long n);
398
399 static inline unsigned long __must_check copy_from_user(void *to, const void __user *from, unsigned long n)
400 {
401 if (access_ok(VERIFY_READ, from, n))
402 n = __copy_from_user(to, from, n);
403 else /* security hole - plug it */
404 memset(to, 0, n);
405 return n;
406 }
407
408 static inline unsigned long __must_check copy_to_user(void __user *to, const void *from, unsigned long n)
409 {
410 if (access_ok(VERIFY_WRITE, to, n))
411 n = __copy_to_user(to, from, n);
412 return n;
413 }
414
415 #define __copy_to_user_inatomic __copy_to_user
416 #define __copy_from_user_inatomic __copy_from_user
417
418 static inline unsigned long __must_check clear_user(void __user *to, unsigned long n)
419 {
420 if (access_ok(VERIFY_WRITE, to, n))
421 n = __clear_user(to, n);
422 return n;
423 }
424
425 static inline long __must_check strncpy_from_user(char *dst, const char __user *src, long count)
426 {
427 long res = -EFAULT;
428 if (access_ok(VERIFY_READ, src, 1))
429 res = __strncpy_from_user(dst, src, count);
430 return res;
431 }
432
433 #define strlen_user(s) strnlen_user(s, ~0UL >> 1)
434
435 static inline long __must_check strnlen_user(const char __user *s, long n)
436 {
437 unsigned long res = 0;
438
439 if (__addr_ok(s))
440 res = __strnlen_user(s, n);
441
442 return res;
443 }
444
445 #endif /* _ASMARM_UACCESS_H */
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK