sh: Fix get_user()/put_user() build error.

Fixes the build error caused by -Werror on gcc 3.x compilers: arch/sh/kernel/signal_32.c: In function `sys_sigaction': arch/sh/kernel/signal_32.c:66: warning: initialization discards qualifiers from pointer target type arch/sh/kernel/signal_32.c:67: warning: initialization discards qualifiers from pointer target type arch/sh/kernel/signal_32.c:69: warning: initialization discards qualifiers from pointer target type arch/sh/kernel/signal_32.c:70: warning: initialization discards qualifiers from pointer target type The mismatch in question was introduced by commit-id 9c5a4eec79b3eb8876d2e7fddfa1e040a7650e55. Signed-off-by: Paul Mundt <lethal@linux-sh.org>

sh: Fix get_user()/put_user() build error.
Fixes the build error caused by -Werror on gcc 3.x compilers: arch/sh/kernel/signal_32.c: In function `sys_sigaction': arch/sh/kernel/signal_32.c:66: warning: initialization discards qualifiers from pointer target type arch/sh/kernel/signal_32.c:67: warning: initialization discards qualifiers from pointer target type arch/sh/kernel/signal_32.c:69: warning: initialization discards qualifiers from pointer target type arch/sh/kernel/signal_32.c:70: warning: initialization discards qualifiers from pointer target type The mismatch in question was introduced by commit-id 9c5a4eec79b3eb8876d2e7fddfa1e040a7650e55. Signed-off-by: Paul Mundt <lethal@linux-sh.org>
Paul Mundt
1 parent 31a49c4bf8
Showing 1 changed file with 28 additions and 36 deletions Side-by-side Diff
include/asm-sh/uaccess_32.h
@@ -95,11 +95,9 @@
 }
 #endif /* CONFIG_MMU */
  
-static inline int access_ok(int type, const void __user *p, unsigned long size)
-{
-	unsigned long addr = (unsigned long)p;
-	return __access_ok(addr, size);
-}
+#define access_ok(type, addr, size)	\
+	(__chk_user_ptr(addr),		\
+	 __access_ok((unsigned long __force)(addr), (size)))
  
 /*
  * Uh, these should become the main single-value transfer routines ...
  
@@ -113,18 +111,16 @@
  * (a) re-use the arguments for side effects (sizeof is ok)
  * (b) require any knowledge of processes at this stage
  */
-#define put_user(x,ptr)	__put_user_check((x),(ptr),sizeof(*(ptr)))
-#define get_user(x,ptr) __get_user_check((x),(ptr),sizeof(*(ptr)))
+#define put_user(x,ptr)		__put_user_check((x), (ptr), sizeof(*(ptr)))
+#define get_user(x,ptr)		__get_user_check((x), (ptr), sizeof(*(ptr)))
  
 /*
  * The "__xxx" versions do not do address space checking, useful when
  * doing multiple accesses to the same area (the user has to do the
  * checks by hand with "access_ok()")
  */
-#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((x), (ptr), sizeof(*(ptr)))
+#define __get_user(x,ptr)	__get_user_nocheck((x), (ptr), sizeof(*(ptr)))
  
 struct __large_struct { unsigned long buf[100]; };
 #define __m(x) (*(struct __large_struct __user *)(x))
