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 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 */ 24#ifdef CONFIG_32BIT 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 34#endif /* CONFIG_32BIT */ 35 36#ifdef CONFIG_64BIT 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 46#endif /* CONFIG_64BIT */ 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 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 197struct __large_struct { unsigned long buf[100]; }; 198#define __m(x) (*(struct __large_struct __user *)(x)) 199 200/* 201 * Yuck. We need two variants, one for 64bit operation and one 202 * for 32 bit mode and old iron. 203 */ 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) 209#endif 210 211extern void __get_user_unknown(void); 212 213#define __get_user_common(val, size, ptr) \ 214do { \ 215 switch (size) { \ 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; \ 220 default: __get_user_unknown(); break; \ 221 } \ 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); \ 229 __gu_err; \ 230}) 231 232#define __get_user_check(x,ptr,size) \ 233({ \ 234 long __gu_err = -EFAULT; \ 235 const __typeof__(*(ptr)) __user * __gu_ptr = (ptr); \ 236 \ 237 if (likely(access_ok(VERIFY_READ, __gu_ptr, size))) \ 238 __get_user_common((x), size, __gu_ptr); \ 239 \ 240 __gu_err; \ 241}) 242 243#define __get_user_asm(val, insn, addr) \ 244{ \ 245 long __gu_tmp; \ 246 \ 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" \ 257 : "=r" (__gu_err), "=r" (__gu_tmp) \ 258 : "0" (0), "o" (__m(addr)), "i" (-EFAULT)); \ 259 \ 260 (val) = (__typeof__(*(addr))) __gu_tmp; \ 261} 262 263/* 264 * Get a long long 64 using 32 bit registers. 265 */ 266#define __get_user_asm_ll32(val, addr) \ 267{ \ 268 union { \ 269 unsigned long long l; \ 270 __typeof__(*(addr)) t; \ 271 } __gu_tmp; \ 272 \ 273 __asm__ __volatile__( \ 274 "1: lw %1, (%3) \n" \ 275 "2: lw %D1, 4(%3) \n" \ 276 "3: .section .fixup,\"ax\" \n" \ 277 "4: li %0, %4 \n" \ 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" \ 286 : "=r" (__gu_err), "=&r" (__gu_tmp.l) \ 287 : "0" (0), "r" (addr), "i" (-EFAULT)); \ 288 \ 289 (val) = __gu_tmp.t; \ 290} 291 292/* 293 * Yuck. We need two variants, one for 64bit operation and one 294 * for 32 bit mode and old iron. 295 */ 296#ifdef CONFIG_32BIT 297#define __PUT_USER_DW(ptr) __put_user_asm_ll32(ptr) 298#endif 299#ifdef CONFIG_64BIT 300#define __PUT_USER_DW(ptr) __put_user_asm("sd", ptr) 301#endif 302 303#define __put_user_nocheck(x,ptr,size) \ 304({ \ 305 __typeof__(*(ptr)) __pu_val; \ 306 long __pu_err = 0; \ 307 \ 308 __pu_val = (x); \ 309 switch (size) { \ 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; \ 314 default: __put_user_unknown(); break; \ 315 } \ 316 __pu_err; \ 317}) 318 319#define __put_user_check(x,ptr,size) \ 320({ \ 321 __typeof__(*(ptr)) __user *__pu_addr = (ptr); \ 322 __typeof__(*(ptr)) __pu_val = (x); \ 323 long __pu_err = -EFAULT; \ 324 \ 325 if (likely(access_ok(VERIFY_WRITE, __pu_addr, size))) { \ 326 switch (size) { \ 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; \ 331 default: __put_user_unknown(); break; \ 332 } \ 333 } \ 334 __pu_err; \ 335}) 336 337#define __put_user_asm(insn, ptr) \ 338{ \ 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) \ 350 : "0" (0), "Jr" (__pu_val), "o" (__m(ptr)), \ 351 "i" (-EFAULT)); \ 352} 353 354#define __put_user_asm_ll32(ptr) \ 355{ \ 356 __asm__ __volatile__( \ 357 "1: sw %2, (%3) # __put_user_asm_ll32 \n" \ 358 "2: sw %D2, 4(%3) \n" \ 359 "3: \n" \ 360 " .section .fixup,\"ax\" \n" \ 361 "4: li %0, %4 \n" \ 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) \ 369 : "0" (0), "r" (__pu_val), "r" (ptr), \ 370 "i" (-EFAULT)); \ 371} 372 373extern 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 390extern size_t __copy_user(void *__to, const void *__from, size_t __n); 391 392#define __invoke_copy_to_user(to,from,n) \ 393({ \ 394 register void __user *__cu_to_r __asm__ ("$4"); \ 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({ \ 426 void __user *__cu_to; \ 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 438extern size_t __copy_user_inatomic(void *__to, const void *__from, size_t __n); 439 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}) 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({ \ 482 void __user *__cu_to; \ 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"); \ 499 register const void __user *__cu_from_r __asm__ ("$5"); \ 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 : \ 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 : \ 537 : "$8", "$9", "$10", "$11", "$12", "$15", "$24", "$31", \ 538 "memory"); \ 539 __cu_len_r; \ 540}) 541 542/* 543 * __copy_from_user: - Copy a block of data from user space, with less checking. 544 * @to: Destination address, in kernel space. 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; \ 562 const void __user *__cu_from; \ 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; \ 593 const void __user *__cu_from; \ 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({ \ 610 void __user *__cu_to; \ 611 const void __user *__cu_from; \ 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 */ 636static inline __kernel_size_t 637__clear_user(void __user *addr, __kernel_size_t size) 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({ \ 657 void __user * __cl_addr = (addr); \ 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 */ 685static inline long 686__strncpy_from_user(char *__to, const char __user *__from, long __len) 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 */ 722static inline long 723strncpy_from_user(char *__to, const char __user *__from, long __len) 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 */ 742static inline long __strlen_user(const char __user *s) 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 */ 772static inline long strlen_user(const char __user *s) 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 */ 789static inline long __strnlen_user(const char __user *s, long n) 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 */ 820static inline long strnlen_user(const char __user *s, long n) 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 837struct exception_table_entry 838{ 839 unsigned long insn; 840 unsigned long nextinsn; 841}; 842 843extern int fixup_exception(struct pt_regs *regs); 844 845#endif /* _ASM_UACCESS_H */ 846