#define segment_eq(a,b) ((a).ar4 == (b).ar4)
-#define __access_ok(addr,size) (1)
-
-#define access_ok(type,addr,size) __access_ok(addr,size)
-
-extern inline int verify_area(int type, const void * addr, unsigned long size)
+static inline int __access_ok(const void __user *addr, unsigned long size)
{
- return access_ok(type,addr,size)?0:-EFAULT;
+ return 1;
}
+#define access_ok(type,addr,size) __access_ok(addr,size)
/*
* The exception table consists of pairs of addresses: the first is the
* These are the main single-value transfer routines. They automatically
* use the right size if we just have the right pointer type.
*/
-#if __GNUC__ > 2
+#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
#define __put_user_asm(x, ptr, err) \
({ \
err = 0; \
({ \
__typeof__(*(ptr)) __x = (x); \
int __pu_err; \
+ __chk_user_ptr(ptr); \
switch (sizeof (*(ptr))) { \
case 1: \
case 2: \
__put_user_asm(__x, ptr, __pu_err); \
break; \
default: \
- __pu_err = __put_user_bad(); \
+ __put_user_bad(); \
break; \
} \
__pu_err; \
})
-extern int __put_user_bad(void);
+extern int __put_user_bad(void) __attribute__((noreturn));
-#if __GNUC__ > 2
+#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
#define __get_user_asm(x, ptr, err) \
({ \
err = 0; \
#define __get_user(x, ptr) \
({ \
- __typeof__(*(ptr)) __x; \
int __gu_err; \
+ __chk_user_ptr(ptr); \
switch (sizeof(*(ptr))) { \
- case 1: \
- case 2: \
- case 4: \
- case 8: \
+ case 1: { \
+ unsigned char __x; \
__get_user_asm(__x, ptr, __gu_err); \
+ (x) = *(__force __typeof__(*(ptr)) *) &__x; \
break; \
+ }; \
+ case 2: { \
+ unsigned short __x; \
+ __get_user_asm(__x, ptr, __gu_err); \
+ (x) = *(__force __typeof__(*(ptr)) *) &__x; \
+ break; \
+ }; \
+ case 4: { \
+ unsigned int __x; \
+ __get_user_asm(__x, ptr, __gu_err); \
+ (x) = *(__force __typeof__(*(ptr)) *) &__x; \
+ break; \
+ }; \
+ case 8: { \
+ unsigned long long __x; \
+ __get_user_asm(__x, ptr, __gu_err); \
+ (x) = *(__force __typeof__(*(ptr)) *) &__x; \
+ break; \
+ }; \
default: \
- __x = 0; \
- __gu_err = __get_user_bad(); \
+ __get_user_bad(); \
break; \
} \
- (x) = __x; \
__gu_err; \
})
__get_user(x, ptr); \
})
-extern int __get_user_bad(void);
+extern int __get_user_bad(void) __attribute__((noreturn));
-extern long __copy_to_user_asm(const void *from, long n, void *to);
+#define __put_user_unaligned __put_user
+#define __get_user_unaligned __get_user
+
+extern long __copy_to_user_asm(const void *from, long n, void __user *to);
/**
* __copy_to_user: - Copy a block of data into user space, with less checking.
return __copy_to_user_asm(from, n, to);
}
+#define __copy_to_user_inatomic __copy_to_user
+#define __copy_from_user_inatomic __copy_from_user
+
/**
* copy_to_user: - Copy a block of data into user space.
* @to: Destination address, in user space.
return n;
}
-extern long __copy_from_user_asm(void *to, long n, const void *from);
+extern long __copy_from_user_asm(void *to, long n, const void __user *from);
/**
* __copy_from_user: - Copy a block of data from user space, with less checking.
return n;
}
-extern long __copy_in_user_asm(const void *from, long n, void *to);
+extern unsigned long __copy_in_user_asm(const void __user *from, long n,
+ void __user *to);
static inline unsigned long
__copy_in_user(void __user *to, const void __user *from, unsigned long n)
{
- __copy_in_user_asm(from, n, to);
+ return __copy_in_user_asm(from, n, to);
}
static inline unsigned long
/*
* Copy a null terminated string from userspace.
*/
-extern long __strncpy_from_user_asm(char *dst, const char *src, long count);
+extern long __strncpy_from_user_asm(long count, char *dst,
+ const char __user *src);
static inline long
-strncpy_from_user(char *dst, const char *src, long count)
+strncpy_from_user(char *dst, const char __user *src, long count)
{
long res = -EFAULT;
might_sleep();
if (access_ok(VERIFY_READ, src, 1))
- res = __strncpy_from_user_asm(dst, src, count);
+ res = __strncpy_from_user_asm(count, dst, src);
return res;
}
-extern long __strnlen_user_asm(const char *src, long count);
+extern long __strnlen_user_asm(long count, const char __user *src);
static inline unsigned long
-strnlen_user(const char * src, unsigned long n)
+strnlen_user(const char __user * src, unsigned long n)
{
might_sleep();
- return __strnlen_user_asm(src, n);
+ return __strnlen_user_asm(n, src);
}
/**
* Zero Userspace
*/
-extern long __clear_user_asm(void *to, long n);
+extern long __clear_user_asm(void __user *to, long n);
static inline unsigned long
-__clear_user(void *to, unsigned long n)
+__clear_user(void __user *to, unsigned long n)
{
return __clear_user_asm(to, n);
}
static inline unsigned long
-clear_user(void *to, unsigned long n)
+clear_user(void __user *to, unsigned long n)
{
might_sleep();
if (access_ok(VERIFY_WRITE, to, n))