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