[LV-k25-commit] kernel-2.5/include/asm-vax uaccess.h,1.8,1.9

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/linux-vax/kernel-2.5/include/asm-vax
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15825/include/asm-vax

Modified Files:
	uaccess.h 
Log Message:
- Real touchup.


Index: uaccess.h
===================================================================
RCS file: /cvsroot/linux-vax/kernel-2.5/include/asm-vax/uaccess.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9

--- uaccess.h	25 Apr 2005 22:25:07 -0000	1.8
+++ uaccess.h	9 May 2005 20:29:55 -0000	1.9
@@ -30,10 +30,10 @@
 
 #define segment_eq(a,b)	((a).seg == (b).seg)
 
-#define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
-#define __user_ok(addr,size) (((size) <= 0x80000000)&&((addr) <= 0x80000000-(size)))
-#define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size)))
-#define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size))
+#define __kernel_ok			(segment_eq(get_fs(), KERNEL_DS))
+#define __user_ok(addr, size)		(((size) <= 0x80000000) && ((addr) <= 0x80000000-(size)))
+#define __access_ok(addr, size)		(__kernel_ok || __user_ok((addr), (size)))
+#define access_ok(type, addr, size)	__access_ok((unsigned long) (addr), (size))
 
 extern inline int __deprecated verify_area(int type, const void * addr, unsigned long size)
 {
@@ -74,72 +74,71 @@
  * with a separate "access_ok()" call (this is used when we do multiple
  * accesses to the same area of user memory).
  *
- * FIXME: Lets try this.. 
+ * FIXME: Lets try this..
  * As we use the same address space for kernel and user data on the
  * PowerPC, we can just do these as direct assignments.  (Of course, the
  * exception handling means that it's no longer "just"...)
  */
-#define get_user(x,ptr) \
-  __get_user_check((x),(ptr),sizeof(*(ptr)))
-#define put_user(x,ptr) \
-  __put_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
+#define get_user(x, ptr) \
+	__get_user_check((x), (ptr), sizeof (*(ptr)))
+#define put_user(x, ptr) \
+	__put_user_check((__typeof__ (*(ptr))) (x),(ptr), sizeof (*(ptr)))
 
-#define __get_user(x,ptr) \
-  __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
-#define __put_user(x,ptr) \
-  __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
+#define __get_user(x, ptr) \
+	__get_user_nocheck((x), (ptr), sizeof(*(ptr)))
+#define __put_user(x, ptr) \
+	__put_user_nocheck((__typeof__ (*(ptr))) (x), (ptr), sizeof (*(ptr)))
 
 /*
  * The "xxx_ret" versions return constant specified in third argument, if
  * something bad happens. These macros can be optimized for the
  * case of just returning from the function xxx_ret is used.
  */
+#define put_user_ret(x, ptr, ret) ({ \
+	if (put_user((x), (ptr))) return ret; })
 
-#define put_user_ret(x,ptr,ret) ({ \
-if (put_user(x,ptr)) return ret; })
-
-#define get_user_ret(x,ptr,ret) ({ \
-if (get_user(x,ptr)) return ret; })
+#define get_user_ret(x, ptr, ret) ({ \
+	if (get_user((x), (ptr))) return ret; })
 
-#define __put_user_ret(x,ptr,ret) ({ \
-if (__put_user(x,ptr)) return ret; })
+#define __put_user_ret(x, ptr, ret) ({ \
+	if (__put_user((x), (ptr))) return ret; })
 
-#define __get_user_ret(x,ptr,ret) ({ \
-if (__get_user(x,ptr)) return ret; })
+#define __get_user_ret(x, ptr, ret) ({ \
+	if (__get_user((x), (ptr))) return ret; })
 
 
 extern long __put_user_bad(void);
 
-#define __put_user_nocheck(x,ptr,size)			\
+#define __put_user_nocheck(x, ptr, size)		\
 ({							\
 	long __pu_err;					\
-	__put_user_size((x),(ptr),(size),__pu_err);	\
+	__put_user_size((x), (ptr), (size), __pu_err);	\
 	__pu_err;					\
 })
 
