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-m68knommu / uaccess.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  4.5 KB  |  177 lines
  1. #ifndef __M68KNOMMU_UACCESS_H
  2. #define __M68KNOMMU_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. #define access_ok(type,addr,size)    _access_ok((unsigned long)(addr),(size))
  17.  
  18. static inline int _access_ok(unsigned long addr, unsigned long size)
  19. {
  20.     extern unsigned long memory_start, memory_end;
  21.  
  22.     return (((addr >= memory_start) && (addr+size < memory_end)) ||
  23.         (is_in_rom(addr) && is_in_rom(addr+size)));
  24. }
  25.  
  26. /*
  27.  * The exception table consists of pairs of addresses: the first is the
  28.  * address of an instruction that is allowed to fault, and the second is
  29.  * the address at which the program should continue.  No registers are
  30.  * modified, so it is entirely up to the continuation code to figure out
  31.  * what to do.
  32.  *
  33.  * All the routines below use bits of fixup code that are out of line
  34.  * with the main instruction path.  This means when everything is well,
  35.  * we don't even have to jump over them.  Further, they do not intrude
  36.  * on our cache or tlb entries.
  37.  */
  38.  
  39. struct exception_table_entry
  40. {
  41.     unsigned long insn, fixup;
  42. };
  43.  
  44. /* Returns 0 if exception not found and fixup otherwise.  */
  45. extern unsigned long search_exception_table(unsigned long);
  46.  
  47.  
  48. /*
  49.  * These are the main single-value transfer routines.  They automatically
  50.  * use the right size if we just have the right pointer type.
  51.  */
  52.  
  53. #define put_user(x, ptr)                \
  54. ({                            \
  55.     int __pu_err = 0;                    \
  56.     typeof(*(ptr)) __pu_val = (x);            \
  57.     switch (sizeof (*(ptr))) {                \
  58.     case 1:                        \
  59.     __put_user_asm(__pu_err, __pu_val, ptr, b);    \
  60.     break;                        \
  61.     case 2:                        \
  62.     __put_user_asm(__pu_err, __pu_val, ptr, w);    \
  63.     break;                        \
  64.     case 4:                        \
  65.     __put_user_asm(__pu_err, __pu_val, ptr, l);    \
  66.     break;                        \
  67.     case 8:                        \
  68.     memcpy(ptr, &__pu_val, sizeof (*(ptr))); \
  69.     break;                        \
  70.     default:                        \
  71.     __pu_err = __put_user_bad();            \
  72.     break;                        \
  73.     }                            \
  74.     __pu_err;                        \
  75. })
  76. #define __put_user(x, ptr) put_user(x, ptr)
  77.  
  78. extern int __put_user_bad(void);
  79.  
  80. /*
  81.  * Tell gcc we read from memory instead of writing: this is because
  82.  * we do not write to any memory gcc knows about, so there are no
  83.  * aliasing issues.
  84.  */
  85.  
  86. #define __ptr(x) ((unsigned long *)(x))
  87.  
  88. #define __put_user_asm(err,x,ptr,bwl)                \
  89.     __asm__ ("move" #bwl " %0,%1"                \
  90.         : /* no outputs */                        \
  91.         :"d" (x),"m" (*__ptr(ptr)) : "memory")
  92.  
  93. #define get_user(x, ptr)                    \
  94. ({                                \
  95.     int __gu_err = 0;                        \
  96.     typeof(*(ptr)) __gu_val = 0;                \
  97.     switch (sizeof(*(ptr))) {                    \
  98.     case 1:                            \
  99.     __get_user_asm(__gu_err, __gu_val, ptr, b, "=d");    \
  100.     break;                            \
  101.     case 2:                            \
  102.     __get_user_asm(__gu_err, __gu_val, ptr, w, "=r");    \
  103.     break;                            \
  104.     case 4:                            \
  105.     __get_user_asm(__gu_err, __gu_val, ptr, l, "=r");    \
  106.     break;                            \
  107.     case 8:                            \
  108.     memcpy(&__gu_val, ptr, sizeof (*(ptr))); \
  109.     break;                            \
  110.     default:                            \
  111.     __gu_val = 0;                        \
  112.     __gu_err = __get_user_bad();                \
  113.     break;                            \
  114.     }                                \
  115.     (x) = __gu_val;                        \
  116.     __gu_err;                            \
  117. })
  118. #define __get_user(x, ptr) get_user(x, ptr)
  119.  
  120. extern int __get_user_bad(void);
  121.  
  122. #define __get_user_asm(err,x,ptr,bwl,reg)    \
  123.     __asm__ ("move" #bwl " %1,%0"            \
  124.          : "=d" (x)                            \
  125.          : "m" (*__ptr(ptr)))
  126.  
  127. #define copy_from_user(to, from, n)        (memcpy(to, from, n), 0)
  128. #define copy_to_user(to, from, n)        (memcpy(to, from, n), 0)
  129.  
  130. #define __copy_from_user(to, from, n) copy_from_user(to, from, n)
  131. #define __copy_to_user(to, from, n) copy_to_user(to, from, n)
  132. #define __copy_to_user_inatomic __copy_to_user
  133. #define __copy_from_user_inatomic __copy_from_user
  134.  
  135. #define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n)) return retval; })
  136.  
  137. #define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n)) return retval; })
  138.  
  139. /*
  140.  * Copy a null terminated string from userspace.
  141.  */
  142.  
  143. static inline long
  144. strncpy_from_user(char *dst, const char *src, long count)
  145. {
  146.     char *tmp;
  147.     strncpy(dst, src, count);
  148.     for (tmp = dst; *tmp && count > 0; tmp++, count--)
  149.         ;
  150.     return(tmp - dst); /* DAVIDM should we count a NUL ?  check getname */
  151. }
  152.  
  153. /*
  154.  * Return the size of a string (including the ending 0)
  155.  *
  156.  * Return 0 on exception, a value greater than N if too long
  157.  */
  158. static inline long strnlen_user(const char *src, long n)
  159. {
  160.     return(strlen(src) + 1); /* DAVIDM make safer */
  161. }
  162.  
  163. #define strlen_user(str) strnlen_user(str, 32767)
  164.  
  165. /*
  166.  * Zero Userspace
  167.  */
  168.  
  169. static inline unsigned long
  170. clear_user(void *to, unsigned long n)
  171. {
  172.     memset(to, 0, n);
  173.     return 0;
  174. }
  175.  
  176. #endif /* _M68KNOMMU_UACCESS_H */
  177.