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