include/asm-v850/uaccess.h

   1 #ifndef __V850_UACCESS_H__
   2 #define __V850_UACCESS_H__
   3
   4 /*
   5  * User space memory access functions
   6  */
   7
   8 #include <linux/errno.h>
   9 #include <linux/string.h>
  10
  11 #include <asm/segment.h>
  12 #include <asm/machdep.h>
  13
  14 #define VERIFY_READ     0
  15 #define VERIFY_WRITE    1
  16
  17 extern inline int access_ok (int type, const void *addr, unsigned long size)
  18 {
  19         /* XXX I guess we should check against real ram bounds at least, and
  20            possibly make sure ADDR is not within the kernel.
  21            For now we just check to make sure it's not a small positive
  22            or negative value, as that will at least catch some kinds of
  23            error.  In particular, we make sure that ADDR's not within the
  24            interrupt vector area, which we know starts at zero, or within the
  25            peripheral-I/O area, which is located just _before_ zero.  */
  26         unsigned long val = (unsigned long)addr;
  27         return val >= (0x80 + NUM_CPU_IRQS*16) && val < 0xFFFFF000;
  28 }
  29
  30 extern inline int verify_area (int type, const void *addr, unsigned long size)
  31 {
  32         return access_ok (type, addr, size) ? 0 : -EFAULT;
  33 }
  34
  35 /*
  36  * The exception table consists of pairs of addresses: the first is the
  37  * address of an instruction that is allowed to fault, and the second is
  38  * the address at which the program should continue.  No registers are
  39  * modified, so it is entirely up to the continuation code to figure out
  40  * what to do.
  41  *
  42  * All the routines below use bits of fixup code that are out of line
  43  * with the main instruction path.  This means when everything is well,
  44  * we don't even have to jump over them.  Further, they do not intrude
  45  * on our cache or tlb entries.
  46  */
  47
  48 struct exception_table_entry
  49 {
  50         unsigned long insn, fixup;
  51 };
  52
  53 /* Returns 0 if exception not found and fixup otherwise.  */
  54 extern unsigned long search_exception_table (unsigned long);
  55
  56
  57 /*
  58  * These are the main single-value transfer routines.  They automatically
  59  * use the right size if we just have the right pointer type.
  60  */
  61
  62 extern int bad_user_access_length (void);
  63
  64 #define __get_user(var, ptr)                                                  \
  65   ({                                                                          \
  66           int __gu_err = 0;                                                   \
  67           typeof(*(ptr)) __gu_val = 0;                                        \
  68           switch (sizeof (*(ptr))) {                                          \
  69           case 1:                                                             \
  70           case 2:                                                             \
  71           case 4:                                                             \
  72                   __gu_val = *(ptr);                                          \
  73                   break;                                                      \
  74           case 8:                                                             \
  75                   memcpy(&__gu_val, ptr, sizeof(__gu_val));                   \
  76                   break;                                                      \
  77           default:                                                            \
  78                   __gu_val = 0;                                               \
  79                   __gu_err = __get_user_bad ();                               \
  80                   break;                                                      \
  81           }                                                                   \
  82           (var) = __gu_val;                                                   \
  83           __gu_err;                                                           \
  84   })
  85 #define __get_user_bad()        (bad_user_access_length (), (-EFAULT))
  86
  87 #define __put_user(var, ptr)                                                  \
  88   ({                                                                          \
  89           int __pu_err = 0;                                                   \
  90           switch (sizeof (*(ptr))) {                                          \
  91           case 1:                                                             \
  92           case 2:                                                             \
  93           case 4:                                                             \
  94                   *(ptr) = (var);                                             \
  95                   break;                                                      \
  96           case 8: {                                                           \
  97                   typeof(*(ptr)) __pu_val = 0;                                \
  98                   memcpy(ptr, &__pu_val, sizeof(__pu_val));                   \
  99                   }                                                           \
 100                   break;                                                      \
 101           default:                                                            \
 102                   __pu_err = __put_user_bad ();                               \
 103                   break;                                                      \
 104           }                                                                   \
 105           __pu_err;                                                           \
 106   })
 107 #define __put_user_bad()        (bad_user_access_length (), (-EFAULT))
 108
 109 #define put_user(x, ptr)        __put_user(x, ptr)
 110 #define get_user(x, ptr)        __get_user(x, ptr)
 111
 112 #define __copy_from_user(to, from, n)   (memcpy (to, from, n), 0)
 113 #define __copy_to_user(to, from, n)     (memcpy(to, from, n), 0)
 114
 115 #define copy_from_user(to, from, n)     __copy_from_user (to, from, n)
 116 #define copy_to_user(to, from, n)       __copy_to_user(to, from, n)
 117
 118 #define copy_to_user_ret(to,from,n,retval) \
 119   ({ if (copy_to_user (to,from,n)) return retval; })
 120
 121 #define copy_from_user_ret(to,from,n,retval) \
 122   ({ if (copy_from_user (to,from,n)) return retval; })
 123
 124 /*
 125  * Copy a null terminated string from userspace.
 126  */
 127
 128 static inline long
 129 strncpy_from_user (char *dst, const char *src, long count)
 130 {
 131         char *tmp;
 132         strncpy (dst, src, count);
 133         for (tmp = dst; *tmp && count > 0; tmp++, count--)
 134                 ;
 135         return tmp - dst;
 136 }
 137
 138 /*
 139  * Return the size of a string (including the ending 0)
 140  *
 141  * Return 0 on exception, a value greater than N if too long
 142  */
 143 static inline long strnlen_user (const char *src, long n)
 144 {
 145         return strlen (src) + 1;
 146 }
 147
 148 #define strlen_user(str)        strnlen_user (str, 32767)
 149
 150 /*
 151  * Zero Userspace
 152  */
 153
 154 static inline unsigned long
 155 clear_user (void *to, unsigned long n)
 156 {
 157         memset (to, 0, n);
 158         return 0;
 159 }
 160
 161 #endif /* __V850_UACCESS_H__ */