1
2
3
4
5
6
7
8
9
10
11#ifndef _ASM_MICROBLAZE_UACCESS_H
12#define _ASM_MICROBLAZE_UACCESS_H
13
14#ifdef __KERNEL__
15#ifndef __ASSEMBLY__
16
17#include <linux/kernel.h>
18#include <linux/errno.h>
19#include <linux/sched.h>
20#include <linux/mm.h>
21
22#include <asm/mmu.h>
23#include <asm/page.h>
24#include <asm/pgtable.h>
25#include <linux/string.h>
26
27#define VERIFY_READ 0
28#define VERIFY_WRITE 1
29
30
31
32
33
34
35
36
37
38
39
40
41
42# define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
43
44# ifndef CONFIG_MMU
45# define KERNEL_DS MAKE_MM_SEG(0)
46# define USER_DS KERNEL_DS
47# else
48# define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
49# define USER_DS MAKE_MM_SEG(TASK_SIZE - 1)
50# endif
51
52# define get_ds() (KERNEL_DS)
53# define get_fs() (current_thread_info()->addr_limit)
54# define set_fs(val) (current_thread_info()->addr_limit = (val))
55
56# define segment_eq(a, b) ((a).seg == (b).seg)
57
58
59
60
61
62
63
64
65
66
67
68
69
70struct exception_table_entry {
71 unsigned long insn, fixup;
72};
73
74
75extern unsigned long search_exception_table(unsigned long);
76
77#ifndef CONFIG_MMU
78
79
80static inline int ___range_ok(unsigned long addr, unsigned long size)
81{
82 return ((addr < memory_start) ||
83 ((addr + size - 1) > (memory_start + memory_size - 1)));
84}
85
86#define __range_ok(addr, size) \
87 ___range_ok((unsigned long)(addr), (unsigned long)(size))
88
89#define access_ok(type, addr, size) (__range_ok((addr), (size)) == 0)
90
91#else
92
93static inline int access_ok(int type, const void __user *addr,
94 unsigned long size)
95{
96 if (!size)
97 goto ok;
98
99 if ((get_fs().seg < ((unsigned long)addr)) ||
100 (get_fs().seg < ((unsigned long)addr + size - 1))) {
101 pr_debug("ACCESS fail: %s at 0x%08x (size 0x%x), seg 0x%08x\n",
102 type ? "WRITE" : "READ ", (__force u32)addr, (u32)size,
103 (u32)get_fs().seg);
104 return 0;
105 }
106ok:
107 pr_debug("ACCESS OK: %s at 0x%08x (size 0x%x), seg 0x%08x\n",
108 type ? "WRITE" : "READ ", (__force u32)addr, (u32)size,
109 (u32)get_fs().seg);
110 return 1;
111}
112#endif
113
114#ifdef CONFIG_MMU
115# define __FIXUP_SECTION ".section .fixup,\"ax\"\n"
116# define __EX_TABLE_SECTION ".section __ex_table,\"a\"\n"
117#else
118# define __FIXUP_SECTION ".section .discard,\"ax\"\n"
119# define __EX_TABLE_SECTION ".section .discard,\"ax\"\n"
120#endif
121
122extern unsigned long __copy_tofrom_user(void __user *to,
123 const void __user *from, unsigned long size);
124
125
126static inline unsigned long __must_check __clear_user(void __user *to,
127 unsigned long n)
128{
129
130 __asm__ __volatile__ ( \
131 "1: sb r0, %1, r0;" \
132 " addik %0, %0, -1;" \
133 " bneid %0, 1b;" \
134 " addik %1, %1, 1;" \
135 "2: " \
136 __EX_TABLE_SECTION \
137 ".word 1b,2b;" \
138 ".previous;" \
139 : "=r"(n), "=r"(to) \
140 : "0"(n), "1"(to)
141 );
142 return n;
143}
144
145static inline unsigned long __must_check clear_user(void __user *to,
146 unsigned long n)
147{
148 might_fault();
149 if (unlikely(!access_ok(VERIFY_WRITE, to, n)))
150 return n;
151
152 return __clear_user(to, n);
153}
154
155
156extern long __user_bad(void);
157
158#define __get_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \
159({ \
160 __asm__ __volatile__ ( \
161 "1:" insn " %1, %2, r0;" \
162 " addk %0, r0, r0;" \
163 "2: " \
164 __FIXUP_SECTION \
165 "3: brid 2b;" \
166 " addik %0, r0, %3;" \
167 ".previous;" \
168 __EX_TABLE_SECTION \
169 ".word 1b,3b;" \
170 ".previous;" \
171 : "=&r"(__gu_err), "=r"(__gu_val) \
172 : "r"(__gu_ptr), "i"(-EFAULT) \
173 ); \
174})
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193#define get_user(x, ptr) \
194 __get_user_check((x), (ptr), sizeof(*(ptr)))
195
196#define __get_user_check(x, ptr, size) \
197({ \
198 unsigned long __gu_val = 0; \
199 const typeof(*(ptr)) __user *__gu_addr = (ptr); \
200 int __gu_err = 0; \
201 \
202 if (access_ok(VERIFY_READ, __gu_addr, size)) { \
203 switch (size) { \
204 case 1: \
205 __get_user_asm("lbu", __gu_addr, __gu_val, \
206 __gu_err); \
207 break; \
208 case 2: \
209 __get_user_asm("lhu", __gu_addr, __gu_val, \
210 __gu_err); \
211 break; \
212 case 4: \
213 __get_user_asm("lw", __gu_addr, __gu_val, \
214 __gu_err); \
215 break; \
216 default: \
217 __gu_err = __user_bad(); \
218 break; \
219 } \
220 } else { \
221 __gu_err = -EFAULT; \
222 } \
223 x = (typeof(*(ptr)))__gu_val; \
224 __gu_err; \
225})
226
227#define __get_user(x, ptr) \
228({ \
229 unsigned long __gu_val; \
230 \
231 long __gu_err; \
232 switch (sizeof(*(ptr))) { \
233 case 1: \
234 __get_user_asm("lbu", (ptr), __gu_val, __gu_err); \
235 break; \
236 case 2: \
237 __get_user_asm("lhu", (ptr), __gu_val, __gu_err); \
238 break; \
239 case 4: \
240 __get_user_asm("lw", (ptr), __gu_val, __gu_err); \
241 break; \
242 default: \
243 __gu_err = __user_bad();\
244 } \
245 x = (__typeof__(*(ptr))) __gu_val; \
246 __gu_err; \
247})
248
249
250#define __put_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \
251({ \
252 __asm__ __volatile__ ( \
253 "1:" insn " %1, %2, r0;" \
254 " addk %0, r0, r0;" \
255 "2: " \
256 __FIXUP_SECTION \
257 "3: brid 2b;" \
258 " addik %0, r0, %3;" \
259 ".previous;" \
260 __EX_TABLE_SECTION \
261 ".word 1b,3b;" \
262 ".previous;" \
263 : "=&r"(__gu_err) \
264 : "r"(__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \
265 ); \
266})
267
268#define __put_user_asm_8(__gu_ptr, __gu_val, __gu_err) \
269({ \
270 __asm__ __volatile__ (" lwi %0, %1, 0;" \
271 "1: swi %0, %2, 0;" \
272 " lwi %0, %1, 4;" \
273 "2: swi %0, %2, 4;" \
274 " addk %0, r0, r0;" \
275 "3: " \
276 __FIXUP_SECTION \
277 "4: brid 3b;" \
278 " addik %0, r0, %3;" \
279 ".previous;" \
280 __EX_TABLE_SECTION \
281 ".word 1b,4b,2b,4b;" \
282 ".previous;" \
283 : "=&r"(__gu_err) \
284 : "r"(&__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \
285 ); \
286})
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304#define put_user(x, ptr) \
305 __put_user_check((x), (ptr), sizeof(*(ptr)))
306
307#define __put_user_check(x, ptr, size) \
308({ \
309 typeof(*(ptr)) volatile __pu_val = x; \
310 typeof(*(ptr)) __user *__pu_addr = (ptr); \
311 int __pu_err = 0; \
312 \
313 if (access_ok(VERIFY_WRITE, __pu_addr, size)) { \
314 switch (size) { \
315 case 1: \
316 __put_user_asm("sb", __pu_addr, __pu_val, \
317 __pu_err); \
318 break; \
319 case 2: \
320 __put_user_asm("sh", __pu_addr, __pu_val, \
321 __pu_err); \
322 break; \
323 case 4: \
324 __put_user_asm("sw", __pu_addr, __pu_val, \
325 __pu_err); \
326 break; \
327 case 8: \
328 __put_user_asm_8(__pu_addr, __pu_val, __pu_err);\
329 break; \
330 default: \
331 __pu_err = __user_bad(); \
332 break; \
333 } \
334 } else { \
335 __pu_err = -EFAULT; \
336 } \
337 __pu_err; \
338})
339
340#define __put_user(x, ptr) \
341({ \
342 __typeof__(*(ptr)) volatile __gu_val = (x); \
343 long __gu_err = 0; \
344 switch (sizeof(__gu_val)) { \
345 case 1: \
346 __put_user_asm("sb", (ptr), __gu_val, __gu_err); \
347 break; \
348 case 2: \
349 __put_user_asm("sh", (ptr), __gu_val, __gu_err); \
350 break; \
351 case 4: \
352 __put_user_asm("sw", (ptr), __gu_val, __gu_err); \
353 break; \
354 case 8: \
355 __put_user_asm_8((ptr), __gu_val, __gu_err); \
356 break; \
357 default: \
358 __gu_err = __user_bad(); \
359 } \
360 __gu_err; \
361})
362
363
364
365#define __copy_from_user(to, from, n) \
366 __copy_tofrom_user((__force void __user *)(to), \
367 (void __user *)(from), (n))
368#define __copy_from_user_inatomic(to, from, n) \
369 __copy_from_user((to), (from), (n))
370
371static inline long copy_from_user(void *to,
372 const void __user *from, unsigned long n)
373{
374 might_fault();
375 if (access_ok(VERIFY_READ, from, n))
376 return __copy_from_user(to, from, n);
377 return n;
378}
379
380#define __copy_to_user(to, from, n) \
381 __copy_tofrom_user((void __user *)(to), \
382 (__force const void __user *)(from), (n))
383#define __copy_to_user_inatomic(to, from, n) __copy_to_user((to), (from), (n))
384
385static inline long copy_to_user(void __user *to,
386 const void *from, unsigned long n)
387{
388 might_fault();
389 if (access_ok(VERIFY_WRITE, to, n))
390 return __copy_to_user(to, from, n);
391 return n;
392}
393
394
395
396
397extern int __strncpy_user(char *to, const char __user *from, int len);
398
399#define __strncpy_from_user __strncpy_user
400
401static inline long
402strncpy_from_user(char *dst, const char __user *src, long count)
403{
404 if (!access_ok(VERIFY_READ, src, 1))
405 return -EFAULT;
406 return __strncpy_from_user(dst, src, count);
407}
408
409
410
411
412
413
414extern int __strnlen_user(const char __user *sstr, int len);
415
416static inline long strnlen_user(const char __user *src, long n)
417{
418 if (!access_ok(VERIFY_READ, src, 1))
419 return 0;
420 return __strnlen_user(src, n);
421}
422
423#endif
424#endif
425
426#endif
427
