1 /* 2 * User address space access functions. 3 * The non inlined parts of asm-i386/uaccess.h are here. 4 * 5 * Copyright 1997 Andi Kleen <ak@muc.de> 6 * Copyright 1997 Linus Torvalds 7 */ 8 #include <linux/mm.h> 9 #include <linux/highmem.h> 10 #include <linux/blkdev.h> 11 #include <linux/module.h> 12 #include <linux/backing-dev.h> 13 #include <linux/interrupt.h> 14 #include <asm/uaccess.h> 15 #include <asm/mmx.h> 16 17 #ifdef CONFIG_X86_INTEL_USERCOPY 18 /* 19 * Alignment at which movsl is preferred for bulk memory copies. 20 */ 21 struct movsl_mask movsl_mask __read_mostly; 22 #endif 23 24 static inline int __movsl_is_ok(unsigned long a1, unsigned long a2, unsigned long n) 25 { 26 #ifdef CONFIG_X86_INTEL_USERCOPY 27 if (n >= 64 && ((a1 ^ a2) & movsl_mask.mask)) 28 return 0; 29 #endif 30 return 1; 31 } 32 #define movsl_is_ok(a1, a2, n) \ 33 __movsl_is_ok((unsigned long)(a1), (unsigned long)(a2), (n)) 34 35 /* 36 * Copy a null terminated string from userspace. 37 */ 38 39 #define __do_strncpy_from_user(dst, src, count, res) \ 40 do { \ 41 int __d0, __d1, __d2; \ 42 might_fault(); \ 43 __asm__ __volatile__( \ 44 " testl %1,%1\n" \ 45 " jz 2f\n" \ 46 "0: lodsb\n" \ 47 " stosb\n" \ 48 " testb %%al,%%al\n" \ 49 " jz 1f\n" \ 50 " decl %1\n" \ 51 " jnz 0b\n" \ 52 "1: subl %1,%0\n" \ 53 "2:\n" \ 54 ".section .fixup,\"ax\"\n" \ 55 "3: movl %5,%0\n" \ 56 " jmp 2b\n" \ 57 ".previous\n" \ 58 _ASM_EXTABLE(0b,3b) \ 59 : "=&d"(res), "=&c"(count), "=&a" (__d0), "=&S" (__d1), \ 60 "=&D" (__d2) \ 61 : "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \ 62 : "memory"); \ 63 } while (0) 64 65 /** 66 * __strncpy_from_user: - Copy a NUL terminated string from userspace, with less checking. 67 * @dst: Destination address, in kernel space. This buffer must be at 68 * least @count bytes long. 69 * @src: Source address, in user space. 70 * @count: Maximum number of bytes to copy, including the trailing NUL. 71 * 72 * Copies a NUL-terminated string from userspace to kernel space. 73 * Caller must check the specified block with access_ok() before calling 74 * this function. 75 * 76 * On success, returns the length of the string (not including the trailing 77 * NUL). 78 * 79 * If access to userspace fails, returns -EFAULT (some data may have been 80 * copied). 81 * 82 * If @count is smaller than the length of the string, copies @count bytes 83 * and returns @count. 84 */ 85 long 86 __strncpy_from_user(char *dst, const char __user *src, long count) 87 { 88 long res; 89 __do_strncpy_from_user(dst, src, count, res); 90 return res; 91 } 92 EXPORT_SYMBOL(__strncpy_from_user); 93 94 /** 95 * strncpy_from_user: - Copy a NUL terminated string from userspace. 96 * @dst: Destination address, in kernel space. This buffer must be at 97 * least @count bytes long. 98 * @src: Source address, in user space. 99 * @count: Maximum number of bytes to copy, including the trailing NUL. 100 * 101 * Copies a NUL-terminated string from userspace to kernel space. 102 * 103 * On success, returns the length of the string (not including the trailing 104 * NUL). 105 * 106 * If access to userspace fails, returns -EFAULT (some data may have been 107 * copied). 108 * 109 * If @count is smaller than the length of the string, copies @count bytes 110 * and returns @count. 111 */ 112 long 113 strncpy_from_user(char *dst, const char __user *src, long count) 114 { 115 long res = -EFAULT; 116 if (access_ok(VERIFY_READ, src, 1)) 117 __do_strncpy_from_user(dst, src, count, res); 118 return res; 119 } 120 EXPORT_SYMBOL(strncpy_from_user); 121 122 /* 123 * Zero Userspace 124 */ 125 126 #define __do_clear_user(addr,size) \ 127 do { \ 128 int __d0; \ 129 might_fault(); \ 130 __asm__ __volatile__( \ 131 "0: rep; stosl\n" \ 132 " movl %2,%0\n" \ 133 "1: rep; stosb\n" \ 134 "2:\n" \ 135 ".section .fixup,\"ax\"\n" \ 136 "3: lea 0(%2,%0,4),%0\n" \ 137 " jmp 2b\n" \ 138 ".previous\n" \ 139 _ASM_EXTABLE(0b,3b) \ 140 _ASM_EXTABLE(1b,2b) \ 141 : "=&c"(size), "=&D" (__d0) \ 142 : "r"(size & 3), "0"(size / 4), "1"(addr), "a"(0)); \ 143 } while (0) 144 145 /** 146 * clear_user: - Zero a block of memory in user space. 147 * @to: Destination address, in user space. 148 * @n: Number of bytes to zero. 149 * 150 * Zero a block of memory in user space. 151 * 152 * Returns number of bytes that could not be cleared. 153 * On success, this will be zero. 154 */ 155 unsigned long 156 clear_user(void __user *to, unsigned long n) 157 { 158 might_fault(); 159 if (access_ok(VERIFY_WRITE, to, n)) 160 __do_clear_user(to, n); 161 return n; 162 } 163 EXPORT_SYMBOL(clear_user); 164 165 /** 166 * __clear_user: - Zero a block of memory in user space, with less checking. 167 * @to: Destination address, in user space. 168 * @n: Number of bytes to zero. 169 * 170 * Zero a block of memory in user space. Caller must check 171 * the specified block with access_ok() before calling this function. 172 * 173 * Returns number of bytes that could not be cleared. 174 * On success, this will be zero. 175 */ 176 unsigned long 177 __clear_user(void __user *to, unsigned long n) 178 { 179 __do_clear_user(to, n); 180 return n; 181 } 182 EXPORT_SYMBOL(__clear_user); 183 184 /** 185 * strnlen_user: - Get the size of a string in user space. 186 * @s: The string to measure. 187 * @n: The maximum valid length 188 * 189 * Get the size of a NUL-terminated string in user space. 190 * 191 * Returns the size of the string INCLUDING the terminating NUL. 192 * On exception, returns 0. 193 * If the string is too long, returns a value greater than @n. 194 */ 195 long strnlen_user(const char __user *s, long n) 196 { 197 unsigned long mask = -__addr_ok(s); 198 unsigned long res, tmp; 199 200 might_fault(); 201 202 __asm__ __volatile__( 203 " testl %0, %0\n" 204 " jz 3f\n" 205 " andl %0,%%ecx\n" 206 "0: repne; scasb\n" 207 " setne %%al\n" 208 " subl %%ecx,%0\n" 209 " addl %0,%%eax\n" 210 "1:\n" 211 ".section .fixup,\"ax\"\n" 212 "2: xorl %%eax,%%eax\n" 213 " jmp 1b\n" 214 "3: movb $1,%%al\n" 215 " jmp 1b\n" 216 ".previous\n" 217 ".section __ex_table,\"a\"\n" 218 " .align 4\n" 219 " .long 0b,2b\n" 220 ".previous" 221 :"=&r" (n), "=&D" (s), "=&a" (res), "=&c" (tmp) 222 :"0" (n), "1" (s), "2" (0), "3" (mask) 223 :"cc"); 224 return res & mask; 225 } 226 EXPORT_SYMBOL(strnlen_user); 227 228 #ifdef CONFIG_X86_INTEL_USERCOPY 229 static unsigned long 230 __copy_user_intel(void __user *to, const void *from, unsigned long size) 231 { 232 int d0, d1; 233 __asm__ __volatile__( 234 " .align 2,0x90\n" 235 "1: movl 32(%4), %%eax\n" 236 " cmpl $67, %0\n" 237 " jbe 3f\n" 238 "2: movl 64(%4), %%eax\n" 239 " .align 2,0x90\n" 240 "3: movl 0(%4), %%eax\n" 241 "4: movl 4(%4), %%edx\n" 242 "5: movl %%eax, 0(%3)\n" 243 "6: movl %%edx, 4(%3)\n" 244 "7: movl 8(%4), %%eax\n" 245 "8: movl 12(%4),%%edx\n" 246 "9: movl %%eax, 8(%3)\n" 247 "10: movl %%edx, 12(%3)\n" 248 "11: movl 16(%4), %%eax\n" 249 "12: movl 20(%4), %%edx\n" 250 "13: movl %%eax, 16(%3)\n" 251 "14: movl %%edx, 20(%3)\n" 252 "15: movl 24(%4), %%eax\n" 253 "16: movl 28(%4), %%edx\n" 254 "17: movl %%eax, 24(%3)\n" 255 "18: movl %%edx, 28(%3)\n" 256 "19: movl 32(%4), %%eax\n" 257 "20: movl 36(%4), %%edx\n" 258 "21: movl %%eax, 32(%3)\n" 259 "22: movl %%edx, 36(%3)\n" 260 "23: movl 40(%4), %%eax\n" 261 "24: movl 44(%4), %%edx\n" 262 "25: movl %%eax, 40(%3)\n" 263 "26: movl %%edx, 44(%3)\n" 264 "27: movl 48(%4), %%eax\n" 265 "28: movl 52(%4), %%edx\n" 266 "29: movl %%eax, 48(%3)\n" 267 "30: movl %%edx, 52(%3)\n" 268 "31: movl 56(%4), %%eax\n" 269 "32: movl 60(%4), %%edx\n" 270 "33: movl %%eax, 56(%3)\n" 271 "34: movl %%edx, 60(%3)\n" 272 " addl $-64, %0\n" 273 " addl $64, %4\n" 274 " addl $64, %3\n" 275 " cmpl $63, %0\n" 276 " ja 1b\n" 277 "35: movl %0, %%eax\n" 278 " shrl $2, %0\n" 279 " andl $3, %%eax\n" 280 " cld\n" 281 "99: rep; movsl\n" 282 "36: movl %%eax, %0\n" 283 "37: rep; movsb\n" 284 "100:\n" 285 ".section .fixup,\"ax\"\n" 286 "101: lea 0(%%eax,%0,4),%0\n" 287 " jmp 100b\n" 288 ".previous\n" 289 ".section __ex_table,\"a\"\n" 290 " .align 4\n" 291 " .long 1b,100b\n" 292 " .long 2b,100b\n" 293 " .long 3b,100b\n" 294 " .long 4b,100b\n" 295 " .long 5b,100b\n" 296 " .long 6b,100b\n" 297 " .long 7b,100b\n" 298 " .long 8b,100b\n" 299 " .long 9b,100b\n" 300 " .long 10b,100b\n" 301 " .long 11b,100b\n" 302 " .long 12b,100b\n" 303 " .long 13b,100b\n" 304 " .long 14b,100b\n" 305 " .long 15b,100b\n" 306 " .long 16b,100b\n" 307 " .long 17b,100b\n" 308 " .long 18b,100b\n" 309 " .long 19b,100b\n" 310 " .long 20b,100b\n" 311 " .long 21b,100b\n" 312 " .long 22b,100b\n" 313 " .long 23b,100b\n" 314 " .long 24b,100b\n" 315 " .long 25b,100b\n" 316 " .long 26b,100b\n" 317 " .long 27b,100b\n" 318 " .long 28b,100b\n" 319 " .long 29b,100b\n" 320 " .long 30b,100b\n" 321 " .long 31b,100b\n" 322 " .long 32b,100b\n" 323 " .long 33b,100b\n" 324 " .long 34b,100b\n" 325 " .long 35b,100b\n" 326 " .long 36b,100b\n" 327 " .long 37b,100b\n" 328 " .long 99b,101b\n" 329 ".previous" 330 : "=&c"(size), "=&D" (d0), "=&S" (d1) 331 : "1"(to), "2"(from), "0"(size) 332 : "eax", "edx", "memory"); 333 return size; 334 } 335 336 static unsigned long 337 __copy_user_zeroing_intel(void *to, const void __user *from, unsigned long size) 338 { 339 int d0, d1; 340 __asm__ __volatile__( 341 " .align 2,0x90\n" 342 "0: movl 32(%4), %%eax\n" 343 " cmpl $67, %0\n" 344 " jbe 2f\n" 345 "1: movl 64(%4), %%eax\n" 346 " .align 2,0x90\n" 347 "2: movl 0(%4), %%eax\n" 348 "21: movl 4(%4), %%edx\n" 349 " movl %%eax, 0(%3)\n" 350 " movl %%edx, 4(%3)\n" 351 "3: movl 8(%4), %%eax\n" 352 "31: movl 12(%4),%%edx\n" 353 " movl %%eax, 8(%3)\n" 354 " movl %%edx, 12(%3)\n" 355 "4: movl 16(%4), %%eax\n" 356 "41: movl 20(%4), %%edx\n" 357 " movl %%eax, 16(%3)\n" 358 " movl %%edx, 20(%3)\n" 359 "10: movl 24(%4), %%eax\n" 360 "51: movl 28(%4), %%edx\n" 361 " movl %%eax, 24(%3)\n" 362 " movl %%edx, 28(%3)\n" 363 "11: movl 32(%4), %%eax\n" 364 "61: movl 36(%4), %%edx\n" 365 " movl %%eax, 32(%3)\n" 366 " movl %%edx, 36(%3)\n" 367 "12: movl 40(%4), %%eax\n" 368 "71: movl 44(%4), %%edx\n" 369 " movl %%eax, 40(%3)\n" 370 " movl %%edx, 44(%3)\n" 371 "13: movl 48(%4), %%eax\n" 372 "81: movl 52(%4), %%edx\n" 373 " movl %%eax, 48(%3)\n" 374 " movl %%edx, 52(%3)\n" 375 "14: movl 56(%4), %%eax\n" 376 "91: movl 60(%4), %%edx\n" 377 " movl %%eax, 56(%3)\n" 378 " movl %%edx, 60(%3)\n" 379 " addl $-64, %0\n" 380 " addl $64, %4\n" 381 " addl $64, %3\n" 382 " cmpl $63, %0\n" 383 " ja 0b\n" 384 "5: movl %0, %%eax\n" 385 " shrl $2, %0\n" 386 " andl $3, %%eax\n" 387 " cld\n" 388 "6: rep; movsl\n" 389 " movl %%eax,%0\n" 390 "7: rep; movsb\n" 391 "8:\n" 392 ".section .fixup,\"ax\"\n" 393 "9: lea 0(%%eax,%0,4),%0\n" 394 "16: pushl %0\n" 395 " pushl %%eax\n" 396 " xorl %%eax,%%eax\n" 397 " rep; stosb\n" 398 " popl %%eax\n" 399 " popl %0\n" 400 " jmp 8b\n" 401 ".previous\n" 402 ".section __ex_table,\"a\"\n" 403 " .align 4\n" 404 " .long 0b,16b\n" 405 " .long 1b,16b\n" 406 " .long 2b,16b\n" 407 " .long 21b,16b\n" 408 " .long 3b,16b\n" 409 " .long 31b,16b\n" 410 " .long 4b,16b\n" 411 " .long 41b,16b\n" 412 " .long 10b,16b\n" 413 " .long 51b,16b\n" 414 " .long 11b,16b\n" 415 " .long 61b,16b\n" 416 " .long 12b,16b\n" 417 " .long 71b,16b\n" 418 " .long 13b,16b\n" 419 " .long 81b,16b\n" 420 " .long 14b,16b\n" 421 " .long 91b,16b\n" 422 " .long 6b,9b\n" 423 " .long 7b,16b\n" 424 ".previous" 425 : "=&c"(size), "=&D" (d0), "=&S" (d1) 426 : "1"(to), "2"(from), "0"(size) 427 : "eax", "edx", "memory"); 428 return size; 429 } 430 431 /* 432 * Non Temporal Hint version of __copy_user_zeroing_intel. It is cache aware. 433 * hyoshiok@miraclelinux.com 434 */ 435 436 static unsigned long __copy_user_zeroing_intel_nocache(void *to, 437 const void __user *from, unsigned long size) 438 { 439 int d0, d1; 440 441 __asm__ __volatile__( 442 " .align 2,0x90\n" 443 "0: movl 32(%4), %%eax\n" 444 " cmpl $67, %0\n" 445 " jbe 2f\n" 446 "1: movl 64(%4), %%eax\n" 447 " .align 2,0x90\n" 448 "2: movl 0(%4), %%eax\n" 449 "21: movl 4(%4), %%edx\n" 450 " movnti %%eax, 0(%3)\n" 451 " movnti %%edx, 4(%3)\n" 452 "3: movl 8(%4), %%eax\n" 453 "31: movl 12(%4),%%edx\n" 454 " movnti %%eax, 8(%3)\n" 455 " movnti %%edx, 12(%3)\n" 456 "4: movl 16(%4), %%eax\n" 457 "41: movl 20(%4), %%edx\n" 458 " movnti %%eax, 16(%3)\n" 459 " movnti %%edx, 20(%3)\n" 460 "10: movl 24(%4), %%eax\n" 461 "51: movl 28(%4), %%edx\n" 462 " movnti %%eax, 24(%3)\n" 463 " movnti %%edx, 28(%3)\n" 464 "11: movl 32(%4), %%eax\n" 465 "61: movl 36(%4), %%edx\n" 466 " movnti %%eax, 32(%3)\n" 467 " movnti %%edx, 36(%3)\n" 468 "12: movl 40(%4), %%eax\n" 469 "71: movl 44(%4), %%edx\n" 470 " movnti %%eax, 40(%3)\n" 471 " movnti %%edx, 44(%3)\n" 472 "13: movl 48(%4), %%eax\n" 473 "81: movl 52(%4), %%edx\n" 474 " movnti %%eax, 48(%3)\n" 475 " movnti %%edx, 52(%3)\n" 476 "14: movl 56(%4), %%eax\n" 477 "91: movl 60(%4), %%edx\n" 478 " movnti %%eax, 56(%3)\n" 479 " movnti %%edx, 60(%3)\n" 480 " addl $-64, %0\n" 481 " addl $64, %4\n" 482 " addl $64, %3\n" 483 " cmpl $63, %0\n" 484 " ja 0b\n" 485 " sfence \n" 486 "5: movl %0, %%eax\n" 487 " shrl $2, %0\n" 488 " andl $3, %%eax\n" 489 " cld\n" 490 "6: rep; movsl\n" 491 " movl %%eax,%0\n" 492 "7: rep; movsb\n" 493 "8:\n" 494 ".section .fixup,\"ax\"\n" 495 "9: lea 0(%%eax,%0,4),%0\n" 496 "16: pushl %0\n" 497 " pushl %%eax\n" 498 " xorl %%eax,%%eax\n" 499 " rep; stosb\n" 500 " popl %%eax\n" 501 " popl %0\n" 502 " jmp 8b\n" 503 ".previous\n" 504 ".section __ex_table,\"a\"\n" 505 " .align 4\n" 506 " .long 0b,16b\n" 507 " .long 1b,16b\n" 508 " .long 2b,16b\n" 509 " .long 21b,16b\n" 510 " .long 3b,16b\n" 511 " .long 31b,16b\n" 512 " .long 4b,16b\n" 513 " .long 41b,16b\n" 514 " .long 10b,16b\n" 515 " .long 51b,16b\n" 516 " .long 11b,16b\n" 517 " .long 61b,16b\n" 518 " .long 12b,16b\n" 519 " .long 71b,16b\n" 520 " .long 13b,16b\n" 521 " .long 81b,16b\n" 522 " .long 14b,16b\n" 523 " .long 91b,16b\n" 524 " .long 6b,9b\n" 525 " .long 7b,16b\n" 526 ".previous" 527 : "=&c"(size), "=&D" (d0), "=&S" (d1) 528 : "1"(to), "2"(from), "0"(size) 529 : "eax", "edx", "memory"); 530 return size; 531 } 532 533 static unsigned long __copy_user_intel_nocache(void *to, 534 const void __user *from, unsigned long size) 535 { 536 int d0, d1; 537 538 __asm__ __volatile__( 539 " .align 2,0x90\n" 540 "0: movl 32(%4), %%eax\n" 541 " cmpl $67, %0\n" 542 " jbe 2f\n" 543 "1: movl 64(%4), %%eax\n" 544 " .align 2,0x90\n" 545 "2: movl 0(%4), %%eax\n" 546 "21: movl 4(%4), %%edx\n" 547 " movnti %%eax, 0(%3)\n" 548 " movnti %%edx, 4(%3)\n" 549 "3: movl 8(%4), %%eax\n" 550 "31: movl 12(%4),%%edx\n" 551 " movnti %%eax, 8(%3)\n" 552 " movnti %%edx, 12(%3)\n" 553 "4: movl 16(%4), %%eax\n" 554 "41: movl 20(%4), %%edx\n" 555 " movnti %%eax, 16(%3)\n" 556 " movnti %%edx, 20(%3)\n" 557 "10: movl 24(%4), %%eax\n" 558 "51: movl 28(%4), %%edx\n" 559 " movnti %%eax, 24(%3)\n" 560 " movnti %%edx, 28(%3)\n" 561 "11: movl 32(%4), %%eax\n" 562 "61: movl 36(%4), %%edx\n" 563 " movnti %%eax, 32(%3)\n" 564 " movnti %%edx, 36(%3)\n" 565 "12: movl 40(%4), %%eax\n" 566 "71: movl 44(%4), %%edx\n" 567 " movnti %%eax, 40(%3)\n" 568 " movnti %%edx, 44(%3)\n" 569 "13: movl 48(%4), %%eax\n" 570 "81: movl 52(%4), %%edx\n" 571 " movnti %%eax, 48(%3)\n" 572 " movnti %%edx, 52(%3)\n" 573 "14: movl 56(%4), %%eax\n" 574 "91: movl 60(%4), %%edx\n" 575 " movnti %%eax, 56(%3)\n" 576 " movnti %%edx, 60(%3)\n" 577 " addl $-64, %0\n" 578 " addl $64, %4\n" 579 " addl $64, %3\n" 580 " cmpl $63, %0\n" 581 " ja 0b\n" 582 " sfence \n" 583 "5: movl %0, %%eax\n" 584 " shrl $2, %0\n" 585 " andl $3, %%eax\n" 586 " cld\n" 587 "6: rep; movsl\n" 588 " movl %%eax,%0\n" 589 "7: rep; movsb\n" 590 "8:\n" 591 ".section .fixup,\"ax\"\n" 592 "9: lea 0(%%eax,%0,4),%0\n" 593 "16: jmp 8b\n" 594 ".previous\n" 595 ".section __ex_table,\"a\"\n" 596 " .align 4\n" 597 " .long 0b,16b\n" 598 " .long 1b,16b\n" 599 " .long 2b,16b\n" 600 " .long 21b,16b\n" 601 " .long 3b,16b\n" 602 " .long 31b,16b\n" 603 " .long 4b,16b\n" 604 " .long 41b,16b\n" 605 " .long 10b,16b\n" 606 " .long 51b,16b\n" 607 " .long 11b,16b\n" 608 " .long 61b,16b\n" 609 " .long 12b,16b\n" 610 " .long 71b,16b\n" 611 " .long 13b,16b\n" 612 " .long 81b,16b\n" 613 " .long 14b,16b\n" 614 " .long 91b,16b\n" 615 " .long 6b,9b\n" 616 " .long 7b,16b\n" 617 ".previous" 618 : "=&c"(size), "=&D" (d0), "=&S" (d1) 619 : "1"(to), "2"(from), "0"(size) 620 : "eax", "edx", "memory"); 621 return size; 622 } 623 624 #else 625 626 /* 627 * Leave these declared but undefined. They should not be any references to 628 * them 629 */ 630 unsigned long __copy_user_zeroing_intel(void *to, const void __user *from, 631 unsigned long size); 632 unsigned long __copy_user_intel(void __user *to, const void *from, 633 unsigned long size); 634 unsigned long __copy_user_zeroing_intel_nocache(void *to, 635 const void __user *from, unsigned long size); 636 #endif /* CONFIG_X86_INTEL_USERCOPY */ 637 638 /* Generic arbitrary sized copy. */ 639 #define __copy_user(to, from, size) \ 640 do { \ 641 int __d0, __d1, __d2; \ 642 __asm__ __volatile__( \ 643 " cmp $7,%0\n" \ 644 " jbe 1f\n" \ 645 " movl %1,%0\n" \ 646 " negl %0\n" \ 647 " andl $7,%0\n" \ 648 " subl %0,%3\n" \ 649 "4: rep; movsb\n" \ 650 " movl %3,%0\n" \ 651 " shrl $2,%0\n" \ 652 " andl $3,%3\n" \ 653 " .align 2,0x90\n" \ 654 "0: rep; movsl\n" \ 655 " movl %3,%0\n" \ 656 "1: rep; movsb\n" \ 657 "2:\n" \ 658 ".section .fixup,\"ax\"\n" \ 659 "5: addl %3,%0\n" \ 660 " jmp 2b\n" \ 661 "3: lea 0(%3,%0,4),%0\n" \ 662 " jmp 2b\n" \ 663 ".previous\n" \ 664 ".section __ex_table,\"a\"\n" \ 665 " .align 4\n" \ 666 " .long 4b,5b\n" \ 667 " .long 0b,3b\n" \ 668 " .long 1b,2b\n" \ 669 ".previous" \ 670 : "=&c"(size), "=&D" (__d0), "=&S" (__d1), "=r"(__d2) \ 671 : "3"(size), "0"(size), "1"(to), "2"(from) \ 672 : "memory"); \ 673 } while (0) 674 675 #define __copy_user_zeroing(to, from, size) \ 676 do { \ 677 int __d0, __d1, __d2; \ 678 __asm__ __volatile__( \ 679 " cmp $7,%0\n" \ 680 " jbe 1f\n" \ 681 " movl %1,%0\n" \ 682 " negl %0\n" \ 683 " andl $7,%0\n" \ 684 " subl %0,%3\n" \ 685 "4: rep; movsb\n" \ 686 " movl %3,%0\n" \ 687 " shrl $2,%0\n" \ 688 " andl $3,%3\n" \ 689 " .align 2,0x90\n" \ 690 "0: rep; movsl\n" \ 691 " movl %3,%0\n" \ 692 "1: rep; movsb\n" \ 693 "2:\n" \ 694 ".section .fixup,\"ax\"\n" \ 695 "5: addl %3,%0\n" \ 696 " jmp 6f\n" \ 697 "3: lea 0(%3,%0,4),%0\n" \ 698 "6: pushl %0\n" \ 699 " pushl %%eax\n" \ 700 " xorl %%eax,%%eax\n" \ 701 " rep; stosb\n" \ 702 " popl %%eax\n" \ 703 " popl %0\n" \ 704 " jmp 2b\n" \ 705 ".previous\n" \ 706 ".section __ex_table,\"a\"\n" \ 707 " .align 4\n" \ 708 " .long 4b,5b\n" \ 709 " .long 0b,3b\n" \ 710 " .long 1b,6b\n" \ 711 ".previous" \ 712 : "=&c"(size), "=&D" (__d0), "=&S" (__d1), "=r"(__d2) \ 713 : "3"(size), "0"(size), "1"(to), "2"(from) \ 714 : "memory"); \ 715 } while (0) 716 717 unsigned long __copy_to_user_ll(void __user *to, const void *from, 718 unsigned long n) 719 { 720 #ifndef CONFIG_X86_WP_WORKS_OK 721 if (unlikely(boot_cpu_data.wp_works_ok == 0) && 722 ((unsigned long)to) < TASK_SIZE) { 723 /* 724 * When we are in an atomic section (see 725 * mm/filemap.c:file_read_actor), return the full 726 * length to take the slow path. 727 */ 728 if (in_atomic()) 729 return n; 730 731 /* 732 * CPU does not honor the WP bit when writing 733 * from supervisory mode, and due to preemption or SMP, 734 * the page tables can change at any time. 735 * Do it manually. Manfred <manfred@colorfullife.com> 736 */ 737 while (n) { 738 unsigned long offset = ((unsigned long)to)%PAGE_SIZE; 739 unsigned long len = PAGE_SIZE - offset; 740 int retval; 741 struct page *pg; 742 void *maddr; 743 744 if (len > n) 745 len = n; 746 747 survive: 748 down_read(¤t->mm->mmap_sem); 749 retval = get_user_pages(current, current->mm, 750 (unsigned long)to, 1, 1, 0, &pg, NULL); 751 752 if (retval == -ENOMEM && is_global_init(current)) { 753 up_read(¤t->mm->mmap_sem); 754 congestion_wait(BLK_RW_ASYNC, HZ/50); 755 goto survive; 756 } 757 758 if (retval != 1) { 759 up_read(¤t->mm->mmap_sem); 760 break; 761 } 762 763 maddr = kmap_atomic(pg, KM_USER0); 764 memcpy(maddr + offset, from, len); 765 kunmap_atomic(maddr, KM_USER0); 766 set_page_dirty_lock(pg); 767 put_page(pg); 768 up_read(¤t->mm->mmap_sem); 769 770 from += len; 771 to += len; 772 n -= len; 773 } 774 return n; 775 } 776 #endif 777 if (movsl_is_ok(to, from, n)) 778 __copy_user(to, from, n); 779 else 780 n = __copy_user_intel(to, from, n); 781 return n; 782 } 783 EXPORT_SYMBOL(__copy_to_user_ll); 784 785 unsigned long __copy_from_user_ll(void *to, const void __user *from, 786 unsigned long n) 787 { 788 if (movsl_is_ok(to, from, n)) 789 __copy_user_zeroing(to, from, n); 790 else 791 n = __copy_user_zeroing_intel(to, from, n); 792 return n; 793 } 794 EXPORT_SYMBOL(__copy_from_user_ll); 795 796 unsigned long __copy_from_user_ll_nozero(void *to, const void __user *from, 797 unsigned long n) 798 { 799 if (movsl_is_ok(to, from, n)) 800 __copy_user(to, from, n); 801 else 802 n = __copy_user_intel((void __user *)to, 803 (const void *)from, n); 804 return n; 805 } 806 EXPORT_SYMBOL(__copy_from_user_ll_nozero); 807 808 unsigned long __copy_from_user_ll_nocache(void *to, const void __user *from, 809 unsigned long n) 810 { 811 #ifdef CONFIG_X86_INTEL_USERCOPY 812 if (n > 64 && cpu_has_xmm2) 813 n = __copy_user_zeroing_intel_nocache(to, from, n); 814 else 815 __copy_user_zeroing(to, from, n); 816 #else 817 __copy_user_zeroing(to, from, n); 818 #endif 819 return n; 820 } 821 EXPORT_SYMBOL(__copy_from_user_ll_nocache); 822 823 unsigned long __copy_from_user_ll_nocache_nozero(void *to, const void __user *from, 824 unsigned long n) 825 { 826 #ifdef CONFIG_X86_INTEL_USERCOPY 827 if (n > 64 && cpu_has_xmm2) 828 n = __copy_user_intel_nocache(to, from, n); 829 else 830 __copy_user(to, from, n); 831 #else 832 __copy_user(to, from, n); 833 #endif 834 return n; 835 } 836 EXPORT_SYMBOL(__copy_from_user_ll_nocache_nozero); 837 838 /** 839 * copy_to_user: - Copy a block of data into user space. 840 * @to: Destination address, in user space. 841 * @from: Source address, in kernel space. 842 * @n: Number of bytes to copy. 843 * 844 * Context: User context only. This function may sleep. 845 * 846 * Copy data from kernel space to user space. 847 * 848 * Returns number of bytes that could not be copied. 849 * On success, this will be zero. 850 */ 851 unsigned long 852 copy_to_user(void __user *to, const void *from, unsigned long n) 853 { 854 if (access_ok(VERIFY_WRITE, to, n)) 855 n = __copy_to_user(to, from, n); 856 return n; 857 } 858 EXPORT_SYMBOL(copy_to_user); 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 */ 876 unsigned long 877 _copy_from_user(void *to, const void __user *from, unsigned long n) 878 { 879 if (access_ok(VERIFY_READ, from, n)) 880 n = __copy_from_user(to, from, n); 881 else 882 memset(to, 0, n); 883 return n; 884 } 885 EXPORT_SYMBOL(_copy_from_user); 886 887 void copy_from_user_overflow(void) 888 { 889 WARN(1, "Buffer overflow detected!\n"); 890 } 891 EXPORT_SYMBOL(copy_from_user_overflow); 892