-#define __put_user_check(x,ptr,size)				\
-({								\
-	long __pu_err = -EFAULT;				\
-	__typeof__(*(ptr)) *__pu_addr = (ptr);			\
-	if (access_ok(VERIFY_WRITE,__pu_addr,size))		\
-		__put_user_size((x),__pu_addr,(size),__pu_err);	\
-	__pu_err;						\
+#define __put_user_check(x, ptr, size)					\
+({									\
+	long __pu_err = -EFAULT;					\
+	__typeof__ (*(ptr)) *__pu_addr = (ptr);				\
+	if (access_ok(VERIFY_WRITE, __pu_addr, (size)))			\
+		__put_user_size((x), __pu_addr, (size), __pu_err);	\
+	__pu_err;							\
 })
 
-#define __put_user_size(x,ptr,size,retval)			\
-do {								\
-	retval = 0;						\
-	switch (size) {						\
-	  case 1: __put_user_asm(x,ptr,retval,"movb"); break;	\
-	  case 2: __put_user_asm(x,ptr,retval,"movw"); break;	\
-	  case 4: __put_user_asm(x,ptr,retval,"movl"); break;	\
-	  case 8: __put_user_asm(x,ptr,retval,"movq"); break;   \
-	  default: __put_user_bad();				\
-	}							\
+#define __put_user_size(x, ptr, size, retval)					\
+do {										\
+	retval = 0;								\
+	switch (size) {								\
+		case 1: __put_user_asm((x), (ptr), (retval), "movb"); break;	\
+		case 2: __put_user_asm((x), (ptr), (retval), "movw"); break;	\
+		case 4: __put_user_asm((x), (ptr), (retval), "movl"); break;	\
+		case 8: __put_user_asm((x), (ptr), (retval), "movq"); break;	\
+		default: __put_user_bad();					\
+	}									\
 } while (0)
 
 struct __large_struct { unsigned long buf[100]; };
-#define __m(x) (*(struct __large_struct *)(x))
+#define __m(x)	(* (struct __large_struct *) (x))
 
 /*
  * We don't tell gcc that we are accessing memory, but this is OK
@@ -148,68 +147,74 @@
  */
 #define __put_user_asm(x, addr, err, op)			\
 	__asm__ __volatile__(					\
-		"1:	"op" %1,%2\n"  			        \
-		"2:\n"						\
-		".section .fixup,\"ax\"\n"			\
-		"3:	movl %3,%0\n"				\
-		"	jmp 2b\n"				\
-		".previous\n"					\
-		".section __ex_table,\"a\"\n"			\
-		"	.align 2\n"				\
-		"	.long 1b,3b\n"				\
-		".previous"					\
-		: "=r"(err)					\
-		: "r"(x), "m"(*addr), "i"(-EFAULT), "0"(err))
+	"1:	"op"	%1, %2			\n"	        \
+	"2:					\n"		\
+	".section .fixup,\"ax\"			\n"		\
+	"3:	movl	%3,%0			\n"		\
+	"	jmp	2b			\n"		\
+	".previous				\n"		\
+	".section __ex_table,\"a\"		\n"		\
+	"	.align	2			\n"		\
+	"	.long	1b,3b			\n"		\
+	".previous"						\
+	: "=r" (err)						\
+	: "r" (x),						\
+	  "m" (*addr),						\
+	  "i" (-EFAULT),					\
+	  "0" (err))
 
 
-#define __get_user_nocheck(x,ptr,size)				\
+#define __get_user_nocheck(x, ptr, size)			\
 ({								\
 	long __gu_err, __gu_val;				\
-	__get_user_size(__gu_val,(ptr),(size),__gu_err);	\
-	(x) = (__typeof__(*(ptr)))__gu_val;			\
+	__get_user_size(__gu_val, (ptr), (size), __gu_err);	\
+	(x) = (__typeof__(*(ptr))) __gu_val;			\
 	__gu_err;						\
 })
 
-#define __get_user_check(x,ptr,size)					\
+#define __get_user_check(x, ptr, size)					\
 ({									\
 	long __gu_err = -EFAULT, __gu_val = 0;				\
 	const __typeof__(*(ptr)) *__gu_addr = (ptr);			\
-	if (access_ok(VERIFY_READ,__gu_addr,size))			\
-		__get_user_size(__gu_val,__gu_addr,(size),__gu_err);	\
-	(x) = (__typeof__(*(ptr)))__gu_val;				\
+	if (access_ok(VERIFY_READ, __gu_addr, (size)))			\
+		__get_user_size(__gu_val, __gu_addr, (size), __gu_err);	\
+	(x) = (__typeof__(*(ptr))) __gu_val;				\
 	__gu_err;							\
 })
 
 extern long __get_user_bad(void);
 
-#define __get_user_size(x,ptr,size,retval)			\
-do {								\
-	retval = 0;						\
-	switch (size) {						\
-	  case 1: __get_user_asm(x,ptr,retval,"movb"); break;	\
-	  case 2: __get_user_asm(x,ptr,retval,"movw"); break;	\
-	  case 4: __get_user_asm(x,ptr,retval,"movl"); break;	\
-	  case 8: __get_user_asm(x,ptr,retval,"movq"); break;	\
-	  default: (x) = __get_user_bad();			\
-	}							\
+#define __get_user_size(x, ptr, size, retval)				\
+do {									\
+	retval = 0;							\
+	switch (size) {							\
+	  case 1: __get_user_asm((x), (ptr), (retval), "movb"); break;	\
+	  case 2: __get_user_asm((x), (ptr), (retval), "movw"); break;	\
+	  case 4: __get_user_asm((x), (ptr), (retval), "movl"); break;	\
+	  case 8: __get_user_asm((x), (ptr), (retval), "movq"); break;	\
+	  default: (x) = __get_user_bad();				\
+	}								\
 } while (0)
 
-#define __get_user_asm(x, addr, err, op)		\
-	__asm__ __volatile__(				\
-		"1:	"op" %2,%1\n"		\
-		"2:\n"					\
-		".section .fixup,\"ax\"\n"		\
-		"3:	movl %3, %0\n"			\
-		"	clrl %1\n"			\
-		"	jmp 2b\n"				\
-		".section __ex_table,\"a\"\n"		\
-		"	.align 2\n"			\
-		"	.long 1b,3b\n"			\
-		".text"					\
-		: "=r"(err), "=r"(x)			\
-		: "m"(*addr), "i"(-EFAULT), "0"(err))
+#define __get_user_asm(x, addr, err, op)			\
+	__asm__ __volatile__(					\
+	"1:	"op"	%2, %1			\n"		\
+	"2:					\n"		\
+	".section .fixup,\"ax\"			\n"		\
+	"3:	movl	%3, %0			\n"		\
+	"	clrl	%1			\n"		\
+	"	jmp 2b				\n"		\
+	".section __ex_table,\"a\"		\n"		\
+	"	.align	2			\n"		\
+	".long	1b, 3b				\n"		\
+	".text					\n"		\
+	: "=r" (err),						\
+	  "=r" (x)						\
+	: "m" (*addr),						\
+	  "i" (-EFAULT),						\
+	  "0" (err))
 
-/* more complex routines */
+/* More complex routines */
 
 extern int __copy_tofrom_user(void *to, const void *from, unsigned long size);
 
@@ -265,8 +270,10 @@
  */
 #define strlen_user(s)	strnlen_user(s, ~0UL >> 1)
 
-/* Returns: 0 if exception before NUL or reaching the supplied limit (N), 
- * a value greater than N if the limit would be exceeded, else strlen. */
+/*
+ * Returns: 0 if exception before NUL or reaching the supplied limit (N),
+ * a value greater than N if the limit would be exceeded, else strlen.
+ */
 extern long __strnlen_user(const char *, long);
 extern inline long strnlen_user(const char *str, long n)
 {