@@ -132,7 +128,6 @@
 #define __get_user_size(x,ptr,size,retval)			\
 do {								\
 	retval = 0;						\
-	__chk_user_ptr(ptr);					\
 	switch (size) {						\
 	case 1:							\
 		__get_user_asm(x, ptr, retval, "b");		\
  
@@ -151,24 +146,22 @@
  
 #define __get_user_nocheck(x,ptr,size)				\
 ({								\
-	long __gu_err, __gu_val;				\
-	__typeof__(*(ptr)) *__pu_addr = (ptr);  \
-	__get_user_size(__gu_val, (__pu_addr), (size), __gu_err);	\
+	long __gu_err;						\
+	unsigned long __gu_val;					\
+	const __typeof__(*(ptr)) __user *__gu_addr = (ptr);	\
+	__chk_user_ptr(ptr);					\
+	__get_user_size(__gu_val, __gu_addr, (size), __gu_err);	\
 	(x) = (__typeof__(*(ptr)))__gu_val;			\
 	__gu_err;						\
 })
  
 #define __get_user_check(x,ptr,size)					\
 ({									\
-	long __gu_err, __gu_val;					\
-	__typeof__(*(ptr)) *__pu_addr = (ptr);				\
-	__chk_user_ptr(__pu_addr);					\
-	if (likely(__addr_ok((unsigned long)(__pu_addr)))) {		\
-		__get_user_size(__gu_val, (__pu_addr), (size), __gu_err);\
-	} else {							\
-		__gu_err = -EFAULT;					\
-		__gu_val = 0;						\
-	}								\
+	long __gu_err = -EFAULT;					\
+	unsigned long __gu_val = 0;					\
+	const __typeof__(*(ptr)) *__gu_addr = (ptr);			\
+	if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))		\
+		__get_user_size(__gu_val, __gu_addr, (size), __gu_err);	\
 	(x) = (__typeof__(*(ptr)))__gu_val;				\
 	__gu_err;							\
 })
@@ -199,7 +192,6 @@
 #define __put_user_size(x,ptr,size,retval)		\
 do {							\
 	retval = 0;					\
-	__chk_user_ptr(ptr);				\
 	switch (size) {					\
 	case 1:						\
 		__put_user_asm(x, ptr, retval, "b");	\
  
  
@@ -218,22 +210,22 @@
 	}						\
 } while (0)
  
