Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
uaccess.h
Go to the documentation of this file.
1 #ifndef _ASM_M32R_UACCESS_H
2 #define _ASM_M32R_UACCESS_H
3 
4 /*
5  * linux/include/asm-m32r/uaccess.h
6  *
7  * M32R version.
8  * Copyright (C) 2004, 2006 Hirokazu Takata <takata at linux-m32r.org>
9  */
10 
11 /*
12  * User space memory access functions
13  */
14 #include <linux/errno.h>
15 #include <linux/thread_info.h>
16 #include <asm/page.h>
17 #include <asm/setup.h>
18 
19 #define VERIFY_READ 0
20 #define VERIFY_WRITE 1
21 
22 /*
23  * The fs value determines whether argument validity checking should be
24  * performed or not. If get_fs() == USER_DS, checking is performed, with
25  * get_fs() == KERNEL_DS, checking is bypassed.
26  *
27  * For historical reasons, these macros are grossly misnamed.
28  */
29 
30 #define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
31 
32 #ifdef CONFIG_MMU
33 
34 #define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
35 #define USER_DS MAKE_MM_SEG(PAGE_OFFSET)
36 #define get_ds() (KERNEL_DS)
37 #define get_fs() (current_thread_info()->addr_limit)
38 #define set_fs(x) (current_thread_info()->addr_limit = (x))
39 
40 #else /* not CONFIG_MMU */
41 
42 #define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
43 #define USER_DS MAKE_MM_SEG(0xFFFFFFFF)
44 #define get_ds() (KERNEL_DS)
45 
46 static inline mm_segment_t get_fs(void)
47 {
48  return USER_DS;
49 }
50 
51 static inline void set_fs(mm_segment_t s)
52 {
53 }
54 
55 #endif /* not CONFIG_MMU */
56 
57 #define segment_eq(a,b) ((a).seg == (b).seg)
58 
59 #define __addr_ok(addr) \
60  ((unsigned long)(addr) < (current_thread_info()->addr_limit.seg))
61 
62 /*
63  * Test whether a block of memory is a valid user space address.
64  * Returns 0 if the range is valid, nonzero otherwise.
65  *
66  * This is equivalent to the following test:
67  * (u33)addr + (u33)size >= (u33)current->addr_limit.seg
68  *
69  * This needs 33-bit arithmetic. We have a carry...
70  */
71 #define __range_ok(addr,size) ({ \
72  unsigned long flag, roksum; \
73  __chk_user_ptr(addr); \
74  asm ( \
75  " cmpu %1, %1 ; clear cbit\n" \
76  " addx %1, %3 ; set cbit if overflow\n" \
77  " subx %0, %0\n" \
78  " cmpu %4, %1\n" \
79  " subx %0, %5\n" \
80  : "=&r" (flag), "=r" (roksum) \
81  : "1" (addr), "r" ((int)(size)), \
82  "r" (current_thread_info()->addr_limit.seg), "r" (0) \
83  : "cbit" ); \
84  flag; })
85 
105 #ifdef CONFIG_MMU
106 #define access_ok(type,addr,size) (likely(__range_ok(addr,size) == 0))
107 #else
108 static inline int access_ok(int type, const void *addr, unsigned long size)
109 {
110  unsigned long val = (unsigned long)addr;
111 
112  return ((val >= memory_start) && ((val + size) < memory_end));
113 }
114 #endif /* CONFIG_MMU */
115 
116 /*
117  * The exception table consists of pairs of addresses: the first is the
118  * address of an instruction that is allowed to fault, and the second is
119  * the address at which the program should continue. No registers are
120  * modified, so it is entirely up to the continuation code to figure out
121  * what to do.
122  *
123  * All the routines below use bits of fixup code that are out of line
124  * with the main instruction path. This means when everything is well,
125  * we don't even have to jump over them. Further, they do not intrude
126  * on our cache or tlb entries.
127  */
128 
129 struct exception_table_entry
130 {
131  unsigned long insn, fixup;
132 };
133 
134 extern int fixup_exception(struct pt_regs *regs);
135 
136 /*
137  * These are the main single-value transfer routines. They automatically
138  * use the right size if we just have the right pointer type.
139  *
140  * This gets kind of ugly. We want to return _two_ values in "get_user()"
141  * and yet we don't want to do any pointers, because that is too much
142  * of a performance impact. Thus we have a few rather ugly macros here,
143  * and hide all the uglyness from the user.
144  *
145  * The "__xxx" versions of the user access functions are versions that
146  * do not verify the address space, that must have been done previously
147  * with a separate "access_ok()" call (this is used when we do multiple
148  * accesses to the same area of user memory).
149  */
150 
151 /* Careful: we have to cast the result to the type of the pointer for sign
152  reasons */
170 #define get_user(x,ptr) \
171  __get_user_check((x),(ptr),sizeof(*(ptr)))
172 
189 #define put_user(x,ptr) \
190  __put_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
191 
212 #define __get_user(x,ptr) \
213  __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
214 
215 #define __get_user_nocheck(x,ptr,size) \
216 ({ \
217  long __gu_err = 0; \
218  unsigned long __gu_val; \
219  might_sleep(); \
220  __get_user_size(__gu_val,(ptr),(size),__gu_err); \
221  (x) = (__typeof__(*(ptr)))__gu_val; \
222  __gu_err; \
223 })
224 
225 #define __get_user_check(x,ptr,size) \
226 ({ \
227  long __gu_err = -EFAULT; \
228  unsigned long __gu_val = 0; \
229  const __typeof__(*(ptr)) __user *__gu_addr = (ptr); \
230  might_sleep(); \
231  if (access_ok(VERIFY_READ,__gu_addr,size)) \
232  __get_user_size(__gu_val,__gu_addr,(size),__gu_err); \
233  (x) = (__typeof__(*(ptr)))__gu_val; \
234  __gu_err; \
235 })
236 
237 extern long __get_user_bad(void);
238 
239 #define __get_user_size(x,ptr,size,retval) \
240 do { \
241  retval = 0; \
242  __chk_user_ptr(ptr); \
243  switch (size) { \
244  case 1: __get_user_asm(x,ptr,retval,"ub"); break; \
245  case 2: __get_user_asm(x,ptr,retval,"uh"); break; \
246  case 4: __get_user_asm(x,ptr,retval,""); break; \
247  default: (x) = __get_user_bad(); \
248  } \
249 } while (0)
250 
251 #define __get_user_asm(x, addr, err, itype) \
252  __asm__ __volatile__( \
253  " .fillinsn\n" \
254  "1: ld"itype" %1,@%2\n" \
255  " .fillinsn\n" \
256  "2:\n" \
257  ".section .fixup,\"ax\"\n" \
258  " .balign 4\n" \
259  "3: ldi %0,%3\n" \
260  " seth r14,#high(2b)\n" \
261  " or3 r14,r14,#low(2b)\n" \
262  " jmp r14\n" \
263  ".previous\n" \
264  ".section __ex_table,\"a\"\n" \
265  " .balign 4\n" \
266  " .long 1b,3b\n" \
267  ".previous" \
268  : "=&r" (err), "=&r" (x) \
269  : "r" (addr), "i" (-EFAULT), "0" (err) \
270  : "r14", "memory")
271 
291 #define __put_user(x,ptr) \
292  __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
293 
294 
295 #define __put_user_nocheck(x,ptr,size) \
296 ({ \
297  long __pu_err; \
298  might_sleep(); \
299  __put_user_size((x),(ptr),(size),__pu_err); \
300  __pu_err; \
301 })
302 
303 
304 #define __put_user_check(x,ptr,size) \
305 ({ \
306  long __pu_err = -EFAULT; \
307  __typeof__(*(ptr)) __user *__pu_addr = (ptr); \
308  might_sleep(); \
309  if (access_ok(VERIFY_WRITE,__pu_addr,size)) \
310  __put_user_size((x),__pu_addr,(size),__pu_err); \
311  __pu_err; \
312 })
313 
314 #if defined(__LITTLE_ENDIAN__)
315 #define __put_user_u64(x, addr, err) \
316  __asm__ __volatile__( \
317  " .fillinsn\n" \
318  "1: st %L1,@%2\n" \
319  " .fillinsn\n" \
320  "2: st %H1,@(4,%2)\n" \
321  " .fillinsn\n" \
322  "3:\n" \
323  ".section .fixup,\"ax\"\n" \
324  " .balign 4\n" \
325  "4: ldi %0,%3\n" \
326  " seth r14,#high(3b)\n" \
327  " or3 r14,r14,#low(3b)\n" \
328  " jmp r14\n" \
329  ".previous\n" \
330  ".section __ex_table,\"a\"\n" \
331  " .balign 4\n" \
332  " .long 1b,4b\n" \
333  " .long 2b,4b\n" \
334  ".previous" \
335  : "=&r" (err) \
336  : "r" (x), "r" (addr), "i" (-EFAULT), "0" (err) \
337  : "r14", "memory")
338 
339 #elif defined(__BIG_ENDIAN__)
340 #define __put_user_u64(x, addr, err) \
341  __asm__ __volatile__( \
342  " .fillinsn\n" \
343  "1: st %H1,@%2\n" \
344  " .fillinsn\n" \
345  "2: st %L1,@(4,%2)\n" \
346  " .fillinsn\n" \
347  "3:\n" \
348  ".section .fixup,\"ax\"\n" \
349  " .balign 4\n" \
350  "4: ldi %0,%3\n" \
351  " seth r14,#high(3b)\n" \
352  " or3 r14,r14,#low(3b)\n" \
353  " jmp r14\n" \
354  ".previous\n" \
355  ".section __ex_table,\"a\"\n" \
356  " .balign 4\n" \
357  " .long 1b,4b\n" \
358  " .long 2b,4b\n" \
359  ".previous" \
360  : "=&r" (err) \
361  : "r" (x), "r" (addr), "i" (-EFAULT), "0" (err) \
362  : "r14", "memory")
363 #else
364 #error no endian defined
365 #endif
366 
367 extern void __put_user_bad(void);
368 
369 #define __put_user_size(x,ptr,size,retval) \
370 do { \
371  retval = 0; \
372  __chk_user_ptr(ptr); \
373  switch (size) { \
374  case 1: __put_user_asm(x,ptr,retval,"b"); break; \
375  case 2: __put_user_asm(x,ptr,retval,"h"); break; \
376  case 4: __put_user_asm(x,ptr,retval,""); break; \
377  case 8: __put_user_u64((__typeof__(*ptr))(x),ptr,retval); break;\
378  default: __put_user_bad(); \
379  } \
380 } while (0)
381 
382 struct __large_struct { unsigned long buf[100]; };
383 #define __m(x) (*(struct __large_struct *)(x))
384 
385 /*
386  * Tell gcc we read from memory instead of writing: this is because
387  * we do not write to any memory gcc knows about, so there are no
388  * aliasing issues.
389  */
390 #define __put_user_asm(x, addr, err, itype) \
391  __asm__ __volatile__( \
392  " .fillinsn\n" \
393  "1: st"itype" %1,@%2\n" \
394  " .fillinsn\n" \
395  "2:\n" \
396  ".section .fixup,\"ax\"\n" \
397  " .balign 4\n" \
398  "3: ldi %0,%3\n" \
399  " seth r14,#high(2b)\n" \
400  " or3 r14,r14,#low(2b)\n" \
401  " jmp r14\n" \
402  ".previous\n" \
403  ".section __ex_table,\"a\"\n" \
404  " .balign 4\n" \
405  " .long 1b,3b\n" \
406  ".previous" \
407  : "=&r" (err) \
408  : "r" (x), "r" (addr), "i" (-EFAULT), "0" (err) \
409  : "r14", "memory")
410 
411 /*
412  * Here we special-case 1, 2 and 4-byte copy_*_user invocations. On a fault
413  * we return the initial request size (1, 2 or 4), as copy_*_user should do.
414  * If a store crosses a page boundary and gets a fault, the m32r will not write
415  * anything, so this is accurate.
416  */
417 
418 /*
419  * Copy To/From Userspace
420  */
421 
422 /* Generic arbitrary sized copy. */
423 /* Return the number of bytes NOT copied. */
424 #define __copy_user(to,from,size) \
425 do { \
426  unsigned long __dst, __src, __c; \
427  __asm__ __volatile__ ( \
428  " mv r14, %0\n" \
429  " or r14, %1\n" \
430  " beq %0, %1, 9f\n" \
431  " beqz %2, 9f\n" \
432  " and3 r14, r14, #3\n" \
433  " bnez r14, 2f\n" \
434  " and3 %2, %2, #3\n" \
435  " beqz %3, 2f\n" \
436  " addi %0, #-4 ; word_copy \n" \
437  " .fillinsn\n" \
438  "0: ld r14, @%1+\n" \
439  " addi %3, #-1\n" \
440  " .fillinsn\n" \
441  "1: st r14, @+%0\n" \
442  " bnez %3, 0b\n" \
443  " beqz %2, 9f\n" \
444  " addi %0, #4\n" \
445  " .fillinsn\n" \
446  "2: ldb r14, @%1 ; byte_copy \n" \
447  " .fillinsn\n" \
448  "3: stb r14, @%0\n" \
449  " addi %1, #1\n" \
450  " addi %2, #-1\n" \
451  " addi %0, #1\n" \
452  " bnez %2, 2b\n" \
453  " .fillinsn\n" \
454  "9:\n" \
455  ".section .fixup,\"ax\"\n" \
456  " .balign 4\n" \
457  "5: addi %3, #1\n" \
458  " addi %1, #-4\n" \
459  " .fillinsn\n" \
460  "6: slli %3, #2\n" \
461  " add %2, %3\n" \
462  " addi %0, #4\n" \
463  " .fillinsn\n" \
464  "7: seth r14, #high(9b)\n" \
465  " or3 r14, r14, #low(9b)\n" \
466  " jmp r14\n" \
467  ".previous\n" \
468  ".section __ex_table,\"a\"\n" \
469  " .balign 4\n" \
470  " .long 0b,6b\n" \
471  " .long 1b,5b\n" \
472  " .long 2b,9b\n" \
473  " .long 3b,9b\n" \
474  ".previous\n" \
475  : "=&r" (__dst), "=&r" (__src), "=&r" (size), \
476  "=&r" (__c) \
477  : "0" (to), "1" (from), "2" (size), "3" (size / 4) \
478  : "r14", "memory"); \
479 } while (0)
480 
481 #define __copy_user_zeroing(to,from,size) \
482 do { \
483  unsigned long __dst, __src, __c; \
484  __asm__ __volatile__ ( \
485  " mv r14, %0\n" \
486  " or r14, %1\n" \
487  " beq %0, %1, 9f\n" \
488  " beqz %2, 9f\n" \
489  " and3 r14, r14, #3\n" \
490  " bnez r14, 2f\n" \
491  " and3 %2, %2, #3\n" \
492  " beqz %3, 2f\n" \
493  " addi %0, #-4 ; word_copy \n" \
494  " .fillinsn\n" \
495  "0: ld r14, @%1+\n" \
496  " addi %3, #-1\n" \
497  " .fillinsn\n" \
498  "1: st r14, @+%0\n" \
499  " bnez %3, 0b\n" \
500  " beqz %2, 9f\n" \
501  " addi %0, #4\n" \
502  " .fillinsn\n" \
503  "2: ldb r14, @%1 ; byte_copy \n" \
504  " .fillinsn\n" \
505  "3: stb r14, @%0\n" \
506  " addi %1, #1\n" \
507  " addi %2, #-1\n" \
508  " addi %0, #1\n" \
509  " bnez %2, 2b\n" \
510  " .fillinsn\n" \
511  "9:\n" \
512  ".section .fixup,\"ax\"\n" \
513  " .balign 4\n" \
514  "5: addi %3, #1\n" \
515  " addi %1, #-4\n" \
516  " .fillinsn\n" \
517  "6: slli %3, #2\n" \
518  " add %2, %3\n" \
519  " addi %0, #4\n" \
520  " .fillinsn\n" \
521  "7: ldi r14, #0 ; store zero \n" \
522  " .fillinsn\n" \
523  "8: addi %2, #-1\n" \
524  " stb r14, @%0 ; ACE? \n" \
525  " addi %0, #1\n" \
526  " bnez %2, 8b\n" \
527  " seth r14, #high(9b)\n" \
528  " or3 r14, r14, #low(9b)\n" \
529  " jmp r14\n" \
530  ".previous\n" \
531  ".section __ex_table,\"a\"\n" \
532  " .balign 4\n" \
533  " .long 0b,6b\n" \
534  " .long 1b,5b\n" \
535  " .long 2b,7b\n" \
536  " .long 3b,7b\n" \
537  ".previous\n" \
538  : "=&r" (__dst), "=&r" (__src), "=&r" (size), \
539  "=&r" (__c) \
540  : "0" (to), "1" (from), "2" (size), "3" (size / 4) \
541  : "r14", "memory"); \
542 } while (0)
543 
544 
545 /* We let the __ versions of copy_from/to_user inline, because they're often
546  * used in fast paths and have only a small space overhead.
547  */
548 static inline unsigned long __generic_copy_from_user_nocheck(void *to,
549  const void __user *from, unsigned long n)
550 {
551  __copy_user_zeroing(to,from,n);
552  return n;
553 }
554 
555 static inline unsigned long __generic_copy_to_user_nocheck(void __user *to,
556  const void *from, unsigned long n)
557 {
558  __copy_user(to,from,n);
559  return n;
560 }
561 
562 unsigned long __generic_copy_to_user(void __user *, const void *, unsigned long);
563 unsigned long __generic_copy_from_user(void *, const void __user *, unsigned long);
564 
579 #define __copy_to_user(to,from,n) \
580  __generic_copy_to_user_nocheck((to),(from),(n))
581 
582 #define __copy_to_user_inatomic __copy_to_user
583 #define __copy_from_user_inatomic __copy_from_user
584 
598 #define copy_to_user(to,from,n) \
599 ({ \
600  might_sleep(); \
601  __generic_copy_to_user((to),(from),(n)); \
602 })
603 
620 #define __copy_from_user(to,from,n) \
621  __generic_copy_from_user_nocheck((to),(from),(n))
622 
639 #define copy_from_user(to,from,n) \
640 ({ \
641  might_sleep(); \
642  __generic_copy_from_user((to),(from),(n)); \
643 })
644 
645 long __must_check strncpy_from_user(char *dst, const char __user *src,
646  long count);
647 long __must_check __strncpy_from_user(char *dst,
648  const char __user *src, long count);
649 
661 unsigned long __clear_user(void __user *mem, unsigned long len);
662 
674 unsigned long clear_user(void __user *mem, unsigned long len);
675 
690 #define strlen_user(str) strnlen_user(str, ~0UL >> 1)
691 long strnlen_user(const char __user *str, long n);
692 
693 #endif /* _ASM_M32R_UACCESS_H */
Generated on Thu Jan 10 2013 12:50:45 for Linux Kernel by   doxygen 1.8.2