kernel_5.10 no rt

hc

2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f

 kernel/arch/openrisc/include/asm/uaccess.h
..
..
@@ -1,3 +1,4 @@
1
+/* SPDX-License-Identifier: GPL-2.0-or-later */
1
2
 /*
2
3
  * OpenRISC Linux
3
4
  *
..
..
@@ -9,11 +10,6 @@
9
10
  * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com>
10
11
  * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
11
12
  * et al.
12
- *
13
- * This program is free software; you can redistribute it and/or modify
14
- * it under the terms of the GNU General Public License as published by
15
- * the Free Software Foundation; either version 2 of the License, or
16
- * (at your option) any later version.
17
13
  */
18
14
 
19
15
 #ifndef __ASM_OPENRISC_UACCESS_H
..
..
@@ -42,27 +38,27 @@
42
38
  */
43
39
 
44
40
 #define KERNEL_DS	(~0UL)
45
-#define get_ds()	(KERNEL_DS)
46
41
 
47
42
 #define USER_DS		(TASK_SIZE)
48
43
 #define get_fs()	(current_thread_info()->addr_limit)
49
44
 #define set_fs(x)	(current_thread_info()->addr_limit = (x))
50
45
 
51
-#define segment_eq(a, b)	((a) == (b))
46
+#define uaccess_kernel()	(get_fs() == KERNEL_DS)
52
47
 
53
48
 /* Ensure that the range from addr to addr+size is all within the process'
54
49
  * address space
55
50
  */
56
-#define __range_ok(addr, size) (size <= get_fs() && addr <= (get_fs()-size))
51
+static inline int __range_ok(unsigned long addr, unsigned long size)
52
+{
53
+	const mm_segment_t fs = get_fs();
57
54
 
58
-/* Ensure that addr is below task's addr_limit */
59
-#define __addr_ok(addr) ((unsigned long) addr < get_fs())
55
+	return size <= fs && addr <= (fs - size);
56
+}
60
57
 
61
-#define access_ok(type, addr, size)						\
58
+#define access_ok(addr, size)						\
62
59
 ({ 									\
63
-	unsigned long __ao_addr = (unsigned long)(addr);		\
64
-	unsigned long __ao_size = (unsigned long)(size);		\
65
-	__range_ok(__ao_addr, __ao_size);				\
60
+	__chk_user_ptr(addr);						\
61
+	__range_ok((unsigned long)(addr), (size));			\
66
62
 })
67
63
 
