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