?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/efi: Enforce CONFIG_RELOCATABLE for EFI boot stub
[linux/fpc-iii.git] / arch / microblaze / include / asm / uaccess.h
blob0aa005703a0b5f348848afb5936f650d18f28322
1 /*
2 * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
3 * Copyright (C) 2008-2009 PetaLogix
4 * Copyright (C) 2006 Atmark Techno, Inc.
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
8 * for more details.
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> /* RLIMIT_FSIZE */
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 * On Microblaze the fs value is actually the top of the corresponding
32 * address space.
33 *
34 * The fs value determines whether argument validity checking should be
35 * performed or not. If get_fs() == USER_DS, checking is performed, with
36 * get_fs() == KERNEL_DS, checking is bypassed.
37 *
38 * For historical reasons, these macros are grossly misnamed.
39 *
40 * For non-MMU arch like Microblaze, KERNEL_DS and USER_DS is equal.
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 * The exception table consists of pairs of addresses: the first is the
60 * address of an instruction that is allowed to fault, and the second is
61 * the address at which the program should continue. No registers are
62 * modified, so it is entirely up to the continuation code to figure out
63 * what to do.
64 *
65 * All the routines below use bits of fixup code that are out of line
66 * with the main instruction path. This means when everything is well,
67 * we don't even have to jump over them. Further, they do not intrude
68 * on our cache or tlb entries.
69 */
70 struct exception_table_entry {
71 unsigned long insn, fixup;
72 };
73
74 /* Returns 0 if exception not found and fixup otherwise. */
75 extern unsigned long search_exception_table(unsigned long);
76
77 #ifndef CONFIG_MMU
78
79 /* Check against bounds of physical memory */
80 static 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
93 static 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 }
106 ok:
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
122 extern unsigned long __copy_tofrom_user(void __user *to,
123 const void __user *from, unsigned long size);
124
125 /* Return: number of not copied bytes, i.e. 0 if OK or non-zero if fail. */
126 static inline unsigned long __must_check __clear_user(void __user *to,
127 unsigned long n)
128 {
129 /* normal memset with two words to __ex_table */
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
145 static 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 /* put_user and get_user macros */
156 extern 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 * get_user: - Get a simple variable from user space.
178 * @x: Variable to store result.
179 * @ptr: Source address, in user space.
180 *
181 * Context: User context only. This function may sleep.
182 *
183 * This macro copies a single simple variable from user space to kernel
184 * space. It supports simple types like char and int, but not larger
185 * data types like structures or arrays.
186 *
187 * @ptr must have pointer-to-simple-variable type, and the result of
188 * dereferencing @ptr must be assignable to @x without a cast.
189 *
190 * Returns zero on success, or -EFAULT on error.
191 * On error, the variable @x is set to zero.
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 /*unsigned long __gu_ptr = (unsigned long)(ptr);*/ \
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_val = 0; __gu_err = -EINVAL;*/ __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 * put_user: - Write a simple value into user space.
290 * @x: Value to copy to user space.
291 * @ptr: Destination address, in user space.
292 *
293 * Context: User context only. This function may sleep.
294 *
295 * This macro copies a single simple value from kernel space to user
296 * space. It supports simple types like char and int, but not larger
297 * data types like structures or arrays.
298 *
299 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
300 * to the result of dereferencing @ptr.
301 *
302 * Returns zero on success, or -EFAULT on error.
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 = -EINVAL;*/ __gu_err = __user_bad(); \
359 } \
360 __gu_err; \
361 })
362
363
364 /* copy_to_from_user */
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
371 static 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
385 static 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 * Copy a null terminated string from userspace.
396 */
397 extern int __strncpy_user(char *to, const char __user *from, int len);
398
399 #define __strncpy_from_user __strncpy_user
400
401 static inline long
402 strncpy_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 * Return the size of a string (including the ending 0)
411 *
412 * Return 0 on exception, a value greater than N if too long
413 */
414 extern int __strnlen_user(const char __user *sstr, int len);
415
416 static 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 /* __ASSEMBLY__ */
424 #endif /* __KERNEL__ */
425
426 #endif /* _ASM_MICROBLAZE_UACCESS_H */
Linux with added FPC-III support