Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * This file is subject to the terms and conditions of the GNU General Public | |
3 | * License. See the file "COPYING" in the main directory of this archive | |
4 | * for more details. | |
5 | * | |
6 | * Copyright (C) 1996, 1997, 1998, 1999, 2000, 03, 04 by Ralf Baechle | |
7 | * Copyright (C) 1999, 2000 Silicon Graphics, Inc. | |
8 | */ | |
9 | #ifndef _ASM_UACCESS_H | |
10 | #define _ASM_UACCESS_H | |
11 | ||
1da177e4 LT |
12 | #include <linux/kernel.h> |
13 | #include <linux/errno.h> | |
14 | #include <linux/thread_info.h> | |
15 | #include <asm-generic/uaccess.h> | |
16 | ||
17 | /* | |
18 | * The fs value determines whether argument validity checking should be | |
19 | * performed or not. If get_fs() == USER_DS, checking is performed, with | |
20 | * get_fs() == KERNEL_DS, checking is bypassed. | |
21 | * | |
22 | * For historical reasons, these macros are grossly misnamed. | |
23 | */ | |
875d43e7 | 24 | #ifdef CONFIG_32BIT |
1da177e4 LT |
25 | |
26 | #define __UA_LIMIT 0x80000000UL | |
27 | ||
28 | #define __UA_ADDR ".word" | |
29 | #define __UA_LA "la" | |
30 | #define __UA_ADDU "addu" | |
31 | #define __UA_t0 "$8" | |
32 | #define __UA_t1 "$9" | |
33 | ||
875d43e7 | 34 | #endif /* CONFIG_32BIT */ |
1da177e4 | 35 | |
875d43e7 | 36 | #ifdef CONFIG_64BIT |
1da177e4 LT |
37 | |
38 | #define __UA_LIMIT (- TASK_SIZE) | |
39 | ||
40 | #define __UA_ADDR ".dword" | |
41 | #define __UA_LA "dla" | |
42 | #define __UA_ADDU "daddu" | |
43 | #define __UA_t0 "$12" | |
44 | #define __UA_t1 "$13" | |
45 | ||
875d43e7 | 46 | #endif /* CONFIG_64BIT */ |
1da177e4 LT |
47 | |
48 | /* | |
49 | * USER_DS is a bitmask that has the bits set that may not be set in a valid | |
50 | * userspace address. Note that we limit 32-bit userspace to 0x7fff8000 but | |
51 | * the arithmetic we're doing only works if the limit is a power of two, so | |
52 | * we use 0x80000000 here on 32-bit kernels. If a process passes an invalid | |
53 | * address in this range it's the process's problem, not ours :-) | |
54 | */ | |
55 | ||
56 | #define KERNEL_DS ((mm_segment_t) { 0UL }) | |
57 | #define USER_DS ((mm_segment_t) { __UA_LIMIT }) | |
58 | ||
59 | #define VERIFY_READ 0 | |
60 | #define VERIFY_WRITE 1 | |
61 | ||
62 | #define get_ds() (KERNEL_DS) | |
63 | #define get_fs() (current_thread_info()->addr_limit) | |
64 | #define set_fs(x) (current_thread_info()->addr_limit = (x)) | |
65 | ||
66 | #define segment_eq(a,b) ((a).seg == (b).seg) | |
67 | ||
68 | ||
69 | /* | |
70 | * Is a address valid? This does a straighforward calculation rather | |
71 | * than tests. | |
72 | * | |
73 | * Address valid if: | |
74 | * - "addr" doesn't have any high-bits set | |
75 | * - AND "size" doesn't have any high-bits set | |
76 | * - AND "addr+size" doesn't have any high-bits set | |
77 | * - OR we are in kernel mode. | |
78 | * | |
79 | * __ua_size() is a trick to avoid runtime checking of positive constant | |
80 | * sizes; for those we already know at compile time that the size is ok. | |
81 | */ | |
82 | #define __ua_size(size) \ | |
83 | ((__builtin_constant_p(size) && (signed long) (size) > 0) ? 0 : (size)) | |
84 | ||
85 | /* | |
86 | * access_ok: - Checks if a user space pointer is valid | |
87 | * @type: Type of access: %VERIFY_READ or %VERIFY_WRITE. Note that | |
88 | * %VERIFY_WRITE is a superset of %VERIFY_READ - if it is safe | |
89 | * to write to a block, it is always safe to read from it. | |
90 | * @addr: User space pointer to start of block to check | |
91 | * @size: Size of block to check | |
92 | * | |
93 | * Context: User context only. This function may sleep. | |
94 | * | |
95 | * Checks if a pointer to a block of memory in user space is valid. | |
96 | * | |
97 | * Returns true (nonzero) if the memory block may be valid, false (zero) | |
98 | * if it is definitely invalid. | |
99 | * | |
100 | * Note that, depending on architecture, this function probably just | |
101 | * checks that the pointer is in the user space range - after calling | |
102 | * this function, memory access functions may still return -EFAULT. | |
103 | */ | |
104 | ||
105 | #define __access_mask get_fs().seg | |
106 | ||
107 | #define __access_ok(addr, size, mask) \ | |
108 | (((signed long)((mask) & ((addr) | ((addr) + (size)) | __ua_size(size)))) == 0) | |
109 | ||
110 | #define access_ok(type, addr, size) \ | |
111 | likely(__access_ok((unsigned long)(addr), (size),__access_mask)) | |
112 | ||
1da177e4 LT |
113 | /* |
114 | * put_user: - Write a simple value into user space. | |
115 | * @x: Value to copy to user space. | |
116 | * @ptr: Destination address, in user space. | |
117 | * | |
118 | * Context: User context only. This function may sleep. | |
119 | * | |
120 | * This macro copies a single simple value from kernel space to user | |
121 | * space. It supports simple types like char and int, but not larger | |
122 | * data types like structures or arrays. | |
123 | * | |
124 | * @ptr must have pointer-to-simple-variable type, and @x must be assignable | |
125 | * to the result of dereferencing @ptr. | |
126 | * | |
127 | * Returns zero on success, or -EFAULT on error. | |
128 | */ | |
129 | #define put_user(x,ptr) \ | |
130 | __put_user_check((x),(ptr),sizeof(*(ptr))) | |
131 | ||
132 | /* | |
133 | * get_user: - Get a simple variable from user space. | |
134 | * @x: Variable to store result. | |
135 | * @ptr: Source address, in user space. | |
136 | * | |
137 | * Context: User context only. This function may sleep. | |
138 | * | |
139 | * This macro copies a single simple variable from user space to kernel | |
140 | * space. It supports simple types like char and int, but not larger | |
141 | * data types like structures or arrays. | |
142 | * | |
143 | * @ptr must have pointer-to-simple-variable type, and the result of | |
144 | * dereferencing @ptr must be assignable to @x without a cast. | |
145 | * | |
146 | * Returns zero on success, or -EFAULT on error. | |
147 | * On error, the variable @x is set to zero. | |
148 | */ | |
149 | #define get_user(x,ptr) \ | |
150 | __get_user_check((x),(ptr),sizeof(*(ptr))) | |
151 | ||
152 | /* | |
153 | * __put_user: - Write a simple value into user space, with less checking. | |
154 | * @x: Value to copy to user space. | |
155 | * @ptr: Destination address, in user space. | |
156 | * | |
157 | * Context: User context only. This function may sleep. | |
158 | * | |
159 | * This macro copies a single simple value from kernel space to user | |
160 | * space. It supports simple types like char and int, but not larger | |
161 | * data types like structures or arrays. | |
162 | * | |
163 | * @ptr must have pointer-to-simple-variable type, and @x must be assignable | |
164 | * to the result of dereferencing @ptr. | |
165 | * | |
166 | * Caller must check the pointer with access_ok() before calling this | |
167 | * function. | |
168 | * | |
169 | * Returns zero on success, or -EFAULT on error. | |
170 | */ | |
171 | #define __put_user(x,ptr) \ | |
172 | __put_user_nocheck((x),(ptr),sizeof(*(ptr))) | |
173 | ||
174 | /* | |
175 | * __get_user: - Get a simple variable from user space, with less checking. | |
176 | * @x: Variable to store result. | |
177 | * @ptr: Source address, in user space. | |
178 | * | |
179 | * Context: User context only. This function may sleep. | |
180 | * | |
181 | * This macro copies a single simple variable from user space to kernel | |
182 | * space. It supports simple types like char and int, but not larger | |
183 | * data types like structures or arrays. | |
184 | * | |
185 | * @ptr must have pointer-to-simple-variable type, and the result of | |
186 | * dereferencing @ptr must be assignable to @x without a cast. | |
187 | * | |
188 | * Caller must check the pointer with access_ok() before calling this | |
189 | * function. | |
190 | * | |
191 | * Returns zero on success, or -EFAULT on error. | |
192 | * On error, the variable @x is set to zero. | |
193 | */ | |
194 | #define __get_user(x,ptr) \ | |
195 | __get_user_nocheck((x),(ptr),sizeof(*(ptr))) | |
196 | ||
197 | struct __large_struct { unsigned long buf[100]; }; | |
fe00f943 | 198 | #define __m(x) (*(struct __large_struct __user *)(x)) |
1da177e4 LT |
199 | |
200 | /* | |
201 | * Yuck. We need two variants, one for 64bit operation and one | |
202 | * for 32 bit mode and old iron. | |
203 | */ | |
4feb8f8f RB |
204 | #ifdef CONFIG_32BIT |
205 | #define __GET_USER_DW(val, ptr) __get_user_asm_ll32(val, ptr) | |
206 | #endif | |
207 | #ifdef CONFIG_64BIT | |
208 | #define __GET_USER_DW(val, ptr) __get_user_asm(val, "ld", ptr) | |
1da177e4 LT |
209 | #endif |
210 | ||
4feb8f8f RB |
211 | extern void __get_user_unknown(void); |
212 | ||
213 | #define __get_user_common(val, size, ptr) \ | |
214 | do { \ | |
1da177e4 | 215 | switch (size) { \ |
4feb8f8f RB |
216 | case 1: __get_user_asm(val, "lb", ptr); break; \ |
217 | case 2: __get_user_asm(val, "lh", ptr); break; \ | |
218 | case 4: __get_user_asm(val, "lw", ptr); break; \ | |
219 | case 8: __GET_USER_DW(val, ptr); break; \ | |
1da177e4 LT |
220 | default: __get_user_unknown(); break; \ |
221 | } \ | |
4feb8f8f RB |
222 | } while (0) |
223 | ||
224 | #define __get_user_nocheck(x,ptr,size) \ | |
225 | ({ \ | |
226 | long __gu_err; \ | |
227 | \ | |
228 | __get_user_common((x), size, ptr); \ | |
1da177e4 LT |
229 | __gu_err; \ |
230 | }) | |
231 | ||
232 | #define __get_user_check(x,ptr,size) \ | |
233 | ({ \ | |
fe00f943 | 234 | long __gu_err = -EFAULT; \ |
8ecbbcaf | 235 | const __typeof__(*(ptr)) __user * __gu_ptr = (ptr); \ |
4feb8f8f RB |
236 | \ |
237 | if (likely(access_ok(VERIFY_READ, __gu_ptr, size))) \ | |
238 | __get_user_common((x), size, __gu_ptr); \ | |
1da177e4 | 239 | \ |
1da177e4 LT |
240 | __gu_err; \ |
241 | }) | |
242 | ||
4feb8f8f | 243 | #define __get_user_asm(val, insn, addr) \ |
fe00f943 | 244 | { \ |
4feb8f8f RB |
245 | long __gu_tmp; \ |
246 | \ | |
1da177e4 LT |
247 | __asm__ __volatile__( \ |
248 | "1: " insn " %1, %3 \n" \ | |
249 | "2: \n" \ | |
250 | " .section .fixup,\"ax\" \n" \ | |
251 | "3: li %0, %4 \n" \ | |
252 | " j 2b \n" \ | |
253 | " .previous \n" \ | |
254 | " .section __ex_table,\"a\" \n" \ | |
255 | " "__UA_ADDR "\t1b, 3b \n" \ | |
256 | " .previous \n" \ | |
4feb8f8f | 257 | : "=r" (__gu_err), "=r" (__gu_tmp) \ |
fe00f943 | 258 | : "0" (0), "o" (__m(addr)), "i" (-EFAULT)); \ |
4feb8f8f | 259 | \ |
8ecbbcaf | 260 | (val) = (__typeof__(*(addr))) __gu_tmp; \ |
fe00f943 | 261 | } |
1da177e4 LT |
262 | |
263 | /* | |
264 | * Get a long long 64 using 32 bit registers. | |
265 | */ | |
4feb8f8f | 266 | #define __get_user_asm_ll32(val, addr) \ |
fe00f943 | 267 | { \ |
cb66fb3f RB |
268 | union { \ |
269 | unsigned long long l; \ | |
270 | __typeof__(*(addr)) t; \ | |
271 | } __gu_tmp; \ | |
cd1fb9ea | 272 | \ |
1da177e4 | 273 | __asm__ __volatile__( \ |
fe00f943 RB |
274 | "1: lw %1, (%3) \n" \ |
275 | "2: lw %D1, 4(%3) \n" \ | |
1da177e4 | 276 | "3: .section .fixup,\"ax\" \n" \ |
fe00f943 | 277 | "4: li %0, %4 \n" \ |
1da177e4 LT |
278 | " move %1, $0 \n" \ |
279 | " move %D1, $0 \n" \ | |
280 | " j 3b \n" \ | |
281 | " .previous \n" \ | |
282 | " .section __ex_table,\"a\" \n" \ | |
283 | " " __UA_ADDR " 1b, 4b \n" \ | |
284 | " " __UA_ADDR " 2b, 4b \n" \ | |
285 | " .previous \n" \ | |
cb66fb3f | 286 | : "=r" (__gu_err), "=&r" (__gu_tmp.l) \ |
fe00f943 | 287 | : "0" (0), "r" (addr), "i" (-EFAULT)); \ |
cb66fb3f RB |
288 | \ |
289 | (val) = __gu_tmp.t; \ | |
fe00f943 | 290 | } |
1da177e4 | 291 | |
1da177e4 LT |
292 | /* |
293 | * Yuck. We need two variants, one for 64bit operation and one | |
294 | * for 32 bit mode and old iron. | |
295 | */ | |
4feb8f8f | 296 | #ifdef CONFIG_32BIT |
fe00f943 | 297 | #define __PUT_USER_DW(ptr) __put_user_asm_ll32(ptr) |
1da177e4 | 298 | #endif |
4feb8f8f RB |
299 | #ifdef CONFIG_64BIT |
300 | #define __PUT_USER_DW(ptr) __put_user_asm("sd", ptr) | |
301 | #endif | |
1da177e4 LT |
302 | |
303 | #define __put_user_nocheck(x,ptr,size) \ | |
304 | ({ \ | |
305 | __typeof__(*(ptr)) __pu_val; \ | |
1da177e4 LT |
306 | long __pu_err = 0; \ |
307 | \ | |
1da177e4 | 308 | __pu_val = (x); \ |
1da177e4 | 309 | switch (size) { \ |
fe00f943 RB |
310 | case 1: __put_user_asm("sb", ptr); break; \ |
311 | case 2: __put_user_asm("sh", ptr); break; \ | |
312 | case 4: __put_user_asm("sw", ptr); break; \ | |
313 | case 8: __PUT_USER_DW(ptr); break; \ | |
1da177e4 LT |
314 | default: __put_user_unknown(); break; \ |
315 | } \ | |
316 | __pu_err; \ | |
317 | }) | |
318 | ||
319 | #define __put_user_check(x,ptr,size) \ | |
320 | ({ \ | |
fe00f943 RB |
321 | __typeof__(*(ptr)) __user *__pu_addr = (ptr); \ |
322 | __typeof__(*(ptr)) __pu_val = (x); \ | |
323 | long __pu_err = -EFAULT; \ | |
1da177e4 | 324 | \ |
fe00f943 | 325 | if (likely(access_ok(VERIFY_WRITE, __pu_addr, size))) { \ |
1da177e4 | 326 | switch (size) { \ |
fe00f943 RB |
327 | case 1: __put_user_asm("sb", __pu_addr); break; \ |
328 | case 2: __put_user_asm("sh", __pu_addr); break; \ | |
329 | case 4: __put_user_asm("sw", __pu_addr); break; \ | |
330 | case 8: __PUT_USER_DW(__pu_addr); break; \ | |
1da177e4 LT |
331 | default: __put_user_unknown(); break; \ |
332 | } \ | |
333 | } \ | |
334 | __pu_err; \ | |
335 | }) | |
336 | ||
fe00f943 RB |
337 | #define __put_user_asm(insn, ptr) \ |
338 | { \ | |
1da177e4 LT |
339 | __asm__ __volatile__( \ |
340 | "1: " insn " %z2, %3 # __put_user_asm\n" \ | |
341 | "2: \n" \ | |
342 | " .section .fixup,\"ax\" \n" \ | |
343 | "3: li %0, %4 \n" \ | |
344 | " j 2b \n" \ | |
345 | " .previous \n" \ | |
346 | " .section __ex_table,\"a\" \n" \ | |
347 | " " __UA_ADDR " 1b, 3b \n" \ | |
348 | " .previous \n" \ | |
349 | : "=r" (__pu_err) \ | |
fe00f943 | 350 | : "0" (0), "Jr" (__pu_val), "o" (__m(ptr)), \ |
1da177e4 | 351 | "i" (-EFAULT)); \ |
fe00f943 | 352 | } |
1da177e4 | 353 | |
fe00f943 RB |
354 | #define __put_user_asm_ll32(ptr) \ |
355 | { \ | |
1da177e4 | 356 | __asm__ __volatile__( \ |
fe00f943 RB |
357 | "1: sw %2, (%3) # __put_user_asm_ll32 \n" \ |
358 | "2: sw %D2, 4(%3) \n" \ | |
1da177e4 LT |
359 | "3: \n" \ |
360 | " .section .fixup,\"ax\" \n" \ | |
fe00f943 | 361 | "4: li %0, %4 \n" \ |
1da177e4 LT |
362 | " j 3b \n" \ |
363 | " .previous \n" \ | |
364 | " .section __ex_table,\"a\" \n" \ | |
365 | " " __UA_ADDR " 1b, 4b \n" \ | |
366 | " " __UA_ADDR " 2b, 4b \n" \ | |
367 | " .previous" \ | |
368 | : "=r" (__pu_err) \ | |
fe00f943 RB |
369 | : "0" (0), "r" (__pu_val), "r" (ptr), \ |
370 | "i" (-EFAULT)); \ | |
371 | } | |
1da177e4 LT |
372 | |
373 | extern void __put_user_unknown(void); | |
374 | ||
375 | /* | |
376 | * We're generating jump to subroutines which will be outside the range of | |
377 | * jump instructions | |
378 | */ | |
379 | #ifdef MODULE | |
380 | #define __MODULE_JAL(destination) \ | |
381 | ".set\tnoat\n\t" \ | |
382 | __UA_LA "\t$1, " #destination "\n\t" \ | |
383 | "jalr\t$1\n\t" \ | |
384 | ".set\tat\n\t" | |
385 | #else | |
386 | #define __MODULE_JAL(destination) \ | |
387 | "jal\t" #destination "\n\t" | |
388 | #endif | |
389 | ||
390 | extern size_t __copy_user(void *__to, const void *__from, size_t __n); | |
391 | ||
392 | #define __invoke_copy_to_user(to,from,n) \ | |
393 | ({ \ | |
fe00f943 | 394 | register void __user *__cu_to_r __asm__ ("$4"); \ |
1da177e4 LT |
395 | register const void *__cu_from_r __asm__ ("$5"); \ |
396 | register long __cu_len_r __asm__ ("$6"); \ | |
397 | \ | |
398 | __cu_to_r = (to); \ | |
399 | __cu_from_r = (from); \ | |
400 | __cu_len_r = (n); \ | |
401 | __asm__ __volatile__( \ | |
402 | __MODULE_JAL(__copy_user) \ | |
403 | : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r) \ | |
404 | : \ | |
405 | : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31", \ | |
406 | "memory"); \ | |
407 | __cu_len_r; \ | |
408 | }) | |
409 | ||
410 | /* | |
411 | * __copy_to_user: - Copy a block of data into user space, with less checking. | |
412 | * @to: Destination address, in user space. | |
413 | * @from: Source address, in kernel space. | |
414 | * @n: Number of bytes to copy. | |
415 | * | |
416 | * Context: User context only. This function may sleep. | |
417 | * | |
418 | * Copy data from kernel space to user space. Caller must check | |
419 | * the specified block with access_ok() before calling this function. | |
420 | * | |
421 | * Returns number of bytes that could not be copied. | |
422 | * On success, this will be zero. | |
423 | */ | |
424 | #define __copy_to_user(to,from,n) \ | |
425 | ({ \ | |
fe00f943 | 426 | void __user *__cu_to; \ |
1da177e4 LT |
427 | const void *__cu_from; \ |
428 | long __cu_len; \ | |
429 | \ | |
430 | might_sleep(); \ | |
431 | __cu_to = (to); \ | |
432 | __cu_from = (from); \ | |
433 | __cu_len = (n); \ | |
434 | __cu_len = __invoke_copy_to_user(__cu_to, __cu_from, __cu_len); \ | |
435 | __cu_len; \ | |
436 | }) | |
437 | ||
d0c91ae2 RB |
438 | extern size_t __copy_user_inatomic(void *__to, const void *__from, size_t __n); |
439 | ||
e03b5269 RB |
440 | #define __copy_to_user_inatomic(to,from,n) \ |
441 | ({ \ | |
442 | void __user *__cu_to; \ | |
443 | const void *__cu_from; \ | |
444 | long __cu_len; \ | |
445 | \ | |
446 | __cu_to = (to); \ | |
447 | __cu_from = (from); \ | |
448 | __cu_len = (n); \ | |
449 | __cu_len = __invoke_copy_to_user(__cu_to, __cu_from, __cu_len); \ | |
450 | __cu_len; \ | |
451 | }) | |
452 | ||
453 | #define __copy_from_user_inatomic(to,from,n) \ | |
454 | ({ \ | |
455 | void *__cu_to; \ | |
456 | const void __user *__cu_from; \ | |
457 | long __cu_len; \ | |
458 | \ | |
459 | __cu_to = (to); \ | |
460 | __cu_from = (from); \ | |
461 | __cu_len = (n); \ | |
462 | __cu_len = __invoke_copy_from_user_inatomic(__cu_to, __cu_from, \ | |
463 | __cu_len); \ | |
464 | __cu_len; \ | |
465 | }) | |
1da177e4 LT |
466 | |
467 | /* | |
468 | * copy_to_user: - Copy a block of data into user space. | |
469 | * @to: Destination address, in user space. | |
470 | * @from: Source address, in kernel space. | |
471 | * @n: Number of bytes to copy. | |
472 | * | |
473 | * Context: User context only. This function may sleep. | |
474 | * | |
475 | * Copy data from kernel space to user space. | |
476 | * | |
477 | * Returns number of bytes that could not be copied. | |
478 | * On success, this will be zero. | |
479 | */ | |
480 | #define copy_to_user(to,from,n) \ | |
481 | ({ \ | |
fe00f943 | 482 | void __user *__cu_to; \ |
1da177e4 LT |
483 | const void *__cu_from; \ |
484 | long __cu_len; \ | |
485 | \ | |
486 | might_sleep(); \ | |
487 | __cu_to = (to); \ | |
488 | __cu_from = (from); \ | |
489 | __cu_len = (n); \ | |
490 | if (access_ok(VERIFY_WRITE, __cu_to, __cu_len)) \ | |
491 | __cu_len = __invoke_copy_to_user(__cu_to, __cu_from, \ | |
492 | __cu_len); \ | |
493 | __cu_len; \ | |
494 | }) | |
495 | ||
496 | #define __invoke_copy_from_user(to,from,n) \ | |
497 | ({ \ | |
498 | register void *__cu_to_r __asm__ ("$4"); \ | |
fe00f943 | 499 | register const void __user *__cu_from_r __asm__ ("$5"); \ |
1da177e4 LT |
500 | register long __cu_len_r __asm__ ("$6"); \ |
501 | \ | |
502 | __cu_to_r = (to); \ | |
503 | __cu_from_r = (from); \ | |
504 | __cu_len_r = (n); \ | |
505 | __asm__ __volatile__( \ | |
506 | ".set\tnoreorder\n\t" \ | |
507 | __MODULE_JAL(__copy_user) \ | |
508 | ".set\tnoat\n\t" \ | |
509 | __UA_ADDU "\t$1, %1, %2\n\t" \ | |
510 | ".set\tat\n\t" \ | |
511 | ".set\treorder" \ | |
512 | : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r) \ | |
513 | : \ | |
e03b5269 RB |
514 | : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31", \ |
515 | "memory"); \ | |
516 | __cu_len_r; \ | |
517 | }) | |
518 | ||
519 | #define __invoke_copy_from_user_inatomic(to,from,n) \ | |
520 | ({ \ | |
521 | register void *__cu_to_r __asm__ ("$4"); \ | |
522 | register const void __user *__cu_from_r __asm__ ("$5"); \ | |
523 | register long __cu_len_r __asm__ ("$6"); \ | |
524 | \ | |
525 | __cu_to_r = (to); \ | |
526 | __cu_from_r = (from); \ | |
527 | __cu_len_r = (n); \ | |
528 | __asm__ __volatile__( \ | |
529 | ".set\tnoreorder\n\t" \ | |
530 | __MODULE_JAL(__copy_user_inatomic) \ | |
531 | ".set\tnoat\n\t" \ | |
532 | __UA_ADDU "\t$1, %1, %2\n\t" \ | |
533 | ".set\tat\n\t" \ | |
534 | ".set\treorder" \ | |
535 | : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r) \ | |
536 | : \ | |
1da177e4 LT |
537 | : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31", \ |
538 | "memory"); \ | |
539 | __cu_len_r; \ | |
540 | }) | |
541 | ||
542 | /* | |
131c1a2b CD |
543 | * __copy_from_user: - Copy a block of data from user space, with less checking. |
544 | * @to: Destination address, in kernel space. | |
1da177e4 LT |
545 | * @from: Source address, in user space. |
546 | * @n: Number of bytes to copy. | |
547 | * | |
548 | * Context: User context only. This function may sleep. | |
549 | * | |
550 | * Copy data from user space to kernel space. Caller must check | |
551 | * the specified block with access_ok() before calling this function. | |
552 | * | |
553 | * Returns number of bytes that could not be copied. | |
554 | * On success, this will be zero. | |
555 | * | |
556 | * If some data could not be copied, this function will pad the copied | |
557 | * data to the requested size using zero bytes. | |
558 | */ | |
559 | #define __copy_from_user(to,from,n) \ | |
560 | ({ \ | |
561 | void *__cu_to; \ | |
fe00f943 | 562 | const void __user *__cu_from; \ |
1da177e4 LT |
563 | long __cu_len; \ |
564 | \ | |
565 | might_sleep(); \ | |
566 | __cu_to = (to); \ | |
567 | __cu_from = (from); \ | |
568 | __cu_len = (n); \ | |
569 | __cu_len = __invoke_copy_from_user(__cu_to, __cu_from, \ | |
570 | __cu_len); \ | |
571 | __cu_len; \ | |
572 | }) | |
573 | ||
574 | /* | |
575 | * copy_from_user: - Copy a block of data from user space. | |
576 | * @to: Destination address, in kernel space. | |
577 | * @from: Source address, in user space. | |
578 | * @n: Number of bytes to copy. | |
579 | * | |
580 | * Context: User context only. This function may sleep. | |
581 | * | |
582 | * Copy data from user space to kernel space. | |
583 | * | |
584 | * Returns number of bytes that could not be copied. | |
585 | * On success, this will be zero. | |
586 | * | |
587 | * If some data could not be copied, this function will pad the copied | |
588 | * data to the requested size using zero bytes. | |
589 | */ | |
590 | #define copy_from_user(to,from,n) \ | |
591 | ({ \ | |
592 | void *__cu_to; \ | |
fe00f943 | 593 | const void __user *__cu_from; \ |
1da177e4 LT |
594 | long __cu_len; \ |
595 | \ | |
596 | might_sleep(); \ | |
597 | __cu_to = (to); \ | |
598 | __cu_from = (from); \ | |
599 | __cu_len = (n); \ | |
600 | if (access_ok(VERIFY_READ, __cu_from, __cu_len)) \ | |
601 | __cu_len = __invoke_copy_from_user(__cu_to, __cu_from, \ | |
602 | __cu_len); \ | |
603 | __cu_len; \ | |
604 | }) | |
605 | ||
606 | #define __copy_in_user(to, from, n) __copy_from_user(to, from, n) | |
607 | ||
608 | #define copy_in_user(to,from,n) \ | |
609 | ({ \ | |
fe00f943 RB |
610 | void __user *__cu_to; \ |
611 | const void __user *__cu_from; \ | |
1da177e4 LT |
612 | long __cu_len; \ |
613 | \ | |
614 | might_sleep(); \ | |
615 | __cu_to = (to); \ | |
616 | __cu_from = (from); \ | |
617 | __cu_len = (n); \ | |
618 | if (likely(access_ok(VERIFY_READ, __cu_from, __cu_len) && \ | |
619 | access_ok(VERIFY_WRITE, __cu_to, __cu_len))) \ | |
620 | __cu_len = __invoke_copy_from_user(__cu_to, __cu_from, \ | |
621 | __cu_len); \ | |
622 | __cu_len; \ | |
623 | }) | |
624 | ||
625 | /* | |
626 | * __clear_user: - Zero a block of memory in user space, with less checking. | |
627 | * @to: Destination address, in user space. | |
628 | * @n: Number of bytes to zero. | |
629 | * | |
630 | * Zero a block of memory in user space. Caller must check | |
631 | * the specified block with access_ok() before calling this function. | |
632 | * | |
633 | * Returns number of bytes that could not be cleared. | |
634 | * On success, this will be zero. | |
635 | */ | |
636 | static inline __kernel_size_t | |
fe00f943 | 637 | __clear_user(void __user *addr, __kernel_size_t size) |
1da177e4 LT |
638 | { |
639 | __kernel_size_t res; | |
640 | ||
641 | might_sleep(); | |
642 | __asm__ __volatile__( | |
643 | "move\t$4, %1\n\t" | |
644 | "move\t$5, $0\n\t" | |
645 | "move\t$6, %2\n\t" | |
646 | __MODULE_JAL(__bzero) | |
647 | "move\t%0, $6" | |
648 | : "=r" (res) | |
649 | : "r" (addr), "r" (size) | |
650 | : "$4", "$5", "$6", __UA_t0, __UA_t1, "$31"); | |
651 | ||
652 | return res; | |
653 | } | |
654 | ||
655 | #define clear_user(addr,n) \ | |
656 | ({ \ | |
fe00f943 | 657 | void __user * __cl_addr = (addr); \ |
1da177e4 LT |
658 | unsigned long __cl_size = (n); \ |
659 | if (__cl_size && access_ok(VERIFY_WRITE, \ | |
660 | ((unsigned long)(__cl_addr)), __cl_size)) \ | |
661 | __cl_size = __clear_user(__cl_addr, __cl_size); \ | |
662 | __cl_size; \ | |
663 | }) | |
664 | ||
665 | /* | |
666 | * __strncpy_from_user: - Copy a NUL terminated string from userspace, with less checking. | |
667 | * @dst: Destination address, in kernel space. This buffer must be at | |
668 | * least @count bytes long. | |
669 | * @src: Source address, in user space. | |
670 | * @count: Maximum number of bytes to copy, including the trailing NUL. | |
671 | * | |
672 | * Copies a NUL-terminated string from userspace to kernel space. | |
673 | * Caller must check the specified block with access_ok() before calling | |
674 | * this function. | |
675 | * | |
676 | * On success, returns the length of the string (not including the trailing | |
677 | * NUL). | |
678 | * | |
679 | * If access to userspace fails, returns -EFAULT (some data may have been | |
680 | * copied). | |
681 | * | |
682 | * If @count is smaller than the length of the string, copies @count bytes | |
683 | * and returns @count. | |
684 | */ | |
685 | static inline long | |
fe00f943 | 686 | __strncpy_from_user(char *__to, const char __user *__from, long __len) |
1da177e4 LT |
687 | { |
688 | long res; | |
689 | ||
690 | might_sleep(); | |
691 | __asm__ __volatile__( | |
692 | "move\t$4, %1\n\t" | |
693 | "move\t$5, %2\n\t" | |
694 | "move\t$6, %3\n\t" | |
695 | __MODULE_JAL(__strncpy_from_user_nocheck_asm) | |
696 | "move\t%0, $2" | |
697 | : "=r" (res) | |
698 | : "r" (__to), "r" (__from), "r" (__len) | |
699 | : "$2", "$3", "$4", "$5", "$6", __UA_t0, "$31", "memory"); | |
700 | ||
701 | return res; | |
702 | } | |
703 | ||
704 | /* | |
705 | * strncpy_from_user: - Copy a NUL terminated string from userspace. | |
706 | * @dst: Destination address, in kernel space. This buffer must be at | |
707 | * least @count bytes long. | |
708 | * @src: Source address, in user space. | |
709 | * @count: Maximum number of bytes to copy, including the trailing NUL. | |
710 | * | |
711 | * Copies a NUL-terminated string from userspace to kernel space. | |
712 | * | |
713 | * On success, returns the length of the string (not including the trailing | |
714 | * NUL). | |
715 | * | |
716 | * If access to userspace fails, returns -EFAULT (some data may have been | |
717 | * copied). | |
718 | * | |
719 | * If @count is smaller than the length of the string, copies @count bytes | |
720 | * and returns @count. | |
721 | */ | |
722 | static inline long | |
fe00f943 | 723 | strncpy_from_user(char *__to, const char __user *__from, long __len) |
1da177e4 LT |
724 | { |
725 | long res; | |
726 | ||
727 | might_sleep(); | |
728 | __asm__ __volatile__( | |
729 | "move\t$4, %1\n\t" | |
730 | "move\t$5, %2\n\t" | |
731 | "move\t$6, %3\n\t" | |
732 | __MODULE_JAL(__strncpy_from_user_asm) | |
733 | "move\t%0, $2" | |
734 | : "=r" (res) | |
735 | : "r" (__to), "r" (__from), "r" (__len) | |
736 | : "$2", "$3", "$4", "$5", "$6", __UA_t0, "$31", "memory"); | |
737 | ||
738 | return res; | |
739 | } | |
740 | ||
741 | /* Returns: 0 if bad, string length+1 (memory size) of string if ok */ | |
fe00f943 | 742 | static inline long __strlen_user(const char __user *s) |
1da177e4 LT |
743 | { |
744 | long res; | |
745 | ||
746 | might_sleep(); | |
747 | __asm__ __volatile__( | |
748 | "move\t$4, %1\n\t" | |
749 | __MODULE_JAL(__strlen_user_nocheck_asm) | |
750 | "move\t%0, $2" | |
751 | : "=r" (res) | |
752 | : "r" (s) | |
753 | : "$2", "$4", __UA_t0, "$31"); | |
754 | ||
755 | return res; | |
756 | } | |
757 | ||
758 | /* | |
759 | * strlen_user: - Get the size of a string in user space. | |
760 | * @str: The string to measure. | |
761 | * | |
762 | * Context: User context only. This function may sleep. | |
763 | * | |
764 | * Get the size of a NUL-terminated string in user space. | |
765 | * | |
766 | * Returns the size of the string INCLUDING the terminating NUL. | |
767 | * On exception, returns 0. | |
768 | * | |
769 | * If there is a limit on the length of a valid string, you may wish to | |
770 | * consider using strnlen_user() instead. | |
771 | */ | |
fe00f943 | 772 | static inline long strlen_user(const char __user *s) |
1da177e4 LT |
773 | { |
774 | long res; | |
775 | ||
776 | might_sleep(); | |
777 | __asm__ __volatile__( | |
778 | "move\t$4, %1\n\t" | |
779 | __MODULE_JAL(__strlen_user_asm) | |
780 | "move\t%0, $2" | |
781 | : "=r" (res) | |
782 | : "r" (s) | |
783 | : "$2", "$4", __UA_t0, "$31"); | |
784 | ||
785 | return res; | |
786 | } | |
787 | ||
788 | /* Returns: 0 if bad, string length+1 (memory size) of string if ok */ | |
fe00f943 | 789 | static inline long __strnlen_user(const char __user *s, long n) |
1da177e4 LT |
790 | { |
791 | long res; | |
792 | ||
793 | might_sleep(); | |
794 | __asm__ __volatile__( | |
795 | "move\t$4, %1\n\t" | |
796 | "move\t$5, %2\n\t" | |
797 | __MODULE_JAL(__strnlen_user_nocheck_asm) | |
798 | "move\t%0, $2" | |
799 | : "=r" (res) | |
800 | : "r" (s), "r" (n) | |
801 | : "$2", "$4", "$5", __UA_t0, "$31"); | |
802 | ||
803 | return res; | |
804 | } | |
805 | ||
806 | /* | |
807 | * strlen_user: - Get the size of a string in user space. | |
808 | * @str: The string to measure. | |
809 | * | |
810 | * Context: User context only. This function may sleep. | |
811 | * | |
812 | * Get the size of a NUL-terminated string in user space. | |
813 | * | |
814 | * Returns the size of the string INCLUDING the terminating NUL. | |
815 | * On exception, returns 0. | |
816 | * | |
817 | * If there is a limit on the length of a valid string, you may wish to | |
818 | * consider using strnlen_user() instead. | |
819 | */ | |
fe00f943 | 820 | static inline long strnlen_user(const char __user *s, long n) |
1da177e4 LT |
821 | { |
822 | long res; | |
823 | ||
824 | might_sleep(); | |
825 | __asm__ __volatile__( | |
826 | "move\t$4, %1\n\t" | |
827 | "move\t$5, %2\n\t" | |
828 | __MODULE_JAL(__strnlen_user_asm) | |
829 | "move\t%0, $2" | |
830 | : "=r" (res) | |
831 | : "r" (s), "r" (n) | |
832 | : "$2", "$4", "$5", __UA_t0, "$31"); | |
833 | ||
834 | return res; | |
835 | } | |
836 | ||
837 | struct exception_table_entry | |
838 | { | |
839 | unsigned long insn; | |
840 | unsigned long nextinsn; | |
841 | }; | |
842 | ||
843 | extern int fixup_exception(struct pt_regs *regs); | |
844 | ||
845 | #endif /* _ASM_UACCESS_H */ |