Commit b1fcec7f authored by Joe Perches's avatar Joe Perches Committed by Ingo Molnar
Browse files

include/asm-x86/uaccess_32.h: checkpatch cleanups - formatting only 



Signed-off-by: default avatarJoe Perches <joe@perches.com>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent 2d86e637

include/asm-x86/uaccess_32.h

+187 −129
Original line number Diff line number Diff line
@@ -43,7 +43,9 @@ extern struct movsl_mask { 
} ____cacheline_aligned_in_smp movsl_mask;

#endif



#define __addr_ok(addr) ((unsigned long __force)(addr) < (current_thread_info()->addr_limit.seg))

#define __addr_ok(addr)					\

	((unsigned long __force)(addr) <		\

	 (current_thread_info()->addr_limit.seg))



/*

 * Test whether a block of memory is a valid user space address.
@@ -54,13 +56,16 @@ extern struct movsl_mask { 
 *

 * This needs 33-bit arithmetic. We have a carry...

 */

#define __range_ok(addr,size) ({ \

#define __range_ok(addr, size)						\

({									\

	unsigned long flag, roksum;					\

	__chk_user_ptr(addr);						\

	asm("addl %3,%1 ; sbbl %0,%0; cmpl %1,%4; sbbl $0,%0"		\

	    :"=&r" (flag), "=r" (roksum)				\

		:"1" (addr),"g" ((int)(size)),"rm" (current_thread_info()->addr_limit.seg)); \

	flag; })

	    :"1" (addr), "g" ((int)(size)),				\

	    "rm" (current_thread_info()->addr_limit.seg));		\

	flag;								\

})



/**

 * access_ok: - Checks if a user space pointer is valid
@@ -96,8 +101,7 @@ extern struct movsl_mask { 
 * on our cache or tlb entries.

 */



struct exception_table_entry

{

struct exception_table_entry {

	unsigned long insn, fixup;

};
@@ -123,12 +127,14 @@ extern void __get_user_2(void); 
extern void __get_user_4(void);



#define __get_user_x(size, ret, x, ptr)	      \

