├── VERSION
├── .gitignore
├── src
    ├── sync.c
    ├── pause.c
    ├── usr26.c
    ├── usr32.c
    ├── vhangup.c
    ├── close.c
    ├── fsync.c
    ├── pipe.c
    ├── setsid.c
    ├── shmdt.c
    ├── acct.c
    ├── breakpoint.c
    ├── fchdir.c
    ├── fork.c
    ├── getpgrp.c
    ├── getppid.c
    ├── iopl.c
    ├── mlockall.c
    ├── munlockall.c
    ├── oldumount.c
    ├── pkey_free.c
    ├── sched_yield.c
    ├── setgid.c
    ├── setuid.c
    ├── sgetmask.c
    ├── syncfs.c
    ├── chdir.c
    ├── chroot.c
    ├── error.c
    ├── fdatasync.c
    ├── getegid.c
    ├── geteuid.c
    ├── getgid.c
    ├── getpid.c
    ├── gettid.c
    ├── getuid.c
    ├── rmdir.c
    ├── set_tls.c
    ├── umask.c
    ├── umount.c
    ├── unlink.c
    ├── uselib.c
    ├── vfork.c
    ├── dup.c
    ├── get_tls.c
    ├── kill.c
    ├── listen.c
    ├── mq_unlink.c
    ├── setgid16.c
    ├── setns.c
    ├── setuid16.c
    ├── shutdown.c
    ├── stime32.c
    ├── swapoff.c
    ├── access.c
    ├── bdflush.c
    ├── flock.c
    ├── getegid16.c
    ├── geteuid16.c
    ├── getgid16.c
    ├── getpgid.c
    ├── getsid.c
    ├── getuid16.c
    ├── inotify_init.c
    ├── io_destroy.c
    ├── kill_v.c
    ├── nice.c
    ├── pipe2.c
    ├── sethostname.c
    ├── ssetmask.c
    ├── sysinfo.c
    ├── tkill.c
    ├── tkill_v.c
    ├── uname.c
    ├── unshare.c
    ├── brk.c
    ├── fchmod.c
    ├── io_destroy_v.c
    ├── link.c
    ├── mlock.c
    ├── munmap.c
    ├── newuname.c
    ├── setdomainname.c
    ├── setpgid.c
    ├── sigpending.c
    ├── sigpending_v.c
    ├── timer_delete.c
    ├── vm86.c
    ├── alarm.c
    ├── arch_prctl.c
    ├── chmod.c
    ├── eventfd.c
    ├── fstatfs.c
    ├── ftruncate.c
    ├── getrusage.c
    ├── ioprio_get.c
    ├── ioprio_set.c
    ├── membarrier.c
    ├── mkdir.c
    ├── munlock.c
    ├── olduname.c
    ├── rename.c
    ├── setfsgid.c
    ├── setfsuid.c
    ├── setpriority.c
    ├── setregid.c
    ├── setreuid.c
    ├── swapon.c
    ├── syslog.c
    ├── truncate.c
    ├── userfaultfd.c
    ├── ustat.c
    ├── utime.c
    ├── vm86old.c
    ├── adjtimex.c
    ├── dup2.c
    ├── epoll_create.c
    ├── fremovexattr.c
    ├── ftruncate64.c
    ├── getcwd.c
    ├── inotify_init1.c
    ├── msync.c
    ├── newfstat.c
    ├── setgroups.c
    ├── statfs.c
    ├── symlink.c
    ├── time.c
    ├── time32.c
    ├── times.c
    ├── truncate64.c
    ├── epoll_create1.c
    ├── epoll_create_v.c
    ├── fchown.c
    ├── fremovexattr_v.c
    ├── fstat.c
    ├── fstat64.c
    ├── get_thread_area.c
    ├── getitimer.c
    ├── getpriority.c
    ├── inotify_rm_watch.c
    ├── ioperm.c
    ├── lremovexattr.c
    ├── memfd_secret.c
    ├── mlock2.c
    ├── msgget.c
    ├── newstat.c
    ├── pivot_root.c
    ├── reboot.c
    ├── removexattr.c
    ├── set_thread_area.c
    ├── set_tid_address.c
    ├── setfsgid16.c
    ├── setfsuid16.c
    ├── setregid16.c
    ├── setreuid16.c
    ├── socketcall.c
    ├── stat64.c
    ├── tgkill.c
    ├── tgkill_v.c
    ├── unlinkat.c
    ├── utime32.c
    ├── utimes.c
    ├── adjtimex_time32.c
    ├── chown.c
    ├── delete_module.c
    ├── epoll_create1_v.c
    ├── eventfd2.c
    ├── faccessat.c
    ├── finit_module.c
    ├── getgroups.c
    ├── getrlimit.c
    ├── io_setup.c
    ├── lremovexattr_v.c
    ├── lstat64.c
    ├── madvise.c
    ├── mknod.c
    ├── newlstat.c
    ├── personality.c
    ├── process_mrelease.c
    ├── readlink.c
    ├── removexattr_v.c
    ├── sched_get_priority_max.c
    ├── sched_get_priority_min.c
    ├── sched_getscheduler.c
    ├── semop.c
    ├── setgroups16.c
    ├── setrlimit.c
    ├── shmat.c
    ├── sigaltstack.c
    ├── socket.c
    ├── stat.c
    ├── timer_getoverrun.c
    ├── bind.c
    ├── cacheflush.c
    ├── creat.c
    ├── dup3.c
    ├── fchmodat.c
    ├── fsopen.c
    ├── init_module.c
    ├── io_setup_v.c
    ├── ioctl.c
    ├── lchown.c
    ├── lstat.c
    ├── mincore.c
    ├── mkdirat.c
    ├── mprotect.c
    ├── old_mmap.c
    ├── old_select.c
    ├── readahead.c
    ├── rt_sigpending.c
    ├── semget.c
    ├── setresgid.c
    ├── setresuid.c
    ├── sigaltstack_v.c
    ├── sysfs.c
    ├── timerfd_create.c
    ├── utimes_time32.c
    ├── bpf.c
    ├── clock_getres.c
    ├── close_range.c
    ├── faccessat2.c
    ├── fchown16.c
    ├── fstatfs64.c
    ├── getgroups16.c
    ├── getresgid.c
    ├── getresuid.c
    ├── modify_ldt.c
    ├── old_getrlimit.c
    ├── old_select_v.c
    ├── pidfd_open.c
    ├── pkey_alloc.c
    ├── read.c
    ├── rseq.c
    ├── rt_sigpending_v.c
    ├── rt_sigsuspend.c
    ├── rt_sigsuspend_v.c
    ├── sched_getparam.c
    ├── sched_setparam.c
    ├── signal.c
    ├── sigsuspend.c
    ├── socketpair.c
    ├── symlinkat.c
    ├── timerfd_gettime.c
    ├── chown16.c
    ├── clock_gettime.c
    ├── clone3.c
    ├── connect.c
    ├── execve.c
    ├── fadvise64.c
    ├── fallocate.c
    ├── fcntl.c
    ├── gettimeofday.c
    ├── lchown16.c
    ├── memfd_create.c
    ├── mq_notify.c
    ├── msgctl.c
    ├── msgsnd.c
    ├── nanosleep.c
    ├── open.c
    ├── quotactl.c
    ├── quotactl_fd.c
    ├── rt_sigqueueinfo.c
    ├── semctl.c
    ├── set_robust_list.c
    ├── settimeofday.c
    ├── shmctl.c
    ├── shmget.c
    ├── signal_v.c
    ├── sigsuspend_v.c
    ├── statfs64.c
    ├── timer_gettime.c
    ├── timerfd_gettime32.c
    ├── waitpid.c
    ├── write.c
    ├── capget.c
    ├── clock_gettime32.c
    ├── clock_settime.c
    ├── clock_settime32.c
    ├── fadvise64_64.c
    ├── fcntl64.c
    ├── flistxattr.c
    ├── fspick.c
    ├── futimesat.c
    ├── getcpu.c
    ├── getsockopt.c
    ├── lookup_dcookie.c
    ├── lseek.c
    ├── mknodat.c
    ├── mount.c
    ├── recv.c
    ├── rt_sigqueueinfo_v.c
    ├── seccomp.c
    ├── send.c
    ├── set_mempolicy.c
    ├── setresgid16.c
    ├── setresuid16.c
    ├── sigprocmask.c
    ├── timer_gettime32.c
    ├── capset.c
    ├── clock_adjtime.c
    ├── fanotify_init.c
    ├── flistxattr_v.c
    ├── fsmount.c
    ├── getdents.c
    ├── getpeername.c
    ├── getrandom.c
    ├── getresgid16.c
    ├── getresuid16.c
    ├── getsockname.c
    ├── landlock_restrict_self.c
    ├── listxattr.c
    ├── old_msgctl.c
    ├── old_semctl.c
    ├── old_shmctl.c
    ├── open_tree.c
    ├── pkey_mprotect.c
    ├── poll.c
    ├── poll_v.c
    ├── readlinkat.c
    ├── recvmsg.c
    ├── sched_rr_get_interval.c
    ├── sched_setattr.c
    ├── sendmsg.c
    ├── setsockopt.c
    ├── sigprocmask_v.c
    ├── tee.c
    ├── clock_adjtime32.c
    ├── clock_getres_time32.c
    ├── fsconfig.c
    ├── fsetxattr.c
    ├── fstatat64.c
    ├── futimesat_time32.c
    ├── getdents64.c
    ├── listxattr_v.c
    ├── llistxattr.c
    ├── llistxattr_v.c
    ├── nanosleep_time32.c
    ├── newfstatat.c
    ├── old_readdir.c
    ├── pidfd_getfd.c
    ├── renameat.c
    ├── sched_getaffinity.c
    ├── sched_setaffinity.c
    ├── sched_setscheduler.c
    ├── utimensat.c
    ├── epoll_ctl.c
    ├── fchownat.c
    ├── fsetxattr_v.c
    ├── get_robust_list.c
    ├── io_cancel.c
    ├── io_uring_setup.c
    ├── linkat.c
    ├── openat.c
    ├── pidfd_send_signal.c
    ├── pread64.c
    ├── readv.c
    ├── riscv_flush_icache.c
    ├── setxattr.c
    ├── sigaction.c
    ├── signalfd.c
    ├── wait4.c
    ├── writev.c
    ├── accept.c
    ├── epoll_ctl_v.c
    ├── fgetxattr.c
    ├── fgetxattr_v.c
    ├── inotify_add_watch.c
    ├── io_cancel_v.c
    ├── kcmp.c
    ├── lsetxattr.c
    ├── mq_open.c
    ├── pwrite64.c
    ├── rt_tgsigqueueinfo.c
    ├── sched_rr_get_interval_time32.c
    ├── setitimer.c
    ├── setxattr_v.c
    ├── sigaction_v.c
    ├── signalfd_v.c
    ├── sync_file_range.c
    ├── utimensat_time32.c
    ├── waitid.c
    ├── execveat.c
    ├── getxattr.c
    ├── getxattr_v.c
    ├── io_submit.c
    ├── lgetxattr.c
    ├── lsetxattr_v.c
    ├── pciconfig_iobase.c
    ├── pciconfig_read.c
    ├── ptrace.c
    ├── rt_sigprocmask.c
    ├── rt_sigprocmask_v.c
    ├── rt_tgsigqueueinfo_v.c
    ├── sched_getattr.c
    ├── sendmmsg.c
    ├── statx.c
    ├── accept4.c
    ├── io_submit_v.c
    ├── io_uring_register.c
    ├── lgetxattr_v.c
    ├── mq_getsetattr.c
    ├── open_by_handle_at.c
    ├── openat2.c
    ├── pciconfig_write.c
    ├── renameat2.c
    ├── semtimedop.c
    ├── sendfile.c
    ├── signalfd4.c
    ├── fanotify_mark.c
    ├── get_mempolicy.c
    ├── llseek.c
    ├── move_pages.c
    ├── msgrcv.c
    ├── name_to_handle_at.c
    ├── prctl.c
    ├── sendfile64.c
    ├── signalfd4_v.c
    ├── timerfd_settime.c
    ├── epoll_wait.c
    ├── epoll_wait_v.c
    ├── kexec_load.c
    ├── keyctl.c
    ├── move_mount.c
    ├── prlimit64.c
    ├── rt_sigaction.c
    ├── timer_create.c
    ├── timer_settime32.c
    ├── vmsplice.c
    ├── clock_nanosleep.c
    ├── futex.c
    ├── ipc.c
    ├── mount_setattr.c
    ├── remap_file_pages.c
    ├── rt_sigaction_v.c
    ├── select.c
    ├── select_v.c
    ├── semtimedop_time32.c
    ├── timerfd_settime32.c
    ├── clone.c
    ├── recvfrom.c
    ├── mbind.c
    ├── migrate_pages.c
    ├── pselect6.c
    ├── recvmmsg.c
    ├── request_key.c
    ├── sendto.c
    ├── timer_settime.c
    ├── add_key.c
    ├── futex_time32.c
    ├── kexec_file_load.c
    ├── mmap.c
    ├── mremap.c
    ├── preadv.c
    ├── pselect6_v.c
    ├── pwritev.c
    ├── clock_nanosleep_time32.c
    ├── mq_timedsend.c
    ├── ppoll.c
    ├── splice.c
    ├── landlock_create_ruleset.c
    ├── perf_event_open.c
    ├── ppoll_v.c
    ├── pselect6_time32.c
    ├── recvmmsg_time32.c
    ├── io_uring_enter.c
    ├── landlock_add_rule.c
    ├── mmap_pgoff.c
    ├── pselect6_time32_v.c
    ├── rt_sigtimedwait.c
    ├── rt_sigtimedwait_v.c
    ├── io_getevents.c
    ├── ppoll_time32.c
    ├── preadv2.c
    ├── pwritev2.c
    ├── copy_file_range.c
    ├── mq_timedreceive.c
    ├── mq_timedsend_time32.c
    ├── ppoll_time32_v.c
    ├── rt_sigtimedwait_time32.c
    ├── epoll_pwait.c
    ├── io_getevents_time32.c
    ├── process_madvise.c
    ├── rt_sigtimedwait_time32_v.c
    ├── epoll_pwait_v.c
    ├── io_getevents_time32_v.c
    ├── mq_timedreceive_time32.c
    ├── process_vm_readv.c
    ├── process_vm_writev.c
    ├── epoll_pwait2.c
    ├── io_pgetevents.c
    ├── io_pgetevents_v.c
    ├── io_pgetevents_time32.c
    └── io_pgetevents_time32_v.c
