1 /* Copyright (c) 2005-2008, Google Inc. 2 * All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 * 30 * --- 31 * Author: Markus Gutschke 32 */ 33 34 /* This file includes Linux-specific support functions common to the 35 * coredumper and the thread lister; primarily, this is a collection 36 * of direct system calls, and a couple of symbols missing from 37 * standard header files. 38 * There are a few options that the including file can set to control 39 * the behavior of this file: 40 * 41 * SYS_CPLUSPLUS: 42 * The entire header file will normally be wrapped in 'extern "C" { }", 43 * making it suitable for compilation as both C and C++ source. If you 44 * do not want to do this, you can set the SYS_CPLUSPLUS macro to inhibit 45 * the wrapping. N.B. doing so will suppress inclusion of all prerequisite 46 * system header files, too. It is the caller's responsibility to provide 47 * the necessary definitions. 48 * 49 * SYS_ERRNO: 50 * All system calls will update "errno" unless overriden by setting the 51 * SYS_ERRNO macro prior to including this file. SYS_ERRNO should be 52 * an l-value. 53 * 54 * SYS_INLINE: 55 * New symbols will be defined "static inline", unless overridden by 56 * the SYS_INLINE macro. 57 * 58 * SYS_LINUX_SYSCALL_SUPPORT_H 59 * This macro is used to avoid multiple inclusions of this header file. 60 * If you need to include this file more than once, make sure to 61 * unset SYS_LINUX_SYSCALL_SUPPORT_H before each inclusion. 62 * 63 * SYS_PREFIX: 64 * New system calls will have a prefix of "sys_" unless overridden by 65 * the SYS_PREFIX macro. Valid values for this macro are [0..9] which 66 * results in prefixes "sys[0..9]_". It is also possible to set this 67 * macro to -1, which avoids all prefixes. 68 * 69 * This file defines a few internal symbols that all start with "LSS_". 70 * Do not access these symbols from outside this file. They are not part 71 * of the supported API. 72 * 73 * NOTE: This is a stripped down version of the official opensource 74 * version of linux_syscall_support.h, which lives at 75 * http://code.google.com/p/linux-syscall-support/ 76 * It includes only the syscalls that are used in perftools, plus a 77 * few extra. Here's the breakdown: 78 * 1) Perftools uses these: grep -rho 'sys_[a-z0-9_A-Z]* *(' src | sort -u 79 * sys__exit( 80 * sys_clone( 81 * sys_close( 82 * sys_fcntl( 83 * sys_fstat( 84 * sys_futex( 85 * sys_futex1( 86 * sys_getcpu( 87 * sys_getdents( 88 * sys_getppid( 89 * sys_gettid( 90 * sys_lseek( 91 * sys_mmap( 92 * sys_mremap( 93 * sys_munmap( 94 * sys_open( 95 * sys_pipe( 96 * sys_prctl( 97 * sys_ptrace( 98 * sys_ptrace_detach( 99 * sys_read( 100 * sys_sched_yield( 101 * sys_sigaction( 102 * sys_sigaltstack( 103 * sys_sigdelset( 104 * sys_sigfillset( 105 * sys_sigprocmask( 106 * sys_socket( 107 * sys_stat( 108 * sys_waitpid( 109 * 2) These are used as subroutines of the above: 110 * sys_getpid -- gettid 111 * sys_kill -- ptrace_detach 112 * sys_restore -- sigaction 113 * sys_restore_rt -- sigaction 114 * sys_socketcall -- socket 115 * sys_wait4 -- waitpid 116 * 3) I left these in even though they're not used. They either 117 * complement the above (write vs read) or are variants (rt_sigaction): 118 * sys_fstat64 119 * sys_getdents64 120 * sys_llseek 121 * sys_mmap2 122 * sys_openat 123 * sys_rt_sigaction 124 * sys_rt_sigprocmask 125 * sys_sigaddset 126 * sys_sigemptyset 127 * sys_stat64 128 * sys_write 129 */ 130 #ifndef SYS_LINUX_SYSCALL_SUPPORT_H 131 #define SYS_LINUX_SYSCALL_SUPPORT_H 132 133 /* We currently only support x86-32, x86-64, ARM, MIPS, and PPC on Linux. 134 * Porting to other related platforms should not be difficult. 135 */ 136 #if (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || \ 137 defined(__mips__) || defined(__PPC__)) && defined(__linux) 138 139 #ifndef SYS_CPLUSPLUS 140 #ifdef __cplusplus 141 /* Some system header files in older versions of gcc neglect to properly 142 * handle being included from C++. As it appears to be harmless to have 143 * multiple nested 'extern "C"' blocks, just add another one here. 144 */ 145 extern "C" { 146 #endif 147 148 #include <errno.h> 149 #include <signal.h> 150 #include <stdarg.h> 151 #include <stddef.h> 152 #include <stdint.h> 153 #include <string.h> 154 #include <sys/ptrace.h> 155 #include <sys/resource.h> 156 #include <sys/time.h> 157 #include <sys/types.h> 158 #if defined(__ANDROID__) 159 #include <sys/syscall.h> 160 #ifndef ANDROID_NON_SDK_BUILD 161 #include <sys/linux-syscalls.h> 162 #endif 163 #else 164 #include <syscall.h> 165 #endif 166 #include <unistd.h> 167 #include <linux/unistd.h> 168 #include <endian.h> 169 170 #ifdef __mips__ 171 /* Include definitions of the ABI currently in use. */ 172 #include <sgidefs.h> 173 #endif 174 175 #endif 176 177 /* As glibc often provides subtly incompatible data structures (and implicit 178 * wrapper functions that convert them), we provide our own kernel data 179 * structures for use by the system calls. 180 * These structures have been developed by using Linux 2.6.23 headers for 181 * reference. Note though, we do not care about exact API compatibility 182 * with the kernel, and in fact the kernel often does not have a single 183 * API that works across architectures. Instead, we try to mimic the glibc 184 * API where reasonable, and only guarantee ABI compatibility with the 185 * kernel headers. 186 * Most notably, here are a few changes that were made to the structures 187 * defined by kernel headers: 188 * 189 * - we only define structures, but not symbolic names for kernel data 190 * types. For the latter, we directly use the native C datatype 191 * (i.e. "unsigned" instead of "mode_t"). 192 * - in a few cases, it is possible to define identical structures for 193 * both 32bit (e.g. i386) and 64bit (e.g. x86-64) platforms by 194 * standardizing on the 64bit version of the data types. In particular, 195 * this means that we use "unsigned" where the 32bit headers say 196 * "unsigned long". 197 * - overall, we try to minimize the number of cases where we need to 198 * conditionally define different structures. 199 * - the "struct kernel_sigaction" class of structures have been 200 * modified to more closely mimic glibc's API by introducing an 201 * anonymous union for the function pointer. 202 * - a small number of field names had to have an underscore appended to 203 * them, because glibc defines a global macro by the same name. 204 */ 205 206 /* include/linux/dirent.h */ 207 struct kernel_dirent64 { 208 unsigned long long d_ino; 209 long long d_off; 210 unsigned short d_reclen; 211 unsigned char d_type; 212 char d_name[256]; 213 }; 214 215 /* include/linux/dirent.h */ 216 struct kernel_dirent { 217 long d_ino; 218 long d_off; 219 unsigned short d_reclen; 220 char d_name[256]; 221 }; 222 223 /* include/linux/time.h */ 224 struct kernel_timespec { 225 long tv_sec; 226 long tv_nsec; 227 }; 228 229 /* include/linux/time.h */ 230 struct kernel_timeval { 231 long tv_sec; 232 long tv_usec; 233 }; 234 235 /* include/linux/resource.h */ 236 struct kernel_rusage { 237 struct kernel_timeval ru_utime; 238 struct kernel_timeval ru_stime; 239 long ru_maxrss; 240 long ru_ixrss; 241 long ru_idrss; 242 long ru_isrss; 243 long ru_minflt; 244 long ru_majflt; 245 long ru_nswap; 246 long ru_inblock; 247 long ru_oublock; 248 long ru_msgsnd; 249 long ru_msgrcv; 250 long ru_nsignals; 251 long ru_nvcsw; 252 long ru_nivcsw; 253 }; 254 255 #if defined(__i386__) || defined(__arm__) || defined(__PPC__) 256 257 /* include/asm-{arm,i386,mips,ppc}/signal.h */ 258 struct kernel_old_sigaction { 259 union { 260 void (*sa_handler_)(int); 261 void (*sa_sigaction_)(int, siginfo_t *, void *); 262 }; 263 unsigned long sa_mask; 264 unsigned long sa_flags; 265 void (*sa_restorer)(void); 266 } __attribute__((packed,aligned(4))); 267 #elif (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 268 #define kernel_old_sigaction kernel_sigaction 269 #endif 270 271 /* Some kernel functions (e.g. sigaction() in 2.6.23) require that the 272 * exactly match the size of the signal set, even though the API was 273 * intended to be extensible. We define our own KERNEL_NSIG to deal with 274 * this. 275 * Please note that glibc provides signals [1.._NSIG-1], whereas the 276 * kernel (and this header) provides the range [1..KERNEL_NSIG]. The 277 * actual number of signals is obviously the same, but the constants 278 * differ by one. 279 */ 280 #ifdef __mips__ 281 #define KERNEL_NSIG 128 282 #else 283 #define KERNEL_NSIG 64 284 #endif 285 286 /* include/asm-{arm,i386,mips,x86_64}/signal.h */ 287 struct kernel_sigset_t { 288 unsigned long sig[(KERNEL_NSIG + 8*sizeof(unsigned long) - 1)/ 289 (8*sizeof(unsigned long))]; 290 }; 291 292 /* include/asm-{arm,i386,mips,x86_64,ppc}/signal.h */ 293 struct kernel_sigaction { 294 #ifdef __mips__ 295 unsigned long sa_flags; 296 union { 297 void (*sa_handler_)(int); 298 void (*sa_sigaction_)(int, siginfo_t *, void *); 299 }; 300 struct kernel_sigset_t sa_mask; 301 #else 302 union { 303 void (*sa_handler_)(int); 304 void (*sa_sigaction_)(int, siginfo_t *, void *); 305 }; 306 unsigned long sa_flags; 307 void (*sa_restorer)(void); 308 struct kernel_sigset_t sa_mask; 309 #endif 310 }; 311 312 /* include/asm-{arm,i386,mips,ppc}/stat.h */ 313 #ifdef __mips__ 314 #if _MIPS_SIM == _MIPS_SIM_ABI64 315 struct kernel_stat { 316 #else 317 struct kernel_stat64 { 318 #endif 319 unsigned st_dev; 320 unsigned __pad0[3]; 321 unsigned long long st_ino; 322 unsigned st_mode; 323 unsigned st_nlink; 324 unsigned st_uid; 325 unsigned st_gid; 326 unsigned st_rdev; 327 unsigned __pad1[3]; 328 long long st_size; 329 unsigned st_atime_; 330 unsigned st_atime_nsec_; 331 unsigned st_mtime_; 332 unsigned st_mtime_nsec_; 333 unsigned st_ctime_; 334 unsigned st_ctime_nsec_; 335 unsigned st_blksize; 336 unsigned __pad2; 337 unsigned long long st_blocks; 338 }; 339 #elif defined __PPC__ 340 struct kernel_stat64 { 341 unsigned long long st_dev; 342 unsigned long long st_ino; 343 unsigned st_mode; 344 unsigned st_nlink; 345 unsigned st_uid; 346 unsigned st_gid; 347 unsigned long long st_rdev; 348 unsigned short int __pad2; 349 long long st_size; 350 long st_blksize; 351 long long st_blocks; 352 long st_atime_; 353 unsigned long st_atime_nsec_; 354 long st_mtime_; 355 unsigned long st_mtime_nsec_; 356 long st_ctime_; 357 unsigned long st_ctime_nsec_; 358 unsigned long __unused4; 359 unsigned long __unused5; 360 }; 361 #else 362 struct kernel_stat64 { 363 unsigned long long st_dev; 364 unsigned char __pad0[4]; 365 unsigned __st_ino; 366 unsigned st_mode; 367 unsigned st_nlink; 368 unsigned st_uid; 369 unsigned st_gid; 370 unsigned long long st_rdev; 371 unsigned char __pad3[4]; 372 long long st_size; 373 unsigned st_blksize; 374 unsigned long long st_blocks; 375 unsigned st_atime_; 376 unsigned st_atime_nsec_; 377 unsigned st_mtime_; 378 unsigned st_mtime_nsec_; 379 unsigned st_ctime_; 380 unsigned st_ctime_nsec_; 381 unsigned long long st_ino; 382 }; 383 #endif 384 385 /* include/asm-{arm,i386,mips,x86_64,ppc}/stat.h */ 386 #if defined(__i386__) || defined(__arm__) 387 struct kernel_stat { 388 /* The kernel headers suggest that st_dev and st_rdev should be 32bit 389 * quantities encoding 12bit major and 20bit minor numbers in an interleaved 390 * format. In reality, we do not see useful data in the top bits. So, 391 * we'll leave the padding in here, until we find a better solution. 392 */ 393 unsigned short st_dev; 394 short pad1; 395 unsigned st_ino; 396 unsigned short st_mode; 397 unsigned short st_nlink; 398 unsigned short st_uid; 399 unsigned short st_gid; 400 unsigned short st_rdev; 401 short pad2; 402 unsigned st_size; 403 unsigned st_blksize; 404 unsigned st_blocks; 405 unsigned st_atime_; 406 unsigned st_atime_nsec_; 407 unsigned st_mtime_; 408 unsigned st_mtime_nsec_; 409 unsigned st_ctime_; 410 unsigned st_ctime_nsec_; 411 unsigned __unused4; 412 unsigned __unused5; 413 }; 414 #elif defined(__x86_64__) 415 struct kernel_stat { 416 uint64_t st_dev; 417 uint64_t st_ino; 418 uint64_t st_nlink; 419 unsigned st_mode; 420 unsigned st_uid; 421 unsigned st_gid; 422 unsigned __pad0; 423 uint64_t st_rdev; 424 int64_t st_size; 425 int64_t st_blksize; 426 int64_t st_blocks; 427 uint64_t st_atime_; 428 uint64_t st_atime_nsec_; 429 uint64_t st_mtime_; 430 uint64_t st_mtime_nsec_; 431 uint64_t st_ctime_; 432 uint64_t st_ctime_nsec_; 433 int64_t __unused[3]; 434 }; 435 #elif defined(__PPC__) 436 struct kernel_stat { 437 unsigned st_dev; 438 unsigned long st_ino; // ino_t 439 unsigned long st_mode; // mode_t 440 unsigned short st_nlink; // nlink_t 441 unsigned st_uid; // uid_t 442 unsigned st_gid; // gid_t 443 unsigned st_rdev; 444 long st_size; // off_t 445 unsigned long st_blksize; 446 unsigned long st_blocks; 447 unsigned long st_atime_; 448 unsigned long st_atime_nsec_; 449 unsigned long st_mtime_; 450 unsigned long st_mtime_nsec_; 451 unsigned long st_ctime_; 452 unsigned long st_ctime_nsec_; 453 unsigned long __unused4; 454 unsigned long __unused5; 455 }; 456 #elif (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI64) 457 struct kernel_stat { 458 unsigned st_dev; 459 int st_pad1[3]; 460 unsigned st_ino; 461 unsigned st_mode; 462 unsigned st_nlink; 463 unsigned st_uid; 464 unsigned st_gid; 465 unsigned st_rdev; 466 int st_pad2[2]; 467 long st_size; 468 int st_pad3; 469 long st_atime_; 470 long st_atime_nsec_; 471 long st_mtime_; 472 long st_mtime_nsec_; 473 long st_ctime_; 474 long st_ctime_nsec_; 475 int st_blksize; 476 int st_blocks; 477 int st_pad4[14]; 478 }; 479 #endif 480 481 // ulong is not defined in Android while used to define __llseek. 482 #if defined(__ANDROID__) 483 typedef unsigned long int ulong; 484 #endif 485 486 487 /* Definitions missing from the standard header files */ 488 #ifndef O_DIRECTORY 489 #if defined(__arm__) 490 #define O_DIRECTORY 0040000 491 #else 492 #define O_DIRECTORY 0200000 493 #endif 494 #endif 495 #ifndef PR_GET_DUMPABLE 496 #define PR_GET_DUMPABLE 3 497 #endif 498 #ifndef PR_SET_DUMPABLE 499 #define PR_SET_DUMPABLE 4 500 #endif 501 #ifndef AT_FDCWD 502 #define AT_FDCWD (-100) 503 #endif 504 #ifndef AT_SYMLINK_NOFOLLOW 505 #define AT_SYMLINK_NOFOLLOW 0x100 506 #endif 507 #ifndef AT_REMOVEDIR 508 #define AT_REMOVEDIR 0x200 509 #endif 510 #ifndef MREMAP_FIXED 511 #define MREMAP_FIXED 2 512 #endif 513 #ifndef SA_RESTORER 514 #define SA_RESTORER 0x04000000 515 #endif 516 517 #if defined(__i386__) 518 #ifndef __NR_rt_sigaction 519 #define __NR_rt_sigaction 174 520 #define __NR_rt_sigprocmask 175 521 #endif 522 #ifndef __NR_stat64 523 #define __NR_stat64 195 524 #endif 525 #ifndef __NR_fstat64 526 #define __NR_fstat64 197 527 #endif 528 #ifndef __NR_getdents64 529 #define __NR_getdents64 220 530 #endif 531 #ifndef __NR_gettid 532 #define __NR_gettid 224 533 #endif 534 #ifndef __NR_futex 535 #define __NR_futex 240 536 #endif 537 #ifndef __NR_openat 538 #define __NR_openat 295 539 #endif 540 #ifndef __NR_getcpu 541 #define __NR_getcpu 318 542 #endif 543 /* End of i386 definitions */ 544 #elif defined(__arm__) 545 #ifndef __syscall 546 #if defined(__thumb__) || defined(__ARM_EABI__) 547 #define __SYS_REG(name) register long __sysreg __asm__("r6") = __NR_##name; 548 #define __SYS_REG_LIST(regs...) [sysreg] "r" (__sysreg) , ##regs 549 #define __syscall(name) "swi\t0" 550 #define __syscall_safe(name) \ 551 "push {r7}\n" \ 552 "mov r7,%[sysreg]\n" \ 553 __syscall(name)"\n" \ 554 "pop {r7}" 555 #else 556 #define __SYS_REG(name) 557 #define __SYS_REG_LIST(regs...) regs 558 #define __syscall(name) "swi\t" __sys1(__NR_##name) "" 559 #define __syscall_safe(name) __syscall(name) 560 #endif 561 #endif 562 #ifndef __NR_rt_sigaction 563 #define __NR_rt_sigaction (__NR_SYSCALL_BASE + 174) 564 #define __NR_rt_sigprocmask (__NR_SYSCALL_BASE + 175) 565 #endif 566 #ifndef __NR_stat64 567 #define __NR_stat64 (__NR_SYSCALL_BASE + 195) 568 #endif 569 #ifndef __NR_fstat64 570 #define __NR_fstat64 (__NR_SYSCALL_BASE + 197) 571 #endif 572 #ifndef __NR_getdents64 573 #define __NR_getdents64 (__NR_SYSCALL_BASE + 217) 574 #endif 575 #ifndef __NR_gettid 576 #define __NR_gettid (__NR_SYSCALL_BASE + 224) 577 #endif 578 #ifndef __NR_futex 579 #define __NR_futex (__NR_SYSCALL_BASE + 240) 580 #endif 581 /* End of ARM definitions */ 582 #elif defined(__x86_64__) 583 #ifndef __NR_gettid 584 #define __NR_gettid 186 585 #endif 586 #ifndef __NR_futex 587 #define __NR_futex 202 588 #endif 589 #ifndef __NR_getdents64 590 #define __NR_getdents64 217 591 #endif 592 #ifndef __NR_openat 593 #define __NR_openat 257 594 #endif 595 /* End of x86-64 definitions */ 596 #elif defined(__mips__) 597 #if _MIPS_SIM == _MIPS_SIM_ABI32 598 #ifndef __NR_rt_sigaction 599 #define __NR_rt_sigaction (__NR_Linux + 194) 600 #define __NR_rt_sigprocmask (__NR_Linux + 195) 601 #endif 602 #ifndef __NR_stat64 603 #define __NR_stat64 (__NR_Linux + 213) 604 #endif 605 #ifndef __NR_fstat64 606 #define __NR_fstat64 (__NR_Linux + 215) 607 #endif 608 #ifndef __NR_getdents64 609 #define __NR_getdents64 (__NR_Linux + 219) 610 #endif 611 #ifndef __NR_gettid 612 #define __NR_gettid (__NR_Linux + 222) 613 #endif 614 #ifndef __NR_futex 615 #define __NR_futex (__NR_Linux + 238) 616 #endif 617 #ifndef __NR_openat 618 #define __NR_openat (__NR_Linux + 288) 619 #endif 620 #ifndef __NR_fstatat 621 #define __NR_fstatat (__NR_Linux + 293) 622 #endif 623 #ifndef __NR_getcpu 624 #define __NR_getcpu (__NR_Linux + 312) 625 #endif 626 /* End of MIPS (old 32bit API) definitions */ 627 #elif _MIPS_SIM == _MIPS_SIM_ABI64 628 #ifndef __NR_gettid 629 #define __NR_gettid (__NR_Linux + 178) 630 #endif 631 #ifndef __NR_futex 632 #define __NR_futex (__NR_Linux + 194) 633 #endif 634 #ifndef __NR_openat 635 #define __NR_openat (__NR_Linux + 247) 636 #endif 637 #ifndef __NR_fstatat 638 #define __NR_fstatat (__NR_Linux + 252) 639 #endif 640 #ifndef __NR_getcpu 641 #define __NR_getcpu (__NR_Linux + 271) 642 #endif 643 /* End of MIPS (64bit API) definitions */ 644 #else 645 #ifndef __NR_gettid 646 #define __NR_gettid (__NR_Linux + 178) 647 #endif 648 #ifndef __NR_futex 649 #define __NR_futex (__NR_Linux + 194) 650 #endif 651 #ifndef __NR_openat 652 #define __NR_openat (__NR_Linux + 251) 653 #endif 654 #ifndef __NR_fstatat 655 #define __NR_fstatat (__NR_Linux + 256) 656 #endif 657 #ifndef __NR_getcpu 658 #define __NR_getcpu (__NR_Linux + 275) 659 #endif 660 /* End of MIPS (new 32bit API) definitions */ 661 #endif 662 /* End of MIPS definitions */ 663 #elif defined(__PPC__) 664 #ifndef __NR_rt_sigaction 665 #define __NR_rt_sigaction 173 666 #define __NR_rt_sigprocmask 174 667 #endif 668 #ifndef __NR_stat64 669 #define __NR_stat64 195 670 #endif 671 #ifndef __NR_fstat64 672 #define __NR_fstat64 197 673 #endif 674 #ifndef __NR_getdents64 675 #define __NR_getdents64 202 676 #endif 677 #ifndef __NR_gettid 678 #define __NR_gettid 207 679 #endif 680 #ifndef __NR_futex 681 #define __NR_futex 221 682 #endif 683 #ifndef __NR_openat 684 #define __NR_openat 286 685 #endif 686 #ifndef __NR_getcpu 687 #define __NR_getcpu 302 688 #endif 689 /* End of powerpc defininitions */ 690 #endif 691 692 693 /* After forking, we must make sure to only call system calls. */ 694 #if __BOUNDED_POINTERS__ 695 #error "Need to port invocations of syscalls for bounded ptrs" 696 #else 697 /* The core dumper and the thread lister get executed after threads 698 * have been suspended. As a consequence, we cannot call any functions 699 * that acquire locks. Unfortunately, libc wraps most system calls 700 * (e.g. in order to implement pthread_atfork, and to make calls 701 * cancellable), which means we cannot call these functions. Instead, 702 * we have to call syscall() directly. 703 */ 704 #undef LSS_ERRNO 705 #ifdef SYS_ERRNO 706 /* Allow the including file to override the location of errno. This can 707 * be useful when using clone() with the CLONE_VM option. 708 */ 709 #define LSS_ERRNO SYS_ERRNO 710 #else 711 #define LSS_ERRNO errno 712 #endif 713 714 #undef LSS_INLINE 715 #ifdef SYS_INLINE 716 #define LSS_INLINE SYS_INLINE 717 #else 718 #define LSS_INLINE static inline 719 #endif 720 721 /* Allow the including file to override the prefix used for all new 722 * system calls. By default, it will be set to "sys_". 723 */ 724 #undef LSS_NAME 725 #ifndef SYS_PREFIX 726 #define LSS_NAME(name) sys_##name 727 #elif SYS_PREFIX < 0 728 #define LSS_NAME(name) name 729 #elif SYS_PREFIX == 0 730 #define LSS_NAME(name) sys0_##name 731 #elif SYS_PREFIX == 1 732 #define LSS_NAME(name) sys1_##name 733 #elif SYS_PREFIX == 2 734 #define LSS_NAME(name) sys2_##name 735 #elif SYS_PREFIX == 3 736 #define LSS_NAME(name) sys3_##name 737 #elif SYS_PREFIX == 4 738 #define LSS_NAME(name) sys4_##name 739 #elif SYS_PREFIX == 5 740 #define LSS_NAME(name) sys5_##name 741 #elif SYS_PREFIX == 6 742 #define LSS_NAME(name) sys6_##name 743 #elif SYS_PREFIX == 7 744 #define LSS_NAME(name) sys7_##name 745 #elif SYS_PREFIX == 8 746 #define LSS_NAME(name) sys8_##name 747 #elif SYS_PREFIX == 9 748 #define LSS_NAME(name) sys9_##name 749 #endif 750 751 #undef LSS_RETURN 752 #if (defined(__i386__) || defined(__x86_64__) || defined(__arm__)) 753 /* Failing system calls return a negative result in the range of 754 * -1..-4095. These are "errno" values with the sign inverted. 755 */ 756 #define LSS_RETURN(type, res) \ 757 do { \ 758 if ((unsigned long)(res) >= (unsigned long)(-4095)) { \ 759 LSS_ERRNO = -(res); \ 760 res = -1; \ 761 } \ 762 return (type) (res); \ 763 } while (0) 764 #elif defined(__mips__) 765 /* On MIPS, failing system calls return -1, and set errno in a 766 * separate CPU register. 767 */ 768 #define LSS_RETURN(type, res, err) \ 769 do { \ 770 if (err) { \ 771 LSS_ERRNO = (res); \ 772 res = -1; \ 773 } \ 774 return (type) (res); \ 775 } while (0) 776 #elif defined(__PPC__) 777 /* On PPC, failing system calls return -1, and set errno in a 778 * separate CPU register. See linux/unistd.h. 779 */ 780 #define LSS_RETURN(type, res, err) \ 781 do { \ 782 if (err & 0x10000000 ) { \ 783 LSS_ERRNO = (res); \ 784 res = -1; \ 785 } \ 786 return (type) (res); \ 787 } while (0) 788 #endif 789 #if defined(__i386__) 790 #if defined(NO_FRAME_POINTER) && (100 * __GNUC__ + __GNUC_MINOR__ >= 404) 791 /* This only works for GCC-4.4 and above -- the first version to use 792 .cfi directives for dwarf unwind info. */ 793 #define CFI_ADJUST_CFA_OFFSET(adjust) \ 794 ".cfi_adjust_cfa_offset " #adjust "\n" 795 #else 796 #define CFI_ADJUST_CFA_OFFSET(adjust) /**/ 797 #endif 798 799 /* In PIC mode (e.g. when building shared libraries), gcc for i386 800 * reserves ebx. Unfortunately, most distribution ship with implementations 801 * of _syscallX() which clobber ebx. 802 * Also, most definitions of _syscallX() neglect to mark "memory" as being 803 * clobbered. This causes problems with compilers, that do a better job 804 * at optimizing across __asm__ calls. 805 * So, we just have to redefine all of the _syscallX() macros. 806 */ 807 #undef LSS_BODY 808 #define LSS_BODY(type,args...) \ 809 long __res; \ 810 __asm__ __volatile__("push %%ebx\n" \ 811 CFI_ADJUST_CFA_OFFSET(4) \ 812 "movl %2,%%ebx\n" \ 813 "int $0x80\n" \ 814 "pop %%ebx\n" \ 815 CFI_ADJUST_CFA_OFFSET(-4) \ 816 args \ 817 : "esp", "memory"); \ 818 LSS_RETURN(type,__res) 819 #undef _syscall0 820 #define _syscall0(type,name) \ 821 type LSS_NAME(name)(void) { \ 822 long __res; \ 823 __asm__ volatile("int $0x80" \ 824 : "=a" (__res) \ 825 : "0" (__NR_##name) \ 826 : "memory"); \ 827 LSS_RETURN(type,__res); \ 828 } 829 #undef _syscall1 830 #define _syscall1(type,name,type1,arg1) \ 831 type LSS_NAME(name)(type1 arg1) { \ 832 LSS_BODY(type, \ 833 : "=a" (__res) \ 834 : "0" (__NR_##name), "ri" ((long)(arg1))); \ 835 } 836 #undef _syscall2 837 #define _syscall2(type,name,type1,arg1,type2,arg2) \ 838 type LSS_NAME(name)(type1 arg1,type2 arg2) { \ 839 LSS_BODY(type, \ 840 : "=a" (__res) \ 841 : "0" (__NR_##name),"ri" ((long)(arg1)), "c" ((long)(arg2))); \ 842 } 843 #undef _syscall3 844 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \ 845 type LSS_NAME(name)(type1 arg1,type2 arg2,type3 arg3) { \ 846 LSS_BODY(type, \ 847 : "=a" (__res) \ 848 : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)), \ 849 "d" ((long)(arg3))); \ 850 } 851 #undef _syscall4 852 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 853 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 854 LSS_BODY(type, \ 855 : "=a" (__res) \ 856 : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)), \ 857 "d" ((long)(arg3)),"S" ((long)(arg4))); \ 858 } 859 #undef _syscall5 860 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 861 type5,arg5) \ 862 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 863 type5 arg5) { \ 864 long __res; \ 865 __asm__ __volatile__("push %%ebx\n" \ 866 "movl %2,%%ebx\n" \ 867 "movl %1,%%eax\n" \ 868 "int $0x80\n" \ 869 "pop %%ebx" \ 870 : "=a" (__res) \ 871 : "i" (__NR_##name), "ri" ((long)(arg1)), \ 872 "c" ((long)(arg2)), "d" ((long)(arg3)), \ 873 "S" ((long)(arg4)), "D" ((long)(arg5)) \ 874 : "esp", "memory"); \ 875 LSS_RETURN(type,__res); \ 876 } 877 #undef _syscall6 878 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 879 type5,arg5,type6,arg6) \ 880 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 881 type5 arg5, type6 arg6) { \ 882 long __res; \ 883 struct { long __a1; long __a6; } __s = { (long)arg1, (long) arg6 }; \ 884 __asm__ __volatile__("push %%ebp\n" \ 885 "push %%ebx\n" \ 886 "movl 4(%2),%%ebp\n" \ 887 "movl 0(%2), %%ebx\n" \ 888 "movl %1,%%eax\n" \ 889 "int $0x80\n" \ 890 "pop %%ebx\n" \ 891 "pop %%ebp" \ 892 : "=a" (__res) \ 893 : "i" (__NR_##name), "0" ((long)(&__s)), \ 894 "c" ((long)(arg2)), "d" ((long)(arg3)), \ 895 "S" ((long)(arg4)), "D" ((long)(arg5)) \ 896 : "esp", "memory"); \ 897 LSS_RETURN(type,__res); \ 898 } 899 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 900 int flags, void *arg, int *parent_tidptr, 901 void *newtls, int *child_tidptr) { 902 long __res; 903 __asm__ __volatile__(/* if (fn == NULL) 904 * return -EINVAL; 905 */ 906 "movl %3,%%ecx\n" 907 "jecxz 1f\n" 908 909 /* if (child_stack == NULL) 910 * return -EINVAL; 911 */ 912 "movl %4,%%ecx\n" 913 "jecxz 1f\n" 914 915 /* Set up alignment of the child stack: 916 * child_stack = (child_stack & ~0xF) - 20; 917 */ 918 "andl $-16,%%ecx\n" 919 "subl $20,%%ecx\n" 920 921 /* Push "arg" and "fn" onto the stack that will be 922 * used by the child. 923 */ 924 "movl %6,%%eax\n" 925 "movl %%eax,4(%%ecx)\n" 926 "movl %3,%%eax\n" 927 "movl %%eax,(%%ecx)\n" 928 929 /* %eax = syscall(%eax = __NR_clone, 930 * %ebx = flags, 931 * %ecx = child_stack, 932 * %edx = parent_tidptr, 933 * %esi = newtls, 934 * %edi = child_tidptr) 935 * Also, make sure that %ebx gets preserved as it is 936 * used in PIC mode. 937 */ 938 "movl %8,%%esi\n" 939 "movl %7,%%edx\n" 940 "movl %5,%%eax\n" 941 "movl %9,%%edi\n" 942 "pushl %%ebx\n" 943 "movl %%eax,%%ebx\n" 944 "movl %2,%%eax\n" 945 "int $0x80\n" 946 947 /* In the parent: restore %ebx 948 * In the child: move "fn" into %ebx 949 */ 950 "popl %%ebx\n" 951 952 /* if (%eax != 0) 953 * return %eax; 954 */ 955 "test %%eax,%%eax\n" 956 "jnz 1f\n" 957 958 /* In the child, now. Terminate frame pointer chain. 959 */ 960 "movl $0,%%ebp\n" 961 962 /* Call "fn". "arg" is already on the stack. 963 */ 964 "call *%%ebx\n" 965 966 /* Call _exit(%ebx). Unfortunately older versions 967 * of gcc restrict the number of arguments that can 968 * be passed to asm(). So, we need to hard-code the 969 * system call number. 970 */ 971 "movl %%eax,%%ebx\n" 972 "movl $1,%%eax\n" 973 "int $0x80\n" 974 975 /* Return to parent. 976 */ 977 "1:\n" 978 : "=a" (__res) 979 : "0"(-EINVAL), "i"(__NR_clone), 980 "m"(fn), "m"(child_stack), "m"(flags), "m"(arg), 981 "m"(parent_tidptr), "m"(newtls), "m"(child_tidptr) 982 : "esp", "memory", "ecx", "edx", "esi", "edi"); 983 LSS_RETURN(int, __res); 984 } 985 986 LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) { 987 /* On i386, the kernel does not know how to return from a signal 988 * handler. Instead, it relies on user space to provide a 989 * restorer function that calls the {rt_,}sigreturn() system call. 990 * Unfortunately, we cannot just reference the glibc version of this 991 * function, as glibc goes out of its way to make it inaccessible. 992 */ 993 void (*res)(void); 994 __asm__ __volatile__("call 2f\n" 995 "0:.align 16\n" 996 "1:movl %1,%%eax\n" 997 "int $0x80\n" 998 "2:popl %0\n" 999 "addl $(1b-0b),%0\n" 1000 : "=a" (res) 1001 : "i" (__NR_rt_sigreturn)); 1002 return res; 1003 } 1004 LSS_INLINE void (*LSS_NAME(restore)(void))(void) { 1005 /* On i386, the kernel does not know how to return from a signal 1006 * handler. Instead, it relies on user space to provide a 1007 * restorer function that calls the {rt_,}sigreturn() system call. 1008 * Unfortunately, we cannot just reference the glibc version of this 1009 * function, as glibc goes out of its way to make it inaccessible. 1010 */ 1011 void (*res)(void); 1012 __asm__ __volatile__("call 2f\n" 1013 "0:.align 16\n" 1014 "1:pop %%eax\n" 1015 "movl %1,%%eax\n" 1016 "int $0x80\n" 1017 "2:popl %0\n" 1018 "addl $(1b-0b),%0\n" 1019 : "=a" (res) 1020 : "i" (__NR_sigreturn)); 1021 return res; 1022 } 1023 #elif defined(__x86_64__) 1024 /* There are no known problems with any of the _syscallX() macros 1025 * currently shipping for x86_64, but we still need to be able to define 1026 * our own version so that we can override the location of the errno 1027 * location (e.g. when using the clone() system call with the CLONE_VM 1028 * option). 1029 */ 1030 #undef LSS_ENTRYPOINT 1031 #define LSS_ENTRYPOINT "syscall\n" 1032 1033 /* The x32 ABI has 32 bit longs, but the syscall interface is 64 bit. 1034 * We need to explicitly cast to an unsigned 64 bit type to avoid implicit 1035 * sign extension. We can't cast pointers directly because those are 1036 * 32 bits, and gcc will dump ugly warnings about casting from a pointer 1037 * to an integer of a different size. 1038 */ 1039 #undef LSS_SYSCALL_ARG 1040 #define LSS_SYSCALL_ARG(a) ((uint64_t)(uintptr_t)(a)) 1041 #undef _LSS_RETURN 1042 #define _LSS_RETURN(type, res, cast) \ 1043 do { \ 1044 if ((uint64_t)(res) >= (uint64_t)(-4095)) { \ 1045 LSS_ERRNO = -(res); \ 1046 res = -1; \ 1047 } \ 1048 return (type)(cast)(res); \ 1049 } while (0) 1050 #undef LSS_RETURN 1051 #define LSS_RETURN(type, res) _LSS_RETURN(type, res, uintptr_t) 1052 1053 #undef _LSS_BODY 1054 #define _LSS_BODY(nr, type, name, cast, ...) \ 1055 long long __res; \ 1056 __asm__ __volatile__(LSS_BODY_ASM##nr LSS_ENTRYPOINT \ 1057 : "=a" (__res) \ 1058 : "0" (__NR_##name) LSS_BODY_ARG##nr(__VA_ARGS__) \ 1059 : LSS_BODY_CLOBBER##nr "r11", "rcx", "memory"); \ 1060 _LSS_RETURN(type, __res, cast) 1061 #undef LSS_BODY 1062 #define LSS_BODY(nr, type, name, args...) \ 1063 _LSS_BODY(nr, type, name, uintptr_t, ## args) 1064 1065 #undef LSS_BODY_ASM0 1066 #undef LSS_BODY_ASM1 1067 #undef LSS_BODY_ASM2 1068 #undef LSS_BODY_ASM3 1069 #undef LSS_BODY_ASM4 1070 #undef LSS_BODY_ASM5 1071 #undef LSS_BODY_ASM6 1072 #define LSS_BODY_ASM0 1073 #define LSS_BODY_ASM1 LSS_BODY_ASM0 1074 #define LSS_BODY_ASM2 LSS_BODY_ASM1 1075 #define LSS_BODY_ASM3 LSS_BODY_ASM2 1076 #define LSS_BODY_ASM4 LSS_BODY_ASM3 "movq %5,%%r10;" 1077 #define LSS_BODY_ASM5 LSS_BODY_ASM4 "movq %6,%%r8;" 1078 #define LSS_BODY_ASM6 LSS_BODY_ASM5 "movq %7,%%r9;" 1079 1080 #undef LSS_BODY_CLOBBER0 1081 #undef LSS_BODY_CLOBBER1 1082 #undef LSS_BODY_CLOBBER2 1083 #undef LSS_BODY_CLOBBER3 1084 #undef LSS_BODY_CLOBBER4 1085 #undef LSS_BODY_CLOBBER5 1086 #undef LSS_BODY_CLOBBER6 1087 #define LSS_BODY_CLOBBER0 1088 #define LSS_BODY_CLOBBER1 LSS_BODY_CLOBBER0 1089 #define LSS_BODY_CLOBBER2 LSS_BODY_CLOBBER1 1090 #define LSS_BODY_CLOBBER3 LSS_BODY_CLOBBER2 1091 #define LSS_BODY_CLOBBER4 LSS_BODY_CLOBBER3 "r10", 1092 #define LSS_BODY_CLOBBER5 LSS_BODY_CLOBBER4 "r8", 1093 #define LSS_BODY_CLOBBER6 LSS_BODY_CLOBBER5 "r9", 1094 1095 #undef LSS_BODY_ARG0 1096 #undef LSS_BODY_ARG1 1097 #undef LSS_BODY_ARG2 1098 #undef LSS_BODY_ARG3 1099 #undef LSS_BODY_ARG4 1100 #undef LSS_BODY_ARG5 1101 #undef LSS_BODY_ARG6 1102 #define LSS_BODY_ARG0() 1103 #define LSS_BODY_ARG1(arg1) \ 1104 LSS_BODY_ARG0(), "D" (arg1) 1105 #define LSS_BODY_ARG2(arg1, arg2) \ 1106 LSS_BODY_ARG1(arg1), "S" (arg2) 1107 #define LSS_BODY_ARG3(arg1, arg2, arg3) \ 1108 LSS_BODY_ARG2(arg1, arg2), "d" (arg3) 1109 #define LSS_BODY_ARG4(arg1, arg2, arg3, arg4) \ 1110 LSS_BODY_ARG3(arg1, arg2, arg3), "r" (arg4) 1111 #define LSS_BODY_ARG5(arg1, arg2, arg3, arg4, arg5) \ 1112 LSS_BODY_ARG4(arg1, arg2, arg3, arg4), "r" (arg5) 1113 #define LSS_BODY_ARG6(arg1, arg2, arg3, arg4, arg5, arg6) \ 1114 LSS_BODY_ARG5(arg1, arg2, arg3, arg4, arg5), "r" (arg6) 1115 1116 #undef _syscall0 1117 #define _syscall0(type,name) \ 1118 type LSS_NAME(name)() { \ 1119 LSS_BODY(0, type, name); \ 1120 } 1121 #undef _syscall1 1122 #define _syscall1(type,name,type1,arg1) \ 1123 type LSS_NAME(name)(type1 arg1) { \ 1124 LSS_BODY(1, type, name, LSS_SYSCALL_ARG(arg1)); \ 1125 } 1126 #undef _syscall2 1127 #define _syscall2(type,name,type1,arg1,type2,arg2) \ 1128 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 1129 LSS_BODY(2, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2));\ 1130 } 1131 #undef _syscall3 1132 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \ 1133 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 1134 LSS_BODY(3, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \ 1135 LSS_SYSCALL_ARG(arg3)); \ 1136 } 1137 #undef _syscall4 1138 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 1139 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 1140 LSS_BODY(4, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \ 1141 LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4));\ 1142 } 1143 #undef _syscall5 1144 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 1145 type5,arg5) \ 1146 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1147 type5 arg5) { \ 1148 LSS_BODY(5, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \ 1149 LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4), \ 1150 LSS_SYSCALL_ARG(arg5)); \ 1151 } 1152 #undef _syscall6 1153 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 1154 type5,arg5,type6,arg6) \ 1155 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1156 type5 arg5, type6 arg6) { \ 1157 LSS_BODY(6, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \ 1158 LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4), \ 1159 LSS_SYSCALL_ARG(arg5), LSS_SYSCALL_ARG(arg6));\ 1160 } 1161 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 1162 int flags, void *arg, int *parent_tidptr, 1163 void *newtls, int *child_tidptr) { 1164 long long __res; 1165 { 1166 __asm__ __volatile__(/* if (fn == NULL) 1167 * return -EINVAL; 1168 */ 1169 "testq %4,%4\n" 1170 "jz 1f\n" 1171 1172 /* if (child_stack == NULL) 1173 * return -EINVAL; 1174 */ 1175 "testq %5,%5\n" 1176 "jz 1f\n" 1177 1178 /* Set up alignment of the child stack: 1179 * child_stack = (child_stack & ~0xF) - 16; 1180 */ 1181 "andq $-16,%5\n" 1182 "subq $16,%5\n" 1183 1184 /* Push "arg" and "fn" onto the stack that will be 1185 * used by the child. 1186 */ 1187 "movq %7,8(%5)\n" 1188 "movq %4,0(%5)\n" 1189 1190 /* %rax = syscall(%rax = __NR_clone, 1191 * %rdi = flags, 1192 * %rsi = child_stack, 1193 * %rdx = parent_tidptr, 1194 * %r8 = new_tls, 1195 * %r10 = child_tidptr) 1196 */ 1197 "movq %2,%%rax\n" 1198 "movq %9,%%r8\n" 1199 "movq %10,%%r10\n" 1200 "syscall\n" 1201 1202 /* if (%rax != 0) 1203 * return; 1204 */ 1205 "testq %%rax,%%rax\n" 1206 "jnz 1f\n" 1207 1208 /* In the child. Terminate frame pointer chain. 1209 */ 1210 "xorq %%rbp,%%rbp\n" 1211 1212 /* Call "fn(arg)". 1213 */ 1214 "popq %%rax\n" 1215 "popq %%rdi\n" 1216 "call *%%rax\n" 1217 1218 /* Call _exit(%ebx). 1219 */ 1220 "movq %%rax,%%rdi\n" 1221 "movq %3,%%rax\n" 1222 "syscall\n" 1223 1224 /* Return to parent. 1225 */ 1226 "1:\n" 1227 : "=a" (__res) 1228 : "0"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit), 1229 "r"(LSS_SYSCALL_ARG(fn)), 1230 "S"(LSS_SYSCALL_ARG(child_stack)), 1231 "D"(LSS_SYSCALL_ARG(flags)), 1232 "r"(LSS_SYSCALL_ARG(arg)), 1233 "d"(LSS_SYSCALL_ARG(parent_tidptr)), 1234 "r"(LSS_SYSCALL_ARG(newtls)), 1235 "r"(LSS_SYSCALL_ARG(child_tidptr)) 1236 : "rsp", "memory", "r8", "r10", "r11", "rcx"); 1237 } 1238 LSS_RETURN(int, __res); 1239 } 1240 1241 LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) { 1242 /* On x86-64, the kernel does not know how to return from 1243 * a signal handler. Instead, it relies on user space to provide a 1244 * restorer function that calls the rt_sigreturn() system call. 1245 * Unfortunately, we cannot just reference the glibc version of this 1246 * function, as glibc goes out of its way to make it inaccessible. 1247 */ 1248 long long res; 1249 __asm__ __volatile__("call 2f\n" 1250 "0:.align 16\n" 1251 "1:movq %1,%%rax\n" 1252 "syscall\n" 1253 "2:popq %0\n" 1254 "addq $(1b-0b),%0\n" 1255 : "=a" (res) 1256 : "i" (__NR_rt_sigreturn)); 1257 return (void (*)(void))(uintptr_t)res; 1258 } 1259 #elif defined(__arm__) 1260 /* Most definitions of _syscallX() neglect to mark "memory" as being 1261 * clobbered. This causes problems with compilers, that do a better job 1262 * at optimizing across __asm__ calls. 1263 * So, we just have to redefine all fo the _syscallX() macros. 1264 */ 1265 #undef LSS_REG 1266 #define LSS_REG(r,a) register long __r##r __asm__("r"#r) = (long)a 1267 1268 /* r0..r3 are scratch registers and not preserved across function 1269 * calls. We need to first evaluate the first 4 syscall arguments 1270 * and store them on stack. They must be loaded into r0..r3 after 1271 * all function calls to avoid r0..r3 being clobbered. 1272 */ 1273 #undef LSS_SAVE_ARG 1274 #define LSS_SAVE_ARG(r,a) long __tmp##r = (long)a 1275 #undef LSS_LOAD_ARG 1276 #define LSS_LOAD_ARG(r) register long __r##r __asm__("r"#r) = __tmp##r 1277 1278 #undef LSS_BODY 1279 #define LSS_BODY(type, name, args...) \ 1280 register long __res_r0 __asm__("r0"); \ 1281 long __res; \ 1282 __SYS_REG(name) \ 1283 __asm__ __volatile__ (__syscall_safe(name) \ 1284 : "=r"(__res_r0) \ 1285 : __SYS_REG_LIST(args) \ 1286 : "lr", "memory"); \ 1287 __res = __res_r0; \ 1288 LSS_RETURN(type, __res) 1289 #undef _syscall0 1290 #define _syscall0(type, name) \ 1291 type LSS_NAME(name)() { \ 1292 LSS_BODY(type, name); \ 1293 } 1294 #undef _syscall1 1295 #define _syscall1(type, name, type1, arg1) \ 1296 type LSS_NAME(name)(type1 arg1) { \ 1297 /* There is no need for using a volatile temp. */ \ 1298 LSS_REG(0, arg1); \ 1299 LSS_BODY(type, name, "r"(__r0)); \ 1300 } 1301 #undef _syscall2 1302 #define _syscall2(type, name, type1, arg1, type2, arg2) \ 1303 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 1304 LSS_SAVE_ARG(0, arg1); \ 1305 LSS_SAVE_ARG(1, arg2); \ 1306 LSS_LOAD_ARG(0); \ 1307 LSS_LOAD_ARG(1); \ 1308 LSS_BODY(type, name, "r"(__r0), "r"(__r1)); \ 1309 } 1310 #undef _syscall3 1311 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 1312 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 1313 LSS_SAVE_ARG(0, arg1); \ 1314 LSS_SAVE_ARG(1, arg2); \ 1315 LSS_SAVE_ARG(2, arg3); \ 1316 LSS_LOAD_ARG(0); \ 1317 LSS_LOAD_ARG(1); \ 1318 LSS_LOAD_ARG(2); \ 1319 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2)); \ 1320 } 1321 #undef _syscall4 1322 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \ 1323 type4, arg4) \ 1324 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 1325 LSS_SAVE_ARG(0, arg1); \ 1326 LSS_SAVE_ARG(1, arg2); \ 1327 LSS_SAVE_ARG(2, arg3); \ 1328 LSS_SAVE_ARG(3, arg4); \ 1329 LSS_LOAD_ARG(0); \ 1330 LSS_LOAD_ARG(1); \ 1331 LSS_LOAD_ARG(2); \ 1332 LSS_LOAD_ARG(3); \ 1333 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3)); \ 1334 } 1335 #undef _syscall5 1336 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \ 1337 type4, arg4, type5, arg5) \ 1338 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1339 type5 arg5) { \ 1340 LSS_SAVE_ARG(0, arg1); \ 1341 LSS_SAVE_ARG(1, arg2); \ 1342 LSS_SAVE_ARG(2, arg3); \ 1343 LSS_SAVE_ARG(3, arg4); \ 1344 LSS_REG(4, arg5); \ 1345 LSS_LOAD_ARG(0); \ 1346 LSS_LOAD_ARG(1); \ 1347 LSS_LOAD_ARG(2); \ 1348 LSS_LOAD_ARG(3); \ 1349 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \ 1350 "r"(__r4)); \ 1351 } 1352 #undef _syscall6 1353 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \ 1354 type4, arg4, type5, arg5, type6, arg6) \ 1355 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1356 type5 arg5, type6 arg6) { \ 1357 LSS_SAVE_ARG(0, arg1); \ 1358 LSS_SAVE_ARG(1, arg2); \ 1359 LSS_SAVE_ARG(2, arg3); \ 1360 LSS_SAVE_ARG(3, arg4); \ 1361 LSS_REG(4, arg5); \ 1362 LSS_REG(5, arg6); \ 1363 LSS_LOAD_ARG(0); \ 1364 LSS_LOAD_ARG(1); \ 1365 LSS_LOAD_ARG(2); \ 1366 LSS_LOAD_ARG(3); \ 1367 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \ 1368 "r"(__r4), "r"(__r5)); \ 1369 } 1370 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 1371 int flags, void *arg, int *parent_tidptr, 1372 void *newtls, int *child_tidptr) { 1373 register long __res __asm__("r5"); 1374 { 1375 if (fn == NULL || child_stack == NULL) { 1376 __res = -EINVAL; 1377 goto clone_exit; 1378 } 1379 1380 /* stash first 4 arguments on stack first because we can only load 1381 * them after all function calls. 1382 */ 1383 int tmp_flags = flags; 1384 int * tmp_stack = (int*) child_stack; 1385 void * tmp_ptid = parent_tidptr; 1386 void * tmp_tls = newtls; 1387 1388 register int *__ctid __asm__("r4") = child_tidptr; 1389 1390 /* Push "arg" and "fn" onto the stack that will be 1391 * used by the child. 1392 */ 1393 *(--tmp_stack) = (int) arg; 1394 *(--tmp_stack) = (int) fn; 1395 1396 /* We must load r0..r3 last after all possible function calls. */ 1397 register int __flags __asm__("r0") = tmp_flags; 1398 register void *__stack __asm__("r1") = tmp_stack; 1399 register void *__ptid __asm__("r2") = tmp_ptid; 1400 register void *__tls __asm__("r3") = tmp_tls; 1401 1402 /* %r0 = syscall(%r0 = flags, 1403 * %r1 = child_stack, 1404 * %r2 = parent_tidptr, 1405 * %r3 = newtls, 1406 * %r4 = child_tidptr) 1407 */ 1408 __SYS_REG(clone) 1409 __asm__ __volatile__(/* %r0 = syscall(%r0 = flags, 1410 * %r1 = child_stack, 1411 * %r2 = parent_tidptr, 1412 * %r3 = newtls, 1413 * %r4 = child_tidptr) 1414 */ 1415 "push {r7}\n" 1416 "mov r7,%1\n" 1417 __syscall(clone)"\n" 1418 1419 /* if (%r0 != 0) 1420 * return %r0; 1421 */ 1422 "movs %0,r0\n" 1423 "bne 1f\n" 1424 1425 /* In the child, now. Call "fn(arg)". 1426 */ 1427 "ldr r0,[sp, #4]\n" 1428 "mov lr,pc\n" 1429 "ldr pc,[sp]\n" 1430 1431 /* Call _exit(%r0), which never returns. We only 1432 * need to set r7 for EABI syscall ABI but we do 1433 * this always to simplify code sharing between 1434 * old and new syscall ABIs. 1435 */ 1436 "mov r7,%2\n" 1437 __syscall(exit)"\n" 1438 1439 /* Pop r7 from the stack only in the parent. 1440 */ 1441 "1: pop {r7}\n" 1442 : "=r" (__res) 1443 : "r"(__sysreg), 1444 "i"(__NR_exit), "r"(__stack), "r"(__flags), 1445 "r"(__ptid), "r"(__tls), "r"(__ctid) 1446 : "cc", "lr", "memory"); 1447 } 1448 clone_exit: 1449 LSS_RETURN(int, __res); 1450 } 1451 #elif defined(__mips__) 1452 #undef LSS_REG 1453 #define LSS_REG(r,a) register unsigned long __r##r __asm__("$"#r) = \ 1454 (unsigned long)(a) 1455 1456 #if _MIPS_SIM == _MIPS_SIM_ABI32 1457 // See http://sources.redhat.com/ml/libc-alpha/2004-10/msg00050.html 1458 // or http://www.linux-mips.org/archives/linux-mips/2004-10/msg00142.html 1459 #define MIPS_SYSCALL_CLOBBERS "$1", "$3", "$8", "$9", "$10", "$11", "$12",\ 1460 "$13", "$14", "$15", "$24", "$25", "memory" 1461 #else 1462 #define MIPS_SYSCALL_CLOBBERS "$1", "$3", "$10", "$11", "$12", "$13", \ 1463 "$14", "$15", "$24", "$25", "memory" 1464 #endif 1465 1466 #undef LSS_BODY 1467 #define LSS_BODY(type,name,r7,...) \ 1468 register unsigned long __v0 __asm__("$2") = __NR_##name; \ 1469 __asm__ __volatile__ ("syscall\n" \ 1470 : "=&r"(__v0), r7 (__r7) \ 1471 : "0"(__v0), ##__VA_ARGS__ \ 1472 : MIPS_SYSCALL_CLOBBERS); \ 1473 LSS_RETURN(type, __v0, __r7) 1474 #undef _syscall0 1475 #define _syscall0(type, name) \ 1476 type LSS_NAME(name)() { \ 1477 register unsigned long __r7 __asm__("$7"); \ 1478 LSS_BODY(type, name, "=r"); \ 1479 } 1480 #undef _syscall1 1481 #define _syscall1(type, name, type1, arg1) \ 1482 type LSS_NAME(name)(type1 arg1) { \ 1483 register unsigned long __r7 __asm__("$7"); \ 1484 LSS_REG(4, arg1); LSS_BODY(type, name, "=r", "r"(__r4)); \ 1485 } 1486 #undef _syscall2 1487 #define _syscall2(type, name, type1, arg1, type2, arg2) \ 1488 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 1489 register unsigned long __r7 __asm__("$7"); \ 1490 LSS_REG(4, arg1); LSS_REG(5, arg2); \ 1491 LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5)); \ 1492 } 1493 #undef _syscall3 1494 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 1495 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 1496 register unsigned long __r7 __asm__("$7"); \ 1497 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 1498 LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5), "r"(__r6)); \ 1499 } 1500 #undef _syscall4 1501 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 1502 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 1503 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 1504 LSS_REG(7, arg4); \ 1505 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6)); \ 1506 } 1507 #undef _syscall5 1508 #if _MIPS_SIM == _MIPS_SIM_ABI32 1509 /* The old 32bit MIPS system call API passes the fifth and sixth argument 1510 * on the stack, whereas the new APIs use registers "r8" and "r9". 1511 */ 1512 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 1513 type5,arg5) \ 1514 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1515 type5 arg5) { \ 1516 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 1517 LSS_REG(7, arg4); \ 1518 register unsigned long __v0 __asm__("$2"); \ 1519 __asm__ __volatile__ (".set noreorder\n" \ 1520 "lw $2, %6\n" \ 1521 "subu $29, 32\n" \ 1522 "sw $2, 16($29)\n" \ 1523 "li $2, %2\n" \ 1524 "syscall\n" \ 1525 "addiu $29, 32\n" \ 1526 ".set reorder\n" \ 1527 : "=&r"(__v0), "+r" (__r7) \ 1528 : "i" (__NR_##name), "r"(__r4), "r"(__r5), \ 1529 "r"(__r6), "m" ((unsigned long)arg5) \ 1530 : MIPS_SYSCALL_CLOBBERS); \ 1531 LSS_RETURN(type, __v0, __r7); \ 1532 } 1533 #else 1534 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 1535 type5,arg5) \ 1536 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1537 type5 arg5) { \ 1538 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 1539 LSS_REG(7, arg4); LSS_REG(8, arg5); \ 1540 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6), \ 1541 "r"(__r8)); \ 1542 } 1543 #endif 1544 #undef _syscall6 1545 #if _MIPS_SIM == _MIPS_SIM_ABI32 1546 /* The old 32bit MIPS system call API passes the fifth and sixth argument 1547 * on the stack, whereas the new APIs use registers "r8" and "r9". 1548 */ 1549 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 1550 type5,arg5,type6,arg6) \ 1551 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1552 type5 arg5, type6 arg6) { \ 1553 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 1554 LSS_REG(7, arg4); \ 1555 register unsigned long __v0 __asm__("$2"); \ 1556 __asm__ __volatile__ (".set noreorder\n" \ 1557 "lw $2, %6\n" \ 1558 "lw $8, %7\n" \ 1559 "subu $29, 32\n" \ 1560 "sw $2, 16($29)\n" \ 1561 "sw $8, 20($29)\n" \ 1562 "li $2, %2\n" \ 1563 "syscall\n" \ 1564 "addiu $29, 32\n" \ 1565 ".set reorder\n" \ 1566 : "=&r"(__v0), "+r" (__r7) \ 1567 : "i" (__NR_##name), "r"(__r4), "r"(__r5), \ 1568 "r"(__r6), "r" ((unsigned long)arg5), \ 1569 "r" ((unsigned long)arg6) \ 1570 : MIPS_SYSCALL_CLOBBERS); \ 1571 LSS_RETURN(type, __v0, __r7); \ 1572 } 1573 #else 1574 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 1575 type5,arg5,type6,arg6) \ 1576 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1577 type5 arg5,type6 arg6) { \ 1578 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 1579 LSS_REG(7, arg4); LSS_REG(8, arg5); LSS_REG(9, arg6); \ 1580 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6), \ 1581 "r"(__r8), "r"(__r9)); \ 1582 } 1583 #endif 1584 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 1585 int flags, void *arg, int *parent_tidptr, 1586 void *newtls, int *child_tidptr) { 1587 register unsigned long __v0 __asm__("$2"); 1588 register unsigned long __r7 __asm__("$7") = (unsigned long)newtls; 1589 { 1590 register int __flags __asm__("$4") = flags; 1591 register void *__stack __asm__("$5") = child_stack; 1592 register void *__ptid __asm__("$6") = parent_tidptr; 1593 register int *__ctid __asm__("$8") = child_tidptr; 1594 __asm__ __volatile__( 1595 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 1596 "subu $29,24\n" 1597 #elif _MIPS_SIM == _MIPS_SIM_NABI32 1598 "sub $29,16\n" 1599 #else 1600 "dsubu $29,16\n" 1601 #endif 1602 1603 /* if (fn == NULL || child_stack == NULL) 1604 * return -EINVAL; 1605 */ 1606 "li %0,%2\n" 1607 "beqz %5,1f\n" 1608 "beqz %6,1f\n" 1609 1610 /* Push "arg" and "fn" onto the stack that will be 1611 * used by the child. 1612 */ 1613 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 1614 "subu %6,32\n" 1615 "sw %5,0(%6)\n" 1616 "sw %8,4(%6)\n" 1617 #elif _MIPS_SIM == _MIPS_SIM_NABI32 1618 "sub %6,32\n" 1619 "sw %5,0(%6)\n" 1620 "sw %8,8(%6)\n" 1621 #else 1622 "dsubu %6,32\n" 1623 "sd %5,0(%6)\n" 1624 "sd %8,8(%6)\n" 1625 #endif 1626 1627 /* $7 = syscall($4 = flags, 1628 * $5 = child_stack, 1629 * $6 = parent_tidptr, 1630 * $7 = newtls, 1631 * $8 = child_tidptr) 1632 */ 1633 "li $2,%3\n" 1634 "syscall\n" 1635 1636 /* if ($7 != 0) 1637 * return $2; 1638 */ 1639 "bnez $7,1f\n" 1640 "bnez $2,1f\n" 1641 1642 /* In the child, now. Call "fn(arg)". 1643 */ 1644 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 1645 "lw $25,0($29)\n" 1646 "lw $4,4($29)\n" 1647 #elif _MIPS_SIM == _MIPS_SIM_NABI32 1648 "lw $25,0($29)\n" 1649 "lw $4,8($29)\n" 1650 #else 1651 "ld $25,0($29)\n" 1652 "ld $4,8($29)\n" 1653 #endif 1654 "jalr $25\n" 1655 1656 /* Call _exit($2) 1657 */ 1658 "move $4,$2\n" 1659 "li $2,%4\n" 1660 "syscall\n" 1661 1662 "1:\n" 1663 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 1664 "addu $29, 24\n" 1665 #elif _MIPS_SIM == _MIPS_SIM_NABI32 1666 "add $29, 16\n" 1667 #else 1668 "daddu $29,16\n" 1669 #endif 1670 : "=&r" (__v0), "=r" (__r7) 1671 : "i"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit), 1672 "r"(fn), "r"(__stack), "r"(__flags), "r"(arg), 1673 "r"(__ptid), "r"(__r7), "r"(__ctid) 1674 : "$9", "$10", "$11", "$12", "$13", "$14", "$15", 1675 "$24", "memory"); 1676 } 1677 LSS_RETURN(int, __v0, __r7); 1678 } 1679 #elif defined (__PPC__) 1680 #undef LSS_LOADARGS_0 1681 #define LSS_LOADARGS_0(name, dummy...) \ 1682 __sc_0 = __NR_##name 1683 #undef LSS_LOADARGS_1 1684 #define LSS_LOADARGS_1(name, arg1) \ 1685 LSS_LOADARGS_0(name); \ 1686 __sc_3 = (unsigned long) (arg1) 1687 #undef LSS_LOADARGS_2 1688 #define LSS_LOADARGS_2(name, arg1, arg2) \ 1689 LSS_LOADARGS_1(name, arg1); \ 1690 __sc_4 = (unsigned long) (arg2) 1691 #undef LSS_LOADARGS_3 1692 #define LSS_LOADARGS_3(name, arg1, arg2, arg3) \ 1693 LSS_LOADARGS_2(name, arg1, arg2); \ 1694 __sc_5 = (unsigned long) (arg3) 1695 #undef LSS_LOADARGS_4 1696 #define LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4) \ 1697 LSS_LOADARGS_3(name, arg1, arg2, arg3); \ 1698 __sc_6 = (unsigned long) (arg4) 1699 #undef LSS_LOADARGS_5 1700 #define LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5) \ 1701 LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4); \ 1702 __sc_7 = (unsigned long) (arg5) 1703 #undef LSS_LOADARGS_6 1704 #define LSS_LOADARGS_6(name, arg1, arg2, arg3, arg4, arg5, arg6) \ 1705 LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5); \ 1706 __sc_8 = (unsigned long) (arg6) 1707 #undef LSS_ASMINPUT_0 1708 #define LSS_ASMINPUT_0 "0" (__sc_0) 1709 #undef LSS_ASMINPUT_1 1710 #define LSS_ASMINPUT_1 LSS_ASMINPUT_0, "1" (__sc_3) 1711 #undef LSS_ASMINPUT_2 1712 #define LSS_ASMINPUT_2 LSS_ASMINPUT_1, "2" (__sc_4) 1713 #undef LSS_ASMINPUT_3 1714 #define LSS_ASMINPUT_3 LSS_ASMINPUT_2, "3" (__sc_5) 1715 #undef LSS_ASMINPUT_4 1716 #define LSS_ASMINPUT_4 LSS_ASMINPUT_3, "4" (__sc_6) 1717 #undef LSS_ASMINPUT_5 1718 #define LSS_ASMINPUT_5 LSS_ASMINPUT_4, "5" (__sc_7) 1719 #undef LSS_ASMINPUT_6 1720 #define LSS_ASMINPUT_6 LSS_ASMINPUT_5, "6" (__sc_8) 1721 #undef LSS_BODY 1722 #define LSS_BODY(nr, type, name, args...) \ 1723 long __sc_ret, __sc_err; \ 1724 { \ 1725 register unsigned long __sc_0 __asm__ ("r0"); \ 1726 register unsigned long __sc_3 __asm__ ("r3"); \ 1727 register unsigned long __sc_4 __asm__ ("r4"); \ 1728 register unsigned long __sc_5 __asm__ ("r5"); \ 1729 register unsigned long __sc_6 __asm__ ("r6"); \ 1730 register unsigned long __sc_7 __asm__ ("r7"); \ 1731 register unsigned long __sc_8 __asm__ ("r8"); \ 1732 \ 1733 LSS_LOADARGS_##nr(name, args); \ 1734 __asm__ __volatile__ \ 1735 ("sc\n\t" \ 1736 "mfcr %0" \ 1737 : "=&r" (__sc_0), \ 1738 "=&r" (__sc_3), "=&r" (__sc_4), \ 1739 "=&r" (__sc_5), "=&r" (__sc_6), \ 1740 "=&r" (__sc_7), "=&r" (__sc_8) \ 1741 : LSS_ASMINPUT_##nr \ 1742 : "cr0", "ctr", "memory", \ 1743 "r9", "r10", "r11", "r12"); \ 1744 __sc_ret = __sc_3; \ 1745 __sc_err = __sc_0; \ 1746 } \ 1747 LSS_RETURN(type, __sc_ret, __sc_err) 1748 #undef _syscall0 1749 #define _syscall0(type, name) \ 1750 type LSS_NAME(name)(void) { \ 1751 LSS_BODY(0, type, name); \ 1752 } 1753 #undef _syscall1 1754 #define _syscall1(type, name, type1, arg1) \ 1755 type LSS_NAME(name)(type1 arg1) { \ 1756 LSS_BODY(1, type, name, arg1); \ 1757 } 1758 #undef _syscall2 1759 #define _syscall2(type, name, type1, arg1, type2, arg2) \ 1760 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 1761 LSS_BODY(2, type, name, arg1, arg2); \ 1762 } 1763 #undef _syscall3 1764 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 1765 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 1766 LSS_BODY(3, type, name, arg1, arg2, arg3); \ 1767 } 1768 #undef _syscall4 1769 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \ 1770 type4, arg4) \ 1771 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 1772 LSS_BODY(4, type, name, arg1, arg2, arg3, arg4); \ 1773 } 1774 #undef _syscall5 1775 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \ 1776 type4, arg4, type5, arg5) \ 1777 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1778 type5 arg5) { \ 1779 LSS_BODY(5, type, name, arg1, arg2, arg3, arg4, arg5); \ 1780 } 1781 #undef _syscall6 1782 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \ 1783 type4, arg4, type5, arg5, type6, arg6) \ 1784 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1785 type5 arg5, type6 arg6) { \ 1786 LSS_BODY(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6); \ 1787 } 1788 /* clone function adapted from glibc 2.3.6 clone.S */ 1789 /* TODO(csilvers): consider wrapping some args up in a struct, like we 1790 * do for i386's _syscall6, so we can compile successfully on gcc 2.95 1791 */ 1792 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 1793 int flags, void *arg, int *parent_tidptr, 1794 void *newtls, int *child_tidptr) { 1795 long __ret, __err; 1796 { 1797 register int (*__fn)(void *) __asm__ ("r8") = fn; 1798 register void *__cstack __asm__ ("r4") = child_stack; 1799 register int __flags __asm__ ("r3") = flags; 1800 register void * __arg __asm__ ("r9") = arg; 1801 register int * __ptidptr __asm__ ("r5") = parent_tidptr; 1802 register void * __newtls __asm__ ("r6") = newtls; 1803 register int * __ctidptr __asm__ ("r7") = child_tidptr; 1804 __asm__ __volatile__( 1805 /* check for fn == NULL 1806 * and child_stack == NULL 1807 */ 1808 "cmpwi cr0, %6, 0\n\t" 1809 "cmpwi cr1, %7, 0\n\t" 1810 "cror cr0*4+eq, cr1*4+eq, cr0*4+eq\n\t" 1811 "beq- cr0, 1f\n\t" 1812 1813 /* set up stack frame for child */ 1814 "clrrwi %7, %7, 4\n\t" 1815 "li 0, 0\n\t" 1816 "stwu 0, -16(%7)\n\t" 1817 1818 /* fn, arg, child_stack are saved across the syscall: r28-30 */ 1819 "mr 28, %6\n\t" 1820 "mr 29, %7\n\t" 1821 "mr 27, %9\n\t" 1822 1823 /* syscall */ 1824 "li 0, %4\n\t" 1825 /* flags already in r3 1826 * child_stack already in r4 1827 * ptidptr already in r5 1828 * newtls already in r6 1829 * ctidptr already in r7 1830 */ 1831 "sc\n\t" 1832 1833 /* Test if syscall was successful */ 1834 "cmpwi cr1, 3, 0\n\t" 1835 "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t" 1836 "bne- cr1, 1f\n\t" 1837 1838 /* Do the function call */ 1839 "mtctr 28\n\t" 1840 "mr 3, 27\n\t" 1841 "bctrl\n\t" 1842 1843 /* Call _exit(r3) */ 1844 "li 0, %5\n\t" 1845 "sc\n\t" 1846 1847 /* Return to parent */ 1848 "1:\n" 1849 "mfcr %1\n\t" 1850 "mr %0, 3\n\t" 1851 : "=r" (__ret), "=r" (__err) 1852 : "0" (-1), "1" (EINVAL), 1853 "i" (__NR_clone), "i" (__NR_exit), 1854 "r" (__fn), "r" (__cstack), "r" (__flags), 1855 "r" (__arg), "r" (__ptidptr), "r" (__newtls), 1856 "r" (__ctidptr) 1857 : "cr0", "cr1", "memory", "ctr", 1858 "r0", "r29", "r27", "r28"); 1859 } 1860 LSS_RETURN(int, __ret, __err); 1861 } 1862 #endif 1863 #define __NR__exit __NR_exit 1864 #define __NR__gettid __NR_gettid 1865 #define __NR__mremap __NR_mremap 1866 LSS_INLINE _syscall1(int, close, int, f) 1867 LSS_INLINE _syscall1(int, _exit, int, e) 1868 LSS_INLINE _syscall3(int, fcntl, int, f, 1869 int, c, long, a) 1870 LSS_INLINE _syscall2(int, fstat, int, f, 1871 struct kernel_stat*, b) 1872 LSS_INLINE _syscall4(int, futex, int*, a, 1873 int, o, int, v, 1874 struct kernel_timespec*, t) 1875 LSS_INLINE _syscall3(int, getdents, int, f, 1876 struct kernel_dirent*, d, int, c) 1877 #ifdef __NR_getdents64 1878 LSS_INLINE _syscall3(int, getdents64, int, f, 1879 struct kernel_dirent64*, d, int, c) 1880 #endif 1881 LSS_INLINE _syscall0(pid_t, getpid) 1882 LSS_INLINE _syscall0(pid_t, getppid) 1883 LSS_INLINE _syscall0(pid_t, _gettid) 1884 LSS_INLINE _syscall2(int, kill, pid_t, p, 1885 int, s) 1886 #if defined(__x86_64__) 1887 /* Need to make sure off_t isn't truncated to 32-bits under x32. */ 1888 LSS_INLINE off_t LSS_NAME(lseek)(int f, off_t o, int w) { 1889 _LSS_BODY(3, off_t, lseek, off_t, LSS_SYSCALL_ARG(f), (uint64_t)(o), 1890 LSS_SYSCALL_ARG(w)); 1891 } 1892 #else 1893 LSS_INLINE _syscall3(off_t, lseek, int, f, 1894 off_t, o, int, w) 1895 #endif 1896 LSS_INLINE _syscall2(int, munmap, void*, s, 1897 size_t, l) 1898 LSS_INLINE _syscall5(void*, _mremap, void*, o, 1899 size_t, os, size_t, ns, 1900 unsigned long, f, void *, a) 1901 LSS_INLINE _syscall3(int, open, const char*, p, 1902 int, f, int, m) 1903 LSS_INLINE _syscall2(int, prctl, int, o, 1904 long, a) 1905 LSS_INLINE _syscall4(long, ptrace, int, r, 1906 pid_t, p, void *, a, void *, d) 1907 LSS_INLINE _syscall3(ssize_t, read, int, f, 1908 void *, b, size_t, c) 1909 LSS_INLINE _syscall4(int, rt_sigaction, int, s, 1910 const struct kernel_sigaction*, a, 1911 struct kernel_sigaction*, o, size_t, c) 1912 LSS_INLINE _syscall4(int, rt_sigprocmask, int, h, 1913 const struct kernel_sigset_t*, s, 1914 struct kernel_sigset_t*, o, size_t, c); 1915 LSS_INLINE _syscall0(int, sched_yield) 1916 LSS_INLINE _syscall2(int, sigaltstack, const stack_t*, s, 1917 const stack_t*, o) 1918 LSS_INLINE _syscall2(int, stat, const char*, f, 1919 struct kernel_stat*, b) 1920 LSS_INLINE _syscall3(ssize_t, write, int, f, 1921 const void *, b, size_t, c) 1922 #if defined(__NR_getcpu) 1923 LSS_INLINE _syscall3(long, getcpu, unsigned *, cpu, 1924 unsigned *, node, void *, unused); 1925 #endif 1926 #if defined(__x86_64__) || \ 1927 (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32) 1928 LSS_INLINE _syscall3(int, socket, int, d, 1929 int, t, int, p) 1930 #endif 1931 #if defined(__x86_64__) 1932 /* Need to make sure __off64_t isn't truncated to 32-bits under x32. */ 1933 LSS_INLINE void* LSS_NAME(mmap)(void *s, size_t l, int p, int f, int d, 1934 __off64_t o) { 1935 LSS_BODY(6, void*, mmap, LSS_SYSCALL_ARG(s), LSS_SYSCALL_ARG(l), 1936 LSS_SYSCALL_ARG(p), LSS_SYSCALL_ARG(f), 1937 LSS_SYSCALL_ARG(d), (uint64_t)(o)); 1938 } 1939 1940 LSS_INLINE int LSS_NAME(sigaction)(int signum, 1941 const struct kernel_sigaction *act, 1942 struct kernel_sigaction *oldact) { 1943 /* On x86_64, the kernel requires us to always set our own 1944 * SA_RESTORER in order to be able to return from a signal handler. 1945 * This function must have a "magic" signature that the "gdb" 1946 * (and maybe the kernel?) can recognize. 1947 */ 1948 if (act != NULL && !(act->sa_flags & SA_RESTORER)) { 1949 struct kernel_sigaction a = *act; 1950 a.sa_flags |= SA_RESTORER; 1951 a.sa_restorer = LSS_NAME(restore_rt)(); 1952 return LSS_NAME(rt_sigaction)(signum, &a, oldact, 1953 (KERNEL_NSIG+7)/8); 1954 } else { 1955 return LSS_NAME(rt_sigaction)(signum, act, oldact, 1956 (KERNEL_NSIG+7)/8); 1957 } 1958 } 1959 1960 LSS_INLINE int LSS_NAME(sigprocmask)(int how, 1961 const struct kernel_sigset_t *set, 1962 struct kernel_sigset_t *oldset) { 1963 return LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8); 1964 } 1965 #endif 1966 #if defined(__x86_64__) || \ 1967 defined(__arm__) || \ 1968 (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32) 1969 LSS_INLINE _syscall4(pid_t, wait4, pid_t, p, 1970 int*, s, int, o, 1971 struct kernel_rusage*, r) 1972 LSS_INLINE pid_t LSS_NAME(waitpid)(pid_t pid, int *status, int options){ 1973 return LSS_NAME(wait4)(pid, status, options, 0); 1974 } 1975 #endif 1976 #if (defined(__i386__) || defined(__x86_64__) || defined(__arm__)) && \ 1977 !defined(__ANDROID__) 1978 LSS_INLINE _syscall4(int, openat, int, d, const char *, p, int, f, int, m) 1979 #endif 1980 LSS_INLINE int LSS_NAME(sigemptyset)(struct kernel_sigset_t *set) { 1981 memset(&set->sig, 0, sizeof(set->sig)); 1982 return 0; 1983 } 1984 1985 LSS_INLINE int LSS_NAME(sigfillset)(struct kernel_sigset_t *set) { 1986 memset(&set->sig, -1, sizeof(set->sig)); 1987 return 0; 1988 } 1989 1990 LSS_INLINE int LSS_NAME(sigaddset)(struct kernel_sigset_t *set, 1991 int signum) { 1992 if (signum < 1 || signum > (int)(8*sizeof(set->sig))) { 1993 LSS_ERRNO = EINVAL; 1994 return -1; 1995 } else { 1996 set->sig[(signum - 1)/(8*sizeof(set->sig[0]))] 1997 |= 1UL << ((signum - 1) % (8*sizeof(set->sig[0]))); 1998 return 0; 1999 } 2000 } 2001 2002 LSS_INLINE int LSS_NAME(sigdelset)(struct kernel_sigset_t *set, 2003 int signum) { 2004 if (signum < 1 || signum > (int)(8*sizeof(set->sig))) { 2005 LSS_ERRNO = EINVAL; 2006 return -1; 2007 } else { 2008 set->sig[(signum - 1)/(8*sizeof(set->sig[0]))] 2009 &= ~(1UL << ((signum - 1) % (8*sizeof(set->sig[0])))); 2010 return 0; 2011 } 2012 } 2013 2014 #if defined(__i386__) || \ 2015 defined(__arm__) || \ 2016 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || defined(__PPC__) 2017 #define __NR__sigaction __NR_sigaction 2018 #define __NR__sigprocmask __NR_sigprocmask 2019 LSS_INLINE _syscall2(int, fstat64, int, f, 2020 struct kernel_stat64 *, b) 2021 LSS_INLINE _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo, 2022 loff_t *, res, uint, wh) 2023 #ifdef __PPC64__ 2024 LSS_INLINE _syscall6(void*, mmap, void*, s, 2025 size_t, l, int, p, 2026 int, f, int, d, 2027 off_t, o) 2028 #else 2029 #ifndef __ARM_EABI__ 2030 /* Not available on ARM EABI Linux. */ 2031 LSS_INLINE _syscall1(void*, mmap, void*, a) 2032 #endif 2033 LSS_INLINE _syscall6(void*, mmap2, void*, s, 2034 size_t, l, int, p, 2035 int, f, int, d, 2036 off_t, o) 2037 #endif 2038 LSS_INLINE _syscall3(int, _sigaction, int, s, 2039 const struct kernel_old_sigaction*, a, 2040 struct kernel_old_sigaction*, o) 2041 LSS_INLINE _syscall3(int, _sigprocmask, int, h, 2042 const unsigned long*, s, 2043 unsigned long*, o) 2044 LSS_INLINE _syscall2(int, stat64, const char *, p, 2045 struct kernel_stat64 *, b) 2046 2047 LSS_INLINE int LSS_NAME(sigaction)(int signum, 2048 const struct kernel_sigaction *act, 2049 struct kernel_sigaction *oldact) { 2050 int old_errno = LSS_ERRNO; 2051 int rc; 2052 struct kernel_sigaction a; 2053 if (act != NULL) { 2054 a = *act; 2055 #ifdef __i386__ 2056 /* On i386, the kernel requires us to always set our own 2057 * SA_RESTORER when using realtime signals. Otherwise, it does not 2058 * know how to return from a signal handler. This function must have 2059 * a "magic" signature that the "gdb" (and maybe the kernel?) can 2060 * recognize. 2061 * Apparently, a SA_RESTORER is implicitly set by the kernel, when 2062 * using non-realtime signals. 2063 * 2064 * TODO: Test whether ARM needs a restorer 2065 */ 2066 if (!(a.sa_flags & SA_RESTORER)) { 2067 a.sa_flags |= SA_RESTORER; 2068 a.sa_restorer = (a.sa_flags & SA_SIGINFO) 2069 ? LSS_NAME(restore_rt)() : LSS_NAME(restore)(); 2070 } 2071 #endif 2072 } 2073 rc = LSS_NAME(rt_sigaction)(signum, act ? &a : act, oldact, 2074 (KERNEL_NSIG+7)/8); 2075 if (rc < 0 && LSS_ERRNO == ENOSYS) { 2076 struct kernel_old_sigaction oa, ooa, *ptr_a = &oa, *ptr_oa = &ooa; 2077 if (!act) { 2078 ptr_a = NULL; 2079 } else { 2080 oa.sa_handler_ = act->sa_handler_; 2081 memcpy(&oa.sa_mask, &act->sa_mask, sizeof(oa.sa_mask)); 2082 #ifndef __mips__ 2083 oa.sa_restorer = act->sa_restorer; 2084 #endif 2085 oa.sa_flags = act->sa_flags; 2086 } 2087 if (!oldact) { 2088 ptr_oa = NULL; 2089 } 2090 LSS_ERRNO = old_errno; 2091 rc = LSS_NAME(_sigaction)(signum, ptr_a, ptr_oa); 2092 if (rc == 0 && oldact) { 2093 if (act) { 2094 memcpy(oldact, act, sizeof(*act)); 2095 } else { 2096 memset(oldact, 0, sizeof(*oldact)); 2097 } 2098 oldact->sa_handler_ = ptr_oa->sa_handler_; 2099 oldact->sa_flags = ptr_oa->sa_flags; 2100 memcpy(&oldact->sa_mask, &ptr_oa->sa_mask, sizeof(ptr_oa->sa_mask)); 2101 #ifndef __mips__ 2102 oldact->sa_restorer = ptr_oa->sa_restorer; 2103 #endif 2104 } 2105 } 2106 return rc; 2107 } 2108 2109 LSS_INLINE int LSS_NAME(sigprocmask)(int how, 2110 const struct kernel_sigset_t *set, 2111 struct kernel_sigset_t *oldset) { 2112 int olderrno = LSS_ERRNO; 2113 int rc = LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8); 2114 if (rc < 0 && LSS_ERRNO == ENOSYS) { 2115 LSS_ERRNO = olderrno; 2116 if (oldset) { 2117 LSS_NAME(sigemptyset)(oldset); 2118 } 2119 rc = LSS_NAME(_sigprocmask)(how, 2120 set ? &set->sig[0] : NULL, 2121 oldset ? &oldset->sig[0] : NULL); 2122 } 2123 return rc; 2124 } 2125 #endif 2126 #if defined(__PPC__) 2127 #undef LSS_SC_LOADARGS_0 2128 #define LSS_SC_LOADARGS_0(dummy...) 2129 #undef LSS_SC_LOADARGS_1 2130 #define LSS_SC_LOADARGS_1(arg1) \ 2131 __sc_4 = (unsigned long) (arg1) 2132 #undef LSS_SC_LOADARGS_2 2133 #define LSS_SC_LOADARGS_2(arg1, arg2) \ 2134 LSS_SC_LOADARGS_1(arg1); \ 2135 __sc_5 = (unsigned long) (arg2) 2136 #undef LSS_SC_LOADARGS_3 2137 #define LSS_SC_LOADARGS_3(arg1, arg2, arg3) \ 2138 LSS_SC_LOADARGS_2(arg1, arg2); \ 2139 __sc_6 = (unsigned long) (arg3) 2140 #undef LSS_SC_LOADARGS_4 2141 #define LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4) \ 2142 LSS_SC_LOADARGS_3(arg1, arg2, arg3); \ 2143 __sc_7 = (unsigned long) (arg4) 2144 #undef LSS_SC_LOADARGS_5 2145 #define LSS_SC_LOADARGS_5(arg1, arg2, arg3, arg4, arg5) \ 2146 LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4); \ 2147 __sc_8 = (unsigned long) (arg5) 2148 #undef LSS_SC_BODY 2149 #define LSS_SC_BODY(nr, type, opt, args...) \ 2150 long __sc_ret, __sc_err; \ 2151 { \ 2152 register unsigned long __sc_0 __asm__ ("r0") = __NR_socketcall; \ 2153 register unsigned long __sc_3 __asm__ ("r3") = opt; \ 2154 register unsigned long __sc_4 __asm__ ("r4"); \ 2155 register unsigned long __sc_5 __asm__ ("r5"); \ 2156 register unsigned long __sc_6 __asm__ ("r6"); \ 2157 register unsigned long __sc_7 __asm__ ("r7"); \ 2158 register unsigned long __sc_8 __asm__ ("r8"); \ 2159 LSS_SC_LOADARGS_##nr(args); \ 2160 __asm__ __volatile__ \ 2161 ("stwu 1, -48(1)\n\t" \ 2162 "stw 4, 20(1)\n\t" \ 2163 "stw 5, 24(1)\n\t" \ 2164 "stw 6, 28(1)\n\t" \ 2165 "stw 7, 32(1)\n\t" \ 2166 "stw 8, 36(1)\n\t" \ 2167 "addi 4, 1, 20\n\t" \ 2168 "sc\n\t" \ 2169 "mfcr %0" \ 2170 : "=&r" (__sc_0), \ 2171 "=&r" (__sc_3), "=&r" (__sc_4), \ 2172 "=&r" (__sc_5), "=&r" (__sc_6), \ 2173 "=&r" (__sc_7), "=&r" (__sc_8) \ 2174 : LSS_ASMINPUT_##nr \ 2175 : "cr0", "ctr", "memory"); \ 2176 __sc_ret = __sc_3; \ 2177 __sc_err = __sc_0; \ 2178 } \ 2179 LSS_RETURN(type, __sc_ret, __sc_err) 2180 2181 LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) { 2182 LSS_SC_BODY(3, int, 1, domain, type, protocol); 2183 } 2184 #endif 2185 #if defined(__i386__) || \ 2186 (defined(__arm__) && !defined(__ARM_EABI__)) || \ 2187 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 2188 2189 /* See sys_socketcall in net/socket.c in kernel source. 2190 * It de-multiplexes on its first arg and unpacks the arglist 2191 * array in its second arg. 2192 */ 2193 LSS_INLINE _syscall2(long, socketcall, int, c, unsigned long*, a) 2194 2195 LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) { 2196 unsigned long args[3] = { 2197 (unsigned long) domain, 2198 (unsigned long) type, 2199 (unsigned long) protocol 2200 }; 2201 return LSS_NAME(socketcall)(1, args); 2202 } 2203 #elif defined(__ARM_EABI__) 2204 LSS_INLINE _syscall3(int, socket, int, d, 2205 int, t, int, p) 2206 #endif 2207 #if defined(__i386__) || defined(__PPC__) || \ 2208 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 2209 LSS_INLINE _syscall3(pid_t, waitpid, pid_t, p, 2210 int*, s, int, o) 2211 #endif 2212 #if defined(__mips__) 2213 /* sys_pipe() on MIPS has non-standard calling conventions, as it returns 2214 * both file handles through CPU registers. 2215 */ 2216 LSS_INLINE int LSS_NAME(pipe)(int *p) { 2217 register unsigned long __v0 __asm__("$2") = __NR_pipe; 2218 register unsigned long __v1 __asm__("$3"); 2219 register unsigned long __r7 __asm__("$7"); 2220 __asm__ __volatile__ ("syscall\n" 2221 : "=&r"(__v0), "=&r"(__v1), "+r" (__r7) 2222 : "0"(__v0) 2223 : "$8", "$9", "$10", "$11", "$12", 2224 "$13", "$14", "$15", "$24", "memory"); 2225 if (__r7) { 2226 LSS_ERRNO = __v0; 2227 return -1; 2228 } else { 2229 p[0] = __v0; 2230 p[1] = __v1; 2231 return 0; 2232 } 2233 } 2234 #else 2235 LSS_INLINE _syscall1(int, pipe, int *, p) 2236 #endif 2237 2238 LSS_INLINE pid_t LSS_NAME(gettid)() { 2239 pid_t tid = LSS_NAME(_gettid)(); 2240 if (tid != -1) { 2241 return tid; 2242 } 2243 return LSS_NAME(getpid)(); 2244 } 2245 2246 LSS_INLINE void *LSS_NAME(mremap)(void *old_address, size_t old_size, 2247 size_t new_size, int flags, ...) { 2248 va_list ap; 2249 void *new_address, *rc; 2250 va_start(ap, flags); 2251 new_address = va_arg(ap, void *); 2252 rc = LSS_NAME(_mremap)(old_address, old_size, new_size, 2253 flags, new_address); 2254 va_end(ap); 2255 return rc; 2256 } 2257 2258 LSS_INLINE int LSS_NAME(ptrace_detach)(pid_t pid) { 2259 /* PTRACE_DETACH can sometimes forget to wake up the tracee and it 2260 * then sends job control signals to the real parent, rather than to 2261 * the tracer. We reduce the risk of this happening by starting a 2262 * whole new time slice, and then quickly sending a SIGCONT signal 2263 * right after detaching from the tracee. 2264 */ 2265 int rc, err; 2266 LSS_NAME(sched_yield)(); 2267 rc = LSS_NAME(ptrace)(PTRACE_DETACH, pid, (void *)0, (void *)0); 2268 err = LSS_ERRNO; 2269 LSS_NAME(kill)(pid, SIGCONT); 2270 LSS_ERRNO = err; 2271 return rc; 2272 } 2273 #endif 2274 2275 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS) 2276 } 2277 #endif 2278 2279 #endif 2280 #endif 2281
