1 /* SPDX-License-Identifier: LGPL-2.1 OR MIT */ 2 /* 3 * Syscall definitions for NOLIBC (those in man(2)) 4 * Copyright (C) 2017-2021 Willy Tarreau <w@1wt.eu> 5 */ 6 7 #ifndef _NOLIBC_SYS_H 8 #define _NOLIBC_SYS_H 9 10 #include "std.h" 11 12 /* system includes */ 13 #include <asm/unistd.h> 14 #include <asm/signal.h> /* for SIGCHLD */ 15 #include <asm/ioctls.h> 16 #include <asm/mman.h> 17 #include <linux/fs.h> 18 #include <linux/loop.h> 19 #include <linux/time.h> 20 #include <linux/auxvec.h> 21 #include <linux/fcntl.h> /* for O_* and AT_* */ 22 #include <linux/stat.h> /* for statx() */ 23 #include <linux/prctl.h> 24 #include <linux/resource.h> 25 26 #include "arch.h" 27 #include "errno.h" 28 #include "stdarg.h" 29 #include "types.h" 30 31 32 /* Syscall return helper: takes the syscall value in argument and checks for an 33 * error in it. This may only be used with signed returns (int or long), but 34 * not with pointers. An error is any value < 0. When an error is encountered, 35 * -ret is set into errno and -1 is returned. Otherwise the returned value is 36 * passed as-is with its type preserved. 37 */ 38 39 #define __sysret(arg) \ 40 ({ \ 41 __typeof__(arg) __sysret_arg = (arg); \ 42 (__sysret_arg < 0) /* error ? */ \ 43 ? (({ SET_ERRNO(-__sysret_arg); }), -1) /* ret -1 with errno = -arg */ \ 44 : __sysret_arg; /* return original value */ \ 45 }) 46 47 /* Syscall ENOSYS helper: Avoids unused-parameter warnings and provides a 48 * debugging hook. 49 */ 50 51 static __inline__ int __nolibc_enosys(const char *syscall, ...) 52 { 53 (void)syscall; 54 return -ENOSYS; 55 } 56 57 58 /* Functions in this file only describe syscalls. They're declared static so 59 * that the compiler usually decides to inline them while still being allowed 60 * to pass a pointer to one of their instances. Each syscall exists in two 61 * versions: 62 * - the "internal" ones, which matches the raw syscall interface at the 63 * kernel level, which may sometimes slightly differ from the documented 64 * libc-level ones. For example most of them return either a valid value 65 * or -errno. All of these are prefixed with "sys_". They may be called 66 * by non-portable applications if desired. 67 * 68 * - the "exported" ones, whose interface must closely match the one 69 * documented in man(2), that applications are supposed to expect. These 70 * ones rely on the internal ones, and set errno. 71 * 72 * Each syscall will be defined with the two functions, sorted in alphabetical 73 * order applied to the exported names. 74 * 75 * In case of doubt about the relevance of a function here, only those which 76 * set errno should be defined here. Wrappers like those appearing in man(3) 77 * should not be placed here. 78 */ 79 80 81 /* 82 * int brk(void *addr); 83 * void *sbrk(intptr_t inc) 84 */ 85 86 static __attribute__((unused)) 87 void *sys_brk(void *addr) 88 { 89 return (void *)my_syscall1(__NR_brk, addr); 90 } 91 92 static __attribute__((unused)) 93 int brk(void *addr) 94 { 95 void *ret = sys_brk(addr); 96 97 if (!ret) { 98 SET_ERRNO(ENOMEM); 99 return -1; 100 } 101 return 0; 102 } 103 104 static __attribute__((unused)) 105 void *sbrk(intptr_t inc) 106 { 107 /* first call to find current end */ 108 void *ret = sys_brk(0); 109 110 if (ret && sys_brk(ret + inc) == ret + inc) 111 return ret + inc; 112 113 SET_ERRNO(ENOMEM); 114 return (void *)-1; 115 } 116 117 118 /* 119 * int chdir(const char *path); 120 */ 121 122 static __attribute__((unused)) 123 int sys_chdir(const char *path) 124 { 125 return my_syscall1(__NR_chdir, path); 126 } 127 128 static __attribute__((unused)) 129 int chdir(const char *path) 130 { 131 return __sysret(sys_chdir(path)); 132 } 133 134 135 /* 136 * int chmod(const char *path, mode_t mode); 137 */ 138 139 static __attribute__((unused)) 140 int sys_chmod(const char *path, mode_t mode) 141 { 142 #ifdef __NR_fchmodat 143 return my_syscall4(__NR_fchmodat, AT_FDCWD, path, mode, 0); 144 #elif defined(__NR_chmod) 145 return my_syscall2(__NR_chmod, path, mode); 146 #else 147 return __nolibc_enosys(__func__, path, mode); 148 #endif 149 } 150 151 static __attribute__((unused)) 152 int chmod(const char *path, mode_t mode) 153 { 154 return __sysret(sys_chmod(path, mode)); 155 } 156 157 158 /* 159 * int chown(const char *path, uid_t owner, gid_t group); 160 */ 161 162 static __attribute__((unused)) 163 int sys_chown(const char *path, uid_t owner, gid_t group) 164 { 165 #ifdef __NR_fchownat 166 return my_syscall5(__NR_fchownat, AT_FDCWD, path, owner, group, 0); 167 #elif defined(__NR_chown) 168 return my_syscall3(__NR_chown, path, owner, group); 169 #else 170 return __nolibc_enosys(__func__, path, owner, group); 171 #endif 172 } 173 174 static __attribute__((unused)) 175 int chown(const char *path, uid_t owner, gid_t group) 176 { 177 return __sysret(sys_chown(path, owner, group)); 178 } 179 180 181 /* 182 * int chroot(const char *path); 183 */ 184 185 static __attribute__((unused)) 186 int sys_chroot(const char *path) 187 { 188 return my_syscall1(__NR_chroot, path); 189 } 190 191 static __attribute__((unused)) 192 int chroot(const char *path) 193 { 194 return __sysret(sys_chroot(path)); 195 } 196 197 198 /* 199 * int close(int fd); 200 */ 201 202 static __attribute__((unused)) 203 int sys_close(int fd) 204 { 205 return my_syscall1(__NR_close, fd); 206 } 207 208 static __attribute__((unused)) 209 int close(int fd) 210 { 211 return __sysret(sys_close(fd)); 212 } 213 214 215 /* 216 * int dup(int fd); 217 */ 218 219 static __attribute__((unused)) 220 int sys_dup(int fd) 221 { 222 return my_syscall1(__NR_dup, fd); 223 } 224 225 static __attribute__((unused)) 226 int dup(int fd) 227 { 228 return __sysret(sys_dup(fd)); 229 } 230 231 232 /* 233 * int dup2(int old, int new); 234 */ 235 236 static __attribute__((unused)) 237 int sys_dup2(int old, int new) 238 { 239 #ifdef __NR_dup3 240 return my_syscall3(__NR_dup3, old, new, 0); 241 #elif defined(__NR_dup2) 242 return my_syscall2(__NR_dup2, old, new); 243 #else 244 return __nolibc_enosys(__func__, old, new); 245 #endif 246 } 247 248 static __attribute__((unused)) 249 int dup2(int old, int new) 250 { 251 return __sysret(sys_dup2(old, new)); 252 } 253 254 255 /* 256 * int dup3(int old, int new, int flags); 257 */ 258 259 #ifdef __NR_dup3 260 static __attribute__((unused)) 261 int sys_dup3(int old, int new, int flags) 262 { 263 return my_syscall3(__NR_dup3, old, new, flags); 264 } 265 266 static __attribute__((unused)) 267 int dup3(int old, int new, int flags) 268 { 269 return __sysret(sys_dup3(old, new, flags)); 270 } 271 #endif 272 273 274 /* 275 * int execve(const char *filename, char *const argv[], char *const envp[]); 276 */ 277 278 static __attribute__((unused)) 279 int sys_execve(const char *filename, char *const argv[], char *const envp[]) 280 { 281 return my_syscall3(__NR_execve, filename, argv, envp); 282 } 283 284 static __attribute__((unused)) 285 int execve(const char *filename, char *const argv[], char *const envp[]) 286 { 287 return __sysret(sys_execve(filename, argv, envp)); 288 } 289 290 291 /* 292 * void exit(int status); 293 */ 294 295 static __attribute__((noreturn,unused)) 296 void sys_exit(int status) 297 { 298 my_syscall1(__NR_exit, status & 255); 299 while(1); /* shut the "noreturn" warnings. */ 300 } 301 302 static __attribute__((noreturn,unused)) 303 void exit(int status) 304 { 305 sys_exit(status); 306 } 307 308 309 /* 310 * pid_t fork(void); 311 */ 312 313 #ifndef sys_fork 314 static __attribute__((unused)) 315 pid_t sys_fork(void) 316 { 317 #ifdef __NR_clone 318 /* note: some archs only have clone() and not fork(). Different archs 319 * have a different API, but most archs have the flags on first arg and 320 * will not use the rest with no other flag. 321 */ 322 return my_syscall5(__NR_clone, SIGCHLD, 0, 0, 0, 0); 323 #elif defined(__NR_fork) 324 return my_syscall0(__NR_fork); 325 #else 326 return __nolibc_enosys(__func__); 327 #endif 328 } 329 #endif 330 331 static __attribute__((unused)) 332 pid_t fork(void) 333 { 334 return __sysret(sys_fork()); 335 } 336 337 338 /* 339 * int fsync(int fd); 340 */ 341 342 static __attribute__((unused)) 343 int sys_fsync(int fd) 344 { 345 return my_syscall1(__NR_fsync, fd); 346 } 347 348 static __attribute__((unused)) 349 int fsync(int fd) 350 { 351 return __sysret(sys_fsync(fd)); 352 } 353 354 355 /* 356 * int getdents64(int fd, struct linux_dirent64 *dirp, int count); 357 */ 358 359 static __attribute__((unused)) 360 int sys_getdents64(int fd, struct linux_dirent64 *dirp, int count) 361 { 362 return my_syscall3(__NR_getdents64, fd, dirp, count); 363 } 364 365 static __attribute__((unused)) 366 int getdents64(int fd, struct linux_dirent64 *dirp, int count) 367 { 368 return __sysret(sys_getdents64(fd, dirp, count)); 369 } 370 371 372 /* 373 * uid_t geteuid(void); 374 */ 375 376 static __attribute__((unused)) 377 uid_t sys_geteuid(void) 378 { 379 #ifdef __NR_geteuid32 380 return my_syscall0(__NR_geteuid32); 381 #else 382 return my_syscall0(__NR_geteuid); 383 #endif 384 } 385 386 static __attribute__((unused)) 387 uid_t geteuid(void) 388 { 389 return sys_geteuid(); 390 } 391 392 393 /* 394 * pid_t getpgid(pid_t pid); 395 */ 396 397 static __attribute__((unused)) 398 pid_t sys_getpgid(pid_t pid) 399 { 400 return my_syscall1(__NR_getpgid, pid); 401 } 402 403 static __attribute__((unused)) 404 pid_t getpgid(pid_t pid) 405 { 406 return __sysret(sys_getpgid(pid)); 407 } 408 409 410 /* 411 * pid_t getpgrp(void); 412 */ 413 414 static __attribute__((unused)) 415 pid_t sys_getpgrp(void) 416 { 417 return sys_getpgid(0); 418 } 419 420 static __attribute__((unused)) 421 pid_t getpgrp(void) 422 { 423 return sys_getpgrp(); 424 } 425 426 427 /* 428 * pid_t getpid(void); 429 */ 430 431 static __attribute__((unused)) 432 pid_t sys_getpid(void) 433 { 434 return my_syscall0(__NR_getpid); 435 } 436 437 static __attribute__((unused)) 438 pid_t getpid(void) 439 { 440 return sys_getpid(); 441 } 442 443 444 /* 445 * pid_t getppid(void); 446 */ 447 448 static __attribute__((unused)) 449 pid_t sys_getppid(void) 450 { 451 return my_syscall0(__NR_getppid); 452 } 453 454 static __attribute__((unused)) 455 pid_t getppid(void) 456 { 457 return sys_getppid(); 458 } 459 460 461 /* 462 * pid_t gettid(void); 463 */ 464 465 static __attribute__((unused)) 466 pid_t sys_gettid(void) 467 { 468 return my_syscall0(__NR_gettid); 469 } 470 471 static __attribute__((unused)) 472 pid_t gettid(void) 473 { 474 return sys_gettid(); 475 } 476 477 static unsigned long getauxval(unsigned long key); 478 479 /* 480 * int getpagesize(void); 481 */ 482 483 static __attribute__((unused)) 484 int getpagesize(void) 485 { 486 return __sysret((int)getauxval(AT_PAGESZ) ?: -ENOENT); 487 } 488 489 490 /* 491 * int gettimeofday(struct timeval *tv, struct timezone *tz); 492 */ 493 494 static __attribute__((unused)) 495 int sys_gettimeofday(struct timeval *tv, struct timezone *tz) 496 { 497 #ifdef __NR_gettimeofday 498 return my_syscall2(__NR_gettimeofday, tv, tz); 499 #else 500 return __nolibc_enosys(__func__, tv, tz); 501 #endif 502 } 503 504 static __attribute__((unused)) 505 int gettimeofday(struct timeval *tv, struct timezone *tz) 506 { 507 return __sysret(sys_gettimeofday(tv, tz)); 508 } 509 510 511 /* 512 * uid_t getuid(void); 513 */ 514 515 static __attribute__((unused)) 516 uid_t sys_getuid(void) 517 { 518 #ifdef __NR_getuid32 519 return my_syscall0(__NR_getuid32); 520 #else 521 return my_syscall0(__NR_getuid); 522 #endif 523 } 524 525 static __attribute__((unused)) 526 uid_t getuid(void) 527 { 528 return sys_getuid(); 529 } 530 531 532 /* 533 * int ioctl(int fd, unsigned long req, void *value); 534 */ 535 536 static __attribute__((unused)) 537 int sys_ioctl(int fd, unsigned long req, void *value) 538 { 539 return my_syscall3(__NR_ioctl, fd, req, value); 540 } 541 542 static __attribute__((unused)) 543 int ioctl(int fd, unsigned long req, void *value) 544 { 545 return __sysret(sys_ioctl(fd, req, value)); 546 } 547 548 /* 549 * int kill(pid_t pid, int signal); 550 */ 551 552 static __attribute__((unused)) 553 int sys_kill(pid_t pid, int signal) 554 { 555 return my_syscall2(__NR_kill, pid, signal); 556 } 557 558 static __attribute__((unused)) 559 int kill(pid_t pid, int signal) 560 { 561 return __sysret(sys_kill(pid, signal)); 562 } 563 564 565 /* 566 * int link(const char *old, const char *new); 567 */ 568 569 static __attribute__((unused)) 570 int sys_link(const char *old, const char *new) 571 { 572 #ifdef __NR_linkat 573 return my_syscall5(__NR_linkat, AT_FDCWD, old, AT_FDCWD, new, 0); 574 #elif defined(__NR_link) 575 return my_syscall2(__NR_link, old, new); 576 #else 577 return __nolibc_enosys(__func__, old, new); 578 #endif 579 } 580 581 static __attribute__((unused)) 582 int link(const char *old, const char *new) 583 { 584 return __sysret(sys_link(old, new)); 585 } 586 587 588 /* 589 * off_t lseek(int fd, off_t offset, int whence); 590 */ 591 592 static __attribute__((unused)) 593 off_t sys_lseek(int fd, off_t offset, int whence) 594 { 595 #ifdef __NR_lseek 596 return my_syscall3(__NR_lseek, fd, offset, whence); 597 #else 598 return __nolibc_enosys(__func__, fd, offset, whence); 599 #endif 600 } 601 602 static __attribute__((unused)) 603 off_t lseek(int fd, off_t offset, int whence) 604 { 605 return __sysret(sys_lseek(fd, offset, whence)); 606 } 607 608 609 /* 610 * int mkdir(const char *path, mode_t mode); 611 */ 612 613 static __attribute__((unused)) 614 int sys_mkdir(const char *path, mode_t mode) 615 { 616 #ifdef __NR_mkdirat 617 return my_syscall3(__NR_mkdirat, AT_FDCWD, path, mode); 618 #elif defined(__NR_mkdir) 619 return my_syscall2(__NR_mkdir, path, mode); 620 #else 621 return __nolibc_enosys(__func__, path, mode); 622 #endif 623 } 624 625 static __attribute__((unused)) 626 int mkdir(const char *path, mode_t mode) 627 { 628 return __sysret(sys_mkdir(path, mode)); 629 } 630 631 /* 632 * int rmdir(const char *path); 633 */ 634 635 static __attribute__((unused)) 636 int sys_rmdir(const char *path) 637 { 638 #ifdef __NR_rmdir 639 return my_syscall1(__NR_rmdir, path); 640 #elif defined(__NR_unlinkat) 641 return my_syscall3(__NR_unlinkat, AT_FDCWD, path, AT_REMOVEDIR); 642 #else 643 return __nolibc_enosys(__func__, path); 644 #endif 645 } 646 647 static __attribute__((unused)) 648 int rmdir(const char *path) 649 { 650 return __sysret(sys_rmdir(path)); 651 } 652 653 654 /* 655 * int mknod(const char *path, mode_t mode, dev_t dev); 656 */ 657 658 static __attribute__((unused)) 659 long sys_mknod(const char *path, mode_t mode, dev_t dev) 660 { 661 #ifdef __NR_mknodat 662 return my_syscall4(__NR_mknodat, AT_FDCWD, path, mode, dev); 663 #elif defined(__NR_mknod) 664 return my_syscall3(__NR_mknod, path, mode, dev); 665 #else 666 return __nolibc_enosys(__func__, path, mode, dev); 667 #endif 668 } 669 670 static __attribute__((unused)) 671 int mknod(const char *path, mode_t mode, dev_t dev) 672 { 673 return __sysret(sys_mknod(path, mode, dev)); 674 } 675 676 #ifndef sys_mmap 677 static __attribute__((unused)) 678 void *sys_mmap(void *addr, size_t length, int prot, int flags, int fd, 679 off_t offset) 680 { 681 int n; 682 683 #if defined(__NR_mmap2) 684 n = __NR_mmap2; 685 offset >>= 12; 686 #else 687 n = __NR_mmap; 688 #endif 689 690 return (void *)my_syscall6(n, addr, length, prot, flags, fd, offset); 691 } 692 #endif 693 694 /* Note that on Linux, MAP_FAILED is -1 so we can use the generic __sysret() 695 * which returns -1 upon error and still satisfy user land that checks for 696 * MAP_FAILED. 697 */ 698 699 static __attribute__((unused)) 700 void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset) 701 { 702 void *ret = sys_mmap(addr, length, prot, flags, fd, offset); 703 704 if ((unsigned long)ret >= -4095UL) { 705 SET_ERRNO(-(long)ret); 706 ret = MAP_FAILED; 707 } 708 return ret; 709 } 710 711 static __attribute__((unused)) 712 int sys_munmap(void *addr, size_t length) 713 { 714 return my_syscall2(__NR_munmap, addr, length); 715 } 716 717 static __attribute__((unused)) 718 int munmap(void *addr, size_t length) 719 { 720 return __sysret(sys_munmap(addr, length)); 721 } 722 723 /* 724 * int mount(const char *source, const char *target, 725 * const char *fstype, unsigned long flags, 726 * const void *data); 727 */ 728 static __attribute__((unused)) 729 int sys_mount(const char *src, const char *tgt, const char *fst, 730 unsigned long flags, const void *data) 731 { 732 return my_syscall5(__NR_mount, src, tgt, fst, flags, data); 733 } 734 735 static __attribute__((unused)) 736 int mount(const char *src, const char *tgt, 737 const char *fst, unsigned long flags, 738 const void *data) 739 { 740 return __sysret(sys_mount(src, tgt, fst, flags, data)); 741 } 742 743 744 /* 745 * int open(const char *path, int flags[, mode_t mode]); 746 */ 747 748 static __attribute__((unused)) 749 int sys_open(const char *path, int flags, mode_t mode) 750 { 751 #ifdef __NR_openat 752 return my_syscall4(__NR_openat, AT_FDCWD, path, flags, mode); 753 #elif defined(__NR_open) 754 return my_syscall3(__NR_open, path, flags, mode); 755 #else 756 return __nolibc_enosys(__func__, path, flags, mode); 757 #endif 758 } 759 760 static __attribute__((unused)) 761 int open(const char *path, int flags, ...) 762 { 763 mode_t mode = 0; 764 765 if (flags & O_CREAT) { 766 va_list args; 767 768 va_start(args, flags); 769 mode = va_arg(args, int); 770 va_end(args); 771 } 772 773 return __sysret(sys_open(path, flags, mode)); 774 } 775 776 777 /* 778 * int pipe2(int pipefd[2], int flags); 779 * int pipe(int pipefd[2]); 780 */ 781 782 static __attribute__((unused)) 783 int sys_pipe2(int pipefd[2], int flags) 784 { 785 return my_syscall2(__NR_pipe2, pipefd, flags); 786 } 787 788 static __attribute__((unused)) 789 int pipe2(int pipefd[2], int flags) 790 { 791 return __sysret(sys_pipe2(pipefd, flags)); 792 } 793 794 static __attribute__((unused)) 795 int pipe(int pipefd[2]) 796 { 797 return pipe2(pipefd, 0); 798 } 799 800 801 /* 802 * int prctl(int option, unsigned long arg2, unsigned long arg3, 803 * unsigned long arg4, unsigned long arg5); 804 */ 805 806 static __attribute__((unused)) 807 int sys_prctl(int option, unsigned long arg2, unsigned long arg3, 808 unsigned long arg4, unsigned long arg5) 809 { 810 return my_syscall5(__NR_prctl, option, arg2, arg3, arg4, arg5); 811 } 812 813 static __attribute__((unused)) 814 int prctl(int option, unsigned long arg2, unsigned long arg3, 815 unsigned long arg4, unsigned long arg5) 816 { 817 return __sysret(sys_prctl(option, arg2, arg3, arg4, arg5)); 818 } 819 820 821 /* 822 * int pivot_root(const char *new, const char *old); 823 */ 824 825 static __attribute__((unused)) 826 int sys_pivot_root(const char *new, const char *old) 827 { 828 return my_syscall2(__NR_pivot_root, new, old); 829 } 830 831 static __attribute__((unused)) 832 int pivot_root(const char *new, const char *old) 833 { 834 return __sysret(sys_pivot_root(new, old)); 835 } 836 837 838 /* 839 * int poll(struct pollfd *fds, int nfds, int timeout); 840 */ 841 842 static __attribute__((unused)) 843 int sys_poll(struct pollfd *fds, int nfds, int timeout) 844 { 845 #if defined(__NR_ppoll) 846 struct timespec t; 847 848 if (timeout >= 0) { 849 t.tv_sec = timeout / 1000; 850 t.tv_nsec = (timeout % 1000) * 1000000; 851 } 852 return my_syscall5(__NR_ppoll, fds, nfds, (timeout >= 0) ? &t : NULL, NULL, 0); 853 #elif defined(__NR_poll) 854 return my_syscall3(__NR_poll, fds, nfds, timeout); 855 #else 856 return __nolibc_enosys(__func__, fds, nfds, timeout); 857 #endif 858 } 859 860 static __attribute__((unused)) 861 int poll(struct pollfd *fds, int nfds, int timeout) 862 { 863 return __sysret(sys_poll(fds, nfds, timeout)); 864 } 865 866 867 /* 868 * ssize_t read(int fd, void *buf, size_t count); 869 */ 870 871 static __attribute__((unused)) 872 ssize_t sys_read(int fd, void *buf, size_t count) 873 { 874 return my_syscall3(__NR_read, fd, buf, count); 875 } 876 877 static __attribute__((unused)) 878 ssize_t read(int fd, void *buf, size_t count) 879 { 880 return __sysret(sys_read(fd, buf, count)); 881 } 882 883 884 /* 885 * int reboot(int cmd); 886 * <cmd> is among LINUX_REBOOT_CMD_* 887 */ 888 889 static __attribute__((unused)) 890 ssize_t sys_reboot(int magic1, int magic2, int cmd, void *arg) 891 { 892 return my_syscall4(__NR_reboot, magic1, magic2, cmd, arg); 893 } 894 895 static __attribute__((unused)) 896 int reboot(int cmd) 897 { 898 return __sysret(sys_reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, 0)); 899 } 900 901 902 /* 903 * int getrlimit(int resource, struct rlimit *rlim); 904 * int setrlimit(int resource, const struct rlimit *rlim); 905 */ 906 907 static __attribute__((unused)) 908 int sys_prlimit64(pid_t pid, int resource, 909 const struct rlimit64 *new_limit, struct rlimit64 *old_limit) 910 { 911 return my_syscall4(__NR_prlimit64, pid, resource, new_limit, old_limit); 912 } 913 914 static __attribute__((unused)) 915 int getrlimit(int resource, struct rlimit *rlim) 916 { 917 struct rlimit64 rlim64; 918 int ret; 919 920 ret = __sysret(sys_prlimit64(0, resource, NULL, &rlim64)); 921 rlim->rlim_cur = rlim64.rlim_cur; 922 rlim->rlim_max = rlim64.rlim_max; 923 924 return ret; 925 } 926 927 static __attribute__((unused)) 928 int setrlimit(int resource, const struct rlimit *rlim) 929 { 930 struct rlimit64 rlim64 = { 931 .rlim_cur = rlim->rlim_cur, 932 .rlim_max = rlim->rlim_max, 933 }; 934 935 return __sysret(sys_prlimit64(0, resource, &rlim64, NULL)); 936 } 937 938 939 /* 940 * int sched_yield(void); 941 */ 942 943 static __attribute__((unused)) 944 int sys_sched_yield(void) 945 { 946 return my_syscall0(__NR_sched_yield); 947 } 948 949 static __attribute__((unused)) 950 int sched_yield(void) 951 { 952 return __sysret(sys_sched_yield()); 953 } 954 955 956 /* 957 * int select(int nfds, fd_set *read_fds, fd_set *write_fds, 958 * fd_set *except_fds, struct timeval *timeout); 959 */ 960 961 static __attribute__((unused)) 962 int sys_select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout) 963 { 964 #if defined(__ARCH_WANT_SYS_OLD_SELECT) && !defined(__NR__newselect) 965 struct sel_arg_struct { 966 unsigned long n; 967 fd_set *r, *w, *e; 968 struct timeval *t; 969 } arg = { .n = nfds, .r = rfds, .w = wfds, .e = efds, .t = timeout }; 970 return my_syscall1(__NR_select, &arg); 971 #elif defined(__NR__newselect) 972 return my_syscall5(__NR__newselect, nfds, rfds, wfds, efds, timeout); 973 #elif defined(__NR_select) 974 return my_syscall5(__NR_select, nfds, rfds, wfds, efds, timeout); 975 #elif defined(__NR_pselect6) 976 struct timespec t; 977 978 if (timeout) { 979 t.tv_sec = timeout->tv_sec; 980 t.tv_nsec = timeout->tv_usec * 1000; 981 } 982 return my_syscall6(__NR_pselect6, nfds, rfds, wfds, efds, timeout ? &t : NULL, NULL); 983 #else 984 return __nolibc_enosys(__func__, nfds, rfds, wfds, efds, timeout); 985 #endif 986 } 987 988 static __attribute__((unused)) 989 int select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout) 990 { 991 return __sysret(sys_select(nfds, rfds, wfds, efds, timeout)); 992 } 993 994 995 /* 996 * int setpgid(pid_t pid, pid_t pgid); 997 */ 998 999 static __attribute__((unused)) 1000 int sys_setpgid(pid_t pid, pid_t pgid) 1001 { 1002 return my_syscall2(__NR_setpgid, pid, pgid); 1003 } 1004 1005 static __attribute__((unused)) 1006 int setpgid(pid_t pid, pid_t pgid) 1007 { 1008 return __sysret(sys_setpgid(pid, pgid)); 1009 } 1010 1011 1012 /* 1013 * pid_t setsid(void); 1014 */ 1015 1016 static __attribute__((unused)) 1017 pid_t sys_setsid(void) 1018 { 1019 return my_syscall0(__NR_setsid); 1020 } 1021 1022 static __attribute__((unused)) 1023 pid_t setsid(void) 1024 { 1025 return __sysret(sys_setsid()); 1026 } 1027 1028 /* 1029 * int statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf); 1030 * int stat(const char *path, struct stat *buf); 1031 */ 1032 1033 static __attribute__((unused)) 1034 int sys_statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf) 1035 { 1036 #ifdef __NR_statx 1037 return my_syscall5(__NR_statx, fd, path, flags, mask, buf); 1038 #else 1039 return __nolibc_enosys(__func__, fd, path, flags, mask, buf); 1040 #endif 1041 } 1042 1043 static __attribute__((unused)) 1044 int statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf) 1045 { 1046 return __sysret(sys_statx(fd, path, flags, mask, buf)); 1047 } 1048 1049 1050 static __attribute__((unused)) 1051 int stat(const char *path, struct stat *buf) 1052 { 1053 struct statx statx; 1054 long ret; 1055 1056 ret = __sysret(sys_statx(AT_FDCWD, path, AT_NO_AUTOMOUNT, STATX_BASIC_STATS, &statx)); 1057 if (ret == -1) 1058 return ret; 1059 1060 buf->st_dev = ((statx.stx_dev_minor & 0xff) 1061 | (statx.stx_dev_major << 8) 1062 | ((statx.stx_dev_minor & ~0xff) << 12)); 1063 buf->st_ino = statx.stx_ino; 1064 buf->st_mode = statx.stx_mode; 1065 buf->st_nlink = statx.stx_nlink; 1066 buf->st_uid = statx.stx_uid; 1067 buf->st_gid = statx.stx_gid; 1068 buf->st_rdev = ((statx.stx_rdev_minor & 0xff) 1069 | (statx.stx_rdev_major << 8) 1070 | ((statx.stx_rdev_minor & ~0xff) << 12)); 1071 buf->st_size = statx.stx_size; 1072 buf->st_blksize = statx.stx_blksize; 1073 buf->st_blocks = statx.stx_blocks; 1074 buf->st_atim.tv_sec = statx.stx_atime.tv_sec; 1075 buf->st_atim.tv_nsec = statx.stx_atime.tv_nsec; 1076 buf->st_mtim.tv_sec = statx.stx_mtime.tv_sec; 1077 buf->st_mtim.tv_nsec = statx.stx_mtime.tv_nsec; 1078 buf->st_ctim.tv_sec = statx.stx_ctime.tv_sec; 1079 buf->st_ctim.tv_nsec = statx.stx_ctime.tv_nsec; 1080 1081 return 0; 1082 } 1083 1084 1085 /* 1086 * int symlink(const char *old, const char *new); 1087 */ 1088 1089 static __attribute__((unused)) 1090 int sys_symlink(const char *old, const char *new) 1091 { 1092 #ifdef __NR_symlinkat 1093 return my_syscall3(__NR_symlinkat, old, AT_FDCWD, new); 1094 #elif defined(__NR_symlink) 1095 return my_syscall2(__NR_symlink, old, new); 1096 #else 1097 return __nolibc_enosys(__func__, old, new); 1098 #endif 1099 } 1100 1101 static __attribute__((unused)) 1102 int symlink(const char *old, const char *new) 1103 { 1104 return __sysret(sys_symlink(old, new)); 1105 } 1106 1107 1108 /* 1109 * mode_t umask(mode_t mode); 1110 */ 1111 1112 static __attribute__((unused)) 1113 mode_t sys_umask(mode_t mode) 1114 { 1115 return my_syscall1(__NR_umask, mode); 1116 } 1117 1118 static __attribute__((unused)) 1119 mode_t umask(mode_t mode) 1120 { 1121 return sys_umask(mode); 1122 } 1123 1124 1125 /* 1126 * int umount2(const char *path, int flags); 1127 */ 1128 1129 static __attribute__((unused)) 1130 int sys_umount2(const char *path, int flags) 1131 { 1132 return my_syscall2(__NR_umount2, path, flags); 1133 } 1134 1135 static __attribute__((unused)) 1136 int umount2(const char *path, int flags) 1137 { 1138 return __sysret(sys_umount2(path, flags)); 1139 } 1140 1141 1142 /* 1143 * int unlink(const char *path); 1144 */ 1145 1146 static __attribute__((unused)) 1147 int sys_unlink(const char *path) 1148 { 1149 #ifdef __NR_unlinkat 1150 return my_syscall3(__NR_unlinkat, AT_FDCWD, path, 0); 1151 #elif defined(__NR_unlink) 1152 return my_syscall1(__NR_unlink, path); 1153 #else 1154 return __nolibc_enosys(__func__, path); 1155 #endif 1156 } 1157 1158 static __attribute__((unused)) 1159 int unlink(const char *path) 1160 { 1161 return __sysret(sys_unlink(path)); 1162 } 1163 1164 1165 /* 1166 * pid_t wait(int *status); 1167 * pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage); 1168 * pid_t waitpid(pid_t pid, int *status, int options); 1169 */ 1170 1171 static __attribute__((unused)) 1172 pid_t sys_wait4(pid_t pid, int *status, int options, struct rusage *rusage) 1173 { 1174 #ifdef __NR_wait4 1175 return my_syscall4(__NR_wait4, pid, status, options, rusage); 1176 #else 1177 return __nolibc_enosys(__func__, pid, status, options, rusage); 1178 #endif 1179 } 1180 1181 static __attribute__((unused)) 1182 pid_t wait(int *status) 1183 { 1184 return __sysret(sys_wait4(-1, status, 0, NULL)); 1185 } 1186 1187 static __attribute__((unused)) 1188 pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage) 1189 { 1190 return __sysret(sys_wait4(pid, status, options, rusage)); 1191 } 1192 1193 1194 static __attribute__((unused)) 1195 pid_t waitpid(pid_t pid, int *status, int options) 1196 { 1197 return __sysret(sys_wait4(pid, status, options, NULL)); 1198 } 1199 1200 1201 /* 1202 * ssize_t write(int fd, const void *buf, size_t count); 1203 */ 1204 1205 static __attribute__((unused)) 1206 ssize_t sys_write(int fd, const void *buf, size_t count) 1207 { 1208 return my_syscall3(__NR_write, fd, buf, count); 1209 } 1210 1211 static __attribute__((unused)) 1212 ssize_t write(int fd, const void *buf, size_t count) 1213 { 1214 return __sysret(sys_write(fd, buf, count)); 1215 } 1216 1217 1218 /* 1219 * int memfd_create(const char *name, unsigned int flags); 1220 */ 1221 1222 static __attribute__((unused)) 1223 int sys_memfd_create(const char *name, unsigned int flags) 1224 { 1225 return my_syscall2(__NR_memfd_create, name, flags); 1226 } 1227 1228 static __attribute__((unused)) 1229 int memfd_create(const char *name, unsigned int flags) 1230 { 1231 return __sysret(sys_memfd_create(name, flags)); 1232 } 1233 1234 /* make sure to include all global symbols */ 1235 #include "nolibc.h" 1236 1237 #endif /* _NOLIBC_SYS_H */ 1238