-#define __put_user_nocheck(x,ptr,size)			\
-({							\
-	long __pu_err;					\
-	__put_user_size((x),(ptr),(size),__pu_err);	\
-	__pu_err;					\
+#define __put_user_nocheck(x,ptr,size)				\
+({								\
+	long __pu_err;						\
+	__typeof__(*(ptr)) __user *__pu_addr = (ptr);		\
+	__chk_user_ptr(ptr);					\
+	__put_user_size((x), __pu_addr, (size), __pu_err);	\
+	__pu_err;						\
 })
  
 #define __put_user_check(x,ptr,size)				\
 ({								\
-	long __pu_err;						\
+	long __pu_err = -EFAULT;				\
 	__typeof__(*(ptr)) __user *__pu_addr = (ptr);		\
-								\
-	if (likely(__addr_ok((unsigned long)__pu_addr)))	\
-		__put_user_size((x),__pu_addr,(size),__pu_err);	\
-	else							\
-		__pu_err = -EFAULT;				\
+	if (likely(access_ok(VERIFY_WRITE, __pu_addr, size)))	\
+		__put_user_size((x), __pu_addr, (size),		\
+				__pu_err);			\
 	__pu_err;						\
 })
...	...	@@ -95,11 +95,9 @@
95	95	}
96	96	#endif /* CONFIG_MMU */
97	97
98		-static inline int access_ok(int type, const void __user *p, unsigned long size)
99		-{
100		- unsigned long addr = (unsigned long)p;
101		- return __access_ok(addr, size);
102		-}
	98	+#define access_ok(type, addr, size) \
	99	+ (__chk_user_ptr(addr), \
	100	+ __access_ok((unsigned long __force)(addr), (size)))
103	101
104	102	/*
105	103	* Uh, these should become the main single-value transfer routines ...
106	104
...	...	@@ -113,18 +111,16 @@
113	111	* (a) re-use the arguments for side effects (sizeof is ok)
114	112	* (b) require any knowledge of processes at this stage
115	113	*/
116		-#define put_user(x,ptr) __put_user_check((x),(ptr),sizeof(*(ptr)))
117		-#define get_user(x,ptr) __get_user_check((x),(ptr),sizeof(*(ptr)))
	114	+#define put_user(x,ptr) __put_user_check((x), (ptr), sizeof(*(ptr)))
	115	+#define get_user(x,ptr) __get_user_check((x), (ptr), sizeof(*(ptr)))
118	116
119	117	/*
120	118	* The "__xxx" versions do not do address space checking, useful when
121	119	* doing multiple accesses to the same area (the user has to do the
122	120	* checks by hand with "access_ok()")
123	121	*/
124		-#define __put_user(x,ptr) \
125		- __put_user_nocheck((__typeof__((ptr)))(x),(ptr),sizeof((ptr)))
126		-#define __get_user(x,ptr) \
127		- __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
	122	+#define __put_user(x,ptr) __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
	123	+#define __get_user(x,ptr) __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
128	124
129	125	struct __large_struct { unsigned long buf[100]; };
130	126	#define __m(x) ((struct __large_struct __user )(x))
...	...	@@ -132,7 +128,6 @@
132	128	#define __get_user_size(x,ptr,size,retval) \
133	129	do { \
134	130	retval = 0; \
135		- __chk_user_ptr(ptr); \
136	131	switch (size) { \
137	132	case 1: \
138	133	__get_user_asm(x, ptr, retval, "b"); \
139	134
...	...	@@ -151,24 +146,22 @@
151	146
152	147	#define __get_user_nocheck(x,ptr,size) \
153	148	({ \
154		- long __gu_err, __gu_val; \
155		- __typeof__((ptr)) __pu_addr = (ptr); \
156		- __get_user_size(__gu_val, (__pu_addr), (size), __gu_err); \
	149	+ long __gu_err; \
	150	+ unsigned long __gu_val; \
	151	+ const __typeof__((ptr)) __user __gu_addr = (ptr); \
	152	+ __chk_user_ptr(ptr); \
	153	+ __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
157	154	(x) = (__typeof__(*(ptr)))__gu_val; \
158	155	__gu_err; \
159	156	})
160	157
161	158	#define __get_user_check(x,ptr,size) \
162	159	({ \
163		- long __gu_err, __gu_val; \
164		- __typeof__((ptr)) __pu_addr = (ptr); \
165		- __chk_user_ptr(__pu_addr); \
166		- if (likely(__addr_ok((unsigned long)(__pu_addr)))) { \
167		- __get_user_size(__gu_val, (__pu_addr), (size), __gu_err);\
168		- } else { \
169		- __gu_err = -EFAULT; \
170		- __gu_val = 0; \
171		- } \
	160	+ long __gu_err = -EFAULT; \
	161	+ unsigned long __gu_val = 0; \
	162	+ const __typeof__((ptr)) __gu_addr = (ptr); \
	163	+ if (likely(access_ok(VERIFY_READ, __gu_addr, (size)))) \
	164	+ __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
172	165	(x) = (__typeof__(*(ptr)))__gu_val; \
173	166	__gu_err; \
174	167	})
...	...	@@ -199,7 +192,6 @@
199	192	#define __put_user_size(x,ptr,size,retval) \
200	193	do { \
201	194	retval = 0; \
202		- __chk_user_ptr(ptr); \
203	195	switch (size) { \
204	196	case 1: \
205	197	__put_user_asm(x, ptr, retval, "b"); \
206	198
207	199
...	...	@@ -218,22 +210,22 @@
218	210	} \
219	211	} while (0)
220	212
221		-#define __put_user_nocheck(x,ptr,size) \
222		-({ \
223		- long __pu_err; \
224		- __put_user_size((x),(ptr),(size),__pu_err); \
225		- __pu_err; \
	213	+#define __put_user_nocheck(x,ptr,size) \
	214	+({ \
	215	+ long __pu_err; \
	216	+ __typeof__((ptr)) __user __pu_addr = (ptr); \
	217	+ __chk_user_ptr(ptr); \
	218	+ __put_user_size((x), __pu_addr, (size), __pu_err); \
	219	+ __pu_err; \
226	220	})
227	221
228	222	#define __put_user_check(x,ptr,size) \
229	223	({ \
230		- long __pu_err; \
	224	+ long __pu_err = -EFAULT; \
231	225	__typeof__((ptr)) __user __pu_addr = (ptr); \
232		- \
233		- if (likely(__addr_ok((unsigned long)__pu_addr))) \
234		- __put_user_size((x),__pu_addr,(size),__pu_err); \
235		- else \
236		- __pu_err = -EFAULT; \
	226	+ if (likely(access_ok(VERIFY_WRITE, __pu_addr, size))) \
	227	+ __put_user_size((x), __pu_addr, (size), \
	228	+ __pu_err); \
237	229	__pu_err; \
238	230	})
239	231