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