├── TODO
├── PORTING
└── tests
    └── syscalls
        ├── acct.c
        ├── brk.c
        ├── dup.c
        ├── iopl.c
        ├── pipe.c
        ├── sync.c
        ├── usr26.c
        ├── usr32.c
        ├── alarm.c
        ├── bind.c
        ├── chdir.c
        ├── chmod.c
        ├── chroot.c
        ├── dup2.c
        ├── fchdir.c
        ├── flock.c
        ├── fstat.c
        ├── fsync.c
        ├── get_tls.c
        ├── getegid.c
        ├── geteuid.c
        ├── getgid.c
        ├── getpgrp.c
        ├── getppid.c
        ├── gettid.c
        ├── getuid.c
        ├── kill.c
        ├── link.c
        ├── lstat.c
        ├── mkdir.c
        ├── mlock.c
        ├── nice.c
        ├── rmdir.c
        ├── set_tls.c
        ├── setgid.c
        ├── setns.c
        ├── setsid.c
        ├── setuid.c
        ├── shmdt.c
        ├── stat.c
        ├── stime32.c
        ├── swapoff.c
        ├── syncfs.c
        ├── sysinfo.c
        ├── time.c
        ├── times.c
        ├── tkill.c
        ├── umask.c
        ├── uname.c
        ├── unlink.c
        ├── unshare.c
        ├── uselib.c
        ├── ustat.c
        ├── utime.c
        ├── vhangup.c
        ├── vm86.c
        ├── vm86old.c
        ├── adjtimex.c
        ├── bdflush.c
        ├── bpf.c
        ├── capget.c
        ├── capset.c
        ├── chown.c
        ├── clone3.c
        ├── creat.c
        ├── eventfd.c
        ├── execve.c
        ├── fchmod.c
        ├── fchown.c
        ├── fcntl.c
        ├── fdatasync.c
        ├── fsopen.c
        ├── fstat64.c
        ├── fstatfs.c
        ├── getcpu.c
        ├── getcwd.c
        ├── getegid16.c
        ├── geteuid16.c
        ├── getgid16.c
        ├── getpgid.c
        ├── getsid.c
        ├── getuid16.c
        ├── io_setup.c
        ├── ioperm.c
        ├── lchown.c
        ├── listen.c
        ├── lseek.c
        ├── lstat64.c
        ├── mknod.c
        ├── mlock2.c
        ├── mlockall.c
        ├── msgget.c
        ├── msync.c
        ├── munlock.c
        ├── munlockall.c
        ├── munmap.c
        ├── newfstat.c
        ├── newlstat.c
        ├── newstat.c
        ├── newuname.c
        ├── old_mmap.c
        ├── oldumount.c
        ├── olduname.c
        ├── open.c
        ├── pkey_free.c
        ├── poll.c
        ├── read.c
        ├── readv.c
        ├── rename.c
        ├── semop.c
        ├── setfsgid.c
        ├── setfsuid.c
        ├── setgid16.c
        ├── setpgid.c
        ├── setregid.c
        ├── setreuid.c
        ├── setuid16.c
        ├── sgetmask.c
        ├── shmat.c
        ├── shutdown.c
        ├── signal.c
        ├── ssetmask.c
        ├── stat64.c
        ├── statfs.c
        ├── swapon.c
        ├── symlink.c
        ├── sysfs.c
        ├── tee.c
        ├── tgkill.c
        ├── time32.c
        ├── truncate.c
        ├── umount.c
        ├── utime32.c
        ├── utimes.c
        ├── write.c
        ├── arch_prctl.c
        ├── chown16.c
        ├── connect.c
        ├── eventfd2.c
        ├── faccessat.c
        ├── fchmodat.c
        ├── fchown16.c
        ├── fcntl64.c
        ├── fsmount.c
        ├── fspick.c
        ├── fstatfs64.c
        ├── ftruncate.c
        ├── futimesat.c
        ├── getgroups.c
        ├── getitimer.c
        ├── getresgid.c
        ├── getresuid.c
        ├── getrlimit.c
        ├── getrusage.c
        ├── inotify_init.c
        ├── io_cancel.c
        ├── io_destroy.c
        ├── ipc.c
        └── kcmp.c


/VERSION:
--------------------------------------------------------------------------------
1 | 0.7.0
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.o
2 | *.d
3 | 


--------------------------------------------------------------------------------
/src/sync.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sync(void);
4 | 


--------------------------------------------------------------------------------
/src/pause.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pause(void);
4 | 


--------------------------------------------------------------------------------
/src/usr26.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_usr26(void);
4 | 


--------------------------------------------------------------------------------
/src/usr32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_usr32(void);
4 | 


--------------------------------------------------------------------------------
/src/vhangup.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_vhangup(void);
4 | 


--------------------------------------------------------------------------------
/src/close.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_close(linux_fd_t fd);
4 | 


--------------------------------------------------------------------------------
/src/fsync.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fsync(linux_fd_t fd);
4 | 


--------------------------------------------------------------------------------
/src/pipe.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pipe(int* fildes);
4 | 


--------------------------------------------------------------------------------
/src/setsid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setsid(int* result);
4 | 


--------------------------------------------------------------------------------
/src/shmdt.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_shmdt(char* shmaddr);
4 | 


--------------------------------------------------------------------------------
/src/acct.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_acct(char const* name);
4 | 


--------------------------------------------------------------------------------
/src/breakpoint.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_breakpoint(void);
4 | 


--------------------------------------------------------------------------------
/src/fchdir.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fchdir(linux_fd_t fd);
4 | 


