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 
48 struct __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 
108 int __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 
177 int __get_user_bad(void);
178 
179 unsigned long __copy_user(void __user *to, const void __user *from, unsigned long size);
180 
raw_copy_to_user(void __user * to,const void * from,unsigned long n)181 static 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 
raw_copy_from_user(void * to,const void __user * from,unsigned long n)186 static 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 
__clear_user(void __user * addr,unsigned long size)194 static 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 
clear_user(void __user * addr,unsigned long n)210 static 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 */
221