]>
Commit | Line | Data |
---|---|---|
5f97f7f9 HS |
1 | /* |
2 | * Copyright (C) 2004-2006 Atmel Corporation | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | */ | |
8 | #ifndef __ASM_AVR32_UACCESS_H | |
9 | #define __ASM_AVR32_UACCESS_H | |
10 | ||
11 | #include <linux/errno.h> | |
12 | #include <linux/sched.h> | |
13 | ||
14 | #define VERIFY_READ 0 | |
15 | #define VERIFY_WRITE 1 | |
16 | ||
17 | typedef struct { | |
18 | unsigned int is_user_space; | |
19 | } mm_segment_t; | |
20 | ||
21 | /* | |
22 | * The fs value determines whether argument validity checking should be | |
23 | * performed or not. If get_fs() == USER_DS, checking is performed, with | |
24 | * get_fs() == KERNEL_DS, checking is bypassed. | |
25 | * | |
26 | * For historical reasons (Data Segment Register?), these macros are misnamed. | |
27 | */ | |
28 | #define MAKE_MM_SEG(s) ((mm_segment_t) { (s) }) | |
29 | #define segment_eq(a,b) ((a).is_user_space == (b).is_user_space) | |
30 | ||
31 | #define USER_ADDR_LIMIT 0x80000000 | |
32 | ||
33 | #define KERNEL_DS MAKE_MM_SEG(0) | |
34 | #define USER_DS MAKE_MM_SEG(1) | |
35 | ||
36 | #define get_ds() (KERNEL_DS) | |
37 | ||
38 | static inline mm_segment_t get_fs(void) | |
39 | { | |
40 | return MAKE_MM_SEG(test_thread_flag(TIF_USERSPACE)); | |
41 | } | |
42 | ||
43 | static inline void set_fs(mm_segment_t s) | |
44 | { | |
45 | if (s.is_user_space) | |
46 | set_thread_flag(TIF_USERSPACE); | |
47 | else | |
48 | clear_thread_flag(TIF_USERSPACE); | |
49 | } | |
50 | ||
51 | /* | |
52 | * Test whether a block of memory is a valid user space address. | |
53 | * Returns 0 if the range is valid, nonzero otherwise. | |
54 | * | |
55 | * We do the following checks: | |
56 | * 1. Is the access from kernel space? | |
57 | * 2. Does (addr + size) set the carry bit? | |
58 | * 3. Is (addr + size) a negative number (i.e. >= 0x80000000)? | |
59 | * | |
60 | * If yes on the first check, access is granted. | |
61 | * If no on any of the others, access is denied. | |
62 | */ | |
63 | #define __range_ok(addr, size) \ | |
64 | (test_thread_flag(TIF_USERSPACE) \ | |
65 | && (((unsigned long)(addr) >= 0x80000000) \ | |
66 | || ((unsigned long)(size) > 0x80000000) \ | |
67 | || (((unsigned long)(addr) + (unsigned long)(size)) > 0x80000000))) | |
68 | ||
69 | #define access_ok(type, addr, size) (likely(__range_ok(addr, size) == 0)) | |
70 | ||
71 | static inline int | |
72 | verify_area(int type, const void __user *addr, unsigned long size) | |
73 | { | |
74 | return access_ok(type, addr, size) ? 0 : -EFAULT; | |
75 | } | |
76 | ||
77 | /* Generic arbitrary sized copy. Return the number of bytes NOT copied */ | |
78 | extern __kernel_size_t __copy_user(void *to, const void *from, | |
79 | __kernel_size_t n); | |
80 | ||
81 | extern __kernel_size_t copy_to_user(void __user *to, const void *from, | |
82 | __kernel_size_t n); | |
83 | extern __kernel_size_t copy_from_user(void *to, const void __user *from, | |
84 | __kernel_size_t n); | |
85 | ||
86 | static inline __kernel_size_t __copy_to_user(void __user *to, const void *from, | |
87 | __kernel_size_t n) | |
88 | { | |
89 | return __copy_user((void __force *)to, from, n); | |
90 | } | |
91 | static inline __kernel_size_t __copy_from_user(void *to, | |
92 | const void __user *from, | |
93 | __kernel_size_t n) | |
94 | { | |
95 | return __copy_user(to, (const void __force *)from, n); | |
96 | } | |
97 | ||
98 | #define __copy_to_user_inatomic __copy_to_user | |
99 | #define __copy_from_user_inatomic __copy_from_user | |
100 | ||
101 | /* | |
102 | * put_user: - Write a simple value into user space. | |
103 | * @x: Value to copy to user space. | |
104 | * @ptr: Destination address, in user space. | |
105 | * | |
106 | * Context: User context only. This function may sleep. | |
107 | * | |
108 | * This macro copies a single simple value from kernel space to user | |
109 | * space. It supports simple types like char and int, but not larger | |
110 | * data types like structures or arrays. | |
111 | * | |
112 | * @ptr must have pointer-to-simple-variable type, and @x must be assignable | |
113 | * to the result of dereferencing @ptr. | |
114 | * | |
115 | * Returns zero on success, or -EFAULT on error. | |
116 | */ | |
117 | #define put_user(x,ptr) \ | |
118 | __put_user_check((x),(ptr),sizeof(*(ptr))) | |
119 | ||
120 | /* | |
121 | * get_user: - Get a simple variable from user space. | |
122 | * @x: Variable to store result. | |
123 | * @ptr: Source address, in user space. | |
124 | * | |
125 | * Context: User context only. This function may sleep. | |
126 | * | |
127 | * This macro copies a single simple variable from user space to kernel | |
128 | * space. It supports simple types like char and int, but not larger | |
129 | * data types like structures or arrays. | |
130 | * | |
131 | * @ptr must have pointer-to-simple-variable type, and the result of | |
132 | * dereferencing @ptr must be assignable to @x without a cast. | |
133 | * | |
134 | * Returns zero on success, or -EFAULT on error. | |
135 | * On error, the variable @x is set to zero. | |
136 | */ | |
137 | #define get_user(x,ptr) \ | |
138 | __get_user_check((x),(ptr),sizeof(*(ptr))) | |
139 | ||
140 | /* | |
141 | * __put_user: - Write a simple value into user space, with less checking. | |
142 | * @x: Value to copy to user space. | |
143 | * @ptr: Destination address, in user space. | |
144 | * | |
145 | * Context: User context only. This function may sleep. | |
146 | * | |
147 | * This macro copies a single simple value from kernel space to user | |
148 | * space. It supports simple types like char and int, but not larger | |
149 | * data types like structures or arrays. | |
150 | * | |
151 | * @ptr must have pointer-to-simple-variable type, and @x must be assignable | |
152 | * to the result of dereferencing @ptr. | |
153 | * | |
154 | * Caller must check the pointer with access_ok() before calling this | |
155 | * function. | |
156 | * | |
157 | * Returns zero on success, or -EFAULT on error. | |
158 | */ | |
159 | #define __put_user(x,ptr) \ | |
160 | __put_user_nocheck((x),(ptr),sizeof(*(ptr))) | |
161 | ||
162 | /* | |
163 | * __get_user: - Get a simple variable from user space, with less checking. | |
164 | * @x: Variable to store result. | |
165 | * @ptr: Source address, in user space. | |
166 | * | |
167 | * Context: User context only. This function may sleep. | |
168 | * | |
169 | * This macro copies a single simple variable from user space to kernel | |
170 | * space. It supports simple types like char and int, but not larger | |
171 | * data types like structures or arrays. | |
172 | * | |
173 | * @ptr must have pointer-to-simple-variable type, and the result of | |
174 | * dereferencing @ptr must be assignable to @x without a cast. | |
175 | * | |
176 | * Caller must check the pointer with access_ok() before calling this | |
177 | * function. | |
178 | * | |
179 | * Returns zero on success, or -EFAULT on error. | |
180 | * On error, the variable @x is set to zero. | |
181 | */ | |
182 | #define __get_user(x,ptr) \ | |
183 | __get_user_nocheck((x),(ptr),sizeof(*(ptr))) | |
184 | ||
185 | extern int __get_user_bad(void); | |
186 | extern int __put_user_bad(void); | |
187 | ||
188 | #define __get_user_nocheck(x, ptr, size) \ | |
189 | ({ \ | |
190 | typeof(*(ptr)) __gu_val = (typeof(*(ptr)) __force)0; \ | |
191 | int __gu_err = 0; \ | |
192 | \ | |
193 | switch (size) { \ | |
194 | case 1: __get_user_asm("ub", __gu_val, ptr, __gu_err); break; \ | |
195 | case 2: __get_user_asm("uh", __gu_val, ptr, __gu_err); break; \ | |
196 | case 4: __get_user_asm("w", __gu_val, ptr, __gu_err); break; \ | |
197 | case 8: __get_user_asm("d", __gu_val, ptr, __gu_err); break; \ | |
198 | default: __gu_err = __get_user_bad(); break; \ | |
199 | } \ | |
200 | \ | |
201 | x = __gu_val; \ | |
202 | __gu_err; \ | |
203 | }) | |
204 | ||
205 | #define __get_user_check(x, ptr, size) \ | |
206 | ({ \ | |
207 | typeof(*(ptr)) __gu_val = (typeof(*(ptr)) __force)0; \ | |
208 | const typeof(*(ptr)) __user * __gu_addr = (ptr); \ | |
209 | int __gu_err = 0; \ | |
210 | \ | |
211 | if (access_ok(VERIFY_READ, __gu_addr, size)) { \ | |
212 | switch (size) { \ | |
213 | case 1: \ | |
214 | __get_user_asm("ub", __gu_val, __gu_addr, \ | |
215 | __gu_err); \ | |
216 | break; \ | |
217 | case 2: \ | |
218 | __get_user_asm("uh", __gu_val, __gu_addr, \ | |
219 | __gu_err); \ | |
220 | break; \ | |
221 | case 4: \ | |
222 | __get_user_asm("w", __gu_val, __gu_addr, \ | |
223 | __gu_err); \ | |
224 | break; \ | |
225 | case 8: \ | |
226 | __get_user_asm("d", __gu_val, __gu_addr, \ | |
227 | __gu_err); \ | |
228 | break; \ | |
229 | default: \ | |
230 | __gu_err = __get_user_bad(); \ | |
231 | break; \ | |
232 | } \ | |
233 | } else { \ | |
234 | __gu_err = -EFAULT; \ | |
235 | } \ | |
236 | x = __gu_val; \ | |
237 | __gu_err; \ | |
238 | }) | |
239 | ||
240 | #define __get_user_asm(suffix, __gu_val, ptr, __gu_err) \ | |
241 | asm volatile( \ | |
242 | "1: ld." suffix " %1, %3 \n" \ | |
243 | "2: \n" \ | |
244 | " .section .fixup, \"ax\" \n" \ | |
245 | "3: mov %0, %4 \n" \ | |
246 | " rjmp 2b \n" \ | |
247 | " .previous \n" \ | |
248 | " .section __ex_table, \"a\" \n" \ | |
249 | " .long 1b, 3b \n" \ | |
250 | " .previous \n" \ | |
251 | : "=r"(__gu_err), "=r"(__gu_val) \ | |
252 | : "0"(__gu_err), "m"(*(ptr)), "i"(-EFAULT)) | |
253 | ||
254 | #define __put_user_nocheck(x, ptr, size) \ | |
255 | ({ \ | |
256 | typeof(*(ptr)) __pu_val; \ | |
257 | int __pu_err = 0; \ | |
258 | \ | |
259 | __pu_val = (x); \ | |
260 | switch (size) { \ | |
261 | case 1: __put_user_asm("b", ptr, __pu_val, __pu_err); break; \ | |
262 | case 2: __put_user_asm("h", ptr, __pu_val, __pu_err); break; \ | |
263 | case 4: __put_user_asm("w", ptr, __pu_val, __pu_err); break; \ | |
264 | case 8: __put_user_asm("d", ptr, __pu_val, __pu_err); break; \ | |
265 | default: __pu_err = __put_user_bad(); break; \ | |
266 | } \ | |
267 | __pu_err; \ | |
268 | }) | |
269 | ||
270 | #define __put_user_check(x, ptr, size) \ | |
271 | ({ \ | |
272 | typeof(*(ptr)) __pu_val; \ | |
273 | typeof(*(ptr)) __user *__pu_addr = (ptr); \ | |
274 | int __pu_err = 0; \ | |
275 | \ | |
276 | __pu_val = (x); \ | |
277 | if (access_ok(VERIFY_WRITE, __pu_addr, size)) { \ | |
278 | switch (size) { \ | |
279 | case 1: \ | |
280 | __put_user_asm("b", __pu_addr, __pu_val, \ | |
281 | __pu_err); \ | |
282 | break; \ | |
283 | case 2: \ | |
284 | __put_user_asm("h", __pu_addr, __pu_val, \ | |
285 | __pu_err); \ | |
286 | break; \ | |
287 | case 4: \ | |
288 | __put_user_asm("w", __pu_addr, __pu_val, \ | |
289 | __pu_err); \ | |
290 | break; \ | |
291 | case 8: \ | |
292 | __put_user_asm("d", __pu_addr, __pu_val, \ | |
293 | __pu_err); \ | |
294 | break; \ | |
295 | default: \ | |
296 | __pu_err = __put_user_bad(); \ | |
297 | break; \ | |
298 | } \ | |
299 | } else { \ | |
300 | __pu_err = -EFAULT; \ | |
301 | } \ | |
302 | __pu_err; \ | |
303 | }) | |
304 | ||
305 | #define __put_user_asm(suffix, ptr, __pu_val, __gu_err) \ | |
306 | asm volatile( \ | |
307 | "1: st." suffix " %1, %3 \n" \ | |
308 | "2: \n" \ | |
309 | " .section .fixup, \"ax\" \n" \ | |
310 | "3: mov %0, %4 \n" \ | |
311 | " rjmp 2b \n" \ | |
312 | " .previous \n" \ | |
313 | " .section __ex_table, \"a\" \n" \ | |
314 | " .long 1b, 3b \n" \ | |
315 | " .previous \n" \ | |
316 | : "=r"(__gu_err), "=m"(*(ptr)) \ | |
317 | : "0"(__gu_err), "r"(__pu_val), "i"(-EFAULT)) | |
318 | ||
319 | extern __kernel_size_t clear_user(void __user *addr, __kernel_size_t size); | |
320 | extern __kernel_size_t __clear_user(void __user *addr, __kernel_size_t size); | |
321 | ||
322 | extern long strncpy_from_user(char *dst, const char __user *src, long count); | |
323 | extern long __strncpy_from_user(char *dst, const char __user *src, long count); | |
324 | ||
325 | extern long strnlen_user(const char __user *__s, long __n); | |
326 | extern long __strnlen_user(const char __user *__s, long __n); | |
327 | ||
328 | #define strlen_user(s) strnlen_user(s, ~0UL >> 1) | |
329 | ||
330 | struct exception_table_entry | |
331 | { | |
332 | unsigned long insn, fixup; | |
333 | }; | |
334 | ||
335 | #endif /* __ASM_AVR32_UACCESS_H */ |