--------------------------------------------------------------------------------
/src/fork.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fork(linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getpgrp.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getpgrp(int* result);
4 | 


--------------------------------------------------------------------------------
/src/getppid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getppid(int* result);
4 | 


--------------------------------------------------------------------------------
/src/iopl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_iopl(unsigned int level);
4 | 


--------------------------------------------------------------------------------
/src/mlockall.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mlockall(int flags);
4 | 


--------------------------------------------------------------------------------
/src/munlockall.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_munlockall(void);
4 | 


--------------------------------------------------------------------------------
/src/oldumount.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_oldumount(char* name);
4 | 


--------------------------------------------------------------------------------
/src/pkey_free.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pkey_free(int pkey);
4 | 


--------------------------------------------------------------------------------
/src/sched_yield.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_yield(void);
4 | 


--------------------------------------------------------------------------------
/src/setgid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setgid(linux_gid_t gid);
4 | 


--------------------------------------------------------------------------------
/src/setuid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setuid(linux_uid_t uid);
4 | 


--------------------------------------------------------------------------------
/src/sgetmask.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sgetmask(int* result);
4 | 


--------------------------------------------------------------------------------
/src/syncfs.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_syncfs(linux_fd_t fd);
4 | 


--------------------------------------------------------------------------------
/src/chdir.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_chdir(char const* filename);
4 | 


--------------------------------------------------------------------------------
/src/chroot.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_chroot(char const* filename);
4 | 


--------------------------------------------------------------------------------
/src/error.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_get_error(linux_word_t ret);
4 | 


--------------------------------------------------------------------------------
/src/fdatasync.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fdatasync(linux_fd_t fd);
4 | 


--------------------------------------------------------------------------------
/src/getegid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getegid(linux_gid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/geteuid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_geteuid(linux_uid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getgid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getgid(linux_gid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getpid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getpid(linux_pid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/gettid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_gettid(linux_pid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getuid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getuid(linux_uid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/rmdir.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rmdir(char const* pathname);
4 | 


--------------------------------------------------------------------------------
/src/set_tls.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_set_tls(linux_uword_t val);
4 | 


--------------------------------------------------------------------------------
/src/umask.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_umask(int mask, int* result);
4 | 


--------------------------------------------------------------------------------
/src/umount.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_umount(char* name, int flags);
4 | 


--------------------------------------------------------------------------------
/src/unlink.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_unlink(char const* pathname);
4 | 


--------------------------------------------------------------------------------
/src/uselib.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_uselib(char const* library);
4 | 


--------------------------------------------------------------------------------
/src/vfork.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_vfork(linux_pid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/dup.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_dup(unsigned int fildes, int* result);
4 | 


--------------------------------------------------------------------------------
/src/get_tls.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_get_tls(linux_uword_t* result);
4 | 


--------------------------------------------------------------------------------
/src/kill.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_kill(linux_pid_t pid, uint32_t sig);
4 | 


--------------------------------------------------------------------------------
/src/listen.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_listen(linux_fd_t fd, int backlog);
4 | 


--------------------------------------------------------------------------------
/src/mq_unlink.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mq_unlink(char const* u_name);
4 | 


--------------------------------------------------------------------------------
/src/setgid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setgid16(linux_old_gid_t gid);
4 | 


--------------------------------------------------------------------------------
/src/setns.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setns(linux_fd_t fd, int nstype);
4 | 


--------------------------------------------------------------------------------
/src/setuid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setuid16(linux_old_uid_t uid);
4 | 


--------------------------------------------------------------------------------
/src/shutdown.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_shutdown(linux_fd_t fd, int how);
4 | 


--------------------------------------------------------------------------------
/src/stime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_stime32(linux_time32_t* tptr);
4 | 


--------------------------------------------------------------------------------
/src/swapoff.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_swapoff(char const* specialfile);
4 | 


--------------------------------------------------------------------------------
/src/access.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_access(char const* filename, int mode);
4 | 


--------------------------------------------------------------------------------
/src/bdflush.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_bdflush(int func, linux_word_t data);
4 | 


--------------------------------------------------------------------------------
/src/flock.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_flock(linux_fd_t fd, unsigned int cmd);
4 | 


--------------------------------------------------------------------------------
/src/getegid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getegid16(linux_old_gid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/geteuid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_geteuid16(linux_old_uid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getgid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getgid16(linux_old_gid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getpgid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getpgid(linux_pid_t pid, int* result);
4 | 


--------------------------------------------------------------------------------
/src/getsid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getsid(linux_pid_t pid, int* result);
4 | 


--------------------------------------------------------------------------------
/src/getuid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getuid16(linux_old_uid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/inotify_init.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_inotify_init(linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_destroy.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_destroy(linux_aio_context_t ctx);
4 | 


--------------------------------------------------------------------------------
/src/kill_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_kill_v(linux_pid_t pid, uint32_t sig);
4 | 


--------------------------------------------------------------------------------
/src/nice.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_nice(int increment, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pipe2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pipe2(linux_fd_t* fildes, int flags);
4 | 


--------------------------------------------------------------------------------
/src/sethostname.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sethostname(char* name, int len);
4 | 


--------------------------------------------------------------------------------
/src/ssetmask.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ssetmask(int newmask, int* result);
4 | 


--------------------------------------------------------------------------------
/src/sysinfo.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sysinfo(struct linux_sysinfo* info);
4 | 


--------------------------------------------------------------------------------
/src/tkill.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_tkill(linux_pid_t pid, uint32_t sig);
4 | 


--------------------------------------------------------------------------------
/src/tkill_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_tkill_v(linux_pid_t pid, uint32_t sig);
4 | 


--------------------------------------------------------------------------------
/src/uname.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_uname(struct linux_old_utsname* name);
4 | 


--------------------------------------------------------------------------------
/src/unshare.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_unshare(linux_uword_t unshare_flags);
4 | 


--------------------------------------------------------------------------------
/src/brk.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_brk(linux_uword_t brk, linux_uword_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fchmod.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fchmod(linux_fd_t fd, linux_umode_t mode);
4 | 


--------------------------------------------------------------------------------
/src/io_destroy_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_destroy_v(linux_aio_context_t ctx);
4 | 


--------------------------------------------------------------------------------
/src/link.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_link(char const* oldname, char const* newname);
4 | 


--------------------------------------------------------------------------------
/src/mlock.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mlock(linux_uword_t start, linux_size_t len);
4 | 


--------------------------------------------------------------------------------
/src/munmap.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_munmap(linux_uword_t addr, linux_size_t len);
4 | 


--------------------------------------------------------------------------------
/src/newuname.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_newuname(struct linux_new_utsname* name);
4 | 


--------------------------------------------------------------------------------
/src/setdomainname.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setdomainname(char* name, int len);
4 | 


--------------------------------------------------------------------------------
/src/setpgid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setpgid(linux_pid_t pid, linux_pid_t pgid);
4 | 


--------------------------------------------------------------------------------
/src/sigpending.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigpending(linux_old_sigset_t* uset);
4 | 


--------------------------------------------------------------------------------
/src/sigpending_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigpending_v(linux_old_sigset_t* uset);
4 | 


--------------------------------------------------------------------------------
/src/timer_delete.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timer_delete(linux_timer_t timer_id);
4 | 


--------------------------------------------------------------------------------
/src/vm86.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_vm86(linux_uword_t cmd, linux_uword_t arg);
4 | 


--------------------------------------------------------------------------------
/src/alarm.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_alarm(unsigned int seconds, unsigned int* result);
4 | 


--------------------------------------------------------------------------------
/src/arch_prctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_arch_prctl(int option, linux_uword_t arg2);
4 | 


--------------------------------------------------------------------------------
/src/chmod.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_chmod(char const* filename, linux_umode_t mode);
4 | 


--------------------------------------------------------------------------------
/src/eventfd.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_eventfd(unsigned int count, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fstatfs.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fstatfs(linux_fd_t fd, struct linux_statfs* buf);
4 | 


--------------------------------------------------------------------------------
/src/ftruncate.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ftruncate(linux_fd_t fd, linux_uword_t length);
4 | 


--------------------------------------------------------------------------------
/src/getrusage.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getrusage(int who, struct linux_rusage* ru);
4 | 


--------------------------------------------------------------------------------
/src/ioprio_get.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ioprio_get(int which, int who, int* result);
4 | 


--------------------------------------------------------------------------------
/src/ioprio_set.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ioprio_set(int which, int who, int ioprio);
4 | 


--------------------------------------------------------------------------------
/src/membarrier.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_membarrier(int cmd, int flags, int* result);
4 | 


--------------------------------------------------------------------------------
/src/mkdir.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mkdir(char const* pathname, linux_umode_t mode);
4 | 


--------------------------------------------------------------------------------
/src/munlock.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_munlock(linux_uword_t start, linux_size_t len);
4 | 


--------------------------------------------------------------------------------
/src/olduname.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_olduname(struct linux_oldold_utsname* name);
4 | 


--------------------------------------------------------------------------------
/src/rename.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rename(char const* oldname, char const* newname);
4 | 


--------------------------------------------------------------------------------
/src/setfsgid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setfsgid(linux_gid_t gid, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/setfsuid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setfsuid(linux_uid_t uid, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/setpriority.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setpriority(int which, int who, int niceval);
4 | 


--------------------------------------------------------------------------------
/src/setregid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setregid(linux_gid_t rgid, linux_gid_t egid);
4 | 


--------------------------------------------------------------------------------
/src/setreuid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setreuid(linux_uid_t ruid, linux_uid_t euid);
4 | 


--------------------------------------------------------------------------------
/src/swapon.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_swapon(char const* specialfile, int swap_flags);
4 | 


--------------------------------------------------------------------------------
/src/syslog.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_syslog(int type, char* buf, int len, int* result);
4 | 


--------------------------------------------------------------------------------
/src/truncate.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_truncate(char const* path, linux_word_t length);
4 | 


--------------------------------------------------------------------------------
/src/userfaultfd.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_userfaultfd(int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/ustat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ustat(unsigned int dev, struct linux_ustat* ubuf);
4 | 


--------------------------------------------------------------------------------
/src/utime.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_utime(char* filename, struct linux_utimbuf* times);
4 | 


--------------------------------------------------------------------------------
/src/vm86old.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_vm86old(struct linux_vm86_struct* user_vm86);
4 | 


--------------------------------------------------------------------------------
/src/adjtimex.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_adjtimex(struct linux_timex* txc_p, int* result);
4 | 


--------------------------------------------------------------------------------
/src/dup2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_dup2(linux_fd_t oldfd, linux_fd_t newfd, int* result);
4 | 


--------------------------------------------------------------------------------
/src/epoll_create.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_create(int32_t size, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fremovexattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fremovexattr(linux_fd_t fd, char const* name);
4 | 


--------------------------------------------------------------------------------
/src/ftruncate64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ftruncate64(linux_fd_t fd, linux_loff_t length);
4 | 


--------------------------------------------------------------------------------
/src/getcwd.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getcwd(char* buf, linux_uword_t size, int* result);
4 | 


--------------------------------------------------------------------------------
/src/inotify_init1.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_inotify_init1(int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/msync.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_msync(linux_uword_t start, linux_size_t len, int flags);
4 | 


--------------------------------------------------------------------------------
/src/newfstat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_newfstat(linux_fd_t fd, struct linux_stat* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/setgroups.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setgroups(int gidsetsize, linux_gid_t* grouplist);
4 | 


--------------------------------------------------------------------------------
/src/statfs.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_statfs(char const* pathname, struct linux_statfs* buf);
4 | 


--------------------------------------------------------------------------------
/src/symlink.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_symlink(char const* oldname, char const* newname);
4 | 


--------------------------------------------------------------------------------
/src/time.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_time(linux_old_time_t* tloc, linux_old_time_t* result);
4 | 


--------------------------------------------------------------------------------
/src/time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_time32(linux_time32_t* tloc, linux_time32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/times.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_times(struct linux_tms* tbuf, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/truncate64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_truncate64(char const* path, linux_loff_t length);
4 | 


--------------------------------------------------------------------------------
/src/epoll_create1.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_create1(uint32_t flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/epoll_create_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_create_v(int32_t size, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fchown.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fchown(linux_fd_t fd, linux_uid_t user, linux_gid_t group);
4 | 


--------------------------------------------------------------------------------
/src/fremovexattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fremovexattr_v(linux_fd_t fd, char const* name);
4 | 


--------------------------------------------------------------------------------
/src/fstat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fstat(linux_fd_t fd, struct linux_old_kernel_stat* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/fstat64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fstat64(linux_uword_t fd, struct linux_stat64* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/get_thread_area.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_get_thread_area(struct linux_user_desc* u_info);
4 | 


--------------------------------------------------------------------------------
/src/getitimer.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getitimer(int which, struct linux_old_itimerval* value);
4 | 


--------------------------------------------------------------------------------
/src/getpriority.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getpriority(int which, int who, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/inotify_rm_watch.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_inotify_rm_watch(linux_fd_t fd, linux_wd_t wd);
4 | 


--------------------------------------------------------------------------------
/src/ioperm.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ioperm(linux_uword_t from, linux_uword_t num, int turn_on);
4 | 


--------------------------------------------------------------------------------
/src/lremovexattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lremovexattr(char const* pathname, char const* name);
4 | 


--------------------------------------------------------------------------------
/src/memfd_secret.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_memfd_secret(unsigned int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/mlock2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mlock2(linux_uword_t start, linux_size_t len, int flags);
4 | 


--------------------------------------------------------------------------------
/src/msgget.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_msgget(linux_key_t key, int msgflg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/newstat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_newstat(char const* filename, struct linux_stat* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/pivot_root.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pivot_root(char const* new_root, char const* put_old);
4 | 


--------------------------------------------------------------------------------
/src/reboot.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_reboot(int magic1, int magic2, unsigned int cmd, void* arg);
4 | 


--------------------------------------------------------------------------------
/src/removexattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_removexattr(char const* pathname, char const* name);
4 | 


--------------------------------------------------------------------------------
/src/set_thread_area.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_set_thread_area(struct linux_user_desc* u_info);
4 | 


--------------------------------------------------------------------------------
/src/set_tid_address.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_set_tid_address(int* tidptr, linux_pid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/setfsgid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setfsgid16(linux_old_gid_t gid, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/setfsuid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setfsuid16(linux_old_uid_t uid, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/setregid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setregid16(linux_old_gid_t rgid, linux_old_gid_t egid);
4 | 


--------------------------------------------------------------------------------
/src/setreuid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setreuid16(linux_old_uid_t ruid, linux_old_uid_t euid);
4 | 


--------------------------------------------------------------------------------
/src/socketcall.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_socketcall(int call, linux_uword_t* args, int* result);
4 | 


--------------------------------------------------------------------------------
/src/stat64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_stat64(char const* filename, struct linux_stat64* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/tgkill.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_tgkill(linux_pid_t tgid, linux_pid_t pid, uint32_t sig);
4 | 


--------------------------------------------------------------------------------
/src/tgkill_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_tgkill_v(linux_pid_t tgid, linux_pid_t pid, uint32_t sig);
4 | 


--------------------------------------------------------------------------------
/src/unlinkat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_unlinkat(linux_fd_t dfd, char const* pathname, int flag);
4 | 


--------------------------------------------------------------------------------
/src/utime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_utime32(char const* filename, struct linux_utimbuf32* t);
4 | 


--------------------------------------------------------------------------------
/src/utimes.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_utimes(char* filename, struct linux_old_timeval* utimes);
4 | 


--------------------------------------------------------------------------------
/src/adjtimex_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_adjtimex_time32(struct linux_timex32* utp, int* result);
4 | 


--------------------------------------------------------------------------------
/src/chown.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_chown(char const* filename, linux_uid_t user, linux_gid_t group);
4 | 


--------------------------------------------------------------------------------
/src/delete_module.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_delete_module(char const* name_user, unsigned int flags);
4 | 


--------------------------------------------------------------------------------
/src/epoll_create1_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_create1_v(uint32_t flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/eventfd2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_eventfd2(unsigned int count, int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/faccessat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_faccessat(linux_fd_t dfd, char const* filename, int mode);
4 | 


--------------------------------------------------------------------------------
/src/finit_module.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_finit_module(linux_fd_t fd, char const* uargs, int flags);
4 | 


--------------------------------------------------------------------------------
/src/getgroups.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getgroups(int gidsetsize, linux_gid_t* grouplis, int* result);
4 | 


--------------------------------------------------------------------------------
/src/getrlimit.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getrlimit(unsigned int resource, struct linux_rlimit* rlim);
4 | 


--------------------------------------------------------------------------------
/src/io_setup.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_setup(unsigned int nr_events, linux_aio_context_t* ctxp);
4 | 


--------------------------------------------------------------------------------
/src/lremovexattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lremovexattr_v(char const* pathname, char const* name);
4 | 


--------------------------------------------------------------------------------
/src/lstat64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lstat64(char const* filename, struct linux_stat64* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/madvise.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_madvise(linux_uword_t start, linux_size_t len_in, int behavior);
4 | 


--------------------------------------------------------------------------------
/src/mknod.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mknod(char const* filename, linux_umode_t mode, unsigned int dev);
4 | 


--------------------------------------------------------------------------------
/src/newlstat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_newlstat(char const* filename, struct linux_stat* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/personality.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_personality(unsigned int personality, unsigned int* result);
4 | 


--------------------------------------------------------------------------------
/src/process_mrelease.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_process_mrelease(linux_fd_t pidfd, unsigned int flags);
4 | 


--------------------------------------------------------------------------------
/src/readlink.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_readlink(char const* path, char* buf, int bufsiz, int* result);
4 | 


--------------------------------------------------------------------------------
/src/removexattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_removexattr_v(char const* pathname, char const* name);
4 | 


--------------------------------------------------------------------------------
/src/sched_get_priority_max.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_get_priority_max(int policy, int* result);
4 | 


--------------------------------------------------------------------------------
/src/sched_get_priority_min.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_get_priority_min(int policy, int* result);
4 | 


--------------------------------------------------------------------------------
/src/sched_getscheduler.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_getscheduler(linux_pid_t pid, int* result);
4 | 


--------------------------------------------------------------------------------
/src/semop.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_semop(int semid, struct linux_sembuf* tsops, unsigned int nsops);
4 | 


--------------------------------------------------------------------------------
/src/setgroups16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setgroups16(int gidsetsize, linux_old_gid_t* grouplist);
4 | 


--------------------------------------------------------------------------------
/src/setrlimit.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setrlimit(unsigned int resource, struct linux_rlimit* rlim);
4 | 


--------------------------------------------------------------------------------
/src/shmat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_shmat(int shmid, char* shmaddr, int shmflg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/sigaltstack.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigaltstack(linux_stack_t const* uss, linux_stack_t* uoss);
4 | 


--------------------------------------------------------------------------------
/src/socket.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_socket(int family, int type, int protocol, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/stat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_stat(char const* filename, struct linux_old_kernel_stat* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/timer_getoverrun.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timer_getoverrun(linux_timer_t timer_id, int* result);
4 | 


--------------------------------------------------------------------------------
/src/bind.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_bind(linux_fd_t fd, struct linux_sockaddr const* umyaddr, int addrlen);
4 | 


--------------------------------------------------------------------------------
/src/cacheflush.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_cacheflush(linux_uword_t start, linux_uword_t end, int flags);
4 | 


--------------------------------------------------------------------------------
/src/creat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_creat(char const* pathname, linux_umode_t mode, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/dup3.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_dup3(linux_fd_t oldfd, linux_fd_t newfd, int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fchmodat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fchmodat(linux_fd_t dfd, char const* filename, linux_umode_t mode);
4 | 


--------------------------------------------------------------------------------
/src/fsopen.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fsopen(char const* fs_name, unsigned int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/init_module.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_init_module(void* umod, linux_uword_t len, char const* uargs);
4 | 


--------------------------------------------------------------------------------
/src/io_setup_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_setup_v(unsigned int nr_events, linux_aio_context_t* ctxp);
4 | 


--------------------------------------------------------------------------------
/src/ioctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ioctl(linux_fd_t fd, unsigned int cmd, linux_uword_t arg, int* result);
4 | 


--------------------------------------------------------------------------------
/src/lchown.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lchown(char const* filename, linux_uid_t user, linux_gid_t group);
4 | 


--------------------------------------------------------------------------------
/src/lstat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lstat(char const* filename, struct linux_old_kernel_stat* statbuf);
4 | 


--------------------------------------------------------------------------------
/src/mincore.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mincore(linux_uword_t start, linux_size_t len, unsigned char* vec);
4 | 


--------------------------------------------------------------------------------
/src/mkdirat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mkdirat(linux_fd_t dfd, char const* pathname, linux_umode_t mode);
4 | 


--------------------------------------------------------------------------------
/src/mprotect.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mprotect(linux_uword_t start, linux_size_t len, linux_uword_t prot);
4 | 


--------------------------------------------------------------------------------
/src/old_mmap.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_old_mmap(struct linux_mmap_arg_struct* arg, linux_uword_t* result);
4 | 


--------------------------------------------------------------------------------
/src/old_select.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_old_select(struct linux_sel_arg_struct* arg, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/readahead.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_readahead(linux_fd_t fd, linux_loff_t offset, linux_size_t count);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigpending.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigpending(linux_sigset_t* uset, linux_size_t sigsetsize);
4 | 


--------------------------------------------------------------------------------
/src/semget.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_semget(linux_key_t key, int nsems, int semflg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/setresgid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setresgid(linux_gid_t rgid, linux_gid_t egid, linux_gid_t sgid);
4 | 


--------------------------------------------------------------------------------
/src/setresuid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setresuid(linux_uid_t ruid, linux_uid_t euid, linux_uid_t suid);
4 | 


--------------------------------------------------------------------------------
/src/sigaltstack_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigaltstack_v(linux_stack_t const* uss, linux_stack_t* uoss);
4 | 


--------------------------------------------------------------------------------
/src/sysfs.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sysfs(int option, linux_uword_t arg1, linux_uword_t arg2, int* result);
4 | 


--------------------------------------------------------------------------------
/src/timerfd_create.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timerfd_create(int clockid, int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/utimes_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_utimes_time32(char const* filename, struct linux_timeval32* t);
4 | 


--------------------------------------------------------------------------------
/src/bpf.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_bpf(int cmd, union linux_bpf_attr* uattr, unsigned int size, int* result);
4 | 


--------------------------------------------------------------------------------
/src/clock_getres.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_getres(linux_clockid_t which_clock, struct linux_timespec* tp);
4 | 


--------------------------------------------------------------------------------
/src/close_range.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_close_range(linux_fd_t fd, linux_fd_t max_fd, unsigned int flags);
4 | 


--------------------------------------------------------------------------------
/src/faccessat2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_faccessat2(linux_fd_t dfd, char const* filename, int mode, int flags);
4 | 


--------------------------------------------------------------------------------
/src/fchown16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fchown16(linux_fd_t fd, linux_old_uid_t user, linux_old_gid_t group);
4 | 


--------------------------------------------------------------------------------
/src/fstatfs64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fstatfs64(linux_fd_t fd, linux_size_t sz, struct linux_statfs64* buf);
4 | 


--------------------------------------------------------------------------------
/src/getgroups16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getgroups16(int gidsetsize, linux_old_gid_t* grouplist, int* result);
4 | 


--------------------------------------------------------------------------------
/src/getresgid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getresgid(linux_gid_t* rgidp, linux_gid_t* egidp, linux_gid_t* sgidp);
4 | 


--------------------------------------------------------------------------------
/src/getresuid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getresuid(linux_uid_t* ruidp, linux_uid_t* euidp, linux_uid_t* suidp);
4 | 


--------------------------------------------------------------------------------
/src/modify_ldt.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_modify_ldt(int func, void* ptr, linux_uword_t bytecount, int* result);
4 | 


--------------------------------------------------------------------------------
/src/old_getrlimit.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_old_getrlimit(unsigned int resource, struct linux_rlimit* rlim);
4 | 


--------------------------------------------------------------------------------
/src/old_select_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_old_select_v(struct linux_sel_arg_struct* arg, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pidfd_open.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pidfd_open(linux_pid_t pid, unsigned int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pkey_alloc.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pkey_alloc(linux_uword_t flags, linux_uword_t init_val, int* result);
4 | 


--------------------------------------------------------------------------------
/src/read.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_read(linux_fd_t fd, void* buf, linux_size_t count, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/rseq.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rseq(struct linux_rseq* rseq, uint32_t rseq_len, int flags, uint32_t sig);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigpending_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigpending_v(linux_sigset_t* uset, linux_size_t sigsetsize);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigsuspend.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigsuspend(linux_sigset_t* unewset, linux_size_t sigsetsize);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigsuspend_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigsuspend_v(linux_sigset_t* unewset, linux_size_t sigsetsize);
4 | 


--------------------------------------------------------------------------------
/src/sched_getparam.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_getparam(linux_pid_t pid, struct linux_sched_param* param);
4 | 


--------------------------------------------------------------------------------
/src/sched_setparam.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_setparam(linux_pid_t pid, struct linux_sched_param* param);
4 | 


--------------------------------------------------------------------------------
/src/signal.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_signal(uint32_t sig, linux_sighandler_t handler, linux_uword_t* result);
4 | 


--------------------------------------------------------------------------------
/src/sigsuspend.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigsuspend(int32_t unused1, int32_t unused2, linux_old_sigset_t mask);
4 | 


--------------------------------------------------------------------------------
/src/socketpair.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_socketpair(int family, int type, int protocol, linux_fd_t* usockvec);
4 | 


--------------------------------------------------------------------------------
/src/symlinkat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_symlinkat(char const* oldname, linux_fd_t newdfd, char const* newname);
4 | 


--------------------------------------------------------------------------------
/src/timerfd_gettime.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timerfd_gettime(linux_fd_t ufd, struct linux_itimerspec* otmr);
4 | 


--------------------------------------------------------------------------------
/src/chown16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_chown16(char const* filename, linux_old_uid_t user, linux_old_gid_t group);
4 | 


--------------------------------------------------------------------------------
/src/clock_gettime.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_gettime(linux_clockid_t which_clock, struct linux_timespec* tp);
4 | 


--------------------------------------------------------------------------------
/src/clone3.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clone3(struct linux_clone_args* uargs, linux_size_t size, linux_pid_t* result);
4 | 


--------------------------------------------------------------------------------
/src/connect.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_connect(linux_fd_t fd, struct linux_sockaddr const* uservaddr, int addrlen);
4 | 


--------------------------------------------------------------------------------
/src/execve.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_execve(char const* filename, char const* const* argv, char const* const* envp);
4 | 


--------------------------------------------------------------------------------
/src/fadvise64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fadvise64(linux_fd_t fd, linux_loff_t offset, linux_size_t len, int advice);
4 | 


--------------------------------------------------------------------------------
/src/fallocate.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fallocate(linux_fd_t fd, int mode, linux_loff_t offset, linux_loff_t len);
4 | 


--------------------------------------------------------------------------------
/src/fcntl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fcntl(linux_fd_t fd, unsigned int cmd, linux_uword_t arg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/gettimeofday.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_gettimeofday(struct linux_old_timeval* tv, struct linux_timezone* tz);
4 | 


--------------------------------------------------------------------------------
/src/lchown16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lchown16(char const* filename, linux_old_uid_t user, linux_old_gid_t group);
4 | 


--------------------------------------------------------------------------------
/src/memfd_create.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_memfd_create(char const* uname, unsigned int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/mq_notify.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mq_notify(linux_mqd_t mqdes, struct linux_sigevent const* u_notification);
4 | 


--------------------------------------------------------------------------------
/src/msgctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_msgctl(int msqid, int cmd, struct linux_msqid64_ds* buf, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/msgsnd.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_msgsnd(int msqid, struct linux_msgbuf* msgp, linux_size_t msgsz, int msgflg);
4 | 


--------------------------------------------------------------------------------
/src/nanosleep.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_nanosleep(struct linux_timespec const* rqtp, struct linux_timespec* rmtp);
4 | 


--------------------------------------------------------------------------------
/src/open.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_open(char const* filename, int flags, linux_umode_t mode, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/quotactl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_quotactl(unsigned int cmd, char const* special, linux_qid_t id, void* addr);
4 | 


--------------------------------------------------------------------------------
/src/quotactl_fd.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_quotactl_fd(linux_fd_t fd, unsigned int cmd, linux_qid_t id, void* addr);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigqueueinfo.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigqueueinfo(linux_pid_t pid, uint32_t sig, linux_siginfo_t* uinfo);
4 | 


--------------------------------------------------------------------------------
/src/semctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_semctl(int semid, int semnum, int cmd, linux_uword_t arg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/set_robust_list.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_set_robust_list(struct linux_robust_list_head* head, linux_size_t len);
4 | 


--------------------------------------------------------------------------------
/src/settimeofday.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_settimeofday(struct linux_old_timeval* tv, struct linux_timezone* tz);
4 | 


--------------------------------------------------------------------------------
/src/shmctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_shmctl(int shmid, int cmd, struct linux_shmid64_ds* buf, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/shmget.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_shmget(linux_key_t key, linux_size_t size, int shmflg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/signal_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_signal_v(uint32_t sig, linux_sighandler_t handler, linux_uword_t* result);
4 | 


--------------------------------------------------------------------------------
/src/sigsuspend_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigsuspend_v(int32_t unused1, int32_t unused2, linux_old_sigset_t mask);
4 | 


--------------------------------------------------------------------------------
/src/statfs64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_statfs64(char const* pathname, linux_size_t sz, struct linux_statfs64* buf);
4 | 


--------------------------------------------------------------------------------
/src/timer_gettime.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timer_gettime(linux_timer_t timer_id, struct linux_itimerspec* setting);
4 | 


--------------------------------------------------------------------------------
/src/timerfd_gettime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timerfd_gettime32(linux_fd_t ufd, struct linux_itimerspec32* otmr);
4 | 


--------------------------------------------------------------------------------
/src/waitpid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_waitpid(linux_pid_t pid, int* stat_addr, int options, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/write.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_write(linux_fd_t fd, void const* buf, linux_size_t count, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/capget.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_capget(linux_cap_user_header_t header, struct linux_user_cap_data_struct* dataptr);
4 | 


--------------------------------------------------------------------------------
/src/clock_gettime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_gettime32(linux_clockid_t which_clock, struct linux_timespec32* tp);
4 | 


--------------------------------------------------------------------------------
/src/clock_settime.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_settime(linux_clockid_t which_clock, struct linux_timespec const* tp);
4 | 


--------------------------------------------------------------------------------
/src/clock_settime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_settime32(linux_clockid_t which_clock, struct linux_timespec32* tp);
4 | 


--------------------------------------------------------------------------------
/src/fadvise64_64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fadvise64_64(linux_fd_t fd, linux_loff_t offset, linux_loff_t len, int advice);
4 | 


--------------------------------------------------------------------------------
/src/fcntl64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fcntl64(linux_fd_t fd, unsigned int cmd, linux_uword_t arg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/flistxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_flistxattr(linux_fd_t fd, char* list, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fspick.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fspick(linux_fd_t dfd, char const* path, unsigned int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/futimesat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_futimesat(linux_fd_t dfd, char const* filename, struct linux_old_timeval* utimes);
4 | 


--------------------------------------------------------------------------------
/src/getcpu.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getcpu(unsigned int* cpup, unsigned int* nodep, struct linux_getcpu_cache* unused);
4 | 


--------------------------------------------------------------------------------
/src/getsockopt.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getsockopt(linux_fd_t fd, int level, int optname, char* optval, int* optlen);
4 | 


--------------------------------------------------------------------------------
/src/lookup_dcookie.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lookup_dcookie(uint64_t cookie64, char* buf, linux_size_t len, int* result);
4 | 


--------------------------------------------------------------------------------
/src/lseek.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lseek(linux_fd_t fd, linux_off_t offset, unsigned int whence, linux_off_t* result);
4 | 


--------------------------------------------------------------------------------
/src/mknodat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mknodat(linux_fd_t dfd, char const* filename, linux_umode_t mode, unsigned int dev);
4 | 


--------------------------------------------------------------------------------
/src/mount.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mount(char* dev_name, char* dir_name, char* type, linux_uword_t flags, void* data);
4 | 


--------------------------------------------------------------------------------
/src/recv.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_recv(linux_fd_t fd, void* ubuf, linux_size_t size, unsigned int flags, int* result);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigqueueinfo_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigqueueinfo_v(linux_pid_t pid, uint32_t sig, linux_siginfo_t* uinfo);
4 | 


--------------------------------------------------------------------------------
/src/seccomp.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_seccomp(unsigned int op, unsigned int flags, void* uargs, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/send.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_send(linux_fd_t fd, void* buff, linux_size_t len, unsigned int flags, int* result);
4 | 


--------------------------------------------------------------------------------
/src/set_mempolicy.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_set_mempolicy(int mode, linux_uword_t const* nmask, linux_uword_t maxnode);
4 | 


--------------------------------------------------------------------------------
/src/setresgid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setresgid16(linux_old_gid_t rgid, linux_old_gid_t egid, linux_old_gid_t sgid);
4 | 


--------------------------------------------------------------------------------
/src/setresuid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setresuid16(linux_old_uid_t ruid, linux_old_uid_t euid, linux_old_uid_t suid);
4 | 


--------------------------------------------------------------------------------
/src/sigprocmask.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigprocmask(uint32_t how, linux_old_sigset_t* nset, linux_old_sigset_t* oset);
4 | 


--------------------------------------------------------------------------------
/src/timer_gettime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timer_gettime32(linux_timer_t timer_id, struct linux_itimerspec32* setting);
4 | 


--------------------------------------------------------------------------------
/src/capset.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_capset(linux_cap_user_header_t header, struct linux_user_cap_data_struct const* data);
4 | 


--------------------------------------------------------------------------------
/src/clock_adjtime.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_adjtime(linux_clockid_t which_clock, struct linux_timex* ktx, int* result);
4 | 


--------------------------------------------------------------------------------
/src/fanotify_init.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fanotify_init(unsigned int flags, unsigned int event_f_flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/flistxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_flistxattr_v(linux_fd_t fd, char* list, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fsmount.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fsmount(linux_fd_t fs_fd, unsigned int flags, unsigned int ms_flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getdents.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getdents(linux_fd_t fd, struct linux_dirent* dirent, unsigned int count, int* result);
4 | 


--------------------------------------------------------------------------------
/src/getpeername.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getpeername(linux_fd_t fd, struct linux_sockaddr* usockaddr, int* usockaddr_len);
4 | 


--------------------------------------------------------------------------------
/src/getrandom.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getrandom(char* buf, linux_size_t count, unsigned int flags, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getresgid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getresgid16(linux_old_gid_t* rgidp, linux_old_gid_t* egidp, linux_old_gid_t* sgidp);
4 | 


--------------------------------------------------------------------------------
/src/getresuid16.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getresuid16(linux_old_uid_t* ruidp, linux_old_uid_t* euidp, linux_old_uid_t* suidp);
4 | 


--------------------------------------------------------------------------------
/src/getsockname.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getsockname(linux_fd_t fd, struct linux_sockaddr* usockaddr, int* usockaddr_len);
4 | 


--------------------------------------------------------------------------------
/src/landlock_restrict_self.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_landlock_restrict_self(linux_fd_t const ruleset_fd, uint32_t const flags);
4 | 


--------------------------------------------------------------------------------
/src/listxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_listxattr(char const* pathname, char* list, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/old_msgctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_old_msgctl(int msqid, int cmd, struct linux_msqid64_ds* buf, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/old_semctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_old_semctl(int semid, int semnum, int cmd, linux_uword_t arg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/old_shmctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_old_shmctl(int shmid, int cmd, struct linux_shmid64_ds* buf, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/open_tree.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_open_tree(linux_fd_t dfd, char const* path, unsigned int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pkey_mprotect.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pkey_mprotect(linux_uword_t start, linux_size_t len, linux_uword_t prot, int pkey);
4 | 


--------------------------------------------------------------------------------
/src/poll.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_poll(struct linux_pollfd* ufds, uint32_t nfds, int32_t timeout_msecs, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/poll_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_poll_v(struct linux_pollfd* ufds, uint32_t nfds, int32_t timeout_msecs, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/readlinkat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_readlinkat(linux_fd_t dfd, char const* pathname, char* buf, int bufsiz, int* result);
4 | 


--------------------------------------------------------------------------------
/src/recvmsg.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_recvmsg(linux_fd_t fd, struct linux_user_msghdr* msg, unsigned int flags, int* result);
4 | 


--------------------------------------------------------------------------------
/src/sched_rr_get_interval.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_rr_get_interval(linux_pid_t pid, struct linux_timespec* interval);
4 | 


--------------------------------------------------------------------------------
/src/sched_setattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_setattr(linux_pid_t pid, struct linux_sched_attr* uattr, unsigned int flags);
4 | 


--------------------------------------------------------------------------------
/src/sendmsg.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sendmsg(linux_fd_t fd, struct linux_user_msghdr* msg, unsigned int flags, int* result);
4 | 


--------------------------------------------------------------------------------
/src/setsockopt.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setsockopt(linux_fd_t fd, int level, int optname, char const* optval, int optlen);
4 | 


--------------------------------------------------------------------------------
/src/sigprocmask_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigprocmask_v(uint32_t how, linux_old_sigset_t* nset, linux_old_sigset_t* oset);
4 | 


--------------------------------------------------------------------------------
/src/tee.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_tee(linux_fd_t fdin, linux_fd_t fdout, linux_size_t len, unsigned int flags, int* result);
4 | 


--------------------------------------------------------------------------------
/src/clock_adjtime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_adjtime32(linux_clockid_t which_clock, struct linux_timex32* utp, int* result);
4 | 


--------------------------------------------------------------------------------
/src/clock_getres_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_getres_time32(linux_clockid_t which_clock, struct linux_timespec32* tp);
4 | 


--------------------------------------------------------------------------------
/src/fsconfig.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fsconfig(linux_fd_t fs_fd, unsigned int cmd, char const* key, void const* value, int aux);
4 | 


--------------------------------------------------------------------------------
/src/fsetxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fsetxattr(linux_fd_t fd, char const* name, void const* value, linux_size_t size, int flags);
4 | 


--------------------------------------------------------------------------------
/src/fstatat64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fstatat64(linux_fd_t dfd, char const* filename, struct linux_stat64* statbuf, int flag);
4 | 


--------------------------------------------------------------------------------
/src/futimesat_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_futimesat_time32(linux_fd_t dfd, char const* filename, struct linux_timeval32* t);
4 | 


--------------------------------------------------------------------------------
/src/getdents64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getdents64(linux_fd_t fd, struct linux_dirent64* dirent, unsigned int count, int* result);
4 | 


--------------------------------------------------------------------------------
/src/listxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_listxattr_v(char const* pathname, char* list, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/llistxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_llistxattr(char const* pathname, char* list, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/llistxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_llistxattr_v(char const* pathname, char* list, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/nanosleep_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_nanosleep_time32(struct linux_timespec32 const* rqtp, struct linux_timespec32* rmtp);
4 | 


--------------------------------------------------------------------------------
/src/newfstatat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_newfstatat(linux_fd_t dfd, char const* filename, struct linux_stat* statbuf, int flag);
4 | 


--------------------------------------------------------------------------------
/src/old_readdir.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_old_readdir(linux_fd_t fd, struct linux_old_linux_dirent* dirent, unsigned int count);
4 | 


--------------------------------------------------------------------------------
/src/pidfd_getfd.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pidfd_getfd(linux_pid_t pidfd, linux_fd_t fd, unsigned int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/renameat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_renameat(linux_fd_t olddfd, char const* oldname, linux_fd_t newdfd, char const* newname);
4 | 


--------------------------------------------------------------------------------
/src/sched_getaffinity.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_getaffinity(linux_pid_t pid, unsigned int len, linux_uword_t* user_mask_ptr);
4 | 


--------------------------------------------------------------------------------
/src/sched_setaffinity.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_setaffinity(linux_pid_t pid, unsigned int len, linux_uword_t* user_mask_ptr);
4 | 


--------------------------------------------------------------------------------
/src/sched_setscheduler.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_setscheduler(linux_pid_t pid, int policy, struct linux_sched_param* param);
4 | 


--------------------------------------------------------------------------------
/src/utimensat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_utimensat(linux_fd_t dfd, char const* filename, struct linux_timespec* utimes, int flags);
4 | 


--------------------------------------------------------------------------------
/src/epoll_ctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_ctl(linux_fd_t epfd, uint32_t op, linux_fd_t fd, struct linux_epoll_event const* event);
4 | 


--------------------------------------------------------------------------------
/src/fchownat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fchownat(linux_fd_t dfd, char const* filename, linux_uid_t user, linux_gid_t group, int flag);
4 | 


--------------------------------------------------------------------------------
/src/fsetxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fsetxattr_v(linux_fd_t fd, char const* name, void const* value, linux_size_t size, int flags);
4 | 


--------------------------------------------------------------------------------
/src/get_robust_list.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_get_robust_list(int pid, struct linux_robust_list_head** head_ptr, linux_size_t* len_ptr);
4 | 


--------------------------------------------------------------------------------
/src/io_cancel.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_cancel(linux_aio_context_t ctx_id, struct linux_iocb* iocb, struct linux_io_event* result);
4 | 


--------------------------------------------------------------------------------
/src/io_uring_setup.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_uring_setup(uint32_t entries, struct linux_io_uring_params* params, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/linkat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_linkat(linux_fd_t olddfd, char const* oldname, linux_fd_t newdfd, char const* newname, int flags);
4 | 


--------------------------------------------------------------------------------
/src/openat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_openat(linux_fd_t dfd, char const* filename, int flags, linux_umode_t mode, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pidfd_send_signal.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pidfd_send_signal(linux_fd_t pidfd, int sig, linux_siginfo_t* info, unsigned int flags);
4 | 


--------------------------------------------------------------------------------
/src/pread64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pread64(linux_fd_t fd, char* buf, linux_size_t count, linux_loff_t pos, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/readv.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_readv(linux_uword_t fd, struct linux_iovec const* vec, linux_uword_t vlen, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/riscv_flush_icache.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_riscv_flush_icache(uintptr_t const start, uintptr_t const end, uintptr_t const flags);
4 | 


--------------------------------------------------------------------------------
/src/setxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setxattr(char const* pathname, char const* name, void const* value, linux_size_t size, int flags);
4 | 


--------------------------------------------------------------------------------
/src/sigaction.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigaction(uint32_t sig, struct linux_old_sigaction const* act, struct linux_old_sigaction* oact);
4 | 


--------------------------------------------------------------------------------
/src/signalfd.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_signalfd(linux_fd_t ufd, linux_sigset_t* user_mask, linux_size_t sizemask, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/wait4.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_wait4(linux_pid_t upid, int* stat_addr, int options, struct linux_rusage* ru, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/writev.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_writev(linux_uword_t fd, struct linux_iovec const* vec, linux_uword_t vlen, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/accept.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_accept(linux_fd_t fd, struct linux_sockaddr* upeer_sockaddr, int* upeer_addrlen, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/epoll_ctl_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_ctl_v(linux_fd_t epfd, uint32_t op, linux_fd_t fd, struct linux_epoll_event const* event);
4 | 


--------------------------------------------------------------------------------
/src/fgetxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fgetxattr(linux_fd_t fd, char const* name, void* value, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fgetxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fgetxattr_v(linux_fd_t fd, char const* name, void* value, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/inotify_add_watch.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_inotify_add_watch(linux_fd_t fd, char const* pathname, uint32_t mask, linux_wd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_cancel_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_cancel_v(linux_aio_context_t ctx_id, struct linux_iocb* iocb, struct linux_io_event* result);
4 | 


--------------------------------------------------------------------------------
/src/kcmp.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_kcmp(linux_pid_t pid1, linux_pid_t pid2, int type, linux_uword_t idx1, linux_uword_t idx2, int* result);
4 | 


--------------------------------------------------------------------------------
/src/lsetxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lsetxattr(char const* pathname, char const* name, void const* value, linux_size_t size, int flags);
4 | 


--------------------------------------------------------------------------------
/src/mq_open.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mq_open(char const* u_name, int oflag, linux_umode_t mode, struct linux_mq_attr* u_attr, int* result);
4 | 


--------------------------------------------------------------------------------
/src/pwrite64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pwrite64(linux_fd_t fd, char const* buf, linux_size_t count, linux_loff_t pos, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/rt_tgsigqueueinfo.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_tgsigqueueinfo(linux_pid_t tgid, linux_pid_t pid, uint32_t sig, linux_siginfo_t* uinfo);
4 | 


--------------------------------------------------------------------------------
/src/sched_rr_get_interval_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_rr_get_interval_time32(linux_pid_t pid, struct linux_timespec32* interval);
4 | 


--------------------------------------------------------------------------------
/src/setitimer.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setitimer(int which, struct linux_old_itimerval const* value, struct linux_old_itimerval* ovalue);
4 | 


--------------------------------------------------------------------------------
/src/setxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_setxattr_v(char const* pathname, char const* name, void const* value, linux_size_t size, int flags);
4 | 


--------------------------------------------------------------------------------
/src/sigaction_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sigaction_v(uint32_t sig, struct linux_old_sigaction const* act, struct linux_old_sigaction* oact);
4 | 


--------------------------------------------------------------------------------
/src/signalfd_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_signalfd_v(linux_fd_t ufd, linux_sigset_t* user_mask, linux_size_t sizemask, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/sync_file_range.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sync_file_range(linux_fd_t fd, unsigned int flags, linux_loff_t offset, linux_loff_t nbytes);
4 | 


--------------------------------------------------------------------------------
/src/utimensat_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_utimensat_time32(linux_fd_t dfd, char const* filename, struct linux_timespec32* t, int flags);
4 | 


--------------------------------------------------------------------------------
/src/waitid.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_waitid(int which, linux_pid_t upid, struct linux_siginfo* infop, int options, struct linux_rusage* ru);
4 | 


--------------------------------------------------------------------------------
/src/execveat.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_execveat(linux_fd_t fd, char const* filename, char const* const* argv, char const* const* envp, int flags);
4 | 


--------------------------------------------------------------------------------
/src/getxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getxattr(char const* pathname, char const* name, void* value, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/getxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_getxattr_v(char const* pathname, char const* name, void* value, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_submit.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_submit(linux_aio_context_t ctx_id, linux_word_t nr, struct linux_iocb** iocbpp, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/lgetxattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lgetxattr(char const* pathname, char const* name, void* value, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/lsetxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lsetxattr_v(char const* pathname, char const* name, void const* value, linux_size_t size, int flags);
4 | 


--------------------------------------------------------------------------------
/src/pciconfig_iobase.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pciconfig_iobase(linux_word_t which, linux_uword_t bus, linux_uword_t devfn, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pciconfig_read.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pciconfig_read(linux_uword_t bus, linux_uword_t dfn, linux_uword_t off, linux_uword_t len, void* buf);
4 | 


--------------------------------------------------------------------------------
/src/ptrace.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ptrace(linux_word_t request, linux_word_t pid, linux_uword_t addr, linux_uword_t data, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigprocmask.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigprocmask(uint32_t how, linux_sigset_t* nset, linux_sigset_t* oset, linux_size_t sigsetsize);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigprocmask_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigprocmask_v(uint32_t how, linux_sigset_t* nset, linux_sigset_t* oset, linux_size_t sigsetsize);
4 | 


--------------------------------------------------------------------------------
/src/rt_tgsigqueueinfo_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_tgsigqueueinfo_v(linux_pid_t tgid, linux_pid_t pid, uint32_t sig, linux_siginfo_t* uinfo);
4 | 


--------------------------------------------------------------------------------
/src/sched_getattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sched_getattr(linux_pid_t pid, struct linux_sched_attr* uattr, unsigned int size, unsigned int flags);
4 | 


--------------------------------------------------------------------------------
/src/sendmmsg.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sendmmsg(linux_fd_t fd, struct linux_mmsghdr* mmsg, unsigned int vlen, unsigned int flags, int* result);
4 | 


--------------------------------------------------------------------------------
/src/statx.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_statx(linux_fd_t dfd, char const* filename, unsigned int flags, unsigned int mask, struct linux_statx* buffer);
4 | 


--------------------------------------------------------------------------------
/src/accept4.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_accept4(linux_fd_t fd, struct linux_sockaddr* upeer_sockaddr, int* upeer_addrlen, int flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_submit_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_submit_v(linux_aio_context_t ctx_id, linux_word_t nr, struct linux_iocb** iocbpp, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_uring_register.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_uring_register(linux_fd_t fd, unsigned int opcode, void* arg, unsigned int nr_args, int* result);
4 | 


--------------------------------------------------------------------------------
/src/lgetxattr_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_lgetxattr_v(char const* pathname, char const* name, void* value, linux_size_t size, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/mq_getsetattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mq_getsetattr(linux_mqd_t mqdes, struct linux_mq_attr const* u_mqstat, struct linux_mq_attr* u_omqstat);
4 | 


--------------------------------------------------------------------------------
/src/open_by_handle_at.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_open_by_handle_at(int mountdirfd, struct linux_file_handle* handle, int flags, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/openat2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_openat2(linux_fd_t dfd, char const* filename, struct linux_open_how* how, linux_size_t usize, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pciconfig_write.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pciconfig_write(linux_uword_t bus, linux_uword_t dfn, linux_uword_t off, linux_uword_t len, void* buf);
4 | 


--------------------------------------------------------------------------------
/src/renameat2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_renameat2(linux_fd_t olddfd, char const* oldname, linux_fd_t newdfd, char const* newname, unsigned int flags);
4 | 


--------------------------------------------------------------------------------
/src/semtimedop.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_semtimedop(int semid, struct linux_sembuf* tsops, unsigned int nsops, struct linux_timespec const* timeout);
4 | 


--------------------------------------------------------------------------------
/src/sendfile.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sendfile(linux_fd_t out_fd, linux_fd_t in_fd, linux_off_t* offset, linux_size_t count, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/signalfd4.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_signalfd4(linux_fd_t ufd, linux_sigset_t* user_mask, linux_size_t sizemask, uint32_t flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/fanotify_mark.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_fanotify_mark(linux_fd_t fanotify_fd, unsigned int flags, uint64_t mask, linux_fd_t dfd, char const* pathname);
4 | 


--------------------------------------------------------------------------------
/src/get_mempolicy.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_get_mempolicy(int* policy, linux_uword_t* nmask, linux_uword_t maxnode, linux_uword_t addr, linux_uword_t flags);
4 | 


--------------------------------------------------------------------------------
/src/llseek.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_llseek(linux_fd_t fd, linux_uword_t offset_high, linux_uword_t offset_low, linux_loff_t* result, unsigned int whence);
4 | 


--------------------------------------------------------------------------------
/src/move_pages.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_move_pages(linux_pid_t pid, linux_uword_t nr_pages, void const** pages, int const* nodes, int* status, int flags);
4 | 


--------------------------------------------------------------------------------
/src/msgrcv.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_msgrcv(int msqid, struct linux_msgbuf* msgp, linux_size_t msgsz, linux_word_t msgtyp, int msgflg, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/name_to_handle_at.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_name_to_handle_at(linux_fd_t dfd, char const* name, struct linux_file_handle* handle, int* mnt_id, int flag);
4 | 


--------------------------------------------------------------------------------
/src/prctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_prctl(int option, linux_uword_t arg2, linux_uword_t arg3, linux_uword_t arg4, linux_uword_t arg5, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/sendfile64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sendfile64(linux_fd_t out_fd, linux_fd_t in_fd, linux_loff_t* offset, linux_size_t count, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/signalfd4_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_signalfd4_v(linux_fd_t ufd, linux_sigset_t* user_mask, linux_size_t sizemask, uint32_t flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/timerfd_settime.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timerfd_settime(linux_fd_t ufd, int flags, struct linux_itimerspec const* utmr, struct linux_itimerspec* otmr);
4 | 


--------------------------------------------------------------------------------
/src/epoll_wait.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_wait(linux_fd_t epfd, struct linux_epoll_event* events, uint32_t maxevents, int32_t timeout, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/epoll_wait_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_wait_v(linux_fd_t epfd, struct linux_epoll_event* events, uint32_t maxevents, int32_t timeout, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/kexec_load.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_kexec_load(linux_uword_t entry, linux_uword_t nr_segments, struct linux_kexec_segment* segments, linux_uword_t flags);
4 | 


--------------------------------------------------------------------------------
/src/keyctl.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_keyctl(int option, linux_uword_t arg2, linux_uword_t arg3, linux_uword_t arg4, linux_uword_t arg5, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/move_mount.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_move_mount(linux_fd_t from_dfd, char const* from_path, linux_fd_t to_dfd, char const* to_path, unsigned int ms_flags);
4 | 


--------------------------------------------------------------------------------
/src/prlimit64.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_prlimit64(linux_pid_t pid, unsigned int resource, struct linux_rlimit64 const* new_rlim, struct linux_rlimit64* old_rlim);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigaction.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigaction(uint32_t sig, struct linux_sigaction const* act, struct linux_sigaction* oact, linux_size_t sigsetsize);
4 | 


--------------------------------------------------------------------------------
/src/timer_create.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timer_create(linux_clockid_t which_clock, struct linux_sigevent* timer_event_spec, linux_timer_t* created_timer_id);
4 | 


--------------------------------------------------------------------------------
/src/timer_settime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timer_settime32(linux_timer_t timer_id, int flags, struct linux_itimerspec32* new, struct linux_itimerspec32* old);
4 | 


--------------------------------------------------------------------------------
/src/vmsplice.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_vmsplice(linux_fd_t fd, struct linux_iovec const* uiov, linux_uword_t nr_segs, unsigned int flags, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/clock_nanosleep.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_nanosleep(linux_clockid_t which_clock, int flags, struct linux_timespec const* rqtp, struct linux_timespec* rmtp);
4 | 


--------------------------------------------------------------------------------
/src/futex.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_futex(uint32_t* uaddr, int op, uint32_t val, struct linux_timespec* utime, uint32_t* uaddr2, uint32_t val3, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/ipc.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ipc(unsigned int call, int first, linux_uword_t second, linux_uword_t third, void* ptr, linux_word_t fifth, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/mount_setattr.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mount_setattr(linux_fd_t dfd, char const* path, unsigned int flags, struct linux_mount_attr* uattr, linux_size_t usize);
4 | 


--------------------------------------------------------------------------------
/src/remap_file_pages.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_remap_file_pages(linux_uword_t start, linux_uword_t size, linux_uword_t prot, linux_uword_t pgoff, linux_uword_t flags);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigaction_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigaction_v(uint32_t sig, struct linux_sigaction const* act, struct linux_sigaction* oact, linux_size_t sigsetsize);
4 | 


--------------------------------------------------------------------------------
/src/select.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_select(uint32_t n, linux_fd_set* inp, linux_fd_set* outp, linux_fd_set* exp, struct linux_old_timeval* tvp, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/select_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_select_v(uint32_t n, linux_fd_set* inp, linux_fd_set* outp, linux_fd_set* exp, struct linux_old_timeval* tvp, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/semtimedop_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_semtimedop_time32(int semid, struct linux_sembuf* tsems, unsigned int nsops, struct linux_timespec32 const* timeout);
4 | 


--------------------------------------------------------------------------------
/src/timerfd_settime32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timerfd_settime32(linux_fd_t ufd, int flags, struct linux_itimerspec32 const* utmr, struct linux_itimerspec32* otmr);
4 | 


--------------------------------------------------------------------------------
/src/clone.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clone(linux_uword_t clone_flags, linux_uword_t newsp, int* parent_tidptr, int* child_tidptr, linux_uword_t tls, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/recvfrom.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_recvfrom(linux_fd_t fd, void* ubuf, linux_size_t size, unsigned int flags, struct linux_sockaddr* addr, int* addr_len, int* result);
4 | 


--------------------------------------------------------------------------------
/src/mbind.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mbind(linux_uword_t start, linux_uword_t len, linux_uword_t mode, linux_uword_t const* nmask, linux_uword_t maxnode, unsigned int flags);
4 | 


--------------------------------------------------------------------------------
/src/migrate_pages.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_migrate_pages(linux_pid_t pid, linux_uword_t maxnode, linux_uword_t const* old_nodes, linux_uword_t const* new_nodes, int* result);
4 | 


--------------------------------------------------------------------------------
/src/pselect6.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pselect6(uint32_t n, linux_fd_set* inp, linux_fd_set* outp, linux_fd_set* exp, struct linux_timespec* tsp, void* sig, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/recvmmsg.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_recvmmsg(linux_fd_t fd, struct linux_mmsghdr* mmsg, unsigned int vlen, unsigned int flags, struct linux_timespec* timeout, int* result);
4 | 


--------------------------------------------------------------------------------
/src/request_key.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_request_key(char const* type, char const* description, char const* callout_info, linux_key_serial_t destringid, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/sendto.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_sendto(linux_fd_t fd, void const* buff, linux_size_t len, unsigned int flags, struct linux_sockaddr const* addr, int addr_le, int* result);
4 | 


--------------------------------------------------------------------------------
/src/timer_settime.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_timer_settime(linux_timer_t timer_id, int flags, struct linux_itimerspec const* new_setting, struct linux_itimerspec* old_setting);
4 | 


--------------------------------------------------------------------------------
/src/add_key.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_add_key(char const* type, char const* description, void const* payload, linux_size_t plen, linux_key_serial_t ringid, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/futex_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_futex_time32(uint32_t* uaddr, int op, uint32_t val, struct linux_timespec32* utime, uint32_t* uaddr2, uint32_t val3, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/kexec_file_load.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_kexec_file_load(linux_fd_t kernel_fd, linux_fd_t initrd_fd, linux_uword_t cmdline_len, char const* cmdline_ptr, linux_uword_t flags);
4 | 


--------------------------------------------------------------------------------
/src/mmap.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mmap(linux_uword_t addr, linux_uword_t len, linux_uword_t prot, linux_uword_t flags, linux_uword_t fd, linux_uword_t off, linux_uword_t* result);
4 | 


--------------------------------------------------------------------------------
/src/mremap.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mremap(linux_uword_t addr, linux_uword_t old_len, linux_uword_t new_len, linux_uword_t flags, linux_uword_t new_addr, linux_uword_t* result);
4 | 


--------------------------------------------------------------------------------
/src/preadv.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_preadv(linux_uword_t fd, struct linux_iovec const* vec, linux_uword_t vlen, linux_uword_t pos_l, linux_uword_t pos_h, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pselect6_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pselect6_v(uint32_t n, linux_fd_set* inp, linux_fd_set* outp, linux_fd_set* exp, struct linux_timespec* tsp, void* sig, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pwritev.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pwritev(linux_uword_t fd, struct linux_iovec const* vec, linux_uword_t vlen, linux_uword_t pos_l, linux_uword_t pos_h, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/clock_nanosleep_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_clock_nanosleep_time32(linux_clockid_t which_clock, int flags, struct linux_timespec32 const* rqtp, struct linux_timespec32* rmtp);
4 | 


--------------------------------------------------------------------------------
/src/mq_timedsend.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mq_timedsend(linux_mqd_t mqdes, char const* u_msg_ptr, linux_size_t msg_len, unsigned int msg_prio, struct linux_timespec const* u_abs_timeout);
4 | 


--------------------------------------------------------------------------------
/src/ppoll.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ppoll(struct linux_pollfd* ufds, uint32_t nfds, struct linux_timespec* tsp, linux_sigset_t const* sigmask, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/splice.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_splice(linux_fd_t fd_in, linux_loff_t* off_in, linux_fd_t fd_out, linux_loff_t* off_out, linux_size_t len, unsigned int flags, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/landlock_create_ruleset.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_landlock_create_ruleset(struct linux_landlock_ruleset_attr const* const attr, linux_size_t const size, uint32_t const flags, int* result);
4 | 


--------------------------------------------------------------------------------
/src/perf_event_open.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_perf_event_open(struct linux_perf_event_attr* attr_uptr, linux_pid_t pid, int cpu, linux_fd_t group_fd, linux_uword_t flags, linux_fd_t* result);
4 | 


--------------------------------------------------------------------------------
/src/ppoll_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ppoll_v(struct linux_pollfd* ufds, uint32_t nfds, struct linux_timespec* tsp, linux_sigset_t const* sigmask, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pselect6_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pselect6_time32(uint32_t n, linux_fd_set* inp, linux_fd_set* outp, linux_fd_set* exp, struct linux_timespec32* tsp, void* sig, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/recvmmsg_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_recvmmsg_time32(linux_fd_t fd, struct linux_mmsghdr* mmsg, unsigned int vlen, unsigned int flags, struct linux_timespec32* timeout, int* result);
4 | 


--------------------------------------------------------------------------------
/src/io_uring_enter.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_uring_enter(linux_fd_t fd, uint32_t to_submit, uint32_t min_complete, uint32_t flags, linux_sigset_t const* sig, linux_size_t sigsz, int* result);
4 | 


--------------------------------------------------------------------------------
/src/landlock_add_rule.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_landlock_add_rule(linux_fd_t const ruleset_fd, enum linux_landlock_rule_type const rule_type, void const* const rule_attr, uint32_t const flags);
4 | 


--------------------------------------------------------------------------------
/src/mmap_pgoff.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mmap_pgoff(linux_uword_t addr, linux_uword_t len, linux_uword_t prot, linux_uword_t flags, linux_uword_t fd, linux_uword_t pgoff, linux_uword_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pselect6_time32_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pselect6_time32_v(uint32_t n, linux_fd_set* inp, linux_fd_set* outp, linux_fd_set* exp, struct linux_timespec32* tsp, void* sig, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigtimedwait.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigtimedwait(linux_sigset_t const* uthese, linux_siginfo_t* uinfo, struct linux_timespec const* uts, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigtimedwait_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigtimedwait_v(linux_sigset_t const* uthese, linux_siginfo_t* uinfo, struct linux_timespec const* uts, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_getevents.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_getevents(linux_aio_context_t ctx_id, linux_word_t min_nr, linux_word_t nr, struct linux_io_event* events, struct linux_timespec* timeout, int* result);
4 | 


--------------------------------------------------------------------------------
/src/ppoll_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ppoll_time32(struct linux_pollfd* ufds, uint32_t nfds, struct linux_timespec32* tsp, linux_sigset_t const* sigmask, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/preadv2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_preadv2(linux_uword_t fd, struct linux_iovec const* vec, linux_uword_t vlen, linux_uword_t pos_l, linux_uword_t pos_h, linux_rwf_t flags, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/pwritev2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_pwritev2(linux_uword_t fd, struct linux_iovec const* vec, linux_uword_t vlen, linux_uword_t pos_l, linux_uword_t pos_h, linux_rwf_t flags, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/copy_file_range.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_copy_file_range(linux_fd_t fd_in, linux_loff_t* off_in, linux_fd_t fd_out, linux_loff_t* off_out, linux_size_t len, unsigned int flags, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/mq_timedreceive.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mq_timedreceive(linux_mqd_t mqdes, char* u_msg_ptr, linux_size_t msg_len, unsigned int* u_msg_prio, struct linux_timespec const* u_abs_timeout, int* result);
4 | 


--------------------------------------------------------------------------------
/src/mq_timedsend_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mq_timedsend_time32(linux_mqd_t mqdes, char const* u_msg_ptr, unsigned int msg_len, unsigned int msg_prio, struct linux_timespec32 const* u_abs_timeout);
4 | 


--------------------------------------------------------------------------------
/src/ppoll_time32_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_ppoll_time32_v(struct linux_pollfd* ufds, uint32_t nfds, struct linux_timespec32* tsp, linux_sigset_t const* sigmask, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigtimedwait_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigtimedwait_time32(linux_sigset_t const* uthese, linux_siginfo_t* uinfo, struct linux_timespec32 const* uts, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/epoll_pwait.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_pwait(linux_fd_t epfd, struct linux_epoll_event* events, uint32_t maxevents, int32_t timeout, linux_sigset_t const* sigmask, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_getevents_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_getevents_time32(linux_aio_context_t ctx_id, linux_word_t min_nr, linux_word_t nr, struct linux_io_event* events, struct linux_timespec32* timeout, int* result);
4 | 


--------------------------------------------------------------------------------
/src/process_madvise.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_process_madvise(int const pidfd, struct linux_iovec const* const vec, linux_size_t const vlen, int const behavior, unsigned int const flags, linux_size_t* const result);
4 | 


--------------------------------------------------------------------------------
/src/rt_sigtimedwait_time32_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_rt_sigtimedwait_time32_v(linux_sigset_t const* uthese, linux_siginfo_t* uinfo, struct linux_timespec32 const* uts, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/epoll_pwait_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_pwait_v(linux_fd_t epfd, struct linux_epoll_event* events, uint32_t maxevents, int32_t timeout, linux_sigset_t const* sigmask, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_getevents_time32_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_getevents_time32_v(linux_aio_context_t ctx_id, linux_word_t min_nr, linux_word_t nr, struct linux_io_event* events, struct linux_timespec32* timeout, int* result);
4 | 


--------------------------------------------------------------------------------
/src/mq_timedreceive_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_mq_timedreceive_time32(linux_mqd_t mqdes, char* u_msg_ptr, unsigned int msg_len, unsigned int* u_msg_prio, struct linux_timespec32 const* u_abs_timeout, int* result);
4 | 


--------------------------------------------------------------------------------
/TODO:
--------------------------------------------------------------------------------
1 | - Support ARM Thumb mode
2 | - Clean up the types in linux.h (i.e. use stdint.h types instead of int/long/etc)
3 | - Are the specific tests in endian.h for arm and arm64 necessary?
4 | - Seperate old and deprecated stuff (constants, types, syscalls, ...) from the modern stuff
5 | 


--------------------------------------------------------------------------------
/src/process_vm_readv.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_process_vm_readv(linux_pid_t pid, struct linux_iovec const* lvec, linux_uword_t liovcnt, struct linux_iovec const* rvec, linux_uword_t riovcnt, linux_uword_t flags, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/process_vm_writev.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_process_vm_writev(linux_pid_t pid, struct linux_iovec const* lvec, linux_uword_t liovcnt, struct linux_iovec const* rvec, linux_uword_t riovcnt, linux_uword_t flags, linux_ssize_t* result);
4 | 


--------------------------------------------------------------------------------
/src/epoll_pwait2.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_epoll_pwait2(linux_fd_t epfd, struct linux_epoll_event* events, uint32_t maxevents, struct linux_timespec const* timeout, linux_sigset_t const* sigmask, linux_size_t sigsetsize, uint32_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_pgetevents.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_pgetevents(linux_aio_context_t ctx_id, linux_word_t min_nr, linux_word_t nr, struct linux_io_event* events, struct linux_timespec* timeout, struct linux_aio_sigset const* usig, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/PORTING:
--------------------------------------------------------------------------------
1 | If you are porting to a new architecture, do not forget to:
2 | - Add a test function to tests/compile.c for the new arch where ALL syscalls are being called
3 | 
4 | - update the README
5 | - port the test suite
6 | - create a new default config
7 | - run the test suite
8 | - fix errors
9 | 


--------------------------------------------------------------------------------
/src/io_pgetevents_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_pgetevents_v(linux_aio_context_t ctx_id, linux_word_t min_nr, linux_word_t nr, struct linux_io_event* events, struct linux_timespec* timeout, struct linux_aio_sigset const* usig, linux_word_t* result);
4 | 


--------------------------------------------------------------------------------
/src/io_pgetevents_time32.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_pgetevents_time32(linux_aio_context_t ctx_id, linux_word_t min_nr, linux_word_t nr, struct linux_io_event* events, struct linux_timespec32* timeout, struct linux_aio_sigset const* usig, int* result);
4 | 


--------------------------------------------------------------------------------
/src/io_pgetevents_time32_v.c:
--------------------------------------------------------------------------------
1 | #include <liblinux/linux.h>
2 | 
3 | extern inline linux_error_t linux_io_pgetevents_time32_v(linux_aio_context_t ctx_id, linux_word_t min_nr, linux_word_t nr, struct linux_io_event* events, struct linux_timespec32* timeout, struct linux_aio_sigset const* usig, int* result);
4 | 


--------------------------------------------------------------------------------
/tests/syscalls/acct.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_acct(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/brk.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_brk(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/dup.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_dup(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/iopl.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_iopl(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/pipe.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_pipe(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/sync.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_sync() == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/usr26.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_usr26() == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/usr32.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_usr32() == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/alarm.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_alarm(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/bind.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_bind(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/chdir.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_chdir(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/chmod.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_chmod(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/chroot.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_chroot(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/dup2.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_dup2(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fchdir.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fchdir(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/flock.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_flock(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fstat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fstat(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fsync.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fsync(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/get_tls.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_get_tls(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getegid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getegid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/geteuid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_geteuid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getgid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getgid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getpgrp.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getpgrp(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getppid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getppid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/gettid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_gettid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getuid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getuid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/kill.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_kill(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/link.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_link(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/lstat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_lstat(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/mkdir.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_mkdir(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/mlock.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_mlock(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/nice.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_nice(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/rmdir.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_rmdir(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/set_tls.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_set_tls(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setgid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setgid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setns.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setns(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setsid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setsid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setuid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setuid(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/shmdt.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_shmdt(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/stat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_stat(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/stime32.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_stime32(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/swapoff.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_swapoff(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/syncfs.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_syncfs(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/sysinfo.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_sysinfo(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/time.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_time(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/times.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_times(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/tkill.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_tkill(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/umask.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_umask(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/uname.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_uname(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/unlink.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_unlink(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/unshare.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_unshare(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/uselib.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_uselib(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/ustat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_ustat(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/utime.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_utime(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/vhangup.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_vhangup() == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/vm86.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_vm86(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/vm86old.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_vm86old(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/adjtimex.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_adjtimex(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/bdflush.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_bdflush(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/bpf.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_bpf(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/capget.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_capget(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/capset.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_capset(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/chown.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_chown(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/clone3.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_clone3(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/creat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_creat(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/eventfd.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_eventfd(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/execve.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_execve(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fchmod.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fchmod(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fchown.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fchown(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fcntl.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fcntl(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fdatasync.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fdatasync(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fsopen.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fsopen(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fstat64.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fstat64(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fstatfs.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fstatfs(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getcpu.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getcpu(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getcwd.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getcwd(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getegid16.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getegid16(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/geteuid16.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_geteuid16(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getgid16.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getgid16(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getpgid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getpgid(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getsid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getsid(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getuid16.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getuid16(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/io_setup.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_io_setup(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/ioperm.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_ioperm(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/lchown.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_lchown(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/listen.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_listen(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/lseek.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_lseek(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/lstat64.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_lstat64(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/mknod.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_mknod(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/mlock2.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_mlock2(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/mlockall.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_mlockall(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/msgget.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_msgget(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/msync.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_msync(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/munlock.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_munlock(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/munlockall.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_munlockall() == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/munmap.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_munmap(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/newfstat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_newfstat(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/newlstat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_newlstat(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/newstat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_newstat(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/newuname.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_newuname(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/old_mmap.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_old_mmap(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/oldumount.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_oldumount(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/olduname.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_olduname(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/open.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_open(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/pkey_free.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_pkey_free(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/poll.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_poll(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/read.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_read(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/readv.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_readv(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/rename.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_rename(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/semop.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_semop(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setfsgid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setfsgid(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setfsuid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setfsuid(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setgid16.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setgid16(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setpgid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setpgid(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setregid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setregid(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setreuid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setreuid(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/setuid16.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_setuid16(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/sgetmask.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_sgetmask(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/shmat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_shmat(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/shutdown.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_shutdown(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/signal.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_signal(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/ssetmask.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_ssetmask(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/stat64.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_stat64(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/statfs.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_statfs(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/swapon.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_swapon(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/symlink.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_symlink(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/sysfs.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_sysfs(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/tee.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_tee(0, 0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/tgkill.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_tgkill(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/time32.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_time32(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/truncate.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_truncate(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/umount.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_umount(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/utime32.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_utime32(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/utimes.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_utimes(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/write.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_write(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/arch_prctl.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_arch_prctl(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/chown16.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_chown16(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/connect.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_connect(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/eventfd2.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_eventfd2(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/faccessat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_faccessat(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fchmodat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fchmodat(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fchown16.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fchown16(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fcntl64.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fcntl64(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fsmount.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fsmount(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fspick.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fspick(0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/fstatfs64.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_fstatfs64(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/ftruncate.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_ftruncate(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/futimesat.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_futimesat(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getgroups.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getgroups(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getitimer.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getitimer(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getresgid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getresgid(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getresuid.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getresuid(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getrlimit.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getrlimit(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/getrusage.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_getrusage(0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/inotify_init.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_inotify_init(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/io_cancel.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_io_cancel(0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/io_destroy.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_io_destroy(0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/ipc.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_ipc(0, 0, 0, 0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------
/tests/syscalls/kcmp.c:
--------------------------------------------------------------------------------
 1 | #include "test.h"
 2 | 
 3 | static enum TestResult test_available(void)
 4 | {
 5 | 	if (linux_kcmp(0, 0, 0, 0, 0, 0) == linux_ENOSYS)
 6 | 		return TEST_NOT_SUPPORTED;
 7 | 
 8 | 	return TEST_SUCCESS;
 9 | }
10 | 
11 | BEGIN_TEST()
12 | 	DO_TEST(test_available, "Syscall is available");
13 | END_TEST()
14 | 


--------------------------------------------------------------------------------