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 { 85d27447bcSZhangjin Wu return __sysret(sys_brk(addr) ? 0 : -ENOMEM); 86bd8c8fbbSWilly Tarreau } 87bd8c8fbbSWilly Tarreau 88bd8c8fbbSWilly Tarreau static __attribute__((unused)) 89bd8c8fbbSWilly Tarreau void *sbrk(intptr_t inc) 90bd8c8fbbSWilly Tarreau { 91bd8c8fbbSWilly Tarreau /* first call to find current end */ 924201cfceSZhangjin Wu void *ret = sys_brk(0); 934201cfceSZhangjin Wu 944201cfceSZhangjin Wu if (ret && sys_brk(ret + inc) == ret + inc) 95bd8c8fbbSWilly Tarreau return ret + inc; 96bd8c8fbbSWilly Tarreau 974201cfceSZhangjin Wu return (void *)__sysret(-ENOMEM); 98bd8c8fbbSWilly Tarreau } 99bd8c8fbbSWilly Tarreau 100bd8c8fbbSWilly Tarreau 101bd8c8fbbSWilly Tarreau /* 102bd8c8fbbSWilly Tarreau * int chdir(const char *path); 103bd8c8fbbSWilly Tarreau */ 104bd8c8fbbSWilly Tarreau 105bd8c8fbbSWilly Tarreau static __attribute__((unused)) 106bd8c8fbbSWilly Tarreau int sys_chdir(const char *path) 107bd8c8fbbSWilly Tarreau { 108bd8c8fbbSWilly Tarreau return my_syscall1(__NR_chdir, path); 109bd8c8fbbSWilly Tarreau } 110bd8c8fbbSWilly Tarreau 111bd8c8fbbSWilly Tarreau static __attribute__((unused)) 112bd8c8fbbSWilly Tarreau int chdir(const char *path) 113bd8c8fbbSWilly Tarreau { 114d27447bcSZhangjin Wu return __sysret(sys_chdir(path)); 115bd8c8fbbSWilly Tarreau } 116bd8c8fbbSWilly Tarreau 117bd8c8fbbSWilly Tarreau 118bd8c8fbbSWilly Tarreau /* 119bd8c8fbbSWilly Tarreau * int chmod(const char *path, mode_t mode); 120bd8c8fbbSWilly Tarreau */ 121bd8c8fbbSWilly Tarreau 122bd8c8fbbSWilly Tarreau static __attribute__((unused)) 123bd8c8fbbSWilly Tarreau int sys_chmod(const char *path, mode_t mode) 124bd8c8fbbSWilly Tarreau { 125bd8c8fbbSWilly Tarreau #ifdef __NR_fchmodat 126bd8c8fbbSWilly Tarreau return my_syscall4(__NR_fchmodat, AT_FDCWD, path, mode, 0); 127bd8c8fbbSWilly Tarreau #elif defined(__NR_chmod) 128bd8c8fbbSWilly Tarreau return my_syscall2(__NR_chmod, path, mode); 129bd8c8fbbSWilly Tarreau #else 130ca50df30SZhangjin Wu return -ENOSYS; 131bd8c8fbbSWilly Tarreau #endif 132bd8c8fbbSWilly Tarreau } 133bd8c8fbbSWilly Tarreau 134bd8c8fbbSWilly Tarreau static __attribute__((unused)) 135bd8c8fbbSWilly Tarreau int chmod(const char *path, mode_t mode) 136bd8c8fbbSWilly Tarreau { 137d27447bcSZhangjin Wu return __sysret(sys_chmod(path, mode)); 138bd8c8fbbSWilly Tarreau } 139bd8c8fbbSWilly Tarreau 140bd8c8fbbSWilly Tarreau 141bd8c8fbbSWilly Tarreau /* 142bd8c8fbbSWilly Tarreau * int chown(const char *path, uid_t owner, gid_t group); 143bd8c8fbbSWilly Tarreau */ 144bd8c8fbbSWilly Tarreau 145bd8c8fbbSWilly Tarreau static __attribute__((unused)) 146bd8c8fbbSWilly Tarreau int sys_chown(const char *path, uid_t owner, gid_t group) 147bd8c8fbbSWilly Tarreau { 148bd8c8fbbSWilly Tarreau #ifdef __NR_fchownat 149bd8c8fbbSWilly Tarreau return my_syscall5(__NR_fchownat, AT_FDCWD, path, owner, group, 0); 150bd8c8fbbSWilly Tarreau #elif defined(__NR_chown) 151bd8c8fbbSWilly Tarreau return my_syscall3(__NR_chown, path, owner, group); 152bd8c8fbbSWilly Tarreau #else 153ca50df30SZhangjin Wu return -ENOSYS; 154bd8c8fbbSWilly Tarreau #endif 155bd8c8fbbSWilly Tarreau } 156bd8c8fbbSWilly Tarreau 157bd8c8fbbSWilly Tarreau static __attribute__((unused)) 158bd8c8fbbSWilly Tarreau int chown(const char *path, uid_t owner, gid_t group) 159bd8c8fbbSWilly Tarreau { 160d27447bcSZhangjin Wu return __sysret(sys_chown(path, owner, group)); 161bd8c8fbbSWilly Tarreau } 162bd8c8fbbSWilly Tarreau 163bd8c8fbbSWilly Tarreau 164bd8c8fbbSWilly Tarreau /* 165bd8c8fbbSWilly Tarreau * int chroot(const char *path); 166bd8c8fbbSWilly Tarreau */ 167bd8c8fbbSWilly Tarreau 168bd8c8fbbSWilly Tarreau static __attribute__((unused)) 169bd8c8fbbSWilly Tarreau int sys_chroot(const char *path) 170bd8c8fbbSWilly Tarreau { 171bd8c8fbbSWilly Tarreau return my_syscall1(__NR_chroot, path); 172bd8c8fbbSWilly Tarreau } 173bd8c8fbbSWilly Tarreau 174bd8c8fbbSWilly Tarreau static __attribute__((unused)) 175bd8c8fbbSWilly Tarreau int chroot(const char *path) 176bd8c8fbbSWilly Tarreau { 177d27447bcSZhangjin Wu return __sysret(sys_chroot(path)); 178bd8c8fbbSWilly Tarreau } 179bd8c8fbbSWilly Tarreau 180bd8c8fbbSWilly Tarreau 181bd8c8fbbSWilly Tarreau /* 182bd8c8fbbSWilly Tarreau * int close(int fd); 183bd8c8fbbSWilly Tarreau */ 184bd8c8fbbSWilly Tarreau 185bd8c8fbbSWilly Tarreau static __attribute__((unused)) 186bd8c8fbbSWilly Tarreau int sys_close(int fd) 187bd8c8fbbSWilly Tarreau { 188bd8c8fbbSWilly Tarreau return my_syscall1(__NR_close, fd); 189bd8c8fbbSWilly Tarreau } 190bd8c8fbbSWilly Tarreau 191bd8c8fbbSWilly Tarreau static __attribute__((unused)) 192bd8c8fbbSWilly Tarreau int close(int fd) 193bd8c8fbbSWilly Tarreau { 194d27447bcSZhangjin Wu return __sysret(sys_close(fd)); 195bd8c8fbbSWilly Tarreau } 196bd8c8fbbSWilly Tarreau 197bd8c8fbbSWilly Tarreau 198bd8c8fbbSWilly Tarreau /* 199bd8c8fbbSWilly Tarreau * int dup(int fd); 200bd8c8fbbSWilly Tarreau */ 201bd8c8fbbSWilly Tarreau 202bd8c8fbbSWilly Tarreau static __attribute__((unused)) 203bd8c8fbbSWilly Tarreau int sys_dup(int fd) 204bd8c8fbbSWilly Tarreau { 205bd8c8fbbSWilly Tarreau return my_syscall1(__NR_dup, fd); 206bd8c8fbbSWilly Tarreau } 207bd8c8fbbSWilly Tarreau 208bd8c8fbbSWilly Tarreau static __attribute__((unused)) 209bd8c8fbbSWilly Tarreau int dup(int fd) 210bd8c8fbbSWilly Tarreau { 211d27447bcSZhangjin Wu return __sysret(sys_dup(fd)); 212bd8c8fbbSWilly Tarreau } 213bd8c8fbbSWilly Tarreau 214bd8c8fbbSWilly Tarreau 215bd8c8fbbSWilly Tarreau /* 216bd8c8fbbSWilly Tarreau * int dup2(int old, int new); 217bd8c8fbbSWilly Tarreau */ 218bd8c8fbbSWilly Tarreau 219bd8c8fbbSWilly Tarreau static __attribute__((unused)) 220bd8c8fbbSWilly Tarreau int sys_dup2(int old, int new) 221bd8c8fbbSWilly Tarreau { 222bd8c8fbbSWilly Tarreau #ifdef __NR_dup3 223bd8c8fbbSWilly Tarreau return my_syscall3(__NR_dup3, old, new, 0); 224bd8c8fbbSWilly Tarreau #elif defined(__NR_dup2) 225bd8c8fbbSWilly Tarreau return my_syscall2(__NR_dup2, old, new); 226bd8c8fbbSWilly Tarreau #else 227ca50df30SZhangjin Wu return -ENOSYS; 228bd8c8fbbSWilly Tarreau #endif 229bd8c8fbbSWilly Tarreau } 230bd8c8fbbSWilly Tarreau 231bd8c8fbbSWilly Tarreau static __attribute__((unused)) 232bd8c8fbbSWilly Tarreau int dup2(int old, int new) 233bd8c8fbbSWilly Tarreau { 234d27447bcSZhangjin Wu return __sysret(sys_dup2(old, new)); 235bd8c8fbbSWilly Tarreau } 236bd8c8fbbSWilly Tarreau 237bd8c8fbbSWilly Tarreau 238bd8c8fbbSWilly Tarreau /* 239bd8c8fbbSWilly Tarreau * int dup3(int old, int new, int flags); 240bd8c8fbbSWilly Tarreau */ 241bd8c8fbbSWilly Tarreau 242bd8c8fbbSWilly Tarreau #ifdef __NR_dup3 243bd8c8fbbSWilly Tarreau static __attribute__((unused)) 244bd8c8fbbSWilly Tarreau int sys_dup3(int old, int new, int flags) 245bd8c8fbbSWilly Tarreau { 246bd8c8fbbSWilly Tarreau return my_syscall3(__NR_dup3, old, new, flags); 247bd8c8fbbSWilly Tarreau } 248bd8c8fbbSWilly Tarreau 249bd8c8fbbSWilly Tarreau static __attribute__((unused)) 250bd8c8fbbSWilly Tarreau int dup3(int old, int new, int flags) 251bd8c8fbbSWilly Tarreau { 252d27447bcSZhangjin Wu return __sysret(sys_dup3(old, new, flags)); 253bd8c8fbbSWilly Tarreau } 254bd8c8fbbSWilly Tarreau #endif 255bd8c8fbbSWilly Tarreau 256bd8c8fbbSWilly Tarreau 257bd8c8fbbSWilly Tarreau /* 258bd8c8fbbSWilly Tarreau * int execve(const char *filename, char *const argv[], char *const envp[]); 259bd8c8fbbSWilly Tarreau */ 260bd8c8fbbSWilly Tarreau 261bd8c8fbbSWilly Tarreau static __attribute__((unused)) 262bd8c8fbbSWilly Tarreau int sys_execve(const char *filename, char *const argv[], char *const envp[]) 263bd8c8fbbSWilly Tarreau { 264bd8c8fbbSWilly Tarreau return my_syscall3(__NR_execve, filename, argv, envp); 265bd8c8fbbSWilly Tarreau } 266bd8c8fbbSWilly Tarreau 267bd8c8fbbSWilly Tarreau static __attribute__((unused)) 268bd8c8fbbSWilly Tarreau int execve(const char *filename, char *const argv[], char *const envp[]) 269bd8c8fbbSWilly Tarreau { 270d27447bcSZhangjin Wu return __sysret(sys_execve(filename, argv, envp)); 271bd8c8fbbSWilly Tarreau } 272bd8c8fbbSWilly Tarreau 273bd8c8fbbSWilly Tarreau 274bd8c8fbbSWilly Tarreau /* 275bd8c8fbbSWilly Tarreau * void exit(int status); 276bd8c8fbbSWilly Tarreau */ 277bd8c8fbbSWilly Tarreau 278bd8c8fbbSWilly Tarreau static __attribute__((noreturn,unused)) 279bd8c8fbbSWilly Tarreau void sys_exit(int status) 280bd8c8fbbSWilly Tarreau { 281bd8c8fbbSWilly Tarreau my_syscall1(__NR_exit, status & 255); 282fddc8f81SThomas Weißschuh while(1); /* shut the "noreturn" warnings. */ 283bd8c8fbbSWilly Tarreau } 284bd8c8fbbSWilly Tarreau 285bd8c8fbbSWilly Tarreau static __attribute__((noreturn,unused)) 286bd8c8fbbSWilly Tarreau void exit(int status) 287bd8c8fbbSWilly Tarreau { 288bd8c8fbbSWilly Tarreau sys_exit(status); 289bd8c8fbbSWilly Tarreau } 290bd8c8fbbSWilly Tarreau 291bd8c8fbbSWilly Tarreau 292bd8c8fbbSWilly Tarreau /* 293bd8c8fbbSWilly Tarreau * pid_t fork(void); 294bd8c8fbbSWilly Tarreau */ 295bd8c8fbbSWilly Tarreau 296404fa87cSThomas Weißschuh #ifndef sys_fork 297bd8c8fbbSWilly Tarreau static __attribute__((unused)) 298bd8c8fbbSWilly Tarreau pid_t sys_fork(void) 299bd8c8fbbSWilly Tarreau { 300bd8c8fbbSWilly Tarreau #ifdef __NR_clone 301bd8c8fbbSWilly Tarreau /* note: some archs only have clone() and not fork(). Different archs 302bd8c8fbbSWilly Tarreau * have a different API, but most archs have the flags on first arg and 303bd8c8fbbSWilly Tarreau * will not use the rest with no other flag. 304bd8c8fbbSWilly Tarreau */ 305bd8c8fbbSWilly Tarreau return my_syscall5(__NR_clone, SIGCHLD, 0, 0, 0, 0); 306bd8c8fbbSWilly Tarreau #elif defined(__NR_fork) 307bd8c8fbbSWilly Tarreau return my_syscall0(__NR_fork); 308bd8c8fbbSWilly Tarreau #else 309ca50df30SZhangjin Wu return -ENOSYS; 310bd8c8fbbSWilly Tarreau #endif 311bd8c8fbbSWilly Tarreau } 312404fa87cSThomas Weißschuh #endif 313bd8c8fbbSWilly Tarreau 314bd8c8fbbSWilly Tarreau static __attribute__((unused)) 315bd8c8fbbSWilly Tarreau pid_t fork(void) 316bd8c8fbbSWilly Tarreau { 317d27447bcSZhangjin Wu return __sysret(sys_fork()); 318bd8c8fbbSWilly Tarreau } 319bd8c8fbbSWilly Tarreau 320bd8c8fbbSWilly Tarreau 321bd8c8fbbSWilly Tarreau /* 322bd8c8fbbSWilly Tarreau * int fsync(int fd); 323bd8c8fbbSWilly Tarreau */ 324bd8c8fbbSWilly Tarreau 325bd8c8fbbSWilly Tarreau static __attribute__((unused)) 326bd8c8fbbSWilly Tarreau int sys_fsync(int fd) 327bd8c8fbbSWilly Tarreau { 328bd8c8fbbSWilly Tarreau return my_syscall1(__NR_fsync, fd); 329bd8c8fbbSWilly Tarreau } 330bd8c8fbbSWilly Tarreau 331bd8c8fbbSWilly Tarreau static __attribute__((unused)) 332bd8c8fbbSWilly Tarreau int fsync(int fd) 333bd8c8fbbSWilly Tarreau { 334d27447bcSZhangjin Wu return __sysret(sys_fsync(fd)); 335bd8c8fbbSWilly Tarreau } 336bd8c8fbbSWilly Tarreau 337bd8c8fbbSWilly Tarreau 338bd8c8fbbSWilly Tarreau /* 339bd8c8fbbSWilly Tarreau * int getdents64(int fd, struct linux_dirent64 *dirp, int count); 340bd8c8fbbSWilly Tarreau */ 341bd8c8fbbSWilly Tarreau 342bd8c8fbbSWilly Tarreau static __attribute__((unused)) 343bd8c8fbbSWilly Tarreau int sys_getdents64(int fd, struct linux_dirent64 *dirp, int count) 344bd8c8fbbSWilly Tarreau { 345bd8c8fbbSWilly Tarreau return my_syscall3(__NR_getdents64, fd, dirp, count); 346bd8c8fbbSWilly Tarreau } 347bd8c8fbbSWilly Tarreau 348bd8c8fbbSWilly Tarreau static __attribute__((unused)) 349bd8c8fbbSWilly Tarreau int getdents64(int fd, struct linux_dirent64 *dirp, int count) 350bd8c8fbbSWilly Tarreau { 351d27447bcSZhangjin Wu return __sysret(sys_getdents64(fd, dirp, count)); 352bd8c8fbbSWilly Tarreau } 353bd8c8fbbSWilly Tarreau 354bd8c8fbbSWilly Tarreau 355bd8c8fbbSWilly Tarreau /* 356919d0532SWilly Tarreau * uid_t geteuid(void); 357919d0532SWilly Tarreau */ 358919d0532SWilly Tarreau 359919d0532SWilly Tarreau static __attribute__((unused)) 360919d0532SWilly Tarreau uid_t sys_geteuid(void) 361919d0532SWilly Tarreau { 362919d0532SWilly Tarreau #ifdef __NR_geteuid32 363919d0532SWilly Tarreau return my_syscall0(__NR_geteuid32); 364919d0532SWilly Tarreau #else 365919d0532SWilly Tarreau return my_syscall0(__NR_geteuid); 366919d0532SWilly Tarreau #endif 367919d0532SWilly Tarreau } 368919d0532SWilly Tarreau 369919d0532SWilly Tarreau static __attribute__((unused)) 370919d0532SWilly Tarreau uid_t geteuid(void) 371919d0532SWilly Tarreau { 372919d0532SWilly Tarreau return sys_geteuid(); 373919d0532SWilly Tarreau } 374919d0532SWilly Tarreau 375919d0532SWilly Tarreau 376919d0532SWilly Tarreau /* 377bd8c8fbbSWilly Tarreau * pid_t getpgid(pid_t pid); 378bd8c8fbbSWilly Tarreau */ 379bd8c8fbbSWilly Tarreau 380bd8c8fbbSWilly Tarreau static __attribute__((unused)) 381bd8c8fbbSWilly Tarreau pid_t sys_getpgid(pid_t pid) 382bd8c8fbbSWilly Tarreau { 383bd8c8fbbSWilly Tarreau return my_syscall1(__NR_getpgid, pid); 384bd8c8fbbSWilly Tarreau } 385bd8c8fbbSWilly Tarreau 386bd8c8fbbSWilly Tarreau static __attribute__((unused)) 387bd8c8fbbSWilly Tarreau pid_t getpgid(pid_t pid) 388bd8c8fbbSWilly Tarreau { 389d27447bcSZhangjin Wu return __sysret(sys_getpgid(pid)); 390bd8c8fbbSWilly Tarreau } 391bd8c8fbbSWilly Tarreau 392bd8c8fbbSWilly Tarreau 393bd8c8fbbSWilly Tarreau /* 394bd8c8fbbSWilly Tarreau * pid_t getpgrp(void); 395bd8c8fbbSWilly Tarreau */ 396bd8c8fbbSWilly Tarreau 397bd8c8fbbSWilly Tarreau static __attribute__((unused)) 398bd8c8fbbSWilly Tarreau pid_t sys_getpgrp(void) 399bd8c8fbbSWilly Tarreau { 400bd8c8fbbSWilly Tarreau return sys_getpgid(0); 401bd8c8fbbSWilly Tarreau } 402bd8c8fbbSWilly Tarreau 403bd8c8fbbSWilly Tarreau static __attribute__((unused)) 404bd8c8fbbSWilly Tarreau pid_t getpgrp(void) 405bd8c8fbbSWilly Tarreau { 406830acd08SWilly Tarreau return sys_getpgrp(); 407bd8c8fbbSWilly Tarreau } 408bd8c8fbbSWilly Tarreau 409bd8c8fbbSWilly Tarreau 410bd8c8fbbSWilly Tarreau /* 411bd8c8fbbSWilly Tarreau * pid_t getpid(void); 412bd8c8fbbSWilly Tarreau */ 413bd8c8fbbSWilly Tarreau 414bd8c8fbbSWilly Tarreau static __attribute__((unused)) 415bd8c8fbbSWilly Tarreau pid_t sys_getpid(void) 416bd8c8fbbSWilly Tarreau { 417bd8c8fbbSWilly Tarreau return my_syscall0(__NR_getpid); 418bd8c8fbbSWilly Tarreau } 419bd8c8fbbSWilly Tarreau 420bd8c8fbbSWilly Tarreau static __attribute__((unused)) 421bd8c8fbbSWilly Tarreau pid_t getpid(void) 422bd8c8fbbSWilly Tarreau { 423830acd08SWilly Tarreau return sys_getpid(); 424bd8c8fbbSWilly Tarreau } 425bd8c8fbbSWilly Tarreau 426bd8c8fbbSWilly Tarreau 427bd8c8fbbSWilly Tarreau /* 42854abe359SWilly Tarreau * pid_t getppid(void); 42954abe359SWilly Tarreau */ 43054abe359SWilly Tarreau 43154abe359SWilly Tarreau static __attribute__((unused)) 43254abe359SWilly Tarreau pid_t sys_getppid(void) 43354abe359SWilly Tarreau { 43454abe359SWilly Tarreau return my_syscall0(__NR_getppid); 43554abe359SWilly Tarreau } 43654abe359SWilly Tarreau 43754abe359SWilly Tarreau static __attribute__((unused)) 43854abe359SWilly Tarreau pid_t getppid(void) 43954abe359SWilly Tarreau { 44054abe359SWilly Tarreau return sys_getppid(); 44154abe359SWilly Tarreau } 44254abe359SWilly Tarreau 44354abe359SWilly Tarreau 44454abe359SWilly Tarreau /* 445bd8c8fbbSWilly Tarreau * pid_t gettid(void); 446bd8c8fbbSWilly Tarreau */ 447bd8c8fbbSWilly Tarreau 448bd8c8fbbSWilly Tarreau static __attribute__((unused)) 449bd8c8fbbSWilly Tarreau pid_t sys_gettid(void) 450bd8c8fbbSWilly Tarreau { 451bd8c8fbbSWilly Tarreau return my_syscall0(__NR_gettid); 452bd8c8fbbSWilly Tarreau } 453bd8c8fbbSWilly Tarreau 454bd8c8fbbSWilly Tarreau static __attribute__((unused)) 455bd8c8fbbSWilly Tarreau pid_t gettid(void) 456bd8c8fbbSWilly Tarreau { 457830acd08SWilly Tarreau return sys_gettid(); 458bd8c8fbbSWilly Tarreau } 459bd8c8fbbSWilly Tarreau 4607efd762eSAmmar Faizi static unsigned long getauxval(unsigned long key); 4617efd762eSAmmar Faizi 4627efd762eSAmmar Faizi /* 4637efd762eSAmmar Faizi * long getpagesize(void); 4647efd762eSAmmar Faizi */ 4657efd762eSAmmar Faizi 4667efd762eSAmmar Faizi static __attribute__((unused)) 4677efd762eSAmmar Faizi long getpagesize(void) 4687efd762eSAmmar Faizi { 469d27447bcSZhangjin Wu return __sysret(getauxval(AT_PAGESZ) ?: -ENOENT); 4707efd762eSAmmar Faizi } 4717efd762eSAmmar Faizi 472bd8c8fbbSWilly Tarreau 473bd8c8fbbSWilly Tarreau /* 474bd8c8fbbSWilly Tarreau * int gettimeofday(struct timeval *tv, struct timezone *tz); 475bd8c8fbbSWilly Tarreau */ 476bd8c8fbbSWilly Tarreau 477bd8c8fbbSWilly Tarreau static __attribute__((unused)) 478bd8c8fbbSWilly Tarreau int sys_gettimeofday(struct timeval *tv, struct timezone *tz) 479bd8c8fbbSWilly Tarreau { 4802f98aca8SZhangjin Wu #ifdef __NR_gettimeofday 481bd8c8fbbSWilly Tarreau return my_syscall2(__NR_gettimeofday, tv, tz); 4822f98aca8SZhangjin Wu #else 4832f98aca8SZhangjin Wu return -ENOSYS; 4842f98aca8SZhangjin Wu #endif 485bd8c8fbbSWilly Tarreau } 486bd8c8fbbSWilly Tarreau 487bd8c8fbbSWilly Tarreau static __attribute__((unused)) 488bd8c8fbbSWilly Tarreau int gettimeofday(struct timeval *tv, struct timezone *tz) 489bd8c8fbbSWilly Tarreau { 490d27447bcSZhangjin Wu return __sysret(sys_gettimeofday(tv, tz)); 491bd8c8fbbSWilly Tarreau } 492bd8c8fbbSWilly Tarreau 493bd8c8fbbSWilly Tarreau 494bd8c8fbbSWilly Tarreau /* 495919d0532SWilly Tarreau * uid_t getuid(void); 496919d0532SWilly Tarreau */ 497919d0532SWilly Tarreau 498919d0532SWilly Tarreau static __attribute__((unused)) 499919d0532SWilly Tarreau uid_t sys_getuid(void) 500919d0532SWilly Tarreau { 501919d0532SWilly Tarreau #ifdef __NR_getuid32 502919d0532SWilly Tarreau return my_syscall0(__NR_getuid32); 503919d0532SWilly Tarreau #else 504919d0532SWilly Tarreau return my_syscall0(__NR_getuid); 505919d0532SWilly Tarreau #endif 506919d0532SWilly Tarreau } 507919d0532SWilly Tarreau 508919d0532SWilly Tarreau static __attribute__((unused)) 509919d0532SWilly Tarreau uid_t getuid(void) 510919d0532SWilly Tarreau { 511919d0532SWilly Tarreau return sys_getuid(); 512919d0532SWilly Tarreau } 513919d0532SWilly Tarreau 514919d0532SWilly Tarreau 515919d0532SWilly Tarreau /* 516bd8c8fbbSWilly Tarreau * int ioctl(int fd, unsigned long req, void *value); 517bd8c8fbbSWilly Tarreau */ 518bd8c8fbbSWilly Tarreau 519bd8c8fbbSWilly Tarreau static __attribute__((unused)) 520bd8c8fbbSWilly Tarreau int sys_ioctl(int fd, unsigned long req, void *value) 521bd8c8fbbSWilly Tarreau { 522bd8c8fbbSWilly Tarreau return my_syscall3(__NR_ioctl, fd, req, value); 523bd8c8fbbSWilly Tarreau } 524bd8c8fbbSWilly Tarreau 525bd8c8fbbSWilly Tarreau static __attribute__((unused)) 526bd8c8fbbSWilly Tarreau int ioctl(int fd, unsigned long req, void *value) 527bd8c8fbbSWilly Tarreau { 528d27447bcSZhangjin Wu return __sysret(sys_ioctl(fd, req, value)); 529bd8c8fbbSWilly Tarreau } 530bd8c8fbbSWilly Tarreau 531bd8c8fbbSWilly Tarreau /* 532bd8c8fbbSWilly Tarreau * int kill(pid_t pid, int signal); 533bd8c8fbbSWilly Tarreau */ 534bd8c8fbbSWilly Tarreau 535bd8c8fbbSWilly Tarreau static __attribute__((unused)) 536bd8c8fbbSWilly Tarreau int sys_kill(pid_t pid, int signal) 537bd8c8fbbSWilly Tarreau { 538bd8c8fbbSWilly Tarreau return my_syscall2(__NR_kill, pid, signal); 539bd8c8fbbSWilly Tarreau } 540bd8c8fbbSWilly Tarreau 541bd8c8fbbSWilly Tarreau static __attribute__((unused)) 542bd8c8fbbSWilly Tarreau int kill(pid_t pid, int signal) 543bd8c8fbbSWilly Tarreau { 544d27447bcSZhangjin Wu return __sysret(sys_kill(pid, signal)); 545bd8c8fbbSWilly Tarreau } 546bd8c8fbbSWilly Tarreau 547bd8c8fbbSWilly Tarreau 548bd8c8fbbSWilly Tarreau /* 549bd8c8fbbSWilly Tarreau * int link(const char *old, const char *new); 550bd8c8fbbSWilly Tarreau */ 551bd8c8fbbSWilly Tarreau 552bd8c8fbbSWilly Tarreau static __attribute__((unused)) 553bd8c8fbbSWilly Tarreau int sys_link(const char *old, const char *new) 554bd8c8fbbSWilly Tarreau { 555bd8c8fbbSWilly Tarreau #ifdef __NR_linkat 556bd8c8fbbSWilly Tarreau return my_syscall5(__NR_linkat, AT_FDCWD, old, AT_FDCWD, new, 0); 557bd8c8fbbSWilly Tarreau #elif defined(__NR_link) 558bd8c8fbbSWilly Tarreau return my_syscall2(__NR_link, old, new); 559bd8c8fbbSWilly Tarreau #else 560ca50df30SZhangjin Wu return -ENOSYS; 561bd8c8fbbSWilly Tarreau #endif 562bd8c8fbbSWilly Tarreau } 563bd8c8fbbSWilly Tarreau 564bd8c8fbbSWilly Tarreau static __attribute__((unused)) 565bd8c8fbbSWilly Tarreau int link(const char *old, const char *new) 566bd8c8fbbSWilly Tarreau { 567d27447bcSZhangjin Wu return __sysret(sys_link(old, new)); 568bd8c8fbbSWilly Tarreau } 569bd8c8fbbSWilly Tarreau 570bd8c8fbbSWilly Tarreau 571bd8c8fbbSWilly Tarreau /* 572bd8c8fbbSWilly Tarreau * off_t lseek(int fd, off_t offset, int whence); 573bd8c8fbbSWilly Tarreau */ 574bd8c8fbbSWilly Tarreau 575bd8c8fbbSWilly Tarreau static __attribute__((unused)) 576bd8c8fbbSWilly Tarreau off_t sys_lseek(int fd, off_t offset, int whence) 577bd8c8fbbSWilly Tarreau { 5782f98aca8SZhangjin Wu #ifdef __NR_lseek 579bd8c8fbbSWilly Tarreau return my_syscall3(__NR_lseek, fd, offset, whence); 5802f98aca8SZhangjin Wu #else 5812f98aca8SZhangjin Wu return -ENOSYS; 5822f98aca8SZhangjin Wu #endif 583bd8c8fbbSWilly Tarreau } 584bd8c8fbbSWilly Tarreau 585bd8c8fbbSWilly Tarreau static __attribute__((unused)) 586bd8c8fbbSWilly Tarreau off_t lseek(int fd, off_t offset, int whence) 587bd8c8fbbSWilly Tarreau { 588d27447bcSZhangjin Wu return __sysret(sys_lseek(fd, offset, whence)); 589bd8c8fbbSWilly Tarreau } 590bd8c8fbbSWilly Tarreau 591bd8c8fbbSWilly Tarreau 592bd8c8fbbSWilly Tarreau /* 593bd8c8fbbSWilly Tarreau * int mkdir(const char *path, mode_t mode); 594bd8c8fbbSWilly Tarreau */ 595bd8c8fbbSWilly Tarreau 596bd8c8fbbSWilly Tarreau static __attribute__((unused)) 597bd8c8fbbSWilly Tarreau int sys_mkdir(const char *path, mode_t mode) 598bd8c8fbbSWilly Tarreau { 599bd8c8fbbSWilly Tarreau #ifdef __NR_mkdirat 600bd8c8fbbSWilly Tarreau return my_syscall3(__NR_mkdirat, AT_FDCWD, path, mode); 601bd8c8fbbSWilly Tarreau #elif defined(__NR_mkdir) 602bd8c8fbbSWilly Tarreau return my_syscall2(__NR_mkdir, path, mode); 603bd8c8fbbSWilly Tarreau #else 604ca50df30SZhangjin Wu return -ENOSYS; 605bd8c8fbbSWilly Tarreau #endif 606bd8c8fbbSWilly Tarreau } 607bd8c8fbbSWilly Tarreau 608bd8c8fbbSWilly Tarreau static __attribute__((unused)) 609bd8c8fbbSWilly Tarreau int mkdir(const char *path, mode_t mode) 610bd8c8fbbSWilly Tarreau { 611d27447bcSZhangjin Wu return __sysret(sys_mkdir(path, mode)); 612bd8c8fbbSWilly Tarreau } 613bd8c8fbbSWilly Tarreau 614*f4191f3dSZhangjin Wu /* 615*f4191f3dSZhangjin Wu * int rmdir(const char *path); 616*f4191f3dSZhangjin Wu */ 617*f4191f3dSZhangjin Wu 618*f4191f3dSZhangjin Wu static __attribute__((unused)) 619*f4191f3dSZhangjin Wu int sys_rmdir(const char *path) 620*f4191f3dSZhangjin Wu { 621*f4191f3dSZhangjin Wu #ifdef __NR_rmdir 622*f4191f3dSZhangjin Wu return my_syscall1(__NR_rmdir, path); 623*f4191f3dSZhangjin Wu #elif defined(__NR_unlinkat) 624*f4191f3dSZhangjin Wu return my_syscall3(__NR_unlinkat, AT_FDCWD, path, AT_REMOVEDIR); 625*f4191f3dSZhangjin Wu #else 626*f4191f3dSZhangjin Wu return -ENOSYS; 627*f4191f3dSZhangjin Wu #endif 628*f4191f3dSZhangjin Wu } 629*f4191f3dSZhangjin Wu 630*f4191f3dSZhangjin Wu static __attribute__((unused)) 631*f4191f3dSZhangjin Wu int rmdir(const char *path) 632*f4191f3dSZhangjin Wu { 633*f4191f3dSZhangjin Wu return __sysret(sys_rmdir(path)); 634*f4191f3dSZhangjin Wu } 635*f4191f3dSZhangjin Wu 636bd8c8fbbSWilly Tarreau 637bd8c8fbbSWilly Tarreau /* 638bd8c8fbbSWilly Tarreau * int mknod(const char *path, mode_t mode, dev_t dev); 639bd8c8fbbSWilly Tarreau */ 640bd8c8fbbSWilly Tarreau 641bd8c8fbbSWilly Tarreau static __attribute__((unused)) 642bd8c8fbbSWilly Tarreau long sys_mknod(const char *path, mode_t mode, dev_t dev) 643bd8c8fbbSWilly Tarreau { 644bd8c8fbbSWilly Tarreau #ifdef __NR_mknodat 645bd8c8fbbSWilly Tarreau return my_syscall4(__NR_mknodat, AT_FDCWD, path, mode, dev); 646bd8c8fbbSWilly Tarreau #elif defined(__NR_mknod) 647bd8c8fbbSWilly Tarreau return my_syscall3(__NR_mknod, path, mode, dev); 648bd8c8fbbSWilly Tarreau #else 649ca50df30SZhangjin Wu return -ENOSYS; 650bd8c8fbbSWilly Tarreau #endif 651bd8c8fbbSWilly Tarreau } 652bd8c8fbbSWilly Tarreau 653bd8c8fbbSWilly Tarreau static __attribute__((unused)) 654bd8c8fbbSWilly Tarreau int mknod(const char *path, mode_t mode, dev_t dev) 655bd8c8fbbSWilly Tarreau { 656d27447bcSZhangjin Wu return __sysret(sys_mknod(path, mode, dev)); 657bd8c8fbbSWilly Tarreau } 658bd8c8fbbSWilly Tarreau 65918a5a09dSSven Schnelle #ifndef sys_mmap 660544fa1a2SAmmar Faizi static __attribute__((unused)) 661544fa1a2SAmmar Faizi void *sys_mmap(void *addr, size_t length, int prot, int flags, int fd, 662544fa1a2SAmmar Faizi off_t offset) 663544fa1a2SAmmar Faizi { 664544fa1a2SAmmar Faizi int n; 665544fa1a2SAmmar Faizi 666364702f7SWilly Tarreau #if defined(__NR_mmap2) 667544fa1a2SAmmar Faizi n = __NR_mmap2; 668544fa1a2SAmmar Faizi offset >>= 12; 669544fa1a2SAmmar Faizi #else 670544fa1a2SAmmar Faizi n = __NR_mmap; 671544fa1a2SAmmar Faizi #endif 672544fa1a2SAmmar Faizi 673544fa1a2SAmmar Faizi return (void *)my_syscall6(n, addr, length, prot, flags, fd, offset); 674544fa1a2SAmmar Faizi } 67518a5a09dSSven Schnelle #endif 676544fa1a2SAmmar Faizi 677924e9539SZhangjin Wu /* Note that on Linux, MAP_FAILED is -1 so we can use the generic __sysret() 678924e9539SZhangjin Wu * which returns -1 upon error and still satisfy user land that checks for 679924e9539SZhangjin Wu * MAP_FAILED. 680924e9539SZhangjin Wu */ 681924e9539SZhangjin Wu 682544fa1a2SAmmar Faizi static __attribute__((unused)) 683544fa1a2SAmmar Faizi void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset) 684544fa1a2SAmmar Faizi { 685924e9539SZhangjin Wu return (void *)__sysret((unsigned long)sys_mmap(addr, length, prot, flags, fd, offset)); 686544fa1a2SAmmar Faizi } 687544fa1a2SAmmar Faizi 688544fa1a2SAmmar Faizi static __attribute__((unused)) 689544fa1a2SAmmar Faizi int sys_munmap(void *addr, size_t length) 690544fa1a2SAmmar Faizi { 691544fa1a2SAmmar Faizi return my_syscall2(__NR_munmap, addr, length); 692544fa1a2SAmmar Faizi } 693544fa1a2SAmmar Faizi 694544fa1a2SAmmar Faizi static __attribute__((unused)) 695544fa1a2SAmmar Faizi int munmap(void *addr, size_t length) 696544fa1a2SAmmar Faizi { 697d27447bcSZhangjin Wu return __sysret(sys_munmap(addr, length)); 698544fa1a2SAmmar Faizi } 699bd8c8fbbSWilly Tarreau 700bd8c8fbbSWilly Tarreau /* 701bd8c8fbbSWilly Tarreau * int mount(const char *source, const char *target, 702bd8c8fbbSWilly Tarreau * const char *fstype, unsigned long flags, 703bd8c8fbbSWilly Tarreau * const void *data); 704bd8c8fbbSWilly Tarreau */ 705bd8c8fbbSWilly Tarreau static __attribute__((unused)) 706bd8c8fbbSWilly Tarreau int sys_mount(const char *src, const char *tgt, const char *fst, 707bd8c8fbbSWilly Tarreau unsigned long flags, const void *data) 708bd8c8fbbSWilly Tarreau { 709bd8c8fbbSWilly Tarreau return my_syscall5(__NR_mount, src, tgt, fst, flags, data); 710bd8c8fbbSWilly Tarreau } 711bd8c8fbbSWilly Tarreau 712bd8c8fbbSWilly Tarreau static __attribute__((unused)) 713bd8c8fbbSWilly Tarreau int mount(const char *src, const char *tgt, 714bd8c8fbbSWilly Tarreau const char *fst, unsigned long flags, 715bd8c8fbbSWilly Tarreau const void *data) 716bd8c8fbbSWilly Tarreau { 717d27447bcSZhangjin Wu return __sysret(sys_mount(src, tgt, fst, flags, data)); 718bd8c8fbbSWilly Tarreau } 719bd8c8fbbSWilly Tarreau 720bd8c8fbbSWilly Tarreau 721bd8c8fbbSWilly Tarreau /* 722a7604ba1SWilly Tarreau * int open(const char *path, int flags[, mode_t mode]); 723bd8c8fbbSWilly Tarreau */ 724bd8c8fbbSWilly Tarreau 725bd8c8fbbSWilly Tarreau static __attribute__((unused)) 726bd8c8fbbSWilly Tarreau int sys_open(const char *path, int flags, mode_t mode) 727bd8c8fbbSWilly Tarreau { 728bd8c8fbbSWilly Tarreau #ifdef __NR_openat 729bd8c8fbbSWilly Tarreau return my_syscall4(__NR_openat, AT_FDCWD, path, flags, mode); 730bd8c8fbbSWilly Tarreau #elif defined(__NR_open) 731bd8c8fbbSWilly Tarreau return my_syscall3(__NR_open, path, flags, mode); 732bd8c8fbbSWilly Tarreau #else 733ca50df30SZhangjin Wu return -ENOSYS; 734bd8c8fbbSWilly Tarreau #endif 735bd8c8fbbSWilly Tarreau } 736bd8c8fbbSWilly Tarreau 737bd8c8fbbSWilly Tarreau static __attribute__((unused)) 738a7604ba1SWilly Tarreau int open(const char *path, int flags, ...) 739bd8c8fbbSWilly Tarreau { 740a7604ba1SWilly Tarreau mode_t mode = 0; 741a7604ba1SWilly Tarreau int ret; 742a7604ba1SWilly Tarreau 743a7604ba1SWilly Tarreau if (flags & O_CREAT) { 744a7604ba1SWilly Tarreau va_list args; 745a7604ba1SWilly Tarreau 746a7604ba1SWilly Tarreau va_start(args, flags); 747f62ec079SZhangjin Wu mode = va_arg(args, int); 748a7604ba1SWilly Tarreau va_end(args); 749a7604ba1SWilly Tarreau } 750a7604ba1SWilly Tarreau 751d27447bcSZhangjin Wu return __sysret(sys_open(path, flags, mode)); 752bd8c8fbbSWilly Tarreau } 753bd8c8fbbSWilly Tarreau 754bd8c8fbbSWilly Tarreau 755bd8c8fbbSWilly Tarreau /* 756208aa9d9SThomas Weißschuh * int prctl(int option, unsigned long arg2, unsigned long arg3, 757208aa9d9SThomas Weißschuh * unsigned long arg4, unsigned long arg5); 758208aa9d9SThomas Weißschuh */ 759208aa9d9SThomas Weißschuh 760208aa9d9SThomas Weißschuh static __attribute__((unused)) 761208aa9d9SThomas Weißschuh int sys_prctl(int option, unsigned long arg2, unsigned long arg3, 762208aa9d9SThomas Weißschuh unsigned long arg4, unsigned long arg5) 763208aa9d9SThomas Weißschuh { 764208aa9d9SThomas Weißschuh return my_syscall5(__NR_prctl, option, arg2, arg3, arg4, arg5); 765208aa9d9SThomas Weißschuh } 766208aa9d9SThomas Weißschuh 767208aa9d9SThomas Weißschuh static __attribute__((unused)) 768208aa9d9SThomas Weißschuh int prctl(int option, unsigned long arg2, unsigned long arg3, 769208aa9d9SThomas Weißschuh unsigned long arg4, unsigned long arg5) 770208aa9d9SThomas Weißschuh { 771d27447bcSZhangjin Wu return __sysret(sys_prctl(option, arg2, arg3, arg4, arg5)); 772208aa9d9SThomas Weißschuh } 773208aa9d9SThomas Weißschuh 774208aa9d9SThomas Weißschuh 775208aa9d9SThomas Weißschuh /* 776bd8c8fbbSWilly Tarreau * int pivot_root(const char *new, const char *old); 777bd8c8fbbSWilly Tarreau */ 778bd8c8fbbSWilly Tarreau 779bd8c8fbbSWilly Tarreau static __attribute__((unused)) 780bd8c8fbbSWilly Tarreau int sys_pivot_root(const char *new, const char *old) 781bd8c8fbbSWilly Tarreau { 782bd8c8fbbSWilly Tarreau return my_syscall2(__NR_pivot_root, new, old); 783bd8c8fbbSWilly Tarreau } 784bd8c8fbbSWilly Tarreau 785bd8c8fbbSWilly Tarreau static __attribute__((unused)) 786bd8c8fbbSWilly Tarreau int pivot_root(const char *new, const char *old) 787bd8c8fbbSWilly Tarreau { 788d27447bcSZhangjin Wu return __sysret(sys_pivot_root(new, old)); 789bd8c8fbbSWilly Tarreau } 790bd8c8fbbSWilly Tarreau 791bd8c8fbbSWilly Tarreau 792bd8c8fbbSWilly Tarreau /* 793bd8c8fbbSWilly Tarreau * int poll(struct pollfd *fds, int nfds, int timeout); 794bd8c8fbbSWilly Tarreau */ 795bd8c8fbbSWilly Tarreau 796bd8c8fbbSWilly Tarreau static __attribute__((unused)) 797bd8c8fbbSWilly Tarreau int sys_poll(struct pollfd *fds, int nfds, int timeout) 798bd8c8fbbSWilly Tarreau { 799bd8c8fbbSWilly Tarreau #if defined(__NR_ppoll) 800bd8c8fbbSWilly Tarreau struct timespec t; 801bd8c8fbbSWilly Tarreau 802bd8c8fbbSWilly Tarreau if (timeout >= 0) { 803bd8c8fbbSWilly Tarreau t.tv_sec = timeout / 1000; 804bd8c8fbbSWilly Tarreau t.tv_nsec = (timeout % 1000) * 1000000; 805bd8c8fbbSWilly Tarreau } 8060dd2fdbfSZhangjin Wu return my_syscall5(__NR_ppoll, fds, nfds, (timeout >= 0) ? &t : NULL, NULL, 0); 807bd8c8fbbSWilly Tarreau #elif defined(__NR_poll) 808bd8c8fbbSWilly Tarreau return my_syscall3(__NR_poll, fds, nfds, timeout); 809bd8c8fbbSWilly Tarreau #else 810ca50df30SZhangjin Wu return -ENOSYS; 811bd8c8fbbSWilly Tarreau #endif 812bd8c8fbbSWilly Tarreau } 813bd8c8fbbSWilly Tarreau 814bd8c8fbbSWilly Tarreau static __attribute__((unused)) 815bd8c8fbbSWilly Tarreau int poll(struct pollfd *fds, int nfds, int timeout) 816bd8c8fbbSWilly Tarreau { 817d27447bcSZhangjin Wu return __sysret(sys_poll(fds, nfds, timeout)); 818bd8c8fbbSWilly Tarreau } 819bd8c8fbbSWilly Tarreau 820bd8c8fbbSWilly Tarreau 821bd8c8fbbSWilly Tarreau /* 822bd8c8fbbSWilly Tarreau * ssize_t read(int fd, void *buf, size_t count); 823bd8c8fbbSWilly Tarreau */ 824bd8c8fbbSWilly Tarreau 825bd8c8fbbSWilly Tarreau static __attribute__((unused)) 826bd8c8fbbSWilly Tarreau ssize_t sys_read(int fd, void *buf, size_t count) 827bd8c8fbbSWilly Tarreau { 828bd8c8fbbSWilly Tarreau return my_syscall3(__NR_read, fd, buf, count); 829bd8c8fbbSWilly Tarreau } 830bd8c8fbbSWilly Tarreau 831bd8c8fbbSWilly Tarreau static __attribute__((unused)) 832bd8c8fbbSWilly Tarreau ssize_t read(int fd, void *buf, size_t count) 833bd8c8fbbSWilly Tarreau { 834d27447bcSZhangjin Wu return __sysret(sys_read(fd, buf, count)); 835bd8c8fbbSWilly Tarreau } 836bd8c8fbbSWilly Tarreau 837bd8c8fbbSWilly Tarreau 838bd8c8fbbSWilly Tarreau /* 839bd8c8fbbSWilly Tarreau * int reboot(int cmd); 840bd8c8fbbSWilly Tarreau * <cmd> is among LINUX_REBOOT_CMD_* 841bd8c8fbbSWilly Tarreau */ 842bd8c8fbbSWilly Tarreau 843bd8c8fbbSWilly Tarreau static __attribute__((unused)) 844bd8c8fbbSWilly Tarreau ssize_t sys_reboot(int magic1, int magic2, int cmd, void *arg) 845bd8c8fbbSWilly Tarreau { 846bd8c8fbbSWilly Tarreau return my_syscall4(__NR_reboot, magic1, magic2, cmd, arg); 847bd8c8fbbSWilly Tarreau } 848bd8c8fbbSWilly Tarreau 849bd8c8fbbSWilly Tarreau static __attribute__((unused)) 850bd8c8fbbSWilly Tarreau int reboot(int cmd) 851bd8c8fbbSWilly Tarreau { 852d27447bcSZhangjin Wu return __sysret(sys_reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, 0)); 853bd8c8fbbSWilly Tarreau } 854bd8c8fbbSWilly Tarreau 855bd8c8fbbSWilly Tarreau 856bd8c8fbbSWilly Tarreau /* 857bd8c8fbbSWilly Tarreau * int sched_yield(void); 858bd8c8fbbSWilly Tarreau */ 859bd8c8fbbSWilly Tarreau 860bd8c8fbbSWilly Tarreau static __attribute__((unused)) 861bd8c8fbbSWilly Tarreau int sys_sched_yield(void) 862bd8c8fbbSWilly Tarreau { 863bd8c8fbbSWilly Tarreau return my_syscall0(__NR_sched_yield); 864bd8c8fbbSWilly Tarreau } 865bd8c8fbbSWilly Tarreau 866bd8c8fbbSWilly Tarreau static __attribute__((unused)) 867bd8c8fbbSWilly Tarreau int sched_yield(void) 868bd8c8fbbSWilly Tarreau { 869d27447bcSZhangjin Wu return __sysret(sys_sched_yield()); 870bd8c8fbbSWilly Tarreau } 871bd8c8fbbSWilly Tarreau 872bd8c8fbbSWilly Tarreau 873bd8c8fbbSWilly Tarreau /* 874bd8c8fbbSWilly Tarreau * int select(int nfds, fd_set *read_fds, fd_set *write_fds, 875bd8c8fbbSWilly Tarreau * fd_set *except_fds, struct timeval *timeout); 876bd8c8fbbSWilly Tarreau */ 877bd8c8fbbSWilly Tarreau 878bd8c8fbbSWilly Tarreau static __attribute__((unused)) 879bd8c8fbbSWilly Tarreau int sys_select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout) 880bd8c8fbbSWilly Tarreau { 881bd8c8fbbSWilly Tarreau #if defined(__ARCH_WANT_SYS_OLD_SELECT) && !defined(__NR__newselect) 882bd8c8fbbSWilly Tarreau struct sel_arg_struct { 883bd8c8fbbSWilly Tarreau unsigned long n; 884bd8c8fbbSWilly Tarreau fd_set *r, *w, *e; 885bd8c8fbbSWilly Tarreau struct timeval *t; 886bd8c8fbbSWilly Tarreau } arg = { .n = nfds, .r = rfds, .w = wfds, .e = efds, .t = timeout }; 887bd8c8fbbSWilly Tarreau return my_syscall1(__NR_select, &arg); 888bd8c8fbbSWilly Tarreau #elif defined(__ARCH_WANT_SYS_PSELECT6) && defined(__NR_pselect6) 889bd8c8fbbSWilly Tarreau struct timespec t; 890bd8c8fbbSWilly Tarreau 891bd8c8fbbSWilly Tarreau if (timeout) { 892bd8c8fbbSWilly Tarreau t.tv_sec = timeout->tv_sec; 893bd8c8fbbSWilly Tarreau t.tv_nsec = timeout->tv_usec * 1000; 894bd8c8fbbSWilly Tarreau } 895bd8c8fbbSWilly Tarreau return my_syscall6(__NR_pselect6, nfds, rfds, wfds, efds, timeout ? &t : NULL, NULL); 896bd8c8fbbSWilly Tarreau #elif defined(__NR__newselect) || defined(__NR_select) 897bd8c8fbbSWilly Tarreau #ifndef __NR__newselect 898bd8c8fbbSWilly Tarreau #define __NR__newselect __NR_select 899bd8c8fbbSWilly Tarreau #endif 900bd8c8fbbSWilly Tarreau return my_syscall5(__NR__newselect, nfds, rfds, wfds, efds, timeout); 901bd8c8fbbSWilly Tarreau #else 902ca50df30SZhangjin Wu return -ENOSYS; 903bd8c8fbbSWilly Tarreau #endif 904bd8c8fbbSWilly Tarreau } 905bd8c8fbbSWilly Tarreau 906bd8c8fbbSWilly Tarreau static __attribute__((unused)) 907bd8c8fbbSWilly Tarreau int select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout) 908bd8c8fbbSWilly Tarreau { 909d27447bcSZhangjin Wu return __sysret(sys_select(nfds, rfds, wfds, efds, timeout)); 910bd8c8fbbSWilly Tarreau } 911bd8c8fbbSWilly Tarreau 912bd8c8fbbSWilly Tarreau 913bd8c8fbbSWilly Tarreau /* 914bd8c8fbbSWilly Tarreau * int setpgid(pid_t pid, pid_t pgid); 915bd8c8fbbSWilly Tarreau */ 916bd8c8fbbSWilly Tarreau 917bd8c8fbbSWilly Tarreau static __attribute__((unused)) 918bd8c8fbbSWilly Tarreau int sys_setpgid(pid_t pid, pid_t pgid) 919bd8c8fbbSWilly Tarreau { 920bd8c8fbbSWilly Tarreau return my_syscall2(__NR_setpgid, pid, pgid); 921bd8c8fbbSWilly Tarreau } 922bd8c8fbbSWilly Tarreau 923bd8c8fbbSWilly Tarreau static __attribute__((unused)) 924bd8c8fbbSWilly Tarreau int setpgid(pid_t pid, pid_t pgid) 925bd8c8fbbSWilly Tarreau { 926d27447bcSZhangjin Wu return __sysret(sys_setpgid(pid, pgid)); 927bd8c8fbbSWilly Tarreau } 928bd8c8fbbSWilly Tarreau 929bd8c8fbbSWilly Tarreau 930bd8c8fbbSWilly Tarreau /* 931bd8c8fbbSWilly Tarreau * pid_t setsid(void); 932bd8c8fbbSWilly Tarreau */ 933bd8c8fbbSWilly Tarreau 934bd8c8fbbSWilly Tarreau static __attribute__((unused)) 935bd8c8fbbSWilly Tarreau pid_t sys_setsid(void) 936bd8c8fbbSWilly Tarreau { 937bd8c8fbbSWilly Tarreau return my_syscall0(__NR_setsid); 938bd8c8fbbSWilly Tarreau } 939bd8c8fbbSWilly Tarreau 940bd8c8fbbSWilly Tarreau static __attribute__((unused)) 941bd8c8fbbSWilly Tarreau pid_t setsid(void) 942bd8c8fbbSWilly Tarreau { 943d27447bcSZhangjin Wu return __sysret(sys_setsid()); 944bd8c8fbbSWilly Tarreau } 945bd8c8fbbSWilly Tarreau 946b551cb7dSFeiyang Chen #if defined(__NR_statx) 947b551cb7dSFeiyang Chen /* 948b551cb7dSFeiyang Chen * int statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf); 949b551cb7dSFeiyang Chen */ 950b551cb7dSFeiyang Chen 951b551cb7dSFeiyang Chen static __attribute__((unused)) 952b551cb7dSFeiyang Chen int sys_statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf) 953b551cb7dSFeiyang Chen { 954b551cb7dSFeiyang Chen return my_syscall5(__NR_statx, fd, path, flags, mask, buf); 955b551cb7dSFeiyang Chen } 956b551cb7dSFeiyang Chen 957b551cb7dSFeiyang Chen static __attribute__((unused)) 958b551cb7dSFeiyang Chen int statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf) 959b551cb7dSFeiyang Chen { 960d27447bcSZhangjin Wu return __sysret(sys_statx(fd, path, flags, mask, buf)); 961b551cb7dSFeiyang Chen } 962b551cb7dSFeiyang Chen #endif 963bd8c8fbbSWilly Tarreau 964bd8c8fbbSWilly Tarreau /* 965bd8c8fbbSWilly Tarreau * int stat(const char *path, struct stat *buf); 966bd8c8fbbSWilly Tarreau * Warning: the struct stat's layout is arch-dependent. 967bd8c8fbbSWilly Tarreau */ 968bd8c8fbbSWilly Tarreau 969b551cb7dSFeiyang Chen #if defined(__NR_statx) && !defined(__NR_newfstatat) && !defined(__NR_stat) 970b551cb7dSFeiyang Chen /* 971b551cb7dSFeiyang Chen * Maybe we can just use statx() when available for all architectures? 972b551cb7dSFeiyang Chen */ 973b551cb7dSFeiyang Chen static __attribute__((unused)) 974b551cb7dSFeiyang Chen int sys_stat(const char *path, struct stat *buf) 975b551cb7dSFeiyang Chen { 976b551cb7dSFeiyang Chen struct statx statx; 977b551cb7dSFeiyang Chen long ret; 978b551cb7dSFeiyang Chen 979b551cb7dSFeiyang Chen ret = sys_statx(AT_FDCWD, path, AT_NO_AUTOMOUNT, STATX_BASIC_STATS, &statx); 980b551cb7dSFeiyang Chen buf->st_dev = ((statx.stx_dev_minor & 0xff) 981b551cb7dSFeiyang Chen | (statx.stx_dev_major << 8) 982b551cb7dSFeiyang Chen | ((statx.stx_dev_minor & ~0xff) << 12)); 983b551cb7dSFeiyang Chen buf->st_ino = statx.stx_ino; 984b551cb7dSFeiyang Chen buf->st_mode = statx.stx_mode; 985b551cb7dSFeiyang Chen buf->st_nlink = statx.stx_nlink; 986b551cb7dSFeiyang Chen buf->st_uid = statx.stx_uid; 987b551cb7dSFeiyang Chen buf->st_gid = statx.stx_gid; 988b551cb7dSFeiyang Chen buf->st_rdev = ((statx.stx_rdev_minor & 0xff) 989b551cb7dSFeiyang Chen | (statx.stx_rdev_major << 8) 990b551cb7dSFeiyang Chen | ((statx.stx_rdev_minor & ~0xff) << 12)); 991b551cb7dSFeiyang Chen buf->st_size = statx.stx_size; 992b551cb7dSFeiyang Chen buf->st_blksize = statx.stx_blksize; 993b551cb7dSFeiyang Chen buf->st_blocks = statx.stx_blocks; 99487b9fa66SThomas Weißschuh buf->st_atim.tv_sec = statx.stx_atime.tv_sec; 99587b9fa66SThomas Weißschuh buf->st_atim.tv_nsec = statx.stx_atime.tv_nsec; 99687b9fa66SThomas Weißschuh buf->st_mtim.tv_sec = statx.stx_mtime.tv_sec; 99787b9fa66SThomas Weißschuh buf->st_mtim.tv_nsec = statx.stx_mtime.tv_nsec; 99887b9fa66SThomas Weißschuh buf->st_ctim.tv_sec = statx.stx_ctime.tv_sec; 99987b9fa66SThomas Weißschuh buf->st_ctim.tv_nsec = statx.stx_ctime.tv_nsec; 1000b551cb7dSFeiyang Chen return ret; 1001b551cb7dSFeiyang Chen } 1002b551cb7dSFeiyang Chen #else 1003bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1004bd8c8fbbSWilly Tarreau int sys_stat(const char *path, struct stat *buf) 1005bd8c8fbbSWilly Tarreau { 1006bd8c8fbbSWilly Tarreau struct sys_stat_struct stat; 1007bd8c8fbbSWilly Tarreau long ret; 1008bd8c8fbbSWilly Tarreau 1009bd8c8fbbSWilly Tarreau #ifdef __NR_newfstatat 1010bd8c8fbbSWilly Tarreau /* only solution for arm64 */ 1011bd8c8fbbSWilly Tarreau ret = my_syscall4(__NR_newfstatat, AT_FDCWD, path, &stat, 0); 1012bd8c8fbbSWilly Tarreau #elif defined(__NR_stat) 1013bd8c8fbbSWilly Tarreau ret = my_syscall2(__NR_stat, path, &stat); 1014bd8c8fbbSWilly Tarreau #else 1015ca50df30SZhangjin Wu return -ENOSYS; 1016bd8c8fbbSWilly Tarreau #endif 1017bd8c8fbbSWilly Tarreau buf->st_dev = stat.st_dev; 1018bd8c8fbbSWilly Tarreau buf->st_ino = stat.st_ino; 1019bd8c8fbbSWilly Tarreau buf->st_mode = stat.st_mode; 1020bd8c8fbbSWilly Tarreau buf->st_nlink = stat.st_nlink; 1021bd8c8fbbSWilly Tarreau buf->st_uid = stat.st_uid; 1022bd8c8fbbSWilly Tarreau buf->st_gid = stat.st_gid; 1023bd8c8fbbSWilly Tarreau buf->st_rdev = stat.st_rdev; 1024bd8c8fbbSWilly Tarreau buf->st_size = stat.st_size; 1025bd8c8fbbSWilly Tarreau buf->st_blksize = stat.st_blksize; 1026bd8c8fbbSWilly Tarreau buf->st_blocks = stat.st_blocks; 102787b9fa66SThomas Weißschuh buf->st_atim.tv_sec = stat.st_atime; 102887b9fa66SThomas Weißschuh buf->st_atim.tv_nsec = stat.st_atime_nsec; 102987b9fa66SThomas Weißschuh buf->st_mtim.tv_sec = stat.st_mtime; 103087b9fa66SThomas Weißschuh buf->st_mtim.tv_nsec = stat.st_mtime_nsec; 103187b9fa66SThomas Weißschuh buf->st_ctim.tv_sec = stat.st_ctime; 103287b9fa66SThomas Weißschuh buf->st_ctim.tv_nsec = stat.st_ctime_nsec; 1033bd8c8fbbSWilly Tarreau return ret; 1034bd8c8fbbSWilly Tarreau } 1035b551cb7dSFeiyang Chen #endif 1036bd8c8fbbSWilly Tarreau 1037bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1038bd8c8fbbSWilly Tarreau int stat(const char *path, struct stat *buf) 1039bd8c8fbbSWilly Tarreau { 1040d27447bcSZhangjin Wu return __sysret(sys_stat(path, buf)); 1041bd8c8fbbSWilly Tarreau } 1042bd8c8fbbSWilly Tarreau 1043bd8c8fbbSWilly Tarreau 1044bd8c8fbbSWilly Tarreau /* 1045bd8c8fbbSWilly Tarreau * int symlink(const char *old, const char *new); 1046bd8c8fbbSWilly Tarreau */ 1047bd8c8fbbSWilly Tarreau 1048bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1049bd8c8fbbSWilly Tarreau int sys_symlink(const char *old, const char *new) 1050bd8c8fbbSWilly Tarreau { 1051bd8c8fbbSWilly Tarreau #ifdef __NR_symlinkat 1052bd8c8fbbSWilly Tarreau return my_syscall3(__NR_symlinkat, old, AT_FDCWD, new); 1053bd8c8fbbSWilly Tarreau #elif defined(__NR_symlink) 1054bd8c8fbbSWilly Tarreau return my_syscall2(__NR_symlink, old, new); 1055bd8c8fbbSWilly Tarreau #else 1056ca50df30SZhangjin Wu return -ENOSYS; 1057bd8c8fbbSWilly Tarreau #endif 1058bd8c8fbbSWilly Tarreau } 1059bd8c8fbbSWilly Tarreau 1060bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1061bd8c8fbbSWilly Tarreau int symlink(const char *old, const char *new) 1062bd8c8fbbSWilly Tarreau { 1063d27447bcSZhangjin Wu return __sysret(sys_symlink(old, new)); 1064bd8c8fbbSWilly Tarreau } 1065bd8c8fbbSWilly Tarreau 1066bd8c8fbbSWilly Tarreau 1067bd8c8fbbSWilly Tarreau /* 1068bd8c8fbbSWilly Tarreau * mode_t umask(mode_t mode); 1069bd8c8fbbSWilly Tarreau */ 1070bd8c8fbbSWilly Tarreau 1071bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1072bd8c8fbbSWilly Tarreau mode_t sys_umask(mode_t mode) 1073bd8c8fbbSWilly Tarreau { 1074bd8c8fbbSWilly Tarreau return my_syscall1(__NR_umask, mode); 1075bd8c8fbbSWilly Tarreau } 1076bd8c8fbbSWilly Tarreau 1077bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1078bd8c8fbbSWilly Tarreau mode_t umask(mode_t mode) 1079bd8c8fbbSWilly Tarreau { 1080bd8c8fbbSWilly Tarreau return sys_umask(mode); 1081bd8c8fbbSWilly Tarreau } 1082bd8c8fbbSWilly Tarreau 1083bd8c8fbbSWilly Tarreau 1084bd8c8fbbSWilly Tarreau /* 1085bd8c8fbbSWilly Tarreau * int umount2(const char *path, int flags); 1086bd8c8fbbSWilly Tarreau */ 1087bd8c8fbbSWilly Tarreau 1088bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1089bd8c8fbbSWilly Tarreau int sys_umount2(const char *path, int flags) 1090bd8c8fbbSWilly Tarreau { 1091bd8c8fbbSWilly Tarreau return my_syscall2(__NR_umount2, path, flags); 1092bd8c8fbbSWilly Tarreau } 1093bd8c8fbbSWilly Tarreau 1094bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1095bd8c8fbbSWilly Tarreau int umount2(const char *path, int flags) 1096bd8c8fbbSWilly Tarreau { 1097d27447bcSZhangjin Wu return __sysret(sys_umount2(path, flags)); 1098bd8c8fbbSWilly Tarreau } 1099bd8c8fbbSWilly Tarreau 1100bd8c8fbbSWilly Tarreau 1101bd8c8fbbSWilly Tarreau /* 1102bd8c8fbbSWilly Tarreau * int unlink(const char *path); 1103bd8c8fbbSWilly Tarreau */ 1104bd8c8fbbSWilly Tarreau 1105bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1106bd8c8fbbSWilly Tarreau int sys_unlink(const char *path) 1107bd8c8fbbSWilly Tarreau { 1108bd8c8fbbSWilly Tarreau #ifdef __NR_unlinkat 1109bd8c8fbbSWilly Tarreau return my_syscall3(__NR_unlinkat, AT_FDCWD, path, 0); 1110bd8c8fbbSWilly Tarreau #elif defined(__NR_unlink) 1111bd8c8fbbSWilly Tarreau return my_syscall1(__NR_unlink, path); 1112bd8c8fbbSWilly Tarreau #else 1113ca50df30SZhangjin Wu return -ENOSYS; 1114bd8c8fbbSWilly Tarreau #endif 1115bd8c8fbbSWilly Tarreau } 1116bd8c8fbbSWilly Tarreau 1117bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1118bd8c8fbbSWilly Tarreau int unlink(const char *path) 1119bd8c8fbbSWilly Tarreau { 1120d27447bcSZhangjin Wu return __sysret(sys_unlink(path)); 1121bd8c8fbbSWilly Tarreau } 1122bd8c8fbbSWilly Tarreau 1123bd8c8fbbSWilly Tarreau 1124bd8c8fbbSWilly Tarreau /* 1125bd8c8fbbSWilly Tarreau * pid_t wait(int *status); 1126bd8c8fbbSWilly Tarreau * pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage); 1127bd8c8fbbSWilly Tarreau * pid_t waitpid(pid_t pid, int *status, int options); 1128bd8c8fbbSWilly Tarreau */ 1129bd8c8fbbSWilly Tarreau 1130bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1131bd8c8fbbSWilly Tarreau pid_t sys_wait4(pid_t pid, int *status, int options, struct rusage *rusage) 1132bd8c8fbbSWilly Tarreau { 11332f98aca8SZhangjin Wu #ifdef __NR_wait4 1134bd8c8fbbSWilly Tarreau return my_syscall4(__NR_wait4, pid, status, options, rusage); 11352f98aca8SZhangjin Wu #else 11362f98aca8SZhangjin Wu return -ENOSYS; 11372f98aca8SZhangjin Wu #endif 1138bd8c8fbbSWilly Tarreau } 1139bd8c8fbbSWilly Tarreau 1140bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1141bd8c8fbbSWilly Tarreau pid_t wait(int *status) 1142bd8c8fbbSWilly Tarreau { 1143d27447bcSZhangjin Wu return __sysret(sys_wait4(-1, status, 0, NULL)); 1144bd8c8fbbSWilly Tarreau } 1145bd8c8fbbSWilly Tarreau 1146bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1147bd8c8fbbSWilly Tarreau pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage) 1148bd8c8fbbSWilly Tarreau { 1149d27447bcSZhangjin Wu return __sysret(sys_wait4(pid, status, options, rusage)); 1150bd8c8fbbSWilly Tarreau } 1151bd8c8fbbSWilly Tarreau 1152bd8c8fbbSWilly Tarreau 1153bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1154bd8c8fbbSWilly Tarreau pid_t waitpid(pid_t pid, int *status, int options) 1155bd8c8fbbSWilly Tarreau { 1156d27447bcSZhangjin Wu return __sysret(sys_wait4(pid, status, options, NULL)); 1157bd8c8fbbSWilly Tarreau } 1158bd8c8fbbSWilly Tarreau 1159bd8c8fbbSWilly Tarreau 1160bd8c8fbbSWilly Tarreau /* 1161bd8c8fbbSWilly Tarreau * ssize_t write(int fd, const void *buf, size_t count); 1162bd8c8fbbSWilly Tarreau */ 1163bd8c8fbbSWilly Tarreau 1164bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1165bd8c8fbbSWilly Tarreau ssize_t sys_write(int fd, const void *buf, size_t count) 1166bd8c8fbbSWilly Tarreau { 1167bd8c8fbbSWilly Tarreau return my_syscall3(__NR_write, fd, buf, count); 1168bd8c8fbbSWilly Tarreau } 1169bd8c8fbbSWilly Tarreau 1170bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1171bd8c8fbbSWilly Tarreau ssize_t write(int fd, const void *buf, size_t count) 1172bd8c8fbbSWilly Tarreau { 1173d27447bcSZhangjin Wu return __sysret(sys_write(fd, buf, count)); 1174bd8c8fbbSWilly Tarreau } 1175bd8c8fbbSWilly Tarreau 1176e8842cf0SThomas Weißschuh 1177e8842cf0SThomas Weißschuh /* 1178e8842cf0SThomas Weißschuh * int memfd_create(const char *name, unsigned int flags); 1179e8842cf0SThomas Weißschuh */ 1180e8842cf0SThomas Weißschuh 1181e8842cf0SThomas Weißschuh static __attribute__((unused)) 1182e8842cf0SThomas Weißschuh int sys_memfd_create(const char *name, unsigned int flags) 1183e8842cf0SThomas Weißschuh { 1184e8842cf0SThomas Weißschuh return my_syscall2(__NR_memfd_create, name, flags); 1185e8842cf0SThomas Weißschuh } 1186e8842cf0SThomas Weißschuh 1187e8842cf0SThomas Weißschuh static __attribute__((unused)) 1188e8842cf0SThomas Weißschuh int memfd_create(const char *name, unsigned int flags) 1189e8842cf0SThomas Weißschuh { 1190d27447bcSZhangjin Wu return __sysret(sys_memfd_create(name, flags)); 1191e8842cf0SThomas Weißschuh } 1192e8842cf0SThomas Weißschuh 119355abdd1fSWilly Tarreau /* make sure to include all global symbols */ 119455abdd1fSWilly Tarreau #include "nolibc.h" 1195bd8c8fbbSWilly Tarreau 1196bd8c8fbbSWilly Tarreau #endif /* _NOLIBC_SYS_H */ 1197