1bd8c8fbbSWilly Tarreau /* SPDX-License-Identifier: LGPL-2.1 OR MIT */ 2bd8c8fbbSWilly Tarreau /* 3bd8c8fbbSWilly Tarreau * Syscall definitions for NOLIBC (those in man(2)) 4bd8c8fbbSWilly Tarreau * Copyright (C) 2017-2021 Willy Tarreau <w@1wt.eu> 5bd8c8fbbSWilly Tarreau */ 6bd8c8fbbSWilly Tarreau 7bd8c8fbbSWilly Tarreau #ifndef _NOLIBC_SYS_H 8bd8c8fbbSWilly Tarreau #define _NOLIBC_SYS_H 9bd8c8fbbSWilly Tarreau 10a7604ba1SWilly Tarreau #include <stdarg.h> 11bd8c8fbbSWilly Tarreau #include "std.h" 12bd8c8fbbSWilly Tarreau 13bd8c8fbbSWilly Tarreau /* system includes */ 14bd8c8fbbSWilly Tarreau #include <asm/unistd.h> 15fddc8f81SThomas Weißschuh #include <asm/signal.h> /* for SIGCHLD */ 16bd8c8fbbSWilly Tarreau #include <asm/ioctls.h> 17544fa1a2SAmmar Faizi #include <asm/mman.h> 18bd8c8fbbSWilly Tarreau #include <linux/fs.h> 19bd8c8fbbSWilly Tarreau #include <linux/loop.h> 20bd8c8fbbSWilly Tarreau #include <linux/time.h> 217efd762eSAmmar Faizi #include <linux/auxvec.h> 22fddc8f81SThomas Weißschuh #include <linux/fcntl.h> /* for O_* and AT_* */ 23fddc8f81SThomas Weißschuh #include <linux/stat.h> /* for statx() */ 24208aa9d9SThomas Weißschuh #include <linux/prctl.h> 25bd8c8fbbSWilly Tarreau 26bd8c8fbbSWilly Tarreau #include "arch.h" 2745a794bfSWilly Tarreau #include "errno.h" 28bd8c8fbbSWilly Tarreau #include "types.h" 29bd8c8fbbSWilly Tarreau 306591be4aSZhangjin Wu 316591be4aSZhangjin Wu /* Syscall return helper for library routines, set errno as -ret when ret is in 326591be4aSZhangjin Wu * range of [-MAX_ERRNO, -1] 336591be4aSZhangjin Wu * 346591be4aSZhangjin Wu * Note, No official reference states the errno range here aligns with musl 356591be4aSZhangjin Wu * (src/internal/syscall_ret.c) and glibc (sysdeps/unix/sysv/linux/sysdep.h) 366591be4aSZhangjin Wu */ 376591be4aSZhangjin Wu 38428905daSZhangjin Wu static __inline__ __attribute__((unused, always_inline)) 396591be4aSZhangjin Wu long __sysret(unsigned long ret) 40428905daSZhangjin Wu { 416591be4aSZhangjin Wu if (ret >= (unsigned long)-MAX_ERRNO) { 426591be4aSZhangjin Wu SET_ERRNO(-(long)ret); 436591be4aSZhangjin Wu return -1; 44428905daSZhangjin Wu } 45428905daSZhangjin Wu return ret; 46428905daSZhangjin Wu } 47bd8c8fbbSWilly Tarreau 48bd8c8fbbSWilly Tarreau /* Functions in this file only describe syscalls. They're declared static so 49bd8c8fbbSWilly Tarreau * that the compiler usually decides to inline them while still being allowed 50bd8c8fbbSWilly Tarreau * to pass a pointer to one of their instances. Each syscall exists in two 51bd8c8fbbSWilly Tarreau * versions: 52bd8c8fbbSWilly Tarreau * - the "internal" ones, which matches the raw syscall interface at the 53bd8c8fbbSWilly Tarreau * kernel level, which may sometimes slightly differ from the documented 54bd8c8fbbSWilly Tarreau * libc-level ones. For example most of them return either a valid value 55bd8c8fbbSWilly Tarreau * or -errno. All of these are prefixed with "sys_". They may be called 56bd8c8fbbSWilly Tarreau * by non-portable applications if desired. 57bd8c8fbbSWilly Tarreau * 58bd8c8fbbSWilly Tarreau * - the "exported" ones, whose interface must closely match the one 59bd8c8fbbSWilly Tarreau * documented in man(2), that applications are supposed to expect. These 60bd8c8fbbSWilly Tarreau * ones rely on the internal ones, and set errno. 61bd8c8fbbSWilly Tarreau * 62bd8c8fbbSWilly Tarreau * Each syscall will be defined with the two functions, sorted in alphabetical 63bd8c8fbbSWilly Tarreau * order applied to the exported names. 64bd8c8fbbSWilly Tarreau * 65bd8c8fbbSWilly Tarreau * In case of doubt about the relevance of a function here, only those which 66bd8c8fbbSWilly Tarreau * set errno should be defined here. Wrappers like those appearing in man(3) 67bd8c8fbbSWilly Tarreau * should not be placed here. 68bd8c8fbbSWilly Tarreau */ 69bd8c8fbbSWilly Tarreau 70bd8c8fbbSWilly Tarreau 71bd8c8fbbSWilly Tarreau /* 72bd8c8fbbSWilly Tarreau * int brk(void *addr); 73bd8c8fbbSWilly Tarreau * void *sbrk(intptr_t inc) 74bd8c8fbbSWilly Tarreau */ 75bd8c8fbbSWilly Tarreau 76bd8c8fbbSWilly Tarreau static __attribute__((unused)) 77bd8c8fbbSWilly Tarreau void *sys_brk(void *addr) 78bd8c8fbbSWilly Tarreau { 79bd8c8fbbSWilly Tarreau return (void *)my_syscall1(__NR_brk, addr); 80bd8c8fbbSWilly Tarreau } 81bd8c8fbbSWilly Tarreau 82bd8c8fbbSWilly Tarreau static __attribute__((unused)) 83bd8c8fbbSWilly Tarreau int brk(void *addr) 84bd8c8fbbSWilly Tarreau { 85*fb01ff63SWilly Tarreau void *ret = sys_brk(addr); 86*fb01ff63SWilly Tarreau 87*fb01ff63SWilly Tarreau if (!ret) { 88*fb01ff63SWilly Tarreau SET_ERRNO(ENOMEM); 89*fb01ff63SWilly Tarreau return -1; 90*fb01ff63SWilly Tarreau } 91*fb01ff63SWilly Tarreau return 0; 92bd8c8fbbSWilly Tarreau } 93bd8c8fbbSWilly Tarreau 94bd8c8fbbSWilly Tarreau static __attribute__((unused)) 95bd8c8fbbSWilly Tarreau void *sbrk(intptr_t inc) 96bd8c8fbbSWilly Tarreau { 97bd8c8fbbSWilly Tarreau /* first call to find current end */ 984201cfceSZhangjin Wu void *ret = sys_brk(0); 994201cfceSZhangjin Wu 1004201cfceSZhangjin Wu if (ret && sys_brk(ret + inc) == ret + inc) 101bd8c8fbbSWilly Tarreau return ret + inc; 102bd8c8fbbSWilly Tarreau 103*fb01ff63SWilly Tarreau SET_ERRNO(ENOMEM); 104*fb01ff63SWilly Tarreau return (void *)-1; 105bd8c8fbbSWilly Tarreau } 106bd8c8fbbSWilly Tarreau 107bd8c8fbbSWilly Tarreau 108bd8c8fbbSWilly Tarreau /* 109bd8c8fbbSWilly Tarreau * int chdir(const char *path); 110bd8c8fbbSWilly Tarreau */ 111bd8c8fbbSWilly Tarreau 112bd8c8fbbSWilly Tarreau static __attribute__((unused)) 113bd8c8fbbSWilly Tarreau int sys_chdir(const char *path) 114bd8c8fbbSWilly Tarreau { 115bd8c8fbbSWilly Tarreau return my_syscall1(__NR_chdir, path); 116bd8c8fbbSWilly Tarreau } 117bd8c8fbbSWilly Tarreau 118bd8c8fbbSWilly Tarreau static __attribute__((unused)) 119bd8c8fbbSWilly Tarreau int chdir(const char *path) 120bd8c8fbbSWilly Tarreau { 121d27447bcSZhangjin Wu return __sysret(sys_chdir(path)); 122bd8c8fbbSWilly Tarreau } 123bd8c8fbbSWilly Tarreau 124bd8c8fbbSWilly Tarreau 125bd8c8fbbSWilly Tarreau /* 126bd8c8fbbSWilly Tarreau * int chmod(const char *path, mode_t mode); 127bd8c8fbbSWilly Tarreau */ 128bd8c8fbbSWilly Tarreau 129bd8c8fbbSWilly Tarreau static __attribute__((unused)) 130bd8c8fbbSWilly Tarreau int sys_chmod(const char *path, mode_t mode) 131bd8c8fbbSWilly Tarreau { 132bd8c8fbbSWilly Tarreau #ifdef __NR_fchmodat 133bd8c8fbbSWilly Tarreau return my_syscall4(__NR_fchmodat, AT_FDCWD, path, mode, 0); 134bd8c8fbbSWilly Tarreau #elif defined(__NR_chmod) 135bd8c8fbbSWilly Tarreau return my_syscall2(__NR_chmod, path, mode); 136bd8c8fbbSWilly Tarreau #else 137ca50df30SZhangjin Wu return -ENOSYS; 138bd8c8fbbSWilly Tarreau #endif 139bd8c8fbbSWilly Tarreau } 140bd8c8fbbSWilly Tarreau 141bd8c8fbbSWilly Tarreau static __attribute__((unused)) 142bd8c8fbbSWilly Tarreau int chmod(const char *path, mode_t mode) 143bd8c8fbbSWilly Tarreau { 144d27447bcSZhangjin Wu return __sysret(sys_chmod(path, mode)); 145bd8c8fbbSWilly Tarreau } 146bd8c8fbbSWilly Tarreau 147bd8c8fbbSWilly Tarreau 148bd8c8fbbSWilly Tarreau /* 149bd8c8fbbSWilly Tarreau * int chown(const char *path, uid_t owner, gid_t group); 150bd8c8fbbSWilly Tarreau */ 151bd8c8fbbSWilly Tarreau 152bd8c8fbbSWilly Tarreau static __attribute__((unused)) 153bd8c8fbbSWilly Tarreau int sys_chown(const char *path, uid_t owner, gid_t group) 154bd8c8fbbSWilly Tarreau { 155bd8c8fbbSWilly Tarreau #ifdef __NR_fchownat 156bd8c8fbbSWilly Tarreau return my_syscall5(__NR_fchownat, AT_FDCWD, path, owner, group, 0); 157bd8c8fbbSWilly Tarreau #elif defined(__NR_chown) 158bd8c8fbbSWilly Tarreau return my_syscall3(__NR_chown, path, owner, group); 159bd8c8fbbSWilly Tarreau #else 160ca50df30SZhangjin Wu return -ENOSYS; 161bd8c8fbbSWilly Tarreau #endif 162bd8c8fbbSWilly Tarreau } 163bd8c8fbbSWilly Tarreau 164bd8c8fbbSWilly Tarreau static __attribute__((unused)) 165bd8c8fbbSWilly Tarreau int chown(const char *path, uid_t owner, gid_t group) 166bd8c8fbbSWilly Tarreau { 167d27447bcSZhangjin Wu return __sysret(sys_chown(path, owner, group)); 168bd8c8fbbSWilly Tarreau } 169bd8c8fbbSWilly Tarreau 170bd8c8fbbSWilly Tarreau 171bd8c8fbbSWilly Tarreau /* 172bd8c8fbbSWilly Tarreau * int chroot(const char *path); 173bd8c8fbbSWilly Tarreau */ 174bd8c8fbbSWilly Tarreau 175bd8c8fbbSWilly Tarreau static __attribute__((unused)) 176bd8c8fbbSWilly Tarreau int sys_chroot(const char *path) 177bd8c8fbbSWilly Tarreau { 178bd8c8fbbSWilly Tarreau return my_syscall1(__NR_chroot, path); 179bd8c8fbbSWilly Tarreau } 180bd8c8fbbSWilly Tarreau 181bd8c8fbbSWilly Tarreau static __attribute__((unused)) 182bd8c8fbbSWilly Tarreau int chroot(const char *path) 183bd8c8fbbSWilly Tarreau { 184d27447bcSZhangjin Wu return __sysret(sys_chroot(path)); 185bd8c8fbbSWilly Tarreau } 186bd8c8fbbSWilly Tarreau 187bd8c8fbbSWilly Tarreau 188bd8c8fbbSWilly Tarreau /* 189bd8c8fbbSWilly Tarreau * int close(int fd); 190bd8c8fbbSWilly Tarreau */ 191bd8c8fbbSWilly Tarreau 192bd8c8fbbSWilly Tarreau static __attribute__((unused)) 193bd8c8fbbSWilly Tarreau int sys_close(int fd) 194bd8c8fbbSWilly Tarreau { 195bd8c8fbbSWilly Tarreau return my_syscall1(__NR_close, fd); 196bd8c8fbbSWilly Tarreau } 197bd8c8fbbSWilly Tarreau 198bd8c8fbbSWilly Tarreau static __attribute__((unused)) 199bd8c8fbbSWilly Tarreau int close(int fd) 200bd8c8fbbSWilly Tarreau { 201d27447bcSZhangjin Wu return __sysret(sys_close(fd)); 202bd8c8fbbSWilly Tarreau } 203bd8c8fbbSWilly Tarreau 204bd8c8fbbSWilly Tarreau 205bd8c8fbbSWilly Tarreau /* 206bd8c8fbbSWilly Tarreau * int dup(int fd); 207bd8c8fbbSWilly Tarreau */ 208bd8c8fbbSWilly Tarreau 209bd8c8fbbSWilly Tarreau static __attribute__((unused)) 210bd8c8fbbSWilly Tarreau int sys_dup(int fd) 211bd8c8fbbSWilly Tarreau { 212bd8c8fbbSWilly Tarreau return my_syscall1(__NR_dup, fd); 213bd8c8fbbSWilly Tarreau } 214bd8c8fbbSWilly Tarreau 215bd8c8fbbSWilly Tarreau static __attribute__((unused)) 216bd8c8fbbSWilly Tarreau int dup(int fd) 217bd8c8fbbSWilly Tarreau { 218d27447bcSZhangjin Wu return __sysret(sys_dup(fd)); 219bd8c8fbbSWilly Tarreau } 220bd8c8fbbSWilly Tarreau 221bd8c8fbbSWilly Tarreau 222bd8c8fbbSWilly Tarreau /* 223bd8c8fbbSWilly Tarreau * int dup2(int old, int new); 224bd8c8fbbSWilly Tarreau */ 225bd8c8fbbSWilly Tarreau 226bd8c8fbbSWilly Tarreau static __attribute__((unused)) 227bd8c8fbbSWilly Tarreau int sys_dup2(int old, int new) 228bd8c8fbbSWilly Tarreau { 229bd8c8fbbSWilly Tarreau #ifdef __NR_dup3 230bd8c8fbbSWilly Tarreau return my_syscall3(__NR_dup3, old, new, 0); 231bd8c8fbbSWilly Tarreau #elif defined(__NR_dup2) 232bd8c8fbbSWilly Tarreau return my_syscall2(__NR_dup2, old, new); 233bd8c8fbbSWilly Tarreau #else 234ca50df30SZhangjin Wu return -ENOSYS; 235bd8c8fbbSWilly Tarreau #endif 236bd8c8fbbSWilly Tarreau } 237bd8c8fbbSWilly Tarreau 238bd8c8fbbSWilly Tarreau static __attribute__((unused)) 239bd8c8fbbSWilly Tarreau int dup2(int old, int new) 240bd8c8fbbSWilly Tarreau { 241d27447bcSZhangjin Wu return __sysret(sys_dup2(old, new)); 242bd8c8fbbSWilly Tarreau } 243bd8c8fbbSWilly Tarreau 244bd8c8fbbSWilly Tarreau 245bd8c8fbbSWilly Tarreau /* 246bd8c8fbbSWilly Tarreau * int dup3(int old, int new, int flags); 247bd8c8fbbSWilly Tarreau */ 248bd8c8fbbSWilly Tarreau 249bd8c8fbbSWilly Tarreau #ifdef __NR_dup3 250bd8c8fbbSWilly Tarreau static __attribute__((unused)) 251bd8c8fbbSWilly Tarreau int sys_dup3(int old, int new, int flags) 252bd8c8fbbSWilly Tarreau { 253bd8c8fbbSWilly Tarreau return my_syscall3(__NR_dup3, old, new, flags); 254bd8c8fbbSWilly Tarreau } 255bd8c8fbbSWilly Tarreau 256bd8c8fbbSWilly Tarreau static __attribute__((unused)) 257bd8c8fbbSWilly Tarreau int dup3(int old, int new, int flags) 258bd8c8fbbSWilly Tarreau { 259d27447bcSZhangjin Wu return __sysret(sys_dup3(old, new, flags)); 260bd8c8fbbSWilly Tarreau } 261bd8c8fbbSWilly Tarreau #endif 262bd8c8fbbSWilly Tarreau 263bd8c8fbbSWilly Tarreau 264bd8c8fbbSWilly Tarreau /* 265bd8c8fbbSWilly Tarreau * int execve(const char *filename, char *const argv[], char *const envp[]); 266bd8c8fbbSWilly Tarreau */ 267bd8c8fbbSWilly Tarreau 268bd8c8fbbSWilly Tarreau static __attribute__((unused)) 269bd8c8fbbSWilly Tarreau int sys_execve(const char *filename, char *const argv[], char *const envp[]) 270bd8c8fbbSWilly Tarreau { 271bd8c8fbbSWilly Tarreau return my_syscall3(__NR_execve, filename, argv, envp); 272bd8c8fbbSWilly Tarreau } 273bd8c8fbbSWilly Tarreau 274bd8c8fbbSWilly Tarreau static __attribute__((unused)) 275bd8c8fbbSWilly Tarreau int execve(const char *filename, char *const argv[], char *const envp[]) 276bd8c8fbbSWilly Tarreau { 277d27447bcSZhangjin Wu return __sysret(sys_execve(filename, argv, envp)); 278bd8c8fbbSWilly Tarreau } 279bd8c8fbbSWilly Tarreau 280bd8c8fbbSWilly Tarreau 281bd8c8fbbSWilly Tarreau /* 282bd8c8fbbSWilly Tarreau * void exit(int status); 283bd8c8fbbSWilly Tarreau */ 284bd8c8fbbSWilly Tarreau 285bd8c8fbbSWilly Tarreau static __attribute__((noreturn,unused)) 286bd8c8fbbSWilly Tarreau void sys_exit(int status) 287bd8c8fbbSWilly Tarreau { 288bd8c8fbbSWilly Tarreau my_syscall1(__NR_exit, status & 255); 289fddc8f81SThomas Weißschuh while(1); /* shut the "noreturn" warnings. */ 290bd8c8fbbSWilly Tarreau } 291bd8c8fbbSWilly Tarreau 292bd8c8fbbSWilly Tarreau static __attribute__((noreturn,unused)) 293bd8c8fbbSWilly Tarreau void exit(int status) 294bd8c8fbbSWilly Tarreau { 295bd8c8fbbSWilly Tarreau sys_exit(status); 296bd8c8fbbSWilly Tarreau } 297bd8c8fbbSWilly Tarreau 298bd8c8fbbSWilly Tarreau 299bd8c8fbbSWilly Tarreau /* 300bd8c8fbbSWilly Tarreau * pid_t fork(void); 301bd8c8fbbSWilly Tarreau */ 302bd8c8fbbSWilly Tarreau 303404fa87cSThomas Weißschuh #ifndef sys_fork 304bd8c8fbbSWilly Tarreau static __attribute__((unused)) 305bd8c8fbbSWilly Tarreau pid_t sys_fork(void) 306bd8c8fbbSWilly Tarreau { 307bd8c8fbbSWilly Tarreau #ifdef __NR_clone 308bd8c8fbbSWilly Tarreau /* note: some archs only have clone() and not fork(). Different archs 309bd8c8fbbSWilly Tarreau * have a different API, but most archs have the flags on first arg and 310bd8c8fbbSWilly Tarreau * will not use the rest with no other flag. 311bd8c8fbbSWilly Tarreau */ 312bd8c8fbbSWilly Tarreau return my_syscall5(__NR_clone, SIGCHLD, 0, 0, 0, 0); 313bd8c8fbbSWilly Tarreau #elif defined(__NR_fork) 314bd8c8fbbSWilly Tarreau return my_syscall0(__NR_fork); 315bd8c8fbbSWilly Tarreau #else 316ca50df30SZhangjin Wu return -ENOSYS; 317bd8c8fbbSWilly Tarreau #endif 318bd8c8fbbSWilly Tarreau } 319404fa87cSThomas Weißschuh #endif 320bd8c8fbbSWilly Tarreau 321bd8c8fbbSWilly Tarreau static __attribute__((unused)) 322bd8c8fbbSWilly Tarreau pid_t fork(void) 323bd8c8fbbSWilly Tarreau { 324d27447bcSZhangjin Wu return __sysret(sys_fork()); 325bd8c8fbbSWilly Tarreau } 326bd8c8fbbSWilly Tarreau 327bd8c8fbbSWilly Tarreau 328bd8c8fbbSWilly Tarreau /* 329bd8c8fbbSWilly Tarreau * int fsync(int fd); 330bd8c8fbbSWilly Tarreau */ 331bd8c8fbbSWilly Tarreau 332bd8c8fbbSWilly Tarreau static __attribute__((unused)) 333bd8c8fbbSWilly Tarreau int sys_fsync(int fd) 334bd8c8fbbSWilly Tarreau { 335bd8c8fbbSWilly Tarreau return my_syscall1(__NR_fsync, fd); 336bd8c8fbbSWilly Tarreau } 337bd8c8fbbSWilly Tarreau 338bd8c8fbbSWilly Tarreau static __attribute__((unused)) 339bd8c8fbbSWilly Tarreau int fsync(int fd) 340bd8c8fbbSWilly Tarreau { 341d27447bcSZhangjin Wu return __sysret(sys_fsync(fd)); 342bd8c8fbbSWilly Tarreau } 343bd8c8fbbSWilly Tarreau 344bd8c8fbbSWilly Tarreau 345bd8c8fbbSWilly Tarreau /* 346bd8c8fbbSWilly Tarreau * int getdents64(int fd, struct linux_dirent64 *dirp, int count); 347bd8c8fbbSWilly Tarreau */ 348bd8c8fbbSWilly Tarreau 349bd8c8fbbSWilly Tarreau static __attribute__((unused)) 350bd8c8fbbSWilly Tarreau int sys_getdents64(int fd, struct linux_dirent64 *dirp, int count) 351bd8c8fbbSWilly Tarreau { 352bd8c8fbbSWilly Tarreau return my_syscall3(__NR_getdents64, fd, dirp, count); 353bd8c8fbbSWilly Tarreau } 354bd8c8fbbSWilly Tarreau 355bd8c8fbbSWilly Tarreau static __attribute__((unused)) 356bd8c8fbbSWilly Tarreau int getdents64(int fd, struct linux_dirent64 *dirp, int count) 357bd8c8fbbSWilly Tarreau { 358d27447bcSZhangjin Wu return __sysret(sys_getdents64(fd, dirp, count)); 359bd8c8fbbSWilly Tarreau } 360bd8c8fbbSWilly Tarreau 361bd8c8fbbSWilly Tarreau 362bd8c8fbbSWilly Tarreau /* 363919d0532SWilly Tarreau * uid_t geteuid(void); 364919d0532SWilly Tarreau */ 365919d0532SWilly Tarreau 366919d0532SWilly Tarreau static __attribute__((unused)) 367919d0532SWilly Tarreau uid_t sys_geteuid(void) 368919d0532SWilly Tarreau { 369919d0532SWilly Tarreau #ifdef __NR_geteuid32 370919d0532SWilly Tarreau return my_syscall0(__NR_geteuid32); 371919d0532SWilly Tarreau #else 372919d0532SWilly Tarreau return my_syscall0(__NR_geteuid); 373919d0532SWilly Tarreau #endif 374919d0532SWilly Tarreau } 375919d0532SWilly Tarreau 376919d0532SWilly Tarreau static __attribute__((unused)) 377919d0532SWilly Tarreau uid_t geteuid(void) 378919d0532SWilly Tarreau { 379919d0532SWilly Tarreau return sys_geteuid(); 380919d0532SWilly Tarreau } 381919d0532SWilly Tarreau 382919d0532SWilly Tarreau 383919d0532SWilly Tarreau /* 384bd8c8fbbSWilly Tarreau * pid_t getpgid(pid_t pid); 385bd8c8fbbSWilly Tarreau */ 386bd8c8fbbSWilly Tarreau 387bd8c8fbbSWilly Tarreau static __attribute__((unused)) 388bd8c8fbbSWilly Tarreau pid_t sys_getpgid(pid_t pid) 389bd8c8fbbSWilly Tarreau { 390bd8c8fbbSWilly Tarreau return my_syscall1(__NR_getpgid, pid); 391bd8c8fbbSWilly Tarreau } 392bd8c8fbbSWilly Tarreau 393bd8c8fbbSWilly Tarreau static __attribute__((unused)) 394bd8c8fbbSWilly Tarreau pid_t getpgid(pid_t pid) 395bd8c8fbbSWilly Tarreau { 396d27447bcSZhangjin Wu return __sysret(sys_getpgid(pid)); 397bd8c8fbbSWilly Tarreau } 398bd8c8fbbSWilly Tarreau 399bd8c8fbbSWilly Tarreau 400bd8c8fbbSWilly Tarreau /* 401bd8c8fbbSWilly Tarreau * pid_t getpgrp(void); 402bd8c8fbbSWilly Tarreau */ 403bd8c8fbbSWilly Tarreau 404bd8c8fbbSWilly Tarreau static __attribute__((unused)) 405bd8c8fbbSWilly Tarreau pid_t sys_getpgrp(void) 406bd8c8fbbSWilly Tarreau { 407bd8c8fbbSWilly Tarreau return sys_getpgid(0); 408bd8c8fbbSWilly Tarreau } 409bd8c8fbbSWilly Tarreau 410bd8c8fbbSWilly Tarreau static __attribute__((unused)) 411bd8c8fbbSWilly Tarreau pid_t getpgrp(void) 412bd8c8fbbSWilly Tarreau { 413830acd08SWilly Tarreau return sys_getpgrp(); 414bd8c8fbbSWilly Tarreau } 415bd8c8fbbSWilly Tarreau 416bd8c8fbbSWilly Tarreau 417bd8c8fbbSWilly Tarreau /* 418bd8c8fbbSWilly Tarreau * pid_t getpid(void); 419bd8c8fbbSWilly Tarreau */ 420bd8c8fbbSWilly Tarreau 421bd8c8fbbSWilly Tarreau static __attribute__((unused)) 422bd8c8fbbSWilly Tarreau pid_t sys_getpid(void) 423bd8c8fbbSWilly Tarreau { 424bd8c8fbbSWilly Tarreau return my_syscall0(__NR_getpid); 425bd8c8fbbSWilly Tarreau } 426bd8c8fbbSWilly Tarreau 427bd8c8fbbSWilly Tarreau static __attribute__((unused)) 428bd8c8fbbSWilly Tarreau pid_t getpid(void) 429bd8c8fbbSWilly Tarreau { 430830acd08SWilly Tarreau return sys_getpid(); 431bd8c8fbbSWilly Tarreau } 432bd8c8fbbSWilly Tarreau 433bd8c8fbbSWilly Tarreau 434bd8c8fbbSWilly Tarreau /* 43554abe359SWilly Tarreau * pid_t getppid(void); 43654abe359SWilly Tarreau */ 43754abe359SWilly Tarreau 43854abe359SWilly Tarreau static __attribute__((unused)) 43954abe359SWilly Tarreau pid_t sys_getppid(void) 44054abe359SWilly Tarreau { 44154abe359SWilly Tarreau return my_syscall0(__NR_getppid); 44254abe359SWilly Tarreau } 44354abe359SWilly Tarreau 44454abe359SWilly Tarreau static __attribute__((unused)) 44554abe359SWilly Tarreau pid_t getppid(void) 44654abe359SWilly Tarreau { 44754abe359SWilly Tarreau return sys_getppid(); 44854abe359SWilly Tarreau } 44954abe359SWilly Tarreau 45054abe359SWilly Tarreau 45154abe359SWilly Tarreau /* 452bd8c8fbbSWilly Tarreau * pid_t gettid(void); 453bd8c8fbbSWilly Tarreau */ 454bd8c8fbbSWilly Tarreau 455bd8c8fbbSWilly Tarreau static __attribute__((unused)) 456bd8c8fbbSWilly Tarreau pid_t sys_gettid(void) 457bd8c8fbbSWilly Tarreau { 458bd8c8fbbSWilly Tarreau return my_syscall0(__NR_gettid); 459bd8c8fbbSWilly Tarreau } 460bd8c8fbbSWilly Tarreau 461bd8c8fbbSWilly Tarreau static __attribute__((unused)) 462bd8c8fbbSWilly Tarreau pid_t gettid(void) 463bd8c8fbbSWilly Tarreau { 464830acd08SWilly Tarreau return sys_gettid(); 465bd8c8fbbSWilly Tarreau } 466bd8c8fbbSWilly Tarreau 4677efd762eSAmmar Faizi static unsigned long getauxval(unsigned long key); 4687efd762eSAmmar Faizi 4697efd762eSAmmar Faizi /* 47064077502SThomas Weißschuh * int getpagesize(void); 4717efd762eSAmmar Faizi */ 4727efd762eSAmmar Faizi 4737efd762eSAmmar Faizi static __attribute__((unused)) 47464077502SThomas Weißschuh int getpagesize(void) 4757efd762eSAmmar Faizi { 47604694658SThomas Weißschuh return __sysret((int)getauxval(AT_PAGESZ) ?: -ENOENT); 4777efd762eSAmmar Faizi } 4787efd762eSAmmar Faizi 479bd8c8fbbSWilly Tarreau 480bd8c8fbbSWilly Tarreau /* 481bd8c8fbbSWilly Tarreau * int gettimeofday(struct timeval *tv, struct timezone *tz); 482bd8c8fbbSWilly Tarreau */ 483bd8c8fbbSWilly Tarreau 484bd8c8fbbSWilly Tarreau static __attribute__((unused)) 485bd8c8fbbSWilly Tarreau int sys_gettimeofday(struct timeval *tv, struct timezone *tz) 486bd8c8fbbSWilly Tarreau { 4872f98aca8SZhangjin Wu #ifdef __NR_gettimeofday 488bd8c8fbbSWilly Tarreau return my_syscall2(__NR_gettimeofday, tv, tz); 4892f98aca8SZhangjin Wu #else 4902f98aca8SZhangjin Wu return -ENOSYS; 4912f98aca8SZhangjin Wu #endif 492bd8c8fbbSWilly Tarreau } 493bd8c8fbbSWilly Tarreau 494bd8c8fbbSWilly Tarreau static __attribute__((unused)) 495bd8c8fbbSWilly Tarreau int gettimeofday(struct timeval *tv, struct timezone *tz) 496bd8c8fbbSWilly Tarreau { 497d27447bcSZhangjin Wu return __sysret(sys_gettimeofday(tv, tz)); 498bd8c8fbbSWilly Tarreau } 499bd8c8fbbSWilly Tarreau 500bd8c8fbbSWilly Tarreau 501bd8c8fbbSWilly Tarreau /* 502919d0532SWilly Tarreau * uid_t getuid(void); 503919d0532SWilly Tarreau */ 504919d0532SWilly Tarreau 505919d0532SWilly Tarreau static __attribute__((unused)) 506919d0532SWilly Tarreau uid_t sys_getuid(void) 507919d0532SWilly Tarreau { 508919d0532SWilly Tarreau #ifdef __NR_getuid32 509919d0532SWilly Tarreau return my_syscall0(__NR_getuid32); 510919d0532SWilly Tarreau #else 511919d0532SWilly Tarreau return my_syscall0(__NR_getuid); 512919d0532SWilly Tarreau #endif 513919d0532SWilly Tarreau } 514919d0532SWilly Tarreau 515919d0532SWilly Tarreau static __attribute__((unused)) 516919d0532SWilly Tarreau uid_t getuid(void) 517919d0532SWilly Tarreau { 518919d0532SWilly Tarreau return sys_getuid(); 519919d0532SWilly Tarreau } 520919d0532SWilly Tarreau 521919d0532SWilly Tarreau 522919d0532SWilly Tarreau /* 523bd8c8fbbSWilly Tarreau * int ioctl(int fd, unsigned long req, void *value); 524bd8c8fbbSWilly Tarreau */ 525bd8c8fbbSWilly Tarreau 526bd8c8fbbSWilly Tarreau static __attribute__((unused)) 527bd8c8fbbSWilly Tarreau int sys_ioctl(int fd, unsigned long req, void *value) 528bd8c8fbbSWilly Tarreau { 529bd8c8fbbSWilly Tarreau return my_syscall3(__NR_ioctl, fd, req, value); 530bd8c8fbbSWilly Tarreau } 531bd8c8fbbSWilly Tarreau 532bd8c8fbbSWilly Tarreau static __attribute__((unused)) 533bd8c8fbbSWilly Tarreau int ioctl(int fd, unsigned long req, void *value) 534bd8c8fbbSWilly Tarreau { 535d27447bcSZhangjin Wu return __sysret(sys_ioctl(fd, req, value)); 536bd8c8fbbSWilly Tarreau } 537bd8c8fbbSWilly Tarreau 538bd8c8fbbSWilly Tarreau /* 539bd8c8fbbSWilly Tarreau * int kill(pid_t pid, int signal); 540bd8c8fbbSWilly Tarreau */ 541bd8c8fbbSWilly Tarreau 542bd8c8fbbSWilly Tarreau static __attribute__((unused)) 543bd8c8fbbSWilly Tarreau int sys_kill(pid_t pid, int signal) 544bd8c8fbbSWilly Tarreau { 545bd8c8fbbSWilly Tarreau return my_syscall2(__NR_kill, pid, signal); 546bd8c8fbbSWilly Tarreau } 547bd8c8fbbSWilly Tarreau 548bd8c8fbbSWilly Tarreau static __attribute__((unused)) 549bd8c8fbbSWilly Tarreau int kill(pid_t pid, int signal) 550bd8c8fbbSWilly Tarreau { 551d27447bcSZhangjin Wu return __sysret(sys_kill(pid, signal)); 552bd8c8fbbSWilly Tarreau } 553bd8c8fbbSWilly Tarreau 554bd8c8fbbSWilly Tarreau 555bd8c8fbbSWilly Tarreau /* 556bd8c8fbbSWilly Tarreau * int link(const char *old, const char *new); 557bd8c8fbbSWilly Tarreau */ 558bd8c8fbbSWilly Tarreau 559bd8c8fbbSWilly Tarreau static __attribute__((unused)) 560bd8c8fbbSWilly Tarreau int sys_link(const char *old, const char *new) 561bd8c8fbbSWilly Tarreau { 562bd8c8fbbSWilly Tarreau #ifdef __NR_linkat 563bd8c8fbbSWilly Tarreau return my_syscall5(__NR_linkat, AT_FDCWD, old, AT_FDCWD, new, 0); 564bd8c8fbbSWilly Tarreau #elif defined(__NR_link) 565bd8c8fbbSWilly Tarreau return my_syscall2(__NR_link, old, new); 566bd8c8fbbSWilly Tarreau #else 567ca50df30SZhangjin Wu return -ENOSYS; 568bd8c8fbbSWilly Tarreau #endif 569bd8c8fbbSWilly Tarreau } 570bd8c8fbbSWilly Tarreau 571bd8c8fbbSWilly Tarreau static __attribute__((unused)) 572bd8c8fbbSWilly Tarreau int link(const char *old, const char *new) 573bd8c8fbbSWilly Tarreau { 574d27447bcSZhangjin Wu return __sysret(sys_link(old, new)); 575bd8c8fbbSWilly Tarreau } 576bd8c8fbbSWilly Tarreau 577bd8c8fbbSWilly Tarreau 578bd8c8fbbSWilly Tarreau /* 579bd8c8fbbSWilly Tarreau * off_t lseek(int fd, off_t offset, int whence); 580bd8c8fbbSWilly Tarreau */ 581bd8c8fbbSWilly Tarreau 582bd8c8fbbSWilly Tarreau static __attribute__((unused)) 583bd8c8fbbSWilly Tarreau off_t sys_lseek(int fd, off_t offset, int whence) 584bd8c8fbbSWilly Tarreau { 5852f98aca8SZhangjin Wu #ifdef __NR_lseek 586bd8c8fbbSWilly Tarreau return my_syscall3(__NR_lseek, fd, offset, whence); 5872f98aca8SZhangjin Wu #else 5882f98aca8SZhangjin Wu return -ENOSYS; 5892f98aca8SZhangjin Wu #endif 590bd8c8fbbSWilly Tarreau } 591bd8c8fbbSWilly Tarreau 592bd8c8fbbSWilly Tarreau static __attribute__((unused)) 593bd8c8fbbSWilly Tarreau off_t lseek(int fd, off_t offset, int whence) 594bd8c8fbbSWilly Tarreau { 595d27447bcSZhangjin Wu return __sysret(sys_lseek(fd, offset, whence)); 596bd8c8fbbSWilly Tarreau } 597bd8c8fbbSWilly Tarreau 598bd8c8fbbSWilly Tarreau 599bd8c8fbbSWilly Tarreau /* 600bd8c8fbbSWilly Tarreau * int mkdir(const char *path, mode_t mode); 601bd8c8fbbSWilly Tarreau */ 602bd8c8fbbSWilly Tarreau 603bd8c8fbbSWilly Tarreau static __attribute__((unused)) 604bd8c8fbbSWilly Tarreau int sys_mkdir(const char *path, mode_t mode) 605bd8c8fbbSWilly Tarreau { 606bd8c8fbbSWilly Tarreau #ifdef __NR_mkdirat 607bd8c8fbbSWilly Tarreau return my_syscall3(__NR_mkdirat, AT_FDCWD, path, mode); 608bd8c8fbbSWilly Tarreau #elif defined(__NR_mkdir) 609bd8c8fbbSWilly Tarreau return my_syscall2(__NR_mkdir, path, mode); 610bd8c8fbbSWilly Tarreau #else 611ca50df30SZhangjin Wu return -ENOSYS; 612bd8c8fbbSWilly Tarreau #endif 613bd8c8fbbSWilly Tarreau } 614bd8c8fbbSWilly Tarreau 615bd8c8fbbSWilly Tarreau static __attribute__((unused)) 616bd8c8fbbSWilly Tarreau int mkdir(const char *path, mode_t mode) 617bd8c8fbbSWilly Tarreau { 618d27447bcSZhangjin Wu return __sysret(sys_mkdir(path, mode)); 619bd8c8fbbSWilly Tarreau } 620bd8c8fbbSWilly Tarreau 621f4191f3dSZhangjin Wu /* 622f4191f3dSZhangjin Wu * int rmdir(const char *path); 623f4191f3dSZhangjin Wu */ 624f4191f3dSZhangjin Wu 625f4191f3dSZhangjin Wu static __attribute__((unused)) 626f4191f3dSZhangjin Wu int sys_rmdir(const char *path) 627f4191f3dSZhangjin Wu { 628f4191f3dSZhangjin Wu #ifdef __NR_rmdir 629f4191f3dSZhangjin Wu return my_syscall1(__NR_rmdir, path); 630f4191f3dSZhangjin Wu #elif defined(__NR_unlinkat) 631f4191f3dSZhangjin Wu return my_syscall3(__NR_unlinkat, AT_FDCWD, path, AT_REMOVEDIR); 632f4191f3dSZhangjin Wu #else 633f4191f3dSZhangjin Wu return -ENOSYS; 634f4191f3dSZhangjin Wu #endif 635f4191f3dSZhangjin Wu } 636f4191f3dSZhangjin Wu 637f4191f3dSZhangjin Wu static __attribute__((unused)) 638f4191f3dSZhangjin Wu int rmdir(const char *path) 639f4191f3dSZhangjin Wu { 640f4191f3dSZhangjin Wu return __sysret(sys_rmdir(path)); 641f4191f3dSZhangjin Wu } 642f4191f3dSZhangjin Wu 643bd8c8fbbSWilly Tarreau 644bd8c8fbbSWilly Tarreau /* 645bd8c8fbbSWilly Tarreau * int mknod(const char *path, mode_t mode, dev_t dev); 646bd8c8fbbSWilly Tarreau */ 647bd8c8fbbSWilly Tarreau 648bd8c8fbbSWilly Tarreau static __attribute__((unused)) 649bd8c8fbbSWilly Tarreau long sys_mknod(const char *path, mode_t mode, dev_t dev) 650bd8c8fbbSWilly Tarreau { 651bd8c8fbbSWilly Tarreau #ifdef __NR_mknodat 652bd8c8fbbSWilly Tarreau return my_syscall4(__NR_mknodat, AT_FDCWD, path, mode, dev); 653bd8c8fbbSWilly Tarreau #elif defined(__NR_mknod) 654bd8c8fbbSWilly Tarreau return my_syscall3(__NR_mknod, path, mode, dev); 655bd8c8fbbSWilly Tarreau #else 656ca50df30SZhangjin Wu return -ENOSYS; 657bd8c8fbbSWilly Tarreau #endif 658bd8c8fbbSWilly Tarreau } 659bd8c8fbbSWilly Tarreau 660bd8c8fbbSWilly Tarreau static __attribute__((unused)) 661bd8c8fbbSWilly Tarreau int mknod(const char *path, mode_t mode, dev_t dev) 662bd8c8fbbSWilly Tarreau { 663d27447bcSZhangjin Wu return __sysret(sys_mknod(path, mode, dev)); 664bd8c8fbbSWilly Tarreau } 665bd8c8fbbSWilly Tarreau 66618a5a09dSSven Schnelle #ifndef sys_mmap 667544fa1a2SAmmar Faizi static __attribute__((unused)) 668544fa1a2SAmmar Faizi void *sys_mmap(void *addr, size_t length, int prot, int flags, int fd, 669544fa1a2SAmmar Faizi off_t offset) 670544fa1a2SAmmar Faizi { 671544fa1a2SAmmar Faizi int n; 672544fa1a2SAmmar Faizi 673364702f7SWilly Tarreau #if defined(__NR_mmap2) 674544fa1a2SAmmar Faizi n = __NR_mmap2; 675544fa1a2SAmmar Faizi offset >>= 12; 676544fa1a2SAmmar Faizi #else 677544fa1a2SAmmar Faizi n = __NR_mmap; 678544fa1a2SAmmar Faizi #endif 679544fa1a2SAmmar Faizi 680544fa1a2SAmmar Faizi return (void *)my_syscall6(n, addr, length, prot, flags, fd, offset); 681544fa1a2SAmmar Faizi } 68218a5a09dSSven Schnelle #endif 683544fa1a2SAmmar Faizi 684924e9539SZhangjin Wu /* Note that on Linux, MAP_FAILED is -1 so we can use the generic __sysret() 685924e9539SZhangjin Wu * which returns -1 upon error and still satisfy user land that checks for 686924e9539SZhangjin Wu * MAP_FAILED. 687924e9539SZhangjin Wu */ 688924e9539SZhangjin Wu 689544fa1a2SAmmar Faizi static __attribute__((unused)) 690544fa1a2SAmmar Faizi void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset) 691544fa1a2SAmmar Faizi { 692*fb01ff63SWilly Tarreau void *ret = sys_mmap(addr, length, prot, flags, fd, offset); 693*fb01ff63SWilly Tarreau 694*fb01ff63SWilly Tarreau if ((unsigned long)ret >= -4095UL) { 695*fb01ff63SWilly Tarreau SET_ERRNO(-(long)ret); 696*fb01ff63SWilly Tarreau ret = MAP_FAILED; 697*fb01ff63SWilly Tarreau } 698*fb01ff63SWilly Tarreau return ret; 699544fa1a2SAmmar Faizi } 700544fa1a2SAmmar Faizi 701544fa1a2SAmmar Faizi static __attribute__((unused)) 702544fa1a2SAmmar Faizi int sys_munmap(void *addr, size_t length) 703544fa1a2SAmmar Faizi { 704544fa1a2SAmmar Faizi return my_syscall2(__NR_munmap, addr, length); 705544fa1a2SAmmar Faizi } 706544fa1a2SAmmar Faizi 707544fa1a2SAmmar Faizi static __attribute__((unused)) 708544fa1a2SAmmar Faizi int munmap(void *addr, size_t length) 709544fa1a2SAmmar Faizi { 710d27447bcSZhangjin Wu return __sysret(sys_munmap(addr, length)); 711544fa1a2SAmmar Faizi } 712bd8c8fbbSWilly Tarreau 713bd8c8fbbSWilly Tarreau /* 714bd8c8fbbSWilly Tarreau * int mount(const char *source, const char *target, 715bd8c8fbbSWilly Tarreau * const char *fstype, unsigned long flags, 716bd8c8fbbSWilly Tarreau * const void *data); 717bd8c8fbbSWilly Tarreau */ 718bd8c8fbbSWilly Tarreau static __attribute__((unused)) 719bd8c8fbbSWilly Tarreau int sys_mount(const char *src, const char *tgt, const char *fst, 720bd8c8fbbSWilly Tarreau unsigned long flags, const void *data) 721bd8c8fbbSWilly Tarreau { 722bd8c8fbbSWilly Tarreau return my_syscall5(__NR_mount, src, tgt, fst, flags, data); 723bd8c8fbbSWilly Tarreau } 724bd8c8fbbSWilly Tarreau 725bd8c8fbbSWilly Tarreau static __attribute__((unused)) 726bd8c8fbbSWilly Tarreau int mount(const char *src, const char *tgt, 727bd8c8fbbSWilly Tarreau const char *fst, unsigned long flags, 728bd8c8fbbSWilly Tarreau const void *data) 729bd8c8fbbSWilly Tarreau { 730d27447bcSZhangjin Wu return __sysret(sys_mount(src, tgt, fst, flags, data)); 731bd8c8fbbSWilly Tarreau } 732bd8c8fbbSWilly Tarreau 733bd8c8fbbSWilly Tarreau 734bd8c8fbbSWilly Tarreau /* 735a7604ba1SWilly Tarreau * int open(const char *path, int flags[, mode_t mode]); 736bd8c8fbbSWilly Tarreau */ 737bd8c8fbbSWilly Tarreau 738bd8c8fbbSWilly Tarreau static __attribute__((unused)) 739bd8c8fbbSWilly Tarreau int sys_open(const char *path, int flags, mode_t mode) 740bd8c8fbbSWilly Tarreau { 741bd8c8fbbSWilly Tarreau #ifdef __NR_openat 742bd8c8fbbSWilly Tarreau return my_syscall4(__NR_openat, AT_FDCWD, path, flags, mode); 743bd8c8fbbSWilly Tarreau #elif defined(__NR_open) 744bd8c8fbbSWilly Tarreau return my_syscall3(__NR_open, path, flags, mode); 745bd8c8fbbSWilly Tarreau #else 746ca50df30SZhangjin Wu return -ENOSYS; 747bd8c8fbbSWilly Tarreau #endif 748bd8c8fbbSWilly Tarreau } 749bd8c8fbbSWilly Tarreau 750bd8c8fbbSWilly Tarreau static __attribute__((unused)) 751a7604ba1SWilly Tarreau int open(const char *path, int flags, ...) 752bd8c8fbbSWilly Tarreau { 753a7604ba1SWilly Tarreau mode_t mode = 0; 754a7604ba1SWilly Tarreau 755a7604ba1SWilly Tarreau if (flags & O_CREAT) { 756a7604ba1SWilly Tarreau va_list args; 757a7604ba1SWilly Tarreau 758a7604ba1SWilly Tarreau va_start(args, flags); 759f62ec079SZhangjin Wu mode = va_arg(args, int); 760a7604ba1SWilly Tarreau va_end(args); 761a7604ba1SWilly Tarreau } 762a7604ba1SWilly Tarreau 763d27447bcSZhangjin Wu return __sysret(sys_open(path, flags, mode)); 764bd8c8fbbSWilly Tarreau } 765bd8c8fbbSWilly Tarreau 766bd8c8fbbSWilly Tarreau 767bd8c8fbbSWilly Tarreau /* 7683ec38af6SYuan Tan * int pipe2(int pipefd[2], int flags); 7693ec38af6SYuan Tan * int pipe(int pipefd[2]); 7703ec38af6SYuan Tan */ 7713ec38af6SYuan Tan 7723ec38af6SYuan Tan static __attribute__((unused)) 7733ec38af6SYuan Tan int sys_pipe2(int pipefd[2], int flags) 7743ec38af6SYuan Tan { 7753ec38af6SYuan Tan return my_syscall2(__NR_pipe2, pipefd, flags); 7763ec38af6SYuan Tan } 7773ec38af6SYuan Tan 7783ec38af6SYuan Tan static __attribute__((unused)) 7793ec38af6SYuan Tan int pipe2(int pipefd[2], int flags) 7803ec38af6SYuan Tan { 7813ec38af6SYuan Tan return __sysret(sys_pipe2(pipefd, flags)); 7823ec38af6SYuan Tan } 7833ec38af6SYuan Tan 7843ec38af6SYuan Tan static __attribute__((unused)) 7853ec38af6SYuan Tan int pipe(int pipefd[2]) 7863ec38af6SYuan Tan { 7873ec38af6SYuan Tan return pipe2(pipefd, 0); 7883ec38af6SYuan Tan } 7893ec38af6SYuan Tan 7903ec38af6SYuan Tan 7913ec38af6SYuan Tan /* 792208aa9d9SThomas Weißschuh * int prctl(int option, unsigned long arg2, unsigned long arg3, 793208aa9d9SThomas Weißschuh * unsigned long arg4, unsigned long arg5); 794208aa9d9SThomas Weißschuh */ 795208aa9d9SThomas Weißschuh 796208aa9d9SThomas Weißschuh static __attribute__((unused)) 797208aa9d9SThomas Weißschuh int sys_prctl(int option, unsigned long arg2, unsigned long arg3, 798208aa9d9SThomas Weißschuh unsigned long arg4, unsigned long arg5) 799208aa9d9SThomas Weißschuh { 800208aa9d9SThomas Weißschuh return my_syscall5(__NR_prctl, option, arg2, arg3, arg4, arg5); 801208aa9d9SThomas Weißschuh } 802208aa9d9SThomas Weißschuh 803208aa9d9SThomas Weißschuh static __attribute__((unused)) 804208aa9d9SThomas Weißschuh int prctl(int option, unsigned long arg2, unsigned long arg3, 805208aa9d9SThomas Weißschuh unsigned long arg4, unsigned long arg5) 806208aa9d9SThomas Weißschuh { 807d27447bcSZhangjin Wu return __sysret(sys_prctl(option, arg2, arg3, arg4, arg5)); 808208aa9d9SThomas Weißschuh } 809208aa9d9SThomas Weißschuh 810208aa9d9SThomas Weißschuh 811208aa9d9SThomas Weißschuh /* 812bd8c8fbbSWilly Tarreau * int pivot_root(const char *new, const char *old); 813bd8c8fbbSWilly Tarreau */ 814bd8c8fbbSWilly Tarreau 815bd8c8fbbSWilly Tarreau static __attribute__((unused)) 816bd8c8fbbSWilly Tarreau int sys_pivot_root(const char *new, const char *old) 817bd8c8fbbSWilly Tarreau { 818bd8c8fbbSWilly Tarreau return my_syscall2(__NR_pivot_root, new, old); 819bd8c8fbbSWilly Tarreau } 820bd8c8fbbSWilly Tarreau 821bd8c8fbbSWilly Tarreau static __attribute__((unused)) 822bd8c8fbbSWilly Tarreau int pivot_root(const char *new, const char *old) 823bd8c8fbbSWilly Tarreau { 824d27447bcSZhangjin Wu return __sysret(sys_pivot_root(new, old)); 825bd8c8fbbSWilly Tarreau } 826bd8c8fbbSWilly Tarreau 827bd8c8fbbSWilly Tarreau 828bd8c8fbbSWilly Tarreau /* 829bd8c8fbbSWilly Tarreau * int poll(struct pollfd *fds, int nfds, int timeout); 830bd8c8fbbSWilly Tarreau */ 831bd8c8fbbSWilly Tarreau 832bd8c8fbbSWilly Tarreau static __attribute__((unused)) 833bd8c8fbbSWilly Tarreau int sys_poll(struct pollfd *fds, int nfds, int timeout) 834bd8c8fbbSWilly Tarreau { 835bd8c8fbbSWilly Tarreau #if defined(__NR_ppoll) 836bd8c8fbbSWilly Tarreau struct timespec t; 837bd8c8fbbSWilly Tarreau 838bd8c8fbbSWilly Tarreau if (timeout >= 0) { 839bd8c8fbbSWilly Tarreau t.tv_sec = timeout / 1000; 840bd8c8fbbSWilly Tarreau t.tv_nsec = (timeout % 1000) * 1000000; 841bd8c8fbbSWilly Tarreau } 8420dd2fdbfSZhangjin Wu return my_syscall5(__NR_ppoll, fds, nfds, (timeout >= 0) ? &t : NULL, NULL, 0); 843bd8c8fbbSWilly Tarreau #elif defined(__NR_poll) 844bd8c8fbbSWilly Tarreau return my_syscall3(__NR_poll, fds, nfds, timeout); 845bd8c8fbbSWilly Tarreau #else 846ca50df30SZhangjin Wu return -ENOSYS; 847bd8c8fbbSWilly Tarreau #endif 848bd8c8fbbSWilly Tarreau } 849bd8c8fbbSWilly Tarreau 850bd8c8fbbSWilly Tarreau static __attribute__((unused)) 851bd8c8fbbSWilly Tarreau int poll(struct pollfd *fds, int nfds, int timeout) 852bd8c8fbbSWilly Tarreau { 853d27447bcSZhangjin Wu return __sysret(sys_poll(fds, nfds, timeout)); 854bd8c8fbbSWilly Tarreau } 855bd8c8fbbSWilly Tarreau 856bd8c8fbbSWilly Tarreau 857bd8c8fbbSWilly Tarreau /* 858bd8c8fbbSWilly Tarreau * ssize_t read(int fd, void *buf, size_t count); 859bd8c8fbbSWilly Tarreau */ 860bd8c8fbbSWilly Tarreau 861bd8c8fbbSWilly Tarreau static __attribute__((unused)) 862bd8c8fbbSWilly Tarreau ssize_t sys_read(int fd, void *buf, size_t count) 863bd8c8fbbSWilly Tarreau { 864bd8c8fbbSWilly Tarreau return my_syscall3(__NR_read, fd, buf, count); 865bd8c8fbbSWilly Tarreau } 866bd8c8fbbSWilly Tarreau 867bd8c8fbbSWilly Tarreau static __attribute__((unused)) 868bd8c8fbbSWilly Tarreau ssize_t read(int fd, void *buf, size_t count) 869bd8c8fbbSWilly Tarreau { 870d27447bcSZhangjin Wu return __sysret(sys_read(fd, buf, count)); 871bd8c8fbbSWilly Tarreau } 872bd8c8fbbSWilly Tarreau 873bd8c8fbbSWilly Tarreau 874bd8c8fbbSWilly Tarreau /* 875bd8c8fbbSWilly Tarreau * int reboot(int cmd); 876bd8c8fbbSWilly Tarreau * <cmd> is among LINUX_REBOOT_CMD_* 877bd8c8fbbSWilly Tarreau */ 878bd8c8fbbSWilly Tarreau 879bd8c8fbbSWilly Tarreau static __attribute__((unused)) 880bd8c8fbbSWilly Tarreau ssize_t sys_reboot(int magic1, int magic2, int cmd, void *arg) 881bd8c8fbbSWilly Tarreau { 882bd8c8fbbSWilly Tarreau return my_syscall4(__NR_reboot, magic1, magic2, cmd, arg); 883bd8c8fbbSWilly Tarreau } 884bd8c8fbbSWilly Tarreau 885bd8c8fbbSWilly Tarreau static __attribute__((unused)) 886bd8c8fbbSWilly Tarreau int reboot(int cmd) 887bd8c8fbbSWilly Tarreau { 888d27447bcSZhangjin Wu return __sysret(sys_reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, 0)); 889bd8c8fbbSWilly Tarreau } 890bd8c8fbbSWilly Tarreau 891bd8c8fbbSWilly Tarreau 892bd8c8fbbSWilly Tarreau /* 893bd8c8fbbSWilly Tarreau * int sched_yield(void); 894bd8c8fbbSWilly Tarreau */ 895bd8c8fbbSWilly Tarreau 896bd8c8fbbSWilly Tarreau static __attribute__((unused)) 897bd8c8fbbSWilly Tarreau int sys_sched_yield(void) 898bd8c8fbbSWilly Tarreau { 899bd8c8fbbSWilly Tarreau return my_syscall0(__NR_sched_yield); 900bd8c8fbbSWilly Tarreau } 901bd8c8fbbSWilly Tarreau 902bd8c8fbbSWilly Tarreau static __attribute__((unused)) 903bd8c8fbbSWilly Tarreau int sched_yield(void) 904bd8c8fbbSWilly Tarreau { 905d27447bcSZhangjin Wu return __sysret(sys_sched_yield()); 906bd8c8fbbSWilly Tarreau } 907bd8c8fbbSWilly Tarreau 908bd8c8fbbSWilly Tarreau 909bd8c8fbbSWilly Tarreau /* 910bd8c8fbbSWilly Tarreau * int select(int nfds, fd_set *read_fds, fd_set *write_fds, 911bd8c8fbbSWilly Tarreau * fd_set *except_fds, struct timeval *timeout); 912bd8c8fbbSWilly Tarreau */ 913bd8c8fbbSWilly Tarreau 914bd8c8fbbSWilly Tarreau static __attribute__((unused)) 915bd8c8fbbSWilly Tarreau int sys_select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout) 916bd8c8fbbSWilly Tarreau { 917bd8c8fbbSWilly Tarreau #if defined(__ARCH_WANT_SYS_OLD_SELECT) && !defined(__NR__newselect) 918bd8c8fbbSWilly Tarreau struct sel_arg_struct { 919bd8c8fbbSWilly Tarreau unsigned long n; 920bd8c8fbbSWilly Tarreau fd_set *r, *w, *e; 921bd8c8fbbSWilly Tarreau struct timeval *t; 922bd8c8fbbSWilly Tarreau } arg = { .n = nfds, .r = rfds, .w = wfds, .e = efds, .t = timeout }; 923bd8c8fbbSWilly Tarreau return my_syscall1(__NR_select, &arg); 924bd8c8fbbSWilly Tarreau #elif defined(__ARCH_WANT_SYS_PSELECT6) && defined(__NR_pselect6) 925bd8c8fbbSWilly Tarreau struct timespec t; 926bd8c8fbbSWilly Tarreau 927bd8c8fbbSWilly Tarreau if (timeout) { 928bd8c8fbbSWilly Tarreau t.tv_sec = timeout->tv_sec; 929bd8c8fbbSWilly Tarreau t.tv_nsec = timeout->tv_usec * 1000; 930bd8c8fbbSWilly Tarreau } 931bd8c8fbbSWilly Tarreau return my_syscall6(__NR_pselect6, nfds, rfds, wfds, efds, timeout ? &t : NULL, NULL); 932bd8c8fbbSWilly Tarreau #elif defined(__NR__newselect) || defined(__NR_select) 933bd8c8fbbSWilly Tarreau #ifndef __NR__newselect 934bd8c8fbbSWilly Tarreau #define __NR__newselect __NR_select 935bd8c8fbbSWilly Tarreau #endif 936bd8c8fbbSWilly Tarreau return my_syscall5(__NR__newselect, nfds, rfds, wfds, efds, timeout); 937bd8c8fbbSWilly Tarreau #else 938ca50df30SZhangjin Wu return -ENOSYS; 939bd8c8fbbSWilly Tarreau #endif 940bd8c8fbbSWilly Tarreau } 941bd8c8fbbSWilly Tarreau 942bd8c8fbbSWilly Tarreau static __attribute__((unused)) 943bd8c8fbbSWilly Tarreau int select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout) 944bd8c8fbbSWilly Tarreau { 945d27447bcSZhangjin Wu return __sysret(sys_select(nfds, rfds, wfds, efds, timeout)); 946bd8c8fbbSWilly Tarreau } 947bd8c8fbbSWilly Tarreau 948bd8c8fbbSWilly Tarreau 949bd8c8fbbSWilly Tarreau /* 950bd8c8fbbSWilly Tarreau * int setpgid(pid_t pid, pid_t pgid); 951bd8c8fbbSWilly Tarreau */ 952bd8c8fbbSWilly Tarreau 953bd8c8fbbSWilly Tarreau static __attribute__((unused)) 954bd8c8fbbSWilly Tarreau int sys_setpgid(pid_t pid, pid_t pgid) 955bd8c8fbbSWilly Tarreau { 956bd8c8fbbSWilly Tarreau return my_syscall2(__NR_setpgid, pid, pgid); 957bd8c8fbbSWilly Tarreau } 958bd8c8fbbSWilly Tarreau 959bd8c8fbbSWilly Tarreau static __attribute__((unused)) 960bd8c8fbbSWilly Tarreau int setpgid(pid_t pid, pid_t pgid) 961bd8c8fbbSWilly Tarreau { 962d27447bcSZhangjin Wu return __sysret(sys_setpgid(pid, pgid)); 963bd8c8fbbSWilly Tarreau } 964bd8c8fbbSWilly Tarreau 965bd8c8fbbSWilly Tarreau 966bd8c8fbbSWilly Tarreau /* 967bd8c8fbbSWilly Tarreau * pid_t setsid(void); 968bd8c8fbbSWilly Tarreau */ 969bd8c8fbbSWilly Tarreau 970bd8c8fbbSWilly Tarreau static __attribute__((unused)) 971bd8c8fbbSWilly Tarreau pid_t sys_setsid(void) 972bd8c8fbbSWilly Tarreau { 973bd8c8fbbSWilly Tarreau return my_syscall0(__NR_setsid); 974bd8c8fbbSWilly Tarreau } 975bd8c8fbbSWilly Tarreau 976bd8c8fbbSWilly Tarreau static __attribute__((unused)) 977bd8c8fbbSWilly Tarreau pid_t setsid(void) 978bd8c8fbbSWilly Tarreau { 979d27447bcSZhangjin Wu return __sysret(sys_setsid()); 980bd8c8fbbSWilly Tarreau } 981bd8c8fbbSWilly Tarreau 982b551cb7dSFeiyang Chen /* 983b551cb7dSFeiyang Chen * int statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf); 984af93807eSZhangjin Wu * int stat(const char *path, struct stat *buf); 985b551cb7dSFeiyang Chen */ 986b551cb7dSFeiyang Chen 987b551cb7dSFeiyang Chen static __attribute__((unused)) 988b551cb7dSFeiyang Chen int sys_statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf) 989b551cb7dSFeiyang Chen { 990af93807eSZhangjin Wu #ifdef __NR_statx 991b551cb7dSFeiyang Chen return my_syscall5(__NR_statx, fd, path, flags, mask, buf); 992af93807eSZhangjin Wu #else 993af93807eSZhangjin Wu return -ENOSYS; 994af93807eSZhangjin Wu #endif 995b551cb7dSFeiyang Chen } 996b551cb7dSFeiyang Chen 997b551cb7dSFeiyang Chen static __attribute__((unused)) 998b551cb7dSFeiyang Chen int statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf) 999b551cb7dSFeiyang Chen { 1000d27447bcSZhangjin Wu return __sysret(sys_statx(fd, path, flags, mask, buf)); 1001b551cb7dSFeiyang Chen } 1002bd8c8fbbSWilly Tarreau 1003bd8c8fbbSWilly Tarreau 1004b551cb7dSFeiyang Chen static __attribute__((unused)) 1005af93807eSZhangjin Wu int stat(const char *path, struct stat *buf) 1006b551cb7dSFeiyang Chen { 1007b551cb7dSFeiyang Chen struct statx statx; 1008b551cb7dSFeiyang Chen long ret; 1009b551cb7dSFeiyang Chen 1010af93807eSZhangjin Wu ret = __sysret(sys_statx(AT_FDCWD, path, AT_NO_AUTOMOUNT, STATX_BASIC_STATS, &statx)); 1011af93807eSZhangjin Wu if (ret == -1) 1012af93807eSZhangjin Wu return ret; 1013af93807eSZhangjin Wu 1014b551cb7dSFeiyang Chen buf->st_dev = ((statx.stx_dev_minor & 0xff) 1015b551cb7dSFeiyang Chen | (statx.stx_dev_major << 8) 1016b551cb7dSFeiyang Chen | ((statx.stx_dev_minor & ~0xff) << 12)); 1017b551cb7dSFeiyang Chen buf->st_ino = statx.stx_ino; 1018b551cb7dSFeiyang Chen buf->st_mode = statx.stx_mode; 1019b551cb7dSFeiyang Chen buf->st_nlink = statx.stx_nlink; 1020b551cb7dSFeiyang Chen buf->st_uid = statx.stx_uid; 1021b551cb7dSFeiyang Chen buf->st_gid = statx.stx_gid; 1022b551cb7dSFeiyang Chen buf->st_rdev = ((statx.stx_rdev_minor & 0xff) 1023b551cb7dSFeiyang Chen | (statx.stx_rdev_major << 8) 1024b551cb7dSFeiyang Chen | ((statx.stx_rdev_minor & ~0xff) << 12)); 1025b551cb7dSFeiyang Chen buf->st_size = statx.stx_size; 1026b551cb7dSFeiyang Chen buf->st_blksize = statx.stx_blksize; 1027b551cb7dSFeiyang Chen buf->st_blocks = statx.stx_blocks; 102887b9fa66SThomas Weißschuh buf->st_atim.tv_sec = statx.stx_atime.tv_sec; 102987b9fa66SThomas Weißschuh buf->st_atim.tv_nsec = statx.stx_atime.tv_nsec; 103087b9fa66SThomas Weißschuh buf->st_mtim.tv_sec = statx.stx_mtime.tv_sec; 103187b9fa66SThomas Weißschuh buf->st_mtim.tv_nsec = statx.stx_mtime.tv_nsec; 103287b9fa66SThomas Weißschuh buf->st_ctim.tv_sec = statx.stx_ctime.tv_sec; 103387b9fa66SThomas Weißschuh buf->st_ctim.tv_nsec = statx.stx_ctime.tv_nsec; 1034bd8c8fbbSWilly Tarreau 1035af93807eSZhangjin Wu return 0; 1036bd8c8fbbSWilly Tarreau } 1037bd8c8fbbSWilly Tarreau 1038bd8c8fbbSWilly Tarreau 1039bd8c8fbbSWilly Tarreau /* 1040bd8c8fbbSWilly Tarreau * int symlink(const char *old, const char *new); 1041bd8c8fbbSWilly Tarreau */ 1042bd8c8fbbSWilly Tarreau 1043bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1044bd8c8fbbSWilly Tarreau int sys_symlink(const char *old, const char *new) 1045bd8c8fbbSWilly Tarreau { 1046bd8c8fbbSWilly Tarreau #ifdef __NR_symlinkat 1047bd8c8fbbSWilly Tarreau return my_syscall3(__NR_symlinkat, old, AT_FDCWD, new); 1048bd8c8fbbSWilly Tarreau #elif defined(__NR_symlink) 1049bd8c8fbbSWilly Tarreau return my_syscall2(__NR_symlink, old, new); 1050bd8c8fbbSWilly Tarreau #else 1051ca50df30SZhangjin Wu return -ENOSYS; 1052bd8c8fbbSWilly Tarreau #endif 1053bd8c8fbbSWilly Tarreau } 1054bd8c8fbbSWilly Tarreau 1055bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1056bd8c8fbbSWilly Tarreau int symlink(const char *old, const char *new) 1057bd8c8fbbSWilly Tarreau { 1058d27447bcSZhangjin Wu return __sysret(sys_symlink(old, new)); 1059bd8c8fbbSWilly Tarreau } 1060bd8c8fbbSWilly Tarreau 1061bd8c8fbbSWilly Tarreau 1062bd8c8fbbSWilly Tarreau /* 1063bd8c8fbbSWilly Tarreau * mode_t umask(mode_t mode); 1064bd8c8fbbSWilly Tarreau */ 1065bd8c8fbbSWilly Tarreau 1066bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1067bd8c8fbbSWilly Tarreau mode_t sys_umask(mode_t mode) 1068bd8c8fbbSWilly Tarreau { 1069bd8c8fbbSWilly Tarreau return my_syscall1(__NR_umask, mode); 1070bd8c8fbbSWilly Tarreau } 1071bd8c8fbbSWilly Tarreau 1072bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1073bd8c8fbbSWilly Tarreau mode_t umask(mode_t mode) 1074bd8c8fbbSWilly Tarreau { 1075bd8c8fbbSWilly Tarreau return sys_umask(mode); 1076bd8c8fbbSWilly Tarreau } 1077bd8c8fbbSWilly Tarreau 1078bd8c8fbbSWilly Tarreau 1079bd8c8fbbSWilly Tarreau /* 1080bd8c8fbbSWilly Tarreau * int umount2(const char *path, int flags); 1081bd8c8fbbSWilly Tarreau */ 1082bd8c8fbbSWilly Tarreau 1083bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1084bd8c8fbbSWilly Tarreau int sys_umount2(const char *path, int flags) 1085bd8c8fbbSWilly Tarreau { 1086bd8c8fbbSWilly Tarreau return my_syscall2(__NR_umount2, path, flags); 1087bd8c8fbbSWilly Tarreau } 1088bd8c8fbbSWilly Tarreau 1089bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1090bd8c8fbbSWilly Tarreau int umount2(const char *path, int flags) 1091bd8c8fbbSWilly Tarreau { 1092d27447bcSZhangjin Wu return __sysret(sys_umount2(path, flags)); 1093bd8c8fbbSWilly Tarreau } 1094bd8c8fbbSWilly Tarreau 1095bd8c8fbbSWilly Tarreau 1096bd8c8fbbSWilly Tarreau /* 1097bd8c8fbbSWilly Tarreau * int unlink(const char *path); 1098bd8c8fbbSWilly Tarreau */ 1099bd8c8fbbSWilly Tarreau 1100bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1101bd8c8fbbSWilly Tarreau int sys_unlink(const char *path) 1102bd8c8fbbSWilly Tarreau { 1103bd8c8fbbSWilly Tarreau #ifdef __NR_unlinkat 1104bd8c8fbbSWilly Tarreau return my_syscall3(__NR_unlinkat, AT_FDCWD, path, 0); 1105bd8c8fbbSWilly Tarreau #elif defined(__NR_unlink) 1106bd8c8fbbSWilly Tarreau return my_syscall1(__NR_unlink, path); 1107bd8c8fbbSWilly Tarreau #else 1108ca50df30SZhangjin Wu return -ENOSYS; 1109bd8c8fbbSWilly Tarreau #endif 1110bd8c8fbbSWilly Tarreau } 1111bd8c8fbbSWilly Tarreau 1112bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1113bd8c8fbbSWilly Tarreau int unlink(const char *path) 1114bd8c8fbbSWilly Tarreau { 1115d27447bcSZhangjin Wu return __sysret(sys_unlink(path)); 1116bd8c8fbbSWilly Tarreau } 1117bd8c8fbbSWilly Tarreau 1118bd8c8fbbSWilly Tarreau 1119bd8c8fbbSWilly Tarreau /* 1120bd8c8fbbSWilly Tarreau * pid_t wait(int *status); 1121bd8c8fbbSWilly Tarreau * pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage); 1122bd8c8fbbSWilly Tarreau * pid_t waitpid(pid_t pid, int *status, int options); 1123bd8c8fbbSWilly Tarreau */ 1124bd8c8fbbSWilly Tarreau 1125bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1126bd8c8fbbSWilly Tarreau pid_t sys_wait4(pid_t pid, int *status, int options, struct rusage *rusage) 1127bd8c8fbbSWilly Tarreau { 11282f98aca8SZhangjin Wu #ifdef __NR_wait4 1129bd8c8fbbSWilly Tarreau return my_syscall4(__NR_wait4, pid, status, options, rusage); 11302f98aca8SZhangjin Wu #else 11312f98aca8SZhangjin Wu return -ENOSYS; 11322f98aca8SZhangjin Wu #endif 1133bd8c8fbbSWilly Tarreau } 1134bd8c8fbbSWilly Tarreau 1135bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1136bd8c8fbbSWilly Tarreau pid_t wait(int *status) 1137bd8c8fbbSWilly Tarreau { 1138d27447bcSZhangjin Wu return __sysret(sys_wait4(-1, status, 0, NULL)); 1139bd8c8fbbSWilly Tarreau } 1140bd8c8fbbSWilly Tarreau 1141bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1142bd8c8fbbSWilly Tarreau pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage) 1143bd8c8fbbSWilly Tarreau { 1144d27447bcSZhangjin Wu return __sysret(sys_wait4(pid, status, options, rusage)); 1145bd8c8fbbSWilly Tarreau } 1146bd8c8fbbSWilly Tarreau 1147bd8c8fbbSWilly Tarreau 1148bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1149bd8c8fbbSWilly Tarreau pid_t waitpid(pid_t pid, int *status, int options) 1150bd8c8fbbSWilly Tarreau { 1151d27447bcSZhangjin Wu return __sysret(sys_wait4(pid, status, options, NULL)); 1152bd8c8fbbSWilly Tarreau } 1153bd8c8fbbSWilly Tarreau 1154bd8c8fbbSWilly Tarreau 1155bd8c8fbbSWilly Tarreau /* 1156bd8c8fbbSWilly Tarreau * ssize_t write(int fd, const void *buf, size_t count); 1157bd8c8fbbSWilly Tarreau */ 1158bd8c8fbbSWilly Tarreau 1159bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1160bd8c8fbbSWilly Tarreau ssize_t sys_write(int fd, const void *buf, size_t count) 1161bd8c8fbbSWilly Tarreau { 1162bd8c8fbbSWilly Tarreau return my_syscall3(__NR_write, fd, buf, count); 1163bd8c8fbbSWilly Tarreau } 1164bd8c8fbbSWilly Tarreau 1165bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1166bd8c8fbbSWilly Tarreau ssize_t write(int fd, const void *buf, size_t count) 1167bd8c8fbbSWilly Tarreau { 1168d27447bcSZhangjin Wu return __sysret(sys_write(fd, buf, count)); 1169bd8c8fbbSWilly Tarreau } 1170bd8c8fbbSWilly Tarreau 1171e8842cf0SThomas Weißschuh 1172e8842cf0SThomas Weißschuh /* 1173e8842cf0SThomas Weißschuh * int memfd_create(const char *name, unsigned int flags); 1174e8842cf0SThomas Weißschuh */ 1175e8842cf0SThomas Weißschuh 1176e8842cf0SThomas Weißschuh static __attribute__((unused)) 1177e8842cf0SThomas Weißschuh int sys_memfd_create(const char *name, unsigned int flags) 1178e8842cf0SThomas Weißschuh { 1179e8842cf0SThomas Weißschuh return my_syscall2(__NR_memfd_create, name, flags); 1180e8842cf0SThomas Weißschuh } 1181e8842cf0SThomas Weißschuh 1182e8842cf0SThomas Weißschuh static __attribute__((unused)) 1183e8842cf0SThomas Weißschuh int memfd_create(const char *name, unsigned int flags) 1184e8842cf0SThomas Weißschuh { 1185d27447bcSZhangjin Wu return __sysret(sys_memfd_create(name, flags)); 1186e8842cf0SThomas Weißschuh } 1187e8842cf0SThomas Weißschuh 118855abdd1fSWilly Tarreau /* make sure to include all global symbols */ 118955abdd1fSWilly Tarreau #include "nolibc.h" 1190bd8c8fbbSWilly Tarreau 1191bd8c8fbbSWilly Tarreau #endif /* _NOLIBC_SYS_H */ 1192