68
64
 /*
..
..
@@ -105,8 +101,8 @@
105
101
 #define __put_user_check(x, ptr, size)					\
106
102
 ({									\
107
103
 	long __pu_err = -EFAULT;					\
108
-	__typeof__(*(ptr)) *__pu_addr = (ptr);				\
109
-	if (access_ok(VERIFY_WRITE, __pu_addr, size))			\
104
+	__typeof__(*(ptr)) __user *__pu_addr = (ptr);			\
105
+	if (access_ok(__pu_addr, size))			\
110
106
 		__put_user_size((x), __pu_addr, (size), __pu_err);	\
111
107
 	__pu_err;							\
112
108
 })
..
..
@@ -169,19 +165,19 @@
169
165
 
170
166
 #define __get_user_nocheck(x, ptr, size)			\
171
167
 ({								\
172
-	long __gu_err, __gu_val;				\
173
-	__get_user_size(__gu_val, (ptr), (size), __gu_err);	\
174
-	(x) = (__force __typeof__(*(ptr)))__gu_val;		\
168
+	long __gu_err;						\
169
+	__get_user_size((x), (ptr), (size), __gu_err);		\
175
170
 	__gu_err;						\
176
171
 })
177
172
 
178
173
 #define __get_user_check(x, ptr, size)					\
179
174
 ({									\
180
-	long __gu_err = -EFAULT, __gu_val = 0;				\
181
-	const __typeof__(*(ptr)) * __gu_addr = (ptr);			\
182
-	if (access_ok(VERIFY_READ, __gu_addr, size))			\
183
-		__get_user_size(__gu_val, __gu_addr, (size), __gu_err);	\
184
-	(x) = (__force __typeof__(*(ptr)))__gu_val;			\
175
+	long __gu_err = -EFAULT;					\
176
+	const __typeof__(*(ptr)) __user *__gu_addr = (ptr);		\
177
+	if (access_ok(__gu_addr, size))					\
178
+		__get_user_size((x), __gu_addr, (size), __gu_err);	\
179
+	else								\
180
+		(x) = (__typeof__(*(ptr))) 0;				\
185
181
 	__gu_err;							\
186
182
 })
187
183
 
..
..
@@ -195,11 +191,13 @@
195
191
 	case 2: __get_user_asm(x, ptr, retval, "l.lhz"); break;		\
196
192
 	case 4: __get_user_asm(x, ptr, retval, "l.lwz"); break;		\
197
193
 	case 8: __get_user_asm2(x, ptr, retval); break;			\
198
-	default: (x) = __get_user_bad();				\
194
+	default: (x) = (__typeof__(*(ptr)))__get_user_bad();		\
199
195
 	}								\
200
196
 } while (0)
201
197
 
202
198
 #define __get_user_asm(x, addr, err, op)		\
199
+{							\
200
+	unsigned long __gu_tmp;				\
203
201
 	__asm__ __volatile__(				\
204
202
 		"1:	"op" %1,0(%2)\n"		\
205
203
 		"2:\n"					\
..
..
@@ -213,10 +211,14 @@
213
211
 		"	.align 2\n"			\
214
212
 		"	.long 1b,3b\n"			\
215
213
 		".previous"				\
216
-		: "=r"(err), "=r"(x)			\
217
-		: "r"(addr), "i"(-EFAULT), "0"(err))
214
+		: "=r"(err), "=r"(__gu_tmp)		\
215
+		: "r"(addr), "i"(-EFAULT), "0"(err));	\
216
+	(x) = (__typeof__(*(addr)))__gu_tmp;		\
217
+}
218
218
 
219
219
 #define __get_user_asm2(x, addr, err)			\
220
+{							\
221
+	unsigned long long __gu_tmp;			\
220
222
 	__asm__ __volatile__(				\
221
223
 		"1:	l.lwz %1,0(%2)\n"		\
222
224
 		"2:	l.lwz %H1,4(%2)\n"		\
..
..
@@ -233,8 +235,11 @@
233
235
 		"	.long 1b,4b\n"			\
234
236
 		"	.long 2b,4b\n"			\
235
237
 		".previous"				\
236
-		: "=r"(err), "=&r"(x)			\
237
-		: "r"(addr), "i"(-EFAULT), "0"(err))
238
+		: "=r"(err), "=&r"(__gu_tmp)		\
239
+		: "r"(addr), "i"(-EFAULT), "0"(err));	\
240
+	(x) = (__typeof__(*(addr)))(			\
241
+		(__typeof__((x)-(x)))__gu_tmp);		\
242
+}
238
243
 
239
244
 /* more complex routines */
240
245
 
..
..
@@ -246,19 +251,19 @@
246
251
 	return __copy_tofrom_user(to, (__force const void *)from, size);
247
252
 }
248
253
 static inline unsigned long
249
-raw_copy_to_user(void *to, const void __user *from, unsigned long size)
254
+raw_copy_to_user(void __user *to, const void *from, unsigned long size)
250
255
 {
251
256
 	return __copy_tofrom_user((__force void *)to, from, size);
252
257
 }
253
258
 #define INLINE_COPY_FROM_USER
254
259
 #define INLINE_COPY_TO_USER
255
260
 
256
-extern unsigned long __clear_user(void *addr, unsigned long size);
261
+extern unsigned long __clear_user(void __user *addr, unsigned long size);
257
262
 
258
263
 static inline __must_check unsigned long
259
-clear_user(void *addr, unsigned long size)
264
+clear_user(void __user *addr, unsigned long size)
260
265
 {
261
-	if (likely(access_ok(VERIFY_WRITE, addr, size)))
266
+	if (likely(access_ok(addr, size)))
262
267
 		size = __clear_user(addr, size);
263
268
 	return size;
264
269
 }