	__asm__ __volatile__("call __get_user_" #size \

	asm volatile("call __get_user_" #size \

		     :"=a" (ret),"=d" (x)     \

		     :"0" (ptr))





/* Careful: we have to cast the result to the type of the pointer for sign reasons */

/* Careful: we have to cast the result to the type of the pointer

 * for sign reasons */



/**

 * get_user: - Get a simple variable from user space.

 * @x:   Variable to store result.
@@ -147,14 +153,23 @@ extern void __get_user_4(void); 
 * On error, the variable @x is set to zero.

 */

#define get_user(x, ptr)						\

({	int __ret_gu;							\

({									\

	int __ret_gu;							\

	unsigned long __val_gu;						\

	__chk_user_ptr(ptr);						\

	switch (sizeof(*(ptr))) {					\

	case 1:  __get_user_x(1,__ret_gu,__val_gu,ptr); break;		\

	case 2:  __get_user_x(2,__ret_gu,__val_gu,ptr); break;		\

	case 4:  __get_user_x(4,__ret_gu,__val_gu,ptr); break;		\

	default: __get_user_x(X,__ret_gu,__val_gu,ptr); break;		\

	case 1:								\

		__get_user_x(1, __ret_gu, __val_gu, ptr);		\

		break;							\

	case 2:								\

		__get_user_x(2, __ret_gu, __val_gu, ptr);		\

		break;							\

	case 4:								\

		__get_user_x(4, __ret_gu, __val_gu, ptr);		\

		break;							\

	default:							\

		__get_user_x(X, __ret_gu, __val_gu, ptr);		\

		break;							\

	}								\

	(x) = (__typeof__(*(ptr)))__val_gu;				\

	__ret_gu;							\
@@ -171,11 +186,25 @@ extern void __put_user_2(void); 
extern void __put_user_4(void);

extern void __put_user_8(void);



#define __put_user_1(x, ptr) __asm__ __volatile__("call __put_user_1":"=a" (__ret_pu):"0" ((typeof(*(ptr)))(x)), "c" (ptr))

#define __put_user_2(x, ptr) __asm__ __volatile__("call __put_user_2":"=a" (__ret_pu):"0" ((typeof(*(ptr)))(x)), "c" (ptr))

#define __put_user_4(x, ptr) __asm__ __volatile__("call __put_user_4":"=a" (__ret_pu):"0" ((typeof(*(ptr)))(x)), "c" (ptr))

#define __put_user_8(x, ptr) __asm__ __volatile__("call __put_user_8":"=a" (__ret_pu):"A" ((typeof(*(ptr)))(x)), "c" (ptr))

#define __put_user_X(x, ptr) __asm__ __volatile__("call __put_user_X":"=a" (__ret_pu):"c" (ptr))

#define __put_user_1(x, ptr)					\

	asm volatile("call __put_user_1" : "=a" (__ret_pu)	\

		     : "0" ((typeof(*(ptr)))(x)), "c" (ptr))



#define __put_user_2(x, ptr)					\

	asm volatile("call __put_user_2" : "=a" (__ret_pu)	\

		     : "0" ((typeof(*(ptr)))(x)), "c" (ptr))



#define __put_user_4(x, ptr)					\

	asm volatile("call __put_user_4" : "=a" (__ret_pu)	\

		     : "0" ((typeof(*(ptr)))(x)), "c" (ptr))



#define __put_user_8(x, ptr)					\

	asm volatile("call __put_user_8" : "=a" (__ret_pu)	\

		     : "A" ((typeof(*(ptr)))(x)), "c" (ptr))



#define __put_user_X(x, ptr)					\

	asm volatile("call __put_user_X" : "=a" (__ret_pu)	\

		     : "c" (ptr))



/**

 * put_user: - Write a simple value into user space.
@@ -196,16 +225,27 @@ extern void __put_user_8(void); 
#ifdef CONFIG_X86_WP_WORKS_OK



#define put_user(x, ptr)					\

({	int __ret_pu;						\

({								\

	int __ret_pu;						\

	__typeof__(*(ptr)) __pu_val;				\

	__chk_user_ptr(ptr);					\

	__pu_val = x;						\

	switch (sizeof(*(ptr))) {				\

	case 1: __put_user_1(__pu_val, ptr); break;		\

	case 2: __put_user_2(__pu_val, ptr); break;		\

	case 4: __put_user_4(__pu_val, ptr); break;		\

	case 8: __put_user_8(__pu_val, ptr); break;		\

	default:__put_user_X(__pu_val, ptr); break;		\

	case 1:							\

		__put_user_1(__pu_val, ptr);			\

		break;						\

	case 2:							\

		__put_user_2(__pu_val, ptr);			\

		break;						\

	case 4:							\

		__put_user_4(__pu_val, ptr);			\

		break;						\

	case 8:							\

		__put_user_8(__pu_val, ptr);			\

		break;						\

	default:						\

		__put_user_X(__pu_val, ptr);			\

		break;						\

	}							\

	__ret_pu;						\

})
@@ -280,8 +320,7 @@ extern void __put_user_8(void); 




#define __put_user_u64(x, addr, err)					\

	__asm__ __volatile__(					\

		"1:	movl %%eax,0(%2)\n"			\

	asm volatile("1:	movl %%eax,0(%2)\n"			\

		     "2:	movl %%edx,4(%2)\n"			\

		     "3:\n"						\

		     ".section .fixup,\"ax\"\n"				\
@@ -300,11 +339,20 @@ do { \ 
	retval = 0;							\

	__chk_user_ptr(ptr);						\

	switch (size) {							\

	case 1: __put_user_asm(x,ptr,retval,"b","b","iq",errret);break;	\

	case 2: __put_user_asm(x,ptr,retval,"w","w","ir",errret);break; \

	case 4: __put_user_asm(x,ptr,retval,"l","","ir",errret); break;	\

	case 8: __put_user_u64((__typeof__(*ptr))(x),ptr,retval); break;\

	  default: __put_user_bad();					\

	case 1:								\

		__put_user_asm(x, ptr, retval, "b", "b", "iq", errret);	\

		break;							\

	case 2:								\

		__put_user_asm(x, ptr, retval, "w", "w", "ir", errret);	\

		break;							\

	case 4:								\

		__put_user_asm(x, ptr, retval, "l", "",  "ir", errret);	\

		break;							\

	case 8:								\

		__put_user_u64((__typeof__(*ptr))(x), ptr, retval);	\

		break;							\

	default:							\

		__put_user_bad();					\

	}								\

} while (0)
@@ -329,8 +377,7 @@ struct __large_struct { unsigned long buf[100]; }; 
 * aliasing issues.

 */

#define __put_user_asm(x, addr, err, itype, rtype, ltype, errret)	\

	__asm__ __volatile__(						\

		"1:	mov"itype" %"rtype"1,%2\n"			\

	asm volatile("1:	mov"itype" %"rtype"1,%2\n"		\

		     "2:\n"						\

		     ".section .fixup,\"ax\"\n"				\

		     "3:	movl %3,%0\n"				\
@@ -357,16 +404,22 @@ do { \ 
	retval = 0;							\

	__chk_user_ptr(ptr);						\

	switch (size) {							\

	case 1: __get_user_asm(x,ptr,retval,"b","b","=q",errret);break;	\

	case 2: __get_user_asm(x,ptr,retval,"w","w","=r",errret);break;	\

	case 4: __get_user_asm(x,ptr,retval,"l","","=r",errret);break;	\

	default: (x) = __get_user_bad();				\

	case 1:								\

		__get_user_asm(x, ptr, retval, "b", "b", "=q", errret);	\

		break;							\

	case 2:								\

		__get_user_asm(x, ptr, retval, "w", "w", "=r", errret);	\

		break;							\

	case 4:								\

		__get_user_asm(x, ptr, retval, "l", "", "=r", errret);	\

		break;							\

	default:							\

		(x) = __get_user_bad();					\

	}								\

} while (0)



#define __get_user_asm(x, addr, err, itype, rtype, ltype, errret)	\

	__asm__ __volatile__(						\

		"1:	mov"itype" %2,%"rtype"1\n"			\

	asm volatile("1:	mov"itype" %2,%"rtype"1\n"		\

		     "2:\n"						\

		     ".section .fixup,\"ax\"\n"				\

		     "3:	movl %3,%0\n"				\
@@ -378,16 +431,16 @@ do { \ 
		     : "m" (__m(addr)), "i" (errret), "0" (err))





unsigned long __must_check __copy_to_user_ll(void __user *to,

				const void *from, unsigned long n);

unsigned long __must_check __copy_from_user_ll(void *to,

				const void __user *from, unsigned long n);

unsigned long __must_check __copy_from_user_ll_nozero(void *to,

				const void __user *from, unsigned long n);

unsigned long __must_check __copy_from_user_ll_nocache(void *to,

				const void __user *from, unsigned long n);

unsigned long __must_check __copy_from_user_ll_nocache_nozero(void *to,

				const void __user *from, unsigned long n);

unsigned long __must_check __copy_to_user_ll

		(void __user *to, const void *from, unsigned long n);

unsigned long __must_check __copy_from_user_ll

		(void *to, const void __user *from, unsigned long n);

unsigned long __must_check __copy_from_user_ll_nozero

		(void *to, const void __user *from, unsigned long n);

unsigned long __must_check __copy_from_user_ll_nocache

		(void *to, const void __user *from, unsigned long n);

unsigned long __must_check __copy_from_user_ll_nocache_nozero

		(void *to, const void __user *from, unsigned long n);



/**

 * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking.
@@ -416,13 +469,16 @@ __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n) 


		switch (n) {

		case 1:

			__put_user_size(*(u8 *)from, (u8 __user *)to, 1, ret, 1);

			__put_user_size(*(u8 *)from, (u8 __user *)to,

					1, ret, 1);

			return ret;

		case 2:

			__put_user_size(*(u16 *)from, (u16 __user *)to, 2, ret, 2);

			__put_user_size(*(u16 *)from, (u16 __user *)to,

					2, ret, 2);

			return ret;

		case 4:

			__put_user_size(*(u32 *)from, (u32 __user *)to, 4, ret, 4);

			__put_user_size(*(u32 *)from, (u32 __user *)to,

					4, ret, 4);

			return ret;

		}

	}
@@ -545,7 +601,8 @@ static __always_inline unsigned long __copy_from_user_nocache(void *to, 
}



static __always_inline unsigned long

__copy_from_user_inatomic_nocache(void *to, const void __user *from, unsigned long n)

__copy_from_user_inatomic_nocache(void *to, const void __user *from,

				  unsigned long n)

{

       return __copy_from_user_ll_nocache_nozero(to, from, n);

}
@@ -553,7 +610,8 @@ __copy_from_user_inatomic_nocache(void *to, const void __user *from, unsigned lo 
unsigned long __must_check copy_to_user(void __user *to,

					const void *from, unsigned long n);

unsigned long __must_check copy_from_user(void *to,

				const void __user *from, unsigned long n);

					  const void __user *from,

					  unsigned long n);

long __must_check strncpy_from_user(char *dst, const char __user *src,

				    long count);

long __must_check __strncpy_from_user(char *dst,