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() */ 2472ffbc67SThomas Weißschuh #include <linux/reboot.h> /* for LINUX_REBOOT_* */ 25208aa9d9SThomas Weißschuh #include <linux/prctl.h> 26bd8c8fbbSWilly Tarreau 27bd8c8fbbSWilly Tarreau #include "arch.h" 2845a794bfSWilly Tarreau #include "errno.h" 29bd8c8fbbSWilly Tarreau #include "types.h" 30bd8c8fbbSWilly Tarreau 31bd8c8fbbSWilly Tarreau 32bd8c8fbbSWilly Tarreau /* Functions in this file only describe syscalls. They're declared static so 33bd8c8fbbSWilly Tarreau * that the compiler usually decides to inline them while still being allowed 34bd8c8fbbSWilly Tarreau * to pass a pointer to one of their instances. Each syscall exists in two 35bd8c8fbbSWilly Tarreau * versions: 36bd8c8fbbSWilly Tarreau * - the "internal" ones, which matches the raw syscall interface at the 37bd8c8fbbSWilly Tarreau * kernel level, which may sometimes slightly differ from the documented 38bd8c8fbbSWilly Tarreau * libc-level ones. For example most of them return either a valid value 39bd8c8fbbSWilly Tarreau * or -errno. All of these are prefixed with "sys_". They may be called 40bd8c8fbbSWilly Tarreau * by non-portable applications if desired. 41bd8c8fbbSWilly Tarreau * 42bd8c8fbbSWilly Tarreau * - the "exported" ones, whose interface must closely match the one 43bd8c8fbbSWilly Tarreau * documented in man(2), that applications are supposed to expect. These 44bd8c8fbbSWilly Tarreau * ones rely on the internal ones, and set errno. 45bd8c8fbbSWilly Tarreau * 46bd8c8fbbSWilly Tarreau * Each syscall will be defined with the two functions, sorted in alphabetical 47bd8c8fbbSWilly Tarreau * order applied to the exported names. 48bd8c8fbbSWilly Tarreau * 49bd8c8fbbSWilly Tarreau * In case of doubt about the relevance of a function here, only those which 50bd8c8fbbSWilly Tarreau * set errno should be defined here. Wrappers like those appearing in man(3) 51bd8c8fbbSWilly Tarreau * should not be placed here. 52bd8c8fbbSWilly Tarreau */ 53bd8c8fbbSWilly Tarreau 54bd8c8fbbSWilly Tarreau 55bd8c8fbbSWilly Tarreau /* 56bd8c8fbbSWilly Tarreau * int brk(void *addr); 57bd8c8fbbSWilly Tarreau * void *sbrk(intptr_t inc) 58bd8c8fbbSWilly Tarreau */ 59bd8c8fbbSWilly Tarreau 60bd8c8fbbSWilly Tarreau static __attribute__((unused)) 61bd8c8fbbSWilly Tarreau void *sys_brk(void *addr) 62bd8c8fbbSWilly Tarreau { 63bd8c8fbbSWilly Tarreau return (void *)my_syscall1(__NR_brk, addr); 64bd8c8fbbSWilly Tarreau } 65bd8c8fbbSWilly Tarreau 66bd8c8fbbSWilly Tarreau static __attribute__((unused)) 67bd8c8fbbSWilly Tarreau int brk(void *addr) 68bd8c8fbbSWilly Tarreau { 69bd8c8fbbSWilly Tarreau void *ret = sys_brk(addr); 70bd8c8fbbSWilly Tarreau 71bd8c8fbbSWilly Tarreau if (!ret) { 72bd8c8fbbSWilly Tarreau SET_ERRNO(ENOMEM); 73bd8c8fbbSWilly Tarreau return -1; 74bd8c8fbbSWilly Tarreau } 75bd8c8fbbSWilly Tarreau return 0; 76bd8c8fbbSWilly Tarreau } 77bd8c8fbbSWilly Tarreau 78bd8c8fbbSWilly Tarreau static __attribute__((unused)) 79bd8c8fbbSWilly Tarreau void *sbrk(intptr_t inc) 80bd8c8fbbSWilly Tarreau { 81bd8c8fbbSWilly Tarreau void *ret; 82bd8c8fbbSWilly Tarreau 83bd8c8fbbSWilly Tarreau /* first call to find current end */ 84bd8c8fbbSWilly Tarreau if ((ret = sys_brk(0)) && (sys_brk(ret + inc) == ret + inc)) 85bd8c8fbbSWilly Tarreau return ret + inc; 86bd8c8fbbSWilly Tarreau 87bd8c8fbbSWilly Tarreau SET_ERRNO(ENOMEM); 88bd8c8fbbSWilly Tarreau return (void *)-1; 89bd8c8fbbSWilly Tarreau } 90bd8c8fbbSWilly Tarreau 91bd8c8fbbSWilly Tarreau 92bd8c8fbbSWilly Tarreau /* 93bd8c8fbbSWilly Tarreau * int chdir(const char *path); 94bd8c8fbbSWilly Tarreau */ 95bd8c8fbbSWilly Tarreau 96bd8c8fbbSWilly Tarreau static __attribute__((unused)) 97bd8c8fbbSWilly Tarreau int sys_chdir(const char *path) 98bd8c8fbbSWilly Tarreau { 99bd8c8fbbSWilly Tarreau return my_syscall1(__NR_chdir, path); 100bd8c8fbbSWilly Tarreau } 101bd8c8fbbSWilly Tarreau 102bd8c8fbbSWilly Tarreau static __attribute__((unused)) 103bd8c8fbbSWilly Tarreau int chdir(const char *path) 104bd8c8fbbSWilly Tarreau { 105bd8c8fbbSWilly Tarreau int ret = sys_chdir(path); 106bd8c8fbbSWilly Tarreau 107bd8c8fbbSWilly Tarreau if (ret < 0) { 108bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 109bd8c8fbbSWilly Tarreau ret = -1; 110bd8c8fbbSWilly Tarreau } 111bd8c8fbbSWilly Tarreau return ret; 112bd8c8fbbSWilly Tarreau } 113bd8c8fbbSWilly Tarreau 114bd8c8fbbSWilly Tarreau 115bd8c8fbbSWilly Tarreau /* 116bd8c8fbbSWilly Tarreau * int chmod(const char *path, mode_t mode); 117bd8c8fbbSWilly Tarreau */ 118bd8c8fbbSWilly Tarreau 119bd8c8fbbSWilly Tarreau static __attribute__((unused)) 120bd8c8fbbSWilly Tarreau int sys_chmod(const char *path, mode_t mode) 121bd8c8fbbSWilly Tarreau { 122bd8c8fbbSWilly Tarreau #ifdef __NR_fchmodat 123bd8c8fbbSWilly Tarreau return my_syscall4(__NR_fchmodat, AT_FDCWD, path, mode, 0); 124bd8c8fbbSWilly Tarreau #elif defined(__NR_chmod) 125bd8c8fbbSWilly Tarreau return my_syscall2(__NR_chmod, path, mode); 126bd8c8fbbSWilly Tarreau #else 127bd8c8fbbSWilly Tarreau #error Neither __NR_fchmodat nor __NR_chmod defined, cannot implement sys_chmod() 128bd8c8fbbSWilly Tarreau #endif 129bd8c8fbbSWilly Tarreau } 130bd8c8fbbSWilly Tarreau 131bd8c8fbbSWilly Tarreau static __attribute__((unused)) 132bd8c8fbbSWilly Tarreau int chmod(const char *path, mode_t mode) 133bd8c8fbbSWilly Tarreau { 134bd8c8fbbSWilly Tarreau int ret = sys_chmod(path, mode); 135bd8c8fbbSWilly Tarreau 136bd8c8fbbSWilly Tarreau if (ret < 0) { 137bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 138bd8c8fbbSWilly Tarreau ret = -1; 139bd8c8fbbSWilly Tarreau } 140bd8c8fbbSWilly Tarreau return ret; 141bd8c8fbbSWilly Tarreau } 142bd8c8fbbSWilly Tarreau 143bd8c8fbbSWilly Tarreau 144bd8c8fbbSWilly Tarreau /* 145bd8c8fbbSWilly Tarreau * int chown(const char *path, uid_t owner, gid_t group); 146bd8c8fbbSWilly Tarreau */ 147bd8c8fbbSWilly Tarreau 148bd8c8fbbSWilly Tarreau static __attribute__((unused)) 149bd8c8fbbSWilly Tarreau int sys_chown(const char *path, uid_t owner, gid_t group) 150bd8c8fbbSWilly Tarreau { 151bd8c8fbbSWilly Tarreau #ifdef __NR_fchownat 152bd8c8fbbSWilly Tarreau return my_syscall5(__NR_fchownat, AT_FDCWD, path, owner, group, 0); 153bd8c8fbbSWilly Tarreau #elif defined(__NR_chown) 154bd8c8fbbSWilly Tarreau return my_syscall3(__NR_chown, path, owner, group); 155bd8c8fbbSWilly Tarreau #else 156bd8c8fbbSWilly Tarreau #error Neither __NR_fchownat nor __NR_chown defined, cannot implement sys_chown() 157bd8c8fbbSWilly Tarreau #endif 158bd8c8fbbSWilly Tarreau } 159bd8c8fbbSWilly Tarreau 160bd8c8fbbSWilly Tarreau static __attribute__((unused)) 161bd8c8fbbSWilly Tarreau int chown(const char *path, uid_t owner, gid_t group) 162bd8c8fbbSWilly Tarreau { 163bd8c8fbbSWilly Tarreau int ret = sys_chown(path, owner, group); 164bd8c8fbbSWilly Tarreau 165bd8c8fbbSWilly Tarreau if (ret < 0) { 166bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 167bd8c8fbbSWilly Tarreau ret = -1; 168bd8c8fbbSWilly Tarreau } 169bd8c8fbbSWilly Tarreau return ret; 170bd8c8fbbSWilly Tarreau } 171bd8c8fbbSWilly Tarreau 172bd8c8fbbSWilly Tarreau 173bd8c8fbbSWilly Tarreau /* 174bd8c8fbbSWilly Tarreau * int chroot(const char *path); 175bd8c8fbbSWilly Tarreau */ 176bd8c8fbbSWilly Tarreau 177bd8c8fbbSWilly Tarreau static __attribute__((unused)) 178bd8c8fbbSWilly Tarreau int sys_chroot(const char *path) 179bd8c8fbbSWilly Tarreau { 180bd8c8fbbSWilly Tarreau return my_syscall1(__NR_chroot, path); 181bd8c8fbbSWilly Tarreau } 182bd8c8fbbSWilly Tarreau 183bd8c8fbbSWilly Tarreau static __attribute__((unused)) 184bd8c8fbbSWilly Tarreau int chroot(const char *path) 185bd8c8fbbSWilly Tarreau { 186bd8c8fbbSWilly Tarreau int ret = sys_chroot(path); 187bd8c8fbbSWilly Tarreau 188bd8c8fbbSWilly Tarreau if (ret < 0) { 189bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 190bd8c8fbbSWilly Tarreau ret = -1; 191bd8c8fbbSWilly Tarreau } 192bd8c8fbbSWilly Tarreau return ret; 193bd8c8fbbSWilly Tarreau } 194bd8c8fbbSWilly Tarreau 195bd8c8fbbSWilly Tarreau 196bd8c8fbbSWilly Tarreau /* 197bd8c8fbbSWilly Tarreau * int close(int fd); 198bd8c8fbbSWilly Tarreau */ 199bd8c8fbbSWilly Tarreau 200bd8c8fbbSWilly Tarreau static __attribute__((unused)) 201bd8c8fbbSWilly Tarreau int sys_close(int fd) 202bd8c8fbbSWilly Tarreau { 203bd8c8fbbSWilly Tarreau return my_syscall1(__NR_close, fd); 204bd8c8fbbSWilly Tarreau } 205bd8c8fbbSWilly Tarreau 206bd8c8fbbSWilly Tarreau static __attribute__((unused)) 207bd8c8fbbSWilly Tarreau int close(int fd) 208bd8c8fbbSWilly Tarreau { 209bd8c8fbbSWilly Tarreau int ret = sys_close(fd); 210bd8c8fbbSWilly Tarreau 211bd8c8fbbSWilly Tarreau if (ret < 0) { 212bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 213bd8c8fbbSWilly Tarreau ret = -1; 214bd8c8fbbSWilly Tarreau } 215bd8c8fbbSWilly Tarreau return ret; 216bd8c8fbbSWilly Tarreau } 217bd8c8fbbSWilly Tarreau 218bd8c8fbbSWilly Tarreau 219bd8c8fbbSWilly Tarreau /* 220bd8c8fbbSWilly Tarreau * int dup(int fd); 221bd8c8fbbSWilly Tarreau */ 222bd8c8fbbSWilly Tarreau 223bd8c8fbbSWilly Tarreau static __attribute__((unused)) 224bd8c8fbbSWilly Tarreau int sys_dup(int fd) 225bd8c8fbbSWilly Tarreau { 226bd8c8fbbSWilly Tarreau return my_syscall1(__NR_dup, fd); 227bd8c8fbbSWilly Tarreau } 228bd8c8fbbSWilly Tarreau 229bd8c8fbbSWilly Tarreau static __attribute__((unused)) 230bd8c8fbbSWilly Tarreau int dup(int fd) 231bd8c8fbbSWilly Tarreau { 232bd8c8fbbSWilly Tarreau int ret = sys_dup(fd); 233bd8c8fbbSWilly Tarreau 234bd8c8fbbSWilly Tarreau if (ret < 0) { 235bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 236bd8c8fbbSWilly Tarreau ret = -1; 237bd8c8fbbSWilly Tarreau } 238bd8c8fbbSWilly Tarreau return ret; 239bd8c8fbbSWilly Tarreau } 240bd8c8fbbSWilly Tarreau 241bd8c8fbbSWilly Tarreau 242bd8c8fbbSWilly Tarreau /* 243bd8c8fbbSWilly Tarreau * int dup2(int old, int new); 244bd8c8fbbSWilly Tarreau */ 245bd8c8fbbSWilly Tarreau 246bd8c8fbbSWilly Tarreau static __attribute__((unused)) 247bd8c8fbbSWilly Tarreau int sys_dup2(int old, int new) 248bd8c8fbbSWilly Tarreau { 249bd8c8fbbSWilly Tarreau #ifdef __NR_dup3 250bd8c8fbbSWilly Tarreau return my_syscall3(__NR_dup3, old, new, 0); 251bd8c8fbbSWilly Tarreau #elif defined(__NR_dup2) 252bd8c8fbbSWilly Tarreau return my_syscall2(__NR_dup2, old, new); 253bd8c8fbbSWilly Tarreau #else 254bd8c8fbbSWilly Tarreau #error Neither __NR_dup3 nor __NR_dup2 defined, cannot implement sys_dup2() 255bd8c8fbbSWilly Tarreau #endif 256bd8c8fbbSWilly Tarreau } 257bd8c8fbbSWilly Tarreau 258bd8c8fbbSWilly Tarreau static __attribute__((unused)) 259bd8c8fbbSWilly Tarreau int dup2(int old, int new) 260bd8c8fbbSWilly Tarreau { 261bd8c8fbbSWilly Tarreau int ret = sys_dup2(old, new); 262bd8c8fbbSWilly Tarreau 263bd8c8fbbSWilly Tarreau if (ret < 0) { 264bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 265bd8c8fbbSWilly Tarreau ret = -1; 266bd8c8fbbSWilly Tarreau } 267bd8c8fbbSWilly Tarreau return ret; 268bd8c8fbbSWilly Tarreau } 269bd8c8fbbSWilly Tarreau 270bd8c8fbbSWilly Tarreau 271bd8c8fbbSWilly Tarreau /* 272bd8c8fbbSWilly Tarreau * int dup3(int old, int new, int flags); 273bd8c8fbbSWilly Tarreau */ 274bd8c8fbbSWilly Tarreau 275bd8c8fbbSWilly Tarreau #ifdef __NR_dup3 276bd8c8fbbSWilly Tarreau static __attribute__((unused)) 277bd8c8fbbSWilly Tarreau int sys_dup3(int old, int new, int flags) 278bd8c8fbbSWilly Tarreau { 279bd8c8fbbSWilly Tarreau return my_syscall3(__NR_dup3, old, new, flags); 280bd8c8fbbSWilly Tarreau } 281bd8c8fbbSWilly Tarreau 282bd8c8fbbSWilly Tarreau static __attribute__((unused)) 283bd8c8fbbSWilly Tarreau int dup3(int old, int new, int flags) 284bd8c8fbbSWilly Tarreau { 285bd8c8fbbSWilly Tarreau int ret = sys_dup3(old, new, flags); 286bd8c8fbbSWilly Tarreau 287bd8c8fbbSWilly Tarreau if (ret < 0) { 288bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 289bd8c8fbbSWilly Tarreau ret = -1; 290bd8c8fbbSWilly Tarreau } 291bd8c8fbbSWilly Tarreau return ret; 292bd8c8fbbSWilly Tarreau } 293bd8c8fbbSWilly Tarreau #endif 294bd8c8fbbSWilly Tarreau 295bd8c8fbbSWilly Tarreau 296bd8c8fbbSWilly Tarreau /* 297bd8c8fbbSWilly Tarreau * int execve(const char *filename, char *const argv[], char *const envp[]); 298bd8c8fbbSWilly Tarreau */ 299bd8c8fbbSWilly Tarreau 300bd8c8fbbSWilly Tarreau static __attribute__((unused)) 301bd8c8fbbSWilly Tarreau int sys_execve(const char *filename, char *const argv[], char *const envp[]) 302bd8c8fbbSWilly Tarreau { 303bd8c8fbbSWilly Tarreau return my_syscall3(__NR_execve, filename, argv, envp); 304bd8c8fbbSWilly Tarreau } 305bd8c8fbbSWilly Tarreau 306bd8c8fbbSWilly Tarreau static __attribute__((unused)) 307bd8c8fbbSWilly Tarreau int execve(const char *filename, char *const argv[], char *const envp[]) 308bd8c8fbbSWilly Tarreau { 309bd8c8fbbSWilly Tarreau int ret = sys_execve(filename, argv, envp); 310bd8c8fbbSWilly Tarreau 311bd8c8fbbSWilly Tarreau if (ret < 0) { 312bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 313bd8c8fbbSWilly Tarreau ret = -1; 314bd8c8fbbSWilly Tarreau } 315bd8c8fbbSWilly Tarreau return ret; 316bd8c8fbbSWilly Tarreau } 317bd8c8fbbSWilly Tarreau 318bd8c8fbbSWilly Tarreau 319bd8c8fbbSWilly Tarreau /* 320bd8c8fbbSWilly Tarreau * void exit(int status); 321bd8c8fbbSWilly Tarreau */ 322bd8c8fbbSWilly Tarreau 323bd8c8fbbSWilly Tarreau static __attribute__((noreturn,unused)) 324bd8c8fbbSWilly Tarreau void sys_exit(int status) 325bd8c8fbbSWilly Tarreau { 326bd8c8fbbSWilly Tarreau my_syscall1(__NR_exit, status & 255); 327fddc8f81SThomas Weißschuh while(1); /* shut the "noreturn" warnings. */ 328bd8c8fbbSWilly Tarreau } 329bd8c8fbbSWilly Tarreau 330bd8c8fbbSWilly Tarreau static __attribute__((noreturn,unused)) 331bd8c8fbbSWilly Tarreau void exit(int status) 332bd8c8fbbSWilly Tarreau { 333bd8c8fbbSWilly Tarreau sys_exit(status); 334bd8c8fbbSWilly Tarreau } 335bd8c8fbbSWilly Tarreau 336bd8c8fbbSWilly Tarreau 337bd8c8fbbSWilly Tarreau /* 338bd8c8fbbSWilly Tarreau * pid_t fork(void); 339bd8c8fbbSWilly Tarreau */ 340bd8c8fbbSWilly Tarreau 341404fa87cSThomas Weißschuh #ifndef sys_fork 342bd8c8fbbSWilly Tarreau static __attribute__((unused)) 343bd8c8fbbSWilly Tarreau pid_t sys_fork(void) 344bd8c8fbbSWilly Tarreau { 345bd8c8fbbSWilly Tarreau #ifdef __NR_clone 346bd8c8fbbSWilly Tarreau /* note: some archs only have clone() and not fork(). Different archs 347bd8c8fbbSWilly Tarreau * have a different API, but most archs have the flags on first arg and 348bd8c8fbbSWilly Tarreau * will not use the rest with no other flag. 349bd8c8fbbSWilly Tarreau */ 350bd8c8fbbSWilly Tarreau return my_syscall5(__NR_clone, SIGCHLD, 0, 0, 0, 0); 351bd8c8fbbSWilly Tarreau #elif defined(__NR_fork) 352bd8c8fbbSWilly Tarreau return my_syscall0(__NR_fork); 353bd8c8fbbSWilly Tarreau #else 354bd8c8fbbSWilly Tarreau #error Neither __NR_clone nor __NR_fork defined, cannot implement sys_fork() 355bd8c8fbbSWilly Tarreau #endif 356bd8c8fbbSWilly Tarreau } 357404fa87cSThomas Weißschuh #endif 358bd8c8fbbSWilly Tarreau 359bd8c8fbbSWilly Tarreau static __attribute__((unused)) 360bd8c8fbbSWilly Tarreau pid_t fork(void) 361bd8c8fbbSWilly Tarreau { 362bd8c8fbbSWilly Tarreau pid_t ret = sys_fork(); 363bd8c8fbbSWilly Tarreau 364bd8c8fbbSWilly Tarreau if (ret < 0) { 365bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 366bd8c8fbbSWilly Tarreau ret = -1; 367bd8c8fbbSWilly Tarreau } 368bd8c8fbbSWilly Tarreau return ret; 369bd8c8fbbSWilly Tarreau } 370bd8c8fbbSWilly Tarreau 371bd8c8fbbSWilly Tarreau 372bd8c8fbbSWilly Tarreau /* 373bd8c8fbbSWilly Tarreau * int fsync(int fd); 374bd8c8fbbSWilly Tarreau */ 375bd8c8fbbSWilly Tarreau 376bd8c8fbbSWilly Tarreau static __attribute__((unused)) 377bd8c8fbbSWilly Tarreau int sys_fsync(int fd) 378bd8c8fbbSWilly Tarreau { 379bd8c8fbbSWilly Tarreau return my_syscall1(__NR_fsync, fd); 380bd8c8fbbSWilly Tarreau } 381bd8c8fbbSWilly Tarreau 382bd8c8fbbSWilly Tarreau static __attribute__((unused)) 383bd8c8fbbSWilly Tarreau int fsync(int fd) 384bd8c8fbbSWilly Tarreau { 385bd8c8fbbSWilly Tarreau int ret = sys_fsync(fd); 386bd8c8fbbSWilly Tarreau 387bd8c8fbbSWilly Tarreau if (ret < 0) { 388bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 389bd8c8fbbSWilly Tarreau ret = -1; 390bd8c8fbbSWilly Tarreau } 391bd8c8fbbSWilly Tarreau return ret; 392bd8c8fbbSWilly Tarreau } 393bd8c8fbbSWilly Tarreau 394bd8c8fbbSWilly Tarreau 395bd8c8fbbSWilly Tarreau /* 396bd8c8fbbSWilly Tarreau * int getdents64(int fd, struct linux_dirent64 *dirp, int count); 397bd8c8fbbSWilly Tarreau */ 398bd8c8fbbSWilly Tarreau 399bd8c8fbbSWilly Tarreau static __attribute__((unused)) 400bd8c8fbbSWilly Tarreau int sys_getdents64(int fd, struct linux_dirent64 *dirp, int count) 401bd8c8fbbSWilly Tarreau { 402bd8c8fbbSWilly Tarreau return my_syscall3(__NR_getdents64, fd, dirp, count); 403bd8c8fbbSWilly Tarreau } 404bd8c8fbbSWilly Tarreau 405bd8c8fbbSWilly Tarreau static __attribute__((unused)) 406bd8c8fbbSWilly Tarreau int getdents64(int fd, struct linux_dirent64 *dirp, int count) 407bd8c8fbbSWilly Tarreau { 408bd8c8fbbSWilly Tarreau int ret = sys_getdents64(fd, dirp, count); 409bd8c8fbbSWilly Tarreau 410bd8c8fbbSWilly Tarreau if (ret < 0) { 411bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 412bd8c8fbbSWilly Tarreau ret = -1; 413bd8c8fbbSWilly Tarreau } 414bd8c8fbbSWilly Tarreau return ret; 415bd8c8fbbSWilly Tarreau } 416bd8c8fbbSWilly Tarreau 417bd8c8fbbSWilly Tarreau 418bd8c8fbbSWilly Tarreau /* 419919d0532SWilly Tarreau * uid_t geteuid(void); 420919d0532SWilly Tarreau */ 421919d0532SWilly Tarreau 422919d0532SWilly Tarreau static __attribute__((unused)) 423919d0532SWilly Tarreau uid_t sys_geteuid(void) 424919d0532SWilly Tarreau { 425919d0532SWilly Tarreau #ifdef __NR_geteuid32 426919d0532SWilly Tarreau return my_syscall0(__NR_geteuid32); 427919d0532SWilly Tarreau #else 428919d0532SWilly Tarreau return my_syscall0(__NR_geteuid); 429919d0532SWilly Tarreau #endif 430919d0532SWilly Tarreau } 431919d0532SWilly Tarreau 432919d0532SWilly Tarreau static __attribute__((unused)) 433919d0532SWilly Tarreau uid_t geteuid(void) 434919d0532SWilly Tarreau { 435919d0532SWilly Tarreau return sys_geteuid(); 436919d0532SWilly Tarreau } 437919d0532SWilly Tarreau 438919d0532SWilly Tarreau 439919d0532SWilly Tarreau /* 440bd8c8fbbSWilly Tarreau * pid_t getpgid(pid_t pid); 441bd8c8fbbSWilly Tarreau */ 442bd8c8fbbSWilly Tarreau 443bd8c8fbbSWilly Tarreau static __attribute__((unused)) 444bd8c8fbbSWilly Tarreau pid_t sys_getpgid(pid_t pid) 445bd8c8fbbSWilly Tarreau { 446bd8c8fbbSWilly Tarreau return my_syscall1(__NR_getpgid, pid); 447bd8c8fbbSWilly Tarreau } 448bd8c8fbbSWilly Tarreau 449bd8c8fbbSWilly Tarreau static __attribute__((unused)) 450bd8c8fbbSWilly Tarreau pid_t getpgid(pid_t pid) 451bd8c8fbbSWilly Tarreau { 452bd8c8fbbSWilly Tarreau pid_t ret = sys_getpgid(pid); 453bd8c8fbbSWilly Tarreau 454bd8c8fbbSWilly Tarreau if (ret < 0) { 455bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 456bd8c8fbbSWilly Tarreau ret = -1; 457bd8c8fbbSWilly Tarreau } 458bd8c8fbbSWilly Tarreau return ret; 459bd8c8fbbSWilly Tarreau } 460bd8c8fbbSWilly Tarreau 461bd8c8fbbSWilly Tarreau 462bd8c8fbbSWilly Tarreau /* 463bd8c8fbbSWilly Tarreau * pid_t getpgrp(void); 464bd8c8fbbSWilly Tarreau */ 465bd8c8fbbSWilly Tarreau 466bd8c8fbbSWilly Tarreau static __attribute__((unused)) 467bd8c8fbbSWilly Tarreau pid_t sys_getpgrp(void) 468bd8c8fbbSWilly Tarreau { 469bd8c8fbbSWilly Tarreau return sys_getpgid(0); 470bd8c8fbbSWilly Tarreau } 471bd8c8fbbSWilly Tarreau 472bd8c8fbbSWilly Tarreau static __attribute__((unused)) 473bd8c8fbbSWilly Tarreau pid_t getpgrp(void) 474bd8c8fbbSWilly Tarreau { 475830acd08SWilly Tarreau return sys_getpgrp(); 476bd8c8fbbSWilly Tarreau } 477bd8c8fbbSWilly Tarreau 478bd8c8fbbSWilly Tarreau 479bd8c8fbbSWilly Tarreau /* 480bd8c8fbbSWilly Tarreau * pid_t getpid(void); 481bd8c8fbbSWilly Tarreau */ 482bd8c8fbbSWilly Tarreau 483bd8c8fbbSWilly Tarreau static __attribute__((unused)) 484bd8c8fbbSWilly Tarreau pid_t sys_getpid(void) 485bd8c8fbbSWilly Tarreau { 486bd8c8fbbSWilly Tarreau return my_syscall0(__NR_getpid); 487bd8c8fbbSWilly Tarreau } 488bd8c8fbbSWilly Tarreau 489bd8c8fbbSWilly Tarreau static __attribute__((unused)) 490bd8c8fbbSWilly Tarreau pid_t getpid(void) 491bd8c8fbbSWilly Tarreau { 492830acd08SWilly Tarreau return sys_getpid(); 493bd8c8fbbSWilly Tarreau } 494bd8c8fbbSWilly Tarreau 495bd8c8fbbSWilly Tarreau 496bd8c8fbbSWilly Tarreau /* 49754abe359SWilly Tarreau * pid_t getppid(void); 49854abe359SWilly Tarreau */ 49954abe359SWilly Tarreau 50054abe359SWilly Tarreau static __attribute__((unused)) 50154abe359SWilly Tarreau pid_t sys_getppid(void) 50254abe359SWilly Tarreau { 50354abe359SWilly Tarreau return my_syscall0(__NR_getppid); 50454abe359SWilly Tarreau } 50554abe359SWilly Tarreau 50654abe359SWilly Tarreau static __attribute__((unused)) 50754abe359SWilly Tarreau pid_t getppid(void) 50854abe359SWilly Tarreau { 50954abe359SWilly Tarreau return sys_getppid(); 51054abe359SWilly Tarreau } 51154abe359SWilly Tarreau 51254abe359SWilly Tarreau 51354abe359SWilly Tarreau /* 514bd8c8fbbSWilly Tarreau * pid_t gettid(void); 515bd8c8fbbSWilly Tarreau */ 516bd8c8fbbSWilly Tarreau 517bd8c8fbbSWilly Tarreau static __attribute__((unused)) 518bd8c8fbbSWilly Tarreau pid_t sys_gettid(void) 519bd8c8fbbSWilly Tarreau { 520bd8c8fbbSWilly Tarreau return my_syscall0(__NR_gettid); 521bd8c8fbbSWilly Tarreau } 522bd8c8fbbSWilly Tarreau 523bd8c8fbbSWilly Tarreau static __attribute__((unused)) 524bd8c8fbbSWilly Tarreau pid_t gettid(void) 525bd8c8fbbSWilly Tarreau { 526830acd08SWilly Tarreau return sys_gettid(); 527bd8c8fbbSWilly Tarreau } 528bd8c8fbbSWilly Tarreau 5297efd762eSAmmar Faizi static unsigned long getauxval(unsigned long key); 5307efd762eSAmmar Faizi 5317efd762eSAmmar Faizi /* 5327efd762eSAmmar Faizi * long getpagesize(void); 5337efd762eSAmmar Faizi */ 5347efd762eSAmmar Faizi 5357efd762eSAmmar Faizi static __attribute__((unused)) 5367efd762eSAmmar Faizi long getpagesize(void) 5377efd762eSAmmar Faizi { 5387efd762eSAmmar Faizi long ret; 5397efd762eSAmmar Faizi 5407efd762eSAmmar Faizi ret = getauxval(AT_PAGESZ); 5417efd762eSAmmar Faizi if (!ret) { 5427efd762eSAmmar Faizi SET_ERRNO(ENOENT); 5437efd762eSAmmar Faizi return -1; 5447efd762eSAmmar Faizi } 5457efd762eSAmmar Faizi 5467efd762eSAmmar Faizi return ret; 5477efd762eSAmmar Faizi } 5487efd762eSAmmar Faizi 549bd8c8fbbSWilly Tarreau 550bd8c8fbbSWilly Tarreau /* 551bd8c8fbbSWilly Tarreau * int gettimeofday(struct timeval *tv, struct timezone *tz); 552bd8c8fbbSWilly Tarreau */ 553bd8c8fbbSWilly Tarreau 554bd8c8fbbSWilly Tarreau static __attribute__((unused)) 555bd8c8fbbSWilly Tarreau int sys_gettimeofday(struct timeval *tv, struct timezone *tz) 556bd8c8fbbSWilly Tarreau { 557bd8c8fbbSWilly Tarreau return my_syscall2(__NR_gettimeofday, tv, tz); 558bd8c8fbbSWilly Tarreau } 559bd8c8fbbSWilly Tarreau 560bd8c8fbbSWilly Tarreau static __attribute__((unused)) 561bd8c8fbbSWilly Tarreau int gettimeofday(struct timeval *tv, struct timezone *tz) 562bd8c8fbbSWilly Tarreau { 563bd8c8fbbSWilly Tarreau int ret = sys_gettimeofday(tv, tz); 564bd8c8fbbSWilly Tarreau 565bd8c8fbbSWilly Tarreau if (ret < 0) { 566bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 567bd8c8fbbSWilly Tarreau ret = -1; 568bd8c8fbbSWilly Tarreau } 569bd8c8fbbSWilly Tarreau return ret; 570bd8c8fbbSWilly Tarreau } 571bd8c8fbbSWilly Tarreau 572bd8c8fbbSWilly Tarreau 573bd8c8fbbSWilly Tarreau /* 574919d0532SWilly Tarreau * uid_t getuid(void); 575919d0532SWilly Tarreau */ 576919d0532SWilly Tarreau 577919d0532SWilly Tarreau static __attribute__((unused)) 578919d0532SWilly Tarreau uid_t sys_getuid(void) 579919d0532SWilly Tarreau { 580919d0532SWilly Tarreau #ifdef __NR_getuid32 581919d0532SWilly Tarreau return my_syscall0(__NR_getuid32); 582919d0532SWilly Tarreau #else 583919d0532SWilly Tarreau return my_syscall0(__NR_getuid); 584919d0532SWilly Tarreau #endif 585919d0532SWilly Tarreau } 586919d0532SWilly Tarreau 587919d0532SWilly Tarreau static __attribute__((unused)) 588919d0532SWilly Tarreau uid_t getuid(void) 589919d0532SWilly Tarreau { 590919d0532SWilly Tarreau return sys_getuid(); 591919d0532SWilly Tarreau } 592919d0532SWilly Tarreau 593919d0532SWilly Tarreau 594919d0532SWilly Tarreau /* 595bd8c8fbbSWilly Tarreau * int ioctl(int fd, unsigned long req, void *value); 596bd8c8fbbSWilly Tarreau */ 597bd8c8fbbSWilly Tarreau 598bd8c8fbbSWilly Tarreau static __attribute__((unused)) 599bd8c8fbbSWilly Tarreau int sys_ioctl(int fd, unsigned long req, void *value) 600bd8c8fbbSWilly Tarreau { 601bd8c8fbbSWilly Tarreau return my_syscall3(__NR_ioctl, fd, req, value); 602bd8c8fbbSWilly Tarreau } 603bd8c8fbbSWilly Tarreau 604bd8c8fbbSWilly Tarreau static __attribute__((unused)) 605bd8c8fbbSWilly Tarreau int ioctl(int fd, unsigned long req, void *value) 606bd8c8fbbSWilly Tarreau { 607bd8c8fbbSWilly Tarreau int ret = sys_ioctl(fd, req, value); 608bd8c8fbbSWilly Tarreau 609bd8c8fbbSWilly Tarreau if (ret < 0) { 610bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 611bd8c8fbbSWilly Tarreau ret = -1; 612bd8c8fbbSWilly Tarreau } 613bd8c8fbbSWilly Tarreau return ret; 614bd8c8fbbSWilly Tarreau } 615bd8c8fbbSWilly Tarreau 616bd8c8fbbSWilly Tarreau /* 617bd8c8fbbSWilly Tarreau * int kill(pid_t pid, int signal); 618bd8c8fbbSWilly Tarreau */ 619bd8c8fbbSWilly Tarreau 620bd8c8fbbSWilly Tarreau static __attribute__((unused)) 621bd8c8fbbSWilly Tarreau int sys_kill(pid_t pid, int signal) 622bd8c8fbbSWilly Tarreau { 623bd8c8fbbSWilly Tarreau return my_syscall2(__NR_kill, pid, signal); 624bd8c8fbbSWilly Tarreau } 625bd8c8fbbSWilly Tarreau 626bd8c8fbbSWilly Tarreau static __attribute__((unused)) 627bd8c8fbbSWilly Tarreau int kill(pid_t pid, int signal) 628bd8c8fbbSWilly Tarreau { 629bd8c8fbbSWilly Tarreau int ret = sys_kill(pid, signal); 630bd8c8fbbSWilly Tarreau 631bd8c8fbbSWilly Tarreau if (ret < 0) { 632bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 633bd8c8fbbSWilly Tarreau ret = -1; 634bd8c8fbbSWilly Tarreau } 635bd8c8fbbSWilly Tarreau return ret; 636bd8c8fbbSWilly Tarreau } 637bd8c8fbbSWilly Tarreau 638bd8c8fbbSWilly Tarreau 639bd8c8fbbSWilly Tarreau /* 640bd8c8fbbSWilly Tarreau * int link(const char *old, const char *new); 641bd8c8fbbSWilly Tarreau */ 642bd8c8fbbSWilly Tarreau 643bd8c8fbbSWilly Tarreau static __attribute__((unused)) 644bd8c8fbbSWilly Tarreau int sys_link(const char *old, const char *new) 645bd8c8fbbSWilly Tarreau { 646bd8c8fbbSWilly Tarreau #ifdef __NR_linkat 647bd8c8fbbSWilly Tarreau return my_syscall5(__NR_linkat, AT_FDCWD, old, AT_FDCWD, new, 0); 648bd8c8fbbSWilly Tarreau #elif defined(__NR_link) 649bd8c8fbbSWilly Tarreau return my_syscall2(__NR_link, old, new); 650bd8c8fbbSWilly Tarreau #else 651bd8c8fbbSWilly Tarreau #error Neither __NR_linkat nor __NR_link defined, cannot implement sys_link() 652bd8c8fbbSWilly Tarreau #endif 653bd8c8fbbSWilly Tarreau } 654bd8c8fbbSWilly Tarreau 655bd8c8fbbSWilly Tarreau static __attribute__((unused)) 656bd8c8fbbSWilly Tarreau int link(const char *old, const char *new) 657bd8c8fbbSWilly Tarreau { 658bd8c8fbbSWilly Tarreau int ret = sys_link(old, new); 659bd8c8fbbSWilly Tarreau 660bd8c8fbbSWilly Tarreau if (ret < 0) { 661bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 662bd8c8fbbSWilly Tarreau ret = -1; 663bd8c8fbbSWilly Tarreau } 664bd8c8fbbSWilly Tarreau return ret; 665bd8c8fbbSWilly Tarreau } 666bd8c8fbbSWilly Tarreau 667bd8c8fbbSWilly Tarreau 668bd8c8fbbSWilly Tarreau /* 669bd8c8fbbSWilly Tarreau * off_t lseek(int fd, off_t offset, int whence); 670bd8c8fbbSWilly Tarreau */ 671bd8c8fbbSWilly Tarreau 672bd8c8fbbSWilly Tarreau static __attribute__((unused)) 673bd8c8fbbSWilly Tarreau off_t sys_lseek(int fd, off_t offset, int whence) 674bd8c8fbbSWilly Tarreau { 675bd8c8fbbSWilly Tarreau return my_syscall3(__NR_lseek, fd, offset, whence); 676bd8c8fbbSWilly Tarreau } 677bd8c8fbbSWilly Tarreau 678bd8c8fbbSWilly Tarreau static __attribute__((unused)) 679bd8c8fbbSWilly Tarreau off_t lseek(int fd, off_t offset, int whence) 680bd8c8fbbSWilly Tarreau { 681bd8c8fbbSWilly Tarreau off_t ret = sys_lseek(fd, offset, whence); 682bd8c8fbbSWilly Tarreau 683bd8c8fbbSWilly Tarreau if (ret < 0) { 684bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 685bd8c8fbbSWilly Tarreau ret = -1; 686bd8c8fbbSWilly Tarreau } 687bd8c8fbbSWilly Tarreau return ret; 688bd8c8fbbSWilly Tarreau } 689bd8c8fbbSWilly Tarreau 690bd8c8fbbSWilly Tarreau 691bd8c8fbbSWilly Tarreau /* 692bd8c8fbbSWilly Tarreau * int mkdir(const char *path, mode_t mode); 693bd8c8fbbSWilly Tarreau */ 694bd8c8fbbSWilly Tarreau 695bd8c8fbbSWilly Tarreau static __attribute__((unused)) 696bd8c8fbbSWilly Tarreau int sys_mkdir(const char *path, mode_t mode) 697bd8c8fbbSWilly Tarreau { 698bd8c8fbbSWilly Tarreau #ifdef __NR_mkdirat 699bd8c8fbbSWilly Tarreau return my_syscall3(__NR_mkdirat, AT_FDCWD, path, mode); 700bd8c8fbbSWilly Tarreau #elif defined(__NR_mkdir) 701bd8c8fbbSWilly Tarreau return my_syscall2(__NR_mkdir, path, mode); 702bd8c8fbbSWilly Tarreau #else 703bd8c8fbbSWilly Tarreau #error Neither __NR_mkdirat nor __NR_mkdir defined, cannot implement sys_mkdir() 704bd8c8fbbSWilly Tarreau #endif 705bd8c8fbbSWilly Tarreau } 706bd8c8fbbSWilly Tarreau 707bd8c8fbbSWilly Tarreau static __attribute__((unused)) 708bd8c8fbbSWilly Tarreau int mkdir(const char *path, mode_t mode) 709bd8c8fbbSWilly Tarreau { 710bd8c8fbbSWilly Tarreau int ret = sys_mkdir(path, mode); 711bd8c8fbbSWilly Tarreau 712bd8c8fbbSWilly Tarreau if (ret < 0) { 713bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 714bd8c8fbbSWilly Tarreau ret = -1; 715bd8c8fbbSWilly Tarreau } 716bd8c8fbbSWilly Tarreau return ret; 717bd8c8fbbSWilly Tarreau } 718bd8c8fbbSWilly Tarreau 719bd8c8fbbSWilly Tarreau 720bd8c8fbbSWilly Tarreau /* 721bd8c8fbbSWilly Tarreau * int mknod(const char *path, mode_t mode, dev_t dev); 722bd8c8fbbSWilly Tarreau */ 723bd8c8fbbSWilly Tarreau 724bd8c8fbbSWilly Tarreau static __attribute__((unused)) 725bd8c8fbbSWilly Tarreau long sys_mknod(const char *path, mode_t mode, dev_t dev) 726bd8c8fbbSWilly Tarreau { 727bd8c8fbbSWilly Tarreau #ifdef __NR_mknodat 728bd8c8fbbSWilly Tarreau return my_syscall4(__NR_mknodat, AT_FDCWD, path, mode, dev); 729bd8c8fbbSWilly Tarreau #elif defined(__NR_mknod) 730bd8c8fbbSWilly Tarreau return my_syscall3(__NR_mknod, path, mode, dev); 731bd8c8fbbSWilly Tarreau #else 732bd8c8fbbSWilly Tarreau #error Neither __NR_mknodat nor __NR_mknod defined, cannot implement sys_mknod() 733bd8c8fbbSWilly Tarreau #endif 734bd8c8fbbSWilly Tarreau } 735bd8c8fbbSWilly Tarreau 736bd8c8fbbSWilly Tarreau static __attribute__((unused)) 737bd8c8fbbSWilly Tarreau int mknod(const char *path, mode_t mode, dev_t dev) 738bd8c8fbbSWilly Tarreau { 739bd8c8fbbSWilly Tarreau int ret = sys_mknod(path, mode, dev); 740bd8c8fbbSWilly Tarreau 741bd8c8fbbSWilly Tarreau if (ret < 0) { 742bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 743bd8c8fbbSWilly Tarreau ret = -1; 744bd8c8fbbSWilly Tarreau } 745bd8c8fbbSWilly Tarreau return ret; 746bd8c8fbbSWilly Tarreau } 747bd8c8fbbSWilly Tarreau 748544fa1a2SAmmar Faizi #ifndef MAP_SHARED 749544fa1a2SAmmar Faizi #define MAP_SHARED 0x01 /* Share changes */ 750544fa1a2SAmmar Faizi #define MAP_PRIVATE 0x02 /* Changes are private */ 751544fa1a2SAmmar Faizi #define MAP_SHARED_VALIDATE 0x03 /* share + validate extension flags */ 752544fa1a2SAmmar Faizi #endif 753544fa1a2SAmmar Faizi 754544fa1a2SAmmar Faizi #ifndef MAP_FAILED 755544fa1a2SAmmar Faizi #define MAP_FAILED ((void *)-1) 756544fa1a2SAmmar Faizi #endif 757544fa1a2SAmmar Faizi 75818a5a09dSSven Schnelle #ifndef sys_mmap 759544fa1a2SAmmar Faizi static __attribute__((unused)) 760544fa1a2SAmmar Faizi void *sys_mmap(void *addr, size_t length, int prot, int flags, int fd, 761544fa1a2SAmmar Faizi off_t offset) 762544fa1a2SAmmar Faizi { 763544fa1a2SAmmar Faizi #ifndef my_syscall6 764544fa1a2SAmmar Faizi /* Function not implemented. */ 7658b53e83bSWilly Tarreau return (void *)-ENOSYS; 766544fa1a2SAmmar Faizi #else 767544fa1a2SAmmar Faizi 768544fa1a2SAmmar Faizi int n; 769544fa1a2SAmmar Faizi 770364702f7SWilly Tarreau #if defined(__NR_mmap2) 771544fa1a2SAmmar Faizi n = __NR_mmap2; 772544fa1a2SAmmar Faizi offset >>= 12; 773544fa1a2SAmmar Faizi #else 774544fa1a2SAmmar Faizi n = __NR_mmap; 775544fa1a2SAmmar Faizi #endif 776544fa1a2SAmmar Faizi 777544fa1a2SAmmar Faizi return (void *)my_syscall6(n, addr, length, prot, flags, fd, offset); 778544fa1a2SAmmar Faizi #endif 779544fa1a2SAmmar Faizi } 78018a5a09dSSven Schnelle #endif 781544fa1a2SAmmar Faizi 782544fa1a2SAmmar Faizi static __attribute__((unused)) 783544fa1a2SAmmar Faizi void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset) 784544fa1a2SAmmar Faizi { 785544fa1a2SAmmar Faizi void *ret = sys_mmap(addr, length, prot, flags, fd, offset); 786544fa1a2SAmmar Faizi 787544fa1a2SAmmar Faizi if ((unsigned long)ret >= -4095UL) { 788544fa1a2SAmmar Faizi SET_ERRNO(-(long)ret); 789544fa1a2SAmmar Faizi ret = MAP_FAILED; 790544fa1a2SAmmar Faizi } 791544fa1a2SAmmar Faizi return ret; 792544fa1a2SAmmar Faizi } 793544fa1a2SAmmar Faizi 794544fa1a2SAmmar Faizi static __attribute__((unused)) 795544fa1a2SAmmar Faizi int sys_munmap(void *addr, size_t length) 796544fa1a2SAmmar Faizi { 797544fa1a2SAmmar Faizi return my_syscall2(__NR_munmap, addr, length); 798544fa1a2SAmmar Faizi } 799544fa1a2SAmmar Faizi 800544fa1a2SAmmar Faizi static __attribute__((unused)) 801544fa1a2SAmmar Faizi int munmap(void *addr, size_t length) 802544fa1a2SAmmar Faizi { 803544fa1a2SAmmar Faizi int ret = sys_munmap(addr, length); 804544fa1a2SAmmar Faizi 805544fa1a2SAmmar Faizi if (ret < 0) { 806544fa1a2SAmmar Faizi SET_ERRNO(-ret); 807544fa1a2SAmmar Faizi ret = -1; 808544fa1a2SAmmar Faizi } 809544fa1a2SAmmar Faizi return ret; 810544fa1a2SAmmar Faizi } 811bd8c8fbbSWilly Tarreau 812bd8c8fbbSWilly Tarreau /* 813bd8c8fbbSWilly Tarreau * int mount(const char *source, const char *target, 814bd8c8fbbSWilly Tarreau * const char *fstype, unsigned long flags, 815bd8c8fbbSWilly Tarreau * const void *data); 816bd8c8fbbSWilly Tarreau */ 817bd8c8fbbSWilly Tarreau static __attribute__((unused)) 818bd8c8fbbSWilly Tarreau int sys_mount(const char *src, const char *tgt, const char *fst, 819bd8c8fbbSWilly Tarreau unsigned long flags, const void *data) 820bd8c8fbbSWilly Tarreau { 821bd8c8fbbSWilly Tarreau return my_syscall5(__NR_mount, src, tgt, fst, flags, data); 822bd8c8fbbSWilly Tarreau } 823bd8c8fbbSWilly Tarreau 824bd8c8fbbSWilly Tarreau static __attribute__((unused)) 825bd8c8fbbSWilly Tarreau int mount(const char *src, const char *tgt, 826bd8c8fbbSWilly Tarreau const char *fst, unsigned long flags, 827bd8c8fbbSWilly Tarreau const void *data) 828bd8c8fbbSWilly Tarreau { 829bd8c8fbbSWilly Tarreau int ret = sys_mount(src, tgt, fst, flags, data); 830bd8c8fbbSWilly Tarreau 831bd8c8fbbSWilly Tarreau if (ret < 0) { 832bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 833bd8c8fbbSWilly Tarreau ret = -1; 834bd8c8fbbSWilly Tarreau } 835bd8c8fbbSWilly Tarreau return ret; 836bd8c8fbbSWilly Tarreau } 837bd8c8fbbSWilly Tarreau 838bd8c8fbbSWilly Tarreau 839bd8c8fbbSWilly Tarreau /* 840a7604ba1SWilly Tarreau * int open(const char *path, int flags[, mode_t mode]); 841bd8c8fbbSWilly Tarreau */ 842bd8c8fbbSWilly Tarreau 843bd8c8fbbSWilly Tarreau static __attribute__((unused)) 844bd8c8fbbSWilly Tarreau int sys_open(const char *path, int flags, mode_t mode) 845bd8c8fbbSWilly Tarreau { 846bd8c8fbbSWilly Tarreau #ifdef __NR_openat 847bd8c8fbbSWilly Tarreau return my_syscall4(__NR_openat, AT_FDCWD, path, flags, mode); 848bd8c8fbbSWilly Tarreau #elif defined(__NR_open) 849bd8c8fbbSWilly Tarreau return my_syscall3(__NR_open, path, flags, mode); 850bd8c8fbbSWilly Tarreau #else 851bd8c8fbbSWilly Tarreau #error Neither __NR_openat nor __NR_open defined, cannot implement sys_open() 852bd8c8fbbSWilly Tarreau #endif 853bd8c8fbbSWilly Tarreau } 854bd8c8fbbSWilly Tarreau 855bd8c8fbbSWilly Tarreau static __attribute__((unused)) 856a7604ba1SWilly Tarreau int open(const char *path, int flags, ...) 857bd8c8fbbSWilly Tarreau { 858a7604ba1SWilly Tarreau mode_t mode = 0; 859a7604ba1SWilly Tarreau int ret; 860a7604ba1SWilly Tarreau 861a7604ba1SWilly Tarreau if (flags & O_CREAT) { 862a7604ba1SWilly Tarreau va_list args; 863a7604ba1SWilly Tarreau 864a7604ba1SWilly Tarreau va_start(args, flags); 865a7604ba1SWilly Tarreau mode = va_arg(args, mode_t); 866a7604ba1SWilly Tarreau va_end(args); 867a7604ba1SWilly Tarreau } 868a7604ba1SWilly Tarreau 869a7604ba1SWilly Tarreau ret = sys_open(path, flags, mode); 870bd8c8fbbSWilly Tarreau 871bd8c8fbbSWilly Tarreau if (ret < 0) { 872bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 873bd8c8fbbSWilly Tarreau ret = -1; 874bd8c8fbbSWilly Tarreau } 875bd8c8fbbSWilly Tarreau return ret; 876bd8c8fbbSWilly Tarreau } 877bd8c8fbbSWilly Tarreau 878bd8c8fbbSWilly Tarreau 879bd8c8fbbSWilly Tarreau /* 880208aa9d9SThomas Weißschuh * int prctl(int option, unsigned long arg2, unsigned long arg3, 881208aa9d9SThomas Weißschuh * unsigned long arg4, unsigned long arg5); 882208aa9d9SThomas Weißschuh */ 883208aa9d9SThomas Weißschuh 884208aa9d9SThomas Weißschuh static __attribute__((unused)) 885208aa9d9SThomas Weißschuh int sys_prctl(int option, unsigned long arg2, unsigned long arg3, 886208aa9d9SThomas Weißschuh unsigned long arg4, unsigned long arg5) 887208aa9d9SThomas Weißschuh { 888208aa9d9SThomas Weißschuh return my_syscall5(__NR_prctl, option, arg2, arg3, arg4, arg5); 889208aa9d9SThomas Weißschuh } 890208aa9d9SThomas Weißschuh 891208aa9d9SThomas Weißschuh static __attribute__((unused)) 892208aa9d9SThomas Weißschuh int prctl(int option, unsigned long arg2, unsigned long arg3, 893208aa9d9SThomas Weißschuh unsigned long arg4, unsigned long arg5) 894208aa9d9SThomas Weißschuh { 895208aa9d9SThomas Weißschuh int ret = sys_prctl(option, arg2, arg3, arg4, arg5); 896208aa9d9SThomas Weißschuh 897208aa9d9SThomas Weißschuh if (ret < 0) { 898208aa9d9SThomas Weißschuh SET_ERRNO(-ret); 899208aa9d9SThomas Weißschuh ret = -1; 900208aa9d9SThomas Weißschuh } 901208aa9d9SThomas Weißschuh return ret; 902208aa9d9SThomas Weißschuh } 903208aa9d9SThomas Weißschuh 904208aa9d9SThomas Weißschuh 905208aa9d9SThomas Weißschuh /* 906bd8c8fbbSWilly Tarreau * int pivot_root(const char *new, const char *old); 907bd8c8fbbSWilly Tarreau */ 908bd8c8fbbSWilly Tarreau 909bd8c8fbbSWilly Tarreau static __attribute__((unused)) 910bd8c8fbbSWilly Tarreau int sys_pivot_root(const char *new, const char *old) 911bd8c8fbbSWilly Tarreau { 912bd8c8fbbSWilly Tarreau return my_syscall2(__NR_pivot_root, new, old); 913bd8c8fbbSWilly Tarreau } 914bd8c8fbbSWilly Tarreau 915bd8c8fbbSWilly Tarreau static __attribute__((unused)) 916bd8c8fbbSWilly Tarreau int pivot_root(const char *new, const char *old) 917bd8c8fbbSWilly Tarreau { 918bd8c8fbbSWilly Tarreau int ret = sys_pivot_root(new, old); 919bd8c8fbbSWilly Tarreau 920bd8c8fbbSWilly Tarreau if (ret < 0) { 921bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 922bd8c8fbbSWilly Tarreau ret = -1; 923bd8c8fbbSWilly Tarreau } 924bd8c8fbbSWilly Tarreau return ret; 925bd8c8fbbSWilly Tarreau } 926bd8c8fbbSWilly Tarreau 927bd8c8fbbSWilly Tarreau 928bd8c8fbbSWilly Tarreau /* 929bd8c8fbbSWilly Tarreau * int poll(struct pollfd *fds, int nfds, int timeout); 930bd8c8fbbSWilly Tarreau */ 931bd8c8fbbSWilly Tarreau 932bd8c8fbbSWilly Tarreau static __attribute__((unused)) 933bd8c8fbbSWilly Tarreau int sys_poll(struct pollfd *fds, int nfds, int timeout) 934bd8c8fbbSWilly Tarreau { 935bd8c8fbbSWilly Tarreau #if defined(__NR_ppoll) 936bd8c8fbbSWilly Tarreau struct timespec t; 937bd8c8fbbSWilly Tarreau 938bd8c8fbbSWilly Tarreau if (timeout >= 0) { 939bd8c8fbbSWilly Tarreau t.tv_sec = timeout / 1000; 940bd8c8fbbSWilly Tarreau t.tv_nsec = (timeout % 1000) * 1000000; 941bd8c8fbbSWilly Tarreau } 942*0dd2fdbfSZhangjin Wu return my_syscall5(__NR_ppoll, fds, nfds, (timeout >= 0) ? &t : NULL, NULL, 0); 943bd8c8fbbSWilly Tarreau #elif defined(__NR_poll) 944bd8c8fbbSWilly Tarreau return my_syscall3(__NR_poll, fds, nfds, timeout); 945bd8c8fbbSWilly Tarreau #else 946bd8c8fbbSWilly Tarreau #error Neither __NR_ppoll nor __NR_poll defined, cannot implement sys_poll() 947bd8c8fbbSWilly Tarreau #endif 948bd8c8fbbSWilly Tarreau } 949bd8c8fbbSWilly Tarreau 950bd8c8fbbSWilly Tarreau static __attribute__((unused)) 951bd8c8fbbSWilly Tarreau int poll(struct pollfd *fds, int nfds, int timeout) 952bd8c8fbbSWilly Tarreau { 953bd8c8fbbSWilly Tarreau int ret = sys_poll(fds, nfds, timeout); 954bd8c8fbbSWilly Tarreau 955bd8c8fbbSWilly Tarreau if (ret < 0) { 956bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 957bd8c8fbbSWilly Tarreau ret = -1; 958bd8c8fbbSWilly Tarreau } 959bd8c8fbbSWilly Tarreau return ret; 960bd8c8fbbSWilly Tarreau } 961bd8c8fbbSWilly Tarreau 962bd8c8fbbSWilly Tarreau 963bd8c8fbbSWilly Tarreau /* 964bd8c8fbbSWilly Tarreau * ssize_t read(int fd, void *buf, size_t count); 965bd8c8fbbSWilly Tarreau */ 966bd8c8fbbSWilly Tarreau 967bd8c8fbbSWilly Tarreau static __attribute__((unused)) 968bd8c8fbbSWilly Tarreau ssize_t sys_read(int fd, void *buf, size_t count) 969bd8c8fbbSWilly Tarreau { 970bd8c8fbbSWilly Tarreau return my_syscall3(__NR_read, fd, buf, count); 971bd8c8fbbSWilly Tarreau } 972bd8c8fbbSWilly Tarreau 973bd8c8fbbSWilly Tarreau static __attribute__((unused)) 974bd8c8fbbSWilly Tarreau ssize_t read(int fd, void *buf, size_t count) 975bd8c8fbbSWilly Tarreau { 976bd8c8fbbSWilly Tarreau ssize_t ret = sys_read(fd, buf, count); 977bd8c8fbbSWilly Tarreau 978bd8c8fbbSWilly Tarreau if (ret < 0) { 979bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 980bd8c8fbbSWilly Tarreau ret = -1; 981bd8c8fbbSWilly Tarreau } 982bd8c8fbbSWilly Tarreau return ret; 983bd8c8fbbSWilly Tarreau } 984bd8c8fbbSWilly Tarreau 985bd8c8fbbSWilly Tarreau 986bd8c8fbbSWilly Tarreau /* 987bd8c8fbbSWilly Tarreau * int reboot(int cmd); 988bd8c8fbbSWilly Tarreau * <cmd> is among LINUX_REBOOT_CMD_* 989bd8c8fbbSWilly Tarreau */ 990bd8c8fbbSWilly Tarreau 991bd8c8fbbSWilly Tarreau static __attribute__((unused)) 992bd8c8fbbSWilly Tarreau ssize_t sys_reboot(int magic1, int magic2, int cmd, void *arg) 993bd8c8fbbSWilly Tarreau { 994bd8c8fbbSWilly Tarreau return my_syscall4(__NR_reboot, magic1, magic2, cmd, arg); 995bd8c8fbbSWilly Tarreau } 996bd8c8fbbSWilly Tarreau 997bd8c8fbbSWilly Tarreau static __attribute__((unused)) 998bd8c8fbbSWilly Tarreau int reboot(int cmd) 999bd8c8fbbSWilly Tarreau { 1000bd8c8fbbSWilly Tarreau int ret = sys_reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, 0); 1001bd8c8fbbSWilly Tarreau 1002bd8c8fbbSWilly Tarreau if (ret < 0) { 1003bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1004bd8c8fbbSWilly Tarreau ret = -1; 1005bd8c8fbbSWilly Tarreau } 1006bd8c8fbbSWilly Tarreau return ret; 1007bd8c8fbbSWilly Tarreau } 1008bd8c8fbbSWilly Tarreau 1009bd8c8fbbSWilly Tarreau 1010bd8c8fbbSWilly Tarreau /* 1011bd8c8fbbSWilly Tarreau * int sched_yield(void); 1012bd8c8fbbSWilly Tarreau */ 1013bd8c8fbbSWilly Tarreau 1014bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1015bd8c8fbbSWilly Tarreau int sys_sched_yield(void) 1016bd8c8fbbSWilly Tarreau { 1017bd8c8fbbSWilly Tarreau return my_syscall0(__NR_sched_yield); 1018bd8c8fbbSWilly Tarreau } 1019bd8c8fbbSWilly Tarreau 1020bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1021bd8c8fbbSWilly Tarreau int sched_yield(void) 1022bd8c8fbbSWilly Tarreau { 1023bd8c8fbbSWilly Tarreau int ret = sys_sched_yield(); 1024bd8c8fbbSWilly Tarreau 1025bd8c8fbbSWilly Tarreau if (ret < 0) { 1026bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1027bd8c8fbbSWilly Tarreau ret = -1; 1028bd8c8fbbSWilly Tarreau } 1029bd8c8fbbSWilly Tarreau return ret; 1030bd8c8fbbSWilly Tarreau } 1031bd8c8fbbSWilly Tarreau 1032bd8c8fbbSWilly Tarreau 1033bd8c8fbbSWilly Tarreau /* 1034bd8c8fbbSWilly Tarreau * int select(int nfds, fd_set *read_fds, fd_set *write_fds, 1035bd8c8fbbSWilly Tarreau * fd_set *except_fds, struct timeval *timeout); 1036bd8c8fbbSWilly Tarreau */ 1037bd8c8fbbSWilly Tarreau 1038bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1039bd8c8fbbSWilly Tarreau int sys_select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout) 1040bd8c8fbbSWilly Tarreau { 1041bd8c8fbbSWilly Tarreau #if defined(__ARCH_WANT_SYS_OLD_SELECT) && !defined(__NR__newselect) 1042bd8c8fbbSWilly Tarreau struct sel_arg_struct { 1043bd8c8fbbSWilly Tarreau unsigned long n; 1044bd8c8fbbSWilly Tarreau fd_set *r, *w, *e; 1045bd8c8fbbSWilly Tarreau struct timeval *t; 1046bd8c8fbbSWilly Tarreau } arg = { .n = nfds, .r = rfds, .w = wfds, .e = efds, .t = timeout }; 1047bd8c8fbbSWilly Tarreau return my_syscall1(__NR_select, &arg); 1048bd8c8fbbSWilly Tarreau #elif defined(__ARCH_WANT_SYS_PSELECT6) && defined(__NR_pselect6) 1049bd8c8fbbSWilly Tarreau struct timespec t; 1050bd8c8fbbSWilly Tarreau 1051bd8c8fbbSWilly Tarreau if (timeout) { 1052bd8c8fbbSWilly Tarreau t.tv_sec = timeout->tv_sec; 1053bd8c8fbbSWilly Tarreau t.tv_nsec = timeout->tv_usec * 1000; 1054bd8c8fbbSWilly Tarreau } 1055bd8c8fbbSWilly Tarreau return my_syscall6(__NR_pselect6, nfds, rfds, wfds, efds, timeout ? &t : NULL, NULL); 1056bd8c8fbbSWilly Tarreau #elif defined(__NR__newselect) || defined(__NR_select) 1057bd8c8fbbSWilly Tarreau #ifndef __NR__newselect 1058bd8c8fbbSWilly Tarreau #define __NR__newselect __NR_select 1059bd8c8fbbSWilly Tarreau #endif 1060bd8c8fbbSWilly Tarreau return my_syscall5(__NR__newselect, nfds, rfds, wfds, efds, timeout); 1061bd8c8fbbSWilly Tarreau #else 1062bd8c8fbbSWilly Tarreau #error None of __NR_select, __NR_pselect6, nor __NR__newselect defined, cannot implement sys_select() 1063bd8c8fbbSWilly Tarreau #endif 1064bd8c8fbbSWilly Tarreau } 1065bd8c8fbbSWilly Tarreau 1066bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1067bd8c8fbbSWilly Tarreau int select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout) 1068bd8c8fbbSWilly Tarreau { 1069bd8c8fbbSWilly Tarreau int ret = sys_select(nfds, rfds, wfds, efds, timeout); 1070bd8c8fbbSWilly Tarreau 1071bd8c8fbbSWilly Tarreau if (ret < 0) { 1072bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1073bd8c8fbbSWilly Tarreau ret = -1; 1074bd8c8fbbSWilly Tarreau } 1075bd8c8fbbSWilly Tarreau return ret; 1076bd8c8fbbSWilly Tarreau } 1077bd8c8fbbSWilly Tarreau 1078bd8c8fbbSWilly Tarreau 1079bd8c8fbbSWilly Tarreau /* 1080bd8c8fbbSWilly Tarreau * int setpgid(pid_t pid, pid_t pgid); 1081bd8c8fbbSWilly Tarreau */ 1082bd8c8fbbSWilly Tarreau 1083bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1084bd8c8fbbSWilly Tarreau int sys_setpgid(pid_t pid, pid_t pgid) 1085bd8c8fbbSWilly Tarreau { 1086bd8c8fbbSWilly Tarreau return my_syscall2(__NR_setpgid, pid, pgid); 1087bd8c8fbbSWilly Tarreau } 1088bd8c8fbbSWilly Tarreau 1089bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1090bd8c8fbbSWilly Tarreau int setpgid(pid_t pid, pid_t pgid) 1091bd8c8fbbSWilly Tarreau { 1092bd8c8fbbSWilly Tarreau int ret = sys_setpgid(pid, pgid); 1093bd8c8fbbSWilly Tarreau 1094bd8c8fbbSWilly Tarreau if (ret < 0) { 1095bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1096bd8c8fbbSWilly Tarreau ret = -1; 1097bd8c8fbbSWilly Tarreau } 1098bd8c8fbbSWilly Tarreau return ret; 1099bd8c8fbbSWilly Tarreau } 1100bd8c8fbbSWilly Tarreau 1101bd8c8fbbSWilly Tarreau 1102bd8c8fbbSWilly Tarreau /* 1103bd8c8fbbSWilly Tarreau * pid_t setsid(void); 1104bd8c8fbbSWilly Tarreau */ 1105bd8c8fbbSWilly Tarreau 1106bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1107bd8c8fbbSWilly Tarreau pid_t sys_setsid(void) 1108bd8c8fbbSWilly Tarreau { 1109bd8c8fbbSWilly Tarreau return my_syscall0(__NR_setsid); 1110bd8c8fbbSWilly Tarreau } 1111bd8c8fbbSWilly Tarreau 1112bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1113bd8c8fbbSWilly Tarreau pid_t setsid(void) 1114bd8c8fbbSWilly Tarreau { 1115bd8c8fbbSWilly Tarreau pid_t ret = sys_setsid(); 1116bd8c8fbbSWilly Tarreau 1117bd8c8fbbSWilly Tarreau if (ret < 0) { 1118bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1119bd8c8fbbSWilly Tarreau ret = -1; 1120bd8c8fbbSWilly Tarreau } 1121bd8c8fbbSWilly Tarreau return ret; 1122bd8c8fbbSWilly Tarreau } 1123bd8c8fbbSWilly Tarreau 1124b551cb7dSFeiyang Chen #if defined(__NR_statx) 1125b551cb7dSFeiyang Chen /* 1126b551cb7dSFeiyang Chen * int statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf); 1127b551cb7dSFeiyang Chen */ 1128b551cb7dSFeiyang Chen 1129b551cb7dSFeiyang Chen static __attribute__((unused)) 1130b551cb7dSFeiyang Chen int sys_statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf) 1131b551cb7dSFeiyang Chen { 1132b551cb7dSFeiyang Chen return my_syscall5(__NR_statx, fd, path, flags, mask, buf); 1133b551cb7dSFeiyang Chen } 1134b551cb7dSFeiyang Chen 1135b551cb7dSFeiyang Chen static __attribute__((unused)) 1136b551cb7dSFeiyang Chen int statx(int fd, const char *path, int flags, unsigned int mask, struct statx *buf) 1137b551cb7dSFeiyang Chen { 1138b551cb7dSFeiyang Chen int ret = sys_statx(fd, path, flags, mask, buf); 1139b551cb7dSFeiyang Chen 1140b551cb7dSFeiyang Chen if (ret < 0) { 1141b551cb7dSFeiyang Chen SET_ERRNO(-ret); 1142b551cb7dSFeiyang Chen ret = -1; 1143b551cb7dSFeiyang Chen } 1144b551cb7dSFeiyang Chen return ret; 1145b551cb7dSFeiyang Chen } 1146b551cb7dSFeiyang Chen #endif 1147bd8c8fbbSWilly Tarreau 1148bd8c8fbbSWilly Tarreau /* 1149bd8c8fbbSWilly Tarreau * int stat(const char *path, struct stat *buf); 1150bd8c8fbbSWilly Tarreau * Warning: the struct stat's layout is arch-dependent. 1151bd8c8fbbSWilly Tarreau */ 1152bd8c8fbbSWilly Tarreau 1153b551cb7dSFeiyang Chen #if defined(__NR_statx) && !defined(__NR_newfstatat) && !defined(__NR_stat) 1154b551cb7dSFeiyang Chen /* 1155b551cb7dSFeiyang Chen * Maybe we can just use statx() when available for all architectures? 1156b551cb7dSFeiyang Chen */ 1157b551cb7dSFeiyang Chen static __attribute__((unused)) 1158b551cb7dSFeiyang Chen int sys_stat(const char *path, struct stat *buf) 1159b551cb7dSFeiyang Chen { 1160b551cb7dSFeiyang Chen struct statx statx; 1161b551cb7dSFeiyang Chen long ret; 1162b551cb7dSFeiyang Chen 1163b551cb7dSFeiyang Chen ret = sys_statx(AT_FDCWD, path, AT_NO_AUTOMOUNT, STATX_BASIC_STATS, &statx); 1164b551cb7dSFeiyang Chen buf->st_dev = ((statx.stx_dev_minor & 0xff) 1165b551cb7dSFeiyang Chen | (statx.stx_dev_major << 8) 1166b551cb7dSFeiyang Chen | ((statx.stx_dev_minor & ~0xff) << 12)); 1167b551cb7dSFeiyang Chen buf->st_ino = statx.stx_ino; 1168b551cb7dSFeiyang Chen buf->st_mode = statx.stx_mode; 1169b551cb7dSFeiyang Chen buf->st_nlink = statx.stx_nlink; 1170b551cb7dSFeiyang Chen buf->st_uid = statx.stx_uid; 1171b551cb7dSFeiyang Chen buf->st_gid = statx.stx_gid; 1172b551cb7dSFeiyang Chen buf->st_rdev = ((statx.stx_rdev_minor & 0xff) 1173b551cb7dSFeiyang Chen | (statx.stx_rdev_major << 8) 1174b551cb7dSFeiyang Chen | ((statx.stx_rdev_minor & ~0xff) << 12)); 1175b551cb7dSFeiyang Chen buf->st_size = statx.stx_size; 1176b551cb7dSFeiyang Chen buf->st_blksize = statx.stx_blksize; 1177b551cb7dSFeiyang Chen buf->st_blocks = statx.stx_blocks; 117887b9fa66SThomas Weißschuh buf->st_atim.tv_sec = statx.stx_atime.tv_sec; 117987b9fa66SThomas Weißschuh buf->st_atim.tv_nsec = statx.stx_atime.tv_nsec; 118087b9fa66SThomas Weißschuh buf->st_mtim.tv_sec = statx.stx_mtime.tv_sec; 118187b9fa66SThomas Weißschuh buf->st_mtim.tv_nsec = statx.stx_mtime.tv_nsec; 118287b9fa66SThomas Weißschuh buf->st_ctim.tv_sec = statx.stx_ctime.tv_sec; 118387b9fa66SThomas Weißschuh buf->st_ctim.tv_nsec = statx.stx_ctime.tv_nsec; 1184b551cb7dSFeiyang Chen return ret; 1185b551cb7dSFeiyang Chen } 1186b551cb7dSFeiyang Chen #else 1187bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1188bd8c8fbbSWilly Tarreau int sys_stat(const char *path, struct stat *buf) 1189bd8c8fbbSWilly Tarreau { 1190bd8c8fbbSWilly Tarreau struct sys_stat_struct stat; 1191bd8c8fbbSWilly Tarreau long ret; 1192bd8c8fbbSWilly Tarreau 1193bd8c8fbbSWilly Tarreau #ifdef __NR_newfstatat 1194bd8c8fbbSWilly Tarreau /* only solution for arm64 */ 1195bd8c8fbbSWilly Tarreau ret = my_syscall4(__NR_newfstatat, AT_FDCWD, path, &stat, 0); 1196bd8c8fbbSWilly Tarreau #elif defined(__NR_stat) 1197bd8c8fbbSWilly Tarreau ret = my_syscall2(__NR_stat, path, &stat); 1198bd8c8fbbSWilly Tarreau #else 1199bd8c8fbbSWilly Tarreau #error Neither __NR_newfstatat nor __NR_stat defined, cannot implement sys_stat() 1200bd8c8fbbSWilly Tarreau #endif 1201bd8c8fbbSWilly Tarreau buf->st_dev = stat.st_dev; 1202bd8c8fbbSWilly Tarreau buf->st_ino = stat.st_ino; 1203bd8c8fbbSWilly Tarreau buf->st_mode = stat.st_mode; 1204bd8c8fbbSWilly Tarreau buf->st_nlink = stat.st_nlink; 1205bd8c8fbbSWilly Tarreau buf->st_uid = stat.st_uid; 1206bd8c8fbbSWilly Tarreau buf->st_gid = stat.st_gid; 1207bd8c8fbbSWilly Tarreau buf->st_rdev = stat.st_rdev; 1208bd8c8fbbSWilly Tarreau buf->st_size = stat.st_size; 1209bd8c8fbbSWilly Tarreau buf->st_blksize = stat.st_blksize; 1210bd8c8fbbSWilly Tarreau buf->st_blocks = stat.st_blocks; 121187b9fa66SThomas Weißschuh buf->st_atim.tv_sec = stat.st_atime; 121287b9fa66SThomas Weißschuh buf->st_atim.tv_nsec = stat.st_atime_nsec; 121387b9fa66SThomas Weißschuh buf->st_mtim.tv_sec = stat.st_mtime; 121487b9fa66SThomas Weißschuh buf->st_mtim.tv_nsec = stat.st_mtime_nsec; 121587b9fa66SThomas Weißschuh buf->st_ctim.tv_sec = stat.st_ctime; 121687b9fa66SThomas Weißschuh buf->st_ctim.tv_nsec = stat.st_ctime_nsec; 1217bd8c8fbbSWilly Tarreau return ret; 1218bd8c8fbbSWilly Tarreau } 1219b551cb7dSFeiyang Chen #endif 1220bd8c8fbbSWilly Tarreau 1221bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1222bd8c8fbbSWilly Tarreau int stat(const char *path, struct stat *buf) 1223bd8c8fbbSWilly Tarreau { 1224bd8c8fbbSWilly Tarreau int ret = sys_stat(path, buf); 1225bd8c8fbbSWilly Tarreau 1226bd8c8fbbSWilly Tarreau if (ret < 0) { 1227bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1228bd8c8fbbSWilly Tarreau ret = -1; 1229bd8c8fbbSWilly Tarreau } 1230bd8c8fbbSWilly Tarreau return ret; 1231bd8c8fbbSWilly Tarreau } 1232bd8c8fbbSWilly Tarreau 1233bd8c8fbbSWilly Tarreau 1234bd8c8fbbSWilly Tarreau /* 1235bd8c8fbbSWilly Tarreau * int symlink(const char *old, const char *new); 1236bd8c8fbbSWilly Tarreau */ 1237bd8c8fbbSWilly Tarreau 1238bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1239bd8c8fbbSWilly Tarreau int sys_symlink(const char *old, const char *new) 1240bd8c8fbbSWilly Tarreau { 1241bd8c8fbbSWilly Tarreau #ifdef __NR_symlinkat 1242bd8c8fbbSWilly Tarreau return my_syscall3(__NR_symlinkat, old, AT_FDCWD, new); 1243bd8c8fbbSWilly Tarreau #elif defined(__NR_symlink) 1244bd8c8fbbSWilly Tarreau return my_syscall2(__NR_symlink, old, new); 1245bd8c8fbbSWilly Tarreau #else 1246bd8c8fbbSWilly Tarreau #error Neither __NR_symlinkat nor __NR_symlink defined, cannot implement sys_symlink() 1247bd8c8fbbSWilly Tarreau #endif 1248bd8c8fbbSWilly Tarreau } 1249bd8c8fbbSWilly Tarreau 1250bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1251bd8c8fbbSWilly Tarreau int symlink(const char *old, const char *new) 1252bd8c8fbbSWilly Tarreau { 1253bd8c8fbbSWilly Tarreau int ret = sys_symlink(old, new); 1254bd8c8fbbSWilly Tarreau 1255bd8c8fbbSWilly Tarreau if (ret < 0) { 1256bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1257bd8c8fbbSWilly Tarreau ret = -1; 1258bd8c8fbbSWilly Tarreau } 1259bd8c8fbbSWilly Tarreau return ret; 1260bd8c8fbbSWilly Tarreau } 1261bd8c8fbbSWilly Tarreau 1262bd8c8fbbSWilly Tarreau 1263bd8c8fbbSWilly Tarreau /* 1264bd8c8fbbSWilly Tarreau * mode_t umask(mode_t mode); 1265bd8c8fbbSWilly Tarreau */ 1266bd8c8fbbSWilly Tarreau 1267bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1268bd8c8fbbSWilly Tarreau mode_t sys_umask(mode_t mode) 1269bd8c8fbbSWilly Tarreau { 1270bd8c8fbbSWilly Tarreau return my_syscall1(__NR_umask, mode); 1271bd8c8fbbSWilly Tarreau } 1272bd8c8fbbSWilly Tarreau 1273bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1274bd8c8fbbSWilly Tarreau mode_t umask(mode_t mode) 1275bd8c8fbbSWilly Tarreau { 1276bd8c8fbbSWilly Tarreau return sys_umask(mode); 1277bd8c8fbbSWilly Tarreau } 1278bd8c8fbbSWilly Tarreau 1279bd8c8fbbSWilly Tarreau 1280bd8c8fbbSWilly Tarreau /* 1281bd8c8fbbSWilly Tarreau * int umount2(const char *path, int flags); 1282bd8c8fbbSWilly Tarreau */ 1283bd8c8fbbSWilly Tarreau 1284bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1285bd8c8fbbSWilly Tarreau int sys_umount2(const char *path, int flags) 1286bd8c8fbbSWilly Tarreau { 1287bd8c8fbbSWilly Tarreau return my_syscall2(__NR_umount2, path, flags); 1288bd8c8fbbSWilly Tarreau } 1289bd8c8fbbSWilly Tarreau 1290bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1291bd8c8fbbSWilly Tarreau int umount2(const char *path, int flags) 1292bd8c8fbbSWilly Tarreau { 1293bd8c8fbbSWilly Tarreau int ret = sys_umount2(path, flags); 1294bd8c8fbbSWilly Tarreau 1295bd8c8fbbSWilly Tarreau if (ret < 0) { 1296bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1297bd8c8fbbSWilly Tarreau ret = -1; 1298bd8c8fbbSWilly Tarreau } 1299bd8c8fbbSWilly Tarreau return ret; 1300bd8c8fbbSWilly Tarreau } 1301bd8c8fbbSWilly Tarreau 1302bd8c8fbbSWilly Tarreau 1303bd8c8fbbSWilly Tarreau /* 1304bd8c8fbbSWilly Tarreau * int unlink(const char *path); 1305bd8c8fbbSWilly Tarreau */ 1306bd8c8fbbSWilly Tarreau 1307bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1308bd8c8fbbSWilly Tarreau int sys_unlink(const char *path) 1309bd8c8fbbSWilly Tarreau { 1310bd8c8fbbSWilly Tarreau #ifdef __NR_unlinkat 1311bd8c8fbbSWilly Tarreau return my_syscall3(__NR_unlinkat, AT_FDCWD, path, 0); 1312bd8c8fbbSWilly Tarreau #elif defined(__NR_unlink) 1313bd8c8fbbSWilly Tarreau return my_syscall1(__NR_unlink, path); 1314bd8c8fbbSWilly Tarreau #else 1315bd8c8fbbSWilly Tarreau #error Neither __NR_unlinkat nor __NR_unlink defined, cannot implement sys_unlink() 1316bd8c8fbbSWilly Tarreau #endif 1317bd8c8fbbSWilly Tarreau } 1318bd8c8fbbSWilly Tarreau 1319bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1320bd8c8fbbSWilly Tarreau int unlink(const char *path) 1321bd8c8fbbSWilly Tarreau { 1322bd8c8fbbSWilly Tarreau int ret = sys_unlink(path); 1323bd8c8fbbSWilly Tarreau 1324bd8c8fbbSWilly Tarreau if (ret < 0) { 1325bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1326bd8c8fbbSWilly Tarreau ret = -1; 1327bd8c8fbbSWilly Tarreau } 1328bd8c8fbbSWilly Tarreau return ret; 1329bd8c8fbbSWilly Tarreau } 1330bd8c8fbbSWilly Tarreau 1331bd8c8fbbSWilly Tarreau 1332bd8c8fbbSWilly Tarreau /* 1333bd8c8fbbSWilly Tarreau * pid_t wait(int *status); 1334bd8c8fbbSWilly Tarreau * pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage); 1335bd8c8fbbSWilly Tarreau * pid_t waitpid(pid_t pid, int *status, int options); 1336bd8c8fbbSWilly Tarreau */ 1337bd8c8fbbSWilly Tarreau 1338bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1339bd8c8fbbSWilly Tarreau pid_t sys_wait4(pid_t pid, int *status, int options, struct rusage *rusage) 1340bd8c8fbbSWilly Tarreau { 1341bd8c8fbbSWilly Tarreau return my_syscall4(__NR_wait4, pid, status, options, rusage); 1342bd8c8fbbSWilly Tarreau } 1343bd8c8fbbSWilly Tarreau 1344bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1345bd8c8fbbSWilly Tarreau pid_t wait(int *status) 1346bd8c8fbbSWilly Tarreau { 1347bd8c8fbbSWilly Tarreau pid_t ret = sys_wait4(-1, status, 0, NULL); 1348bd8c8fbbSWilly Tarreau 1349bd8c8fbbSWilly Tarreau if (ret < 0) { 1350bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1351bd8c8fbbSWilly Tarreau ret = -1; 1352bd8c8fbbSWilly Tarreau } 1353bd8c8fbbSWilly Tarreau return ret; 1354bd8c8fbbSWilly Tarreau } 1355bd8c8fbbSWilly Tarreau 1356bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1357bd8c8fbbSWilly Tarreau pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage) 1358bd8c8fbbSWilly Tarreau { 1359bd8c8fbbSWilly Tarreau pid_t ret = sys_wait4(pid, status, options, rusage); 1360bd8c8fbbSWilly Tarreau 1361bd8c8fbbSWilly Tarreau if (ret < 0) { 1362bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1363bd8c8fbbSWilly Tarreau ret = -1; 1364bd8c8fbbSWilly Tarreau } 1365bd8c8fbbSWilly Tarreau return ret; 1366bd8c8fbbSWilly Tarreau } 1367bd8c8fbbSWilly Tarreau 1368bd8c8fbbSWilly Tarreau 1369bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1370bd8c8fbbSWilly Tarreau pid_t waitpid(pid_t pid, int *status, int options) 1371bd8c8fbbSWilly Tarreau { 1372bd8c8fbbSWilly Tarreau pid_t ret = sys_wait4(pid, status, options, NULL); 1373bd8c8fbbSWilly Tarreau 1374bd8c8fbbSWilly Tarreau if (ret < 0) { 1375bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1376bd8c8fbbSWilly Tarreau ret = -1; 1377bd8c8fbbSWilly Tarreau } 1378bd8c8fbbSWilly Tarreau return ret; 1379bd8c8fbbSWilly Tarreau } 1380bd8c8fbbSWilly Tarreau 1381bd8c8fbbSWilly Tarreau 1382bd8c8fbbSWilly Tarreau /* 1383bd8c8fbbSWilly Tarreau * ssize_t write(int fd, const void *buf, size_t count); 1384bd8c8fbbSWilly Tarreau */ 1385bd8c8fbbSWilly Tarreau 1386bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1387bd8c8fbbSWilly Tarreau ssize_t sys_write(int fd, const void *buf, size_t count) 1388bd8c8fbbSWilly Tarreau { 1389bd8c8fbbSWilly Tarreau return my_syscall3(__NR_write, fd, buf, count); 1390bd8c8fbbSWilly Tarreau } 1391bd8c8fbbSWilly Tarreau 1392bd8c8fbbSWilly Tarreau static __attribute__((unused)) 1393bd8c8fbbSWilly Tarreau ssize_t write(int fd, const void *buf, size_t count) 1394bd8c8fbbSWilly Tarreau { 1395bd8c8fbbSWilly Tarreau ssize_t ret = sys_write(fd, buf, count); 1396bd8c8fbbSWilly Tarreau 1397bd8c8fbbSWilly Tarreau if (ret < 0) { 1398bd8c8fbbSWilly Tarreau SET_ERRNO(-ret); 1399bd8c8fbbSWilly Tarreau ret = -1; 1400bd8c8fbbSWilly Tarreau } 1401bd8c8fbbSWilly Tarreau return ret; 1402bd8c8fbbSWilly Tarreau } 1403bd8c8fbbSWilly Tarreau 1404e8842cf0SThomas Weißschuh 1405e8842cf0SThomas Weißschuh /* 1406e8842cf0SThomas Weißschuh * int memfd_create(const char *name, unsigned int flags); 1407e8842cf0SThomas Weißschuh */ 1408e8842cf0SThomas Weißschuh 1409e8842cf0SThomas Weißschuh static __attribute__((unused)) 1410e8842cf0SThomas Weißschuh int sys_memfd_create(const char *name, unsigned int flags) 1411e8842cf0SThomas Weißschuh { 1412e8842cf0SThomas Weißschuh return my_syscall2(__NR_memfd_create, name, flags); 1413e8842cf0SThomas Weißschuh } 1414e8842cf0SThomas Weißschuh 1415e8842cf0SThomas Weißschuh static __attribute__((unused)) 1416e8842cf0SThomas Weißschuh int memfd_create(const char *name, unsigned int flags) 1417e8842cf0SThomas Weißschuh { 1418e8842cf0SThomas Weißschuh ssize_t ret = sys_memfd_create(name, flags); 1419e8842cf0SThomas Weißschuh 1420e8842cf0SThomas Weißschuh if (ret < 0) { 1421e8842cf0SThomas Weißschuh SET_ERRNO(-ret); 1422e8842cf0SThomas Weißschuh ret = -1; 1423e8842cf0SThomas Weißschuh } 1424e8842cf0SThomas Weißschuh return ret; 1425e8842cf0SThomas Weißschuh } 1426e8842cf0SThomas Weißschuh 142755abdd1fSWilly Tarreau /* make sure to include all global symbols */ 142855abdd1fSWilly Tarreau #include "nolibc.h" 1429bd8c8fbbSWilly Tarreau 1430bd8c8fbbSWilly Tarreau #endif /* _NOLIBC_SYS_H */ 1431