]>
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. | |
619b6e18 | 8 | * Copyright (C) 2007 Maciej W. Rozycki |
1da177e4 LT |
9 | */ |
10 | #ifndef _ASM_UACCESS_H | |
11 | #define _ASM_UACCESS_H | |
12 | ||
1da177e4 LT |
13 | #include <linux/kernel.h> |
14 | #include <linux/errno.h> | |
15 | #include <linux/thread_info.h> | |
1da177e4 LT |
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 | 37 | |
949e51be DD |
38 | extern u64 __ua_limit; |
39 | ||
40 | #define __UA_LIMIT __ua_limit | |
1da177e4 LT |
41 | |
42 | #define __UA_ADDR ".dword" | |
43 | #define __UA_LA "dla" | |
44 | #define __UA_ADDU "daddu" | |
45 | #define __UA_t0 "$12" | |
46 | #define __UA_t1 "$13" | |
47 | ||
875d43e7 | 48 | #endif /* CONFIG_64BIT */ |
1da177e4 LT |
49 | |
50 | /* | |
51 | * USER_DS is a bitmask that has the bits set that may not be set in a valid | |
52 | * userspace address. Note that we limit 32-bit userspace to 0x7fff8000 but | |
53 | * the arithmetic we're doing only works if the limit is a power of two, so | |
54 | * we use 0x80000000 here on 32-bit kernels. If a process passes an invalid | |
55 | * address in this range it's the process's problem, not ours :-) | |
56 | */ | |
57 | ||
58 | #define KERNEL_DS ((mm_segment_t) { 0UL }) | |
59 | #define USER_DS ((mm_segment_t) { __UA_LIMIT }) | |
60 | ||
61 | #define VERIFY_READ 0 | |
62 | #define VERIFY_WRITE 1 | |
63 | ||
64 | #define get_ds() (KERNEL_DS) | |
65 | #define get_fs() (current_thread_info()->addr_limit) | |
66 | #define set_fs(x) (current_thread_info()->addr_limit = (x)) | |
67 | ||
21a151d8 | 68 | #define segment_eq(a, b) ((a).seg == (b).seg) |
1da177e4 LT |
69 | |
70 | ||
71 | /* | |
72 | * Is a address valid? This does a straighforward calculation rather | |
73 | * than tests. | |
74 | * | |
75 | * Address valid if: | |
76 | * - "addr" doesn't have any high-bits set | |
77 | * - AND "size" doesn't have any high-bits set | |
78 | * - AND "addr+size" doesn't have any high-bits set | |
79 | * - OR we are in kernel mode. | |
80 | * | |
81 | * __ua_size() is a trick to avoid runtime checking of positive constant | |
82 | * sizes; for those we already know at compile time that the size is ok. | |
83 | */ | |
84 | #define __ua_size(size) \ | |
85 | ((__builtin_constant_p(size) && (signed long) (size) > 0) ? 0 : (size)) | |
86 | ||
87 | /* | |
88 | * access_ok: - Checks if a user space pointer is valid | |
89 | * @type: Type of access: %VERIFY_READ or %VERIFY_WRITE. Note that | |
90 | * %VERIFY_WRITE is a superset of %VERIFY_READ - if it is safe | |
91 | * to write to a block, it is always safe to read from it. | |
92 | * @addr: User space pointer to start of block to check | |
93 | * @size: Size of block to check | |
94 | * | |
95 | * Context: User context only. This function may sleep. | |
96 | * | |
97 | * Checks if a pointer to a block of memory in user space is valid. | |
98 | * | |
99 | * Returns true (nonzero) if the memory block may be valid, false (zero) | |
100 | * if it is definitely invalid. | |
101 | * | |
102 | * Note that, depending on architecture, this function probably just | |
103 | * checks that the pointer is in the user space range - after calling | |
104 | * this function, memory access functions may still return -EFAULT. | |
105 | */ | |
106 | ||
107 | #define __access_mask get_fs().seg | |
108 | ||
ed01b3d2 RB |
109 | #define __access_ok(addr, size, mask) \ |
110 | ({ \ | |
111 | unsigned long __addr = (unsigned long) (addr); \ | |
112 | unsigned long __size = size; \ | |
113 | unsigned long __mask = mask; \ | |
114 | unsigned long __ok; \ | |
115 | \ | |
116 | __chk_user_ptr(addr); \ | |
117 | __ok = (signed long)(__mask & (__addr | (__addr + __size) | \ | |
118 | __ua_size(__size))); \ | |
119 | __ok == 0; \ | |
d0aab922 | 120 | }) |
1da177e4 LT |
121 | |
122 | #define access_ok(type, addr, size) \ | |
d0aab922 | 123 | likely(__access_ok((addr), (size), __access_mask)) |
1da177e4 | 124 | |
1da177e4 LT |
125 | /* |
126 | * put_user: - Write a simple value into user space. | |
127 | * @x: Value to copy to user space. | |
128 | * @ptr: Destination address, in user space. | |
129 | * | |
130 | * Context: User context only. This function may sleep. | |
131 | * | |
132 | * This macro copies a single simple value from kernel space to user | |
133 | * space. It supports simple types like char and int, but not larger | |
134 | * data types like structures or arrays. | |
135 | * | |
136 | * @ptr must have pointer-to-simple-variable type, and @x must be assignable | |
137 | * to the result of dereferencing @ptr. | |
138 | * | |
139 | * Returns zero on success, or -EFAULT on error. | |
140 | */ | |
141 | #define put_user(x,ptr) \ | |
21a151d8 | 142 | __put_user_check((x), (ptr), sizeof(*(ptr))) |
1da177e4 LT |
143 | |
144 | /* | |
145 | * get_user: - Get a simple variable from user space. | |
146 | * @x: Variable to store result. | |
147 | * @ptr: Source address, in user space. | |
148 | * | |
149 | * Context: User context only. This function may sleep. | |
150 | * | |
151 | * This macro copies a single simple variable from user space to kernel | |
152 | * space. It supports simple types like char and int, but not larger | |
153 | * data types like structures or arrays. | |
154 | * | |
155 | * @ptr must have pointer-to-simple-variable type, and the result of | |
156 | * dereferencing @ptr must be assignable to @x without a cast. | |
157 | * | |
158 | * Returns zero on success, or -EFAULT on error. | |
159 | * On error, the variable @x is set to zero. | |
160 | */ | |
161 | #define get_user(x,ptr) \ | |
21a151d8 | 162 | __get_user_check((x), (ptr), sizeof(*(ptr))) |
1da177e4 LT |
163 | |
164 | /* | |
165 | * __put_user: - Write a simple value into user space, with less checking. | |
166 | * @x: Value to copy to user space. | |
167 | * @ptr: Destination address, in user space. | |
168 | * | |
169 | * Context: User context only. This function may sleep. | |
170 | * | |
171 | * This macro copies a single simple value from kernel space to user | |
172 | * space. It supports simple types like char and int, but not larger | |
173 | * data types like structures or arrays. | |
174 | * | |
175 | * @ptr must have pointer-to-simple-variable type, and @x must be assignable | |
176 | * to the result of dereferencing @ptr. | |
177 | * | |
178 | * Caller must check the pointer with access_ok() before calling this | |
179 | * function. | |
180 | * | |
181 | * Returns zero on success, or -EFAULT on error. | |
182 | */ | |
183 | #define __put_user(x,ptr) \ | |
21a151d8 | 184 | __put_user_nocheck((x), (ptr), sizeof(*(ptr))) |
1da177e4 LT |
185 | |
186 | /* | |
187 | * __get_user: - Get a simple variable from user space, with less checking. | |
188 | * @x: Variable to store result. | |
189 | * @ptr: Source address, in user space. | |
190 | * | |
191 | * Context: User context only. This function may sleep. | |
192 | * | |
193 | * This macro copies a single simple variable from user space to kernel | |
194 | * space. It supports simple types like char and int, but not larger | |
195 | * data types like structures or arrays. | |
196 | * | |
197 | * @ptr must have pointer-to-simple-variable type, and the result of | |
198 | * dereferencing @ptr must be assignable to @x without a cast. | |
199 | * | |
200 | * Caller must check the pointer with access_ok() before calling this | |
201 | * function. | |
202 | * | |
203 | * Returns zero on success, or -EFAULT on error. | |
204 | * On error, the variable @x is set to zero. | |
205 | */ | |
206 | #define __get_user(x,ptr) \ | |
21a151d8 | 207 | __get_user_nocheck((x), (ptr), sizeof(*(ptr))) |
1da177e4 LT |
208 | |
209 | struct __large_struct { unsigned long buf[100]; }; | |
fe00f943 | 210 | #define __m(x) (*(struct __large_struct __user *)(x)) |
1da177e4 LT |
211 | |
212 | /* | |
213 | * Yuck. We need two variants, one for 64bit operation and one | |
214 | * for 32 bit mode and old iron. | |
215 | */ | |
4feb8f8f RB |
216 | #ifdef CONFIG_32BIT |
217 | #define __GET_USER_DW(val, ptr) __get_user_asm_ll32(val, ptr) | |
218 | #endif | |
219 | #ifdef CONFIG_64BIT | |
220 | #define __GET_USER_DW(val, ptr) __get_user_asm(val, "ld", ptr) | |
1da177e4 LT |
221 | #endif |
222 | ||
4feb8f8f RB |
223 | extern void __get_user_unknown(void); |
224 | ||
225 | #define __get_user_common(val, size, ptr) \ | |
226 | do { \ | |
1da177e4 | 227 | switch (size) { \ |
4feb8f8f RB |
228 | case 1: __get_user_asm(val, "lb", ptr); break; \ |
229 | case 2: __get_user_asm(val, "lh", ptr); break; \ | |
230 | case 4: __get_user_asm(val, "lw", ptr); break; \ | |
231 | case 8: __GET_USER_DW(val, ptr); break; \ | |
1da177e4 LT |
232 | default: __get_user_unknown(); break; \ |
233 | } \ | |
4feb8f8f RB |
234 | } while (0) |
235 | ||
21a151d8 | 236 | #define __get_user_nocheck(x, ptr, size) \ |
4feb8f8f | 237 | ({ \ |
8d2d91e8 | 238 | int __gu_err; \ |
4feb8f8f | 239 | \ |
ed01b3d2 | 240 | __chk_user_ptr(ptr); \ |
4feb8f8f | 241 | __get_user_common((x), size, ptr); \ |
1da177e4 LT |
242 | __gu_err; \ |
243 | }) | |
244 | ||
21a151d8 | 245 | #define __get_user_check(x, ptr, size) \ |
1da177e4 | 246 | ({ \ |
8d2d91e8 | 247 | int __gu_err = -EFAULT; \ |
8ecbbcaf | 248 | const __typeof__(*(ptr)) __user * __gu_ptr = (ptr); \ |
4feb8f8f | 249 | \ |
ef41f460 | 250 | might_fault(); \ |
4feb8f8f RB |
251 | if (likely(access_ok(VERIFY_READ, __gu_ptr, size))) \ |
252 | __get_user_common((x), size, __gu_ptr); \ | |
1da177e4 | 253 | \ |
1da177e4 LT |
254 | __gu_err; \ |
255 | }) | |
256 | ||
4feb8f8f | 257 | #define __get_user_asm(val, insn, addr) \ |
fe00f943 | 258 | { \ |
4feb8f8f RB |
259 | long __gu_tmp; \ |
260 | \ | |
1da177e4 LT |
261 | __asm__ __volatile__( \ |
262 | "1: " insn " %1, %3 \n" \ | |
263 | "2: \n" \ | |
264 | " .section .fixup,\"ax\" \n" \ | |
265 | "3: li %0, %4 \n" \ | |
266 | " j 2b \n" \ | |
267 | " .previous \n" \ | |
268 | " .section __ex_table,\"a\" \n" \ | |
269 | " "__UA_ADDR "\t1b, 3b \n" \ | |
270 | " .previous \n" \ | |
4feb8f8f | 271 | : "=r" (__gu_err), "=r" (__gu_tmp) \ |
fe00f943 | 272 | : "0" (0), "o" (__m(addr)), "i" (-EFAULT)); \ |
4feb8f8f | 273 | \ |
8ecbbcaf | 274 | (val) = (__typeof__(*(addr))) __gu_tmp; \ |
fe00f943 | 275 | } |
1da177e4 LT |
276 | |
277 | /* | |
278 | * Get a long long 64 using 32 bit registers. | |
279 | */ | |
4feb8f8f | 280 | #define __get_user_asm_ll32(val, addr) \ |
fe00f943 | 281 | { \ |
cb66fb3f RB |
282 | union { \ |
283 | unsigned long long l; \ | |
284 | __typeof__(*(addr)) t; \ | |
285 | } __gu_tmp; \ | |
cd1fb9ea | 286 | \ |
1da177e4 | 287 | __asm__ __volatile__( \ |
fe00f943 RB |
288 | "1: lw %1, (%3) \n" \ |
289 | "2: lw %D1, 4(%3) \n" \ | |
1da177e4 | 290 | "3: .section .fixup,\"ax\" \n" \ |
fe00f943 | 291 | "4: li %0, %4 \n" \ |
1da177e4 LT |
292 | " move %1, $0 \n" \ |
293 | " move %D1, $0 \n" \ | |
294 | " j 3b \n" \ | |
295 | " .previous \n" \ | |
296 | " .section __ex_table,\"a\" \n" \ | |
297 | " " __UA_ADDR " 1b, 4b \n" \ | |
298 | " " __UA_ADDR " 2b, 4b \n" \ | |
299 | " .previous \n" \ | |
cb66fb3f | 300 | : "=r" (__gu_err), "=&r" (__gu_tmp.l) \ |
fe00f943 | 301 | : "0" (0), "r" (addr), "i" (-EFAULT)); \ |
cb66fb3f RB |
302 | \ |
303 | (val) = __gu_tmp.t; \ | |
fe00f943 | 304 | } |
1da177e4 | 305 | |
1da177e4 LT |
306 | /* |
307 | * Yuck. We need two variants, one for 64bit operation and one | |
308 | * for 32 bit mode and old iron. | |
309 | */ | |
4feb8f8f | 310 | #ifdef CONFIG_32BIT |
fe00f943 | 311 | #define __PUT_USER_DW(ptr) __put_user_asm_ll32(ptr) |
1da177e4 | 312 | #endif |
4feb8f8f RB |
313 | #ifdef CONFIG_64BIT |
314 | #define __PUT_USER_DW(ptr) __put_user_asm("sd", ptr) | |
315 | #endif | |
1da177e4 | 316 | |
21a151d8 | 317 | #define __put_user_nocheck(x, ptr, size) \ |
1da177e4 LT |
318 | ({ \ |
319 | __typeof__(*(ptr)) __pu_val; \ | |
8d2d91e8 | 320 | int __pu_err = 0; \ |
1da177e4 | 321 | \ |
ed01b3d2 | 322 | __chk_user_ptr(ptr); \ |
1da177e4 | 323 | __pu_val = (x); \ |
1da177e4 | 324 | switch (size) { \ |
fe00f943 RB |
325 | case 1: __put_user_asm("sb", ptr); break; \ |
326 | case 2: __put_user_asm("sh", ptr); break; \ | |
327 | case 4: __put_user_asm("sw", ptr); break; \ | |
328 | case 8: __PUT_USER_DW(ptr); break; \ | |
1da177e4 LT |
329 | default: __put_user_unknown(); break; \ |
330 | } \ | |
331 | __pu_err; \ | |
332 | }) | |
333 | ||
21a151d8 | 334 | #define __put_user_check(x, ptr, size) \ |
1da177e4 | 335 | ({ \ |
fe00f943 RB |
336 | __typeof__(*(ptr)) __user *__pu_addr = (ptr); \ |
337 | __typeof__(*(ptr)) __pu_val = (x); \ | |
8d2d91e8 | 338 | int __pu_err = -EFAULT; \ |
1da177e4 | 339 | \ |
ef41f460 | 340 | might_fault(); \ |
fe00f943 | 341 | if (likely(access_ok(VERIFY_WRITE, __pu_addr, size))) { \ |
1da177e4 | 342 | switch (size) { \ |
fe00f943 RB |
343 | case 1: __put_user_asm("sb", __pu_addr); break; \ |
344 | case 2: __put_user_asm("sh", __pu_addr); break; \ | |
345 | case 4: __put_user_asm("sw", __pu_addr); break; \ | |
346 | case 8: __PUT_USER_DW(__pu_addr); break; \ | |
1da177e4 LT |
347 | default: __put_user_unknown(); break; \ |
348 | } \ | |
349 | } \ | |
350 | __pu_err; \ | |
351 | }) | |
352 | ||
fe00f943 RB |
353 | #define __put_user_asm(insn, ptr) \ |
354 | { \ | |
1da177e4 LT |
355 | __asm__ __volatile__( \ |
356 | "1: " insn " %z2, %3 # __put_user_asm\n" \ | |
357 | "2: \n" \ | |
358 | " .section .fixup,\"ax\" \n" \ | |
359 | "3: li %0, %4 \n" \ | |
360 | " j 2b \n" \ | |
361 | " .previous \n" \ | |
362 | " .section __ex_table,\"a\" \n" \ | |
363 | " " __UA_ADDR " 1b, 3b \n" \ | |
364 | " .previous \n" \ | |
365 | : "=r" (__pu_err) \ | |
fe00f943 | 366 | : "0" (0), "Jr" (__pu_val), "o" (__m(ptr)), \ |
1da177e4 | 367 | "i" (-EFAULT)); \ |
fe00f943 | 368 | } |
1da177e4 | 369 | |
fe00f943 RB |
370 | #define __put_user_asm_ll32(ptr) \ |
371 | { \ | |
1da177e4 | 372 | __asm__ __volatile__( \ |
fe00f943 RB |
373 | "1: sw %2, (%3) # __put_user_asm_ll32 \n" \ |
374 | "2: sw %D2, 4(%3) \n" \ | |
1da177e4 LT |
375 | "3: \n" \ |
376 | " .section .fixup,\"ax\" \n" \ | |
fe00f943 | 377 | "4: li %0, %4 \n" \ |
1da177e4 LT |
378 | " j 3b \n" \ |
379 | " .previous \n" \ | |
380 | " .section __ex_table,\"a\" \n" \ | |
381 | " " __UA_ADDR " 1b, 4b \n" \ | |
382 | " " __UA_ADDR " 2b, 4b \n" \ | |
383 | " .previous" \ | |
384 | : "=r" (__pu_err) \ | |
fe00f943 RB |
385 | : "0" (0), "r" (__pu_val), "r" (ptr), \ |
386 | "i" (-EFAULT)); \ | |
387 | } | |
1da177e4 LT |
388 | |
389 | extern void __put_user_unknown(void); | |
390 | ||
71ec6ccf RB |
391 | /* |
392 | * put_user_unaligned: - Write a simple value into user space. | |
393 | * @x: Value to copy to user space. | |
394 | * @ptr: Destination address, in user space. | |
395 | * | |
396 | * Context: User context only. This function may sleep. | |
397 | * | |
398 | * This macro copies a single simple value from kernel space to user | |
399 | * space. It supports simple types like char and int, but not larger | |
400 | * data types like structures or arrays. | |
401 | * | |
402 | * @ptr must have pointer-to-simple-variable type, and @x must be assignable | |
403 | * to the result of dereferencing @ptr. | |
404 | * | |
405 | * Returns zero on success, or -EFAULT on error. | |
406 | */ | |
407 | #define put_user_unaligned(x,ptr) \ | |
408 | __put_user_unaligned_check((x),(ptr),sizeof(*(ptr))) | |
409 | ||
410 | /* | |
411 | * get_user_unaligned: - Get a simple variable from user space. | |
412 | * @x: Variable to store result. | |
413 | * @ptr: Source address, in user space. | |
414 | * | |
415 | * Context: User context only. This function may sleep. | |
416 | * | |
417 | * This macro copies a single simple variable from user space to kernel | |
418 | * space. It supports simple types like char and int, but not larger | |
419 | * data types like structures or arrays. | |
420 | * | |
421 | * @ptr must have pointer-to-simple-variable type, and the result of | |
422 | * dereferencing @ptr must be assignable to @x without a cast. | |
423 | * | |
424 | * Returns zero on success, or -EFAULT on error. | |
425 | * On error, the variable @x is set to zero. | |
426 | */ | |
427 | #define get_user_unaligned(x,ptr) \ | |
428 | __get_user_unaligned_check((x),(ptr),sizeof(*(ptr))) | |
429 | ||
430 | /* | |
431 | * __put_user_unaligned: - Write a simple value into user space, with less checking. | |
432 | * @x: Value to copy to user space. | |
433 | * @ptr: Destination address, in user space. | |
434 | * | |
435 | * Context: User context only. This function may sleep. | |
436 | * | |
437 | * This macro copies a single simple value from kernel space to user | |
438 | * space. It supports simple types like char and int, but not larger | |
439 | * data types like structures or arrays. | |
440 | * | |
441 | * @ptr must have pointer-to-simple-variable type, and @x must be assignable | |
442 | * to the result of dereferencing @ptr. | |
443 | * | |
444 | * Caller must check the pointer with access_ok() before calling this | |
445 | * function. | |
446 | * | |
447 | * Returns zero on success, or -EFAULT on error. | |
448 | */ | |
449 | #define __put_user_unaligned(x,ptr) \ | |
450 | __put_user_unaligned_nocheck((x),(ptr),sizeof(*(ptr))) | |
451 | ||
452 | /* | |
453 | * __get_user_unaligned: - Get a simple variable from user space, with less checking. | |
454 | * @x: Variable to store result. | |
455 | * @ptr: Source address, in user space. | |
456 | * | |
457 | * Context: User context only. This function may sleep. | |
458 | * | |
459 | * This macro copies a single simple variable from user space to kernel | |
460 | * space. It supports simple types like char and int, but not larger | |
461 | * data types like structures or arrays. | |
462 | * | |
463 | * @ptr must have pointer-to-simple-variable type, and the result of | |
464 | * dereferencing @ptr must be assignable to @x without a cast. | |
465 | * | |
466 | * Caller must check the pointer with access_ok() before calling this | |
467 | * function. | |
468 | * | |
469 | * Returns zero on success, or -EFAULT on error. | |
470 | * On error, the variable @x is set to zero. | |
471 | */ | |
472 | #define __get_user_unaligned(x,ptr) \ | |
473 | __get_user__unalignednocheck((x),(ptr),sizeof(*(ptr))) | |
474 | ||
475 | /* | |
476 | * Yuck. We need two variants, one for 64bit operation and one | |
477 | * for 32 bit mode and old iron. | |
478 | */ | |
479 | #ifdef CONFIG_32BIT | |
480 | #define __GET_USER_UNALIGNED_DW(val, ptr) \ | |
481 | __get_user_unaligned_asm_ll32(val, ptr) | |
482 | #endif | |
483 | #ifdef CONFIG_64BIT | |
484 | #define __GET_USER_UNALIGNED_DW(val, ptr) \ | |
485 | __get_user_unaligned_asm(val, "uld", ptr) | |
486 | #endif | |
487 | ||
488 | extern void __get_user_unaligned_unknown(void); | |
489 | ||
490 | #define __get_user_unaligned_common(val, size, ptr) \ | |
491 | do { \ | |
492 | switch (size) { \ | |
493 | case 1: __get_user_asm(val, "lb", ptr); break; \ | |
494 | case 2: __get_user_unaligned_asm(val, "ulh", ptr); break; \ | |
495 | case 4: __get_user_unaligned_asm(val, "ulw", ptr); break; \ | |
496 | case 8: __GET_USER_UNALIGNED_DW(val, ptr); break; \ | |
497 | default: __get_user_unaligned_unknown(); break; \ | |
498 | } \ | |
499 | } while (0) | |
500 | ||
501 | #define __get_user_unaligned_nocheck(x,ptr,size) \ | |
502 | ({ \ | |
503 | int __gu_err; \ | |
504 | \ | |
505 | __get_user_unaligned_common((x), size, ptr); \ | |
506 | __gu_err; \ | |
507 | }) | |
508 | ||
509 | #define __get_user_unaligned_check(x,ptr,size) \ | |
510 | ({ \ | |
511 | int __gu_err = -EFAULT; \ | |
512 | const __typeof__(*(ptr)) __user * __gu_ptr = (ptr); \ | |
513 | \ | |
514 | if (likely(access_ok(VERIFY_READ, __gu_ptr, size))) \ | |
515 | __get_user_unaligned_common((x), size, __gu_ptr); \ | |
516 | \ | |
517 | __gu_err; \ | |
518 | }) | |
519 | ||
520 | #define __get_user_unaligned_asm(val, insn, addr) \ | |
521 | { \ | |
522 | long __gu_tmp; \ | |
523 | \ | |
524 | __asm__ __volatile__( \ | |
525 | "1: " insn " %1, %3 \n" \ | |
526 | "2: \n" \ | |
527 | " .section .fixup,\"ax\" \n" \ | |
528 | "3: li %0, %4 \n" \ | |
529 | " j 2b \n" \ | |
530 | " .previous \n" \ | |
531 | " .section __ex_table,\"a\" \n" \ | |
532 | " "__UA_ADDR "\t1b, 3b \n" \ | |
533 | " "__UA_ADDR "\t1b + 4, 3b \n" \ | |
534 | " .previous \n" \ | |
535 | : "=r" (__gu_err), "=r" (__gu_tmp) \ | |
536 | : "0" (0), "o" (__m(addr)), "i" (-EFAULT)); \ | |
537 | \ | |
538 | (val) = (__typeof__(*(addr))) __gu_tmp; \ | |
539 | } | |
540 | ||
541 | /* | |
542 | * Get a long long 64 using 32 bit registers. | |
543 | */ | |
544 | #define __get_user_unaligned_asm_ll32(val, addr) \ | |
545 | { \ | |
546 | unsigned long long __gu_tmp; \ | |
547 | \ | |
548 | __asm__ __volatile__( \ | |
549 | "1: ulw %1, (%3) \n" \ | |
550 | "2: ulw %D1, 4(%3) \n" \ | |
551 | " move %0, $0 \n" \ | |
552 | "3: .section .fixup,\"ax\" \n" \ | |
553 | "4: li %0, %4 \n" \ | |
554 | " move %1, $0 \n" \ | |
555 | " move %D1, $0 \n" \ | |
556 | " j 3b \n" \ | |
557 | " .previous \n" \ | |
558 | " .section __ex_table,\"a\" \n" \ | |
559 | " " __UA_ADDR " 1b, 4b \n" \ | |
560 | " " __UA_ADDR " 1b + 4, 4b \n" \ | |
561 | " " __UA_ADDR " 2b, 4b \n" \ | |
562 | " " __UA_ADDR " 2b + 4, 4b \n" \ | |
563 | " .previous \n" \ | |
564 | : "=r" (__gu_err), "=&r" (__gu_tmp) \ | |
565 | : "0" (0), "r" (addr), "i" (-EFAULT)); \ | |
566 | (val) = (__typeof__(*(addr))) __gu_tmp; \ | |
567 | } | |
568 | ||
569 | /* | |
570 | * Yuck. We need two variants, one for 64bit operation and one | |
571 | * for 32 bit mode and old iron. | |
572 | */ | |
573 | #ifdef CONFIG_32BIT | |
574 | #define __PUT_USER_UNALIGNED_DW(ptr) __put_user_unaligned_asm_ll32(ptr) | |
575 | #endif | |
576 | #ifdef CONFIG_64BIT | |
577 | #define __PUT_USER_UNALIGNED_DW(ptr) __put_user_unaligned_asm("usd", ptr) | |
578 | #endif | |
579 | ||
580 | #define __put_user_unaligned_nocheck(x,ptr,size) \ | |
581 | ({ \ | |
582 | __typeof__(*(ptr)) __pu_val; \ | |
583 | int __pu_err = 0; \ | |
584 | \ | |
585 | __pu_val = (x); \ | |
586 | switch (size) { \ | |
587 | case 1: __put_user_asm("sb", ptr); break; \ | |
588 | case 2: __put_user_unaligned_asm("ush", ptr); break; \ | |
589 | case 4: __put_user_unaligned_asm("usw", ptr); break; \ | |
590 | case 8: __PUT_USER_UNALIGNED_DW(ptr); break; \ | |
591 | default: __put_user_unaligned_unknown(); break; \ | |
592 | } \ | |
593 | __pu_err; \ | |
594 | }) | |
595 | ||
596 | #define __put_user_unaligned_check(x,ptr,size) \ | |
597 | ({ \ | |
598 | __typeof__(*(ptr)) __user *__pu_addr = (ptr); \ | |
599 | __typeof__(*(ptr)) __pu_val = (x); \ | |
600 | int __pu_err = -EFAULT; \ | |
601 | \ | |
602 | if (likely(access_ok(VERIFY_WRITE, __pu_addr, size))) { \ | |
603 | switch (size) { \ | |
604 | case 1: __put_user_asm("sb", __pu_addr); break; \ | |
605 | case 2: __put_user_unaligned_asm("ush", __pu_addr); break; \ | |
606 | case 4: __put_user_unaligned_asm("usw", __pu_addr); break; \ | |
607 | case 8: __PUT_USER_UNALGINED_DW(__pu_addr); break; \ | |
608 | default: __put_user_unaligned_unknown(); break; \ | |
609 | } \ | |
610 | } \ | |
611 | __pu_err; \ | |
612 | }) | |
613 | ||
614 | #define __put_user_unaligned_asm(insn, ptr) \ | |
615 | { \ | |
616 | __asm__ __volatile__( \ | |
617 | "1: " insn " %z2, %3 # __put_user_unaligned_asm\n" \ | |
618 | "2: \n" \ | |
619 | " .section .fixup,\"ax\" \n" \ | |
620 | "3: li %0, %4 \n" \ | |
621 | " j 2b \n" \ | |
622 | " .previous \n" \ | |
623 | " .section __ex_table,\"a\" \n" \ | |
624 | " " __UA_ADDR " 1b, 3b \n" \ | |
625 | " .previous \n" \ | |
626 | : "=r" (__pu_err) \ | |
627 | : "0" (0), "Jr" (__pu_val), "o" (__m(ptr)), \ | |
628 | "i" (-EFAULT)); \ | |
629 | } | |
630 | ||
631 | #define __put_user_unaligned_asm_ll32(ptr) \ | |
632 | { \ | |
633 | __asm__ __volatile__( \ | |
634 | "1: sw %2, (%3) # __put_user_unaligned_asm_ll32 \n" \ | |
635 | "2: sw %D2, 4(%3) \n" \ | |
636 | "3: \n" \ | |
637 | " .section .fixup,\"ax\" \n" \ | |
638 | "4: li %0, %4 \n" \ | |
639 | " j 3b \n" \ | |
640 | " .previous \n" \ | |
641 | " .section __ex_table,\"a\" \n" \ | |
642 | " " __UA_ADDR " 1b, 4b \n" \ | |
643 | " " __UA_ADDR " 1b + 4, 4b \n" \ | |
644 | " " __UA_ADDR " 2b, 4b \n" \ | |
645 | " " __UA_ADDR " 2b + 4, 4b \n" \ | |
646 | " .previous" \ | |
647 | : "=r" (__pu_err) \ | |
648 | : "0" (0), "r" (__pu_val), "r" (ptr), \ | |
649 | "i" (-EFAULT)); \ | |
650 | } | |
651 | ||
652 | extern void __put_user_unaligned_unknown(void); | |
653 | ||
1da177e4 LT |
654 | /* |
655 | * We're generating jump to subroutines which will be outside the range of | |
656 | * jump instructions | |
657 | */ | |
658 | #ifdef MODULE | |
659 | #define __MODULE_JAL(destination) \ | |
660 | ".set\tnoat\n\t" \ | |
661 | __UA_LA "\t$1, " #destination "\n\t" \ | |
662 | "jalr\t$1\n\t" \ | |
663 | ".set\tat\n\t" | |
664 | #else | |
665 | #define __MODULE_JAL(destination) \ | |
666 | "jal\t" #destination "\n\t" | |
667 | #endif | |
668 | ||
619b6e18 MR |
669 | #ifndef CONFIG_CPU_DADDI_WORKAROUNDS |
670 | #define DADDI_SCRATCH "$0" | |
671 | #else | |
672 | #define DADDI_SCRATCH "$3" | |
673 | #endif | |
674 | ||
1da177e4 LT |
675 | extern size_t __copy_user(void *__to, const void *__from, size_t __n); |
676 | ||
21a151d8 | 677 | #define __invoke_copy_to_user(to, from, n) \ |
1da177e4 | 678 | ({ \ |
49a89efb RB |
679 | register void __user *__cu_to_r __asm__("$4"); \ |
680 | register const void *__cu_from_r __asm__("$5"); \ | |
681 | register long __cu_len_r __asm__("$6"); \ | |
1da177e4 LT |
682 | \ |
683 | __cu_to_r = (to); \ | |
684 | __cu_from_r = (from); \ | |
685 | __cu_len_r = (n); \ | |
686 | __asm__ __volatile__( \ | |
687 | __MODULE_JAL(__copy_user) \ | |
688 | : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r) \ | |
689 | : \ | |
690 | : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31", \ | |
619b6e18 | 691 | DADDI_SCRATCH, "memory"); \ |
1da177e4 LT |
692 | __cu_len_r; \ |
693 | }) | |
694 | ||
695 | /* | |
696 | * __copy_to_user: - Copy a block of data into user space, with less checking. | |
697 | * @to: Destination address, in user space. | |
698 | * @from: Source address, in kernel space. | |
699 | * @n: Number of bytes to copy. | |
700 | * | |
701 | * Context: User context only. This function may sleep. | |
702 | * | |
703 | * Copy data from kernel space to user space. Caller must check | |
704 | * the specified block with access_ok() before calling this function. | |
705 | * | |
706 | * Returns number of bytes that could not be copied. | |
707 | * On success, this will be zero. | |
708 | */ | |
21a151d8 | 709 | #define __copy_to_user(to, from, n) \ |
1da177e4 | 710 | ({ \ |
fe00f943 | 711 | void __user *__cu_to; \ |
1da177e4 LT |
712 | const void *__cu_from; \ |
713 | long __cu_len; \ | |
714 | \ | |
1da177e4 LT |
715 | __cu_to = (to); \ |
716 | __cu_from = (from); \ | |
717 | __cu_len = (n); \ | |
ef41f460 | 718 | might_fault(); \ |
1da177e4 LT |
719 | __cu_len = __invoke_copy_to_user(__cu_to, __cu_from, __cu_len); \ |
720 | __cu_len; \ | |
721 | }) | |
722 | ||
d0c91ae2 RB |
723 | extern size_t __copy_user_inatomic(void *__to, const void *__from, size_t __n); |
724 | ||
21a151d8 | 725 | #define __copy_to_user_inatomic(to, from, n) \ |
e03b5269 RB |
726 | ({ \ |
727 | void __user *__cu_to; \ | |
728 | const void *__cu_from; \ | |
729 | long __cu_len; \ | |
730 | \ | |
731 | __cu_to = (to); \ | |
732 | __cu_from = (from); \ | |
733 | __cu_len = (n); \ | |
734 | __cu_len = __invoke_copy_to_user(__cu_to, __cu_from, __cu_len); \ | |
735 | __cu_len; \ | |
736 | }) | |
737 | ||
21a151d8 | 738 | #define __copy_from_user_inatomic(to, from, n) \ |
e03b5269 RB |
739 | ({ \ |
740 | void *__cu_to; \ | |
741 | const void __user *__cu_from; \ | |
742 | long __cu_len; \ | |
743 | \ | |
744 | __cu_to = (to); \ | |
745 | __cu_from = (from); \ | |
746 | __cu_len = (n); \ | |
747 | __cu_len = __invoke_copy_from_user_inatomic(__cu_to, __cu_from, \ | |
748 | __cu_len); \ | |
749 | __cu_len; \ | |
750 | }) | |
1da177e4 LT |
751 | |
752 | /* | |
753 | * copy_to_user: - Copy a block of data into user space. | |
754 | * @to: Destination address, in user space. | |
755 | * @from: Source address, in kernel space. | |
756 | * @n: Number of bytes to copy. | |
757 | * | |
758 | * Context: User context only. This function may sleep. | |
759 | * | |
760 | * Copy data from kernel space to user space. | |
761 | * | |
762 | * Returns number of bytes that could not be copied. | |
763 | * On success, this will be zero. | |
764 | */ | |
21a151d8 | 765 | #define copy_to_user(to, from, n) \ |
1da177e4 | 766 | ({ \ |
fe00f943 | 767 | void __user *__cu_to; \ |
1da177e4 LT |
768 | const void *__cu_from; \ |
769 | long __cu_len; \ | |
770 | \ | |
1da177e4 LT |
771 | __cu_to = (to); \ |
772 | __cu_from = (from); \ | |
773 | __cu_len = (n); \ | |
ef41f460 RB |
774 | if (access_ok(VERIFY_WRITE, __cu_to, __cu_len)) { \ |
775 | might_fault(); \ | |
1da177e4 LT |
776 | __cu_len = __invoke_copy_to_user(__cu_to, __cu_from, \ |
777 | __cu_len); \ | |
ef41f460 | 778 | } \ |
1da177e4 LT |
779 | __cu_len; \ |
780 | }) | |
781 | ||
21a151d8 | 782 | #define __invoke_copy_from_user(to, from, n) \ |
1da177e4 | 783 | ({ \ |
49a89efb RB |
784 | register void *__cu_to_r __asm__("$4"); \ |
785 | register const void __user *__cu_from_r __asm__("$5"); \ | |
786 | register long __cu_len_r __asm__("$6"); \ | |
1da177e4 LT |
787 | \ |
788 | __cu_to_r = (to); \ | |
789 | __cu_from_r = (from); \ | |
790 | __cu_len_r = (n); \ | |
791 | __asm__ __volatile__( \ | |
792 | ".set\tnoreorder\n\t" \ | |
793 | __MODULE_JAL(__copy_user) \ | |
794 | ".set\tnoat\n\t" \ | |
795 | __UA_ADDU "\t$1, %1, %2\n\t" \ | |
796 | ".set\tat\n\t" \ | |
797 | ".set\treorder" \ | |
798 | : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r) \ | |
799 | : \ | |
e03b5269 | 800 | : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31", \ |
619b6e18 | 801 | DADDI_SCRATCH, "memory"); \ |
e03b5269 RB |
802 | __cu_len_r; \ |
803 | }) | |
804 | ||
21a151d8 | 805 | #define __invoke_copy_from_user_inatomic(to, from, n) \ |
e03b5269 | 806 | ({ \ |
49a89efb RB |
807 | register void *__cu_to_r __asm__("$4"); \ |
808 | register const void __user *__cu_from_r __asm__("$5"); \ | |
809 | register long __cu_len_r __asm__("$6"); \ | |
e03b5269 RB |
810 | \ |
811 | __cu_to_r = (to); \ | |
812 | __cu_from_r = (from); \ | |
813 | __cu_len_r = (n); \ | |
814 | __asm__ __volatile__( \ | |
815 | ".set\tnoreorder\n\t" \ | |
816 | __MODULE_JAL(__copy_user_inatomic) \ | |
817 | ".set\tnoat\n\t" \ | |
818 | __UA_ADDU "\t$1, %1, %2\n\t" \ | |
819 | ".set\tat\n\t" \ | |
820 | ".set\treorder" \ | |
821 | : "+r" (__cu_to_r), "+r" (__cu_from_r), "+r" (__cu_len_r) \ | |
822 | : \ | |
1da177e4 | 823 | : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31", \ |
619b6e18 | 824 | DADDI_SCRATCH, "memory"); \ |
1da177e4 LT |
825 | __cu_len_r; \ |
826 | }) | |
827 | ||
828 | /* | |
131c1a2b CD |
829 | * __copy_from_user: - Copy a block of data from user space, with less checking. |
830 | * @to: Destination address, in kernel space. | |
1da177e4 LT |
831 | * @from: Source address, in user space. |
832 | * @n: Number of bytes to copy. | |
833 | * | |
834 | * Context: User context only. This function may sleep. | |
835 | * | |
836 | * Copy data from user space to kernel space. Caller must check | |
837 | * the specified block with access_ok() before calling this function. | |
838 | * | |
839 | * Returns number of bytes that could not be copied. | |
840 | * On success, this will be zero. | |
841 | * | |
842 | * If some data could not be copied, this function will pad the copied | |
843 | * data to the requested size using zero bytes. | |
844 | */ | |
21a151d8 | 845 | #define __copy_from_user(to, from, n) \ |
1da177e4 LT |
846 | ({ \ |
847 | void *__cu_to; \ | |
fe00f943 | 848 | const void __user *__cu_from; \ |
1da177e4 LT |
849 | long __cu_len; \ |
850 | \ | |
1da177e4 LT |
851 | __cu_to = (to); \ |
852 | __cu_from = (from); \ | |
853 | __cu_len = (n); \ | |
ef41f460 | 854 | might_fault(); \ |
1da177e4 LT |
855 | __cu_len = __invoke_copy_from_user(__cu_to, __cu_from, \ |
856 | __cu_len); \ | |
857 | __cu_len; \ | |
858 | }) | |
859 | ||
860 | /* | |
861 | * copy_from_user: - Copy a block of data from user space. | |
862 | * @to: Destination address, in kernel space. | |
863 | * @from: Source address, in user space. | |
864 | * @n: Number of bytes to copy. | |
865 | * | |
866 | * Context: User context only. This function may sleep. | |
867 | * | |
868 | * Copy data from user space to kernel space. | |
869 | * | |
870 | * Returns number of bytes that could not be copied. | |
871 | * On success, this will be zero. | |
872 | * | |
873 | * If some data could not be copied, this function will pad the copied | |
874 | * data to the requested size using zero bytes. | |
875 | */ | |
21a151d8 | 876 | #define copy_from_user(to, from, n) \ |
1da177e4 LT |
877 | ({ \ |
878 | void *__cu_to; \ | |
fe00f943 | 879 | const void __user *__cu_from; \ |
1da177e4 LT |
880 | long __cu_len; \ |
881 | \ | |
1da177e4 LT |
882 | __cu_to = (to); \ |
883 | __cu_from = (from); \ | |
884 | __cu_len = (n); \ | |
ef41f460 RB |
885 | if (access_ok(VERIFY_READ, __cu_from, __cu_len)) { \ |
886 | might_fault(); \ | |
1da177e4 LT |
887 | __cu_len = __invoke_copy_from_user(__cu_to, __cu_from, \ |
888 | __cu_len); \ | |
ef41f460 | 889 | } \ |
1da177e4 LT |
890 | __cu_len; \ |
891 | }) | |
892 | ||
ed01b3d2 RB |
893 | #define __copy_in_user(to, from, n) \ |
894 | ({ \ | |
895 | void __user *__cu_to; \ | |
896 | const void __user *__cu_from; \ | |
897 | long __cu_len; \ | |
898 | \ | |
ed01b3d2 RB |
899 | __cu_to = (to); \ |
900 | __cu_from = (from); \ | |
901 | __cu_len = (n); \ | |
ef41f460 | 902 | might_fault(); \ |
ed01b3d2 RB |
903 | __cu_len = __invoke_copy_from_user(__cu_to, __cu_from, \ |
904 | __cu_len); \ | |
905 | __cu_len; \ | |
906 | }) | |
1da177e4 | 907 | |
21a151d8 | 908 | #define copy_in_user(to, from, n) \ |
1da177e4 | 909 | ({ \ |
fe00f943 RB |
910 | void __user *__cu_to; \ |
911 | const void __user *__cu_from; \ | |
1da177e4 LT |
912 | long __cu_len; \ |
913 | \ | |
1da177e4 LT |
914 | __cu_to = (to); \ |
915 | __cu_from = (from); \ | |
916 | __cu_len = (n); \ | |
917 | if (likely(access_ok(VERIFY_READ, __cu_from, __cu_len) && \ | |
ef41f460 RB |
918 | access_ok(VERIFY_WRITE, __cu_to, __cu_len))) { \ |
919 | might_fault(); \ | |
1da177e4 LT |
920 | __cu_len = __invoke_copy_from_user(__cu_to, __cu_from, \ |
921 | __cu_len); \ | |
ef41f460 | 922 | } \ |
1da177e4 LT |
923 | __cu_len; \ |
924 | }) | |
925 | ||
926 | /* | |
927 | * __clear_user: - Zero a block of memory in user space, with less checking. | |
928 | * @to: Destination address, in user space. | |
929 | * @n: Number of bytes to zero. | |
930 | * | |
931 | * Zero a block of memory in user space. Caller must check | |
932 | * the specified block with access_ok() before calling this function. | |
933 | * | |
934 | * Returns number of bytes that could not be cleared. | |
935 | * On success, this will be zero. | |
936 | */ | |
937 | static inline __kernel_size_t | |
fe00f943 | 938 | __clear_user(void __user *addr, __kernel_size_t size) |
1da177e4 LT |
939 | { |
940 | __kernel_size_t res; | |
941 | ||
ef41f460 | 942 | might_fault(); |
1da177e4 LT |
943 | __asm__ __volatile__( |
944 | "move\t$4, %1\n\t" | |
945 | "move\t$5, $0\n\t" | |
946 | "move\t$6, %2\n\t" | |
947 | __MODULE_JAL(__bzero) | |
948 | "move\t%0, $6" | |
949 | : "=r" (res) | |
950 | : "r" (addr), "r" (size) | |
951 | : "$4", "$5", "$6", __UA_t0, __UA_t1, "$31"); | |
952 | ||
953 | return res; | |
954 | } | |
955 | ||
956 | #define clear_user(addr,n) \ | |
957 | ({ \ | |
fe00f943 | 958 | void __user * __cl_addr = (addr); \ |
1da177e4 LT |
959 | unsigned long __cl_size = (n); \ |
960 | if (__cl_size && access_ok(VERIFY_WRITE, \ | |
63d38923 | 961 | __cl_addr, __cl_size)) \ |
1da177e4 LT |
962 | __cl_size = __clear_user(__cl_addr, __cl_size); \ |
963 | __cl_size; \ | |
964 | }) | |
965 | ||
966 | /* | |
967 | * __strncpy_from_user: - Copy a NUL terminated string from userspace, with less checking. | |
968 | * @dst: Destination address, in kernel space. This buffer must be at | |
969 | * least @count bytes long. | |
970 | * @src: Source address, in user space. | |
971 | * @count: Maximum number of bytes to copy, including the trailing NUL. | |
972 | * | |
973 | * Copies a NUL-terminated string from userspace to kernel space. | |
974 | * Caller must check the specified block with access_ok() before calling | |
975 | * this function. | |
976 | * | |
977 | * On success, returns the length of the string (not including the trailing | |
978 | * NUL). | |
979 | * | |
980 | * If access to userspace fails, returns -EFAULT (some data may have been | |
981 | * copied). | |
982 | * | |
983 | * If @count is smaller than the length of the string, copies @count bytes | |
984 | * and returns @count. | |
985 | */ | |
986 | static inline long | |
fe00f943 | 987 | __strncpy_from_user(char *__to, const char __user *__from, long __len) |
1da177e4 LT |
988 | { |
989 | long res; | |
990 | ||
ef41f460 | 991 | might_fault(); |
1da177e4 LT |
992 | __asm__ __volatile__( |
993 | "move\t$4, %1\n\t" | |
994 | "move\t$5, %2\n\t" | |
995 | "move\t$6, %3\n\t" | |
996 | __MODULE_JAL(__strncpy_from_user_nocheck_asm) | |
997 | "move\t%0, $2" | |
998 | : "=r" (res) | |
999 | : "r" (__to), "r" (__from), "r" (__len) | |
1000 | : "$2", "$3", "$4", "$5", "$6", __UA_t0, "$31", "memory"); | |
1001 | ||
1002 | return res; | |
1003 | } | |
1004 | ||
1005 | /* | |
1006 | * strncpy_from_user: - Copy a NUL terminated string from userspace. | |
1007 | * @dst: Destination address, in kernel space. This buffer must be at | |
1008 | * least @count bytes long. | |
1009 | * @src: Source address, in user space. | |
1010 | * @count: Maximum number of bytes to copy, including the trailing NUL. | |
1011 | * | |
1012 | * Copies a NUL-terminated string from userspace to kernel space. | |
1013 | * | |
1014 | * On success, returns the length of the string (not including the trailing | |
1015 | * NUL). | |
1016 | * | |
1017 | * If access to userspace fails, returns -EFAULT (some data may have been | |
1018 | * copied). | |
1019 | * | |
1020 | * If @count is smaller than the length of the string, copies @count bytes | |
1021 | * and returns @count. | |
1022 | */ | |
1023 | static inline long | |
fe00f943 | 1024 | strncpy_from_user(char *__to, const char __user *__from, long __len) |
1da177e4 LT |
1025 | { |
1026 | long res; | |
1027 | ||
ef41f460 | 1028 | might_fault(); |
1da177e4 LT |
1029 | __asm__ __volatile__( |
1030 | "move\t$4, %1\n\t" | |
1031 | "move\t$5, %2\n\t" | |
1032 | "move\t$6, %3\n\t" | |
1033 | __MODULE_JAL(__strncpy_from_user_asm) | |
1034 | "move\t%0, $2" | |
1035 | : "=r" (res) | |
1036 | : "r" (__to), "r" (__from), "r" (__len) | |
1037 | : "$2", "$3", "$4", "$5", "$6", __UA_t0, "$31", "memory"); | |
1038 | ||
1039 | return res; | |
1040 | } | |
1041 | ||
1042 | /* Returns: 0 if bad, string length+1 (memory size) of string if ok */ | |
fe00f943 | 1043 | static inline long __strlen_user(const char __user *s) |
1da177e4 LT |
1044 | { |
1045 | long res; | |
1046 | ||
ef41f460 | 1047 | might_fault(); |
1da177e4 LT |
1048 | __asm__ __volatile__( |
1049 | "move\t$4, %1\n\t" | |
1050 | __MODULE_JAL(__strlen_user_nocheck_asm) | |
1051 | "move\t%0, $2" | |
1052 | : "=r" (res) | |
1053 | : "r" (s) | |
1054 | : "$2", "$4", __UA_t0, "$31"); | |
1055 | ||
1056 | return res; | |
1057 | } | |
1058 | ||
1059 | /* | |
1060 | * strlen_user: - Get the size of a string in user space. | |
1061 | * @str: The string to measure. | |
1062 | * | |
1063 | * Context: User context only. This function may sleep. | |
1064 | * | |
1065 | * Get the size of a NUL-terminated string in user space. | |
1066 | * | |
1067 | * Returns the size of the string INCLUDING the terminating NUL. | |
1068 | * On exception, returns 0. | |
1069 | * | |
1070 | * If there is a limit on the length of a valid string, you may wish to | |
1071 | * consider using strnlen_user() instead. | |
1072 | */ | |
fe00f943 | 1073 | static inline long strlen_user(const char __user *s) |
1da177e4 LT |
1074 | { |
1075 | long res; | |
1076 | ||
ef41f460 | 1077 | might_fault(); |
1da177e4 LT |
1078 | __asm__ __volatile__( |
1079 | "move\t$4, %1\n\t" | |
1080 | __MODULE_JAL(__strlen_user_asm) | |
1081 | "move\t%0, $2" | |
1082 | : "=r" (res) | |
1083 | : "r" (s) | |
1084 | : "$2", "$4", __UA_t0, "$31"); | |
1085 | ||
1086 | return res; | |
1087 | } | |
1088 | ||
1089 | /* Returns: 0 if bad, string length+1 (memory size) of string if ok */ | |
fe00f943 | 1090 | static inline long __strnlen_user(const char __user *s, long n) |
1da177e4 LT |
1091 | { |
1092 | long res; | |
1093 | ||
ef41f460 | 1094 | might_fault(); |
1da177e4 LT |
1095 | __asm__ __volatile__( |
1096 | "move\t$4, %1\n\t" | |
1097 | "move\t$5, %2\n\t" | |
1098 | __MODULE_JAL(__strnlen_user_nocheck_asm) | |
1099 | "move\t%0, $2" | |
1100 | : "=r" (res) | |
1101 | : "r" (s), "r" (n) | |
1102 | : "$2", "$4", "$5", __UA_t0, "$31"); | |
1103 | ||
1104 | return res; | |
1105 | } | |
1106 | ||
1107 | /* | |
1108 | * strlen_user: - Get the size of a string in user space. | |
1109 | * @str: The string to measure. | |
1110 | * | |
1111 | * Context: User context only. This function may sleep. | |
1112 | * | |
1113 | * Get the size of a NUL-terminated string in user space. | |
1114 | * | |
1115 | * Returns the size of the string INCLUDING the terminating NUL. | |
1116 | * On exception, returns 0. | |
1117 | * | |
1118 | * If there is a limit on the length of a valid string, you may wish to | |
1119 | * consider using strnlen_user() instead. | |
1120 | */ | |
fe00f943 | 1121 | static inline long strnlen_user(const char __user *s, long n) |
1da177e4 LT |
1122 | { |
1123 | long res; | |
1124 | ||
ef41f460 | 1125 | might_fault(); |
1da177e4 LT |
1126 | __asm__ __volatile__( |
1127 | "move\t$4, %1\n\t" | |
1128 | "move\t$5, %2\n\t" | |
1129 | __MODULE_JAL(__strnlen_user_asm) | |
1130 | "move\t%0, $2" | |
1131 | : "=r" (res) | |
1132 | : "r" (s), "r" (n) | |
1133 | : "$2", "$4", "$5", __UA_t0, "$31"); | |
1134 | ||
1135 | return res; | |
1136 | } | |
1137 | ||
1138 | struct exception_table_entry | |
1139 | { | |
1140 | unsigned long insn; | |
1141 | unsigned long nextinsn; | |
1142 | }; | |
1143 | ||
1144 | extern int fixup_exception(struct pt_regs *regs); | |
1145 | ||
1146 | #endif /* _ASM_UACCESS_H */ |