1 /* Copyright (c) 2005-2011, 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 * SYS_SYSCALL_ENTRYPOINT: 70 * Some applications (such as sandboxes that filter system calls), need 71 * to be able to run custom-code each time a system call is made. If this 72 * macro is defined, it expands to the name of a "common" symbol. If 73 * this symbol is assigned a non-NULL pointer value, it is used as the 74 * address of the system call entrypoint. 75 * A pointer to this symbol can be obtained by calling 76 * get_syscall_entrypoint() 77 * 78 * This file defines a few internal symbols that all start with "LSS_". 79 * Do not access these symbols from outside this file. They are not part 80 * of the supported API. 81 */ 82 #ifndef SYS_LINUX_SYSCALL_SUPPORT_H 83 #define SYS_LINUX_SYSCALL_SUPPORT_H 84 85 /* We currently only support x86-32, x86-64, ARM, MIPS, and PPC on Linux. 86 * Porting to other related platforms should not be difficult. 87 */ 88 #if (defined(__i386__) || defined(__x86_64__) || defined(__ARM_ARCH_3__) || \ 89 defined(__mips__) || defined(__PPC__) || defined(__ARM_EABI__) || \ 90 defined(__aarch64__)) \ 91 && (defined(__linux) || defined(__ANDROID__)) 92 93 #ifndef SYS_CPLUSPLUS 94 #ifdef __cplusplus 95 /* Some system header files in older versions of gcc neglect to properly 96 * handle being included from C++. As it appears to be harmless to have 97 * multiple nested 'extern "C"' blocks, just add another one here. 98 */ 99 extern "C" { 100 #endif 101 102 #include <errno.h> 103 #include <fcntl.h> 104 #include <sched.h> 105 #include <signal.h> 106 #include <stdarg.h> 107 #include <stddef.h> 108 #include <stdint.h> 109 #include <string.h> 110 #include <sys/ptrace.h> 111 #include <sys/resource.h> 112 #include <sys/time.h> 113 #include <sys/types.h> 114 #include <sys/syscall.h> 115 #include <unistd.h> 116 #include <linux/unistd.h> 117 #include <endian.h> 118 119 #ifdef __mips__ 120 /* Include definitions of the ABI currently in use. */ 121 #include <sgidefs.h> 122 #endif 123 #endif 124 125 /* The Android NDK's <sys/stat.h> #defines these macros as aliases 126 * to their non-64 counterparts. To avoid naming conflict, remove them. */ 127 #ifdef __ANDROID__ 128 /* These are restored by the corresponding #pragma pop_macro near 129 * the end of this file. */ 130 # pragma push_macro("stat64") 131 # pragma push_macro("fstat64") 132 # pragma push_macro("lstat64") 133 # undef stat64 134 # undef fstat64 135 # undef lstat64 136 #endif 137 138 /* As glibc often provides subtly incompatible data structures (and implicit 139 * wrapper functions that convert them), we provide our own kernel data 140 * structures for use by the system calls. 141 * These structures have been developed by using Linux 2.6.23 headers for 142 * reference. Note though, we do not care about exact API compatibility 143 * with the kernel, and in fact the kernel often does not have a single 144 * API that works across architectures. Instead, we try to mimic the glibc 145 * API where reasonable, and only guarantee ABI compatibility with the 146 * kernel headers. 147 * Most notably, here are a few changes that were made to the structures 148 * defined by kernel headers: 149 * 150 * - we only define structures, but not symbolic names for kernel data 151 * types. For the latter, we directly use the native C datatype 152 * (i.e. "unsigned" instead of "mode_t"). 153 * - in a few cases, it is possible to define identical structures for 154 * both 32bit (e.g. i386) and 64bit (e.g. x86-64) platforms by 155 * standardizing on the 64bit version of the data types. In particular, 156 * this means that we use "unsigned" where the 32bit headers say 157 * "unsigned long". 158 * - overall, we try to minimize the number of cases where we need to 159 * conditionally define different structures. 160 * - the "struct kernel_sigaction" class of structures have been 161 * modified to more closely mimic glibc's API by introducing an 162 * anonymous union for the function pointer. 163 * - a small number of field names had to have an underscore appended to 164 * them, because glibc defines a global macro by the same name. 165 */ 166 167 /* include/linux/dirent.h */ 168 struct kernel_dirent64 { 169 unsigned long long d_ino; 170 long long d_off; 171 unsigned short d_reclen; 172 unsigned char d_type; 173 char d_name[256]; 174 }; 175 176 /* include/linux/dirent.h */ 177 #if defined(__aarch64__) 178 // aarch64 only defines dirent64, just uses that for dirent too. 179 #define kernel_dirent kernel_dirent64 180 #else 181 struct kernel_dirent { 182 long d_ino; 183 long d_off; 184 unsigned short d_reclen; 185 char d_name[256]; 186 }; 187 #endif 188 189 /* include/linux/uio.h */ 190 struct kernel_iovec { 191 void *iov_base; 192 unsigned long iov_len; 193 }; 194 195 /* include/linux/socket.h */ 196 struct kernel_msghdr { 197 void *msg_name; 198 int msg_namelen; 199 struct kernel_iovec*msg_iov; 200 unsigned long msg_iovlen; 201 void *msg_control; 202 unsigned long msg_controllen; 203 unsigned msg_flags; 204 }; 205 206 /* include/asm-generic/poll.h */ 207 struct kernel_pollfd { 208 int fd; 209 short events; 210 short revents; 211 }; 212 213 /* include/linux/resource.h */ 214 struct kernel_rlimit { 215 unsigned long rlim_cur; 216 unsigned long rlim_max; 217 }; 218 219 /* include/linux/time.h */ 220 struct kernel_timespec { 221 long tv_sec; 222 long tv_nsec; 223 }; 224 225 /* include/linux/time.h */ 226 struct kernel_timeval { 227 long tv_sec; 228 long tv_usec; 229 }; 230 231 /* include/linux/resource.h */ 232 struct kernel_rusage { 233 struct kernel_timeval ru_utime; 234 struct kernel_timeval ru_stime; 235 long ru_maxrss; 236 long ru_ixrss; 237 long ru_idrss; 238 long ru_isrss; 239 long ru_minflt; 240 long ru_majflt; 241 long ru_nswap; 242 long ru_inblock; 243 long ru_oublock; 244 long ru_msgsnd; 245 long ru_msgrcv; 246 long ru_nsignals; 247 long ru_nvcsw; 248 long ru_nivcsw; 249 }; 250 251 #if defined(__i386__) || defined(__ARM_EABI__) || defined(__ARM_ARCH_3__) \ 252 || defined(__PPC__) 253 254 /* include/asm-{arm,i386,mips,ppc}/signal.h */ 255 struct kernel_old_sigaction { 256 union { 257 void (*sa_handler_)(int); 258 void (*sa_sigaction_)(int, siginfo_t *, void *); 259 }; 260 unsigned long sa_mask; 261 unsigned long sa_flags; 262 void (*sa_restorer)(void); 263 } __attribute__((packed,aligned(4))); 264 #elif (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 265 #define kernel_old_sigaction kernel_sigaction 266 #elif defined(__aarch64__) 267 // No kernel_old_sigaction defined for arm64. 268 #endif 269 270 /* Some kernel functions (e.g. sigaction() in 2.6.23) require that the 271 * exactly match the size of the signal set, even though the API was 272 * intended to be extensible. We define our own KERNEL_NSIG to deal with 273 * this. 274 * Please note that glibc provides signals [1.._NSIG-1], whereas the 275 * kernel (and this header) provides the range [1..KERNEL_NSIG]. The 276 * actual number of signals is obviously the same, but the constants 277 * differ by one. 278 */ 279 #ifdef __mips__ 280 #define KERNEL_NSIG 128 281 #else 282 #define KERNEL_NSIG 64 283 #endif 284 285 /* include/asm-{arm,aarch64,i386,mips,x86_64}/signal.h */ 286 struct kernel_sigset_t { 287 unsigned long sig[(KERNEL_NSIG + 8*sizeof(unsigned long) - 1)/ 288 (8*sizeof(unsigned long))]; 289 }; 290 291 /* include/asm-{arm,i386,mips,x86_64,ppc}/signal.h */ 292 struct kernel_sigaction { 293 #ifdef __mips__ 294 unsigned long sa_flags; 295 union { 296 void (*sa_handler_)(int); 297 void (*sa_sigaction_)(int, siginfo_t *, void *); 298 }; 299 struct kernel_sigset_t sa_mask; 300 #else 301 union { 302 void (*sa_handler_)(int); 303 void (*sa_sigaction_)(int, siginfo_t *, void *); 304 }; 305 unsigned long sa_flags; 306 void (*sa_restorer)(void); 307 struct kernel_sigset_t sa_mask; 308 #endif 309 }; 310 311 /* include/linux/socket.h */ 312 struct kernel_sockaddr { 313 unsigned short sa_family; 314 char sa_data[14]; 315 }; 316 317 /* include/asm-{arm,aarch64,i386,mips,ppc}/stat.h */ 318 #ifdef __mips__ 319 #if _MIPS_SIM == _MIPS_SIM_ABI64 320 struct kernel_stat { 321 #else 322 struct kernel_stat64 { 323 #endif 324 unsigned st_dev; 325 unsigned __pad0[3]; 326 unsigned long long st_ino; 327 unsigned st_mode; 328 unsigned st_nlink; 329 unsigned st_uid; 330 unsigned st_gid; 331 unsigned st_rdev; 332 unsigned __pad1[3]; 333 long long st_size; 334 unsigned st_atime_; 335 unsigned st_atime_nsec_; 336 unsigned st_mtime_; 337 unsigned st_mtime_nsec_; 338 unsigned st_ctime_; 339 unsigned st_ctime_nsec_; 340 unsigned st_blksize; 341 unsigned __pad2; 342 unsigned long long st_blocks; 343 }; 344 #elif defined __PPC__ 345 struct kernel_stat64 { 346 unsigned long long st_dev; 347 unsigned long long st_ino; 348 unsigned st_mode; 349 unsigned st_nlink; 350 unsigned st_uid; 351 unsigned st_gid; 352 unsigned long long st_rdev; 353 unsigned short int __pad2; 354 long long st_size; 355 long st_blksize; 356 long long st_blocks; 357 long st_atime_; 358 unsigned long st_atime_nsec_; 359 long st_mtime_; 360 unsigned long st_mtime_nsec_; 361 long st_ctime_; 362 unsigned long st_ctime_nsec_; 363 unsigned long __unused4; 364 unsigned long __unused5; 365 }; 366 #else 367 struct kernel_stat64 { 368 unsigned long long st_dev; 369 unsigned char __pad0[4]; 370 unsigned __st_ino; 371 unsigned st_mode; 372 unsigned st_nlink; 373 unsigned st_uid; 374 unsigned st_gid; 375 unsigned long long st_rdev; 376 unsigned char __pad3[4]; 377 long long st_size; 378 unsigned st_blksize; 379 unsigned long long st_blocks; 380 unsigned st_atime_; 381 unsigned st_atime_nsec_; 382 unsigned st_mtime_; 383 unsigned st_mtime_nsec_; 384 unsigned st_ctime_; 385 unsigned st_ctime_nsec_; 386 unsigned long long st_ino; 387 }; 388 #endif 389 390 /* include/asm-{arm,aarch64,i386,mips,x86_64,ppc}/stat.h */ 391 #if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) 392 struct kernel_stat { 393 /* The kernel headers suggest that st_dev and st_rdev should be 32bit 394 * quantities encoding 12bit major and 20bit minor numbers in an interleaved 395 * format. In reality, we do not see useful data in the top bits. So, 396 * we'll leave the padding in here, until we find a better solution. 397 */ 398 unsigned short st_dev; 399 short pad1; 400 unsigned st_ino; 401 unsigned short st_mode; 402 unsigned short st_nlink; 403 unsigned short st_uid; 404 unsigned short st_gid; 405 unsigned short st_rdev; 406 short pad2; 407 unsigned st_size; 408 unsigned st_blksize; 409 unsigned st_blocks; 410 unsigned st_atime_; 411 unsigned st_atime_nsec_; 412 unsigned st_mtime_; 413 unsigned st_mtime_nsec_; 414 unsigned st_ctime_; 415 unsigned st_ctime_nsec_; 416 unsigned __unused4; 417 unsigned __unused5; 418 }; 419 #elif defined(__x86_64__) 420 struct kernel_stat { 421 uint64_t st_dev; 422 uint64_t st_ino; 423 uint64_t st_nlink; 424 unsigned st_mode; 425 unsigned st_uid; 426 unsigned st_gid; 427 unsigned __pad0; 428 uint64_t st_rdev; 429 int64_t st_size; 430 int64_t st_blksize; 431 int64_t st_blocks; 432 uint64_t st_atime_; 433 uint64_t st_atime_nsec_; 434 uint64_t st_mtime_; 435 uint64_t st_mtime_nsec_; 436 uint64_t st_ctime_; 437 uint64_t st_ctime_nsec_; 438 int64_t __unused4[3]; 439 }; 440 #elif defined(__PPC__) 441 struct kernel_stat { 442 unsigned st_dev; 443 unsigned long st_ino; // ino_t 444 unsigned long st_mode; // mode_t 445 unsigned short st_nlink; // nlink_t 446 unsigned st_uid; // uid_t 447 unsigned st_gid; // gid_t 448 unsigned st_rdev; 449 long st_size; // off_t 450 unsigned long st_blksize; 451 unsigned long st_blocks; 452 unsigned long st_atime_; 453 unsigned long st_atime_nsec_; 454 unsigned long st_mtime_; 455 unsigned long st_mtime_nsec_; 456 unsigned long st_ctime_; 457 unsigned long st_ctime_nsec_; 458 unsigned long __unused4; 459 unsigned long __unused5; 460 }; 461 #elif (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI64) 462 struct kernel_stat { 463 unsigned st_dev; 464 int st_pad1[3]; 465 unsigned st_ino; 466 unsigned st_mode; 467 unsigned st_nlink; 468 unsigned st_uid; 469 unsigned st_gid; 470 unsigned st_rdev; 471 int st_pad2[2]; 472 long st_size; 473 int st_pad3; 474 long st_atime_; 475 long st_atime_nsec_; 476 long st_mtime_; 477 long st_mtime_nsec_; 478 long st_ctime_; 479 long st_ctime_nsec_; 480 int st_blksize; 481 int st_blocks; 482 int st_pad4[14]; 483 }; 484 #elif defined(__aarch64__) 485 struct kernel_stat { 486 unsigned long st_dev; 487 unsigned long st_ino; 488 unsigned int st_mode; 489 unsigned int st_nlink; 490 unsigned int st_uid; 491 unsigned int st_gid; 492 unsigned long st_rdev; 493 unsigned long __pad1; 494 long st_size; 495 int st_blksize; 496 int __pad2; 497 long st_blocks; 498 long st_atime_; 499 unsigned long st_atime_nsec_; 500 long st_mtime_; 501 unsigned long st_mtime_nsec_; 502 long st_ctime_; 503 unsigned long st_ctime_nsec_; 504 unsigned int __unused4; 505 unsigned int __unused5; 506 }; 507 #endif 508 509 /* include/asm-{arm,aarch64,i386,mips,x86_64,ppc}/statfs.h */ 510 #ifdef __mips__ 511 #if _MIPS_SIM != _MIPS_SIM_ABI64 512 struct kernel_statfs64 { 513 unsigned long f_type; 514 unsigned long f_bsize; 515 unsigned long f_frsize; 516 unsigned long __pad; 517 unsigned long long f_blocks; 518 unsigned long long f_bfree; 519 unsigned long long f_files; 520 unsigned long long f_ffree; 521 unsigned long long f_bavail; 522 struct { int val[2]; } f_fsid; 523 unsigned long f_namelen; 524 unsigned long f_spare[6]; 525 }; 526 #endif 527 #elif !defined(__x86_64__) 528 struct kernel_statfs64 { 529 unsigned long f_type; 530 unsigned long f_bsize; 531 unsigned long long f_blocks; 532 unsigned long long f_bfree; 533 unsigned long long f_bavail; 534 unsigned long long f_files; 535 unsigned long long f_ffree; 536 struct { int val[2]; } f_fsid; 537 unsigned long f_namelen; 538 unsigned long f_frsize; 539 unsigned long f_spare[5]; 540 }; 541 #endif 542 543 /* include/asm-{arm,i386,mips,x86_64,ppc,generic}/statfs.h */ 544 #ifdef __mips__ 545 struct kernel_statfs { 546 long f_type; 547 long f_bsize; 548 long f_frsize; 549 long f_blocks; 550 long f_bfree; 551 long f_files; 552 long f_ffree; 553 long f_bavail; 554 struct { int val[2]; } f_fsid; 555 long f_namelen; 556 long f_spare[6]; 557 }; 558 #elif defined(__x86_64__) 559 struct kernel_statfs { 560 /* x86_64 actually defines all these fields as signed, whereas all other */ 561 /* platforms define them as unsigned. Leaving them at unsigned should not */ 562 /* cause any problems. Make sure these are 64-bit even on x32. */ 563 uint64_t f_type; 564 uint64_t f_bsize; 565 uint64_t f_blocks; 566 uint64_t f_bfree; 567 uint64_t f_bavail; 568 uint64_t f_files; 569 uint64_t f_ffree; 570 struct { int val[2]; } f_fsid; 571 uint64_t f_namelen; 572 uint64_t f_frsize; 573 uint64_t f_spare[5]; 574 }; 575 #else 576 struct kernel_statfs { 577 unsigned long f_type; 578 unsigned long f_bsize; 579 unsigned long f_blocks; 580 unsigned long f_bfree; 581 unsigned long f_bavail; 582 unsigned long f_files; 583 unsigned long f_ffree; 584 struct { int val[2]; } f_fsid; 585 unsigned long f_namelen; 586 unsigned long f_frsize; 587 unsigned long f_spare[5]; 588 }; 589 #endif 590 591 592 /* Definitions missing from the standard header files */ 593 #ifndef O_DIRECTORY 594 #if defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || defined(__aarch64__) 595 #define O_DIRECTORY 0040000 596 #else 597 #define O_DIRECTORY 0200000 598 #endif 599 #endif 600 #ifndef NT_PRXFPREG 601 #define NT_PRXFPREG 0x46e62b7f 602 #endif 603 #ifndef PTRACE_GETFPXREGS 604 #define PTRACE_GETFPXREGS ((enum __ptrace_request)18) 605 #endif 606 #ifndef PR_GET_DUMPABLE 607 #define PR_GET_DUMPABLE 3 608 #endif 609 #ifndef PR_SET_DUMPABLE 610 #define PR_SET_DUMPABLE 4 611 #endif 612 #ifndef PR_GET_SECCOMP 613 #define PR_GET_SECCOMP 21 614 #endif 615 #ifndef PR_SET_SECCOMP 616 #define PR_SET_SECCOMP 22 617 #endif 618 #ifndef AT_FDCWD 619 #define AT_FDCWD (-100) 620 #endif 621 #ifndef AT_SYMLINK_NOFOLLOW 622 #define AT_SYMLINK_NOFOLLOW 0x100 623 #endif 624 #ifndef AT_REMOVEDIR 625 #define AT_REMOVEDIR 0x200 626 #endif 627 #ifndef MREMAP_FIXED 628 #define MREMAP_FIXED 2 629 #endif 630 #ifndef SA_RESTORER 631 #define SA_RESTORER 0x04000000 632 #endif 633 #ifndef CPUCLOCK_PROF 634 #define CPUCLOCK_PROF 0 635 #endif 636 #ifndef CPUCLOCK_VIRT 637 #define CPUCLOCK_VIRT 1 638 #endif 639 #ifndef CPUCLOCK_SCHED 640 #define CPUCLOCK_SCHED 2 641 #endif 642 #ifndef CPUCLOCK_PERTHREAD_MASK 643 #define CPUCLOCK_PERTHREAD_MASK 4 644 #endif 645 #ifndef MAKE_PROCESS_CPUCLOCK 646 #define MAKE_PROCESS_CPUCLOCK(pid, clock) \ 647 ((~(int)(pid) << 3) | (int)(clock)) 648 #endif 649 #ifndef MAKE_THREAD_CPUCLOCK 650 #define MAKE_THREAD_CPUCLOCK(tid, clock) \ 651 ((~(int)(tid) << 3) | (int)((clock) | CPUCLOCK_PERTHREAD_MASK)) 652 #endif 653 654 #ifndef FUTEX_WAIT 655 #define FUTEX_WAIT 0 656 #endif 657 #ifndef FUTEX_WAKE 658 #define FUTEX_WAKE 1 659 #endif 660 #ifndef FUTEX_FD 661 #define FUTEX_FD 2 662 #endif 663 #ifndef FUTEX_REQUEUE 664 #define FUTEX_REQUEUE 3 665 #endif 666 #ifndef FUTEX_CMP_REQUEUE 667 #define FUTEX_CMP_REQUEUE 4 668 #endif 669 #ifndef FUTEX_WAKE_OP 670 #define FUTEX_WAKE_OP 5 671 #endif 672 #ifndef FUTEX_LOCK_PI 673 #define FUTEX_LOCK_PI 6 674 #endif 675 #ifndef FUTEX_UNLOCK_PI 676 #define FUTEX_UNLOCK_PI 7 677 #endif 678 #ifndef FUTEX_TRYLOCK_PI 679 #define FUTEX_TRYLOCK_PI 8 680 #endif 681 #ifndef FUTEX_PRIVATE_FLAG 682 #define FUTEX_PRIVATE_FLAG 128 683 #endif 684 #ifndef FUTEX_CMD_MASK 685 #define FUTEX_CMD_MASK ~FUTEX_PRIVATE_FLAG 686 #endif 687 #ifndef FUTEX_WAIT_PRIVATE 688 #define FUTEX_WAIT_PRIVATE (FUTEX_WAIT | FUTEX_PRIVATE_FLAG) 689 #endif 690 #ifndef FUTEX_WAKE_PRIVATE 691 #define FUTEX_WAKE_PRIVATE (FUTEX_WAKE | FUTEX_PRIVATE_FLAG) 692 #endif 693 #ifndef FUTEX_REQUEUE_PRIVATE 694 #define FUTEX_REQUEUE_PRIVATE (FUTEX_REQUEUE | FUTEX_PRIVATE_FLAG) 695 #endif 696 #ifndef FUTEX_CMP_REQUEUE_PRIVATE 697 #define FUTEX_CMP_REQUEUE_PRIVATE (FUTEX_CMP_REQUEUE | FUTEX_PRIVATE_FLAG) 698 #endif 699 #ifndef FUTEX_WAKE_OP_PRIVATE 700 #define FUTEX_WAKE_OP_PRIVATE (FUTEX_WAKE_OP | FUTEX_PRIVATE_FLAG) 701 #endif 702 #ifndef FUTEX_LOCK_PI_PRIVATE 703 #define FUTEX_LOCK_PI_PRIVATE (FUTEX_LOCK_PI | FUTEX_PRIVATE_FLAG) 704 #endif 705 #ifndef FUTEX_UNLOCK_PI_PRIVATE 706 #define FUTEX_UNLOCK_PI_PRIVATE (FUTEX_UNLOCK_PI | FUTEX_PRIVATE_FLAG) 707 #endif 708 #ifndef FUTEX_TRYLOCK_PI_PRIVATE 709 #define FUTEX_TRYLOCK_PI_PRIVATE (FUTEX_TRYLOCK_PI | FUTEX_PRIVATE_FLAG) 710 #endif 711 712 713 #if defined(__x86_64__) 714 #ifndef ARCH_SET_GS 715 #define ARCH_SET_GS 0x1001 716 #endif 717 #ifndef ARCH_GET_GS 718 #define ARCH_GET_GS 0x1004 719 #endif 720 #endif 721 722 #if defined(__i386__) 723 #ifndef __NR_quotactl 724 #define __NR_quotactl 131 725 #endif 726 #ifndef __NR_setresuid 727 #define __NR_setresuid 164 728 #define __NR_getresuid 165 729 #define __NR_setresgid 170 730 #define __NR_getresgid 171 731 #endif 732 #ifndef __NR_rt_sigaction 733 #define __NR_rt_sigreturn 173 734 #define __NR_rt_sigaction 174 735 #define __NR_rt_sigprocmask 175 736 #define __NR_rt_sigpending 176 737 #define __NR_rt_sigsuspend 179 738 #endif 739 #ifndef __NR_pread64 740 #define __NR_pread64 180 741 #endif 742 #ifndef __NR_pwrite64 743 #define __NR_pwrite64 181 744 #endif 745 #ifndef __NR_ugetrlimit 746 #define __NR_ugetrlimit 191 747 #endif 748 #ifndef __NR_stat64 749 #define __NR_stat64 195 750 #endif 751 #ifndef __NR_fstat64 752 #define __NR_fstat64 197 753 #endif 754 #ifndef __NR_setresuid32 755 #define __NR_setresuid32 208 756 #define __NR_getresuid32 209 757 #define __NR_setresgid32 210 758 #define __NR_getresgid32 211 759 #endif 760 #ifndef __NR_setfsuid32 761 #define __NR_setfsuid32 215 762 #define __NR_setfsgid32 216 763 #endif 764 #ifndef __NR_getdents64 765 #define __NR_getdents64 220 766 #endif 767 #ifndef __NR_gettid 768 #define __NR_gettid 224 769 #endif 770 #ifndef __NR_readahead 771 #define __NR_readahead 225 772 #endif 773 #ifndef __NR_setxattr 774 #define __NR_setxattr 226 775 #endif 776 #ifndef __NR_lsetxattr 777 #define __NR_lsetxattr 227 778 #endif 779 #ifndef __NR_getxattr 780 #define __NR_getxattr 229 781 #endif 782 #ifndef __NR_lgetxattr 783 #define __NR_lgetxattr 230 784 #endif 785 #ifndef __NR_listxattr 786 #define __NR_listxattr 232 787 #endif 788 #ifndef __NR_llistxattr 789 #define __NR_llistxattr 233 790 #endif 791 #ifndef __NR_tkill 792 #define __NR_tkill 238 793 #endif 794 #ifndef __NR_futex 795 #define __NR_futex 240 796 #endif 797 #ifndef __NR_sched_setaffinity 798 #define __NR_sched_setaffinity 241 799 #define __NR_sched_getaffinity 242 800 #endif 801 #ifndef __NR_set_tid_address 802 #define __NR_set_tid_address 258 803 #endif 804 #ifndef __NR_clock_gettime 805 #define __NR_clock_gettime 265 806 #endif 807 #ifndef __NR_clock_getres 808 #define __NR_clock_getres 266 809 #endif 810 #ifndef __NR_statfs64 811 #define __NR_statfs64 268 812 #endif 813 #ifndef __NR_fstatfs64 814 #define __NR_fstatfs64 269 815 #endif 816 #ifndef __NR_fadvise64_64 817 #define __NR_fadvise64_64 272 818 #endif 819 #ifndef __NR_ioprio_set 820 #define __NR_ioprio_set 289 821 #endif 822 #ifndef __NR_ioprio_get 823 #define __NR_ioprio_get 290 824 #endif 825 #ifndef __NR_openat 826 #define __NR_openat 295 827 #endif 828 #ifndef __NR_fstatat64 829 #define __NR_fstatat64 300 830 #endif 831 #ifndef __NR_unlinkat 832 #define __NR_unlinkat 301 833 #endif 834 #ifndef __NR_move_pages 835 #define __NR_move_pages 317 836 #endif 837 #ifndef __NR_getcpu 838 #define __NR_getcpu 318 839 #endif 840 #ifndef __NR_fallocate 841 #define __NR_fallocate 324 842 #endif 843 /* End of i386 definitions */ 844 #elif defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) 845 #ifndef __NR_setresuid 846 #define __NR_setresuid (__NR_SYSCALL_BASE + 164) 847 #define __NR_getresuid (__NR_SYSCALL_BASE + 165) 848 #define __NR_setresgid (__NR_SYSCALL_BASE + 170) 849 #define __NR_getresgid (__NR_SYSCALL_BASE + 171) 850 #endif 851 #ifndef __NR_rt_sigaction 852 #define __NR_rt_sigreturn (__NR_SYSCALL_BASE + 173) 853 #define __NR_rt_sigaction (__NR_SYSCALL_BASE + 174) 854 #define __NR_rt_sigprocmask (__NR_SYSCALL_BASE + 175) 855 #define __NR_rt_sigpending (__NR_SYSCALL_BASE + 176) 856 #define __NR_rt_sigsuspend (__NR_SYSCALL_BASE + 179) 857 #endif 858 #ifndef __NR_pread64 859 #define __NR_pread64 (__NR_SYSCALL_BASE + 180) 860 #endif 861 #ifndef __NR_pwrite64 862 #define __NR_pwrite64 (__NR_SYSCALL_BASE + 181) 863 #endif 864 #ifndef __NR_ugetrlimit 865 #define __NR_ugetrlimit (__NR_SYSCALL_BASE + 191) 866 #endif 867 #ifndef __NR_stat64 868 #define __NR_stat64 (__NR_SYSCALL_BASE + 195) 869 #endif 870 #ifndef __NR_fstat64 871 #define __NR_fstat64 (__NR_SYSCALL_BASE + 197) 872 #endif 873 #ifndef __NR_setresuid32 874 #define __NR_setresuid32 (__NR_SYSCALL_BASE + 208) 875 #define __NR_getresuid32 (__NR_SYSCALL_BASE + 209) 876 #define __NR_setresgid32 (__NR_SYSCALL_BASE + 210) 877 #define __NR_getresgid32 (__NR_SYSCALL_BASE + 211) 878 #endif 879 #ifndef __NR_setfsuid32 880 #define __NR_setfsuid32 (__NR_SYSCALL_BASE + 215) 881 #define __NR_setfsgid32 (__NR_SYSCALL_BASE + 216) 882 #endif 883 #ifndef __NR_getdents64 884 #define __NR_getdents64 (__NR_SYSCALL_BASE + 217) 885 #endif 886 #ifndef __NR_gettid 887 #define __NR_gettid (__NR_SYSCALL_BASE + 224) 888 #endif 889 #ifndef __NR_readahead 890 #define __NR_readahead (__NR_SYSCALL_BASE + 225) 891 #endif 892 #ifndef __NR_setxattr 893 #define __NR_setxattr (__NR_SYSCALL_BASE + 226) 894 #endif 895 #ifndef __NR_lsetxattr 896 #define __NR_lsetxattr (__NR_SYSCALL_BASE + 227) 897 #endif 898 #ifndef __NR_getxattr 899 #define __NR_getxattr (__NR_SYSCALL_BASE + 229) 900 #endif 901 #ifndef __NR_lgetxattr 902 #define __NR_lgetxattr (__NR_SYSCALL_BASE + 230) 903 #endif 904 #ifndef __NR_listxattr 905 #define __NR_listxattr (__NR_SYSCALL_BASE + 232) 906 #endif 907 #ifndef __NR_llistxattr 908 #define __NR_llistxattr (__NR_SYSCALL_BASE + 233) 909 #endif 910 #ifndef __NR_tkill 911 #define __NR_tkill (__NR_SYSCALL_BASE + 238) 912 #endif 913 #ifndef __NR_futex 914 #define __NR_futex (__NR_SYSCALL_BASE + 240) 915 #endif 916 #ifndef __NR_sched_setaffinity 917 #define __NR_sched_setaffinity (__NR_SYSCALL_BASE + 241) 918 #define __NR_sched_getaffinity (__NR_SYSCALL_BASE + 242) 919 #endif 920 #ifndef __NR_set_tid_address 921 #define __NR_set_tid_address (__NR_SYSCALL_BASE + 256) 922 #endif 923 #ifndef __NR_clock_gettime 924 #define __NR_clock_gettime (__NR_SYSCALL_BASE + 263) 925 #endif 926 #ifndef __NR_clock_getres 927 #define __NR_clock_getres (__NR_SYSCALL_BASE + 264) 928 #endif 929 #ifndef __NR_statfs64 930 #define __NR_statfs64 (__NR_SYSCALL_BASE + 266) 931 #endif 932 #ifndef __NR_fstatfs64 933 #define __NR_fstatfs64 (__NR_SYSCALL_BASE + 267) 934 #endif 935 #ifndef __NR_ioprio_set 936 #define __NR_ioprio_set (__NR_SYSCALL_BASE + 314) 937 #endif 938 #ifndef __NR_ioprio_get 939 #define __NR_ioprio_get (__NR_SYSCALL_BASE + 315) 940 #endif 941 #ifndef __NR_move_pages 942 #define __NR_move_pages (__NR_SYSCALL_BASE + 344) 943 #endif 944 #ifndef __NR_getcpu 945 #define __NR_getcpu (__NR_SYSCALL_BASE + 345) 946 #endif 947 /* End of ARM 3/EABI definitions */ 948 #elif defined(__aarch64__) 949 #ifndef __NR_setxattr 950 #define __NR_setxattr 5 951 #endif 952 #ifndef __NR_lsetxattr 953 #define __NR_lsetxattr 6 954 #endif 955 #ifndef __NR_getxattr 956 #define __NR_getxattr 8 957 #endif 958 #ifndef __NR_lgetxattr 959 #define __NR_lgetxattr 9 960 #endif 961 #ifndef __NR_listxattr 962 #define __NR_listxattr 11 963 #endif 964 #ifndef __NR_llistxattr 965 #define __NR_llistxattr 12 966 #endif 967 #ifndef __NR_ioprio_set 968 #define __NR_ioprio_set 30 969 #endif 970 #ifndef __NR_ioprio_get 971 #define __NR_ioprio_get 31 972 #endif 973 #ifndef __NR_unlinkat 974 #define __NR_unlinkat 35 975 #endif 976 #ifndef __NR_fallocate 977 #define __NR_fallocate 47 978 #endif 979 #ifndef __NR_openat 980 #define __NR_openat 56 981 #endif 982 #ifndef __NR_quotactl 983 #define __NR_quotactl 60 984 #endif 985 #ifndef __NR_getdents64 986 #define __NR_getdents64 61 987 #endif 988 #ifndef __NR_getdents 989 #define __NR_getdents __NR_getdents64 990 #endif 991 #ifndef __NR_pread64 992 #define __NR_pread64 67 993 #endif 994 #ifndef __NR_pwrite64 995 #define __NR_pwrite64 68 996 #endif 997 #ifndef __NR_ppoll 998 #define __NR_ppoll 73 999 #endif 1000 #ifndef __NR_readlinkat 1001 #define __NR_readlinkat 78 1002 #endif 1003 #ifndef __NR_newfstatat 1004 #define __NR_newfstatat 79 1005 #endif 1006 #ifndef __NR_set_tid_address 1007 #define __NR_set_tid_address 96 1008 #endif 1009 #ifndef __NR_futex 1010 #define __NR_futex 98 1011 #endif 1012 #ifndef __NR_clock_gettime 1013 #define __NR_clock_gettime 113 1014 #endif 1015 #ifndef __NR_clock_getres 1016 #define __NR_clock_getres 114 1017 #endif 1018 #ifndef __NR_sched_setaffinity 1019 #define __NR_sched_setaffinity 122 1020 #define __NR_sched_getaffinity 123 1021 #endif 1022 #ifndef __NR_tkill 1023 #define __NR_tkill 130 1024 #endif 1025 #ifndef __NR_setresuid 1026 #define __NR_setresuid 147 1027 #define __NR_getresuid 148 1028 #define __NR_setresgid 149 1029 #define __NR_getresgid 150 1030 #endif 1031 #ifndef __NR_gettid 1032 #define __NR_gettid 178 1033 #endif 1034 #ifndef __NR_readahead 1035 #define __NR_readahead 213 1036 #endif 1037 #ifndef __NR_fadvise64 1038 #define __NR_fadvise64 223 1039 #endif 1040 #ifndef __NR_move_pages 1041 #define __NR_move_pages 239 1042 #endif 1043 /* End of aarch64 definitions */ 1044 #elif defined(__x86_64__) 1045 #ifndef __NR_pread64 1046 #define __NR_pread64 17 1047 #endif 1048 #ifndef __NR_pwrite64 1049 #define __NR_pwrite64 18 1050 #endif 1051 #ifndef __NR_setresuid 1052 #define __NR_setresuid 117 1053 #define __NR_getresuid 118 1054 #define __NR_setresgid 119 1055 #define __NR_getresgid 120 1056 #endif 1057 #ifndef __NR_quotactl 1058 #define __NR_quotactl 179 1059 #endif 1060 #ifndef __NR_gettid 1061 #define __NR_gettid 186 1062 #endif 1063 #ifndef __NR_readahead 1064 #define __NR_readahead 187 1065 #endif 1066 #ifndef __NR_setxattr 1067 #define __NR_setxattr 188 1068 #endif 1069 #ifndef __NR_lsetxattr 1070 #define __NR_lsetxattr 189 1071 #endif 1072 #ifndef __NR_getxattr 1073 #define __NR_getxattr 191 1074 #endif 1075 #ifndef __NR_lgetxattr 1076 #define __NR_lgetxattr 192 1077 #endif 1078 #ifndef __NR_listxattr 1079 #define __NR_listxattr 194 1080 #endif 1081 #ifndef __NR_llistxattr 1082 #define __NR_llistxattr 195 1083 #endif 1084 #ifndef __NR_tkill 1085 #define __NR_tkill 200 1086 #endif 1087 #ifndef __NR_futex 1088 #define __NR_futex 202 1089 #endif 1090 #ifndef __NR_sched_setaffinity 1091 #define __NR_sched_setaffinity 203 1092 #define __NR_sched_getaffinity 204 1093 #endif 1094 #ifndef __NR_getdents64 1095 #define __NR_getdents64 217 1096 #endif 1097 #ifndef __NR_set_tid_address 1098 #define __NR_set_tid_address 218 1099 #endif 1100 #ifndef __NR_fadvise64 1101 #define __NR_fadvise64 221 1102 #endif 1103 #ifndef __NR_clock_gettime 1104 #define __NR_clock_gettime 228 1105 #endif 1106 #ifndef __NR_clock_getres 1107 #define __NR_clock_getres 229 1108 #endif 1109 #ifndef __NR_ioprio_set 1110 #define __NR_ioprio_set 251 1111 #endif 1112 #ifndef __NR_ioprio_get 1113 #define __NR_ioprio_get 252 1114 #endif 1115 #ifndef __NR_openat 1116 #define __NR_openat 257 1117 #endif 1118 #ifndef __NR_newfstatat 1119 #define __NR_newfstatat 262 1120 #endif 1121 #ifndef __NR_unlinkat 1122 #define __NR_unlinkat 263 1123 #endif 1124 #ifndef __NR_move_pages 1125 #define __NR_move_pages 279 1126 #endif 1127 #ifndef __NR_fallocate 1128 #define __NR_fallocate 285 1129 #endif 1130 /* End of x86-64 definitions */ 1131 #elif defined(__mips__) 1132 #if _MIPS_SIM == _MIPS_SIM_ABI32 1133 #ifndef __NR_setresuid 1134 #define __NR_setresuid (__NR_Linux + 185) 1135 #define __NR_getresuid (__NR_Linux + 186) 1136 #define __NR_setresgid (__NR_Linux + 190) 1137 #define __NR_getresgid (__NR_Linux + 191) 1138 #endif 1139 #ifndef __NR_rt_sigaction 1140 #define __NR_rt_sigreturn (__NR_Linux + 193) 1141 #define __NR_rt_sigaction (__NR_Linux + 194) 1142 #define __NR_rt_sigprocmask (__NR_Linux + 195) 1143 #define __NR_rt_sigpending (__NR_Linux + 196) 1144 #define __NR_rt_sigsuspend (__NR_Linux + 199) 1145 #endif 1146 #ifndef __NR_pread64 1147 #define __NR_pread64 (__NR_Linux + 200) 1148 #endif 1149 #ifndef __NR_pwrite64 1150 #define __NR_pwrite64 (__NR_Linux + 201) 1151 #endif 1152 #ifndef __NR_stat64 1153 #define __NR_stat64 (__NR_Linux + 213) 1154 #endif 1155 #ifndef __NR_fstat64 1156 #define __NR_fstat64 (__NR_Linux + 215) 1157 #endif 1158 #ifndef __NR_getdents64 1159 #define __NR_getdents64 (__NR_Linux + 219) 1160 #endif 1161 #ifndef __NR_gettid 1162 #define __NR_gettid (__NR_Linux + 222) 1163 #endif 1164 #ifndef __NR_readahead 1165 #define __NR_readahead (__NR_Linux + 223) 1166 #endif 1167 #ifndef __NR_setxattr 1168 #define __NR_setxattr (__NR_Linux + 224) 1169 #endif 1170 #ifndef __NR_lsetxattr 1171 #define __NR_lsetxattr (__NR_Linux + 225) 1172 #endif 1173 #ifndef __NR_getxattr 1174 #define __NR_getxattr (__NR_Linux + 227) 1175 #endif 1176 #ifndef __NR_lgetxattr 1177 #define __NR_lgetxattr (__NR_Linux + 228) 1178 #endif 1179 #ifndef __NR_listxattr 1180 #define __NR_listxattr (__NR_Linux + 230) 1181 #endif 1182 #ifndef __NR_llistxattr 1183 #define __NR_llistxattr (__NR_Linux + 231) 1184 #endif 1185 #ifndef __NR_tkill 1186 #define __NR_tkill (__NR_Linux + 236) 1187 #endif 1188 #ifndef __NR_futex 1189 #define __NR_futex (__NR_Linux + 238) 1190 #endif 1191 #ifndef __NR_sched_setaffinity 1192 #define __NR_sched_setaffinity (__NR_Linux + 239) 1193 #define __NR_sched_getaffinity (__NR_Linux + 240) 1194 #endif 1195 #ifndef __NR_set_tid_address 1196 #define __NR_set_tid_address (__NR_Linux + 252) 1197 #endif 1198 #ifndef __NR_statfs64 1199 #define __NR_statfs64 (__NR_Linux + 255) 1200 #endif 1201 #ifndef __NR_fstatfs64 1202 #define __NR_fstatfs64 (__NR_Linux + 256) 1203 #endif 1204 #ifndef __NR_clock_gettime 1205 #define __NR_clock_gettime (__NR_Linux + 263) 1206 #endif 1207 #ifndef __NR_clock_getres 1208 #define __NR_clock_getres (__NR_Linux + 264) 1209 #endif 1210 #ifndef __NR_openat 1211 #define __NR_openat (__NR_Linux + 288) 1212 #endif 1213 #ifndef __NR_fstatat 1214 #define __NR_fstatat (__NR_Linux + 293) 1215 #endif 1216 #ifndef __NR_unlinkat 1217 #define __NR_unlinkat (__NR_Linux + 294) 1218 #endif 1219 #ifndef __NR_move_pages 1220 #define __NR_move_pages (__NR_Linux + 308) 1221 #endif 1222 #ifndef __NR_getcpu 1223 #define __NR_getcpu (__NR_Linux + 312) 1224 #endif 1225 #ifndef __NR_ioprio_set 1226 #define __NR_ioprio_set (__NR_Linux + 314) 1227 #endif 1228 #ifndef __NR_ioprio_get 1229 #define __NR_ioprio_get (__NR_Linux + 315) 1230 #endif 1231 /* End of MIPS (old 32bit API) definitions */ 1232 #elif _MIPS_SIM == _MIPS_SIM_ABI64 1233 #ifndef __NR_pread64 1234 #define __NR_pread64 (__NR_Linux + 16) 1235 #endif 1236 #ifndef __NR_pwrite64 1237 #define __NR_pwrite64 (__NR_Linux + 17) 1238 #endif 1239 #ifndef __NR_setresuid 1240 #define __NR_setresuid (__NR_Linux + 115) 1241 #define __NR_getresuid (__NR_Linux + 116) 1242 #define __NR_setresgid (__NR_Linux + 117) 1243 #define __NR_getresgid (__NR_Linux + 118) 1244 #endif 1245 #ifndef __NR_gettid 1246 #define __NR_gettid (__NR_Linux + 178) 1247 #endif 1248 #ifndef __NR_readahead 1249 #define __NR_readahead (__NR_Linux + 179) 1250 #endif 1251 #ifndef __NR_setxattr 1252 #define __NR_setxattr (__NR_Linux + 180) 1253 #endif 1254 #ifndef __NR_lsetxattr 1255 #define __NR_lsetxattr (__NR_Linux + 181) 1256 #endif 1257 #ifndef __NR_getxattr 1258 #define __NR_getxattr (__NR_Linux + 183) 1259 #endif 1260 #ifndef __NR_lgetxattr 1261 #define __NR_lgetxattr (__NR_Linux + 184) 1262 #endif 1263 #ifndef __NR_listxattr 1264 #define __NR_listxattr (__NR_Linux + 186) 1265 #endif 1266 #ifndef __NR_llistxattr 1267 #define __NR_llistxattr (__NR_Linux + 187) 1268 #endif 1269 #ifndef __NR_tkill 1270 #define __NR_tkill (__NR_Linux + 192) 1271 #endif 1272 #ifndef __NR_futex 1273 #define __NR_futex (__NR_Linux + 194) 1274 #endif 1275 #ifndef __NR_sched_setaffinity 1276 #define __NR_sched_setaffinity (__NR_Linux + 195) 1277 #define __NR_sched_getaffinity (__NR_Linux + 196) 1278 #endif 1279 #ifndef __NR_set_tid_address 1280 #define __NR_set_tid_address (__NR_Linux + 212) 1281 #endif 1282 #ifndef __NR_clock_gettime 1283 #define __NR_clock_gettime (__NR_Linux + 222) 1284 #endif 1285 #ifndef __NR_clock_getres 1286 #define __NR_clock_getres (__NR_Linux + 223) 1287 #endif 1288 #ifndef __NR_openat 1289 #define __NR_openat (__NR_Linux + 247) 1290 #endif 1291 #ifndef __NR_fstatat 1292 #define __NR_fstatat (__NR_Linux + 252) 1293 #endif 1294 #ifndef __NR_unlinkat 1295 #define __NR_unlinkat (__NR_Linux + 253) 1296 #endif 1297 #ifndef __NR_move_pages 1298 #define __NR_move_pages (__NR_Linux + 267) 1299 #endif 1300 #ifndef __NR_getcpu 1301 #define __NR_getcpu (__NR_Linux + 271) 1302 #endif 1303 #ifndef __NR_ioprio_set 1304 #define __NR_ioprio_set (__NR_Linux + 273) 1305 #endif 1306 #ifndef __NR_ioprio_get 1307 #define __NR_ioprio_get (__NR_Linux + 274) 1308 #endif 1309 /* End of MIPS (64bit API) definitions */ 1310 #else 1311 #ifndef __NR_setresuid 1312 #define __NR_setresuid (__NR_Linux + 115) 1313 #define __NR_getresuid (__NR_Linux + 116) 1314 #define __NR_setresgid (__NR_Linux + 117) 1315 #define __NR_getresgid (__NR_Linux + 118) 1316 #endif 1317 #ifndef __NR_gettid 1318 #define __NR_gettid (__NR_Linux + 178) 1319 #endif 1320 #ifndef __NR_readahead 1321 #define __NR_readahead (__NR_Linux + 179) 1322 #endif 1323 #ifndef __NR_setxattr 1324 #define __NR_setxattr (__NR_Linux + 180) 1325 #endif 1326 #ifndef __NR_lsetxattr 1327 #define __NR_lsetxattr (__NR_Linux + 181) 1328 #endif 1329 #ifndef __NR_getxattr 1330 #define __NR_getxattr (__NR_Linux + 183) 1331 #endif 1332 #ifndef __NR_lgetxattr 1333 #define __NR_lgetxattr (__NR_Linux + 184) 1334 #endif 1335 #ifndef __NR_listxattr 1336 #define __NR_listxattr (__NR_Linux + 186) 1337 #endif 1338 #ifndef __NR_llistxattr 1339 #define __NR_llistxattr (__NR_Linux + 187) 1340 #endif 1341 #ifndef __NR_tkill 1342 #define __NR_tkill (__NR_Linux + 192) 1343 #endif 1344 #ifndef __NR_futex 1345 #define __NR_futex (__NR_Linux + 194) 1346 #endif 1347 #ifndef __NR_sched_setaffinity 1348 #define __NR_sched_setaffinity (__NR_Linux + 195) 1349 #define __NR_sched_getaffinity (__NR_Linux + 196) 1350 #endif 1351 #ifndef __NR_set_tid_address 1352 #define __NR_set_tid_address (__NR_Linux + 213) 1353 #endif 1354 #ifndef __NR_statfs64 1355 #define __NR_statfs64 (__NR_Linux + 217) 1356 #endif 1357 #ifndef __NR_fstatfs64 1358 #define __NR_fstatfs64 (__NR_Linux + 218) 1359 #endif 1360 #ifndef __NR_clock_gettime 1361 #define __NR_clock_gettime (__NR_Linux + 226) 1362 #endif 1363 #ifndef __NR_clock_getres 1364 #define __NR_clock_getres (__NR_Linux + 227) 1365 #endif 1366 #ifndef __NR_openat 1367 #define __NR_openat (__NR_Linux + 251) 1368 #endif 1369 #ifndef __NR_fstatat 1370 #define __NR_fstatat (__NR_Linux + 256) 1371 #endif 1372 #ifndef __NR_unlinkat 1373 #define __NR_unlinkat (__NR_Linux + 257) 1374 #endif 1375 #ifndef __NR_move_pages 1376 #define __NR_move_pages (__NR_Linux + 271) 1377 #endif 1378 #ifndef __NR_getcpu 1379 #define __NR_getcpu (__NR_Linux + 275) 1380 #endif 1381 #ifndef __NR_ioprio_set 1382 #define __NR_ioprio_set (__NR_Linux + 277) 1383 #endif 1384 #ifndef __NR_ioprio_get 1385 #define __NR_ioprio_get (__NR_Linux + 278) 1386 #endif 1387 /* End of MIPS (new 32bit API) definitions */ 1388 #endif 1389 /* End of MIPS definitions */ 1390 #elif defined(__PPC__) 1391 #ifndef __NR_setfsuid 1392 #define __NR_setfsuid 138 1393 #define __NR_setfsgid 139 1394 #endif 1395 #ifndef __NR_setresuid 1396 #define __NR_setresuid 164 1397 #define __NR_getresuid 165 1398 #define __NR_setresgid 169 1399 #define __NR_getresgid 170 1400 #endif 1401 #ifndef __NR_rt_sigaction 1402 #define __NR_rt_sigreturn 172 1403 #define __NR_rt_sigaction 173 1404 #define __NR_rt_sigprocmask 174 1405 #define __NR_rt_sigpending 175 1406 #define __NR_rt_sigsuspend 178 1407 #endif 1408 #ifndef __NR_pread64 1409 #define __NR_pread64 179 1410 #endif 1411 #ifndef __NR_pwrite64 1412 #define __NR_pwrite64 180 1413 #endif 1414 #ifndef __NR_ugetrlimit 1415 #define __NR_ugetrlimit 190 1416 #endif 1417 #ifndef __NR_readahead 1418 #define __NR_readahead 191 1419 #endif 1420 #ifndef __NR_stat64 1421 #define __NR_stat64 195 1422 #endif 1423 #ifndef __NR_fstat64 1424 #define __NR_fstat64 197 1425 #endif 1426 #ifndef __NR_getdents64 1427 #define __NR_getdents64 202 1428 #endif 1429 #ifndef __NR_gettid 1430 #define __NR_gettid 207 1431 #endif 1432 #ifndef __NR_tkill 1433 #define __NR_tkill 208 1434 #endif 1435 #ifndef __NR_setxattr 1436 #define __NR_setxattr 209 1437 #endif 1438 #ifndef __NR_lsetxattr 1439 #define __NR_lsetxattr 210 1440 #endif 1441 #ifndef __NR_getxattr 1442 #define __NR_getxattr 212 1443 #endif 1444 #ifndef __NR_lgetxattr 1445 #define __NR_lgetxattr 213 1446 #endif 1447 #ifndef __NR_listxattr 1448 #define __NR_listxattr 215 1449 #endif 1450 #ifndef __NR_llistxattr 1451 #define __NR_llistxattr 216 1452 #endif 1453 #ifndef __NR_futex 1454 #define __NR_futex 221 1455 #endif 1456 #ifndef __NR_sched_setaffinity 1457 #define __NR_sched_setaffinity 222 1458 #define __NR_sched_getaffinity 223 1459 #endif 1460 #ifndef __NR_set_tid_address 1461 #define __NR_set_tid_address 232 1462 #endif 1463 #ifndef __NR_clock_gettime 1464 #define __NR_clock_gettime 246 1465 #endif 1466 #ifndef __NR_clock_getres 1467 #define __NR_clock_getres 247 1468 #endif 1469 #ifndef __NR_statfs64 1470 #define __NR_statfs64 252 1471 #endif 1472 #ifndef __NR_fstatfs64 1473 #define __NR_fstatfs64 253 1474 #endif 1475 #ifndef __NR_fadvise64_64 1476 #define __NR_fadvise64_64 254 1477 #endif 1478 #ifndef __NR_ioprio_set 1479 #define __NR_ioprio_set 273 1480 #endif 1481 #ifndef __NR_ioprio_get 1482 #define __NR_ioprio_get 274 1483 #endif 1484 #ifndef __NR_openat 1485 #define __NR_openat 286 1486 #endif 1487 #ifndef __NR_fstatat64 1488 #define __NR_fstatat64 291 1489 #endif 1490 #ifndef __NR_unlinkat 1491 #define __NR_unlinkat 292 1492 #endif 1493 #ifndef __NR_move_pages 1494 #define __NR_move_pages 301 1495 #endif 1496 #ifndef __NR_getcpu 1497 #define __NR_getcpu 302 1498 #endif 1499 /* End of powerpc defininitions */ 1500 #endif 1501 1502 1503 /* After forking, we must make sure to only call system calls. */ 1504 #if defined(__BOUNDED_POINTERS__) 1505 #error "Need to port invocations of syscalls for bounded ptrs" 1506 #else 1507 /* The core dumper and the thread lister get executed after threads 1508 * have been suspended. As a consequence, we cannot call any functions 1509 * that acquire locks. Unfortunately, libc wraps most system calls 1510 * (e.g. in order to implement pthread_atfork, and to make calls 1511 * cancellable), which means we cannot call these functions. Instead, 1512 * we have to call syscall() directly. 1513 */ 1514 #undef LSS_ERRNO 1515 #ifdef SYS_ERRNO 1516 /* Allow the including file to override the location of errno. This can 1517 * be useful when using clone() with the CLONE_VM option. 1518 */ 1519 #define LSS_ERRNO SYS_ERRNO 1520 #else 1521 #define LSS_ERRNO errno 1522 #endif 1523 1524 #undef LSS_INLINE 1525 #ifdef SYS_INLINE 1526 #define LSS_INLINE SYS_INLINE 1527 #else 1528 #define LSS_INLINE static inline 1529 #endif 1530 1531 /* Allow the including file to override the prefix used for all new 1532 * system calls. By default, it will be set to "sys_". 1533 */ 1534 #undef LSS_NAME 1535 #ifndef SYS_PREFIX 1536 #define LSS_NAME(name) sys_##name 1537 #elif defined(SYS_PREFIX) && SYS_PREFIX < 0 1538 #define LSS_NAME(name) name 1539 #elif defined(SYS_PREFIX) && SYS_PREFIX == 0 1540 #define LSS_NAME(name) sys0_##name 1541 #elif defined(SYS_PREFIX) && SYS_PREFIX == 1 1542 #define LSS_NAME(name) sys1_##name 1543 #elif defined(SYS_PREFIX) && SYS_PREFIX == 2 1544 #define LSS_NAME(name) sys2_##name 1545 #elif defined(SYS_PREFIX) && SYS_PREFIX == 3 1546 #define LSS_NAME(name) sys3_##name 1547 #elif defined(SYS_PREFIX) && SYS_PREFIX == 4 1548 #define LSS_NAME(name) sys4_##name 1549 #elif defined(SYS_PREFIX) && SYS_PREFIX == 5 1550 #define LSS_NAME(name) sys5_##name 1551 #elif defined(SYS_PREFIX) && SYS_PREFIX == 6 1552 #define LSS_NAME(name) sys6_##name 1553 #elif defined(SYS_PREFIX) && SYS_PREFIX == 7 1554 #define LSS_NAME(name) sys7_##name 1555 #elif defined(SYS_PREFIX) && SYS_PREFIX == 8 1556 #define LSS_NAME(name) sys8_##name 1557 #elif defined(SYS_PREFIX) && SYS_PREFIX == 9 1558 #define LSS_NAME(name) sys9_##name 1559 #endif 1560 1561 #undef LSS_RETURN 1562 #if (defined(__i386__) || defined(__x86_64__) || defined(__ARM_ARCH_3__) \ 1563 || defined(__ARM_EABI__) || defined(__aarch64__)) 1564 /* Failing system calls return a negative result in the range of 1565 * -1..-4095. These are "errno" values with the sign inverted. 1566 */ 1567 #define LSS_RETURN(type, res) \ 1568 do { \ 1569 if ((unsigned long)(res) >= (unsigned long)(-4095)) { \ 1570 LSS_ERRNO = -(res); \ 1571 res = -1; \ 1572 } \ 1573 return (type) (res); \ 1574 } while (0) 1575 #elif defined(__mips__) 1576 /* On MIPS, failing system calls return -1, and set errno in a 1577 * separate CPU register. 1578 */ 1579 #define LSS_RETURN(type, res, err) \ 1580 do { \ 1581 if (err) { \ 1582 unsigned long __errnovalue = (res); \ 1583 LSS_ERRNO = __errnovalue; \ 1584 res = -1; \ 1585 } \ 1586 return (type) (res); \ 1587 } while (0) 1588 #elif defined(__PPC__) 1589 /* On PPC, failing system calls return -1, and set errno in a 1590 * separate CPU register. See linux/unistd.h. 1591 */ 1592 #define LSS_RETURN(type, res, err) \ 1593 do { \ 1594 if (err & 0x10000000 ) { \ 1595 LSS_ERRNO = (res); \ 1596 res = -1; \ 1597 } \ 1598 return (type) (res); \ 1599 } while (0) 1600 #endif 1601 #if defined(__i386__) 1602 /* In PIC mode (e.g. when building shared libraries), gcc for i386 1603 * reserves ebx. Unfortunately, most distribution ship with implementations 1604 * of _syscallX() which clobber ebx. 1605 * Also, most definitions of _syscallX() neglect to mark "memory" as being 1606 * clobbered. This causes problems with compilers, that do a better job 1607 * at optimizing across __asm__ calls. 1608 * So, we just have to redefine all of the _syscallX() macros. 1609 */ 1610 #undef LSS_ENTRYPOINT 1611 #ifdef SYS_SYSCALL_ENTRYPOINT LSS_NAME(get_syscall_entrypoint)1612 static inline void (**LSS_NAME(get_syscall_entrypoint)(void))(void) { 1613 void (**entrypoint)(void); 1614 asm volatile(".bss\n" 1615 ".align 8\n" 1616 ".globl " SYS_SYSCALL_ENTRYPOINT "\n" 1617 ".common " SYS_SYSCALL_ENTRYPOINT ",8,8\n" 1618 ".previous\n" 1619 /* This logically does 'lea "SYS_SYSCALL_ENTRYPOINT", %0' */ 1620 "call 0f\n" 1621 "0:pop %0\n" 1622 "add $_GLOBAL_OFFSET_TABLE_+[.-0b], %0\n" 1623 "mov " SYS_SYSCALL_ENTRYPOINT "@GOT(%0), %0\n" 1624 : "=r"(entrypoint)); 1625 return entrypoint; 1626 } 1627 1628 #define LSS_ENTRYPOINT ".bss\n" \ 1629 ".align 8\n" \ 1630 ".globl " SYS_SYSCALL_ENTRYPOINT "\n" \ 1631 ".common " SYS_SYSCALL_ENTRYPOINT ",8,8\n" \ 1632 ".previous\n" \ 1633 /* Check the SYS_SYSCALL_ENTRYPOINT vector */ \ 1634 "push %%eax\n" \ 1635 "call 10000f\n" \ 1636 "10000:pop %%eax\n" \ 1637 "add $_GLOBAL_OFFSET_TABLE_+[.-10000b], %%eax\n" \ 1638 "mov " SYS_SYSCALL_ENTRYPOINT \ 1639 "@GOT(%%eax), %%eax\n" \ 1640 "mov 0(%%eax), %%eax\n" \ 1641 "test %%eax, %%eax\n" \ 1642 "jz 10002f\n" \ 1643 "push %%eax\n" \ 1644 "call 10001f\n" \ 1645 "10001:pop %%eax\n" \ 1646 "add $(10003f-10001b), %%eax\n" \ 1647 "xchg 4(%%esp), %%eax\n" \ 1648 "ret\n" \ 1649 "10002:pop %%eax\n" \ 1650 "int $0x80\n" \ 1651 "10003:\n" 1652 #else 1653 #define LSS_ENTRYPOINT "int $0x80\n" 1654 #endif 1655 #undef LSS_BODY 1656 #define LSS_BODY(type,args...) \ 1657 long __res; \ 1658 __asm__ __volatile__("push %%ebx\n" \ 1659 "movl %2,%%ebx\n" \ 1660 LSS_ENTRYPOINT \ 1661 "pop %%ebx" \ 1662 args \ 1663 : "esp", "memory"); \ 1664 LSS_RETURN(type,__res) 1665 #undef _syscall0 1666 #define _syscall0(type,name) \ 1667 type LSS_NAME(name)(void) { \ 1668 long __res; \ 1669 __asm__ volatile(LSS_ENTRYPOINT \ 1670 : "=a" (__res) \ 1671 : "0" (__NR_##name) \ 1672 : "esp", "memory"); \ 1673 LSS_RETURN(type,__res); \ 1674 } 1675 #undef _syscall1 1676 #define _syscall1(type,name,type1,arg1) \ 1677 type LSS_NAME(name)(type1 arg1) { \ 1678 LSS_BODY(type, \ 1679 : "=a" (__res) \ 1680 : "0" (__NR_##name), "ri" ((long)(arg1))); \ 1681 } 1682 #undef _syscall2 1683 #define _syscall2(type,name,type1,arg1,type2,arg2) \ 1684 type LSS_NAME(name)(type1 arg1,type2 arg2) { \ 1685 LSS_BODY(type, \ 1686 : "=a" (__res) \ 1687 : "0" (__NR_##name),"ri" ((long)(arg1)), "c" ((long)(arg2))); \ 1688 } 1689 #undef _syscall3 1690 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \ 1691 type LSS_NAME(name)(type1 arg1,type2 arg2,type3 arg3) { \ 1692 LSS_BODY(type, \ 1693 : "=a" (__res) \ 1694 : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)), \ 1695 "d" ((long)(arg3))); \ 1696 } 1697 #undef _syscall4 1698 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 1699 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 1700 LSS_BODY(type, \ 1701 : "=a" (__res) \ 1702 : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)), \ 1703 "d" ((long)(arg3)),"S" ((long)(arg4))); \ 1704 } 1705 #undef _syscall5 1706 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 1707 type5,arg5) \ 1708 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1709 type5 arg5) { \ 1710 long __res; \ 1711 __asm__ __volatile__("push %%ebx\n" \ 1712 "movl %2,%%ebx\n" \ 1713 "movl %1,%%eax\n" \ 1714 LSS_ENTRYPOINT \ 1715 "pop %%ebx" \ 1716 : "=a" (__res) \ 1717 : "i" (__NR_##name), "ri" ((long)(arg1)), \ 1718 "c" ((long)(arg2)), "d" ((long)(arg3)), \ 1719 "S" ((long)(arg4)), "D" ((long)(arg5)) \ 1720 : "esp", "memory"); \ 1721 LSS_RETURN(type,__res); \ 1722 } 1723 #undef _syscall6 1724 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 1725 type5,arg5,type6,arg6) \ 1726 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 1727 type5 arg5, type6 arg6) { \ 1728 long __res; \ 1729 struct { long __a1; long __a6; } __s = { (long)arg1, (long) arg6 }; \ 1730 __asm__ __volatile__("push %%ebp\n" \ 1731 "push %%ebx\n" \ 1732 "movl 4(%2),%%ebp\n" \ 1733 "movl 0(%2), %%ebx\n" \ 1734 "movl %1,%%eax\n" \ 1735 LSS_ENTRYPOINT \ 1736 "pop %%ebx\n" \ 1737 "pop %%ebp" \ 1738 : "=a" (__res) \ 1739 : "i" (__NR_##name), "0" ((long)(&__s)), \ 1740 "c" ((long)(arg2)), "d" ((long)(arg3)), \ 1741 "S" ((long)(arg4)), "D" ((long)(arg5)) \ 1742 : "esp", "memory"); \ 1743 LSS_RETURN(type,__res); \ 1744 } LSS_NAME(clone)1745 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 1746 int flags, void *arg, int *parent_tidptr, 1747 void *newtls, int *child_tidptr) { 1748 long __res; 1749 __asm__ __volatile__(/* if (fn == NULL) 1750 * return -EINVAL; 1751 */ 1752 "movl %3,%%ecx\n" 1753 "jecxz 1f\n" 1754 1755 /* if (child_stack == NULL) 1756 * return -EINVAL; 1757 */ 1758 "movl %4,%%ecx\n" 1759 "jecxz 1f\n" 1760 1761 /* Set up alignment of the child stack: 1762 * child_stack = (child_stack & ~0xF) - 20; 1763 */ 1764 "andl $-16,%%ecx\n" 1765 "subl $20,%%ecx\n" 1766 1767 /* Push "arg" and "fn" onto the stack that will be 1768 * used by the child. 1769 */ 1770 "movl %6,%%eax\n" 1771 "movl %%eax,4(%%ecx)\n" 1772 "movl %3,%%eax\n" 1773 "movl %%eax,(%%ecx)\n" 1774 1775 /* %eax = syscall(%eax = __NR_clone, 1776 * %ebx = flags, 1777 * %ecx = child_stack, 1778 * %edx = parent_tidptr, 1779 * %esi = newtls, 1780 * %edi = child_tidptr) 1781 * Also, make sure that %ebx gets preserved as it is 1782 * used in PIC mode. 1783 */ 1784 "movl %8,%%esi\n" 1785 "movl %7,%%edx\n" 1786 "movl %5,%%eax\n" 1787 "movl %9,%%edi\n" 1788 "pushl %%ebx\n" 1789 "movl %%eax,%%ebx\n" 1790 "movl %2,%%eax\n" 1791 LSS_ENTRYPOINT 1792 1793 /* In the parent: restore %ebx 1794 * In the child: move "fn" into %ebx 1795 */ 1796 "popl %%ebx\n" 1797 1798 /* if (%eax != 0) 1799 * return %eax; 1800 */ 1801 "test %%eax,%%eax\n" 1802 "jnz 1f\n" 1803 1804 /* In the child, now. Terminate frame pointer chain. 1805 */ 1806 "movl $0,%%ebp\n" 1807 1808 /* Call "fn". "arg" is already on the stack. 1809 */ 1810 "call *%%ebx\n" 1811 1812 /* Call _exit(%ebx). Unfortunately older versions 1813 * of gcc restrict the number of arguments that can 1814 * be passed to asm(). So, we need to hard-code the 1815 * system call number. 1816 */ 1817 "movl %%eax,%%ebx\n" 1818 "movl $1,%%eax\n" 1819 LSS_ENTRYPOINT 1820 1821 /* Return to parent. 1822 */ 1823 "1:\n" 1824 : "=a" (__res) 1825 : "0"(-EINVAL), "i"(__NR_clone), 1826 "m"(fn), "m"(child_stack), "m"(flags), "m"(arg), 1827 "m"(parent_tidptr), "m"(newtls), "m"(child_tidptr) 1828 : "esp", "memory", "ecx", "edx", "esi", "edi"); 1829 LSS_RETURN(int, __res); 1830 } 1831 1832 #define __NR__fadvise64_64 __NR_fadvise64_64 _syscall6(int,_fadvise64_64,int,fd,unsigned,offset_lo,unsigned,offset_hi,unsigned,len_lo,unsigned,len_hi,int,advice)1833 LSS_INLINE _syscall6(int, _fadvise64_64, int, fd, 1834 unsigned, offset_lo, unsigned, offset_hi, 1835 unsigned, len_lo, unsigned, len_hi, 1836 int, advice) 1837 1838 LSS_INLINE int LSS_NAME(fadvise64)(int fd, loff_t offset, 1839 loff_t len, int advice) { 1840 return LSS_NAME(_fadvise64_64)(fd, 1841 (unsigned)offset, (unsigned)(offset >>32), 1842 (unsigned)len, (unsigned)(len >> 32), 1843 advice); 1844 } 1845 1846 #define __NR__fallocate __NR_fallocate _syscall6(int,_fallocate,int,fd,int,mode,unsigned,offset_lo,unsigned,offset_hi,unsigned,len_lo,unsigned,len_hi)1847 LSS_INLINE _syscall6(int, _fallocate, int, fd, 1848 int, mode, 1849 unsigned, offset_lo, unsigned, offset_hi, 1850 unsigned, len_lo, unsigned, len_hi) 1851 1852 LSS_INLINE int LSS_NAME(fallocate)(int fd, int mode, 1853 loff_t offset, loff_t len) { 1854 union { loff_t off; unsigned w[2]; } o = { offset }, l = { len }; 1855 return LSS_NAME(_fallocate)(fd, mode, o.w[0], o.w[1], l.w[0], l.w[1]); 1856 } 1857 _syscall1(int,set_thread_area,void *,u)1858 LSS_INLINE _syscall1(int, set_thread_area, void *, u) 1859 LSS_INLINE _syscall1(int, get_thread_area, void *, u) 1860 1861 LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) { 1862 /* On i386, the kernel does not know how to return from a signal 1863 * handler. Instead, it relies on user space to provide a 1864 * restorer function that calls the {rt_,}sigreturn() system call. 1865 * Unfortunately, we cannot just reference the glibc version of this 1866 * function, as glibc goes out of its way to make it inaccessible. 1867 */ 1868 void (*res)(void); 1869 __asm__ __volatile__("call 2f\n" 1870 "0:.align 16\n" 1871 "1:movl %1,%%eax\n" 1872 LSS_ENTRYPOINT 1873 "2:popl %0\n" 1874 "addl $(1b-0b),%0\n" 1875 : "=a" (res) 1876 : "i" (__NR_rt_sigreturn)); 1877 return res; 1878 } LSS_NAME(restore)1879 LSS_INLINE void (*LSS_NAME(restore)(void))(void) { 1880 /* On i386, the kernel does not know how to return from a signal 1881 * handler. Instead, it relies on user space to provide a 1882 * restorer function that calls the {rt_,}sigreturn() system call. 1883 * Unfortunately, we cannot just reference the glibc version of this 1884 * function, as glibc goes out of its way to make it inaccessible. 1885 */ 1886 void (*res)(void); 1887 __asm__ __volatile__("call 2f\n" 1888 "0:.align 16\n" 1889 "1:pop %%eax\n" 1890 "movl %1,%%eax\n" 1891 LSS_ENTRYPOINT 1892 "2:popl %0\n" 1893 "addl $(1b-0b),%0\n" 1894 : "=a" (res) 1895 : "i" (__NR_sigreturn)); 1896 return res; 1897 } 1898 #elif defined(__x86_64__) 1899 /* There are no known problems with any of the _syscallX() macros 1900 * currently shipping for x86_64, but we still need to be able to define 1901 * our own version so that we can override the location of the errno 1902 * location (e.g. when using the clone() system call with the CLONE_VM 1903 * option). 1904 */ 1905 #undef LSS_ENTRYPOINT 1906 #ifdef SYS_SYSCALL_ENTRYPOINT LSS_NAME(get_syscall_entrypoint)1907 static inline void (**LSS_NAME(get_syscall_entrypoint)(void))(void) { 1908 void (**entrypoint)(void); 1909 asm volatile(".bss\n" 1910 ".align 8\n" 1911 ".globl " SYS_SYSCALL_ENTRYPOINT "\n" 1912 ".common " SYS_SYSCALL_ENTRYPOINT ",8,8\n" 1913 ".previous\n" 1914 "mov " SYS_SYSCALL_ENTRYPOINT "@GOTPCREL(%%rip), %0\n" 1915 : "=r"(entrypoint)); 1916 return entrypoint; 1917 } 1918 1919 #define LSS_ENTRYPOINT \ 1920 ".bss\n" \ 1921 ".align 8\n" \ 1922 ".globl " SYS_SYSCALL_ENTRYPOINT "\n" \ 1923 ".common " SYS_SYSCALL_ENTRYPOINT ",8,8\n" \ 1924 ".previous\n" \ 1925 "mov " SYS_SYSCALL_ENTRYPOINT "@GOTPCREL(%%rip), %%rcx\n" \ 1926 "mov 0(%%rcx), %%rcx\n" \ 1927 "test %%rcx, %%rcx\n" \ 1928 "jz 10001f\n" \ 1929 "call *%%rcx\n" \ 1930 "jmp 10002f\n" \ 1931 "10001:syscall\n" \ 1932 "10002:\n" 1933 1934 #else 1935 #define LSS_ENTRYPOINT "syscall\n" 1936 #endif 1937 1938 /* The x32 ABI has 32 bit longs, but the syscall interface is 64 bit. 1939 * We need to explicitly cast to an unsigned 64 bit type to avoid implicit 1940 * sign extension. We can't cast pointers directly because those are 1941 * 32 bits, and gcc will dump ugly warnings about casting from a pointer 1942 * to an integer of a different size. 1943 */ 1944 #undef LSS_SYSCALL_ARG 1945 #define LSS_SYSCALL_ARG(a) ((uint64_t)(uintptr_t)(a)) 1946 #undef _LSS_RETURN 1947 #define _LSS_RETURN(type, res, cast) \ 1948 do { \ 1949 if ((uint64_t)(res) >= (uint64_t)(-4095)) { \ 1950 LSS_ERRNO = -(res); \ 1951 res = -1; \ 1952 } \ 1953 return (type)(cast)(res); \ 1954 } while (0) 1955 #undef LSS_RETURN 1956 #define LSS_RETURN(type, res) _LSS_RETURN(type, res, uintptr_t) 1957 1958 #undef _LSS_BODY 1959 #define _LSS_BODY(nr, type, name, cast, ...) \ 1960 long long __res; \ 1961 __asm__ __volatile__(LSS_BODY_ASM##nr LSS_ENTRYPOINT \ 1962 : "=a" (__res) \ 1963 : "0" (__NR_##name) LSS_BODY_ARG##nr(__VA_ARGS__) \ 1964 : LSS_BODY_CLOBBER##nr "r11", "rcx", "memory"); \ 1965 _LSS_RETURN(type, __res, cast) 1966 #undef LSS_BODY 1967 #define LSS_BODY(nr, type, name, args...) \ 1968 _LSS_BODY(nr, type, name, uintptr_t, ## args) 1969 1970 #undef LSS_BODY_ASM0 1971 #undef LSS_BODY_ASM1 1972 #undef LSS_BODY_ASM2 1973 #undef LSS_BODY_ASM3 1974 #undef LSS_BODY_ASM4 1975 #undef LSS_BODY_ASM5 1976 #undef LSS_BODY_ASM6 1977 #define LSS_BODY_ASM0 1978 #define LSS_BODY_ASM1 LSS_BODY_ASM0 1979 #define LSS_BODY_ASM2 LSS_BODY_ASM1 1980 #define LSS_BODY_ASM3 LSS_BODY_ASM2 1981 #define LSS_BODY_ASM4 LSS_BODY_ASM3 "movq %5,%%r10;" 1982 #define LSS_BODY_ASM5 LSS_BODY_ASM4 "movq %6,%%r8;" 1983 #define LSS_BODY_ASM6 LSS_BODY_ASM5 "movq %7,%%r9;" 1984 1985 #undef LSS_BODY_CLOBBER0 1986 #undef LSS_BODY_CLOBBER1 1987 #undef LSS_BODY_CLOBBER2 1988 #undef LSS_BODY_CLOBBER3 1989 #undef LSS_BODY_CLOBBER4 1990 #undef LSS_BODY_CLOBBER5 1991 #undef LSS_BODY_CLOBBER6 1992 #define LSS_BODY_CLOBBER0 1993 #define LSS_BODY_CLOBBER1 LSS_BODY_CLOBBER0 1994 #define LSS_BODY_CLOBBER2 LSS_BODY_CLOBBER1 1995 #define LSS_BODY_CLOBBER3 LSS_BODY_CLOBBER2 1996 #define LSS_BODY_CLOBBER4 LSS_BODY_CLOBBER3 "r10", 1997 #define LSS_BODY_CLOBBER5 LSS_BODY_CLOBBER4 "r8", 1998 #define LSS_BODY_CLOBBER6 LSS_BODY_CLOBBER5 "r9", 1999 2000 #undef LSS_BODY_ARG0 2001 #undef LSS_BODY_ARG1 2002 #undef LSS_BODY_ARG2 2003 #undef LSS_BODY_ARG3 2004 #undef LSS_BODY_ARG4 2005 #undef LSS_BODY_ARG5 2006 #undef LSS_BODY_ARG6 2007 #define LSS_BODY_ARG0() 2008 #define LSS_BODY_ARG1(arg1) \ 2009 LSS_BODY_ARG0(), "D" (arg1) 2010 #define LSS_BODY_ARG2(arg1, arg2) \ 2011 LSS_BODY_ARG1(arg1), "S" (arg2) 2012 #define LSS_BODY_ARG3(arg1, arg2, arg3) \ 2013 LSS_BODY_ARG2(arg1, arg2), "d" (arg3) 2014 #define LSS_BODY_ARG4(arg1, arg2, arg3, arg4) \ 2015 LSS_BODY_ARG3(arg1, arg2, arg3), "r" (arg4) 2016 #define LSS_BODY_ARG5(arg1, arg2, arg3, arg4, arg5) \ 2017 LSS_BODY_ARG4(arg1, arg2, arg3, arg4), "r" (arg5) 2018 #define LSS_BODY_ARG6(arg1, arg2, arg3, arg4, arg5, arg6) \ 2019 LSS_BODY_ARG5(arg1, arg2, arg3, arg4, arg5), "r" (arg6) 2020 2021 #undef _syscall0 2022 #define _syscall0(type,name) \ 2023 type LSS_NAME(name)(void) { \ 2024 LSS_BODY(0, type, name); \ 2025 } 2026 #undef _syscall1 2027 #define _syscall1(type,name,type1,arg1) \ 2028 type LSS_NAME(name)(type1 arg1) { \ 2029 LSS_BODY(1, type, name, LSS_SYSCALL_ARG(arg1)); \ 2030 } 2031 #undef _syscall2 2032 #define _syscall2(type,name,type1,arg1,type2,arg2) \ 2033 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 2034 LSS_BODY(2, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2));\ 2035 } 2036 #undef _syscall3 2037 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \ 2038 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 2039 LSS_BODY(3, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \ 2040 LSS_SYSCALL_ARG(arg3)); \ 2041 } 2042 #undef _syscall4 2043 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 2044 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 2045 LSS_BODY(4, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \ 2046 LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4));\ 2047 } 2048 #undef _syscall5 2049 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2050 type5,arg5) \ 2051 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2052 type5 arg5) { \ 2053 LSS_BODY(5, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \ 2054 LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4), \ 2055 LSS_SYSCALL_ARG(arg5)); \ 2056 } 2057 #undef _syscall6 2058 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2059 type5,arg5,type6,arg6) \ 2060 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2061 type5 arg5, type6 arg6) { \ 2062 LSS_BODY(6, type, name, LSS_SYSCALL_ARG(arg1), LSS_SYSCALL_ARG(arg2), \ 2063 LSS_SYSCALL_ARG(arg3), LSS_SYSCALL_ARG(arg4), \ 2064 LSS_SYSCALL_ARG(arg5), LSS_SYSCALL_ARG(arg6));\ 2065 } LSS_NAME(clone)2066 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 2067 int flags, void *arg, int *parent_tidptr, 2068 void *newtls, int *child_tidptr) { 2069 long long __res; 2070 { 2071 __asm__ __volatile__(/* if (fn == NULL) 2072 * return -EINVAL; 2073 */ 2074 "testq %4,%4\n" 2075 "jz 1f\n" 2076 2077 /* if (child_stack == NULL) 2078 * return -EINVAL; 2079 */ 2080 "testq %5,%5\n" 2081 "jz 1f\n" 2082 2083 /* childstack -= 2*sizeof(void *); 2084 */ 2085 "subq $16,%5\n" 2086 2087 /* Push "arg" and "fn" onto the stack that will be 2088 * used by the child. 2089 */ 2090 "movq %7,8(%5)\n" 2091 "movq %4,0(%5)\n" 2092 2093 /* %rax = syscall(%rax = __NR_clone, 2094 * %rdi = flags, 2095 * %rsi = child_stack, 2096 * %rdx = parent_tidptr, 2097 * %r8 = new_tls, 2098 * %r10 = child_tidptr) 2099 */ 2100 "movq %2,%%rax\n" 2101 "movq %9,%%r8\n" 2102 "movq %10,%%r10\n" 2103 LSS_ENTRYPOINT 2104 2105 /* if (%rax != 0) 2106 * return; 2107 */ 2108 "testq %%rax,%%rax\n" 2109 "jnz 1f\n" 2110 2111 /* In the child. Terminate frame pointer chain. 2112 */ 2113 "xorq %%rbp,%%rbp\n" 2114 2115 /* Call "fn(arg)". 2116 */ 2117 "popq %%rax\n" 2118 "popq %%rdi\n" 2119 "call *%%rax\n" 2120 2121 /* Call _exit(%ebx). 2122 */ 2123 "movq %%rax,%%rdi\n" 2124 "movq %3,%%rax\n" 2125 LSS_ENTRYPOINT 2126 2127 /* Return to parent. 2128 */ 2129 "1:\n" 2130 : "=a" (__res) 2131 : "0"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit), 2132 "r"(LSS_SYSCALL_ARG(fn)), 2133 "S"(LSS_SYSCALL_ARG(child_stack)), 2134 "D"(LSS_SYSCALL_ARG(flags)), 2135 "r"(LSS_SYSCALL_ARG(arg)), 2136 "d"(LSS_SYSCALL_ARG(parent_tidptr)), 2137 "r"(LSS_SYSCALL_ARG(newtls)), 2138 "r"(LSS_SYSCALL_ARG(child_tidptr)) 2139 : "rsp", "memory", "r8", "r10", "r11", "rcx"); 2140 } 2141 LSS_RETURN(int, __res); 2142 } _syscall2(int,arch_prctl,int,c,void *,a)2143 LSS_INLINE _syscall2(int, arch_prctl, int, c, void *, a) 2144 2145 /* Need to make sure loff_t isn't truncated to 32-bits under x32. */ 2146 LSS_INLINE int LSS_NAME(fadvise64)(int fd, loff_t offset, loff_t len, 2147 int advice) { 2148 LSS_BODY(4, int, fadvise64, LSS_SYSCALL_ARG(fd), (uint64_t)(offset), 2149 (uint64_t)(len), LSS_SYSCALL_ARG(advice)); 2150 } 2151 LSS_NAME(restore_rt)2152 LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) { 2153 /* On x86-64, the kernel does not know how to return from 2154 * a signal handler. Instead, it relies on user space to provide a 2155 * restorer function that calls the rt_sigreturn() system call. 2156 * Unfortunately, we cannot just reference the glibc version of this 2157 * function, as glibc goes out of its way to make it inaccessible. 2158 */ 2159 long long res; 2160 __asm__ __volatile__("jmp 2f\n" 2161 ".align 16\n" 2162 "1:movq %1,%%rax\n" 2163 LSS_ENTRYPOINT 2164 "2:leaq 1b(%%rip),%0\n" 2165 : "=r" (res) 2166 : "i" (__NR_rt_sigreturn)); 2167 return (void (*)(void))(uintptr_t)res; 2168 } 2169 #elif defined(__ARM_ARCH_3__) 2170 /* Most definitions of _syscallX() neglect to mark "memory" as being 2171 * clobbered. This causes problems with compilers, that do a better job 2172 * at optimizing across __asm__ calls. 2173 * So, we just have to redefine all of the _syscallX() macros. 2174 */ 2175 #undef LSS_REG 2176 #define LSS_REG(r,a) register long __r##r __asm__("r"#r) = (long)a 2177 #undef LSS_BODY 2178 #define LSS_BODY(type,name,args...) \ 2179 register long __res_r0 __asm__("r0"); \ 2180 long __res; \ 2181 __asm__ __volatile__ (__syscall(name) \ 2182 : "=r"(__res_r0) : args : "lr", "memory"); \ 2183 __res = __res_r0; \ 2184 LSS_RETURN(type, __res) 2185 #undef _syscall0 2186 #define _syscall0(type, name) \ 2187 type LSS_NAME(name)(void) { \ 2188 LSS_BODY(type, name); \ 2189 } 2190 #undef _syscall1 2191 #define _syscall1(type, name, type1, arg1) \ 2192 type LSS_NAME(name)(type1 arg1) { \ 2193 LSS_REG(0, arg1); LSS_BODY(type, name, "r"(__r0)); \ 2194 } 2195 #undef _syscall2 2196 #define _syscall2(type, name, type1, arg1, type2, arg2) \ 2197 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 2198 LSS_REG(0, arg1); LSS_REG(1, arg2); \ 2199 LSS_BODY(type, name, "r"(__r0), "r"(__r1)); \ 2200 } 2201 #undef _syscall3 2202 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 2203 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 2204 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2205 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2)); \ 2206 } 2207 #undef _syscall4 2208 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 2209 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 2210 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2211 LSS_REG(3, arg4); \ 2212 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3)); \ 2213 } 2214 #undef _syscall5 2215 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2216 type5,arg5) \ 2217 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2218 type5 arg5) { \ 2219 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2220 LSS_REG(3, arg4); LSS_REG(4, arg5); \ 2221 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \ 2222 "r"(__r4)); \ 2223 } 2224 #undef _syscall6 2225 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2226 type5,arg5,type6,arg6) \ 2227 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2228 type5 arg5, type6 arg6) { \ 2229 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2230 LSS_REG(3, arg4); LSS_REG(4, arg5); LSS_REG(5, arg6); \ 2231 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \ 2232 "r"(__r4), "r"(__r5)); \ 2233 } LSS_NAME(clone)2234 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 2235 int flags, void *arg, int *parent_tidptr, 2236 void *newtls, int *child_tidptr) { 2237 long __res; 2238 { 2239 register int __flags __asm__("r0") = flags; 2240 register void *__stack __asm__("r1") = child_stack; 2241 register void *__ptid __asm__("r2") = parent_tidptr; 2242 register void *__tls __asm__("r3") = newtls; 2243 register int *__ctid __asm__("r4") = child_tidptr; 2244 __asm__ __volatile__(/* if (fn == NULL || child_stack == NULL) 2245 * return -EINVAL; 2246 */ 2247 "cmp %2,#0\n" 2248 "cmpne %3,#0\n" 2249 "moveq %0,%1\n" 2250 "beq 1f\n" 2251 2252 /* Push "arg" and "fn" onto the stack that will be 2253 * used by the child. 2254 */ 2255 "str %5,[%3,#-4]!\n" 2256 "str %2,[%3,#-4]!\n" 2257 2258 /* %r0 = syscall(%r0 = flags, 2259 * %r1 = child_stack, 2260 * %r2 = parent_tidptr, 2261 * %r3 = newtls, 2262 * %r4 = child_tidptr) 2263 */ 2264 __syscall(clone)"\n" 2265 2266 /* if (%r0 != 0) 2267 * return %r0; 2268 */ 2269 "movs %0,r0\n" 2270 "bne 1f\n" 2271 2272 /* In the child, now. Call "fn(arg)". 2273 */ 2274 "ldr r0,[sp, #4]\n" 2275 "mov lr,pc\n" 2276 "ldr pc,[sp]\n" 2277 2278 /* Call _exit(%r0). 2279 */ 2280 __syscall(exit)"\n" 2281 "1:\n" 2282 : "=r" (__res) 2283 : "i"(-EINVAL), 2284 "r"(fn), "r"(__stack), "r"(__flags), "r"(arg), 2285 "r"(__ptid), "r"(__tls), "r"(__ctid) 2286 : "cc", "lr", "memory"); 2287 } 2288 LSS_RETURN(int, __res); 2289 } 2290 #elif defined(__ARM_EABI__) 2291 /* Most definitions of _syscallX() neglect to mark "memory" as being 2292 * clobbered. This causes problems with compilers, that do a better job 2293 * at optimizing across __asm__ calls. 2294 * So, we just have to redefine all fo the _syscallX() macros. 2295 */ 2296 #undef LSS_REG 2297 #define LSS_REG(r,a) register long __r##r __asm__("r"#r) = (long)a 2298 #undef LSS_BODY 2299 #define LSS_BODY(type,name,args...) \ 2300 register long __res_r0 __asm__("r0"); \ 2301 long __res; \ 2302 __asm__ __volatile__ ("push {r7}\n" \ 2303 "mov r7, %1\n" \ 2304 "swi 0x0\n" \ 2305 "pop {r7}\n" \ 2306 : "=r"(__res_r0) \ 2307 : "i"(__NR_##name) , ## args \ 2308 : "lr", "memory"); \ 2309 __res = __res_r0; \ 2310 LSS_RETURN(type, __res) 2311 #undef _syscall0 2312 #define _syscall0(type, name) \ 2313 type LSS_NAME(name)(void) { \ 2314 LSS_BODY(type, name); \ 2315 } 2316 #undef _syscall1 2317 #define _syscall1(type, name, type1, arg1) \ 2318 type LSS_NAME(name)(type1 arg1) { \ 2319 LSS_REG(0, arg1); LSS_BODY(type, name, "r"(__r0)); \ 2320 } 2321 #undef _syscall2 2322 #define _syscall2(type, name, type1, arg1, type2, arg2) \ 2323 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 2324 LSS_REG(0, arg1); LSS_REG(1, arg2); \ 2325 LSS_BODY(type, name, "r"(__r0), "r"(__r1)); \ 2326 } 2327 #undef _syscall3 2328 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 2329 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 2330 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2331 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2)); \ 2332 } 2333 #undef _syscall4 2334 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 2335 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 2336 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2337 LSS_REG(3, arg4); \ 2338 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3)); \ 2339 } 2340 #undef _syscall5 2341 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2342 type5,arg5) \ 2343 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2344 type5 arg5) { \ 2345 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2346 LSS_REG(3, arg4); LSS_REG(4, arg5); \ 2347 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \ 2348 "r"(__r4)); \ 2349 } 2350 #undef _syscall6 2351 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2352 type5,arg5,type6,arg6) \ 2353 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2354 type5 arg5, type6 arg6) { \ 2355 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2356 LSS_REG(3, arg4); LSS_REG(4, arg5); LSS_REG(5, arg6); \ 2357 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \ 2358 "r"(__r4), "r"(__r5)); \ 2359 } LSS_NAME(clone)2360 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 2361 int flags, void *arg, int *parent_tidptr, 2362 void *newtls, int *child_tidptr) { 2363 long __res; 2364 { 2365 register int __flags __asm__("r0") = flags; 2366 register void *__stack __asm__("r1") = child_stack; 2367 register void *__ptid __asm__("r2") = parent_tidptr; 2368 register void *__tls __asm__("r3") = newtls; 2369 register int *__ctid __asm__("r4") = child_tidptr; 2370 __asm__ __volatile__(/* if (fn == NULL || child_stack == NULL) 2371 * return -EINVAL; 2372 */ 2373 #ifdef __thumb2__ 2374 "push {r7}\n" 2375 #endif 2376 "cmp %2,#0\n" 2377 "it ne\n" 2378 "cmpne %3,#0\n" 2379 "it eq\n" 2380 "moveq %0,%1\n" 2381 "beq 1f\n" 2382 2383 /* Push "arg" and "fn" onto the stack that will be 2384 * used by the child. 2385 */ 2386 "str %5,[%3,#-4]!\n" 2387 "str %2,[%3,#-4]!\n" 2388 2389 /* %r0 = syscall(%r0 = flags, 2390 * %r1 = child_stack, 2391 * %r2 = parent_tidptr, 2392 * %r3 = newtls, 2393 * %r4 = child_tidptr) 2394 */ 2395 "mov r7, %9\n" 2396 "swi 0x0\n" 2397 2398 /* if (%r0 != 0) 2399 * return %r0; 2400 */ 2401 "movs %0,r0\n" 2402 "bne 1f\n" 2403 2404 /* In the child, now. Call "fn(arg)". 2405 */ 2406 "ldr r0,[sp, #4]\n" 2407 2408 /* When compiling for Thumb-2 the "MOV LR,PC" here 2409 * won't work because it loads PC+4 into LR, 2410 * whereas the LDR is a 4-byte instruction. 2411 * This results in the child thread always 2412 * crashing with an "Illegal Instruction" when it 2413 * returned into the middle of the LDR instruction 2414 * The instruction sequence used instead was 2415 * recommended by 2416 * "https://wiki.edubuntu.org/ARM/Thumb2PortingHowto#Quick_Reference". 2417 */ 2418 #ifdef __thumb2__ 2419 "ldr r7,[sp]\n" 2420 "blx r7\n" 2421 #else 2422 "mov lr,pc\n" 2423 "ldr pc,[sp]\n" 2424 #endif 2425 2426 /* Call _exit(%r0). 2427 */ 2428 "mov r7, %10\n" 2429 "swi 0x0\n" 2430 "1:\n" 2431 #ifdef __thumb2__ 2432 "pop {r7}" 2433 #endif 2434 : "=r" (__res) 2435 : "i"(-EINVAL), 2436 "r"(fn), "r"(__stack), "r"(__flags), "r"(arg), 2437 "r"(__ptid), "r"(__tls), "r"(__ctid), 2438 "i"(__NR_clone), "i"(__NR_exit) 2439 #ifdef __thumb2__ 2440 : "cc", "lr", "memory"); 2441 #else 2442 : "cc", "r7", "lr", "memory"); 2443 #endif 2444 } 2445 LSS_RETURN(int, __res); 2446 } 2447 #elif defined(__aarch64__) 2448 /* Most definitions of _syscallX() neglect to mark "memory" as being 2449 * clobbered. This causes problems with compilers, that do a better job 2450 * at optimizing across __asm__ calls. 2451 * So, we just have to redefine all of the _syscallX() macros. 2452 */ 2453 #undef LSS_REG 2454 #define LSS_REG(r,a) register int64_t __r##r __asm__("x"#r) = (int64_t)a 2455 #undef LSS_BODY 2456 #define LSS_BODY(type,name,args...) \ 2457 register int64_t __res_x0 __asm__("x0"); \ 2458 int64_t __res; \ 2459 __asm__ __volatile__ ("mov x8, %1\n" \ 2460 "svc 0x0\n" \ 2461 : "=r"(__res_x0) \ 2462 : "i"(__NR_##name) , ## args \ 2463 : "x8", "memory"); \ 2464 __res = __res_x0; \ 2465 LSS_RETURN(type, __res) 2466 #undef _syscall0 2467 #define _syscall0(type, name) \ 2468 type LSS_NAME(name)(void) { \ 2469 LSS_BODY(type, name); \ 2470 } 2471 #undef _syscall1 2472 #define _syscall1(type, name, type1, arg1) \ 2473 type LSS_NAME(name)(type1 arg1) { \ 2474 LSS_REG(0, arg1); LSS_BODY(type, name, "r"(__r0)); \ 2475 } 2476 #undef _syscall2 2477 #define _syscall2(type, name, type1, arg1, type2, arg2) \ 2478 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 2479 LSS_REG(0, arg1); LSS_REG(1, arg2); \ 2480 LSS_BODY(type, name, "r"(__r0), "r"(__r1)); \ 2481 } 2482 #undef _syscall3 2483 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 2484 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 2485 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2486 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2)); \ 2487 } 2488 #undef _syscall4 2489 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 2490 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 2491 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2492 LSS_REG(3, arg4); \ 2493 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3)); \ 2494 } 2495 #undef _syscall5 2496 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2497 type5,arg5) \ 2498 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2499 type5 arg5) { \ 2500 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2501 LSS_REG(3, arg4); LSS_REG(4, arg5); \ 2502 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \ 2503 "r"(__r4)); \ 2504 } 2505 #undef _syscall6 2506 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2507 type5,arg5,type6,arg6) \ 2508 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2509 type5 arg5, type6 arg6) { \ 2510 LSS_REG(0, arg1); LSS_REG(1, arg2); LSS_REG(2, arg3); \ 2511 LSS_REG(3, arg4); LSS_REG(4, arg5); LSS_REG(5, arg6); \ 2512 LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), \ 2513 "r"(__r4), "r"(__r5)); \ 2514 } 2515 LSS_NAME(clone)2516 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 2517 int flags, void *arg, int *parent_tidptr, 2518 void *newtls, int *child_tidptr) { 2519 int64_t __res; 2520 { 2521 register uint64_t __flags __asm__("x0") = flags; 2522 register void *__stack __asm__("x1") = child_stack; 2523 register void *__ptid __asm__("x2") = parent_tidptr; 2524 register void *__tls __asm__("x3") = newtls; 2525 register int *__ctid __asm__("x4") = child_tidptr; 2526 __asm__ __volatile__(/* Push "arg" and "fn" onto the stack that will be 2527 * used by the child. 2528 */ 2529 "stp %1, %4, [%2, #-16]!\n" 2530 2531 /* %x0 = syscall(%x0 = flags, 2532 * %x1 = child_stack, 2533 * %x2 = parent_tidptr, 2534 * %x3 = newtls, 2535 * %x4 = child_tidptr) 2536 */ 2537 "mov x8, %8\n" 2538 "svc 0x0\n" 2539 2540 /* if (%r0 != 0) 2541 * return %r0; 2542 */ 2543 "mov %0, x0\n" 2544 "cbnz x0, 1f\n" 2545 2546 /* In the child, now. Call "fn(arg)". 2547 */ 2548 "ldp x1, x0, [sp], #16\n" 2549 "blr x1\n" 2550 2551 /* Call _exit(%r0). 2552 */ 2553 "mov x8, %9\n" 2554 "svc 0x0\n" 2555 "1:\n" 2556 : "=r" (__res) 2557 : "r"(fn), "r"(__stack), "r"(__flags), "r"(arg), 2558 "r"(__ptid), "r"(__tls), "r"(__ctid), 2559 "i"(__NR_clone), "i"(__NR_exit) 2560 : "cc", "x8", "memory"); 2561 } 2562 LSS_RETURN(int, __res); 2563 } 2564 #elif defined(__mips__) 2565 #undef LSS_REG 2566 #define LSS_REG(r,a) register unsigned long __r##r __asm__("$"#r) = \ 2567 (unsigned long)(a) 2568 #undef LSS_BODY 2569 #undef LSS_SYSCALL_CLOBBERS 2570 #if _MIPS_SIM == _MIPS_SIM_ABI32 2571 #define LSS_SYSCALL_CLOBBERS "$1", "$3", "$8", "$9", "$10", \ 2572 "$11", "$12", "$13", "$14", "$15", \ 2573 "$24", "$25", "hi", "lo", "memory" 2574 #else 2575 #define LSS_SYSCALL_CLOBBERS "$1", "$3", "$10", "$11", "$12", \ 2576 "$13", "$14", "$15", "$24", "$25", \ 2577 "hi", "lo", "memory" 2578 #endif 2579 #define LSS_BODY(type,name,r7,...) \ 2580 register unsigned long __v0 __asm__("$2") = __NR_##name; \ 2581 __asm__ __volatile__ ("syscall\n" \ 2582 : "=r"(__v0), r7 (__r7) \ 2583 : "0"(__v0), ##__VA_ARGS__ \ 2584 : LSS_SYSCALL_CLOBBERS); \ 2585 LSS_RETURN(type, __v0, __r7) 2586 #undef _syscall0 2587 #define _syscall0(type, name) \ 2588 type LSS_NAME(name)(void) { \ 2589 register unsigned long __r7 __asm__("$7"); \ 2590 LSS_BODY(type, name, "=r"); \ 2591 } 2592 #undef _syscall1 2593 #define _syscall1(type, name, type1, arg1) \ 2594 type LSS_NAME(name)(type1 arg1) { \ 2595 register unsigned long __r7 __asm__("$7"); \ 2596 LSS_REG(4, arg1); LSS_BODY(type, name, "=r", "r"(__r4)); \ 2597 } 2598 #undef _syscall2 2599 #define _syscall2(type, name, type1, arg1, type2, arg2) \ 2600 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 2601 register unsigned long __r7 __asm__("$7"); \ 2602 LSS_REG(4, arg1); LSS_REG(5, arg2); \ 2603 LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5)); \ 2604 } 2605 #undef _syscall3 2606 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 2607 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 2608 register unsigned long __r7 __asm__("$7"); \ 2609 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 2610 LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5), "r"(__r6)); \ 2611 } 2612 #undef _syscall4 2613 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \ 2614 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 2615 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 2616 LSS_REG(7, arg4); \ 2617 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6)); \ 2618 } 2619 #undef _syscall5 2620 #if _MIPS_SIM == _MIPS_SIM_ABI32 2621 /* The old 32bit MIPS system call API passes the fifth and sixth argument 2622 * on the stack, whereas the new APIs use registers "r8" and "r9". 2623 */ 2624 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2625 type5,arg5) \ 2626 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2627 type5 arg5) { \ 2628 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 2629 LSS_REG(7, arg4); \ 2630 register unsigned long __v0 __asm__("$2") = __NR_##name; \ 2631 __asm__ __volatile__ (".set noreorder\n" \ 2632 "subu $29, 32\n" \ 2633 "sw %5, 16($29)\n" \ 2634 "syscall\n" \ 2635 "addiu $29, 32\n" \ 2636 ".set reorder\n" \ 2637 : "+r"(__v0), "+r" (__r7) \ 2638 : "r"(__r4), "r"(__r5), \ 2639 "r"(__r6), "r" ((unsigned long)arg5) \ 2640 : "$8", "$9", "$10", "$11", "$12", \ 2641 "$13", "$14", "$15", "$24", "$25", \ 2642 "memory"); \ 2643 LSS_RETURN(type, __v0, __r7); \ 2644 } 2645 #else 2646 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2647 type5,arg5) \ 2648 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2649 type5 arg5) { \ 2650 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 2651 LSS_REG(7, arg4); LSS_REG(8, arg5); \ 2652 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6), \ 2653 "r"(__r8)); \ 2654 } 2655 #endif 2656 #undef _syscall6 2657 #if _MIPS_SIM == _MIPS_SIM_ABI32 2658 /* The old 32bit MIPS system call API passes the fifth and sixth argument 2659 * on the stack, whereas the new APIs use registers "r8" and "r9". 2660 */ 2661 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2662 type5,arg5,type6,arg6) \ 2663 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2664 type5 arg5, type6 arg6) { \ 2665 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 2666 LSS_REG(7, arg4); \ 2667 register unsigned long __v0 __asm__("$2") = __NR_##name; \ 2668 __asm__ __volatile__ (".set noreorder\n" \ 2669 "subu $29, 32\n" \ 2670 "sw %5, 16($29)\n" \ 2671 "sw %6, 20($29)\n" \ 2672 "syscall\n" \ 2673 "addiu $29, 32\n" \ 2674 ".set reorder\n" \ 2675 : "+r"(__v0), "+r" (__r7) \ 2676 : "r"(__r4), "r"(__r5), \ 2677 "r"(__r6), "r" ((unsigned long)arg5), \ 2678 "r" ((unsigned long)arg6) \ 2679 : "$8", "$9", "$10", "$11", "$12", \ 2680 "$13", "$14", "$15", "$24", "$25", \ 2681 "memory"); \ 2682 LSS_RETURN(type, __v0, __r7); \ 2683 } 2684 #else 2685 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \ 2686 type5,arg5,type6,arg6) \ 2687 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2688 type5 arg5,type6 arg6) { \ 2689 LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3); \ 2690 LSS_REG(7, arg4); LSS_REG(8, arg5); LSS_REG(9, arg6); \ 2691 LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6), \ 2692 "r"(__r8), "r"(__r9)); \ 2693 } 2694 #endif LSS_NAME(clone)2695 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 2696 int flags, void *arg, int *parent_tidptr, 2697 void *newtls, int *child_tidptr) { 2698 register unsigned long __v0 __asm__("$2"); 2699 register unsigned long __r7 __asm__("$7") = (unsigned long)newtls; 2700 { 2701 register int __flags __asm__("$4") = flags; 2702 register void *__stack __asm__("$5") = child_stack; 2703 register void *__ptid __asm__("$6") = parent_tidptr; 2704 register int *__ctid __asm__("$8") = child_tidptr; 2705 __asm__ __volatile__( 2706 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 2707 "subu $29,24\n" 2708 #elif _MIPS_SIM == _MIPS_SIM_NABI32 2709 "sub $29,16\n" 2710 #else 2711 "dsubu $29,16\n" 2712 #endif 2713 2714 /* if (fn == NULL || child_stack == NULL) 2715 * return -EINVAL; 2716 */ 2717 "li %0,%2\n" 2718 "beqz %5,1f\n" 2719 "beqz %6,1f\n" 2720 2721 /* Push "arg" and "fn" onto the stack that will be 2722 * used by the child. 2723 */ 2724 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 2725 "subu %6,32\n" 2726 "sw %5,0(%6)\n" 2727 "sw %8,4(%6)\n" 2728 #elif _MIPS_SIM == _MIPS_SIM_NABI32 2729 "sub %6,32\n" 2730 "sw %5,0(%6)\n" 2731 "sw %8,8(%6)\n" 2732 #else 2733 "dsubu %6,32\n" 2734 "sd %5,0(%6)\n" 2735 "sd %8,8(%6)\n" 2736 #endif 2737 2738 /* $7 = syscall($4 = flags, 2739 * $5 = child_stack, 2740 * $6 = parent_tidptr, 2741 * $7 = newtls, 2742 * $8 = child_tidptr) 2743 */ 2744 "li $2,%3\n" 2745 "syscall\n" 2746 2747 /* if ($7 != 0) 2748 * return $2; 2749 */ 2750 "bnez $7,1f\n" 2751 "bnez $2,1f\n" 2752 2753 /* In the child, now. Call "fn(arg)". 2754 */ 2755 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 2756 "lw $25,0($29)\n" 2757 "lw $4,4($29)\n" 2758 #elif _MIPS_SIM == _MIPS_SIM_NABI32 2759 "lw $25,0($29)\n" 2760 "lw $4,8($29)\n" 2761 #else 2762 "ld $25,0($29)\n" 2763 "ld $4,8($29)\n" 2764 #endif 2765 "jalr $25\n" 2766 2767 /* Call _exit($2) 2768 */ 2769 "move $4,$2\n" 2770 "li $2,%4\n" 2771 "syscall\n" 2772 2773 "1:\n" 2774 #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 2775 "addu $29, 24\n" 2776 #elif _MIPS_SIM == _MIPS_SIM_NABI32 2777 "add $29, 16\n" 2778 #else 2779 "daddu $29,16\n" 2780 #endif 2781 : "+r" (__v0), "+r" (__r7) 2782 : "i"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit), 2783 "r"(fn), "r"(__stack), "r"(__flags), "r"(arg), 2784 "r"(__ptid), "r"(__r7), "r"(__ctid) 2785 : "$9", "$10", "$11", "$12", "$13", "$14", "$15", 2786 "$24", "$25", "memory"); 2787 } 2788 LSS_RETURN(int, __v0, __r7); 2789 } 2790 #elif defined (__PPC__) 2791 #undef LSS_LOADARGS_0 2792 #define LSS_LOADARGS_0(name, dummy...) \ 2793 __sc_0 = __NR_##name 2794 #undef LSS_LOADARGS_1 2795 #define LSS_LOADARGS_1(name, arg1) \ 2796 LSS_LOADARGS_0(name); \ 2797 __sc_3 = (unsigned long) (arg1) 2798 #undef LSS_LOADARGS_2 2799 #define LSS_LOADARGS_2(name, arg1, arg2) \ 2800 LSS_LOADARGS_1(name, arg1); \ 2801 __sc_4 = (unsigned long) (arg2) 2802 #undef LSS_LOADARGS_3 2803 #define LSS_LOADARGS_3(name, arg1, arg2, arg3) \ 2804 LSS_LOADARGS_2(name, arg1, arg2); \ 2805 __sc_5 = (unsigned long) (arg3) 2806 #undef LSS_LOADARGS_4 2807 #define LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4) \ 2808 LSS_LOADARGS_3(name, arg1, arg2, arg3); \ 2809 __sc_6 = (unsigned long) (arg4) 2810 #undef LSS_LOADARGS_5 2811 #define LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5) \ 2812 LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4); \ 2813 __sc_7 = (unsigned long) (arg5) 2814 #undef LSS_LOADARGS_6 2815 #define LSS_LOADARGS_6(name, arg1, arg2, arg3, arg4, arg5, arg6) \ 2816 LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5); \ 2817 __sc_8 = (unsigned long) (arg6) 2818 #undef LSS_ASMINPUT_0 2819 #define LSS_ASMINPUT_0 "0" (__sc_0) 2820 #undef LSS_ASMINPUT_1 2821 #define LSS_ASMINPUT_1 LSS_ASMINPUT_0, "1" (__sc_3) 2822 #undef LSS_ASMINPUT_2 2823 #define LSS_ASMINPUT_2 LSS_ASMINPUT_1, "2" (__sc_4) 2824 #undef LSS_ASMINPUT_3 2825 #define LSS_ASMINPUT_3 LSS_ASMINPUT_2, "3" (__sc_5) 2826 #undef LSS_ASMINPUT_4 2827 #define LSS_ASMINPUT_4 LSS_ASMINPUT_3, "4" (__sc_6) 2828 #undef LSS_ASMINPUT_5 2829 #define LSS_ASMINPUT_5 LSS_ASMINPUT_4, "5" (__sc_7) 2830 #undef LSS_ASMINPUT_6 2831 #define LSS_ASMINPUT_6 LSS_ASMINPUT_5, "6" (__sc_8) 2832 #undef LSS_BODY 2833 #define LSS_BODY(nr, type, name, args...) \ 2834 long __sc_ret, __sc_err; \ 2835 { \ 2836 register unsigned long __sc_0 __asm__ ("r0"); \ 2837 register unsigned long __sc_3 __asm__ ("r3"); \ 2838 register unsigned long __sc_4 __asm__ ("r4"); \ 2839 register unsigned long __sc_5 __asm__ ("r5"); \ 2840 register unsigned long __sc_6 __asm__ ("r6"); \ 2841 register unsigned long __sc_7 __asm__ ("r7"); \ 2842 register unsigned long __sc_8 __asm__ ("r8"); \ 2843 \ 2844 LSS_LOADARGS_##nr(name, args); \ 2845 __asm__ __volatile__ \ 2846 ("sc\n\t" \ 2847 "mfcr %0" \ 2848 : "=&r" (__sc_0), \ 2849 "=&r" (__sc_3), "=&r" (__sc_4), \ 2850 "=&r" (__sc_5), "=&r" (__sc_6), \ 2851 "=&r" (__sc_7), "=&r" (__sc_8) \ 2852 : LSS_ASMINPUT_##nr \ 2853 : "cr0", "ctr", "memory", \ 2854 "r9", "r10", "r11", "r12"); \ 2855 __sc_ret = __sc_3; \ 2856 __sc_err = __sc_0; \ 2857 } \ 2858 LSS_RETURN(type, __sc_ret, __sc_err) 2859 #undef _syscall0 2860 #define _syscall0(type, name) \ 2861 type LSS_NAME(name)(void) { \ 2862 LSS_BODY(0, type, name); \ 2863 } 2864 #undef _syscall1 2865 #define _syscall1(type, name, type1, arg1) \ 2866 type LSS_NAME(name)(type1 arg1) { \ 2867 LSS_BODY(1, type, name, arg1); \ 2868 } 2869 #undef _syscall2 2870 #define _syscall2(type, name, type1, arg1, type2, arg2) \ 2871 type LSS_NAME(name)(type1 arg1, type2 arg2) { \ 2872 LSS_BODY(2, type, name, arg1, arg2); \ 2873 } 2874 #undef _syscall3 2875 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \ 2876 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) { \ 2877 LSS_BODY(3, type, name, arg1, arg2, arg3); \ 2878 } 2879 #undef _syscall4 2880 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \ 2881 type4, arg4) \ 2882 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) { \ 2883 LSS_BODY(4, type, name, arg1, arg2, arg3, arg4); \ 2884 } 2885 #undef _syscall5 2886 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \ 2887 type4, arg4, type5, arg5) \ 2888 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2889 type5 arg5) { \ 2890 LSS_BODY(5, type, name, arg1, arg2, arg3, arg4, arg5); \ 2891 } 2892 #undef _syscall6 2893 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \ 2894 type4, arg4, type5, arg5, type6, arg6) \ 2895 type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \ 2896 type5 arg5, type6 arg6) { \ 2897 LSS_BODY(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6); \ 2898 } 2899 /* clone function adapted from glibc 2.3.6 clone.S */ 2900 /* TODO(csilvers): consider wrapping some args up in a struct, like we 2901 * do for i386's _syscall6, so we can compile successfully on gcc 2.95 2902 */ LSS_NAME(clone)2903 LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 2904 int flags, void *arg, int *parent_tidptr, 2905 void *newtls, int *child_tidptr) { 2906 long __ret, __err; 2907 { 2908 register int (*__fn)(void *) __asm__ ("r8") = fn; 2909 register void *__cstack __asm__ ("r4") = child_stack; 2910 register int __flags __asm__ ("r3") = flags; 2911 register void * __arg __asm__ ("r9") = arg; 2912 register int * __ptidptr __asm__ ("r5") = parent_tidptr; 2913 register void * __newtls __asm__ ("r6") = newtls; 2914 register int * __ctidptr __asm__ ("r7") = child_tidptr; 2915 __asm__ __volatile__( 2916 /* check for fn == NULL 2917 * and child_stack == NULL 2918 */ 2919 "cmpwi cr0, %6, 0\n\t" 2920 "cmpwi cr1, %7, 0\n\t" 2921 "cror cr0*4+eq, cr1*4+eq, cr0*4+eq\n\t" 2922 "beq- cr0, 1f\n\t" 2923 2924 /* set up stack frame for child */ 2925 "clrrwi %7, %7, 4\n\t" 2926 "li 0, 0\n\t" 2927 "stwu 0, -16(%7)\n\t" 2928 2929 /* fn, arg, child_stack are saved across the syscall: r28-30 */ 2930 "mr 28, %6\n\t" 2931 "mr 29, %7\n\t" 2932 "mr 27, %9\n\t" 2933 2934 /* syscall */ 2935 "li 0, %4\n\t" 2936 /* flags already in r3 2937 * child_stack already in r4 2938 * ptidptr already in r5 2939 * newtls already in r6 2940 * ctidptr already in r7 2941 */ 2942 "sc\n\t" 2943 2944 /* Test if syscall was successful */ 2945 "cmpwi cr1, 3, 0\n\t" 2946 "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t" 2947 "bne- cr1, 1f\n\t" 2948 2949 /* Do the function call */ 2950 "mtctr 28\n\t" 2951 "mr 3, 27\n\t" 2952 "bctrl\n\t" 2953 2954 /* Call _exit(r3) */ 2955 "li 0, %5\n\t" 2956 "sc\n\t" 2957 2958 /* Return to parent */ 2959 "1:\n" 2960 "mfcr %1\n\t" 2961 "mr %0, 3\n\t" 2962 : "=r" (__ret), "=r" (__err) 2963 : "0" (-1), "1" (EINVAL), 2964 "i" (__NR_clone), "i" (__NR_exit), 2965 "r" (__fn), "r" (__cstack), "r" (__flags), 2966 "r" (__arg), "r" (__ptidptr), "r" (__newtls), 2967 "r" (__ctidptr) 2968 : "cr0", "cr1", "memory", "ctr", 2969 "r0", "r29", "r27", "r28"); 2970 } 2971 LSS_RETURN(int, __ret, __err); 2972 } 2973 #endif 2974 #define __NR__exit __NR_exit 2975 #define __NR__gettid __NR_gettid 2976 #define __NR__mremap __NR_mremap _syscall1(void *,brk,void *,e)2977 LSS_INLINE _syscall1(void *, brk, void *, e) 2978 LSS_INLINE _syscall1(int, chdir, const char *,p) 2979 LSS_INLINE _syscall1(int, close, int, f) 2980 LSS_INLINE _syscall2(int, clock_getres, int, c, 2981 struct kernel_timespec*, t) 2982 LSS_INLINE _syscall2(int, clock_gettime, int, c, 2983 struct kernel_timespec*, t) 2984 LSS_INLINE _syscall1(int, dup, int, f) 2985 #if !defined(__aarch64__) 2986 // The dup2 syscall has been deprecated on aarch64. We polyfill it below. 2987 LSS_INLINE _syscall2(int, dup2, int, s, 2988 int, d) 2989 #endif 2990 LSS_INLINE _syscall3(int, execve, const char*, f, 2991 const char*const*,a,const char*const*, e) 2992 LSS_INLINE _syscall1(int, _exit, int, e) 2993 LSS_INLINE _syscall1(int, exit_group, int, e) 2994 LSS_INLINE _syscall3(int, fcntl, int, f, 2995 int, c, long, a) 2996 #if !defined(__aarch64__) 2997 // The fork syscall has been deprecated on aarch64. We polyfill it below. 2998 LSS_INLINE _syscall0(pid_t, fork) 2999 #endif 3000 LSS_INLINE _syscall2(int, fstat, int, f, 3001 struct kernel_stat*, b) 3002 LSS_INLINE _syscall2(int, fstatfs, int, f, 3003 struct kernel_statfs*, b) 3004 #if defined(__x86_64__) 3005 /* Need to make sure off_t isn't truncated to 32-bits under x32. */ 3006 LSS_INLINE int LSS_NAME(ftruncate)(int f, off_t l) { 3007 LSS_BODY(2, int, ftruncate, LSS_SYSCALL_ARG(f), (uint64_t)(l)); 3008 } 3009 #else 3010 LSS_INLINE _syscall2(int, ftruncate, int, f, 3011 off_t, l) 3012 #endif _syscall4(int,futex,int *,a,int,o,int,v,struct kernel_timespec *,t)3013 LSS_INLINE _syscall4(int, futex, int*, a, 3014 int, o, int, v, 3015 struct kernel_timespec*, t) 3016 LSS_INLINE _syscall3(int, getdents, int, f, 3017 struct kernel_dirent*, d, int, c) 3018 LSS_INLINE _syscall3(int, getdents64, int, f, 3019 struct kernel_dirent64*, d, int, c) 3020 LSS_INLINE _syscall0(gid_t, getegid) 3021 LSS_INLINE _syscall0(uid_t, geteuid) 3022 #if !defined(__aarch64__) 3023 // The getgprp syscall has been deprecated on aarch64. 3024 LSS_INLINE _syscall0(pid_t, getpgrp) 3025 #endif 3026 LSS_INLINE _syscall0(pid_t, getpid) 3027 LSS_INLINE _syscall0(pid_t, getppid) 3028 LSS_INLINE _syscall2(int, getpriority, int, a, 3029 int, b) 3030 LSS_INLINE _syscall3(int, getresgid, gid_t *, r, 3031 gid_t *, e, gid_t *, s) 3032 LSS_INLINE _syscall3(int, getresuid, uid_t *, r, 3033 uid_t *, e, uid_t *, s) 3034 #if !defined(__ARM_EABI__) 3035 LSS_INLINE _syscall2(int, getrlimit, int, r, 3036 struct kernel_rlimit*, l) 3037 #endif 3038 LSS_INLINE _syscall1(pid_t, getsid, pid_t, p) 3039 LSS_INLINE _syscall0(pid_t, _gettid) 3040 LSS_INLINE _syscall2(pid_t, gettimeofday, struct kernel_timeval*, t, 3041 void*, tz) 3042 LSS_INLINE _syscall5(int, setxattr, const char *,p, 3043 const char *, n, const void *,v, 3044 size_t, s, int, f) 3045 LSS_INLINE _syscall5(int, lsetxattr, const char *,p, 3046 const char *, n, const void *,v, 3047 size_t, s, int, f) 3048 LSS_INLINE _syscall4(ssize_t, getxattr, const char *,p, 3049 const char *, n, void *, v, size_t, s) 3050 LSS_INLINE _syscall4(ssize_t, lgetxattr, const char *,p, 3051 const char *, n, void *, v, size_t, s) 3052 LSS_INLINE _syscall3(ssize_t, listxattr, const char *,p, 3053 char *, l, size_t, s) 3054 LSS_INLINE _syscall3(ssize_t, llistxattr, const char *,p, 3055 char *, l, size_t, s) 3056 LSS_INLINE _syscall3(int, ioctl, int, d, 3057 int, r, void *, a) 3058 LSS_INLINE _syscall2(int, ioprio_get, int, which, 3059 int, who) 3060 LSS_INLINE _syscall3(int, ioprio_set, int, which, 3061 int, who, int, ioprio) 3062 LSS_INLINE _syscall2(int, kill, pid_t, p, 3063 int, s) 3064 #if defined(__x86_64__) 3065 /* Need to make sure off_t isn't truncated to 32-bits under x32. */ 3066 LSS_INLINE off_t LSS_NAME(lseek)(int f, off_t o, int w) { 3067 _LSS_BODY(3, off_t, lseek, off_t, LSS_SYSCALL_ARG(f), (uint64_t)(o), 3068 LSS_SYSCALL_ARG(w)); 3069 } 3070 #else 3071 LSS_INLINE _syscall3(off_t, lseek, int, f, 3072 off_t, o, int, w) 3073 #endif _syscall2(int,munmap,void *,s,size_t,l)3074 LSS_INLINE _syscall2(int, munmap, void*, s, 3075 size_t, l) 3076 LSS_INLINE _syscall6(long, move_pages, pid_t, p, 3077 unsigned long, n, void **,g, int *, d, 3078 int *, s, int, f) 3079 LSS_INLINE _syscall3(int, mprotect, const void *,a, 3080 size_t, l, int, p) 3081 LSS_INLINE _syscall5(void*, _mremap, void*, o, 3082 size_t, os, size_t, ns, 3083 unsigned long, f, void *, a) 3084 #if !defined(__aarch64__) 3085 // The open and poll syscalls have been deprecated on aarch64. We polyfill 3086 // them below. 3087 LSS_INLINE _syscall3(int, open, const char*, p, 3088 int, f, int, m) 3089 LSS_INLINE _syscall3(int, poll, struct kernel_pollfd*, u, 3090 unsigned int, n, int, t) 3091 #endif 3092 LSS_INLINE _syscall5(int, prctl, int, option, 3093 unsigned long, arg2, 3094 unsigned long, arg3, 3095 unsigned long, arg4, 3096 unsigned long, arg5) 3097 LSS_INLINE _syscall4(long, ptrace, int, r, 3098 pid_t, p, void *, a, void *, d) 3099 #if defined(__NR_quotactl) 3100 // Defined on x86_64 / i386 only 3101 LSS_INLINE _syscall4(int, quotactl, int, cmd, const char *, special, 3102 int, id, caddr_t, addr) 3103 #endif 3104 LSS_INLINE _syscall3(ssize_t, read, int, f, 3105 void *, b, size_t, c) 3106 #if !defined(__aarch64__) 3107 // The readlink syscall has been deprecated on aarch64. We polyfill below. 3108 LSS_INLINE _syscall3(int, readlink, const char*, p, 3109 char*, b, size_t, s) 3110 #endif 3111 LSS_INLINE _syscall4(int, rt_sigaction, int, s, 3112 const struct kernel_sigaction*, a, 3113 struct kernel_sigaction*, o, size_t, c) 3114 LSS_INLINE _syscall2(int, rt_sigpending, struct kernel_sigset_t *, s, 3115 size_t, c) 3116 LSS_INLINE _syscall4(int, rt_sigprocmask, int, h, 3117 const struct kernel_sigset_t*, s, 3118 struct kernel_sigset_t*, o, size_t, c) 3119 LSS_INLINE _syscall2(int, rt_sigsuspend, 3120 const struct kernel_sigset_t*, s, size_t, c) 3121 LSS_INLINE _syscall3(int, sched_getaffinity,pid_t, p, 3122 unsigned int, l, unsigned long *, m) 3123 LSS_INLINE _syscall3(int, sched_setaffinity,pid_t, p, 3124 unsigned int, l, unsigned long *, m) 3125 LSS_INLINE _syscall0(int, sched_yield) 3126 LSS_INLINE _syscall1(long, set_tid_address, int *, t) 3127 LSS_INLINE _syscall1(int, setfsgid, gid_t, g) 3128 LSS_INLINE _syscall1(int, setfsuid, uid_t, u) 3129 LSS_INLINE _syscall1(int, setuid, uid_t, u) 3130 LSS_INLINE _syscall1(int, setgid, gid_t, g) 3131 LSS_INLINE _syscall2(int, setpgid, pid_t, p, 3132 pid_t, g) 3133 LSS_INLINE _syscall3(int, setpriority, int, a, 3134 int, b, int, p) 3135 LSS_INLINE _syscall3(int, setresgid, gid_t, r, 3136 gid_t, e, gid_t, s) 3137 LSS_INLINE _syscall3(int, setresuid, uid_t, r, 3138 uid_t, e, uid_t, s) 3139 LSS_INLINE _syscall2(int, setrlimit, int, r, 3140 const struct kernel_rlimit*, l) 3141 LSS_INLINE _syscall0(pid_t, setsid) 3142 LSS_INLINE _syscall2(int, sigaltstack, const stack_t*, s, 3143 const stack_t*, o) 3144 #if defined(__NR_sigreturn) 3145 LSS_INLINE _syscall1(int, sigreturn, unsigned long, u) 3146 #endif 3147 #if !defined(__aarch64__) 3148 // The stat syscall has been deprecated on aarch64. We polyfill it below. 3149 LSS_INLINE _syscall2(int, stat, const char*, f, 3150 struct kernel_stat*, b) 3151 #endif 3152 LSS_INLINE _syscall2(int, statfs, const char*, f, 3153 struct kernel_statfs*, b) 3154 LSS_INLINE _syscall3(int, tgkill, pid_t, p, 3155 pid_t, t, int, s) 3156 LSS_INLINE _syscall2(int, tkill, pid_t, p, 3157 int, s) 3158 #if !defined(__aarch64__) 3159 // The unlink syscall has been deprecated on aarch64. We polyfill it below. 3160 LSS_INLINE _syscall1(int, unlink, const char*, f) 3161 #endif 3162 LSS_INLINE _syscall3(ssize_t, write, int, f, 3163 const void *, b, size_t, c) 3164 LSS_INLINE _syscall3(ssize_t, writev, int, f, 3165 const struct kernel_iovec*, v, size_t, c) 3166 #if defined(__NR_getcpu) 3167 LSS_INLINE _syscall3(long, getcpu, unsigned *, cpu, 3168 unsigned *, node, void *, unused) 3169 #endif 3170 #if defined(__x86_64__) || \ 3171 (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32) 3172 LSS_INLINE _syscall3(int, recvmsg, int, s, 3173 struct kernel_msghdr*, m, int, f) 3174 LSS_INLINE _syscall3(int, sendmsg, int, s, 3175 const struct kernel_msghdr*, m, int, f) 3176 LSS_INLINE _syscall6(int, sendto, int, s, 3177 const void*, m, size_t, l, 3178 int, f, 3179 const struct kernel_sockaddr*, a, int, t) 3180 LSS_INLINE _syscall2(int, shutdown, int, s, 3181 int, h) 3182 LSS_INLINE _syscall3(int, socket, int, d, 3183 int, t, int, p) 3184 LSS_INLINE _syscall4(int, socketpair, int, d, 3185 int, t, int, p, int*, s) 3186 #endif 3187 #if defined(__x86_64__) 3188 /* Need to make sure loff_t isn't truncated to 32-bits under x32. */ 3189 LSS_INLINE int LSS_NAME(fallocate)(int f, int mode, loff_t offset, 3190 loff_t len) { 3191 LSS_BODY(4, int, fallocate, LSS_SYSCALL_ARG(f), LSS_SYSCALL_ARG(mode), 3192 (uint64_t)(offset), (uint64_t)(len)); 3193 } 3194 LSS_NAME(getresgid32)3195 LSS_INLINE int LSS_NAME(getresgid32)(gid_t *rgid, 3196 gid_t *egid, 3197 gid_t *sgid) { 3198 return LSS_NAME(getresgid)(rgid, egid, sgid); 3199 } 3200 LSS_NAME(getresuid32)3201 LSS_INLINE int LSS_NAME(getresuid32)(uid_t *ruid, 3202 uid_t *euid, 3203 uid_t *suid) { 3204 return LSS_NAME(getresuid)(ruid, euid, suid); 3205 } 3206 3207 /* Need to make sure __off64_t isn't truncated to 32-bits under x32. */ LSS_NAME(mmap)3208 LSS_INLINE void* LSS_NAME(mmap)(void *s, size_t l, int p, int f, int d, 3209 int64_t o) { 3210 LSS_BODY(6, void*, mmap, LSS_SYSCALL_ARG(s), LSS_SYSCALL_ARG(l), 3211 LSS_SYSCALL_ARG(p), LSS_SYSCALL_ARG(f), 3212 LSS_SYSCALL_ARG(d), (uint64_t)(o)); 3213 } 3214 _syscall4(int,newfstatat,int,d,const char *,p,struct kernel_stat *,b,int,f)3215 LSS_INLINE _syscall4(int, newfstatat, int, d, 3216 const char *, p, 3217 struct kernel_stat*, b, int, f) 3218 3219 LSS_INLINE int LSS_NAME(setfsgid32)(gid_t gid) { 3220 return LSS_NAME(setfsgid)(gid); 3221 } 3222 LSS_NAME(setfsuid32)3223 LSS_INLINE int LSS_NAME(setfsuid32)(uid_t uid) { 3224 return LSS_NAME(setfsuid)(uid); 3225 } 3226 LSS_NAME(setresgid32)3227 LSS_INLINE int LSS_NAME(setresgid32)(gid_t rgid, gid_t egid, gid_t sgid) { 3228 return LSS_NAME(setresgid)(rgid, egid, sgid); 3229 } 3230 LSS_NAME(setresuid32)3231 LSS_INLINE int LSS_NAME(setresuid32)(uid_t ruid, uid_t euid, uid_t suid) { 3232 return LSS_NAME(setresuid)(ruid, euid, suid); 3233 } 3234 LSS_NAME(sigaction)3235 LSS_INLINE int LSS_NAME(sigaction)(int signum, 3236 const struct kernel_sigaction *act, 3237 struct kernel_sigaction *oldact) { 3238 /* On x86_64, the kernel requires us to always set our own 3239 * SA_RESTORER in order to be able to return from a signal handler. 3240 * This function must have a "magic" signature that the "gdb" 3241 * (and maybe the kernel?) can recognize. 3242 */ 3243 if (act != NULL && !(act->sa_flags & SA_RESTORER)) { 3244 struct kernel_sigaction a = *act; 3245 a.sa_flags |= SA_RESTORER; 3246 a.sa_restorer = LSS_NAME(restore_rt)(); 3247 return LSS_NAME(rt_sigaction)(signum, &a, oldact, 3248 (KERNEL_NSIG+7)/8); 3249 } else { 3250 return LSS_NAME(rt_sigaction)(signum, act, oldact, 3251 (KERNEL_NSIG+7)/8); 3252 } 3253 } 3254 LSS_NAME(sigpending)3255 LSS_INLINE int LSS_NAME(sigpending)(struct kernel_sigset_t *set) { 3256 return LSS_NAME(rt_sigpending)(set, (KERNEL_NSIG+7)/8); 3257 } 3258 LSS_NAME(sigprocmask)3259 LSS_INLINE int LSS_NAME(sigprocmask)(int how, 3260 const struct kernel_sigset_t *set, 3261 struct kernel_sigset_t *oldset) { 3262 return LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8); 3263 } 3264 LSS_NAME(sigsuspend)3265 LSS_INLINE int LSS_NAME(sigsuspend)(const struct kernel_sigset_t *set) { 3266 return LSS_NAME(rt_sigsuspend)(set, (KERNEL_NSIG+7)/8); 3267 } 3268 #endif 3269 #if defined(__x86_64__) || defined(__ARM_ARCH_3__) || \ 3270 defined(__ARM_EABI__) || defined(__aarch64__) || \ 3271 (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32) _syscall4(pid_t,wait4,pid_t,p,int *,s,int,o,struct kernel_rusage *,r)3272 LSS_INLINE _syscall4(pid_t, wait4, pid_t, p, 3273 int*, s, int, o, 3274 struct kernel_rusage*, r) 3275 3276 LSS_INLINE pid_t LSS_NAME(waitpid)(pid_t pid, int *status, int options){ 3277 return LSS_NAME(wait4)(pid, status, options, 0); 3278 } 3279 #endif 3280 #if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) _syscall4(int,openat,int,d,const char *,p,int,f,int,m)3281 LSS_INLINE _syscall4(int, openat, int, d, const char *, p, int, f, int, m) 3282 LSS_INLINE _syscall3(int, unlinkat, int, d, const char *, p, int, f) 3283 #endif 3284 #if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) 3285 #define __NR__getresgid32 __NR_getresgid32 3286 #define __NR__getresuid32 __NR_getresuid32 3287 #define __NR__setfsgid32 __NR_setfsgid32 3288 #define __NR__setfsuid32 __NR_setfsuid32 3289 #define __NR__setresgid32 __NR_setresgid32 3290 #define __NR__setresuid32 __NR_setresuid32 3291 #if defined(__ARM_EABI__) 3292 LSS_INLINE _syscall2(int, ugetrlimit, int, r, 3293 struct kernel_rlimit*, l) 3294 #endif 3295 LSS_INLINE _syscall3(int, _getresgid32, gid_t *, r, 3296 gid_t *, e, gid_t *, s) 3297 LSS_INLINE _syscall3(int, _getresuid32, uid_t *, r, 3298 uid_t *, e, uid_t *, s) 3299 LSS_INLINE _syscall1(int, _setfsgid32, gid_t, f) 3300 LSS_INLINE _syscall1(int, _setfsuid32, uid_t, f) 3301 LSS_INLINE _syscall3(int, _setresgid32, gid_t, r, 3302 gid_t, e, gid_t, s) 3303 LSS_INLINE _syscall3(int, _setresuid32, uid_t, r, 3304 uid_t, e, uid_t, s) 3305 3306 LSS_INLINE int LSS_NAME(getresgid32)(gid_t *rgid, 3307 gid_t *egid, 3308 gid_t *sgid) { 3309 int rc; 3310 if ((rc = LSS_NAME(_getresgid32)(rgid, egid, sgid)) < 0 && 3311 LSS_ERRNO == ENOSYS) { 3312 if ((rgid == NULL) || (egid == NULL) || (sgid == NULL)) { 3313 return EFAULT; 3314 } 3315 // Clear the high bits first, since getresgid only sets 16 bits 3316 *rgid = *egid = *sgid = 0; 3317 rc = LSS_NAME(getresgid)(rgid, egid, sgid); 3318 } 3319 return rc; 3320 } 3321 LSS_NAME(getresuid32)3322 LSS_INLINE int LSS_NAME(getresuid32)(uid_t *ruid, 3323 uid_t *euid, 3324 uid_t *suid) { 3325 int rc; 3326 if ((rc = LSS_NAME(_getresuid32)(ruid, euid, suid)) < 0 && 3327 LSS_ERRNO == ENOSYS) { 3328 if ((ruid == NULL) || (euid == NULL) || (suid == NULL)) { 3329 return EFAULT; 3330 } 3331 // Clear the high bits first, since getresuid only sets 16 bits 3332 *ruid = *euid = *suid = 0; 3333 rc = LSS_NAME(getresuid)(ruid, euid, suid); 3334 } 3335 return rc; 3336 } 3337 LSS_NAME(setfsgid32)3338 LSS_INLINE int LSS_NAME(setfsgid32)(gid_t gid) { 3339 int rc; 3340 if ((rc = LSS_NAME(_setfsgid32)(gid)) < 0 && 3341 LSS_ERRNO == ENOSYS) { 3342 if ((unsigned int)gid & ~0xFFFFu) { 3343 rc = EINVAL; 3344 } else { 3345 rc = LSS_NAME(setfsgid)(gid); 3346 } 3347 } 3348 return rc; 3349 } 3350 LSS_NAME(setfsuid32)3351 LSS_INLINE int LSS_NAME(setfsuid32)(uid_t uid) { 3352 int rc; 3353 if ((rc = LSS_NAME(_setfsuid32)(uid)) < 0 && 3354 LSS_ERRNO == ENOSYS) { 3355 if ((unsigned int)uid & ~0xFFFFu) { 3356 rc = EINVAL; 3357 } else { 3358 rc = LSS_NAME(setfsuid)(uid); 3359 } 3360 } 3361 return rc; 3362 } 3363 LSS_NAME(setresgid32)3364 LSS_INLINE int LSS_NAME(setresgid32)(gid_t rgid, gid_t egid, gid_t sgid) { 3365 int rc; 3366 if ((rc = LSS_NAME(_setresgid32)(rgid, egid, sgid)) < 0 && 3367 LSS_ERRNO == ENOSYS) { 3368 if ((unsigned int)rgid & ~0xFFFFu || 3369 (unsigned int)egid & ~0xFFFFu || 3370 (unsigned int)sgid & ~0xFFFFu) { 3371 rc = EINVAL; 3372 } else { 3373 rc = LSS_NAME(setresgid)(rgid, egid, sgid); 3374 } 3375 } 3376 return rc; 3377 } 3378 LSS_NAME(setresuid32)3379 LSS_INLINE int LSS_NAME(setresuid32)(uid_t ruid, uid_t euid, uid_t suid) { 3380 int rc; 3381 if ((rc = LSS_NAME(_setresuid32)(ruid, euid, suid)) < 0 && 3382 LSS_ERRNO == ENOSYS) { 3383 if ((unsigned int)ruid & ~0xFFFFu || 3384 (unsigned int)euid & ~0xFFFFu || 3385 (unsigned int)suid & ~0xFFFFu) { 3386 rc = EINVAL; 3387 } else { 3388 rc = LSS_NAME(setresuid)(ruid, euid, suid); 3389 } 3390 } 3391 return rc; 3392 } 3393 #endif LSS_NAME(sigemptyset)3394 LSS_INLINE int LSS_NAME(sigemptyset)(struct kernel_sigset_t *set) { 3395 memset(&set->sig, 0, sizeof(set->sig)); 3396 return 0; 3397 } 3398 LSS_NAME(sigfillset)3399 LSS_INLINE int LSS_NAME(sigfillset)(struct kernel_sigset_t *set) { 3400 memset(&set->sig, -1, sizeof(set->sig)); 3401 return 0; 3402 } 3403 LSS_NAME(sigaddset)3404 LSS_INLINE int LSS_NAME(sigaddset)(struct kernel_sigset_t *set, 3405 int signum) { 3406 if (signum < 1 || signum > (int)(8*sizeof(set->sig))) { 3407 LSS_ERRNO = EINVAL; 3408 return -1; 3409 } else { 3410 set->sig[(signum - 1)/(8*sizeof(set->sig[0]))] 3411 |= 1UL << ((signum - 1) % (8*sizeof(set->sig[0]))); 3412 return 0; 3413 } 3414 } 3415 LSS_NAME(sigdelset)3416 LSS_INLINE int LSS_NAME(sigdelset)(struct kernel_sigset_t *set, 3417 int signum) { 3418 if (signum < 1 || signum > (int)(8*sizeof(set->sig))) { 3419 LSS_ERRNO = EINVAL; 3420 return -1; 3421 } else { 3422 set->sig[(signum - 1)/(8*sizeof(set->sig[0]))] 3423 &= ~(1UL << ((signum - 1) % (8*sizeof(set->sig[0])))); 3424 return 0; 3425 } 3426 } 3427 LSS_NAME(sigismember)3428 LSS_INLINE int LSS_NAME(sigismember)(struct kernel_sigset_t *set, 3429 int signum) { 3430 if (signum < 1 || signum > (int)(8*sizeof(set->sig))) { 3431 LSS_ERRNO = EINVAL; 3432 return -1; 3433 } else { 3434 return !!(set->sig[(signum - 1)/(8*sizeof(set->sig[0]))] & 3435 (1UL << ((signum - 1) % (8*sizeof(set->sig[0]))))); 3436 } 3437 } 3438 #if defined(__i386__) || defined(__ARM_ARCH_3__) || \ 3439 defined(__ARM_EABI__) || \ 3440 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || defined(__PPC__) 3441 #define __NR__sigaction __NR_sigaction 3442 #define __NR__sigpending __NR_sigpending 3443 #define __NR__sigprocmask __NR_sigprocmask 3444 #define __NR__sigsuspend __NR_sigsuspend 3445 #define __NR__socketcall __NR_socketcall _syscall2(int,fstat64,int,f,struct kernel_stat64 *,b)3446 LSS_INLINE _syscall2(int, fstat64, int, f, 3447 struct kernel_stat64 *, b) 3448 LSS_INLINE _syscall5(int, _llseek, uint, fd, 3449 unsigned long, hi, unsigned long, lo, 3450 loff_t *, res, uint, wh) 3451 #if !defined(__ARM_EABI__) 3452 LSS_INLINE _syscall1(void*, mmap, void*, a) 3453 #endif 3454 LSS_INLINE _syscall6(void*, mmap2, void*, s, 3455 size_t, l, int, p, 3456 int, f, int, d, 3457 off_t, o) 3458 LSS_INLINE _syscall3(int, _sigaction, int, s, 3459 const struct kernel_old_sigaction*, a, 3460 struct kernel_old_sigaction*, o) 3461 LSS_INLINE _syscall1(int, _sigpending, unsigned long*, s) 3462 LSS_INLINE _syscall3(int, _sigprocmask, int, h, 3463 const unsigned long*, s, 3464 unsigned long*, o) 3465 #ifdef __PPC__ 3466 LSS_INLINE _syscall1(int, _sigsuspend, unsigned long, s) 3467 #else 3468 LSS_INLINE _syscall3(int, _sigsuspend, const void*, a, 3469 int, b, 3470 unsigned long, s) 3471 #endif 3472 LSS_INLINE _syscall2(int, stat64, const char *, p, 3473 struct kernel_stat64 *, b) 3474 3475 LSS_INLINE int LSS_NAME(sigaction)(int signum, 3476 const struct kernel_sigaction *act, 3477 struct kernel_sigaction *oldact) { 3478 int old_errno = LSS_ERRNO; 3479 int rc; 3480 struct kernel_sigaction a; 3481 if (act != NULL) { 3482 a = *act; 3483 #ifdef __i386__ 3484 /* On i386, the kernel requires us to always set our own 3485 * SA_RESTORER when using realtime signals. Otherwise, it does not 3486 * know how to return from a signal handler. This function must have 3487 * a "magic" signature that the "gdb" (and maybe the kernel?) can 3488 * recognize. 3489 * Apparently, a SA_RESTORER is implicitly set by the kernel, when 3490 * using non-realtime signals. 3491 * 3492 * TODO: Test whether ARM needs a restorer 3493 */ 3494 if (!(a.sa_flags & SA_RESTORER)) { 3495 a.sa_flags |= SA_RESTORER; 3496 a.sa_restorer = (a.sa_flags & SA_SIGINFO) 3497 ? LSS_NAME(restore_rt)() : LSS_NAME(restore)(); 3498 } 3499 #endif 3500 } 3501 rc = LSS_NAME(rt_sigaction)(signum, act ? &a : act, oldact, 3502 (KERNEL_NSIG+7)/8); 3503 if (rc < 0 && LSS_ERRNO == ENOSYS) { 3504 struct kernel_old_sigaction oa, ooa, *ptr_a = &oa, *ptr_oa = &ooa; 3505 if (!act) { 3506 ptr_a = NULL; 3507 } else { 3508 oa.sa_handler_ = act->sa_handler_; 3509 memcpy(&oa.sa_mask, &act->sa_mask, sizeof(oa.sa_mask)); 3510 #ifndef __mips__ 3511 oa.sa_restorer = act->sa_restorer; 3512 #endif 3513 oa.sa_flags = act->sa_flags; 3514 } 3515 if (!oldact) { 3516 ptr_oa = NULL; 3517 } 3518 LSS_ERRNO = old_errno; 3519 rc = LSS_NAME(_sigaction)(signum, ptr_a, ptr_oa); 3520 if (rc == 0 && oldact) { 3521 if (act) { 3522 memcpy(oldact, act, sizeof(*act)); 3523 } else { 3524 memset(oldact, 0, sizeof(*oldact)); 3525 } 3526 oldact->sa_handler_ = ptr_oa->sa_handler_; 3527 oldact->sa_flags = ptr_oa->sa_flags; 3528 memcpy(&oldact->sa_mask, &ptr_oa->sa_mask, sizeof(ptr_oa->sa_mask)); 3529 #ifndef __mips__ 3530 oldact->sa_restorer = ptr_oa->sa_restorer; 3531 #endif 3532 } 3533 } 3534 return rc; 3535 } 3536 LSS_NAME(sigpending)3537 LSS_INLINE int LSS_NAME(sigpending)(struct kernel_sigset_t *set) { 3538 int old_errno = LSS_ERRNO; 3539 int rc = LSS_NAME(rt_sigpending)(set, (KERNEL_NSIG+7)/8); 3540 if (rc < 0 && LSS_ERRNO == ENOSYS) { 3541 LSS_ERRNO = old_errno; 3542 LSS_NAME(sigemptyset)(set); 3543 rc = LSS_NAME(_sigpending)(&set->sig[0]); 3544 } 3545 return rc; 3546 } 3547 LSS_NAME(sigprocmask)3548 LSS_INLINE int LSS_NAME(sigprocmask)(int how, 3549 const struct kernel_sigset_t *set, 3550 struct kernel_sigset_t *oldset) { 3551 int olderrno = LSS_ERRNO; 3552 int rc = LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8); 3553 if (rc < 0 && LSS_ERRNO == ENOSYS) { 3554 LSS_ERRNO = olderrno; 3555 if (oldset) { 3556 LSS_NAME(sigemptyset)(oldset); 3557 } 3558 rc = LSS_NAME(_sigprocmask)(how, 3559 set ? &set->sig[0] : NULL, 3560 oldset ? &oldset->sig[0] : NULL); 3561 } 3562 return rc; 3563 } 3564 LSS_NAME(sigsuspend)3565 LSS_INLINE int LSS_NAME(sigsuspend)(const struct kernel_sigset_t *set) { 3566 int olderrno = LSS_ERRNO; 3567 int rc = LSS_NAME(rt_sigsuspend)(set, (KERNEL_NSIG+7)/8); 3568 if (rc < 0 && LSS_ERRNO == ENOSYS) { 3569 LSS_ERRNO = olderrno; 3570 rc = LSS_NAME(_sigsuspend)( 3571 #ifndef __PPC__ 3572 set, 0, 3573 #endif 3574 set->sig[0]); 3575 } 3576 return rc; 3577 } 3578 #endif 3579 #if defined(__PPC__) 3580 #undef LSS_SC_LOADARGS_0 3581 #define LSS_SC_LOADARGS_0(dummy...) 3582 #undef LSS_SC_LOADARGS_1 3583 #define LSS_SC_LOADARGS_1(arg1) \ 3584 __sc_4 = (unsigned long) (arg1) 3585 #undef LSS_SC_LOADARGS_2 3586 #define LSS_SC_LOADARGS_2(arg1, arg2) \ 3587 LSS_SC_LOADARGS_1(arg1); \ 3588 __sc_5 = (unsigned long) (arg2) 3589 #undef LSS_SC_LOADARGS_3 3590 #define LSS_SC_LOADARGS_3(arg1, arg2, arg3) \ 3591 LSS_SC_LOADARGS_2(arg1, arg2); \ 3592 __sc_6 = (unsigned long) (arg3) 3593 #undef LSS_SC_LOADARGS_4 3594 #define LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4) \ 3595 LSS_SC_LOADARGS_3(arg1, arg2, arg3); \ 3596 __sc_7 = (unsigned long) (arg4) 3597 #undef LSS_SC_LOADARGS_5 3598 #define LSS_SC_LOADARGS_5(arg1, arg2, arg3, arg4, arg5) \ 3599 LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4); \ 3600 __sc_8 = (unsigned long) (arg5) 3601 #undef LSS_SC_BODY 3602 #define LSS_SC_BODY(nr, type, opt, args...) \ 3603 long __sc_ret, __sc_err; \ 3604 { \ 3605 register unsigned long __sc_0 __asm__ ("r0") = __NR_socketcall; \ 3606 register unsigned long __sc_3 __asm__ ("r3") = opt; \ 3607 register unsigned long __sc_4 __asm__ ("r4"); \ 3608 register unsigned long __sc_5 __asm__ ("r5"); \ 3609 register unsigned long __sc_6 __asm__ ("r6"); \ 3610 register unsigned long __sc_7 __asm__ ("r7"); \ 3611 register unsigned long __sc_8 __asm__ ("r8"); \ 3612 LSS_SC_LOADARGS_##nr(args); \ 3613 __asm__ __volatile__ \ 3614 ("stwu 1, -48(1)\n\t" \ 3615 "stw 4, 20(1)\n\t" \ 3616 "stw 5, 24(1)\n\t" \ 3617 "stw 6, 28(1)\n\t" \ 3618 "stw 7, 32(1)\n\t" \ 3619 "stw 8, 36(1)\n\t" \ 3620 "addi 4, 1, 20\n\t" \ 3621 "sc\n\t" \ 3622 "mfcr %0" \ 3623 : "=&r" (__sc_0), \ 3624 "=&r" (__sc_3), "=&r" (__sc_4), \ 3625 "=&r" (__sc_5), "=&r" (__sc_6), \ 3626 "=&r" (__sc_7), "=&r" (__sc_8) \ 3627 : LSS_ASMINPUT_##nr \ 3628 : "cr0", "ctr", "memory"); \ 3629 __sc_ret = __sc_3; \ 3630 __sc_err = __sc_0; \ 3631 } \ 3632 LSS_RETURN(type, __sc_ret, __sc_err) 3633 LSS_NAME(recvmsg)3634 LSS_INLINE ssize_t LSS_NAME(recvmsg)(int s,struct kernel_msghdr *msg, 3635 int flags){ 3636 LSS_SC_BODY(3, ssize_t, 17, s, msg, flags); 3637 } 3638 LSS_NAME(sendmsg)3639 LSS_INLINE ssize_t LSS_NAME(sendmsg)(int s, 3640 const struct kernel_msghdr *msg, 3641 int flags) { 3642 LSS_SC_BODY(3, ssize_t, 16, s, msg, flags); 3643 } 3644 3645 // TODO(csilvers): why is this ifdef'ed out? 3646 #if 0 3647 LSS_INLINE ssize_t LSS_NAME(sendto)(int s, const void *buf, size_t len, 3648 int flags, 3649 const struct kernel_sockaddr *to, 3650 unsigned int tolen) { 3651 LSS_BODY(6, ssize_t, 11, s, buf, len, flags, to, tolen); 3652 } 3653 #endif 3654 LSS_NAME(shutdown)3655 LSS_INLINE int LSS_NAME(shutdown)(int s, int how) { 3656 LSS_SC_BODY(2, int, 13, s, how); 3657 } 3658 LSS_NAME(socket)3659 LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) { 3660 LSS_SC_BODY(3, int, 1, domain, type, protocol); 3661 } 3662 LSS_NAME(socketpair)3663 LSS_INLINE int LSS_NAME(socketpair)(int d, int type, int protocol, 3664 int sv[2]) { 3665 LSS_SC_BODY(4, int, 8, d, type, protocol, sv); 3666 } 3667 #endif 3668 #if defined(__ARM_EABI__) || defined (__aarch64__) _syscall3(ssize_t,recvmsg,int,s,struct kernel_msghdr *,msg,int,flags)3669 LSS_INLINE _syscall3(ssize_t, recvmsg, int, s, struct kernel_msghdr*, msg, 3670 int, flags) 3671 LSS_INLINE _syscall3(ssize_t, sendmsg, int, s, const struct kernel_msghdr*, 3672 msg, int, flags) 3673 LSS_INLINE _syscall6(ssize_t, sendto, int, s, const void*, buf, size_t,len, 3674 int, flags, const struct kernel_sockaddr*, to, 3675 unsigned int, tolen) 3676 LSS_INLINE _syscall2(int, shutdown, int, s, int, how) 3677 LSS_INLINE _syscall3(int, socket, int, domain, int, type, int, protocol) 3678 LSS_INLINE _syscall4(int, socketpair, int, d, int, type, int, protocol, 3679 int*, sv) 3680 #endif 3681 #if defined(__i386__) || defined(__ARM_ARCH_3__) || \ 3682 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 3683 #define __NR__socketcall __NR_socketcall 3684 LSS_INLINE _syscall2(int, _socketcall, int, c, 3685 va_list, a) 3686 LSS_INLINE int LSS_NAME(socketcall)(int op, ...) { 3687 int rc; 3688 va_list ap; 3689 va_start(ap, op); 3690 rc = LSS_NAME(_socketcall)(op, ap); 3691 va_end(ap); 3692 return rc; 3693 } 3694 LSS_NAME(recvmsg)3695 LSS_INLINE ssize_t LSS_NAME(recvmsg)(int s,struct kernel_msghdr *msg, 3696 int flags){ 3697 return (ssize_t)LSS_NAME(socketcall)(17, s, msg, flags); 3698 } 3699 LSS_NAME(sendmsg)3700 LSS_INLINE ssize_t LSS_NAME(sendmsg)(int s, 3701 const struct kernel_msghdr *msg, 3702 int flags) { 3703 return (ssize_t)LSS_NAME(socketcall)(16, s, msg, flags); 3704 } 3705 LSS_NAME(sendto)3706 LSS_INLINE ssize_t LSS_NAME(sendto)(int s, const void *buf, size_t len, 3707 int flags, 3708 const struct kernel_sockaddr *to, 3709 unsigned int tolen) { 3710 return (ssize_t)LSS_NAME(socketcall)(11, s, buf, len, flags, to, tolen); 3711 } 3712 LSS_NAME(shutdown)3713 LSS_INLINE int LSS_NAME(shutdown)(int s, int how) { 3714 return LSS_NAME(socketcall)(13, s, how); 3715 } 3716 LSS_NAME(socket)3717 LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) { 3718 return LSS_NAME(socketcall)(1, domain, type, protocol); 3719 } 3720 LSS_NAME(socketpair)3721 LSS_INLINE int LSS_NAME(socketpair)(int d, int type, int protocol, 3722 int sv[2]) { 3723 return LSS_NAME(socketcall)(8, d, type, protocol, sv); 3724 } 3725 #endif 3726 #if defined(__i386__) || defined(__PPC__) _syscall4(int,fstatat64,int,d,const char *,p,struct kernel_stat64 *,b,int,f)3727 LSS_INLINE _syscall4(int, fstatat64, int, d, 3728 const char *, p, 3729 struct kernel_stat64 *, b, int, f) 3730 #endif 3731 #if defined(__i386__) || defined(__PPC__) || \ 3732 (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 3733 LSS_INLINE _syscall3(pid_t, waitpid, pid_t, p, 3734 int*, s, int, o) 3735 #endif 3736 #if defined(__mips__) 3737 /* sys_pipe() on MIPS has non-standard calling conventions, as it returns 3738 * both file handles through CPU registers. 3739 */ 3740 LSS_INLINE int LSS_NAME(pipe)(int *p) { 3741 register unsigned long __v0 __asm__("$2") = __NR_pipe; 3742 register unsigned long __v1 __asm__("$3"); 3743 register unsigned long __r7 __asm__("$7"); 3744 __asm__ __volatile__ ("syscall\n" 3745 : "=r"(__v0), "=r"(__v1), "=r" (__r7) 3746 : "0"(__v0) 3747 : "$8", "$9", "$10", "$11", "$12", 3748 "$13", "$14", "$15", "$24", "$25", "memory"); 3749 if (__r7) { 3750 unsigned long __errnovalue = __v0; 3751 LSS_ERRNO = __errnovalue; 3752 return -1; 3753 } else { 3754 p[0] = __v0; 3755 p[1] = __v1; 3756 return 0; 3757 } 3758 } 3759 #elif !defined(__aarch64__) 3760 // The unlink syscall has been deprecated on aarch64. We polyfill it below. 3761 LSS_INLINE _syscall1(int, pipe, int *, p) 3762 #endif 3763 /* TODO(csilvers): see if ppc can/should support this as well */ 3764 #if defined(__i386__) || defined(__ARM_ARCH_3__) || \ 3765 defined(__ARM_EABI__) || \ 3766 (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI64) 3767 #define __NR__statfs64 __NR_statfs64 3768 #define __NR__fstatfs64 __NR_fstatfs64 _syscall3(int,_statfs64,const char *,p,size_t,s,struct kernel_statfs64 *,b)3769 LSS_INLINE _syscall3(int, _statfs64, const char*, p, 3770 size_t, s,struct kernel_statfs64*, b) 3771 LSS_INLINE _syscall3(int, _fstatfs64, int, f, 3772 size_t, s,struct kernel_statfs64*, b) 3773 LSS_INLINE int LSS_NAME(statfs64)(const char *p, 3774 struct kernel_statfs64 *b) { 3775 return LSS_NAME(_statfs64)(p, sizeof(*b), b); 3776 } LSS_NAME(fstatfs64)3777 LSS_INLINE int LSS_NAME(fstatfs64)(int f,struct kernel_statfs64 *b) { 3778 return LSS_NAME(_fstatfs64)(f, sizeof(*b), b); 3779 } 3780 #endif 3781 LSS_NAME(execv)3782 LSS_INLINE int LSS_NAME(execv)(const char *path, const char *const argv[]) { 3783 extern char **environ; 3784 return LSS_NAME(execve)(path, argv, (const char *const *)environ); 3785 } 3786 LSS_NAME(gettid)3787 LSS_INLINE pid_t LSS_NAME(gettid)(void) { 3788 pid_t tid = LSS_NAME(_gettid)(); 3789 if (tid != -1) { 3790 return tid; 3791 } 3792 return LSS_NAME(getpid)(); 3793 } 3794 LSS_NAME(mremap)3795 LSS_INLINE void *LSS_NAME(mremap)(void *old_address, size_t old_size, 3796 size_t new_size, int flags, ...) { 3797 va_list ap; 3798 void *new_address, *rc; 3799 va_start(ap, flags); 3800 new_address = va_arg(ap, void *); 3801 rc = LSS_NAME(_mremap)(old_address, old_size, new_size, 3802 flags, new_address); 3803 va_end(ap); 3804 return rc; 3805 } 3806 LSS_NAME(ptrace_detach)3807 LSS_INLINE int LSS_NAME(ptrace_detach)(pid_t pid) { 3808 /* PTRACE_DETACH can sometimes forget to wake up the tracee and it 3809 * then sends job control signals to the real parent, rather than to 3810 * the tracer. We reduce the risk of this happening by starting a 3811 * whole new time slice, and then quickly sending a SIGCONT signal 3812 * right after detaching from the tracee. 3813 * 3814 * We use tkill to ensure that we only issue a wakeup for the thread being 3815 * detached. Large multi threaded apps can take a long time in the kernel 3816 * processing SIGCONT. 3817 */ 3818 int rc, err; 3819 LSS_NAME(sched_yield)(); 3820 rc = LSS_NAME(ptrace)(PTRACE_DETACH, pid, (void *)0, (void *)0); 3821 err = LSS_ERRNO; 3822 LSS_NAME(tkill)(pid, SIGCONT); 3823 /* Old systems don't have tkill */ 3824 if (LSS_ERRNO == ENOSYS) 3825 LSS_NAME(kill)(pid, SIGCONT); 3826 LSS_ERRNO = err; 3827 return rc; 3828 } 3829 LSS_NAME(raise)3830 LSS_INLINE int LSS_NAME(raise)(int sig) { 3831 return LSS_NAME(kill)(LSS_NAME(getpid)(), sig); 3832 } 3833 LSS_NAME(setpgrp)3834 LSS_INLINE int LSS_NAME(setpgrp)(void) { 3835 return LSS_NAME(setpgid)(0, 0); 3836 } 3837 LSS_NAME(sysconf)3838 LSS_INLINE int LSS_NAME(sysconf)(int name) { 3839 extern int __getpagesize(void); 3840 switch (name) { 3841 case _SC_OPEN_MAX: { 3842 struct kernel_rlimit limit; 3843 #if defined(__ARM_EABI__) 3844 return LSS_NAME(ugetrlimit)(RLIMIT_NOFILE, &limit) < 0 3845 ? 8192 : limit.rlim_cur; 3846 #else 3847 return LSS_NAME(getrlimit)(RLIMIT_NOFILE, &limit) < 0 3848 ? 8192 : limit.rlim_cur; 3849 #endif 3850 } 3851 case _SC_PAGESIZE: 3852 return __getpagesize(); 3853 default: 3854 LSS_ERRNO = ENOSYS; 3855 return -1; 3856 } 3857 } 3858 #if defined(__x86_64__) 3859 /* Need to make sure loff_t isn't truncated to 32-bits under x32. */ LSS_NAME(pread64)3860 LSS_INLINE ssize_t LSS_NAME(pread64)(int f, void *b, size_t c, loff_t o) { 3861 LSS_BODY(4, ssize_t, pread64, LSS_SYSCALL_ARG(f), LSS_SYSCALL_ARG(b), 3862 LSS_SYSCALL_ARG(c), (uint64_t)(o)); 3863 } 3864 LSS_NAME(pwrite64)3865 LSS_INLINE ssize_t LSS_NAME(pwrite64)(int f, const void *b, size_t c, 3866 loff_t o) { 3867 LSS_BODY(4, ssize_t, pwrite64, LSS_SYSCALL_ARG(f), LSS_SYSCALL_ARG(b), 3868 LSS_SYSCALL_ARG(c), (uint64_t)(o)); 3869 } 3870 LSS_NAME(readahead)3871 LSS_INLINE int LSS_NAME(readahead)(int f, loff_t o, unsigned c) { 3872 LSS_BODY(3, int, readahead, LSS_SYSCALL_ARG(f), (uint64_t)(o), 3873 LSS_SYSCALL_ARG(c)); 3874 } 3875 #elif defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI64 _syscall4(ssize_t,pread64,int,f,void *,b,size_t,c,loff_t,o)3876 LSS_INLINE _syscall4(ssize_t, pread64, int, f, 3877 void *, b, size_t, c, 3878 loff_t, o) 3879 LSS_INLINE _syscall4(ssize_t, pwrite64, int, f, 3880 const void *, b, size_t, c, 3881 loff_t, o) 3882 LSS_INLINE _syscall3(int, readahead, int, f, 3883 loff_t, o, unsigned, c) 3884 LSS_INLINE _syscall6(void *, mmap, void *, addr, size_t, length, int, prot, 3885 int, flags, int, fd, int64_t, offset) 3886 #else 3887 #define __NR__pread64 __NR_pread64 3888 #define __NR__pwrite64 __NR_pwrite64 3889 #define __NR__readahead __NR_readahead 3890 #if defined(__ARM_EABI__) || defined(__mips__) 3891 /* On ARM and MIPS, a 64-bit parameter has to be in an even-odd register 3892 * pair. Hence these calls ignore their fourth argument (r3) so that their 3893 * fifth and sixth make such a pair (r4,r5). 3894 */ 3895 #define LSS_LLARG_PAD 0, 3896 LSS_INLINE _syscall6(ssize_t, _pread64, int, f, 3897 void *, b, size_t, c, 3898 unsigned, skip, unsigned, o1, unsigned, o2) 3899 LSS_INLINE _syscall6(ssize_t, _pwrite64, int, f, 3900 const void *, b, size_t, c, 3901 unsigned, skip, unsigned, o1, unsigned, o2) 3902 LSS_INLINE _syscall5(int, _readahead, int, f, 3903 unsigned, skip, 3904 unsigned, o1, unsigned, o2, size_t, c) 3905 #else 3906 #define LSS_LLARG_PAD 3907 LSS_INLINE _syscall5(ssize_t, _pread64, int, f, 3908 void *, b, size_t, c, unsigned, o1, 3909 unsigned, o2) 3910 LSS_INLINE _syscall5(ssize_t, _pwrite64, int, f, 3911 const void *, b, size_t, c, unsigned, o1, 3912 long, o2) 3913 LSS_INLINE _syscall4(int, _readahead, int, f, 3914 unsigned, o1, unsigned, o2, size_t, c) 3915 #endif 3916 /* We force 64bit-wide parameters onto the stack, then access each 3917 * 32-bit component individually. This guarantees that we build the 3918 * correct parameters independent of the native byte-order of the 3919 * underlying architecture. 3920 */ 3921 LSS_INLINE ssize_t LSS_NAME(pread64)(int fd, void *buf, size_t count, 3922 loff_t off) { 3923 union { loff_t off; unsigned arg[2]; } o = { off }; 3924 return LSS_NAME(_pread64)(fd, buf, count, 3925 LSS_LLARG_PAD o.arg[0], o.arg[1]); 3926 } 3927 LSS_INLINE ssize_t LSS_NAME(pwrite64)(int fd, const void *buf, 3928 size_t count, loff_t off) { 3929 union { loff_t off; unsigned arg[2]; } o = { off }; 3930 return LSS_NAME(_pwrite64)(fd, buf, count, 3931 LSS_LLARG_PAD o.arg[0], o.arg[1]); 3932 } 3933 LSS_INLINE int LSS_NAME(readahead)(int fd, loff_t off, int len) { 3934 union { loff_t off; unsigned arg[2]; } o = { off }; 3935 return LSS_NAME(_readahead)(fd, LSS_LLARG_PAD o.arg[0], o.arg[1], len); 3936 } 3937 #endif 3938 #endif 3939 3940 #if defined(__aarch64__) 3941 LSS_INLINE _syscall3(int, dup3, int, s, int, d, int, f) 3942 LSS_INLINE _syscall6(void *, mmap, void *, addr, size_t, length, int, prot, 3943 int, flags, int, fd, int64_t, offset) 3944 LSS_INLINE _syscall4(int, newfstatat, int, dirfd, const char *, pathname, 3945 struct kernel_stat *, buf, int, flags) 3946 LSS_INLINE _syscall2(int, pipe2, int *, pipefd, int, flags) 3947 LSS_INLINE _syscall5(int, ppoll, struct kernel_pollfd *, u, 3948 unsigned int, n, const struct kernel_timespec *, t, 3949 const kernel_sigset_t *, sigmask, size_t, s) 3950 LSS_INLINE _syscall4(int, readlinkat, int, d, const char *, p, char *, b, 3951 size_t, s) 3952 #endif 3953 3954 /* 3955 * Polyfills for deprecated syscalls. 3956 */ 3957 3958 #if defined(__aarch64__) 3959 LSS_INLINE int LSS_NAME(dup2)(int s, int d) { 3960 return LSS_NAME(dup3)(s, d, 0); 3961 } 3962 LSS_NAME(open)3963 LSS_INLINE int LSS_NAME(open)(const char *pathname, int flags, int mode) { 3964 return LSS_NAME(openat)(AT_FDCWD, pathname, flags, mode); 3965 } 3966 LSS_NAME(unlink)3967 LSS_INLINE int LSS_NAME(unlink)(const char *pathname) { 3968 return LSS_NAME(unlinkat)(AT_FDCWD, pathname, 0); 3969 } 3970 LSS_NAME(readlink)3971 LSS_INLINE int LSS_NAME(readlink)(const char *pathname, char *buffer, 3972 size_t size) { 3973 return LSS_NAME(readlinkat)(AT_FDCWD, pathname, buffer, size); 3974 } 3975 LSS_NAME(pipe)3976 LSS_INLINE pid_t LSS_NAME(pipe)(int *pipefd) { 3977 return LSS_NAME(pipe2)(pipefd, 0); 3978 } 3979 LSS_NAME(poll)3980 LSS_INLINE int LSS_NAME(poll)(struct kernel_pollfd *fds, unsigned int nfds, 3981 int timeout) { 3982 struct kernel_timespec timeout_ts; 3983 struct kernel_timespec *timeout_ts_p = NULL; 3984 3985 if (timeout >= 0) { 3986 timeout_ts.tv_sec = timeout / 1000; 3987 timeout_ts.tv_nsec = (timeout % 1000) * 1000000; 3988 timeout_ts_p = &timeout_ts; 3989 } 3990 return LSS_NAME(ppoll)(fds, nfds, timeout_ts_p, NULL, 0); 3991 } 3992 LSS_NAME(stat)3993 LSS_INLINE int LSS_NAME(stat)(const char *pathname, 3994 struct kernel_stat *buf) { 3995 return LSS_NAME(newfstatat)(AT_FDCWD, pathname, buf, 0); 3996 } 3997 LSS_NAME(fork)3998 LSS_INLINE pid_t LSS_NAME(fork)(void) { 3999 // No fork syscall on aarch64 - implement by means of the clone syscall. 4000 // Note that this does not reset glibc's cached view of the PID/TID, so 4001 // some glibc interfaces might go wrong in the forked subprocess. 4002 int flags = SIGCHLD; 4003 void *child_stack = NULL; 4004 void *parent_tidptr = NULL; 4005 void *newtls = NULL; 4006 void *child_tidptr = NULL; 4007 4008 LSS_REG(0, flags); 4009 LSS_REG(1, child_stack); 4010 LSS_REG(2, parent_tidptr); 4011 LSS_REG(3, newtls); 4012 LSS_REG(4, child_tidptr); 4013 LSS_BODY(pid_t, clone, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3), 4014 "r"(__r4)); 4015 } 4016 #endif 4017 4018 #ifdef __ANDROID__ 4019 /* These restore the original values of these macros saved by the 4020 * corresponding #pragma push_macro near the top of this file. */ 4021 # pragma pop_macro("stat64") 4022 # pragma pop_macro("fstat64") 4023 # pragma pop_macro("lstat64") 4024 #endif 4025 4026 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS) 4027 } 4028 #endif 4029 4030 #endif 4031 #endif 4032