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