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