upgrade to fedora-2.6.12-1.1398.FC4 + vserver 2.0.rc7

[linux-2.6.git] / include / asm-mips / uaccess.h

diff --git a/include/asm-mips/uaccess.h b/include/asm-mips/uaccess.h
index 2f0328a..0711489 100644 (file)
--- a/include/asm-mips/uaccess.h
+++ b/include/asm-mips/uaccess.h
@@ -112,7 +112,8 @@
        likely(__access_ok((unsigned long)(addr), (size),__access_mask))
 
 /*
- * verify_area: - Obsolete, use access_ok()
+ * verify_area: - Obsolete/deprecated and will go away soon,
+ * use access_ok() instead.
  * @type: Type of access: %VERIFY_READ or %VERIFY_WRITE
  * @addr: User space pointer to start of block to check
  * @size: Size of block to check
@@ -128,7 +129,7 @@
  *
  * See access_ok() for more details.
  */
-static inline int verify_area(int type, const void * addr, unsigned long size)
+static inline int __deprecated verify_area(int type, const void * addr, unsigned long size)
 {
        return access_ok(type, addr, size) ? 0 : -EFAULT;
 }
@@ -150,7 +151,7 @@ static inline int verify_area(int type, const void * addr, unsigned long size)
  * Returns zero on success, or -EFAULT on error.
  */
 #define put_user(x,ptr)        \
-       __put_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
+       __put_user_check((x),(ptr),sizeof(*(ptr)))
 
 /*
  * get_user: - Get a simple variable from user space.
@@ -170,7 +171,7 @@ static inline int verify_area(int type, const void * addr, unsigned long size)
  * On error, the variable @x is set to zero.
  */
 #define get_user(x,ptr) \
-       __get_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
+       __get_user_check((x),(ptr),sizeof(*(ptr)))
 
 /*
  * __put_user: - Write a simple value into user space, with less checking.
@@ -192,7 +193,7 @@ static inline int verify_area(int type, const void * addr, unsigned long size)
  * Returns zero on success, or -EFAULT on error.
  */
 #define __put_user(x,ptr) \
-       __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
+       __put_user_nocheck((x),(ptr),sizeof(*(ptr)))
 
 /*
  * __get_user: - Get a simple variable from user space, with less checking.
@@ -215,7 +216,7 @@ static inline int verify_area(int type, const void * addr, unsigned long size)
  * On error, the variable @x is set to zero.
  */
 #define __get_user(x,ptr) \
-       __get_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
+       __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
 
 struct __large_struct { unsigned long buf[100]; };
 #define __m(x) (*(struct __large_struct *)(x))
@@ -232,9 +233,10 @@ struct __large_struct { unsigned long buf[100]; };
 
 #define __get_user_nocheck(x,ptr,size)                                 \
 ({                                                                     \
-       long __gu_err = 0;                                              \
        __typeof(*(ptr)) __gu_val = 0;                                  \
        long __gu_addr;                                                 \
+       long __gu_err = 0;                                              \
+                                                                       \
        might_sleep();                                                  \
        __gu_addr = (long) (ptr);                                       \
        switch (size) {                                                 \
@@ -244,18 +246,20 @@ struct __large_struct { unsigned long buf[100]; };
        case 8: __GET_USER_DW(__gu_err); break;                         \
        default: __get_user_unknown(); break;                           \
        }                                                               \
-        x = (__typeof__(*(ptr))) __gu_val;                             \
+       x = (__typeof__(*(ptr))) __gu_val;                              \
        __gu_err;                                                       \
 })
 
 #define __get_user_check(x,ptr,size)                                   \
 ({                                                                     \
        __typeof__(*(ptr)) __gu_val = 0;                                \
-       long __gu_addr = (long) (ptr);                                  \
+       long __gu_addr;                                                 \
        long __gu_err;                                                  \
                                                                        \
        might_sleep();                                                  \
-       __gu_err = verify_area(VERIFY_READ, (void *) __gu_addr, size);  \
+       __gu_addr = (long) (ptr);                                       \
+       __gu_err = access_ok(VERIFY_READ, (void *) __gu_addr, size)     \
+                               ? 0 : -EFAULT;                          \
                                                                        \
        if (likely(!__gu_err)) {                                        \
                switch (size) {                                         \
@@ -267,7 +271,7 @@ struct __large_struct { unsigned long buf[100]; };
                }                                                       \
        }                                                               \
        x = (__typeof__(*(ptr))) __gu_val;                              \
-        __gu_err;                                                      \
+       __gu_err;                                                       \
 })
 
 #define __get_user_asm(insn,__gu_err)                                  \
@@ -324,9 +328,10 @@ extern void __get_user_unknown(void);
 
 #define __put_user_nocheck(x,ptr,size)                                 \
 ({                                                                     \
-       long __pu_err = 0;                                              \
        __typeof__(*(ptr)) __pu_val;                                    \
        long __pu_addr;                                                 \
+       long __pu_err = 0;                                              \
+                                                                       \
        might_sleep();                                                  \
        __pu_val = (x);                                                 \
        __pu_addr = (long) (ptr);                                       \
@@ -342,12 +347,15 @@ extern void __get_user_unknown(void);
 
 #define __put_user_check(x,ptr,size)                                   \
 ({                                                                     \
-       __typeof__(*(ptr)) __pu_val = (x);                              \
-       long __pu_addr = (long) (ptr);                                  \
+       __typeof__(*(ptr)) __pu_val;                                    \
+       long __pu_addr;                                                 \
        long __pu_err;                                                  \
                                                                        \
        might_sleep();                                                  \
-       __pu_err = verify_area(VERIFY_WRITE, (void *) __pu_addr, size); \
+       __pu_val = (x);                                                 \
+       __pu_addr = (long) (ptr);                                       \
+       __pu_err = access_ok(VERIFY_WRITE, (void *) __pu_addr, size)    \
+                               ? 0 : -EFAULT;                          \
                                                                        \
        if (likely(!__pu_err)) {                                        \
                switch (size) {                                         \