CRIS: Whitespace cleanup

No functional change, just clean up the most obvious. Signed-off-by: Jesper Nilsson <jesper.nilsson@axis.com>

CRIS: Whitespace cleanup
No functional change, just clean up the most obvious. Signed-off-by: Jesper Nilsson <jesper.nilsson@axis.com>
Jesper Nilsson
1 parent 83f1588e9f
Showing 1 changed file with 52 additions and 31 deletions Side-by-side Diff
arch/cris/include/asm/uaccess.h
-/* 
+/*
  * Authors:    Bjorn Wesen (bjornw@axis.com)
  *	       Hans-Peter Nilsson (hp@axis.com)
  */
@@ -35,7 +35,7 @@
 #define MAKE_MM_SEG(s)	((mm_segment_t) { (s) })
  
 /* addr_limit is the maximum accessible address for the task. we misuse
- * the KERNEL_DS and USER_DS values to both assign and compare the 
+ * the KERNEL_DS and USER_DS values to both assign and compare the
  * addr_limit values through the equally misnamed get/set_fs macros.
  * (see above)
  */
@@ -51,7 +51,7 @@
  
 #define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
 #define __user_ok(addr, size) \
-	(((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
+	(((size) <= TASK_SIZE) && ((addr) <= TASK_SIZE-(size)))
 #define __access_ok(addr, size) (__kernel_ok || __user_ok((addr), (size)))
 #define access_ok(type, addr, size) __access_ok((unsigned long)(addr), (size))
  
@@ -70,8 +70,7 @@
  * on our cache or tlb entries.
  */
  
-struct exception_table_entry
-{
+struct exception_table_entry {
 	unsigned long insn, fixup;
 };
  
  
  
  
@@ -94,14 +93,14 @@
  * exception handling means that it's no longer "just"...)
  */
 #define get_user(x, ptr) \
-  __get_user_check((x), (ptr), sizeof(*(ptr)))
+	__get_user_check((x), (ptr), sizeof(*(ptr)))
 #define put_user(x, ptr) \
-  __put_user_check((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
+	__put_user_check((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
  
 #define __get_user(x, ptr) \
-  __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
+	__get_user_nocheck((x), (ptr), sizeof(*(ptr)))
 #define __put_user(x, ptr) \
-  __put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
+	__put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
  
 extern long __put_user_bad(void);
  
@@ -109,11 +108,20 @@
 do {									\
 	retval = 0;							\
 	switch (size) {							\
-	  case 1: __put_user_asm(x, ptr, retval, "move.b"); break;	\
-	  case 2: __put_user_asm(x, ptr, retval, "move.w"); break;	\
-	  case 4: __put_user_asm(x, ptr, retval, "move.d"); break;	\
-	  case 8: __put_user_asm_64(x, ptr, retval); break;		\
-	  default: __put_user_bad();					\
+	case 1:								\
+		__put_user_asm(x, ptr, retval, "move.b");		\
+		break;							\
+	case 2:								\
+		__put_user_asm(x, ptr, retval, "move.w");		\
+		break;							\
+	case 4:								\
+		__put_user_asm(x, ptr, retval, "move.d");		\
+		break;							\
+	case 8:								\
+		__put_user_asm_64(x, ptr, retval);			\
+		break;							\
+	default:							\
+		__put_user_bad();					\
 	}								\
 } while (0)
  
@@ -121,11 +129,20 @@
 do {									\
 	retval = 0;							\
 	switch (size) {							\
-	  case 1: __get_user_asm(x, ptr, retval, "move.b"); break;	\
-	  case 2: __get_user_asm(x, ptr, retval, "move.w"); break;	\
-	  case 4: __get_user_asm(x, ptr, retval, "move.d"); break;	\
-	  case 8: __get_user_asm_64(x, ptr, retval); break;		\
-	  default: (x) = __get_user_bad();				\
+	case 1:								\
+		__get_user_asm(x, ptr, retval, "move.b");		\
+		break;							\
+	case 2:								\
+		__get_user_asm(x, ptr, retval, "move.w");		\
+		break;							\
+	case 4:								\
+		__get_user_asm(x, ptr, retval, "move.d");		\
+		break;							\
+	case 8:								\
+		__get_user_asm_64(x, ptr, retval);			\
+		break;							\
+	default:							\
+		(x) = __get_user_bad();					\
 	}								\
 } while (0)
  
@@ -211,6 +228,7 @@
 strncpy_from_user(char *dst, const char __user *src, long count)
 {
 	long res = -EFAULT;
+
 	if (access_ok(VERIFY_READ, src, 1))
 		res = __do_strncpy_from_user(dst, src, count);
 	return res;
@@ -224,6 +242,7 @@
 __constant_copy_from_user(void *to, const void __user *from, unsigned long n)
 {
 	unsigned long ret = 0;
+
 	if (n == 0)
 		;
 	else if (n == 1)
@@ -274,6 +293,7 @@
 __constant_copy_to_user(void __user *to, const void *from, unsigned long n)
 {
 	unsigned long ret = 0;
+
 	if (n == 0)
 		;
 	else if (n == 1)
@@ -324,6 +344,7 @@
 __constant_clear_user(void __user *to, unsigned long n)
 {
 	unsigned long ret = 0;
+
 	if (n == 0)
 		;
 	else if (n == 1)
  
  
@@ -351,20 +372,20 @@
 }
  
  
-#define clear_user(to, n)			\
-(__builtin_constant_p(n) ?			\
- __constant_clear_user(to, n) :			\
- __generic_clear_user(to, n))
+#define clear_user(to, n)				\
+	(__builtin_constant_p(n) ?			\
+	 __constant_clear_user(to, n) :			\
+	 __generic_clear_user(to, n))
  
-#define copy_from_user(to, from, n)		\
-(__builtin_constant_p(n) ?			\
- __constant_copy_from_user(to, from, n) :	\
- __generic_copy_from_user(to, from, n))
+#define copy_from_user(to, from, n)			\
+	(__builtin_constant_p(n) ?			\
+	 __constant_copy_from_user(to, from, n) :	\
+	 __generic_copy_from_user(to, from, n))
  
-#define copy_to_user(to, from, n)		\
-(__builtin_constant_p(n) ?			\
- __constant_copy_to_user(to, from, n) :		\
- __generic_copy_to_user(to, from, n))
+#define copy_to_user(to, from, n)			\
+	(__builtin_constant_p(n) ?			\
+	 __constant_copy_to_user(to, from, n) :		\
+	 __generic_copy_to_user(to, from, n))
  
 /* We let the __ versions of copy_from/to_user inline, because they're often
  * used in fast paths and have only a small space overhead.
1		-/*
	1	+/*
2	2	* Authors: Bjorn Wesen (bjornw@axis.com)
3	3	* Hans-Peter Nilsson (hp@axis.com)
4	4	*/
...	...	@@ -35,7 +35,7 @@
35	35	#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
36	36
37	37	/* addr_limit is the maximum accessible address for the task. we misuse
38		- * the KERNEL_DS and USER_DS values to both assign and compare the
	38	+ * the KERNEL_DS and USER_DS values to both assign and compare the
39	39	* addr_limit values through the equally misnamed get/set_fs macros.
40	40	* (see above)
41	41	*/
...	...	@@ -51,7 +51,7 @@
51	51
52	52	#define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
53	53	#define __user_ok(addr, size) \
54		- (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
	54	+ (((size) <= TASK_SIZE) && ((addr) <= TASK_SIZE-(size)))
55	55	#define __access_ok(addr, size) (__kernel_ok \|\| __user_ok((addr), (size)))
56	56	#define access_ok(type, addr, size) __access_ok((unsigned long)(addr), (size))
57	57
...	...	@@ -70,8 +70,7 @@
70	70	* on our cache or tlb entries.
71	71	*/
72	72
73		-struct exception_table_entry
74		-{
	73	+struct exception_table_entry {
75	74	unsigned long insn, fixup;
76	75	};
77	76
78	77
79	78
80	79
...	...	@@ -94,14 +93,14 @@
94	93	* exception handling means that it's no longer "just"...)
95	94	*/
96	95	#define get_user(x, ptr) \
97		- __get_user_check((x), (ptr), sizeof(*(ptr)))
	96	+ __get_user_check((x), (ptr), sizeof(*(ptr)))
98	97	#define put_user(x, ptr) \
99		- __put_user_check((__typeof__((ptr)))(x), (ptr), sizeof((ptr)))
	98	+ __put_user_check((__typeof__((ptr)))(x), (ptr), sizeof((ptr)))
100	99
101	100	#define __get_user(x, ptr) \
102		- __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
	101	+ __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
103	102	#define __put_user(x, ptr) \
104		- __put_user_nocheck((__typeof__((ptr)))(x), (ptr), sizeof((ptr)))
	103	+ __put_user_nocheck((__typeof__((ptr)))(x), (ptr), sizeof((ptr)))
105	104
106	105	extern long __put_user_bad(void);
107	106
...	...	@@ -109,11 +108,20 @@
109	108	do { \
110	109	retval = 0; \
111	110	switch (size) { \
112		- case 1: __put_user_asm(x, ptr, retval, "move.b"); break; \
113		- case 2: __put_user_asm(x, ptr, retval, "move.w"); break; \
114		- case 4: __put_user_asm(x, ptr, retval, "move.d"); break; \
115		- case 8: __put_user_asm_64(x, ptr, retval); break; \
116		- default: __put_user_bad(); \
	111	+ case 1: \
	112	+ __put_user_asm(x, ptr, retval, "move.b"); \
	113	+ break; \
	114	+ case 2: \
	115	+ __put_user_asm(x, ptr, retval, "move.w"); \
	116	+ break; \
	117	+ case 4: \
	118	+ __put_user_asm(x, ptr, retval, "move.d"); \
	119	+ break; \
	120	+ case 8: \
	121	+ __put_user_asm_64(x, ptr, retval); \
	122	+ break; \
	123	+ default: \
	124	+ __put_user_bad(); \
117	125	} \
118	126	} while (0)
119	127
...	...	@@ -121,11 +129,20 @@
121	129	do { \
122	130	retval = 0; \
123	131	switch (size) { \
124		- case 1: __get_user_asm(x, ptr, retval, "move.b"); break; \
125		- case 2: __get_user_asm(x, ptr, retval, "move.w"); break; \
126		- case 4: __get_user_asm(x, ptr, retval, "move.d"); break; \
127		- case 8: __get_user_asm_64(x, ptr, retval); break; \
128		- default: (x) = __get_user_bad(); \
	132	+ case 1: \
	133	+ __get_user_asm(x, ptr, retval, "move.b"); \
	134	+ break; \
	135	+ case 2: \
	136	+ __get_user_asm(x, ptr, retval, "move.w"); \
	137	+ break; \
	138	+ case 4: \
	139	+ __get_user_asm(x, ptr, retval, "move.d"); \
	140	+ break; \
	141	+ case 8: \
	142	+ __get_user_asm_64(x, ptr, retval); \
	143	+ break; \
	144	+ default: \
	145	+ (x) = __get_user_bad(); \
129	146	} \
130	147	} while (0)
131	148
...	...	@@ -211,6 +228,7 @@
211	228	strncpy_from_user(char dst, const char __user src, long count)
212	229	{
213	230	long res = -EFAULT;
	231	+
214	232	if (access_ok(VERIFY_READ, src, 1))
215	233	res = __do_strncpy_from_user(dst, src, count);
216	234	return res;
...	...	@@ -224,6 +242,7 @@
224	242	__constant_copy_from_user(void to, const void __user from, unsigned long n)
225	243	{
226	244	unsigned long ret = 0;
	245	+
227	246	if (n == 0)
228	247	;
229	248	else if (n == 1)
...	...	@@ -274,6 +293,7 @@
274	293	__constant_copy_to_user(void __user to, const void from, unsigned long n)
275	294	{
276	295	unsigned long ret = 0;
	296	+
277	297	if (n == 0)
278	298	;
279	299	else if (n == 1)
...	...	@@ -324,6 +344,7 @@
324	344	__constant_clear_user(void __user *to, unsigned long n)
325	345	{
326	346	unsigned long ret = 0;
	347	+
327	348	if (n == 0)
328	349	;
329	350	else if (n == 1)
330	351
331	352
...	...	@@ -351,20 +372,20 @@
351	372	}
352	373
353	374
354		-#define clear_user(to, n) \
355		-(__builtin_constant_p(n) ? \
356		- __constant_clear_user(to, n) : \
357		- __generic_clear_user(to, n))
	375	+#define clear_user(to, n) \
	376	+ (__builtin_constant_p(n) ? \
	377	+ __constant_clear_user(to, n) : \
	378	+ __generic_clear_user(to, n))
358	379
359		-#define copy_from_user(to, from, n) \
360		-(__builtin_constant_p(n) ? \
361		- __constant_copy_from_user(to, from, n) : \
362		- __generic_copy_from_user(to, from, n))
	380	+#define copy_from_user(to, from, n) \
	381	+ (__builtin_constant_p(n) ? \
	382	+ __constant_copy_from_user(to, from, n) : \
	383	+ __generic_copy_from_user(to, from, n))
363	384
364		-#define copy_to_user(to, from, n) \
365		-(__builtin_constant_p(n) ? \
366		- __constant_copy_to_user(to, from, n) : \
367		- __generic_copy_to_user(to, from, n))
	385	+#define copy_to_user(to, from, n) \
	386	+ (__builtin_constant_p(n) ? \
	387	+ __constant_copy_to_user(to, from, n) : \
	388	+ __generic_copy_to_user(to, from, n))
368	389
369	390	/* We let the __ versions of copy_from/to_user inline, because they're often
370	391	* used in fast paths and have only a small space overhead.