1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __ASM_GENERIC_UACCESS_H
3 #define __ASM_GENERIC_UACCESS_H
4 
5 /*
6  * User space memory access functions, these should work
7  * on any machine that has kernel and user data in the same
8  * address space, e.g. all NOMMU machines.
9  */
10 #include <linux/string.h>
11 
12 #ifdef CONFIG_UACCESS_MEMCPY
13 #include <asm/unaligned.h>
14 
15 static __always_inline int
__get_user_fn(size_t size,const void __user * from,void * to)16 __get_user_fn(size_t size, const void __user *from, void *to)
17 {
18 	BUILD_BUG_ON(!__builtin_constant_p(size));
19 
20 	switch (size) {
21 	case 1:
22 		*(u8 *)to = *((u8 __force *)from);
23 		return 0;
24 	case 2:
25 		*(u16 *)to = get_unaligned((u16 __force *)from);
26 		return 0;
27 	case 4:
28 		*(u32 *)to = get_unaligned((u32 __force *)from);
29 		return 0;
30 	case 8:
31 		*(u64 *)to = get_unaligned((u64 __force *)from);
32 		return 0;
33 	default:
34 		BUILD_BUG();
35 		return 0;
36 	}
37 
38 }
39 #define __get_user_fn(sz, u, k)	__get_user_fn(sz, u, k)
40 
41 static __always_inline int
__put_user_fn(size_t size,void __user * to,void * from)42 __put_user_fn(size_t size, void __user *to, void *from)
43 {
44 	BUILD_BUG_ON(!__builtin_constant_p(size));
45 
46 	switch (size) {
47 	case 1:
48 		*(u8 __force *)to = *(u8 *)from;
49 		return 0;
50 	case 2:
51 		put_unaligned(*(u16 *)from, (u16 __force *)to);
52 		return 0;
53 	case 4:
54 		put_unaligned(*(u32 *)from, (u32 __force *)to);
55 		return 0;
56 	case 8:
57 		put_unaligned(*(u64 *)from, (u64 __force *)to);
58 		return 0;
59 	default:
60 		BUILD_BUG();
61 		return 0;
62 	}
63 }
64 #define __put_user_fn(sz, u, k)	__put_user_fn(sz, u, k)
65 
66 #define __get_kernel_nofault(dst, src, type, err_label)			\
67 do {									\
68 	*((type *)dst) = get_unaligned((type *)(src));			\
69 	if (0) /* make sure the label looks used to the compiler */	\
70 		goto err_label;						\
71 } while (0)
72 
73 #define __put_kernel_nofault(dst, src, type, err_label)			\
74 do {									\
75 	put_unaligned(*((type *)src), (type *)(dst));			\
76 	if (0) /* make sure the label looks used to the compiler */	\
77 		goto err_label;						\
78 } while (0)
79 
80 #define HAVE_GET_KERNEL_NOFAULT 1
81 
82 static inline __must_check unsigned long
raw_copy_from_user(void * to,const void __user * from,unsigned long n)83 raw_copy_from_user(void *to, const void __user * from, unsigned long n)
84 {
85 	memcpy(to, (const void __force *)from, n);
86 	return 0;
87 }
88 
89 static inline __must_check unsigned long
raw_copy_to_user(void __user * to,const void * from,unsigned long n)90 raw_copy_to_user(void __user *to, const void *from, unsigned long n)
91 {
92 	memcpy((void __force *)to, from, n);
93 	return 0;
94 }
95 #define INLINE_COPY_FROM_USER
96 #define INLINE_COPY_TO_USER
97 #endif /* CONFIG_UACCESS_MEMCPY */
98 
99 #ifdef CONFIG_SET_FS
100 #define MAKE_MM_SEG(s)	((mm_segment_t) { (s) })
101 
102 #ifndef KERNEL_DS
103 #define KERNEL_DS	MAKE_MM_SEG(~0UL)
104 #endif
105 
106 #ifndef USER_DS
107 #define USER_DS		MAKE_MM_SEG(TASK_SIZE - 1)
108 #endif
109 
110 #ifndef get_fs
111 #define get_fs()	(current_thread_info()->addr_limit)
112 
set_fs(mm_segment_t fs)113 static inline void set_fs(mm_segment_t fs)
114 {
115 	current_thread_info()->addr_limit = fs;
116 }
117 #endif
118 
119 #ifndef uaccess_kernel
120 #define uaccess_kernel() (get_fs().seg == KERNEL_DS.seg)
121 #endif
122 
123 #ifndef user_addr_max
124 #define user_addr_max() (uaccess_kernel() ? ~0UL : TASK_SIZE)
125 #endif
126 
127 #endif /* CONFIG_SET_FS */
128 
129 #define access_ok(addr, size) __access_ok((unsigned long)(addr),(size))
130 
131 /*
132  * The architecture should really override this if possible, at least
133  * doing a check on the get_fs()
134  */
135 #ifndef __access_ok
__access_ok(unsigned long addr,unsigned long size)136 static inline int __access_ok(unsigned long addr, unsigned long size)
137 {
138 	return 1;
139 }
140 #endif
141 
142 /*
143  * These are the main single-value transfer routines.  They automatically
144  * use the right size if we just have the right pointer type.
145  * This version just falls back to copy_{from,to}_user, which should
146  * provide a fast-path for small values.
147  */
148 #define __put_user(x, ptr) \
149 ({								\
150 	__typeof__(*(ptr)) __x = (x);				\
151 	int __pu_err = -EFAULT;					\
152         __chk_user_ptr(ptr);                                    \
153 	switch (sizeof (*(ptr))) {				\
154 	case 1:							\
155 	case 2:							\
156 	case 4:							\
157 	case 8:							\
158 		__pu_err = __put_user_fn(sizeof (*(ptr)),	\
159 					 ptr, &__x);		\
160 		break;						\
161 	default:						\
162 		__put_user_bad();				\
163 		break;						\
164 	 }							\
165 	__pu_err;						\
166 })
167 
168 #define put_user(x, ptr)					\
169 ({								\
170 	void __user *__p = (ptr);				\
171 	might_fault();						\
172 	access_ok(__p, sizeof(*ptr)) ?		\
173 		__put_user((x), ((__typeof__(*(ptr)) __user *)__p)) :	\
174 		-EFAULT;					\
175 })
176 
177 #ifndef __put_user_fn
178 
__put_user_fn(size_t size,void __user * ptr,void * x)179 static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
180 {
181 	return unlikely(raw_copy_to_user(ptr, x, size)) ? -EFAULT : 0;
182 }
183 
184 #define __put_user_fn(sz, u, k)	__put_user_fn(sz, u, k)
185 
186 #endif
187 
188 extern int __put_user_bad(void) __attribute__((noreturn));
189 
190 #define __get_user(x, ptr)					\
191 ({								\
192 	int __gu_err = -EFAULT;					\
193 	__chk_user_ptr(ptr);					\
194 	switch (sizeof(*(ptr))) {				\
195 	case 1: {						\
196 		unsigned char __x = 0;				\
197 		__gu_err = __get_user_fn(sizeof (*(ptr)),	\
198 					 ptr, &__x);		\
199 		(x) = *(__force __typeof__(*(ptr)) *) &__x;	\
200 		break;						\
201 	};							\
202 	case 2: {						\
203 		unsigned short __x = 0;				\
204 		__gu_err = __get_user_fn(sizeof (*(ptr)),	\
205 					 ptr, &__x);		\
206 		(x) = *(__force __typeof__(*(ptr)) *) &__x;	\
207 		break;						\
208 	};							\
209 	case 4: {						\
210 		unsigned int __x = 0;				\
211 		__gu_err = __get_user_fn(sizeof (*(ptr)),	\
212 					 ptr, &__x);		\
213 		(x) = *(__force __typeof__(*(ptr)) *) &__x;	\
214 		break;						\
215 	};							\
216 	case 8: {						\
217 		unsigned long long __x = 0;			\
218 		__gu_err = __get_user_fn(sizeof (*(ptr)),	\
219 					 ptr, &__x);		\
220 		(x) = *(__force __typeof__(*(ptr)) *) &__x;	\
221 		break;						\
222 	};							\
223 	default:						\
224 		__get_user_bad();				\
225 		break;						\
226 	}							\
227 	__gu_err;						\
228 })
229 
230 #define get_user(x, ptr)					\
231 ({								\
232 	const void __user *__p = (ptr);				\
233 	might_fault();						\
234 	access_ok(__p, sizeof(*ptr)) ?		\
235 		__get_user((x), (__typeof__(*(ptr)) __user *)__p) :\
236 		((x) = (__typeof__(*(ptr)))0,-EFAULT);		\
237 })
238 
239 #ifndef __get_user_fn
__get_user_fn(size_t size,const void __user * ptr,void * x)240 static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
241 {
242 	return unlikely(raw_copy_from_user(x, ptr, size)) ? -EFAULT : 0;
243 }
244 
245 #define __get_user_fn(sz, u, k)	__get_user_fn(sz, u, k)
246 
247 #endif
248 
249 extern int __get_user_bad(void) __attribute__((noreturn));
250 
251 /*
252  * Zero Userspace
253  */
254 #ifndef __clear_user
255 static inline __must_check unsigned long
__clear_user(void __user * to,unsigned long n)256 __clear_user(void __user *to, unsigned long n)
257 {
258 	memset((void __force *)to, 0, n);
259 	return 0;
260 }
261 #endif
262 
263 static inline __must_check unsigned long
clear_user(void __user * to,unsigned long n)264 clear_user(void __user *to, unsigned long n)
265 {
266 	might_fault();
267 	if (!access_ok(to, n))
268 		return n;
269 
270 	return __clear_user(to, n);
271 }
272 
273 #include <asm/extable.h>
274 
275 __must_check long strncpy_from_user(char *dst, const char __user *src,
276 				    long count);
277 __must_check long strnlen_user(const char __user *src, long n);
278 
279 #endif /* __ASM_GENERIC_UACCESS_H */
280