IB/mad: Report number of times a mad was retried

[linux-2.6] / include / asm-sh / uaccess.h

diff --git a/include/asm-sh/uaccess.h b/include/asm-sh/uaccess.h
index 6c0014dd2ef7cd5bbee74562019f626f8eea9936..77c391fa93d6380b1f25996a692dc77ca5af66dc 100644 (file)
--- a/include/asm-sh/uaccess.h
+++ b/include/asm-sh/uaccess.h
@@ -34,12 +34,12 @@
 
 #define segment_eq(a,b)        ((a).seg == (b).seg)
 
-#define __addr_ok(addr) \
-       ((unsigned long)(addr) < (current_thread_info()->addr_limit.seg))
-
 #define get_ds()       (KERNEL_DS)
 
 #if !defined(CONFIG_MMU)
+/* NOMMU is always true */
+#define __addr_ok(addr) (1)
+
 static inline mm_segment_t get_fs(void)
 {
        return USER_DS;
@@ -61,49 +61,38 @@ static inline void set_fs(mm_segment_t s)
  */
 static inline int __access_ok(unsigned long addr, unsigned long size)
 {
-       extern unsigned long memory_start, memory_end;
-
        return ((addr >= memory_start) && ((addr + size) < memory_end));
 }
 #else /* CONFIG_MMU */
+#define __addr_ok(addr) \
+       ((unsigned long)(addr) < (current_thread_info()->addr_limit.seg))
+
 #define get_fs()       (current_thread_info()->addr_limit)
 #define set_fs(x)      (current_thread_info()->addr_limit = (x))
 
 /*
  * __access_ok: Check if address with size is OK or not.
  *
- * We do three checks:
- * (1) is it user space? 
- * (2) addr + size --> carry?
- * (3) addr + size >= 0x80000000  (PAGE_OFFSET)
+ * Uhhuh, this needs 33-bit arithmetic. We have a carry..
  *
- * (1) (2) (3) | RESULT
- *  0   0   0  |  ok
- *  0   0   1  |  ok
- *  0   1   0  |  bad
- *  0   1   1  |  bad
- *  1   0   0  |  ok
- *  1   0   1  |  bad
- *  1   1   0  |  bad
- *  1   1   1  |  bad
+ * sum := addr + size;  carry? --> flag = true;
+ * if (sum >= addr_limit) flag = true;
  */
 static inline int __access_ok(unsigned long addr, unsigned long size)
 {
-       unsigned long flag, tmp;
-
-       __asm__("stc    r7_bank, %0\n\t"
-               "mov.l  @(8,%0), %0\n\t"
-               "clrt\n\t"
-               "addc   %2, %1\n\t"
-               "and    %1, %0\n\t"
-               "rotcl  %0\n\t"
-               "rotcl  %0\n\t"
-               "and    #3, %0"
-               : "=&z" (flag), "=r" (tmp)
-               : "r" (addr), "1" (size)
-               : "t");
-
+       unsigned long flag, sum;
+
+       __asm__("clrt\n\t"
+               "addc   %3, %1\n\t"
+               "movt   %0\n\t"
+               "cmp/hi %4, %1\n\t"
+               "rotcl  %0"
+               :"=&r" (flag), "=r" (sum)
+               :"1" (addr), "r" (size),
+                "r" (current_thread_info()->addr_limit.seg)
+               :"t");
        return flag == 0;
+
 }
 #endif /* CONFIG_MMU */
 
@@ -139,11 +128,12 @@ static inline int access_ok(int type, const void __user *p, unsigned long size)
   __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
 
 struct __large_struct { unsigned long buf[100]; };
-#define __m(x) (*(struct __large_struct *)(x))
+#define __m(x) (*(struct __large_struct __user *)(x))
 
 #define __get_user_size(x,ptr,size,retval)                     \
 do {                                                           \
        retval = 0;                                             \
+       __chk_user_ptr(ptr);                                    \
        switch (size) {                                         \
        case 1:                                                 \
                __get_user_asm(x, ptr, retval, "b");            \
@@ -168,9 +158,11 @@ do {                                                               \
        __gu_err;                                               \
 })
 
+#ifdef CONFIG_MMU
 #define __get_user_check(x,ptr,size)                           \
 ({                                                             \
        long __gu_err, __gu_val;                                \
+       __chk_user_ptr(ptr);                                    \
        switch (size) {                                         \
        case 1:                                                 \
                __get_user_1(__gu_val, (ptr), __gu_err);        \
@@ -257,6 +249,18 @@ __asm__("stc       r7_bank, %1\n\t"                \
        : "r" (addr)                            \
        : "t");                                 \
 })
+#else /* CONFIG_MMU */
+#define __get_user_check(x,ptr,size)                                   \
+({                                                                     \
+       long __gu_err, __gu_val;                                        \
+       if (__access_ok((unsigned long)(ptr), (size))) {                \
+               __get_user_size(__gu_val, (ptr), (size), __gu_err);     \
+               (x) = (__typeof__(*(ptr)))__gu_val;                     \
+       } else                                                          \
+               __gu_err = -EFAULT;                                     \
+       __gu_err;                                                       \
+})
+#endif
 
 #define __get_user_asm(x, addr, err, insn) \
 ({ \
@@ -284,6 +288,7 @@ extern void __get_user_unknown(void);
 #define __put_user_size(x,ptr,size,retval)             \
 do {                                                   \
        retval = 0;                                     \
+       __chk_user_ptr(ptr);                            \
        switch (size) {                                 \
        case 1:                                         \
                __put_user_asm(x, ptr, retval, "b");    \
@@ -312,7 +317,7 @@ do {                                                        \
 #define __put_user_check(x,ptr,size)                           \
 ({                                                             \
        long __pu_err = -EFAULT;                                \
-       __typeof__(*(ptr)) *__pu_addr = (ptr);                  \
+       __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
                                                                \
        if (__access_ok((unsigned long)__pu_addr,size))         \
                __put_user_size((x),__pu_addr,(size),__pu_err); \
@@ -390,10 +395,10 @@ __asm__ __volatile__( \
 #endif
 
 extern void __put_user_unknown(void);
-\f
+
 /* Generic arbitrary sized copy.  */
 /* Return the number of bytes NOT copied */
-extern __kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);
+__kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);
 
 #define copy_to_user(to,from,n) ({ \
 void *__copy_to = (void *) (to); \
@@ -404,14 +409,6 @@ __copy_res = __copy_user(__copy_to, (void *) (from), __copy_size); \
 } else __copy_res = __copy_size; \
 __copy_res; })
 
-#define __copy_to_user(to,from,n)              \
-       __copy_user((void *)(to),               \
-                   (void *)(from), n)
-
-#define __copy_to_user_inatomic __copy_to_user
-#define __copy_from_user_inatomic __copy_from_user
-
-
 #define copy_from_user(to,from,n) ({ \
 void *__copy_to = (void *) (to); \
 void *__copy_from = (void *) (from); \
@@ -422,9 +419,20 @@ __copy_res = __copy_user(__copy_to, __copy_from, __copy_size); \
 } else __copy_res = __copy_size; \
 __copy_res; })
 
-#define __copy_from_user(to,from,n)            \
-       __copy_user((void *)(to),               \
-                   (void *)(from), n)
+static __always_inline unsigned long
+__copy_from_user(void *to, const void __user *from, unsigned long n)
+{
+       return __copy_user(to, (__force void *)from, n);
+}
+
+static __always_inline unsigned long __must_check
+__copy_to_user(void __user *to, const void *from, unsigned long n)
+{
+       return __copy_user((__force void *)to, from, n);
+}
+
+#define __copy_to_user_inatomic __copy_to_user
+#define __copy_from_user_inatomic __copy_from_user
 
 /*
  * Clear the area and return remaining number of bytes