1/*
  2 * uaccess.h: User space memore access functions.
  3 *
  4 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
  5 * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  6 */
  7#ifndef _ASM_UACCESS_H
  8#define _ASM_UACCESS_H
  9
 10#ifdef __KERNEL__
 11#include <linux/compiler.h>
 12#include <linux/sched.h>
 13#include <linux/string.h>
 14#include <linux/errno.h>
 15#include <asm/vac-ops.h>
 16#endif
 17
 18#ifndef __ASSEMBLY__
 19
 20#define ARCH_HAS_SORT_EXTABLE
 21#define ARCH_HAS_SEARCH_EXTABLE
 22
 23/* Sparc is not segmented, however we need to be able to fool access_ok()
 24 * when doing system calls from kernel mode legitimately.
 25 *
 26 * "For historical reasons, these macros are grossly misnamed." -Linus
 27 */
 28
 29#define KERNEL_DS   ((mm_segment_t) { 0 })
 30#define USER_DS     ((mm_segment_t) { -1 })
 31
 32#define VERIFY_READ	0
 33#define VERIFY_WRITE	1
 34
 35#define get_ds()	(KERNEL_DS)
 36#define get_fs()	(current->thread.current_ds)
 37#define set_fs(val)	((current->thread.current_ds) = (val))
 38
 39#define segment_eq(a,b)	((a).seg == (b).seg)
 40
 41/* We have there a nice not-mapped page at PAGE_OFFSET - PAGE_SIZE, so that this test
 42 * can be fairly lightweight.
 43 * No one can read/write anything from userland in the kernel space by setting
 44 * large size and address near to PAGE_OFFSET - a fault will break his intentions.
 45 */
 46#define __user_ok(addr, size) ({ (void)(size); (addr) < STACK_TOP; })
 47#define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
 48#define __access_ok(addr,size) (__user_ok((addr) & get_fs().seg,(size)))
 49#define access_ok(type, addr, size)					\
 50	({ (void)(type); __access_ok((unsigned long)(addr), size); })
 51
 52/*
 53 * The exception table consists of pairs of addresses: the first is the
 54 * address of an instruction that is allowed to fault, and the second is
 55 * the address at which the program should continue.  No registers are
 56 * modified, so it is entirely up to the continuation code to figure out
 57 * what to do.
 58 *
 59 * All the routines below use bits of fixup code that are out of line
 60 * with the main instruction path.  This means when everything is well,
 61 * we don't even have to jump over them.  Further, they do not intrude
 62 * on our cache or tlb entries.
 63 *
 64 * There is a special way how to put a range of potentially faulting
 65 * insns (like twenty ldd/std's with now intervening other instructions)
 66 * You specify address of first in insn and 0 in fixup and in the next
 67 * exception_table_entry you specify last potentially faulting insn + 1
 68 * and in fixup the routine which should handle the fault.
 69 * That fixup code will get
 70 * (faulting_insn_address - first_insn_in_the_range_address)/4
 71 * in %g2 (ie. index of the faulting instruction in the range).
 72 */
 73
 74struct exception_table_entry
 75{
 76        unsigned long insn, fixup;
 77};
 78
 79/* Returns 0 if exception not found and fixup otherwise.  */
 80extern unsigned long search_extables_range(unsigned long addr, unsigned long *g2);
 81
 82extern void __ret_efault(void);
 83
 84/* Uh, these should become the main single-value transfer routines..
 85 * They automatically use the right size if we just have the right
 86 * pointer type..
 87 *
 88 * This gets kind of ugly. We want to return _two_ values in "get_user()"
 89 * and yet we don't want to do any pointers, because that is too much
 90 * of a performance impact. Thus we have a few rather ugly macros here,
 91 * and hide all the ugliness from the user.
 92 */
 93#define put_user(x,ptr) ({ \
 94unsigned long __pu_addr = (unsigned long)(ptr); \
 95__chk_user_ptr(ptr); \
 96__put_user_check((__typeof__(*(ptr)))(x),__pu_addr,sizeof(*(ptr))); })
 97
 98#define get_user(x,ptr) ({ \
 99unsigned long __gu_addr = (unsigned long)(ptr); \
