home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-h8300 / uaccess.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  4.2 KB  |  166 lines
  1. #ifndef __H8300_UACCESS_H
  2. #define __H8300_UACCESS_H
  3.  
  4. /*
  5.  * User space memory access functions
  6.  */
  7. #include <linux/sched.h>
  8. #include <linux/mm.h>
  9. #include <linux/string.h>
  10.  
  11. #include <asm/segment.h>
  12.  
  13. #define VERIFY_READ    0
  14. #define VERIFY_WRITE    1
  15.  
  16. /* We let the MMU do all checking */
  17. #define access_ok(type, addr, size) __access_ok((unsigned long)addr,size)
  18. static inline int __access_ok(unsigned long addr, unsigned long size)
  19. {
  20. #define    RANGE_CHECK_OK(addr, size, lower, upper) \
  21.     (((addr) >= (lower)) && (((addr) + (size)) < (upper)))
  22.  
  23.     extern unsigned long _ramend;
  24.     return(RANGE_CHECK_OK(addr, size, 0L, (unsigned long)&_ramend));
  25. }
  26.  
  27. /*
  28.  * The exception table consists of pairs of addresses: the first is the
  29.  * address of an instruction that is allowed to fault, and the second is
  30.  * the address at which the program should continue.  No registers are
  31.  * modified, so it is entirely up to the continuation code to figure out
  32.  * what to do.
  33.  *
  34.  * All the routines below use bits of fixup code that are out of line
  35.  * with the main instruction path.  This means when everything is well,
  36.  * we don't even have to jump over them.  Further, they do not intrude
  37.  * on our cache or tlb entries.
  38.  */
  39.  
  40. struct exception_table_entry
  41. {
  42.     unsigned long insn, fixup;
  43. };
  44.  
  45. /* Returns 0 if exception not found and fixup otherwise.  */
  46. extern unsigned long search_exception_table(unsigned long);
  47.  
  48.  
  49. /*
  50.  * These are the main single-value transfer routines.  They automatically
  51.  * use the right size if we just have the right pointer type.
  52.  */
  53.  
  54. #define put_user(x, ptr)                \
  55. ({                            \
  56.     int __pu_err = 0;                    \
  57.     typeof(*(ptr)) __pu_val = (x);            \
  58.     switch (sizeof (*(ptr))) {                \
  59.     case 1:                        \
  60.     case 2:                        \
  61.     case 4:                        \
  62.     *(ptr) = (__pu_val);                       \
  63.     break;                        \
  64.     case 8:                        \
  65.     memcpy(ptr, &__pu_val, sizeof (*(ptr)));        \
  66.     break;                        \
  67.     default:                        \
  68.     __pu_err = __put_user_bad();            \
  69.     break;                        \
  70.     }                            \
  71.     __pu_err;                        \
  72. })
  73. #define __put_user(x, ptr) put_user(x, ptr)
  74.  
  75. extern int __put_user_bad(void);
  76.  
  77. /*
  78.  * Tell gcc we read from memory instead of writing: this is because
  79.  * we do not write to any memory gcc knows about, so there are no
  80.  * aliasing issues.
  81.  */
  82.  
  83. #define __ptr(x) ((unsigned long *)(x))
  84.  
  85. /*
  86.  * Tell gcc we read from memory instead of writing: this is because
  87.  * we do not write to any memory gcc knows about, so there are no
  88.  * aliasing issues.
  89.  */
  90.  
  91. #define get_user(x, ptr)                    \
  92. ({                                \
  93.     int __gu_err = 0;                        \
  94.     typeof(*(ptr)) __gu_val = 0;                \
  95.     switch (sizeof(*(ptr))) {                    \
  96.     case 1:                            \
  97.     case 2:                            \
  98.     case 4:                            \
  99.     __gu_val = *(ptr);                            \
  100.     break;                            \
  101.     case 8:                            \
  102.     memcpy(&__gu_val, ptr, sizeof (*(ptr)));         \
  103.     break;                            \
  104.     default:                            \
  105.     __gu_val = 0;                        \
  106.     __gu_err = __get_user_bad();                \
  107.     break;                            \
  108.     }                                \
  109.     (x) = __gu_val;                        \
  110.     __gu_err;                            \
  111. })
  112. #define __get_user(x, ptr) get_user(x, ptr)
  113.  
  114. extern int __get_user_bad(void);
  115.  
  116. #define copy_from_user(to, from, n)        (memcpy(to, from, n), 0)
  117. #define copy_to_user(to, from, n)        (memcpy(to, from, n), 0)
  118.  
  119. #define __copy_from_user(to, from, n) copy_from_user(to, from, n)
  120. #define __copy_to_user(to, from, n) copy_to_user(to, from, n)
  121. #define __copy_to_user_inatomic __copy_to_user
  122. #define __copy_from_user_inatomic __copy_from_user
  123.  
  124. #define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n)) return retval; })
  125.  
  126. #define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n)) return retval; })
  127.  
  128. /*
  129.  * Copy a null terminated string from userspace.
  130.  */
  131.  
  132. static inline long
  133. strncpy_from_user(char *dst, const char *src, long count)
  134. {
  135.     char *tmp;
  136.     strncpy(dst, src, count);
  137.     for (tmp = dst; *tmp && count > 0; tmp++, count--)
  138.         ;
  139.     return(tmp - dst); /* DAVIDM should we count a NUL ?  check getname */
  140. }
  141.  
  142. /*
  143.  * Return the size of a string (including the ending 0)
  144.  *
  145.  * Return 0 on exception, a value greater than N if too long
  146.  */
  147. static inline long strnlen_user(const char *src, long n)
  148. {
  149.     return(strlen(src) + 1); /* DAVIDM make safer */
  150. }
  151.  
  152. #define strlen_user(str) strnlen_user(str, 32767)
  153.  
  154. /*
  155.  * Zero Userspace
  156.  */
  157.  
  158. static inline unsigned long
  159. clear_user(void *to, unsigned long n)
  160. {
  161.     memset(to, 0, n);
  162.     return 0;
  163. }
  164.  
  165. #endif /* _H8300_UACCESS_H */
  166.