?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.18.10
[linux/fpc-iii.git] / arch / microblaze / include / asm / uaccess.h
blob81f16aadbf9ea8fd61df1c91df7bfd64ccf843c3
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 #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 * On Microblaze the fs value is actually the top of the corresponding
25 * address space.
26 *
27 * The fs value determines whether argument validity checking should be
28 * performed or not. If get_fs() == USER_DS, checking is performed, with
29 * get_fs() == KERNEL_DS, checking is bypassed.
30 *
31 * For historical reasons, these macros are grossly misnamed.
32 *
33 * For non-MMU arch like Microblaze, KERNEL_DS and USER_DS is equal.
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 /* Check against bounds of physical memory */
54 static 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
67 static 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 }
80 ok:
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
96 extern unsigned long __copy_tofrom_user(void __user *to,
97 const void __user *from, unsigned long size);
98
99 /* Return: number of not copied bytes, i.e. 0 if OK or non-zero if fail. */
100 static inline unsigned long __must_check __clear_user(void __user *to,
101 unsigned long n)
102 {
103 /* normal memset with two words to __ex_table */
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
119 static 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 /* put_user and get_user macros */
130 extern 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 * get_user: - Get a simple variable from user space.
152 * @x: Variable to store result.
153 * @ptr: Source address, in user space.
154 *
155 * Context: User context only. This function may sleep if pagefaults are
156 * enabled.
157 *
158 * This macro copies a single simple variable from user space to kernel
159 * space. It supports simple types like char and int, but not larger
160 * data types like structures or arrays.
161 *
162 * @ptr must have pointer-to-simple-variable type, and the result of
163 * dereferencing @ptr must be assignable to @x without a cast.
164 *
165 * Returns zero on success, or -EFAULT on error.
166 * On error, the variable @x is set to zero.
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 /*unsigned long __gu_ptr = (unsigned long)(ptr);*/ \
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_val = 0; __gu_err = -EINVAL;*/ __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 * put_user: - Write a simple value into user space.
265 * @x: Value to copy to user space.
266 * @ptr: Destination address, in user space.
267 *
268 * Context: User context only. This function may sleep if pagefaults are
269 * enabled.
270 *
271 * This macro copies a single simple value from kernel space to user
272 * space. It supports simple types like char and int, but not larger
273 * data types like structures or arrays.
274 *
275 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
276 * to the result of dereferencing @ptr.
277 *
278 * Returns zero on success, or -EFAULT on error.
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 = -EINVAL;*/ __gu_err = __user_bad(); \
335 } \
336 __gu_err; \
337 })
338
339 static inline unsigned long
340 raw_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
345 static inline unsigned long
346 raw_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 * Copy a null terminated string from userspace.
355 */
356 extern int __strncpy_user(char *to, const char __user *from, int len);
357
358 static inline long
359 strncpy_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 * Return the size of a string (including the ending 0)
368 *
369 * Return 0 on exception, a value greater than N if too long
370 */
371 extern int __strnlen_user(const char __user *sstr, int len);
372
373 static 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 /* _ASM_MICROBLAZE_UACCESS_H */
Linux with added FPC-III support