Commit | Line | Data |
---|---|---|
ace02e2b GH |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // Copyright (C) 2005-2017 Andes Technology Corporation | |
3 | ||
4 | #ifndef _ASMANDES_UACCESS_H | |
5 | #define _ASMANDES_UACCESS_H | |
6 | ||
7 | /* | |
8 | * User space memory access functions | |
9 | */ | |
10 | #include <linux/sched.h> | |
11 | #include <asm/errno.h> | |
12 | #include <asm/memory.h> | |
13 | #include <asm/types.h> | |
14 | #include <linux/mm.h> | |
15 | ||
ace02e2b GH |
16 | #define __asmeq(x, y) ".ifnc " x "," y " ; .err ; .endif\n\t" |
17 | ||
18 | /* | |
19 | * The exception table consists of pairs of addresses: the first is the | |
20 | * address of an instruction that is allowed to fault, and the second is | |
21 | * the address at which the program should continue. No registers are | |
22 | * modified, so it is entirely up to the continuation code to figure out | |
23 | * what to do. | |
24 | * | |
25 | * All the routines below use bits of fixup code that are out of line | |
26 | * with the main instruction path. This means when everything is well, | |
27 | * we don't even have to jump over them. Further, they do not intrude | |
28 | * on our cache or tlb entries. | |
29 | */ | |
30 | ||
31 | struct exception_table_entry { | |
32 | unsigned long insn, fixup; | |
33 | }; | |
34 | ||
35 | extern int fixup_exception(struct pt_regs *regs); | |
36 | ||
37 | #define KERNEL_DS ((mm_segment_t) { ~0UL }) | |
7ef39548 | 38 | #define USER_DS ((mm_segment_t) {TASK_SIZE - 1}) |
ace02e2b | 39 | |
ace02e2b GH |
40 | #define get_fs() (current_thread_info()->addr_limit) |
41 | #define user_addr_max get_fs | |
42 | ||
43 | static inline void set_fs(mm_segment_t fs) | |
44 | { | |
45 | current_thread_info()->addr_limit = fs; | |
46 | } | |
47 | ||
7ef39548 | 48 | #define segment_eq(a, b) ((a) == (b)) |
ace02e2b GH |
49 | |
50 | #define __range_ok(addr, size) (size <= get_fs() && addr <= (get_fs() -size)) | |
51 | ||
96d4f267 | 52 | #define access_ok(addr, size) \ |
ace02e2b GH |
53 | __range_ok((unsigned long)addr, (unsigned long)size) |
54 | /* | |
55 | * Single-value transfer routines. They automatically use the right | |
56 | * size if we just have the right pointer type. Note that the functions | |
57 | * which read from user space (*get_*) need to take care not to leak | |
58 | * kernel data even if the calling code is buggy and fails to check | |
59 | * the return value. This means zeroing out the destination variable | |
60 | * or buffer on error. Normally this is done out of line by the | |
61 | * fixup code, but there are a few places where it intrudes on the | |
62 | * main code path. When we only write to user space, there is no | |
63 | * problem. | |
64 | * | |
65 | * The "__xxx" versions of the user access functions do not verify the | |
66 | * address space - it must have been done previously with a separate | |
67 | * "access_ok()" call. | |
68 | * | |
69 | * The "xxx_error" versions set the third argument to EFAULT if an | |
70 | * error occurs, and leave it unchanged on success. Note that these | |
71 | * versions are void (ie, don't return a value as such). | |
72 | */ | |
73 | ||
487913ab | 74 | #define get_user __get_user \ |
7ef39548 ZL |
75 | |
76 | #define __get_user(x, ptr) \ | |
ace02e2b GH |
77 | ({ \ |
78 | long __gu_err = 0; \ | |
487913ab | 79 | __get_user_check((x), (ptr), __gu_err); \ |
ace02e2b GH |
80 | __gu_err; \ |
81 | }) | |
82 | ||
7ef39548 | 83 | #define __get_user_error(x, ptr, err) \ |
ace02e2b | 84 | ({ \ |
487913ab | 85 | __get_user_check((x), (ptr), (err)); \ |
7ef39548 | 86 | (void)0; \ |
ace02e2b GH |
87 | }) |
88 | ||
487913ab ZL |
89 | #define __get_user_check(x, ptr, err) \ |
90 | ({ \ | |
91 | const __typeof__(*(ptr)) __user *__p = (ptr); \ | |
92 | might_fault(); \ | |
96d4f267 | 93 | if (access_ok(__p, sizeof(*__p))) { \ |
487913ab ZL |
94 | __get_user_err((x), __p, (err)); \ |
95 | } else { \ | |
96 | (x) = 0; (err) = -EFAULT; \ | |
97 | } \ | |
98 | }) | |
99 | ||
7ef39548 | 100 | #define __get_user_err(x, ptr, err) \ |
ace02e2b | 101 | do { \ |
ace02e2b | 102 | unsigned long __gu_val; \ |
487913ab ZL |
103 | __chk_user_ptr(ptr); \ |
104 | switch (sizeof(*(ptr))) { \ | |
ace02e2b | 105 | case 1: \ |
487913ab | 106 | __get_user_asm("lbi", __gu_val, (ptr), (err)); \ |
ace02e2b GH |
107 | break; \ |
108 | case 2: \ | |
487913ab | 109 | __get_user_asm("lhi", __gu_val, (ptr), (err)); \ |
ace02e2b GH |
110 | break; \ |
111 | case 4: \ | |
487913ab | 112 | __get_user_asm("lwi", __gu_val, (ptr), (err)); \ |
ace02e2b GH |
113 | break; \ |
114 | case 8: \ | |
487913ab | 115 | __get_user_asm_dword(__gu_val, (ptr), (err)); \ |
ace02e2b GH |
116 | break; \ |
117 | default: \ | |
118 | BUILD_BUG(); \ | |
119 | break; \ | |
120 | } \ | |
487913ab | 121 | (x) = (__force __typeof__(*(ptr)))__gu_val; \ |
ace02e2b GH |
122 | } while (0) |
123 | ||
7ef39548 ZL |
124 | #define __get_user_asm(inst, x, addr, err) \ |
125 | __asm__ __volatile__ ( \ | |
126 | "1: "inst" %1,[%2]\n" \ | |
127 | "2:\n" \ | |
128 | " .section .fixup,\"ax\"\n" \ | |
129 | " .align 2\n" \ | |
130 | "3: move %0, %3\n" \ | |
131 | " move %1, #0\n" \ | |
132 | " b 2b\n" \ | |
133 | " .previous\n" \ | |
134 | " .section __ex_table,\"a\"\n" \ | |
135 | " .align 3\n" \ | |
136 | " .long 1b, 3b\n" \ | |
137 | " .previous" \ | |
138 | : "+r" (err), "=&r" (x) \ | |
139 | : "r" (addr), "i" (-EFAULT) \ | |
140 | : "cc") | |
ace02e2b GH |
141 | |
142 | #ifdef __NDS32_EB__ | |
143 | #define __gu_reg_oper0 "%H1" | |
144 | #define __gu_reg_oper1 "%L1" | |
145 | #else | |
146 | #define __gu_reg_oper0 "%L1" | |
147 | #define __gu_reg_oper1 "%H1" | |
148 | #endif | |
149 | ||
150 | #define __get_user_asm_dword(x, addr, err) \ | |
7ef39548 ZL |
151 | __asm__ __volatile__ ( \ |
152 | "\n1:\tlwi " __gu_reg_oper0 ",[%2]\n" \ | |
153 | "\n2:\tlwi " __gu_reg_oper1 ",[%2+4]\n" \ | |
154 | "3:\n" \ | |
155 | " .section .fixup,\"ax\"\n" \ | |
156 | " .align 2\n" \ | |
157 | "4: move %0, %3\n" \ | |
158 | " b 3b\n" \ | |
159 | " .previous\n" \ | |
160 | " .section __ex_table,\"a\"\n" \ | |
161 | " .align 3\n" \ | |
162 | " .long 1b, 4b\n" \ | |
163 | " .long 2b, 4b\n" \ | |
164 | " .previous" \ | |
165 | : "+r"(err), "=&r"(x) \ | |
166 | : "r"(addr), "i"(-EFAULT) \ | |
167 | : "cc") | |
168 | ||
487913ab | 169 | #define put_user __put_user \ |
7ef39548 ZL |
170 | |
171 | #define __put_user(x, ptr) \ | |
ace02e2b GH |
172 | ({ \ |
173 | long __pu_err = 0; \ | |
7ef39548 | 174 | __put_user_err((x), (ptr), __pu_err); \ |
ace02e2b GH |
175 | __pu_err; \ |
176 | }) | |
177 | ||
7ef39548 | 178 | #define __put_user_error(x, ptr, err) \ |
ace02e2b | 179 | ({ \ |
487913ab | 180 | __put_user_err((x), (ptr), (err)); \ |
7ef39548 | 181 | (void)0; \ |
ace02e2b GH |
182 | }) |
183 | ||
487913ab ZL |
184 | #define __put_user_check(x, ptr, err) \ |
185 | ({ \ | |
186 | __typeof__(*(ptr)) __user *__p = (ptr); \ | |
187 | might_fault(); \ | |
96d4f267 | 188 | if (access_ok(__p, sizeof(*__p))) { \ |
487913ab ZL |
189 | __put_user_err((x), __p, (err)); \ |
190 | } else { \ | |
191 | (err) = -EFAULT; \ | |
192 | } \ | |
193 | }) | |
194 | ||
7ef39548 | 195 | #define __put_user_err(x, ptr, err) \ |
ace02e2b | 196 | do { \ |
487913ab ZL |
197 | __typeof__(*(ptr)) __pu_val = (x); \ |
198 | __chk_user_ptr(ptr); \ | |
199 | switch (sizeof(*(ptr))) { \ | |
ace02e2b | 200 | case 1: \ |
487913ab | 201 | __put_user_asm("sbi", __pu_val, (ptr), (err)); \ |
ace02e2b GH |
202 | break; \ |
203 | case 2: \ | |
487913ab | 204 | __put_user_asm("shi", __pu_val, (ptr), (err)); \ |
ace02e2b GH |
205 | break; \ |
206 | case 4: \ | |
487913ab | 207 | __put_user_asm("swi", __pu_val, (ptr), (err)); \ |
ace02e2b GH |
208 | break; \ |
209 | case 8: \ | |
487913ab | 210 | __put_user_asm_dword(__pu_val, (ptr), (err)); \ |
ace02e2b GH |
211 | break; \ |
212 | default: \ | |
213 | BUILD_BUG(); \ | |
214 | break; \ | |
215 | } \ | |
216 | } while (0) | |
217 | ||
7ef39548 ZL |
218 | #define __put_user_asm(inst, x, addr, err) \ |
219 | __asm__ __volatile__ ( \ | |
220 | "1: "inst" %1,[%2]\n" \ | |
221 | "2:\n" \ | |
222 | " .section .fixup,\"ax\"\n" \ | |
223 | " .align 2\n" \ | |
224 | "3: move %0, %3\n" \ | |
225 | " b 2b\n" \ | |
226 | " .previous\n" \ | |
227 | " .section __ex_table,\"a\"\n" \ | |
228 | " .align 3\n" \ | |
229 | " .long 1b, 3b\n" \ | |
230 | " .previous" \ | |
231 | : "+r" (err) \ | |
232 | : "r" (x), "r" (addr), "i" (-EFAULT) \ | |
233 | : "cc") | |
ace02e2b GH |
234 | |
235 | #ifdef __NDS32_EB__ | |
236 | #define __pu_reg_oper0 "%H2" | |
237 | #define __pu_reg_oper1 "%L2" | |
238 | #else | |
239 | #define __pu_reg_oper0 "%L2" | |
240 | #define __pu_reg_oper1 "%H2" | |
241 | #endif | |
242 | ||
243 | #define __put_user_asm_dword(x, addr, err) \ | |
7ef39548 ZL |
244 | __asm__ __volatile__ ( \ |
245 | "\n1:\tswi " __pu_reg_oper0 ",[%1]\n" \ | |
246 | "\n2:\tswi " __pu_reg_oper1 ",[%1+4]\n" \ | |
247 | "3:\n" \ | |
248 | " .section .fixup,\"ax\"\n" \ | |
249 | " .align 2\n" \ | |
250 | "4: move %0, %3\n" \ | |
251 | " b 3b\n" \ | |
252 | " .previous\n" \ | |
253 | " .section __ex_table,\"a\"\n" \ | |
254 | " .align 3\n" \ | |
255 | " .long 1b, 4b\n" \ | |
256 | " .long 2b, 4b\n" \ | |
257 | " .previous" \ | |
258 | : "+r"(err) \ | |
259 | : "r"(addr), "r"(x), "i"(-EFAULT) \ | |
260 | : "cc") | |
261 | ||
ace02e2b GH |
262 | extern unsigned long __arch_clear_user(void __user * addr, unsigned long n); |
263 | extern long strncpy_from_user(char *dest, const char __user * src, long count); | |
264 | extern __must_check long strlen_user(const char __user * str); | |
265 | extern __must_check long strnlen_user(const char __user * str, long n); | |
266 | extern unsigned long __arch_copy_from_user(void *to, const void __user * from, | |
267 | unsigned long n); | |
268 | extern unsigned long __arch_copy_to_user(void __user * to, const void *from, | |
269 | unsigned long n); | |
270 | ||
271 | #define raw_copy_from_user __arch_copy_from_user | |
272 | #define raw_copy_to_user __arch_copy_to_user | |
273 | ||
274 | #define INLINE_COPY_FROM_USER | |
275 | #define INLINE_COPY_TO_USER | |
276 | static inline unsigned long clear_user(void __user * to, unsigned long n) | |
277 | { | |
96d4f267 | 278 | if (access_ok(to, n)) |
ace02e2b GH |
279 | n = __arch_clear_user(to, n); |
280 | return n; | |
281 | } | |
282 | ||
283 | static inline unsigned long __clear_user(void __user * to, unsigned long n) | |
284 | { | |
285 | return __arch_clear_user(to, n); | |
286 | } | |
287 | ||
288 | #endif /* _ASMNDS32_UACCESS_H */ |