100__chk_user_ptr(ptr); \
101__get_user_check((x),__gu_addr,sizeof(*(ptr)),__typeof__(*(ptr))); })
 
 
102
103/*
104 * The "__xxx" versions do not do address space checking, useful when
105 * doing multiple accesses to the same area (the user has to do the
106 * checks by hand with "access_ok()")
107 */
108#define __put_user(x,ptr) __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
109#define __get_user(x,ptr) __get_user_nocheck((x),(ptr),sizeof(*(ptr)),__typeof__(*(ptr)))
 
 
110
111struct __large_struct { unsigned long buf[100]; };
112#define __m(x) ((struct __large_struct __user *)(x))
113
114#define __put_user_check(x,addr,size) ({ \
115register int __pu_ret; \
116if (__access_ok(addr,size)) { \
117switch (size) { \
118case 1: __put_user_asm(x,b,addr,__pu_ret); break; \
119case 2: __put_user_asm(x,h,addr,__pu_ret); break; \
120case 4: __put_user_asm(x,,addr,__pu_ret); break; \
121case 8: __put_user_asm(x,d,addr,__pu_ret); break; \
122default: __pu_ret = __put_user_bad(); break; \
123} } else { __pu_ret = -EFAULT; } __pu_ret; })
124
125#define __put_user_nocheck(x,addr,size) ({ \
126register int __pu_ret; \
127switch (size) { \
128case 1: __put_user_asm(x,b,addr,__pu_ret); break; \
129case 2: __put_user_asm(x,h,addr,__pu_ret); break; \
130case 4: __put_user_asm(x,,addr,__pu_ret); break; \
131case 8: __put_user_asm(x,d,addr,__pu_ret); break; \
132default: __pu_ret = __put_user_bad(); break; \
133} __pu_ret; })
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
134
135#define __put_user_asm(x,size,addr,ret)					\
136__asm__ __volatile__(							\
137	"/* Put user asm, inline. */\n"					\
138"1:\t"	"st"#size " %1, %2\n\t"						\
139	"clr	%0\n"							\
140"2:\n\n\t"								\
141	".section .fixup,#alloc,#execinstr\n\t"				\
142	".align	4\n"							\
143"3:\n\t"								\
144	"b	2b\n\t"							\
145	" mov	%3, %0\n\t"						\
146        ".previous\n\n\t"						\
147	".section __ex_table,#alloc\n\t"				\
148	".align	4\n\t"							\
149	".word	1b, 3b\n\t"						\
150	".previous\n\n\t"						\
151       : "=&r" (ret) : "r" (x), "m" (*__m(addr)),			\
152	 "i" (-EFAULT))
153
154extern int __put_user_bad(void);
155
156#define __get_user_check(x,addr,size,type) ({ \
157register int __gu_ret; \
158register unsigned long __gu_val; \
159if (__access_ok(addr,size)) { \
160switch (size) { \
161case 1: __get_user_asm(__gu_val,ub,addr,__gu_ret); break; \
162case 2: __get_user_asm(__gu_val,uh,addr,__gu_ret); break; \
163case 4: __get_user_asm(__gu_val,,addr,__gu_ret); break; \
164case 8: __get_user_asm(__gu_val,d,addr,__gu_ret); break; \
165default: __gu_val = 0; __gu_ret = __get_user_bad(); break; \
166} } else { __gu_val = 0; __gu_ret = -EFAULT; } x = (type) __gu_val; __gu_ret; })
167
168#define __get_user_check_ret(x,addr,size,type,retval) ({ \
169register unsigned long __gu_val __asm__ ("l1"); \
170if (__access_ok(addr,size)) { \
171switch (size) { \
172case 1: __get_user_asm_ret(__gu_val,ub,addr,retval); break; \
173case 2: __get_user_asm_ret(__gu_val,uh,addr,retval); break; \
174case 4: __get_user_asm_ret(__gu_val,,addr,retval); break; \
175case 8: __get_user_asm_ret(__gu_val,d,addr,retval); break; \
176default: if (__get_user_bad()) return retval; \
177} x = (type) __gu_val; } else return retval; })
178
179#define __get_user_nocheck(x,addr,size,type) ({ \
180register int __gu_ret; \
181register unsigned long __gu_val; \
182switch (size) { \
183case 1: __get_user_asm(__gu_val,ub,addr,__gu_ret); break; \
184case 2: __get_user_asm(__gu_val,uh,addr,__gu_ret); break; \
185case 4: __get_user_asm(__gu_val,,addr,__gu_ret); break; \
186case 8: __get_user_asm(__gu_val,d,addr,__gu_ret); break; \
187default: __gu_val = 0; __gu_ret = __get_user_bad(); break; \
188} x = (type) __gu_val; __gu_ret; })
189
190#define __get_user_nocheck_ret(x,addr,size,type,retval) ({ \
191register unsigned long __gu_val __asm__ ("l1"); \
192switch (size) { \
193case 1: __get_user_asm_ret(__gu_val,ub,addr,retval); break; \
194case 2: __get_user_asm_ret(__gu_val,uh,addr,retval); break; \
195case 4: __get_user_asm_ret(__gu_val,,addr,retval); break; \
196case 8: __get_user_asm_ret(__gu_val,d,addr,retval); break; \
197default: if (__get_user_bad()) return retval; \
198} x = (type) __gu_val; })
 
 
 
