1 /* SPDX-License-Identifier: GPL-2.0 */
2 // Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.
3
4 #ifndef __ASM_CSKY_UACCESS_H
5 #define __ASM_CSKY_UACCESS_H
6
7 /*
8 * User space memory access functions
9 */
10 #include <linux/compiler.h>
11 #include <linux/errno.h>
12 #include <linux/types.h>
13 #include <linux/sched.h>
14 #include <linux/string.h>
15 #include <linux/version.h>
16 #include <asm/segment.h>
17
access_ok(const void * addr,unsigned long size)18 static inline int access_ok(const void *addr, unsigned long size)
19 {
20 unsigned long limit = current_thread_info()->addr_limit.seg;
21
22 return (((unsigned long)addr < limit) &&
23 ((unsigned long)(addr + size) < limit));
24 }
25
26 #define __addr_ok(addr) (access_ok(addr, 0))
27
28 extern int __put_user_bad(void);
29
30 /*
31 * Tell gcc we read from memory instead of writing: this is because
32 * we do not write to any memory gcc knows about, so there are no
33 * aliasing issues.
34 */
35
36 /*
37 * These are the main single-value transfer routines. They automatically
38 * use the right size if we just have the right pointer type.
39 *
40 * This gets kind of ugly. We want to return _two_ values in "get_user()"
41 * and yet we don't want to do any pointers, because that is too much
42 * of a performance impact. Thus we have a few rather ugly macros here,
43 * and hide all the ugliness from the user.
44 *
45 * The "__xxx" versions of the user access functions are versions that
46 * do not verify the address space, that must have been done previously
47 * with a separate "access_ok()" call (this is used when we do multiple
48 * accesses to the same area of user memory).
49 *
50 * As we use the same address space for kernel and user data on
51 * Ckcore, we can just do these as direct assignments. (Of course, the
52 * exception handling means that it's no longer "just"...)
53 */
54
55 #define put_user(x, ptr) \
56 __put_user_check((x), (ptr), sizeof(*(ptr)))
57
58 #define __put_user(x, ptr) \
59 __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
60
61 #define __ptr(x) ((unsigned long *)(x))
62
63 #define get_user(x, ptr) \
64 __get_user_check((x), (ptr), sizeof(*(ptr)))
65
66 #define __get_user(x, ptr) \
67 __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
68
69 #define __put_user_nocheck(x, ptr, size) \
70 ({ \
71 long __pu_err = 0; \
72 typeof(*(ptr)) *__pu_addr = (ptr); \
73 typeof(*(ptr)) __pu_val = (typeof(*(ptr)))(x); \
74 if (__pu_addr) \
75 __put_user_size(__pu_val, (__pu_addr), (size), \
76 __pu_err); \
77 __pu_err; \
78 })
79
80 #define __put_user_check(x, ptr, size) \
81 ({ \
82 long __pu_err = -EFAULT; \
83 typeof(*(ptr)) *__pu_addr = (ptr); \
84 typeof(*(ptr)) __pu_val = (typeof(*(ptr)))(x); \
85 if (access_ok(__pu_addr, size) && __pu_addr) \
86 __put_user_size(__pu_val, __pu_addr, (size), __pu_err); \
87 __pu_err; \
88 })
89
90 #define __put_user_size(x, ptr, size, retval) \
91 do { \
92 retval = 0; \
93 switch (size) { \
94 case 1: \
95 __put_user_asm_b(x, ptr, retval); \
96 break; \
97 case 2: \
98 __put_user_asm_h(x, ptr, retval); \
99 break; \
100 case 4: \
101 __put_user_asm_w(x, ptr, retval); \
102 break; \
103 case 8: \
104 __put_user_asm_64(x, ptr, retval); \
105 break; \
106 default: \
107 __put_user_bad(); \
108 } \
109 } while (0)
110
111 /*
112 * We don't tell gcc that we are accessing memory, but this is OK
113 * because we do not write to any memory gcc knows about, so there
114 * are no aliasing issues.
115 *
116 * Note that PC at a fault is the address *after* the faulting
117 * instruction.
118 */
119 #define __put_user_asm_b(x, ptr, err) \
120 do { \
121 int errcode; \
122 asm volatile( \
123 "1: stb %1, (%2,0) \n" \
124 " br 3f \n" \
125 "2: mov %0, %3 \n" \
126 " br 3f \n" \
127 ".section __ex_table, \"a\" \n" \
128 ".align 2 \n" \
129 ".long 1b,2b \n" \
130 ".previous \n" \
131 "3: \n" \
132 : "=r"(err), "=r"(x), "=r"(ptr), "=r"(errcode) \
133 : "0"(err), "1"(x), "2"(ptr), "3"(-EFAULT) \
134 : "memory"); \
135 } while (0)
136
137 #define __put_user_asm_h(x, ptr, err) \
138 do { \
139 int errcode; \
140 asm volatile( \
141 "1: sth %1, (%2,0) \n" \
142 " br 3f \n" \
143 "2: mov %0, %3 \n" \
144 " br 3f \n" \
145 ".section __ex_table, \"a\" \n" \
146 ".align 2 \n" \
147 ".long 1b,2b \n" \
148 ".previous \n" \
149 "3: \n" \
150 : "=r"(err), "=r"(x), "=r"(ptr), "=r"(errcode) \
151 : "0"(err), "1"(x), "2"(ptr), "3"(-EFAULT) \
152 : "memory"); \
153 } while (0)
154
155 #define __put_user_asm_w(x, ptr, err) \
156 do { \
157 int errcode; \
158 asm volatile( \
159 "1: stw %1, (%2,0) \n" \
160 " br 3f \n" \
161 "2: mov %0, %3 \n" \
162 " br 3f \n" \
163 ".section __ex_table,\"a\" \n" \
164 ".align 2 \n" \
165 ".long 1b, 2b \n" \
166 ".previous \n" \
167 "3: \n" \
168 : "=r"(err), "=r"(x), "=r"(ptr), "=r"(errcode) \
169 : "0"(err), "1"(x), "2"(ptr), "3"(-EFAULT) \
170 : "memory"); \
171 } while (0)
172
173 #define __put_user_asm_64(x, ptr, err) \
174 do { \
175 int tmp; \
176 int errcode; \
177 typeof(*(ptr))src = (typeof(*(ptr)))x; \
178 typeof(*(ptr))*psrc = &src; \
179 \
180 asm volatile( \
181 " ldw %3, (%1, 0) \n" \
182 "1: stw %3, (%2, 0) \n" \
183 " ldw %3, (%1, 4) \n" \
184 "2: stw %3, (%2, 4) \n" \
185 " br 4f \n" \
186 "3: mov %0, %4 \n" \
187 " br 4f \n" \
188 ".section __ex_table, \"a\" \n" \
189 ".align 2 \n" \
190 ".long 1b, 3b \n" \
191 ".long 2b, 3b \n" \
192 ".previous \n" \
193 "4: \n" \
194 : "=r"(err), "=r"(psrc), "=r"(ptr), \
195 "=r"(tmp), "=r"(errcode) \
196 : "0"(err), "1"(psrc), "2"(ptr), "3"(0), "4"(-EFAULT) \
197 : "memory"); \
198 } while (0)
199
200 #define __get_user_nocheck(x, ptr, size) \
201 ({ \
202 long __gu_err; \
203 __get_user_size(x, (ptr), (size), __gu_err); \
204 __gu_err; \
205 })
206
207 #define __get_user_check(x, ptr, size) \
208 ({ \
209 int __gu_err = -EFAULT; \
210 const __typeof__(*(ptr)) __user *__gu_ptr = (ptr); \
211 if (access_ok(__gu_ptr, size) && __gu_ptr) \
212 __get_user_size(x, __gu_ptr, size, __gu_err); \
213 __gu_err; \
214 })
215
216 #define __get_user_size(x, ptr, size, retval) \
217 do { \
218 switch (size) { \
219 case 1: \
220 __get_user_asm_common((x), ptr, "ldb", retval); \
221 break; \
222 case 2: \
223 __get_user_asm_common((x), ptr, "ldh", retval); \
224 break; \
225 case 4: \
226 __get_user_asm_common((x), ptr, "ldw", retval); \
227 break; \
228 default: \
229 x = 0; \
230 (retval) = __get_user_bad(); \
231 } \
232 } while (0)
233
234 #define __get_user_asm_common(x, ptr, ins, err) \
235 do { \
236 int errcode; \
237 asm volatile( \
238 "1: " ins " %1, (%4,0) \n" \
239 " br 3f \n" \
240 /* Fix up codes */ \
241 "2: mov %0, %2 \n" \
242 " movi %1, 0 \n" \
243 " br 3f \n" \
244 ".section __ex_table,\"a\" \n" \
245 ".align 2 \n" \
246 ".long 1b, 2b \n" \
247 ".previous \n" \
248 "3: \n" \
249 : "=r"(err), "=r"(x), "=r"(errcode) \
250 : "0"(0), "r"(ptr), "2"(-EFAULT) \
251 : "memory"); \
252 } while (0)
253
254 extern int __get_user_bad(void);
255
256 #define ___copy_to_user(to, from, n) \
257 do { \
258 int w0, w1, w2, w3; \
259 asm volatile( \
260 "0: cmpnei %1, 0 \n" \
261 " bf 8f \n" \
262 " mov %3, %1 \n" \
263 " or %3, %2 \n" \
264 " andi %3, 3 \n" \
265 " cmpnei %3, 0 \n" \
266 " bf 1f \n" \
267 " br 5f \n" \
268 "1: cmplti %0, 16 \n" /* 4W */ \
269 " bt 3f \n" \
270 " ldw %3, (%2, 0) \n" \
271 " ldw %4, (%2, 4) \n" \
272 " ldw %5, (%2, 8) \n" \
273 " ldw %6, (%2, 12) \n" \
274 "2: stw %3, (%1, 0) \n" \
275 "9: stw %4, (%1, 4) \n" \
276 "10: stw %5, (%1, 8) \n" \
277 "11: stw %6, (%1, 12) \n" \
278 " addi %2, 16 \n" \
279 " addi %1, 16 \n" \
280 " subi %0, 16 \n" \
281 " br 1b \n" \
282 "3: cmplti %0, 4 \n" /* 1W */ \
283 " bt 5f \n" \
284 " ldw %3, (%2, 0) \n" \
285 "4: stw %3, (%1, 0) \n" \
286 " addi %2, 4 \n" \
287 " addi %1, 4 \n" \
288 " subi %0, 4 \n" \
289 " br 3b \n" \
290 "5: cmpnei %0, 0 \n" /* 1B */ \
291 " bf 13f \n" \
292 " ldb %3, (%2, 0) \n" \
293 "6: stb %3, (%1, 0) \n" \
294 " addi %2, 1 \n" \
295 " addi %1, 1 \n" \
296 " subi %0, 1 \n" \
297 " br 5b \n" \
298 "7: subi %0, 4 \n" \
299 "8: subi %0, 4 \n" \
300 "12: subi %0, 4 \n" \
301 " br 13f \n" \
302 ".section __ex_table, \"a\" \n" \
303 ".align 2 \n" \
304 ".long 2b, 13f \n" \
305 ".long 4b, 13f \n" \
306 ".long 6b, 13f \n" \
307 ".long 9b, 12b \n" \
308 ".long 10b, 8b \n" \
309 ".long 11b, 7b \n" \
310 ".previous \n" \
311 "13: \n" \
312 : "=r"(n), "=r"(to), "=r"(from), "=r"(w0), \
313 "=r"(w1), "=r"(w2), "=r"(w3) \
314 : "0"(n), "1"(to), "2"(from) \
315 : "memory"); \
316 } while (0)
317
318 #define ___copy_from_user(to, from, n) \
319 do { \
320 int tmp; \
321 int nsave; \
322 asm volatile( \
323 "0: cmpnei %1, 0 \n" \
324 " bf 7f \n" \
325 " mov %3, %1 \n" \
326 " or %3, %2 \n" \
327 " andi %3, 3 \n" \
328 " cmpnei %3, 0 \n" \
329 " bf 1f \n" \
330 " br 5f \n" \
331 "1: cmplti %0, 16 \n" \
332 " bt 3f \n" \
333 "2: ldw %3, (%2, 0) \n" \
334 "10: ldw %4, (%2, 4) \n" \
335 " stw %3, (%1, 0) \n" \
336 " stw %4, (%1, 4) \n" \
337 "11: ldw %3, (%2, 8) \n" \
338 "12: ldw %4, (%2, 12) \n" \
339 " stw %3, (%1, 8) \n" \
340 " stw %4, (%1, 12) \n" \
341 " addi %2, 16 \n" \
342 " addi %1, 16 \n" \
343 " subi %0, 16 \n" \
344 " br 1b \n" \
345 "3: cmplti %0, 4 \n" \
346 " bt 5f \n" \
347 "4: ldw %3, (%2, 0) \n" \
348 " stw %3, (%1, 0) \n" \
349 " addi %2, 4 \n" \
350 " addi %1, 4 \n" \
351 " subi %0, 4 \n" \
352 " br 3b \n" \
353 "5: cmpnei %0, 0 \n" \
354 " bf 7f \n" \
355 "6: ldb %3, (%2, 0) \n" \
356 " stb %3, (%1, 0) \n" \
357 " addi %2, 1 \n" \
358 " addi %1, 1 \n" \
359 " subi %0, 1 \n" \
360 " br 5b \n" \
361 "8: stw %3, (%1, 0) \n" \
362 " subi %0, 4 \n" \
363 " bf 7f \n" \
364 "9: subi %0, 8 \n" \
365 " bf 7f \n" \
366 "13: stw %3, (%1, 8) \n" \
367 " subi %0, 12 \n" \
368 " bf 7f \n" \
369 ".section __ex_table, \"a\" \n" \
370 ".align 2 \n" \
371 ".long 2b, 7f \n" \
372 ".long 4b, 7f \n" \
373 ".long 6b, 7f \n" \
374 ".long 10b, 8b \n" \
375 ".long 11b, 9b \n" \
376 ".long 12b,13b \n" \
377 ".previous \n" \
378 "7: \n" \
379 : "=r"(n), "=r"(to), "=r"(from), "=r"(nsave), \
380 "=r"(tmp) \
381 : "0"(n), "1"(to), "2"(from) \
382 : "memory"); \
383 } while (0)
384
385 unsigned long raw_copy_from_user(void *to, const void *from, unsigned long n);
386 unsigned long raw_copy_to_user(void *to, const void *from, unsigned long n);
387
388 unsigned long clear_user(void *to, unsigned long n);
389 unsigned long __clear_user(void __user *to, unsigned long n);
390
391 long strncpy_from_user(char *dst, const char *src, long count);
392 long __strncpy_from_user(char *dst, const char *src, long count);
393
394 /*
395 * Return the size of a string (including the ending 0)
396 *
397 * Return 0 on exception, a value greater than N if too long
398 */
399 long strnlen_user(const char *src, long n);
400
401 #define strlen_user(str) strnlen_user(str, 32767)
402
403 struct exception_table_entry {
404 unsigned long insn;
405 unsigned long nextinsn;
406 };
407
408 extern int fixup_exception(struct pt_regs *regs);
409
410 #endif /* __ASM_CSKY_UACCESS_H */
411