199
200#define __get_user_asm(x,size,addr,ret)					\
201__asm__ __volatile__(							\
202	"/* Get user asm, inline. */\n"					\
203"1:\t"	"ld"#size " %2, %1\n\t"						\
204	"clr	%0\n"							\
205"2:\n\n\t"								\
206	".section .fixup,#alloc,#execinstr\n\t"				\
207	".align	4\n"							\
208"3:\n\t"								\
209	"clr	%1\n\t"							\
210	"b	2b\n\t"							\
211	" mov	%3, %0\n\n\t"						\
212	".previous\n\t"							\
213	".section __ex_table,#alloc\n\t"				\
214	".align	4\n\t"							\
215	".word	1b, 3b\n\n\t"						\
216	".previous\n\t"							\
217       : "=&r" (ret), "=&r" (x) : "m" (*__m(addr)),			\
218	 "i" (-EFAULT))
219
220#define __get_user_asm_ret(x,size,addr,retval)				\
221if (__builtin_constant_p(retval) && retval == -EFAULT)			\
222__asm__ __volatile__(							\
223	"/* Get user asm ret, inline. */\n"				\
224"1:\t"	"ld"#size " %1, %0\n\n\t"					\
225	".section __ex_table,#alloc\n\t"				\
226	".align	4\n\t"							\
227	".word	1b,__ret_efault\n\n\t"					\
228	".previous\n\t"							\
229       : "=&r" (x) : "m" (*__m(addr)));					\
230else									\
231__asm__ __volatile__(							\
232	"/* Get user asm ret, inline. */\n"				\
233"1:\t"	"ld"#size " %1, %0\n\n\t"					\
234	".section .fixup,#alloc,#execinstr\n\t"				\
235	".align	4\n"							\
236"3:\n\t"								\
237	"ret\n\t"							\
238	" restore %%g0, %2, %%o0\n\n\t"					\
239	".previous\n\t"							\
240	".section __ex_table,#alloc\n\t"				\
241	".align	4\n\t"							\
242	".word	1b, 3b\n\n\t"						\
243	".previous\n\t"							\
244       : "=&r" (x) : "m" (*__m(addr)), "i" (retval))
245
246extern int __get_user_bad(void);
247
248extern unsigned long __copy_user(void __user *to, const void __user *from, unsigned long size);
249
250static inline unsigned long copy_to_user(void __user *to, const void *from, unsigned long n)
251{
252	if (n && __access_ok((unsigned long) to, n))
253		return __copy_user(to, (__force void __user *) from, n);
254	else
255		return n;
256}
257
258static inline unsigned long __copy_to_user(void __user *to, const void *from, unsigned long n)
259{
260	return __copy_user(to, (__force void __user *) from, n);
261}
262
263static inline unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)
264{
265	if (n && __access_ok((unsigned long) from, n))
266		return __copy_user((__force void __user *) to, from, n);
267	else
268		return n;
269}
270
271static inline unsigned long __copy_from_user(void *to, const void __user *from, unsigned long n)
272{
273	return __copy_user((__force void __user *) to, from, n);
274}
275
276#define __copy_to_user_inatomic __copy_to_user
277#define __copy_from_user_inatomic __copy_from_user
278
279static inline unsigned long __clear_user(void __user *addr, unsigned long size)
280{
281	unsigned long ret;
282
283	__asm__ __volatile__ (
284		".section __ex_table,#alloc\n\t"
285		".align 4\n\t"
286		".word 1f,3\n\t"
287		".previous\n\t"
288		"mov %2, %%o1\n"
289		"1:\n\t"
290		"call __bzero\n\t"
291		" mov %1, %%o0\n\t"
292		"mov %%o0, %0\n"
293		: "=r" (ret) : "r" (addr), "r" (size) :
294		"o0", "o1", "o2", "o3", "o4", "o5", "o7",
295		"g1", "g2", "g3", "g4", "g5", "g7", "cc");
296
297	return ret;
298}
299
300static inline unsigned long clear_user(void __user *addr, unsigned long n)
301{
302	if (n && __access_ok((unsigned long) addr, n))
303		return __clear_user(addr, n);
304	else
305		return n;
306}
307
308extern long __strncpy_from_user(char *dest, const char __user *src, long count);
309
310static inline long strncpy_from_user(char *dest, const char __user *src, long count)
311{
312	if (__access_ok((unsigned long) src, count))
313		return __strncpy_from_user(dest, src, count);
314	else
315		return -EFAULT;
316}
317
318extern long __strlen_user(const char __user *);
319extern long __strnlen_user(const char __user *, long len);
320
321static inline long strlen_user(const char __user *str)
322{
323	if (!access_ok(VERIFY_READ, str, 0))
324		return 0;
325	else
326		return __strlen_user(str);
327}
328
329static inline long strnlen_user(const char __user *str, long len)
330{
331	if (!access_ok(VERIFY_READ, str, 0))
332		return 0;
333	else
334		return __strnlen_user(str, len);
335}
336
337#endif  /* __ASSEMBLY__ */
338
339#endif /* _ASM_UACCESS_H */

  1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 * uaccess.h: User space memore access functions.
  4 *
  5 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
  6 * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  7 */
  8#ifndef _ASM_UACCESS_H
  9#define _ASM_UACCESS_H
 10
 
 11#include <linux/compiler.h>
 
 12#include <linux/string.h>
 
 
 
 13
 14#include <asm/processor.h>
 15#include <asm-generic/access_ok.h>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 16
 17/* Uh, these should become the main single-value transfer routines..
 18 * They automatically use the right size if we just have the right
 19 * pointer type..
 20 *
 21 * This gets kind of ugly. We want to return _two_ values in "get_user()"
 22 * and yet we don't want to do any pointers, because that is too much
 23 * of a performance impact. Thus we have a few rather ugly macros here,
 24 * and hide all the ugliness from the user.
 25 */
 26#define put_user(x, ptr) ({ \
 27	void __user *__pu_addr = (ptr); \
 28	__chk_user_ptr(ptr); \
 29	__put_user_check((__typeof__(*(ptr)))(x), __pu_addr, sizeof(*(ptr))); \
 30})
 31
 32#define get_user(x, ptr) ({ \
 33	const void __user *__gu_addr = (ptr); \
 34	__chk_user_ptr(ptr); \
 35	__get_user_check((x), __gu_addr, sizeof(*(ptr)), __typeof__(*(ptr))); \
 36})
 37
 38/*
 39 * The "__xxx" versions do not do address space checking, useful when
 40 * doing multiple accesses to the same area (the user has to do the
 41 * checks by hand with "access_ok()")
 42 */
 43#define __put_user(x, ptr) \
 44	__put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
 45#define __get_user(x, ptr) \
 46    __get_user_nocheck((x), (ptr), sizeof(*(ptr)), __typeof__(*(ptr)))
 47
 48struct __large_struct { unsigned long buf[100]; };
 49#define __m(x) ((struct __large_struct __user *)(x))
 50
 51#define __put_user_check(x, addr, size) ({ \
 52	register int __pu_ret; \
 53	if (__access_ok(addr, size)) { \
 54		switch (size) { \
 55		case 1: \
 56			__put_user_asm(x, b, addr, __pu_ret); \
 57			break; \
 58		case 2: \
 59			__put_user_asm(x, h, addr, __pu_ret); \
 60			break; \
 61		case 4: \
 62			__put_user_asm(x, , addr, __pu_ret); \
 63			break; \
 64		case 8: \
 65			__put_user_asm(x, d, addr, __pu_ret); \
 66			break; \
 67		default: \
 68			__pu_ret = __put_user_bad(); \
 69			break; \
 70		} \
 71	} else { \
 72		__pu_ret = -EFAULT; \
 73	} \
 74	__pu_ret; \
 75})
 76
 77#define __put_user_nocheck(x, addr, size) ({			\
 78	register int __pu_ret;					\
 79	switch (size) {						\
 80	case 1: __put_user_asm(x, b, addr, __pu_ret); break;	\
 81	case 2: __put_user_asm(x, h, addr, __pu_ret); break;	\
 82	case 4: __put_user_asm(x, , addr, __pu_ret); break;	\
 83	case 8: __put_user_asm(x, d, addr, __pu_ret); break;	\
 84	default: __pu_ret = __put_user_bad(); break;		\
 85	} \
 86	__pu_ret; \
 87})
 88
 89#define __put_user_asm(x, size, addr, ret)				\
 90__asm__ __volatile__(							\
 91		"/* Put user asm, inline. */\n"				\
 92	"1:\t"	"st"#size " %1, %2\n\t"					\
 93		"clr	%0\n"						\
 94	"2:\n\n\t"							\
 95		".section .fixup,#alloc,#execinstr\n\t"			\
 96		".align	4\n"						\
 97	"3:\n\t"							\
 98		"b	2b\n\t"						\
 99		" mov	%3, %0\n\t"					\
100		".previous\n\n\t"					\
101		".section __ex_table,#alloc\n\t"			\
102		".align	4\n\t"						\
103		".word	1b, 3b\n\t"					\
104		".previous\n\n\t"					\
105	       : "=&r" (ret) : "r" (x), "m" (*__m(addr)),		\
106		 "i" (-EFAULT))
107
108int __put_user_bad(void);
109
110#define __get_user_check(x, addr, size, type) ({ \
111	register int __gu_ret; \
112	register unsigned long __gu_val; \
113	if (__access_ok(addr, size)) { \
114		switch (size) { \
115		case 1: \
116			 __get_user_asm(__gu_val, ub, addr, __gu_ret); \
117			break; \
118		case 2: \
119			__get_user_asm(__gu_val, uh, addr, __gu_ret); \
120			break; \
121		case 4: \
122			__get_user_asm(__gu_val, , addr, __gu_ret); \
123			break; \
124		case 8: \
125			__get_user_asm(__gu_val, d, addr, __gu_ret); \
126			break; \
127		default: \
128			__gu_val = 0; \
129			__gu_ret = __get_user_bad(); \
130			break; \
131		} \
132	 } else { \
133		 __gu_val = 0; \
134		 __gu_ret = -EFAULT; \
135	} \
136	x = (__force type) __gu_val; \
137	__gu_ret; \
138})
139
140#define __get_user_nocheck(x, addr, size, type) ({			\
141	register int __gu_ret;						\
142	register unsigned long __gu_val;				\
143	switch (size) {							\
144	case 1: __get_user_asm(__gu_val, ub, addr, __gu_ret); break;	\
145	case 2: __get_user_asm(__gu_val, uh, addr, __gu_ret); break;	\
146	case 4: __get_user_asm(__gu_val, , addr, __gu_ret); break;	\
147	case 8: __get_user_asm(__gu_val, d, addr, __gu_ret); break;	\
148	default:							\
149		__gu_val = 0;						\
150		__gu_ret = __get_user_bad();				\
151		break;							\
152	}								\
153	x = (__force type) __gu_val;					\
154	__gu_ret;							\
155})
156
157#define __get_user_asm(x, size, addr, ret)				\
158__asm__ __volatile__(							\
159		"/* Get user asm, inline. */\n"				\
160	"1:\t"	"ld"#size " %2, %1\n\t"					\
161		"clr	%0\n"						\
162	"2:\n\n\t"							\
163		".section .fixup,#alloc,#execinstr\n\t"			\
164		".align	4\n"						\
165	"3:\n\t"							\
166		"clr	%1\n\t"						\
167		"b	2b\n\t"						\
168		" mov	%3, %0\n\n\t"					\
169		".previous\n\t"						\
170		".section __ex_table,#alloc\n\t"			\
171		".align	4\n\t"						\
172		".word	1b, 3b\n\n\t"					\
173		".previous\n\t"						\
174	       : "=&r" (ret), "=&r" (x) : "m" (*__m(addr)),		\
175		 "i" (-EFAULT))
176
177int __get_user_bad(void);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
178
179unsigned long __copy_user(void __user *to, const void __user *from, unsigned long size);
 
 
 
 
 
 
 
 
180
181static inline unsigned long raw_copy_to_user(void __user *to, const void *from, unsigned long n)
182{
183	return __copy_user(to, (__force void __user *) from, n);
184}
185
186static inline unsigned long raw_copy_from_user(void *to, const void __user *from, unsigned long n)
 
 
 
 
 
 
 
 
187{
188	return __copy_user((__force void __user *) to, from, n);
189}
190
191#define INLINE_COPY_FROM_USER
192#define INLINE_COPY_TO_USER
193
194static inline unsigned long __clear_user(void __user *addr, unsigned long size)
195{
196	unsigned long ret;
197
198	__asm__ __volatile__ (
 
 
 
 
199		"mov %2, %%o1\n"
 
200		"call __bzero\n\t"
201		" mov %1, %%o0\n\t"
202		"mov %%o0, %0\n"
203		: "=r" (ret) : "r" (addr), "r" (size) :
204		"o0", "o1", "o2", "o3", "o4", "o5", "o7",
205		"g1", "g2", "g3", "g4", "g5", "g7", "cc");
206
207	return ret;
208}
209
210static inline unsigned long clear_user(void __user *addr, unsigned long n)
211{
212	if (n && __access_ok(addr, n))
213		return __clear_user(addr, n);
214	else
215		return n;
216}
217
218__must_check long strnlen_user(const char __user *str, long n);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
219
220#endif /* _ASM_UACCESS_H */