diff options
Diffstat (limited to 'lib/mlibc/sysdeps/linux')
94 files changed, 7059 insertions, 0 deletions
diff --git a/lib/mlibc/sysdeps/linux/aarch64/arch-syscall.cpp b/lib/mlibc/sysdeps/linux/aarch64/arch-syscall.cpp new file mode 100644 index 0000000..b178538 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/arch-syscall.cpp @@ -0,0 +1,117 @@ +#include <sys/syscall.h> +#include <bits/syscall.h> + +using sc_word_t = __sc_word_t; + +sc_word_t __do_syscall0(long sc) { + register int sc_reg asm("x8") = sc; + register sc_word_t ret asm("x0"); + asm volatile ("svc 0" : "=r"(ret) : "r"(sc_reg) : "memory"); + return ret; +} + +sc_word_t __do_syscall1(long sc, + sc_word_t arg1) { + register int sc_reg asm("x8") = sc; + register sc_word_t arg1_reg asm("x0") = arg1; + register sc_word_t ret asm("x0"); + asm volatile ("svc 0" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall2(long sc, + sc_word_t arg1, sc_word_t arg2) { + register int sc_reg asm("x8") = sc; + register sc_word_t arg1_reg asm("x0") = arg1; + register sc_word_t arg2_reg asm("x1") = arg2; + register sc_word_t ret asm("x0"); + asm volatile ("svc 0" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall3(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3) { + register int sc_reg asm("x8") = sc; + register sc_word_t arg1_reg asm("x0") = arg1; + register sc_word_t arg2_reg asm("x1") = arg2; + register sc_word_t arg3_reg asm("x2") = arg3; + register sc_word_t ret asm("x0"); + asm volatile ("svc 0" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg), + "r"(arg3_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall4(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4) { + register int sc_reg asm("x8") = sc; + register sc_word_t arg1_reg asm("x0") = arg1; + register sc_word_t arg2_reg asm("x1") = arg2; + register sc_word_t arg3_reg asm("x2") = arg3; + register sc_word_t arg4_reg asm("x3") = arg4; + register sc_word_t ret asm("x0"); + asm volatile ("svc 0" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg), + "r"(arg3_reg), + "r"(arg4_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall5(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5) { + register int sc_reg asm("x8") = sc; + register sc_word_t arg1_reg asm("x0") = arg1; + register sc_word_t arg2_reg asm("x1") = arg2; + register sc_word_t arg3_reg asm("x2") = arg3; + register sc_word_t arg4_reg asm("x3") = arg4; + register sc_word_t arg5_reg asm("x4") = arg5; + register sc_word_t ret asm("x0"); + asm volatile ("svc 0" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg), + "r"(arg3_reg), + "r"(arg4_reg), + "r"(arg5_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall6(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5, sc_word_t arg6) { + register int sc_reg asm("x8") = sc; + register sc_word_t arg1_reg asm("x0") = arg1; + register sc_word_t arg2_reg asm("x1") = arg2; + register sc_word_t arg3_reg asm("x2") = arg3; + register sc_word_t arg4_reg asm("x3") = arg4; + register sc_word_t arg5_reg asm("x4") = arg5; + register sc_word_t arg6_reg asm("x5") = arg6; + register sc_word_t ret asm("x0"); + asm volatile ("svc 0" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg), + "r"(arg3_reg), + "r"(arg4_reg), + "r"(arg5_reg), + "r"(arg6_reg) + : "memory" + ); + return ret; +} diff --git a/lib/mlibc/sysdeps/linux/aarch64/cp_syscall.S b/lib/mlibc/sysdeps/linux/aarch64/cp_syscall.S new file mode 100644 index 0000000..98690c7 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/cp_syscall.S @@ -0,0 +1,31 @@ +.section .text +.global __mlibc_do_asm_cp_syscall +.global __mlibc_syscall_begin +.global __mlibc_syscall_end +.type __mlibc_do_asm_cp_syscall, "function" +__mlibc_do_asm_cp_syscall: + mov x8, x0 + mov x0, x1 + mov x1, x2 + mov x2, x3 + mov x3, x4 + mov x4, x5 + mov x5, x6 + + mrs x7, tpidr_el0 + ldr w7, [x7, #-80] // Tcb::cancelBits. See asserts in tcb.hpp. +__mlibc_syscall_begin: + // tcbCancelEnableBit && tcbCancelTriggerBit + mov x9, #((1 << 0) | (1 << 2)) + and x7, x7, x9 + cmp x7, x9 + b.eq cancel + svc 0 +__mlibc_syscall_end: + ret + +cancel: + bl __mlibc_do_cancel + brk #0 +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/aarch64/crt-src/Scrt1.S b/lib/mlibc/sysdeps/linux/aarch64/crt-src/Scrt1.S new file mode 100644 index 0000000..547499e --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/crt-src/Scrt1.S @@ -0,0 +1,11 @@ +.section .text +.global _start +_start: + mov x0, sp + adr x1, main + + bl __mlibc_entry + brk #0 + +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/aarch64/crt-src/crt1.S b/lib/mlibc/sysdeps/linux/aarch64/crt-src/crt1.S new file mode 100644 index 0000000..6550612 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/crt-src/crt1.S @@ -0,0 +1,9 @@ +.section .text +.global _start +_start: + mov x0, sp + adrp x1, main + add x1, x1, :lo12:main + bl __mlibc_entry +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/aarch64/crt-src/crti.S b/lib/mlibc/sysdeps/linux/aarch64/crt-src/crti.S new file mode 100644 index 0000000..0f5ca0f --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/crt-src/crti.S @@ -0,0 +1,13 @@ +.section .init +.global _init +_init: + stp x29, x30, [sp, -16]! + mov x29, sp + +.section .fini +.global _fini +_fini: + stp x29, x30, [sp, -16]! + mov x29, sp +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/aarch64/crt-src/crtn.S b/lib/mlibc/sysdeps/linux/aarch64/crt-src/crtn.S new file mode 100644 index 0000000..cd95321 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/crt-src/crtn.S @@ -0,0 +1,9 @@ +.section .init + ldp x29, x30, [sp], #16 + ret + +.section .fini + ldp x29, x30, [sp], #16 + ret +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/aarch64/signals.S b/lib/mlibc/sysdeps/linux/aarch64/signals.S new file mode 100644 index 0000000..923d8d7 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/signals.S @@ -0,0 +1,12 @@ +.section .text + +.global __mlibc_signal_restore +.type __mlibc_signal_restore, @function +__mlibc_signal_restore: +.global __mlibc_signal_restore_rt +.type __mlibc_signal_restore_rt, @function +__mlibc_signal_restore_rt: + mov x8,#139 // SYS_rt_sigreturn + svc 0 +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/aarch64/syscallnos.h b/lib/mlibc/sysdeps/linux/aarch64/syscallnos.h new file mode 100644 index 0000000..9df2598 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/syscallnos.h @@ -0,0 +1,313 @@ +#ifndef __MLIBC_SYSCALLNOS_h +#define __MLIBC_SYSCALLNOS_h +/* This file is autogenerated. Don't bother. */ +/* Generator script: sysdeps/linux/update-syscall-list.py. */ +#define __NR_io_setup 0 +#define __NR_io_destroy 1 +#define __NR_io_submit 2 +#define __NR_io_cancel 3 +#define __NR_io_getevents 4 +#define __NR_setxattr 5 +#define __NR_lsetxattr 6 +#define __NR_fsetxattr 7 +#define __NR_getxattr 8 +#define __NR_lgetxattr 9 +#define __NR_fgetxattr 10 +#define __NR_listxattr 11 +#define __NR_llistxattr 12 +#define __NR_flistxattr 13 +#define __NR_removexattr 14 +#define __NR_lremovexattr 15 +#define __NR_fremovexattr 16 +#define __NR_getcwd 17 +#define __NR_lookup_dcookie 18 +#define __NR_eventfd2 19 +#define __NR_epoll_create1 20 +#define __NR_epoll_ctl 21 +#define __NR_epoll_pwait 22 +#define __NR_dup 23 +#define __NR_dup3 24 +#define __NR_fcntl 25 +#define __NR_inotify_init1 26 +#define __NR_inotify_add_watch 27 +#define __NR_inotify_rm_watch 28 +#define __NR_ioctl 29 +#define __NR_ioprio_set 30 +#define __NR_ioprio_get 31 +#define __NR_flock 32 +#define __NR_mknodat 33 +#define __NR_mkdirat 34 +#define __NR_unlinkat 35 +#define __NR_symlinkat 36 +#define __NR_linkat 37 +#define __NR_renameat 38 +#define __NR_umount2 39 +#define __NR_mount 40 +#define __NR_pivot_root 41 +#define __NR_nfsservctl 42 +#define __NR_statfs 43 +#define __NR_fstatfs 44 +#define __NR_truncate 45 +#define __NR_ftruncate 46 +#define __NR_fallocate 47 +#define __NR_faccessat 48 +#define __NR_chdir 49 +#define __NR_fchdir 50 +#define __NR_chroot 51 +#define __NR_fchmod 52 +#define __NR_fchmodat 53 +#define __NR_fchownat 54 +#define __NR_fchown 55 +#define __NR_openat 56 +#define __NR_close 57 +#define __NR_vhangup 58 +#define __NR_pipe2 59 +#define __NR_quotactl 60 +#define __NR_getdents64 61 +#define __NR_lseek 62 +#define __NR_read 63 +#define __NR_write 64 +#define __NR_readv 65 +#define __NR_writev 66 +#define __NR_pread64 67 +#define __NR_pwrite64 68 +#define __NR_preadv 69 +#define __NR_pwritev 70 +#define __NR_sendfile 71 +#define __NR_pselect6 72 +#define __NR_ppoll 73 +#define __NR_signalfd4 74 +#define __NR_vmsplice 75 +#define __NR_splice 76 +#define __NR_tee 77 +#define __NR_readlinkat 78 +#define __NR_newfstatat 79 +#define __NR_fstat 80 +#define __NR_sync 81 +#define __NR_fsync 82 +#define __NR_fdatasync 83 +#define __NR_sync_file_range 84 +#define __NR_timerfd_create 85 +#define __NR_timerfd_settime 86 +#define __NR_timerfd_gettime 87 +#define __NR_utimensat 88 +#define __NR_acct 89 +#define __NR_capget 90 +#define __NR_capset 91 +#define __NR_personality 92 +#define __NR_exit 93 +#define __NR_exit_group 94 +#define __NR_waitid 95 +#define __NR_set_tid_address 96 +#define __NR_unshare 97 +#define __NR_futex 98 +#define __NR_set_robust_list 99 +#define __NR_get_robust_list 100 +#define __NR_nanosleep 101 +#define __NR_getitimer 102 +#define __NR_setitimer 103 +#define __NR_kexec_load 104 +#define __NR_init_module 105 +#define __NR_delete_module 106 +#define __NR_timer_create 107 +#define __NR_timer_gettime 108 +#define __NR_timer_getoverrun 109 +#define __NR_timer_settime 110 +#define __NR_timer_delete 111 +#define __NR_clock_settime 112 +#define __NR_clock_gettime 113 +#define __NR_clock_getres 114 +#define __NR_clock_nanosleep 115 +#define __NR_syslog 116 +#define __NR_ptrace 117 +#define __NR_sched_setparam 118 +#define __NR_sched_setscheduler 119 +#define __NR_sched_getscheduler 120 +#define __NR_sched_getparam 121 +#define __NR_sched_setaffinity 122 +#define __NR_sched_getaffinity 123 +#define __NR_sched_yield 124 +#define __NR_sched_get_priority_max 125 +#define __NR_sched_get_priority_min 126 +#define __NR_sched_rr_get_interval 127 +#define __NR_restart_syscall 128 +#define __NR_kill 129 +#define __NR_tkill 130 +#define __NR_tgkill 131 +#define __NR_sigaltstack 132 +#define __NR_rt_sigsuspend 133 +#define __NR_rt_sigaction 134 +#define __NR_rt_sigprocmask 135 +#define __NR_rt_sigpending 136 +#define __NR_rt_sigtimedwait 137 +#define __NR_rt_sigqueueinfo 138 +#define __NR_rt_sigreturn 139 +#define __NR_setpriority 140 +#define __NR_getpriority 141 +#define __NR_reboot 142 +#define __NR_setregid 143 +#define __NR_setgid 144 +#define __NR_setreuid 145 +#define __NR_setuid 146 +#define __NR_setresuid 147 +#define __NR_getresuid 148 +#define __NR_setresgid 149 +#define __NR_getresgid 150 +#define __NR_setfsuid 151 +#define __NR_setfsgid 152 +#define __NR_times 153 +#define __NR_setpgid 154 +#define __NR_getpgid 155 +#define __NR_getsid 156 +#define __NR_setsid 157 +#define __NR_getgroups 158 +#define __NR_setgroups 159 +#define __NR_uname 160 +#define __NR_sethostname 161 +#define __NR_setdomainname 162 +#define __NR_getrlimit 163 +#define __NR_setrlimit 164 +#define __NR_getrusage 165 +#define __NR_umask 166 +#define __NR_prctl 167 +#define __NR_getcpu 168 +#define __NR_gettimeofday 169 +#define __NR_settimeofday 170 +#define __NR_adjtimex 171 +#define __NR_getpid 172 +#define __NR_getppid 173 +#define __NR_getuid 174 +#define __NR_geteuid 175 +#define __NR_getgid 176 +#define __NR_getegid 177 +#define __NR_gettid 178 +#define __NR_sysinfo 179 +#define __NR_mq_open 180 +#define __NR_mq_unlink 181 +#define __NR_mq_timedsend 182 +#define __NR_mq_timedreceive 183 +#define __NR_mq_notify 184 +#define __NR_mq_getsetattr 185 +#define __NR_msgget 186 +#define __NR_msgctl 187 +#define __NR_msgrcv 188 +#define __NR_msgsnd 189 +#define __NR_semget 190 +#define __NR_semctl 191 +#define __NR_semtimedop 192 +#define __NR_semop 193 +#define __NR_shmget 194 +#define __NR_shmctl 195 +#define __NR_shmat 196 +#define __NR_shmdt 197 +#define __NR_socket 198 +#define __NR_socketpair 199 +#define __NR_bind 200 +#define __NR_listen 201 +#define __NR_accept 202 +#define __NR_connect 203 +#define __NR_getsockname 204 +#define __NR_getpeername 205 +#define __NR_sendto 206 +#define __NR_recvfrom 207 +#define __NR_setsockopt 208 +#define __NR_getsockopt 209 +#define __NR_shutdown 210 +#define __NR_sendmsg 211 +#define __NR_recvmsg 212 +#define __NR_readahead 213 +#define __NR_brk 214 +#define __NR_munmap 215 +#define __NR_mremap 216 +#define __NR_add_key 217 +#define __NR_request_key 218 +#define __NR_keyctl 219 +#define __NR_clone 220 +#define __NR_execve 221 +#define __NR_mmap 222 +#define __NR_fadvise64 223 +#define __NR_swapon 224 +#define __NR_swapoff 225 +#define __NR_mprotect 226 +#define __NR_msync 227 +#define __NR_mlock 228 +#define __NR_munlock 229 +#define __NR_mlockall 230 +#define __NR_munlockall 231 +#define __NR_mincore 232 +#define __NR_madvise 233 +#define __NR_remap_file_pages 234 +#define __NR_mbind 235 +#define __NR_get_mempolicy 236 +#define __NR_set_mempolicy 237 +#define __NR_migrate_pages 238 +#define __NR_move_pages 239 +#define __NR_rt_tgsigqueueinfo 240 +#define __NR_perf_event_open 241 +#define __NR_accept4 242 +#define __NR_recvmmsg 243 +#define __NR_arch_specific_syscall 244 +#define __NR_wait4 260 +#define __NR_prlimit64 261 +#define __NR_fanotify_init 262 +#define __NR_fanotify_mark 263 +#define __NR_name_to_handle_at 264 +#define __NR_open_by_handle_at 265 +#define __NR_clock_adjtime 266 +#define __NR_syncfs 267 +#define __NR_setns 268 +#define __NR_sendmmsg 269 +#define __NR_process_vm_readv 270 +#define __NR_process_vm_writev 271 +#define __NR_kcmp 272 +#define __NR_finit_module 273 +#define __NR_sched_setattr 274 +#define __NR_sched_getattr 275 +#define __NR_renameat2 276 +#define __NR_seccomp 277 +#define __NR_getrandom 278 +#define __NR_memfd_create 279 +#define __NR_bpf 280 +#define __NR_execveat 281 +#define __NR_userfaultfd 282 +#define __NR_membarrier 283 +#define __NR_mlock2 284 +#define __NR_copy_file_range 285 +#define __NR_preadv2 286 +#define __NR_pwritev2 287 +#define __NR_pkey_mprotect 288 +#define __NR_pkey_alloc 289 +#define __NR_pkey_free 290 +#define __NR_statx 291 +#define __NR_io_pgetevents 292 +#define __NR_rseq 293 +#define __NR_kexec_file_load 294 +#define __NR_pidfd_send_signal 424 +#define __NR_io_uring_setup 425 +#define __NR_io_uring_enter 426 +#define __NR_io_uring_register 427 +#define __NR_open_tree 428 +#define __NR_move_mount 429 +#define __NR_fsopen 430 +#define __NR_fsconfig 431 +#define __NR_fsmount 432 +#define __NR_fspick 433 +#define __NR_pidfd_open 434 +#define __NR_clone3 435 +#define __NR_close_range 436 +#define __NR_openat2 437 +#define __NR_pidfd_getfd 438 +#define __NR_faccessat2 439 +#define __NR_process_madvise 440 +#define __NR_epoll_pwait2 441 +#define __NR_mount_setattr 442 +#define __NR_quotactl_fd 443 +#define __NR_landlock_create_ruleset 444 +#define __NR_landlock_add_rule 445 +#define __NR_landlock_restrict_self 446 +#define __NR_memfd_secret 447 +#define __NR_process_mrelease 448 +#define __NR_futex_waitv 449 +#define __NR_set_mempolicy_home_node 450 +#define __NR_syscalls 451 +#endif /* __MLIBC_SYSCALLNOS_h */ diff --git a/lib/mlibc/sysdeps/linux/aarch64/thread_entry.S b/lib/mlibc/sysdeps/linux/aarch64/thread_entry.S new file mode 100644 index 0000000..a47a048 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/aarch64/thread_entry.S @@ -0,0 +1,27 @@ +.section .text +.global __mlibc_spawn_thread +.type __mlibc_spawn_thread, "function" +__mlibc_spawn_thread: + // __mlibc_spawn_thread(flags, stack, pid_out, child_tid, tls) + // x0, x1, x2, x3, x4 + // syscall(NR_clone, flags, stack, ptid, tls, ctid) + // x8, x0, x1, x2, x3, x4 + + // Swap x3 <-> x4 + mov x5, x4 + mov x4, x3 + mov x3, x5 + + mov x8, 220 // NR_clone + svc 0 + cbnz x0, .parent + + ldp x0, x1, [sp], #16 + + bl __mlibc_enter_thread + brk #0 + +.parent: + ret +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/generic/cxx-syscall.hpp b/lib/mlibc/sysdeps/linux/generic/cxx-syscall.hpp new file mode 100644 index 0000000..aa7d17c --- /dev/null +++ b/lib/mlibc/sysdeps/linux/generic/cxx-syscall.hpp @@ -0,0 +1,118 @@ +#pragma once + +#include <errno.h> +#include <mlibc/tcb.hpp> +#include <mlibc/thread.hpp> +#include <mlibc-config.h> +#include <utility> + +#include <sys/syscall.h> +#include <bits/syscall.h> + +using sc_word_t = __sc_word_t; + +extern "C" { + extern sc_word_t __mlibc_do_asm_cp_syscall(int sc, sc_word_t arg1, sc_word_t arg2, + sc_word_t arg3, sc_word_t arg4, sc_word_t arg5, sc_word_t arg6); + + extern void __mlibc_do_cancel(); +} + +namespace mlibc { + // C++ wrappers for the extern "C" functions. + inline sc_word_t do_nargs_syscall(int sc) { + return __do_syscall0(sc); + } + inline sc_word_t do_nargs_syscall(int sc, sc_word_t arg1) { + return __do_syscall1(sc, arg1); + } + inline sc_word_t do_nargs_syscall(int sc, sc_word_t arg1, sc_word_t arg2) { + return __do_syscall2(sc, arg1, arg2); + } + inline sc_word_t do_nargs_syscall(int sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3) { + return __do_syscall3(sc, arg1, arg2, arg3); + } + inline sc_word_t do_nargs_syscall(int sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4) { + return __do_syscall4(sc, arg1, arg2, arg3, arg4); + } + inline sc_word_t do_nargs_syscall(int sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5) { + return __do_syscall5(sc, arg1, arg2, arg3, arg4, arg5); + } + inline sc_word_t do_nargs_syscall(int sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5, sc_word_t arg6) { + return __do_syscall6(sc, arg1, arg2, arg3, arg4, arg5, arg6); + } + + inline sc_word_t do_nargs_cp_syscall(int sc, sc_word_t arg1) { + return __mlibc_do_asm_cp_syscall(sc, arg1, 0, 0, 0, 0, 0); + } + inline sc_word_t do_nargs_cp_syscall(int sc, sc_word_t arg1, sc_word_t arg2) { + return __mlibc_do_asm_cp_syscall(sc, arg1, arg2, 0, 0, 0, 0); + } + inline sc_word_t do_nargs_cp_syscall(int sc, sc_word_t arg1, sc_word_t arg2, + sc_word_t arg3) { + return __mlibc_do_asm_cp_syscall(sc, arg1, arg2, arg3, 0, 0, 0); + } + inline sc_word_t do_nargs_cp_syscall(int sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4) { + return __mlibc_do_asm_cp_syscall(sc, arg1, arg2, arg3, arg4, 0, 0); + } + inline sc_word_t do_nargs_cp_syscall(int sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5) { + return __mlibc_do_asm_cp_syscall(sc, arg1, arg2, arg3, arg4, arg5, 0); + } + inline sc_word_t do_nargs_cp_syscall(int sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5, sc_word_t arg6) { + return __mlibc_do_asm_cp_syscall(sc, arg1, arg2, arg3, arg4, arg5, arg6); + } + + // Type-safe syscall result type. + enum class sc_result_t : sc_word_t { }; + + // Cast to the argument type of the extern "C" functions. + inline sc_word_t sc_cast(long x) { return x; } + inline sc_word_t sc_cast(const void *x) { return reinterpret_cast<sc_word_t>(x); } + + template<typename... T> + sc_result_t do_syscall(int sc, T... args) { + return static_cast<sc_result_t>(do_nargs_syscall(sc, sc_cast(args)...)); + } + + inline int sc_error(sc_result_t ret) { + auto v = static_cast<sc_word_t>(ret); + if(static_cast<unsigned long>(v) > -4096UL) + return -v; + return 0; + } + + template<typename... T> + sc_result_t do_cp_syscall(int sc, T... args) { +#if __MLIBC_POSIX_OPTION && !MLIBC_BUILDING_RTDL + auto result = static_cast<sc_result_t>(do_nargs_cp_syscall(sc, sc_cast(args)...)); + if (int e = sc_error(result); e) { + auto tcb = reinterpret_cast<Tcb*>(get_current_tcb()); + if (tcb_cancelled(tcb->cancelBits) && e == EINTR) { + __mlibc_do_cancel(); + __builtin_unreachable(); + } + } + return result; +#else + return do_syscall(sc, std::forward<T>(args)...); +#endif // __MLIBC_POSIX_OPTION || !MLIBC_BUILDING_RTDL + } + // Cast from the syscall result type. + template<typename T> + T sc_int_result(sc_result_t ret) { + auto v = static_cast<sc_word_t>(ret); + return v; + } + + template<typename T> + T *sc_ptr_result(sc_result_t ret) { + auto v = static_cast<sc_word_t>(ret); + return reinterpret_cast<T *>(v); + } +} diff --git a/lib/mlibc/sysdeps/linux/generic/entry.cpp b/lib/mlibc/sysdeps/linux/generic/entry.cpp new file mode 100644 index 0000000..aa049ce --- /dev/null +++ b/lib/mlibc/sysdeps/linux/generic/entry.cpp @@ -0,0 +1,38 @@ +#include <stdint.h> +#include <stdlib.h> +#include <bits/ensure.h> +#include <mlibc/elf/startup.h> +#include <sys/auxv.h> + +// defined by the POSIX library +void __mlibc_initLocale(); + +extern "C" uintptr_t *__dlapi_entrystack(); +extern "C" void __dlapi_enter(uintptr_t *); + +extern char **environ; +static mlibc::exec_stack_data __mlibc_stack_data; + +size_t __hwcap; + +struct LibraryGuard { + LibraryGuard(); +}; + +static LibraryGuard guard; + +LibraryGuard::LibraryGuard() { + __mlibc_initLocale(); + + // Parse the exec() stack. + mlibc::parse_exec_stack(__dlapi_entrystack(), &__mlibc_stack_data); + mlibc::set_startup_data(__mlibc_stack_data.argc, __mlibc_stack_data.argv, + __mlibc_stack_data.envp); +} + +extern "C" void __mlibc_entry(uintptr_t *entry_stack, int (*main_fn)(int argc, char *argv[], char *env[])) { + __dlapi_enter(entry_stack); + __hwcap = getauxval(AT_HWCAP); + auto result = main_fn(__mlibc_stack_data.argc, __mlibc_stack_data.argv, environ); + exit(result); +} diff --git a/lib/mlibc/sysdeps/linux/generic/sysdeps.cpp b/lib/mlibc/sysdeps/linux/generic/sysdeps.cpp new file mode 100644 index 0000000..bc33a9e --- /dev/null +++ b/lib/mlibc/sysdeps/linux/generic/sysdeps.cpp @@ -0,0 +1,2002 @@ +#include <asm/ioctls.h> +#include <errno.h> +#include <limits.h> + +#include <type_traits> + +#include <mlibc-config.h> +#include <bits/ensure.h> +#include <abi-bits/fcntl.h> +#include <abi-bits/socklen_t.h> +#include <mlibc/allocator.hpp> +#include <mlibc/debug.hpp> +#include <mlibc/all-sysdeps.hpp> +#include <mlibc/thread-entry.hpp> +#include <limits.h> +#include <sys/syscall.h> +#include "cxx-syscall.hpp" + +#define STUB_ONLY { __ensure(!"STUB_ONLY function was called"); __builtin_unreachable(); } +#define UNUSED(x) (void)(x); + +#ifndef MLIBC_BUILDING_RTDL +extern "C" long __do_syscall_ret(unsigned long ret) { + if(ret > -4096UL) { + errno = -ret; + return -1; + } + return ret; +} +#endif + +namespace mlibc { + +void sys_libc_log(const char *message) { + size_t n = 0; + while(message[n]) + n++; + do_syscall(SYS_write, 2, message, n); + char lf = '\n'; + do_syscall(SYS_write, 2, &lf, 1); +} + +void sys_libc_panic() { + __builtin_trap(); +} + +#if defined(__i386__) + +struct user_desc { + unsigned int entry_number; + unsigned long base_addr; + unsigned int limit; + unsigned int seg_32bit: 1; + unsigned int contents: 2; + unsigned int read_exec_only: 1; + unsigned int limit_in_pages: 1; + unsigned int seg_not_present: 1; + unsigned int useable: 1; +}; + +#endif + +int sys_tcb_set(void *pointer) { +#if defined(__x86_64__) + auto ret = do_syscall(SYS_arch_prctl, 0x1002 /* ARCH_SET_FS */, pointer); + if(int e = sc_error(ret); e) + return e; +#elif defined(__i386__) + struct user_desc desc = { + .entry_number = static_cast<unsigned int>(-1), + .base_addr = uintptr_t(pointer), + .limit = 0xfffff, + .seg_32bit = 1, + .contents = 0, + .read_exec_only = 0, + .limit_in_pages = 1, + .seg_not_present = 0, + .useable = 1, + }; + auto ret = do_syscall(SYS_set_thread_area, &desc); + __ensure(!sc_error(ret)); + asm volatile ("movw %w0, %%gs" : : "q"(desc.entry_number * 8 + 3) :); +#elif defined(__riscv) + uintptr_t thread_data = reinterpret_cast<uintptr_t>(pointer) + sizeof(Tcb); + asm volatile ("mv tp, %0" :: "r"(thread_data)); +#elif defined (__aarch64__) + uintptr_t thread_data = reinterpret_cast<uintptr_t>(pointer) + sizeof(Tcb) - 0x10; + asm volatile ("msr tpidr_el0, %0" :: "r"(thread_data)); +#else +#error "Missing architecture specific code." +#endif + return 0; +} + +int sys_anon_allocate(size_t size, void **pointer) { + return sys_vm_map(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, + -1, 0, pointer); +} +int sys_anon_free(void *pointer, size_t size) { + return sys_vm_unmap(pointer, size); +} + +int sys_fadvise(int fd, off_t offset, off_t length, int advice) { + auto ret = do_syscall(SYS_fadvise64, fd, offset, length, advice); + if(int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_open(const char *path, int flags, mode_t mode, int *fd) { + auto ret = do_cp_syscall(SYS_openat, AT_FDCWD, path, flags, mode); + if(int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_openat(int dirfd, const char *path, int flags, mode_t mode, int *fd) { + auto ret = do_syscall(SYS_openat, dirfd, path, flags, mode); + if (int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_close(int fd) { + auto ret = do_cp_syscall(SYS_close, fd); + if(int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_dup2(int fd, int flags, int newfd) { + auto ret = do_cp_syscall(SYS_dup3, fd, newfd, flags); + if(int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_read(int fd, void *buffer, size_t size, ssize_t *bytes_read) { + auto ret = do_cp_syscall(SYS_read, fd, buffer, size); + if(int e = sc_error(ret); e) + return e; + *bytes_read = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_readv(int fd, const struct iovec *iovs, int iovc, ssize_t *bytes_read) { + auto ret = do_cp_syscall(SYS_readv, fd, iovs, iovc); + if(int e = sc_error(ret); e) + return e; + *bytes_read = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_write(int fd, const void *buffer, size_t size, ssize_t *bytes_written) { + auto ret = do_cp_syscall(SYS_write, fd, buffer, size); + if(int e = sc_error(ret); e) + return e; + if(bytes_written) + *bytes_written = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_seek(int fd, off_t offset, int whence, off_t *new_offset) { + auto ret = do_syscall(SYS_lseek, fd, offset, whence); + if(int e = sc_error(ret); e) + return e; + *new_offset = sc_int_result<off_t>(ret); + return 0; +} + +int sys_chmod(const char *pathname, mode_t mode) { + auto ret = do_cp_syscall(SYS_fchmodat, AT_FDCWD, pathname, mode); + if(int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_fchmod(int fd, mode_t mode) { + auto ret = do_cp_syscall(SYS_fchmod, fd, mode); + if(int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_fchmodat(int fd, const char *pathname, mode_t mode, int flags) { + auto ret = do_cp_syscall(SYS_fchmodat, fd, pathname, mode, flags); + if(int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_fchownat(int dirfd, const char *pathname, uid_t owner, gid_t group, int flags) { + auto ret = do_cp_syscall(SYS_fchownat, dirfd, pathname, owner, group, flags); + if(int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_utimensat(int dirfd, const char *pathname, const struct timespec times[2], int flags) { + auto ret = do_cp_syscall(SYS_utimensat, dirfd, pathname, times, flags); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_vm_map(void *hint, size_t size, int prot, int flags, + int fd, off_t offset, void **window) { + if(offset % 4096) + return EINVAL; + if(size >= PTRDIFF_MAX) + return ENOMEM; +#if defined(SYS_mmap2) + auto ret = do_syscall(SYS_mmap2, hint, size, prot, flags, fd, offset/4096); +#else + auto ret = do_syscall(SYS_mmap, hint, size, prot, flags, fd, offset); +#endif + // TODO: musl fixes up EPERM errors from the kernel. + if(int e = sc_error(ret); e) + return e; + *window = sc_ptr_result<void>(ret); + return 0; +} + +int sys_vm_unmap(void *pointer, size_t size) { + auto ret = do_syscall(SYS_munmap, pointer, size); + if(int e = sc_error(ret); e) + return e; + return 0; +} + +// All remaining functions are disabled in ldso. +#ifndef MLIBC_BUILDING_RTDL + +int sys_clock_get(int clock, time_t *secs, long *nanos) { + struct timespec tp = {}; + auto ret = do_syscall(SYS_clock_gettime, clock, &tp); + if (int e = sc_error(ret); e) + return e; + *secs = tp.tv_sec; + *nanos = tp.tv_nsec; + return 0; +} + +int sys_clock_getres(int clock, time_t *secs, long *nanos) { + struct timespec tp = {}; + auto ret = do_syscall(SYS_clock_getres, clock, &tp); + if (int e = sc_error(ret); e) + return e; + *secs = tp.tv_sec; + *nanos = tp.tv_nsec; + return 0; +} + +int sys_stat(fsfd_target fsfdt, int fd, const char *path, int flags, struct stat *statbuf) { + if (fsfdt == fsfd_target::path) + fd = AT_FDCWD; + else if (fsfdt == fsfd_target::fd) + flags |= AT_EMPTY_PATH; + else + __ensure(fsfdt == fsfd_target::fd_path); + +#if defined(SYS_newfstatat) + auto ret = do_cp_syscall(SYS_newfstatat, fd, path, statbuf, flags); +#else + auto ret = do_cp_syscall(SYS_fstatat64, fd, path, statbuf, flags); +#endif + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_statfs(const char *path, struct statfs *buf) { + auto ret = do_cp_syscall(SYS_statfs, path, buf); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_fstatfs(int fd, struct statfs *buf) { + auto ret = do_cp_syscall(SYS_fstatfs, fd, buf); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +extern "C" void __mlibc_signal_restore(void); +extern "C" void __mlibc_signal_restore_rt(void); + +int sys_sigaction(int signum, const struct sigaction *act, + struct sigaction *oldact) { + struct ksigaction { + void (*handler)(int); + unsigned long flags; + void (*restorer)(void); + sigset_t mask; + }; + + struct ksigaction kernel_act, kernel_oldact; + if (act) { + kernel_act.handler = act->sa_handler; + kernel_act.flags = act->sa_flags | SA_RESTORER; + kernel_act.restorer = (act->sa_flags & SA_SIGINFO) ? __mlibc_signal_restore_rt : __mlibc_signal_restore; + kernel_act.mask = act->sa_mask; + } + + static_assert(sizeof(sigset_t) == 8); + + auto ret = do_syscall(SYS_rt_sigaction, signum, act ? + &kernel_act : NULL, oldact ? + &kernel_oldact : NULL, sizeof(sigset_t)); + if (int e = sc_error(ret); e) + return e; + + if (oldact) { + oldact->sa_handler = kernel_oldact.handler; + oldact->sa_flags = kernel_oldact.flags; + oldact->sa_restorer = kernel_oldact.restorer; + oldact->sa_mask = kernel_oldact.mask; + } + return 0; +} + +int sys_socket(int domain, int type, int protocol, int *fd) { + auto ret = do_syscall(SYS_socket, domain, type, protocol); + if (int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_msg_send(int sockfd, const struct msghdr *msg, int flags, ssize_t *length) { + auto ret = do_cp_syscall(SYS_sendmsg, sockfd, msg, flags); + if (int e = sc_error(ret); e) + return e; + *length = sc_int_result<ssize_t>(ret); + return 0; +} + +ssize_t sys_sendto(int fd, const void *buffer, size_t size, int flags, const struct sockaddr *sock_addr, socklen_t addr_length, ssize_t *length) { + auto ret = do_cp_syscall(SYS_sendto, fd, buffer, size, flags, sock_addr, addr_length); + if(int e = sc_error(ret); e) { + return e; + } + *length = sc_int_result<ssize_t>(ret); + return 0; +} + +ssize_t sys_recvfrom(int fd, void *buffer, size_t size, int flags, struct sockaddr *sock_addr, socklen_t *addr_length, ssize_t *length) { + auto ret = do_cp_syscall(SYS_recvfrom, fd, buffer, size, flags, sock_addr, addr_length); + if(int e = sc_error(ret); e) { + return e; + } + *length = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_msg_recv(int sockfd, struct msghdr *msg, int flags, ssize_t *length) { + auto ret = do_cp_syscall(SYS_recvmsg, sockfd, msg, flags); + if (int e = sc_error(ret); e) + return e; + *length = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_fcntl(int fd, int cmd, va_list args, int *result) { + auto arg = va_arg(args, unsigned long); + // TODO: the api for linux differs for each command so fcntl()s might fail with -EINVAL + // we should implement all the different fcntl()s + // TODO(geert): only some fcntl()s can fail with -EINTR, making do_cp_syscall useless + // on most fcntls(). Another reason to handle different fcntl()s seperately. + auto ret = do_cp_syscall(SYS_fcntl, fd, cmd, arg); + if (int e = sc_error(ret); e) + return e; + *result = sc_int_result<int>(ret); + return 0; +} + +int sys_getcwd(char *buf, size_t size) { + auto ret = do_syscall(SYS_getcwd, buf, size); + if (int e = sc_error(ret); e) { + return e; + } + return 0; +} + +int sys_unlinkat(int dfd, const char *path, int flags) { + auto ret = do_syscall(SYS_unlinkat, dfd, path, flags); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_sleep(time_t *secs, long *nanos) { + struct timespec req = { + .tv_sec = *secs, + .tv_nsec = *nanos + }; + struct timespec rem = {}; + + auto ret = do_cp_syscall(SYS_nanosleep, &req, &rem); + if (int e = sc_error(ret); e) + return e; + + *secs = rem.tv_sec; + *nanos = rem.tv_nsec; + return 0; +} + +int sys_isatty(int fd) { + unsigned short winsizeHack[4]; + auto ret = do_syscall(SYS_ioctl, fd, 0x5413 /* TIOCGWINSZ */, &winsizeHack); + if (int e = sc_error(ret); e) + return e; + auto res = sc_int_result<unsigned long>(ret); + if(!res) return 0; + return 1; +} + +#if __MLIBC_POSIX_OPTION + +#include <net/if.h> +#include <sys/ioctl.h> +#include <sys/ipc.h> +#include <sys/user.h> +#include <sys/utsname.h> +#include <sys/stat.h> +#include <sys/sysinfo.h> +#include <unistd.h> +#include <stdio.h> +#include <stdlib.h> +#include <sched.h> +#include <fcntl.h> +#include <pthread.h> + +int sys_ioctl(int fd, unsigned long request, void *arg, int *result) { + auto ret = do_syscall(SYS_ioctl, fd, request, arg); + if (int e = sc_error(ret); e) + return e; + if (result) + *result = sc_int_result<unsigned long>(ret); + return 0; +} + +int sys_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) { + auto ret = do_cp_syscall(SYS_connect, sockfd, addr, addrlen); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_pselect(int nfds, fd_set *readfds, fd_set *writefds, + fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask, int *num_events) { + // The Linux kernel really wants 7 arguments, even tho this is not supported + // To fix that issue, they use a struct as the last argument. + // See the man page of pselect and the glibc source code + struct { + sigset_t ss; + size_t ss_len; + } data; + data.ss = (uintptr_t)sigmask; + data.ss_len = NSIG / 8; + + auto ret = do_cp_syscall(SYS_pselect6, nfds, readfds, writefds, + exceptfds, timeout, &data); + if (int e = sc_error(ret); e) + return e; + *num_events = sc_int_result<int>(ret); + return 0; +} + +int sys_pipe(int *fds, int flags) { + if(flags) { + auto ret = do_syscall(SYS_pipe2, fds, flags); + if (int e = sc_error(ret); e) + return e; + return 0; + } else { + auto ret = do_syscall(SYS_pipe2, fds, 0); + if (int e = sc_error(ret); e) + return e; + return 0; + } +} + +int sys_fork(pid_t *child) { + auto ret = do_syscall(SYS_clone, SIGCHLD, 0); + if (int e = sc_error(ret); e) + return e; + *child = sc_int_result<int>(ret); + return 0; +} + +int sys_waitpid(pid_t pid, int *status, int flags, struct rusage *ru, pid_t *ret_pid) { + auto ret = do_syscall(SYS_wait4, pid, status, flags, ru); + if (int e = sc_error(ret); e) + return e; + *ret_pid = sc_int_result<pid_t>(ret); + return 0; +} + +int sys_execve(const char *path, char *const argv[], char *const envp[]) { + auto ret = do_syscall(SYS_execve, path, argv, envp); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_sigprocmask(int how, const sigset_t *set, sigset_t *old) { + auto ret = do_syscall(SYS_rt_sigprocmask, how, set, old, NSIG / 8); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_setresuid(uid_t ruid, uid_t euid, uid_t suid) { + auto ret = do_syscall(SYS_setresuid, ruid, euid, suid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid) { + auto ret = do_syscall(SYS_setresgid, rgid, egid, sgid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_getresuid(uid_t *ruid, uid_t *euid, uid_t *suid) { + auto ret = do_syscall(SYS_getresuid, &ruid, &euid, &suid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid) { + auto ret = do_syscall(SYS_getresgid, &rgid, &egid, &sgid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_setreuid(uid_t ruid, uid_t euid) { + auto ret = do_syscall(SYS_setreuid, ruid, euid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_setregid(gid_t rgid, gid_t egid) { + auto ret = do_syscall(SYS_setregid, rgid, egid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_sysinfo(struct sysinfo *info) { + auto ret = do_syscall(SYS_sysinfo, info); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +void sys_yield() { + do_syscall(SYS_sched_yield); +} + +int sys_clone(void *tcb, pid_t *pid_out, void *stack) { + unsigned long flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND + | CLONE_THREAD | CLONE_SYSVSEM | CLONE_SETTLS + | CLONE_PARENT_SETTID; + +#if defined(__riscv) + // TP should point to the address immediately after the TCB. + // TODO: We should change the sysdep so that we don't need to do this. + auto tls = reinterpret_cast<char *>(tcb) + sizeof(Tcb); + tcb = reinterpret_cast<void *>(tls); +#elif defined(__aarch64__) + // TP should point to the address 16 bytes before the end of the TCB. + // TODO: We should change the sysdep so that we don't need to do this. + auto tp = reinterpret_cast<char *>(tcb) + sizeof(Tcb) - 0x10; + tcb = reinterpret_cast<void *>(tp); +#elif defined(__i386__) + /* get the entry number, as we don't request a new one here */ + uint32_t gs; + asm volatile("movw %%gs, %w0" : "=q"(gs)); + + auto user_desc = reinterpret_cast<struct user_desc *>(getAllocator().allocate(sizeof(struct user_desc))); + + user_desc->entry_number = (gs & 0xffff) >> 3; + user_desc->base_addr = uintptr_t(tcb); + user_desc->limit = 0xfffff; + user_desc->seg_32bit = 1; + user_desc->contents = 0; + user_desc->read_exec_only = 0; + user_desc->limit_in_pages = 1; + user_desc->seg_not_present = 0; + user_desc->useable = 1; + + tcb = reinterpret_cast<void *>(user_desc); +#endif + + auto ret = __mlibc_spawn_thread(flags, stack, pid_out, NULL, tcb); + if (ret < 0) + return ret; + + return 0; +} + +extern "C" const char __mlibc_syscall_begin[1]; +extern "C" const char __mlibc_syscall_end[1]; + +#if defined(__riscv) +// Disable UBSan here to work around qemu-user misaligning ucontext_t. +// https://github.com/qemu/qemu/blob/2bf40d0841b942e7ba12953d515e62a436f0af84/linux-user/riscv/signal.c#L68-L69 +[[gnu::no_sanitize("undefined")]] +#endif +int sys_before_cancellable_syscall(ucontext_t *uct) { +#if defined(__x86_64__) + auto pc = reinterpret_cast<void*>(uct->uc_mcontext.gregs[REG_RIP]); +#elif defined(__i386__) + auto pc = reinterpret_cast<void*>(uct->uc_mcontext.gregs[REG_EIP]); +#elif defined(__riscv) + auto pc = reinterpret_cast<void*>(uct->uc_mcontext.gregs[REG_PC]); +#elif defined(__aarch64__) + auto pc = reinterpret_cast<void*>(uct->uc_mcontext.pc); +#else +#error "Missing architecture specific code." +#endif + if (pc < __mlibc_syscall_begin || pc > __mlibc_syscall_end) + return 0; + return 1; +} + +int sys_tgkill(int tgid, int tid, int sig) { + auto ret = do_syscall(SYS_tgkill, tgid, tid, sig); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_tcgetattr(int fd, struct termios *attr) { + auto ret = do_syscall(SYS_ioctl, fd, TCGETS, attr); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_tcsetattr(int fd, int optional_action, const struct termios *attr) { + int req; + + switch (optional_action) { + case TCSANOW: req = TCSETS; break; + case TCSADRAIN: req = TCSETSW; break; + case TCSAFLUSH: req = TCSETSF; break; + default: return EINVAL; + } + + auto ret = do_syscall(SYS_ioctl, fd, req, attr); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_tcflush(int fd, int queue) { + auto ret = do_syscall(SYS_ioctl, fd, TCFLSH, queue); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_tcdrain(int fd) { + auto ret = do_syscall(SYS_ioctl, fd, TCSBRK, 1); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_tcflow(int fd, int action) { + auto ret = do_syscall(SYS_ioctl, fd, TCXONC, action); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_access(const char *path, int mode) { + auto ret = do_syscall(SYS_faccessat, AT_FDCWD, path, mode, 0); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_faccessat(int dirfd, const char *pathname, int mode, int flags) { + auto ret = do_syscall(SYS_faccessat, dirfd, pathname, mode, flags); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_accept(int fd, int *newfd, struct sockaddr *addr_ptr, socklen_t *addr_length, int flags) { + auto ret = do_syscall(SYS_accept4, fd, addr_ptr, addr_length, flags); + if (int e = sc_error(ret); e) + return e; + *newfd = sc_int_result<int>(ret); + return 0; +} + +int sys_bind(int fd, const struct sockaddr *addr_ptr, socklen_t addr_length) { + auto ret = do_syscall(SYS_bind, fd, addr_ptr, addr_length, 0, 0, 0); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_setsockopt(int fd, int layer, int number, const void *buffer, socklen_t size) { + auto ret = do_syscall(SYS_setsockopt, fd, layer, number, buffer, size, 0); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_sockname(int fd, struct sockaddr *addr_ptr, socklen_t max_addr_length, + socklen_t *actual_length) { + auto ret = do_syscall(SYS_getsockname, fd, addr_ptr, &max_addr_length); + if (int e = sc_error(ret); e) + return e; + *actual_length = max_addr_length; + return 0; +} + +int sys_peername(int fd, struct sockaddr *addr_ptr, socklen_t max_addr_length, + socklen_t *actual_length) { + auto ret = do_syscall(SYS_getpeername, fd, addr_ptr, &max_addr_length); + if (int e = sc_error(ret); e) + return e; + *actual_length = max_addr_length; + return 0; +} + +int sys_listen(int fd, int backlog) { + auto ret = do_syscall(SYS_listen, fd, backlog, 0, 0, 0, 0); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_shutdown(int sockfd, int how) { + auto ret = do_syscall(SYS_shutdown, sockfd, how); + if (int e = sc_error(ret); e) { + return e; + } + return 0; +} + +int sys_getpriority(int which, id_t who, int *value) { + auto ret = do_syscall(SYS_getpriority, which, who); + if (int e = sc_error(ret); e) { + return e; + } + *value = 20 - sc_int_result<int>(ret); + return 0; +} + +int sys_setpriority(int which, id_t who, int prio) { + auto ret = do_syscall(SYS_setpriority, which, who, prio); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value) { + auto ret = do_syscall(SYS_setitimer, which, new_value, old_value); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +/* Linux' uapi does some weird union stuff in place of `sigev_tid`, which we conveniently ignore */ +struct linux_uapi_sigevent { + union sigval sigev_value; + int sigev_signo; + int sigev_notify; + int sigev_tid; +}; + +int sys_timer_create(clockid_t clk, struct sigevent *__restrict evp, timer_t *__restrict res) { + struct linux_uapi_sigevent ksev; + struct linux_uapi_sigevent *ksevp = 0; + int timer_id; + + switch(evp ? evp->sigev_notify : SIGEV_SIGNAL) { + case SIGEV_NONE: + case SIGEV_SIGNAL: { + if(evp) { + ksev.sigev_value = evp->sigev_value; + ksev.sigev_signo = evp->sigev_signo; + ksev.sigev_notify = evp->sigev_notify; + ksev.sigev_tid = 0; + ksevp = &ksev; + } + + auto ret = do_syscall(SYS_timer_create, clk, ksevp, &timer_id); + if (int e = sc_error(ret); e) { + return e; + } + *res = (void *) (intptr_t) timer_id; + break; + } + case SIGEV_THREAD: + __ensure(!"sys_timer_create with evp->sigev_notify == SIGEV_THREAD is unimplemented"); + [[fallthrough]]; + default: + return EINVAL; + } + + return 0; +} + +int sys_timer_settime(timer_t t, int flags, const struct itimerspec *__restrict val, struct itimerspec *__restrict old) { + auto ret = do_syscall(SYS_timer_settime, t, flags, val, old); + if (int e = sc_error(ret); e) { + return e; + } + return 0; +} + +int sys_timer_delete(timer_t t) { + __ensure((intptr_t) t >= 0); + auto ret = do_syscall(SYS_timer_delete, t); + if (int e = sc_error(ret); e) { + return e; + } + return 0; +} + +int sys_ptrace(long req, pid_t pid, void *addr, void *data, long *out) { + auto ret = do_syscall(SYS_ptrace, req, pid, addr, data); + if (int e = sc_error(ret); e) + return e; + *out = sc_int_result<long>(ret); + return 0; +} + +int sys_open_dir(const char *path, int *fd) { + return sys_open(path, O_DIRECTORY, 0, fd); +} + +int sys_read_entries(int handle, void *buffer, size_t max_size, size_t *bytes_read) { + auto ret = do_syscall(SYS_getdents64, handle, buffer, max_size); + if(int e = sc_error(ret); e) + return e; + *bytes_read = sc_int_result<int>(ret); + return 0; +} + +int sys_prctl(int op, va_list ap, int *out) { + unsigned long x[4]; + for(int i = 0; i < 4; i++) + x[i] = va_arg(ap, unsigned long); + + auto ret = do_syscall(SYS_prctl, op, x[0], x[1], x[2], x[3]); + if (int e = sc_error(ret); e) + return e; + *out = sc_int_result<int>(ret); + return 0; +} + +int sys_uname(struct utsname *buf) { + auto ret = do_syscall(SYS_uname, buf); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_gethostname(char *buf, size_t bufsize) { + struct utsname uname_buf; + if (auto e = sys_uname(&uname_buf); e) + return e; + + auto node_len = strlen(uname_buf.nodename); + if (node_len >= bufsize) + return ENAMETOOLONG; + + memcpy(buf, uname_buf.nodename, node_len); + buf[node_len] = '\0'; + return 0; +} + +int sys_pread(int fd, void *buf, size_t n, off_t off, ssize_t *bytes_read) { + auto ret = do_syscall(SYS_pread64, fd, buf, n, off); + if (int e = sc_error(ret); e) + return e; + *bytes_read = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_pwrite(int fd, const void *buf, size_t n, off_t off, ssize_t *bytes_written) { + auto ret = do_syscall(SYS_pwrite64, fd, buf, n, off); + if (int e = sc_error(ret); e) + return e; + *bytes_written = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_poll(struct pollfd *fds, nfds_t count, int timeout, int *num_events) { + struct timespec tm; + tm.tv_sec = timeout / 1000; + tm.tv_nsec = timeout % 1000 * 1000000; + auto ret = do_syscall(SYS_ppoll, fds, count, timeout >= 0 ? &tm : nullptr, 0, NSIG / 8); + if (int e = sc_error(ret); e) + return e; + *num_events = sc_int_result<int>(ret); + return 0; +} + +int sys_getrusage(int scope, struct rusage *usage) { + auto ret = do_syscall(SYS_getrusage, scope, usage); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_madvise(void *addr, size_t length, int advice) { + auto ret = do_syscall(SYS_madvise, addr, length, advice); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_msync(void *addr, size_t length, int flags) { + auto ret = do_syscall(SYS_msync, addr, length, flags); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_swapon(const char *path, int flags) { + auto ret = do_syscall(SYS_swapon, path, flags); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_swapoff(const char *path) { + auto ret = do_syscall(SYS_swapoff, path); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask) { + auto ret = do_syscall(SYS_sched_getaffinity, pid, cpusetsize, mask); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_mount(const char *source, const char *target, + const char *fstype, unsigned long flags, const void *data) { + auto ret = do_syscall(SYS_mount, source, target, fstype, flags, data); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_umount2(const char *target, int flags) { + auto ret = do_syscall(SYS_umount2, target, flags); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_sethostname(const char *buffer, size_t bufsize) { + auto ret = do_syscall(SYS_sethostname, buffer, bufsize); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_epoll_create(int flags, int *fd) { + auto ret = do_syscall(SYS_epoll_create1, flags); + if (int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_epoll_ctl(int epfd, int mode, int fd, struct epoll_event *ev) { + auto ret = do_syscall(SYS_epoll_ctl, epfd, mode, fd, ev); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_epoll_pwait(int epfd, struct epoll_event *ev, int n, int timeout, const sigset_t *sigmask, int *raised) { + auto ret = do_syscall(SYS_epoll_pwait, epfd, ev, n, timeout, sigmask, NSIG / 8); + if (int e = sc_error(ret); e) + return e; + *raised = sc_int_result<int>(ret); + return 0; +} + +int sys_eventfd_create(unsigned int initval, int flags, int *fd) { + auto ret = do_syscall(SYS_eventfd2, initval, flags); + if (int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_signalfd_create(const sigset_t *masks, int flags, int *fd) { + auto ret = do_syscall(SYS_signalfd4, *fd, masks, sizeof(sigset_t), flags); + if (int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_timerfd_create(int clockid, int flags, int *fd) { + auto ret = do_syscall(SYS_timerfd_create, clockid, flags); + if (int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_timerfd_settime(int fd, int flags, const struct itimerspec *value, struct itimerspec *oldvalue) { + auto ret = do_syscall(SYS_timerfd_settime, fd, flags, value, oldvalue); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_inotify_create(int flags, int *fd) { + auto ret = do_syscall(SYS_inotify_init1, flags); + if (int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_init_module(void *module, unsigned long length, const char *args) { + auto ret = do_syscall(SYS_init_module, module, length, args); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_delete_module(const char *name, unsigned flags) { + auto ret = do_syscall(SYS_delete_module, name, flags); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_klogctl(int type, char *bufp, int len, int *out) { + auto ret = do_syscall(SYS_syslog, type, bufp, len); + if (int e = sc_error(ret); e) + return e; + *out = sc_int_result<int>(ret); + return 0; +} + +int sys_getcpu(int *cpu) { + auto ret = do_syscall(SYS_getcpu, cpu, NULL, NULL); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_socketpair(int domain, int type_and_flags, int proto, int *fds) { + auto ret = do_syscall(SYS_socketpair, domain, type_and_flags, proto, fds, 0, 0); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_getsockopt(int fd, int layer, int number, void *__restrict buffer, socklen_t *__restrict size) { + auto ret = do_syscall(SYS_getsockopt, fd, layer, number, buffer, size, 0); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_inotify_add_watch(int ifd, const char *path, uint32_t mask, int *wd) { + auto ret = do_syscall(SYS_inotify_add_watch, ifd, path, mask); + if (int e = sc_error(ret); e) + return e; + *wd = sc_int_result<int>(ret); + return 0; +} + +int sys_inotify_rm_watch(int ifd, int wd) { + auto ret = do_syscall(SYS_inotify_rm_watch, ifd, wd); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_ttyname(int fd, char *buf, size_t size) { + if (!isatty(fd)) + return errno; + + char *procname; + if(int e = asprintf(&procname, "/proc/self/fd/%i", fd); e) + return ENOMEM; + __ensure(procname); + + ssize_t l = readlink(procname, buf, size); + free(procname); + + if (l < 0) + return errno; + else if ((size_t)l >= size) + return ERANGE; + + buf[l] = '\0'; + struct stat st1; + struct stat st2; + + if (stat(buf, &st1) || fstat(fd, &st2)) + return errno; + if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) + return ENODEV; + + return 0; +} + +int sys_pause() { +#ifdef SYS_pause + auto ret = do_syscall(SYS_pause); +#else + auto ret = do_syscall(SYS_ppoll, 0, 0, 0, 0); +#endif + if (int e = sc_error(ret); e) + return e; + return EINTR; +} + +int sys_mlockall(int flags) { + auto ret = do_syscall(SYS_mlockall, flags); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_get_min_priority(int policy, int *out) { + auto ret = do_syscall(SYS_sched_get_priority_min, policy); + if (int e = sc_error(ret); e) + return e; + *out = sc_int_result<int>(ret); + + return 0; +} + +int sys_getschedparam(void *tcb, int *policy, struct sched_param *param) { + auto t = reinterpret_cast<Tcb *>(tcb); + + if(!t->tid) { + return ESRCH; + } + + auto ret_param = do_syscall(SYS_sched_getparam, t->tid, param); + if (int e = sc_error(ret_param); e) + return e; + + auto ret_sched = do_syscall(SYS_sched_getscheduler, t->tid, param); + if (int e = sc_error(ret_sched); e) + return e; + *policy = sc_int_result<int>(ret_sched); + + return 0; +} + +int sys_setschedparam(void *tcb, int policy, const struct sched_param *param) { + auto t = reinterpret_cast<Tcb *>(tcb); + + if(!t->tid) { + return ESRCH; + } + + auto ret = do_syscall(SYS_sched_setscheduler, t->tid, policy, param); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_if_indextoname(unsigned int index, char *name) { + int fd = 0; + int r = sys_socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, AF_UNSPEC, &fd); + + if(r) + return r; + + struct ifreq ifr; + ifr.ifr_ifindex = index; + + int ret = sys_ioctl(fd, SIOCGIFNAME, &ifr, NULL); + close(fd); + + if(ret) { + if(ret == ENODEV) + return ENXIO; + return ret; + } + + strncpy(name, ifr.ifr_name, IF_NAMESIZE); + + return 0; +} + +int sys_if_nametoindex(const char *name, unsigned int *ret) { + int fd = 0; + int r = sys_socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, AF_UNSPEC, &fd); + + if(r) + return r; + + struct ifreq ifr; + strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name); + + r = sys_ioctl(fd, SIOCGIFINDEX, &ifr, NULL); + close(fd); + + if(r) { + return r; + } + + *ret = ifr.ifr_ifindex; + + return 0; +} + +int sys_ptsname(int fd, char *buffer, size_t length) { + int index; + if(int e = sys_ioctl(fd, TIOCGPTN, &index, NULL); e) + return e; + if((size_t)snprintf(buffer, length, "/dev/pts/%d", index) >= length) { + return ERANGE; + } + return 0; +} + +int sys_unlockpt(int fd) { + int unlock = 0; + + if(int e = sys_ioctl(fd, TIOCSPTLCK, &unlock, NULL); e) + return e; + + return 0; +} + +int sys_thread_setname(void *tcb, const char *name) { + if(strlen(name) > 15) { + return ERANGE; + } + + auto t = reinterpret_cast<Tcb *>(tcb); + char *path; + int cs = 0; + + if(asprintf(&path, "/proc/self/task/%d/comm", t->tid) < 0) { + return ENOMEM; + } + + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs); + + int fd; + if(int e = sys_open(path, O_WRONLY, 0, &fd); e) { + return e; + } + + if(int e = sys_write(fd, name, strlen(name) + 1, NULL)) { + return e; + } + + sys_close(fd); + + pthread_setcancelstate(cs, 0); + + return 0; +} + +int sys_thread_getname(void *tcb, char *name, size_t size) { + auto t = reinterpret_cast<Tcb *>(tcb); + char *path; + int cs = 0; + ssize_t real_size = 0; + + if(asprintf(&path, "/proc/self/task/%d/comm", t->tid) < 0) { + return ENOMEM; + } + + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs); + + int fd; + if(int e = sys_open(path, O_RDONLY | O_CLOEXEC, 0, &fd); e) { + return e; + } + + if(int e = sys_read(fd, name, size, &real_size)) { + return e; + } + + name[real_size - 1] = 0; + sys_close(fd); + + pthread_setcancelstate(cs, 0); + + if(static_cast<ssize_t>(size) <= real_size) { + return ERANGE; + } + + return 0; +} + +int sys_mlock(const void *addr, size_t length) { + auto ret = do_syscall(SYS_mlock, addr, length); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_munlock(const void *addr, size_t length) { + auto ret = do_syscall(SYS_munlock, addr, length); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_munlockall(void) { + auto ret = do_syscall(SYS_munlockall); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_mincore(void *addr, size_t length, unsigned char *vec) { + auto ret = do_syscall(SYS_mincore, addr, length, vec); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_memfd_create(const char *name, int flags, int *fd) { + auto ret = do_syscall(SYS_memfd_create, name, flags); + if (int e = sc_error(ret); e) + return e; + *fd = sc_int_result<int>(ret); + return 0; +} + +int sys_fallocate(int fd, off_t offset, size_t size) { + auto ret = do_syscall(SYS_fallocate, fd, 0, offset, size); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_flock(int fd, int options) { + auto ret = do_syscall(SYS_flock, fd, options); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_seteuid(uid_t euid) { + return sys_setresuid(-1, euid, -1); +} + +int sys_vm_remap(void *pointer, size_t size, size_t new_size, void **window) { + auto ret = do_syscall(SYS_mremap, pointer, size, new_size, MREMAP_MAYMOVE); + // TODO: musl fixes up EPERM errors from the kernel. + if(int e = sc_error(ret); e) + return e; + *window = sc_ptr_result<void>(ret); + return 0; +} + +int sys_link(const char *old_path, const char *new_path) { +#ifdef SYS_link + auto ret = do_syscall(SYS_link, old_path, new_path); + if (int e = sc_error(ret); e) + return e; + return 0; +#else + auto ret = do_syscall(SYS_linkat, AT_FDCWD, old_path, AT_FDCWD, new_path, 0); + if (int e = sc_error(ret); e) + return e; + return 0; +#endif +} + +// Inspired by musl (src/stat/statvfs.c:28 fixup function) +static void statfs_to_statvfs(struct statfs *from, struct statvfs *to) { + *to = { + .f_bsize = from->f_bsize, + .f_frsize = from->f_frsize ? from->f_frsize : from->f_bsize, + .f_blocks = from->f_blocks, + .f_bfree = from->f_bfree, + .f_bavail = from->f_bavail, + .f_files = from->f_files, + .f_ffree = from->f_ffree, + .f_favail = from->f_ffree, + .f_fsid = (unsigned long) from->f_fsid.__val[0], + .f_flag = from->f_flags, + .f_namemax = from->f_namelen, + }; +} + +int sys_statvfs(const char *path, struct statvfs *out) { + struct statfs buf; + if(auto ret = sys_statfs(path, &buf); ret != 0) { + return ret; + } + statfs_to_statvfs(&buf, out); + return 0; +} + +int sys_fstatvfs(int fd, struct statvfs *out) { + struct statfs buf; + if(auto ret = sys_fstatfs(fd, &buf); ret != 0) { + return ret; + } + statfs_to_statvfs(&buf, out); + return 0; +} + +int sys_sysconf(int num, long *ret) { + switch(num) { + case _SC_OPEN_MAX: { + struct rlimit ru; + if(int e = sys_getrlimit(RLIMIT_NOFILE, &ru); e) { + return e; + } + *ret = (ru.rlim_cur == RLIM_INFINITY) ? -1 : ru.rlim_cur; + break; + } + case _SC_NPROCESSORS_ONLN: { + cpu_set_t set; + CPU_ZERO(&set); + if(int e = sys_getaffinity(0, sizeof(set), &set); e) { + return e; + } + *ret = CPU_COUNT(&set); + break; + } + case _SC_PHYS_PAGES: { + struct sysinfo info; + if(int e = sys_sysinfo(&info); e) { + return e; + } + unsigned unit = (info.mem_unit) ? info.mem_unit : 1; + *ret = std::min(long((info.totalram * unit) / PAGE_SIZE), LONG_MAX); + break; + } + case _SC_CHILD_MAX: { + struct rlimit ru; + if(int e = sys_getrlimit(RLIMIT_NPROC, &ru); e) { + return e; + } + *ret = (ru.rlim_cur == RLIM_INFINITY) ? -1 : ru.rlim_cur; + break; + } + case _SC_LINE_MAX: { + *ret = -1; + break; + } + default: { + return EINVAL; + } + } + + return 0; +} + +int sys_semget(key_t key, int n, int fl, int *id) { + auto ret = do_syscall(SYS_semget, key, n, fl); + if(int e = sc_error(ret); e) + return e; + *id = sc_int_result<int>(ret); + return 0; +} + +int sys_semctl(int semid, int semnum, int cmd, void *semun, int *out) { + auto ret = do_syscall(SYS_semctl, semid, semnum, cmd | IPC_64, semun); + if(int e = sc_error(ret); e) + return e; + *out = sc_int_result<int>(ret); + return 0; +} + +int sys_waitid(idtype_t idtype, id_t id, siginfo_t *info, int options) { + auto ret = do_syscall(SYS_waitid, idtype, id, info, options, 0); + if(int e = sc_error(ret); e) + return e; + return sc_int_result<int>(ret); +} + +#endif // __MLIBC_POSIX_OPTION + +#if __MLIBC_LINUX_OPTION + +#include <linux/reboot.h> + +int sys_reboot(int cmd) { + auto ret = do_syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, nullptr); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +#endif // __MLIBC_LINUX_OPTION + +int sys_times(struct tms *tms, clock_t *out) { + auto ret = do_syscall(SYS_times, tms); + if (int e = sc_error(ret); e) + return e; + *out = sc_int_result<long>(ret); + return 0; +} + +pid_t sys_getpid() { + auto ret = do_syscall(SYS_getpid); + // getpid() always succeeds. + return sc_int_result<pid_t>(ret); +} + +pid_t sys_gettid() { + auto ret = do_syscall(SYS_gettid); + // gettid() always succeeds. + return sc_int_result<pid_t>(ret); +} + +uid_t sys_getuid() { + auto ret = do_syscall(SYS_getuid); + // getuid() always succeeds. + return sc_int_result<pid_t>(ret); +} + +uid_t sys_geteuid() { + auto ret = do_syscall(SYS_geteuid); + // geteuid() always succeeds. + return sc_int_result<pid_t>(ret); +} + +gid_t sys_getgid() { + auto ret = do_syscall(SYS_getgid); + // getgid() always succeeds. + return sc_int_result<pid_t>(ret); +} + +gid_t sys_getegid() { + auto ret = do_syscall(SYS_getegid); + // getegid() always succeeds. + return sc_int_result<pid_t>(ret); +} + +int sys_kill(int pid, int sig) { + auto ret = do_syscall(SYS_kill, pid, sig); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_vm_protect(void *pointer, size_t size, int prot) { + auto ret = do_syscall(SYS_mprotect, pointer, size, prot); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +void sys_thread_exit() { + do_syscall(SYS_exit, 0); + __builtin_trap(); +} + +void sys_exit(int status) { + do_syscall(SYS_exit_group, status); + __builtin_trap(); +} + +#endif // MLIBC_BUILDING_RTDL + +#define FUTEX_WAIT 0 +#define FUTEX_WAKE 1 + +int sys_futex_tid() { + auto ret = do_syscall(SYS_gettid); + // gettid() always succeeds. + return sc_int_result<pid_t>(ret); +} + +int sys_futex_wait(int *pointer, int expected, const struct timespec *time) { + auto ret = do_cp_syscall(SYS_futex, pointer, FUTEX_WAIT, expected, time); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_futex_wake(int *pointer) { + auto ret = do_syscall(SYS_futex, pointer, FUTEX_WAKE, INT_MAX); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_sigsuspend(const sigset_t *set) { + auto ret = do_syscall(SYS_rt_sigsuspend, set, NSIG / 8); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_sigaltstack(const stack_t *ss, stack_t *oss) { + auto ret = do_syscall(SYS_sigaltstack, ss, oss); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_mkdir(const char *path, mode_t mode) { + auto ret = do_syscall(SYS_mkdirat, AT_FDCWD, path, mode); + if (int e = sc_error(ret); e) + return e; + return 0; +} + + +int sys_mkdirat(int dirfd, const char *path, mode_t mode) { + auto ret = do_syscall(SYS_mkdirat, dirfd, path, mode); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_mknodat(int dirfd, const char *path, int mode, int dev) { + auto ret = do_syscall(SYS_mknodat, dirfd, path, mode, dev); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_mkfifoat(int dirfd, const char *path, int mode) { + return sys_mknodat(dirfd, path, mode | S_IFIFO, 0); +} + +int sys_symlink(const char *target_path, const char *link_path) { + auto ret = do_syscall(SYS_symlinkat, target_path, AT_FDCWD, link_path); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_symlinkat(const char *target_path, int dirfd, const char *link_path) { + auto ret = do_syscall(SYS_symlinkat, target_path, dirfd, link_path); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_umask(mode_t mode, mode_t *old) { + auto ret = do_syscall(SYS_umask, mode); + if (int e = sc_error(ret); e) + return e; + *old = sc_int_result<mode_t>(ret); + return 0; +} + +int sys_chdir(const char *path) { + auto ret = do_syscall(SYS_chdir, path); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_fchdir(int fd) { + auto ret = do_syscall(SYS_fchdir, fd); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_rename(const char *old_path, const char *new_path) { + return sys_renameat(AT_FDCWD, old_path, AT_FDCWD, new_path); +} + +int sys_renameat(int old_dirfd, const char *old_path, int new_dirfd, const char *new_path) { +#ifdef SYS_renameat2 + auto ret = do_syscall(SYS_renameat2, old_dirfd, old_path, new_dirfd, new_path, 0); +#else + auto ret = do_syscall(SYS_renameat, old_dirfd, old_path, new_dirfd, new_path); +#endif /* defined(SYS_renameat2) */ + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_rmdir(const char *path) { + auto ret = do_syscall(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_ftruncate(int fd, size_t size) { + auto ret = do_syscall(SYS_ftruncate, fd, size); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_readlink(const char *path, void *buf, size_t bufsiz, ssize_t *len) { + auto ret = do_syscall(SYS_readlinkat, AT_FDCWD, path, buf, bufsiz); + if (int e = sc_error(ret); e) + return e; + *len = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_getrlimit(int resource, struct rlimit *limit) { + auto ret = do_syscall(SYS_getrlimit, resource, limit); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_setrlimit(int resource, const struct rlimit *limit) { + auto ret = do_syscall(SYS_setrlimit, resource, limit); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +pid_t sys_getppid() { + auto ret = do_syscall(SYS_getppid); + // getppid() always succeeds. + return sc_int_result<pid_t>(ret); +} + +int sys_setpgid(pid_t pid, pid_t pgid) { + auto ret = do_syscall(SYS_setpgid, pid, pgid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_getsid(pid_t pid, pid_t *sid) { + auto ret = do_syscall(SYS_getsid, pid); + if (int e = sc_error(ret); e) + return e; + *sid = sc_int_result<pid_t>(ret); + return 0; +} + +int sys_setsid(pid_t *sid) { + auto ret = do_syscall(SYS_setsid); + if (int e = sc_error(ret); e) + return e; + *sid = sc_int_result<pid_t>(ret); + return 0; +} + +int sys_setuid(uid_t uid) { + auto ret = do_syscall(SYS_setuid, uid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_setgid(gid_t gid) { + auto ret = do_syscall(SYS_setgid, gid); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_getpgid(pid_t pid, pid_t *out) { + auto ret = do_syscall(SYS_getpgid, pid); + if (int e = sc_error(ret); e) + return e; + *out = sc_int_result<pid_t>(ret); + return 0; +} + +int sys_getgroups(size_t size, const gid_t *list, int *retval) { + auto ret = do_syscall(SYS_getgroups, size, list); + if (int e = sc_error(ret); e) + return e; + *retval = sc_int_result<int>(ret); + return 0; +} + +int sys_dup(int fd, int flags, int *newfd) { + __ensure(!flags); + auto ret = do_cp_syscall(SYS_dup, fd); + if (int e = sc_error(ret); e) + return e; + *newfd = sc_int_result<int>(ret); + return 0; +} + +void sys_sync() { + do_syscall(SYS_sync); +} + +int sys_fsync(int fd) { + auto ret = do_syscall(SYS_fsync, fd); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_fdatasync(int fd) { + auto ret = do_syscall(SYS_fdatasync, fd); + if (int e = sc_error(ret); e) + return e; + return 0; +} + +int sys_getrandom(void *buffer, size_t length, int flags, ssize_t *bytes_written) { + auto ret = do_syscall(SYS_getrandom, buffer, length, flags); + if (int e = sc_error(ret); e) + return e; + *bytes_written = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_getentropy(void *buffer, size_t length) { + ssize_t written; + return sys_getrandom(buffer, length, 0, &written); +} + +int sys_setxattr(const char *path, const char *name, const void *val, + size_t size, int flags) { + auto ret = do_syscall(SYS_setxattr, path, name, val, size, flags); + return sc_error(ret); +} + +int sys_lsetxattr(const char *path, const char *name, const void *val, + size_t size, int flags) { + auto ret = do_syscall(SYS_lsetxattr, path, name, val, size, flags); + return sc_error(ret); +} + +int sys_fsetxattr(int fd, const char *name, const void *val, + size_t size, int flags) { + auto ret = do_syscall(SYS_fsetxattr, fd, name, val, size, flags); + return sc_error(ret); +} + +int sys_getxattr(const char *path, const char *name, void *val, size_t size, + ssize_t *nread) { + auto ret = do_syscall(SYS_getxattr, path, name, val, size); + if (int e = sc_error(ret); e) { + return e; + } + + *nread = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_lgetxattr(const char *path, const char *name, void *val, size_t size, + ssize_t *nread) { + auto ret = do_syscall(SYS_lgetxattr, path, name, val, size); + if (int e = sc_error(ret); e) { + return e; + } + + *nread = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_fgetxattr(int fd, const char *name, void *val, size_t size, + ssize_t *nread) { + auto ret = do_syscall(SYS_fgetxattr, fd, name, val, size); + if (int e = sc_error(ret); e) { + return e; + } + + *nread = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_removexattr(const char *path, const char *name) { + auto ret = do_syscall(SYS_removexattr, path, name); + return sc_error(ret); +} + +int sys_lremovexattr(const char *path, const char *name) { + auto ret = do_syscall(SYS_lremovexattr, path, name); + return sc_error(ret); +} + +int sys_fremovexattr(int fd, const char *name) { + auto ret = do_syscall(SYS_fremovexattr, fd, name); + return sc_error(ret); +} + +int sys_listxattr(const char *path, char *list, size_t size, ssize_t *nread) { + auto ret = do_syscall(SYS_listxattr, path, list, size); + if (int e = sc_error(ret); e) { + return e; + } + + *nread = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_llistxattr(const char *path, char *list, size_t size, ssize_t *nread) { + auto ret = do_syscall(SYS_llistxattr, path, list, size); + if (int e = sc_error(ret); e) { + return e; + } + + *nread = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_flistxattr(int fd, char *list, size_t size, ssize_t *nread) { + auto ret = do_syscall(SYS_flistxattr, fd, list, size); + if (int e = sc_error(ret); e) { + return e; + } + + *nread = sc_int_result<ssize_t>(ret); + return 0; +} + +int sys_sigtimedwait(const sigset_t *__restrict set, siginfo_t *__restrict info, const struct timespec *__restrict timeout, int *out_signal) { + auto ret = do_syscall(SYS_rt_sigtimedwait, set, info, timeout, NSIG / 8); + + if (int e = sc_error(ret); e) + return e; + + *out_signal = sc_int_result<int>(ret); + + return 0; +} + +#if __MLIBC_BSD_OPTION +int sys_brk(void **out) { + auto ret = do_syscall(SYS_brk, 0); + if(int e = sc_error(ret); e) { + return e; + } + + *out = (void *) sc_int_result<uintptr_t>(ret); + return 0; +} +#endif // __MLIBC_BSD_OPTION + +#if __MLIBC_GLIBC_OPTION + +int sys_personality(unsigned long persona, int *out) { + auto ret = do_syscall(SYS_personality, persona); + + if(int e = sc_error(ret); e) { + return e; + } + + *out = sc_int_result<int>(ret); + return 0; +} + +int sys_ioperm(unsigned long int from, unsigned long int num, int turn_on) { +#if defined(SYS_ioperm) + auto ret = do_syscall(SYS_ioperm, from, num, turn_on); + + if(int e = sc_error(ret); e) { + return e; + } + + return 0; +#else + (void) from; + (void) num; + (void) turn_on; + return ENOSYS; +#endif +} + +int sys_iopl(int level) { +#if defined(SYS_iopl) + auto ret = do_syscall(SYS_iopl, level); + + if(int e = sc_error(ret); e) { + return e; + } + + return 0; +#else + (void) level; + return ENOSYS; +#endif +} + +#endif // __MLIBC_GLIBC_OPTION + +} // namespace mlibc diff --git a/lib/mlibc/sysdeps/linux/generic/thread.cpp b/lib/mlibc/sysdeps/linux/generic/thread.cpp new file mode 100644 index 0000000..e413e4f --- /dev/null +++ b/lib/mlibc/sysdeps/linux/generic/thread.cpp @@ -0,0 +1,60 @@ +#include <mlibc/thread-entry.hpp> +#include <mlibc/all-sysdeps.hpp> +#include <mlibc/thread.hpp> +#include <bits/ensure.h> +#include <sys/mman.h> +#include <stdint.h> +#include <stddef.h> +#include <errno.h> + +extern "C" void __mlibc_enter_thread(void *entry, void *user_arg) { + // The linux kernel already sets the TCB in sys_clone(). + auto tcb = mlibc::get_current_tcb(); + + // Wait until our parent sets up the TID. + while(!__atomic_load_n(&tcb->tid, __ATOMIC_RELAXED)) + mlibc::sys_futex_wait(&tcb->tid, 0, nullptr); + + tcb->invokeThreadFunc(entry, user_arg); + + __atomic_store_n(&tcb->didExit, 1, __ATOMIC_RELEASE); + mlibc::sys_futex_wake(&tcb->didExit); + + mlibc::sys_thread_exit(); +} + +namespace mlibc { + +static constexpr size_t default_stacksize = 0x200000; + +int sys_prepare_stack(void **stack, void *entry, void *user_arg, void *tcb, size_t *stack_size, size_t *guard_size, void **stack_base) { + (void)tcb; + if (!*stack_size) + *stack_size = default_stacksize; + + uintptr_t map; + if (*stack) { + map = reinterpret_cast<uintptr_t>(*stack); + *guard_size = 0; + } else { + map = reinterpret_cast<uintptr_t>( + mmap(nullptr, *stack_size + *guard_size, + PROT_NONE, + MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) + ); + if (reinterpret_cast<void*>(map) == MAP_FAILED) + return EAGAIN; + int ret = mprotect(reinterpret_cast<void*>(map + *guard_size), *stack_size, + PROT_READ | PROT_WRITE); + if(ret) + return EAGAIN; + } + + *stack_base = reinterpret_cast<void*>(map); + auto sp = reinterpret_cast<uintptr_t*>(map + *guard_size + *stack_size); + *--sp = reinterpret_cast<uintptr_t>(user_arg); + *--sp = reinterpret_cast<uintptr_t>(entry); + *stack = reinterpret_cast<void*>(sp); + return 0; +} +} // namespace mlibc diff --git a/lib/mlibc/sysdeps/linux/include-internal/linux/unistd.h b/lib/mlibc/sysdeps/linux/include-internal/linux/unistd.h new file mode 100644 index 0000000..6a8020e --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include-internal/linux/unistd.h @@ -0,0 +1,2 @@ +/* stub header not present in practice, redirects to our internal syscallnos */ +#include <syscallnos.h> diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/access.h b/lib/mlibc/sysdeps/linux/include/abi-bits/access.h new file mode 120000 index 0000000..cb83931 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/access.h @@ -0,0 +1 @@ +../../../../abis/linux/access.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/auxv.h b/lib/mlibc/sysdeps/linux/include/abi-bits/auxv.h new file mode 120000 index 0000000..c43f878 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/auxv.h @@ -0,0 +1 @@ +../../../../abis/linux/auxv.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/blkcnt_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/blkcnt_t.h new file mode 120000 index 0000000..0b0ec27 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/blkcnt_t.h @@ -0,0 +1 @@ +../../../../abis/linux/blkcnt_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/blksize_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/blksize_t.h new file mode 120000 index 0000000..7dc8d7c --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/blksize_t.h @@ -0,0 +1 @@ +../../../../abis/linux/blksize_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/clockid_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/clockid_t.h new file mode 120000 index 0000000..6a42da5 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/clockid_t.h @@ -0,0 +1 @@ +../../../../abis/linux/clockid_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/dev_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/dev_t.h new file mode 120000 index 0000000..bca881e --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/dev_t.h @@ -0,0 +1 @@ +../../../../abis/linux/dev_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/epoll.h b/lib/mlibc/sysdeps/linux/include/abi-bits/epoll.h new file mode 120000 index 0000000..eb4b76d --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/epoll.h @@ -0,0 +1 @@ +../../../../abis/linux/epoll.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/errno.h b/lib/mlibc/sysdeps/linux/include/abi-bits/errno.h new file mode 120000 index 0000000..6e507de --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/errno.h @@ -0,0 +1 @@ +../../../../abis/linux/errno.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/fcntl.h b/lib/mlibc/sysdeps/linux/include/abi-bits/fcntl.h new file mode 120000 index 0000000..463e2c9 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/fcntl.h @@ -0,0 +1 @@ +../../../../abis/linux/fcntl.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/fsblkcnt_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/fsblkcnt_t.h new file mode 120000 index 0000000..898dfb2 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/fsblkcnt_t.h @@ -0,0 +1 @@ +../../../../abis/linux/fsblkcnt_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/fsfilcnt_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/fsfilcnt_t.h new file mode 120000 index 0000000..791755c --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/fsfilcnt_t.h @@ -0,0 +1 @@ +../../../../abis/linux/fsfilcnt_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/gid_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/gid_t.h new file mode 120000 index 0000000..abce6d6 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/gid_t.h @@ -0,0 +1 @@ +../../../../abis/linux/gid_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/in.h b/lib/mlibc/sysdeps/linux/include/abi-bits/in.h new file mode 120000 index 0000000..418d1d5 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/in.h @@ -0,0 +1 @@ +../../../../abis/linux/in.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/ino_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/ino_t.h new file mode 120000 index 0000000..4c20aca --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/ino_t.h @@ -0,0 +1 @@ +../../../../abis/linux/ino_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/inotify.h b/lib/mlibc/sysdeps/linux/include/abi-bits/inotify.h new file mode 120000 index 0000000..b5cb282 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/inotify.h @@ -0,0 +1 @@ +../../../../abis/linux/inotify.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/ioctls.h b/lib/mlibc/sysdeps/linux/include/abi-bits/ioctls.h new file mode 120000 index 0000000..595106b --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/ioctls.h @@ -0,0 +1 @@ +../../../../abis/linux/ioctls.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/limits.h b/lib/mlibc/sysdeps/linux/include/abi-bits/limits.h new file mode 120000 index 0000000..6c88db2 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/limits.h @@ -0,0 +1 @@ +../../../../abis/linux/limits.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/mode_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/mode_t.h new file mode 120000 index 0000000..5d78fdf --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/mode_t.h @@ -0,0 +1 @@ +../../../../abis/linux/mode_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/mqueue.h b/lib/mlibc/sysdeps/linux/include/abi-bits/mqueue.h new file mode 120000 index 0000000..fa87b07 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/mqueue.h @@ -0,0 +1 @@ +../../../../abis/linux/mqueue.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/msg.h b/lib/mlibc/sysdeps/linux/include/abi-bits/msg.h new file mode 120000 index 0000000..f402b49 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/msg.h @@ -0,0 +1 @@ +../../../../abis/linux/msg.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/nlink_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/nlink_t.h new file mode 120000 index 0000000..bb3b625 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/nlink_t.h @@ -0,0 +1 @@ +../../../../abis/linux/nlink_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/packet.h b/lib/mlibc/sysdeps/linux/include/abi-bits/packet.h new file mode 120000 index 0000000..998ef1a --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/packet.h @@ -0,0 +1 @@ +../../../../abis/linux/packet.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/pid_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/pid_t.h new file mode 120000 index 0000000..baa90f6 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/pid_t.h @@ -0,0 +1 @@ +../../../../abis/linux/pid_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/poll.h b/lib/mlibc/sysdeps/linux/include/abi-bits/poll.h new file mode 120000 index 0000000..8ea6a0a --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/poll.h @@ -0,0 +1 @@ +../../../../abis/linux/poll.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/ptrace.h b/lib/mlibc/sysdeps/linux/include/abi-bits/ptrace.h new file mode 120000 index 0000000..b2517b2 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/ptrace.h @@ -0,0 +1 @@ +../../../../abis/linux/ptrace.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/reboot.h b/lib/mlibc/sysdeps/linux/include/abi-bits/reboot.h new file mode 120000 index 0000000..77013a4 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/reboot.h @@ -0,0 +1 @@ +../../../../abis/linux/reboot.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/resource.h b/lib/mlibc/sysdeps/linux/include/abi-bits/resource.h new file mode 120000 index 0000000..88d7402 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/resource.h @@ -0,0 +1 @@ +../../../../abis/linux/resource.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/seek-whence.h b/lib/mlibc/sysdeps/linux/include/abi-bits/seek-whence.h new file mode 120000 index 0000000..df7bccf --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/seek-whence.h @@ -0,0 +1 @@ +../../../../abis/linux/seek-whence.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/shm.h b/lib/mlibc/sysdeps/linux/include/abi-bits/shm.h new file mode 120000 index 0000000..067d8c4 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/shm.h @@ -0,0 +1 @@ +../../../../abis/linux/shm.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/signal.h b/lib/mlibc/sysdeps/linux/include/abi-bits/signal.h new file mode 120000 index 0000000..4dcb0b7 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/signal.h @@ -0,0 +1 @@ +../../../../abis/linux/signal.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/socket.h b/lib/mlibc/sysdeps/linux/include/abi-bits/socket.h new file mode 120000 index 0000000..f1dc016 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/socket.h @@ -0,0 +1 @@ +../../../../abis/linux/socket.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/socklen_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/socklen_t.h new file mode 120000 index 0000000..41f3b11 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/socklen_t.h @@ -0,0 +1 @@ +../../../../abis/linux/socklen_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/stat.h b/lib/mlibc/sysdeps/linux/include/abi-bits/stat.h new file mode 120000 index 0000000..1f63b41 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/stat.h @@ -0,0 +1 @@ +../../../../abis/linux/stat.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/statfs.h b/lib/mlibc/sysdeps/linux/include/abi-bits/statfs.h new file mode 120000 index 0000000..e3d202f --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/statfs.h @@ -0,0 +1 @@ +../../../../abis/linux/statfs.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/statvfs.h b/lib/mlibc/sysdeps/linux/include/abi-bits/statvfs.h new file mode 120000 index 0000000..1fc80c2 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/statvfs.h @@ -0,0 +1 @@ +../../../../abis/linux/statvfs.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/suseconds_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/suseconds_t.h new file mode 120000 index 0000000..9ed6597 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/suseconds_t.h @@ -0,0 +1 @@ +../../../../abis/linux/suseconds_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/termios.h b/lib/mlibc/sysdeps/linux/include/abi-bits/termios.h new file mode 120000 index 0000000..ee8f0b0 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/termios.h @@ -0,0 +1 @@ +../../../../abis/linux/termios.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/time.h b/lib/mlibc/sysdeps/linux/include/abi-bits/time.h new file mode 120000 index 0000000..2a02625 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/time.h @@ -0,0 +1 @@ +../../../../abis/linux/time.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/uid_t.h b/lib/mlibc/sysdeps/linux/include/abi-bits/uid_t.h new file mode 120000 index 0000000..b306777 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/uid_t.h @@ -0,0 +1 @@ +../../../../abis/linux/uid_t.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/utsname.h b/lib/mlibc/sysdeps/linux/include/abi-bits/utsname.h new file mode 120000 index 0000000..b285754 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/utsname.h @@ -0,0 +1 @@ +../../../../abis/linux/utsname.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/vm-flags.h b/lib/mlibc/sysdeps/linux/include/abi-bits/vm-flags.h new file mode 120000 index 0000000..bbe258c --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/vm-flags.h @@ -0,0 +1 @@ +../../../../abis/linux/vm-flags.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/vt.h b/lib/mlibc/sysdeps/linux/include/abi-bits/vt.h new file mode 120000 index 0000000..5798a4a --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/vt.h @@ -0,0 +1 @@ +../../../../abis/linux/vt.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/wait.h b/lib/mlibc/sysdeps/linux/include/abi-bits/wait.h new file mode 120000 index 0000000..feb2840 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/wait.h @@ -0,0 +1 @@ +../../../../abis/linux/wait.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/abi-bits/xattr.h b/lib/mlibc/sysdeps/linux/include/abi-bits/xattr.h new file mode 120000 index 0000000..66412d7 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/abi-bits/xattr.h @@ -0,0 +1 @@ +../../../../abis/linux/xattr.h
\ No newline at end of file diff --git a/lib/mlibc/sysdeps/linux/include/bits/syscall.h b/lib/mlibc/sysdeps/linux/include/bits/syscall.h new file mode 100644 index 0000000..3023a3b --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/bits/syscall.h @@ -0,0 +1,90 @@ +#ifndef _MLIBC_SYSCALL_H +#define _MLIBC_SYSCALL_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef long __sc_word_t; + +/* These functions are implemented in arch-syscall.cpp. */ +__sc_word_t __do_syscall0(long); +__sc_word_t __do_syscall1(long, __sc_word_t); +__sc_word_t __do_syscall2(long, __sc_word_t, __sc_word_t); +__sc_word_t __do_syscall3(long, __sc_word_t, __sc_word_t, __sc_word_t); +__sc_word_t __do_syscall4(long, __sc_word_t, __sc_word_t, __sc_word_t, __sc_word_t); +__sc_word_t __do_syscall5(long, __sc_word_t, __sc_word_t, __sc_word_t, __sc_word_t, + __sc_word_t); +__sc_word_t __do_syscall6(long, __sc_word_t, __sc_word_t, __sc_word_t, __sc_word_t, + __sc_word_t, __sc_word_t); +__sc_word_t __do_syscall7(long, __sc_word_t, __sc_word_t, __sc_word_t, __sc_word_t, + __sc_word_t, __sc_word_t, __sc_word_t); +long __do_syscall_ret(unsigned long); + +#ifdef __cplusplus +extern "C++" { + +/* Defining a syscall as a macro is more problematic in C++, since there's a high chance of + * a name collision e.g foo.syscall() or foo::syscall. + */ +template<typename Arg0> +long syscall(long n) { + return __do_syscall_ret(__do_syscall0(n)); +} +template<typename Arg0> +long syscall(long n, Arg0 a0) { + return __do_syscall_ret(__do_syscall1(n, (long)a0)); +} +template<typename Arg0, typename Arg1> +long syscall(long n, Arg0 a0, Arg1 a1) { + return __do_syscall_ret(__do_syscall2(n, (long)a0, (long)a1)); +} +template<typename Arg0, typename Arg1, typename Arg2> +long syscall(long n, Arg0 a0, Arg1 a1, Arg2 a2) { + return __do_syscall_ret(__do_syscall3(n, (long)a0, (long)a1, (long)a2)); +} +template<typename Arg0, typename Arg1, typename Arg2, typename Arg3> +long syscall(long n, Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) { + return __do_syscall_ret(__do_syscall4(n, (long)a0, (long)a1, (long)a2, (long)a3)); +} +template<typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4> +long syscall(long n, Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) { + return __do_syscall_ret(__do_syscall5(n, (long)a0, (long)a1, (long)a2, (long)a3, (long)a4)); +} +template<typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> +long syscall(long n, Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) { + return __do_syscall_ret(__do_syscall6(n, (long)a0, (long)a1, (long)a2, (long)a3, (long)a4, (long)a5)); +} +template<typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6> +long syscall(long n, Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5, Arg6 a6) { + return __do_syscall_ret(__do_syscall7(n, (long)a0, (long)a1, (long)a2, (long)a3, (long)a4, (long)a5, (long)a6)); +} + +} /* extern C++ */ +#else + +/* These syscall macros were copied from musl. */ +#define __scc(x) ((__sc_word_t)(x)) +#define __syscall0(n) __do_syscall0(n) +#define __syscall1(n,a) __do_syscall1(n,__scc(a)) +#define __syscall2(n,a,b) __do_syscall2(n,__scc(a),__scc(b)) +#define __syscall3(n,a,b,c) __do_syscall3(n,__scc(a),__scc(b),__scc(c)) +#define __syscall4(n,a,b,c,d) __do_syscall4(n,__scc(a),__scc(b),__scc(c),__scc(d)) +#define __syscall5(n,a,b,c,d,e) __do_syscall5(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e)) +#define __syscall6(n,a,b,c,d,e,f) __do_syscall6(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),__scc(f)) +#define __syscall7(n,a,b,c,d,e,f,g) __do_syscall7(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),__scc(f),__scc(g)) +#define __SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n +#define __SYSCALL_NARGS(...) __SYSCALL_NARGS_X(__VA_ARGS__,7,6,5,4,3,2,1,0,) +#define __SYSCALL_CONCAT_X(a,b) a##b +#define __SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X(a,b) +#define __SYSCALL_DISP(b,...) __SYSCALL_CONCAT(b,__SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__) +#define __syscall(...) __SYSCALL_DISP(__syscall,__VA_ARGS__) +#define syscall(...) __do_syscall_ret(__syscall(__VA_ARGS__)) + +#endif + +#ifdef __cplusplus +} +#endif + +#endif // _MLIBC_SYSCALL_H diff --git a/lib/mlibc/sysdeps/linux/include/bits/syscall_aliases.h b/lib/mlibc/sysdeps/linux/include/bits/syscall_aliases.h new file mode 100644 index 0000000..b929efc --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/bits/syscall_aliases.h @@ -0,0 +1,1823 @@ +#ifndef __MLIBC_SYSCALL_ALIAS_BIT +#define __MLIBC_SYSCALL_ALIAS_BIT +/* This file is autogenerated. Don't bother. */ +/* Generator script: sysdeps/linux/update-syscall-list.py. */ +#ifdef __NR__llseek +# define SYS__llseek __NR__llseek +#endif +#ifdef __NR__newselect +# define SYS__newselect __NR__newselect +#endif +#ifdef __NR__sysctl +# define SYS__sysctl __NR__sysctl +#endif +#ifdef __NR_accept +# define SYS_accept __NR_accept +#endif +#ifdef __NR_accept4 +# define SYS_accept4 __NR_accept4 +#endif +#ifdef __NR_access +# define SYS_access __NR_access +#endif +#ifdef __NR_acct +# define SYS_acct __NR_acct +#endif +#ifdef __NR_add_key +# define SYS_add_key __NR_add_key +#endif +#ifdef __NR_adjtimex +# define SYS_adjtimex __NR_adjtimex +#endif +#ifdef __NR_alarm +# define SYS_alarm __NR_alarm +#endif +#ifdef __NR_arc_gettls +# define SYS_arc_gettls __NR_arc_gettls +#endif +#ifdef __NR_arc_settls +# define SYS_arc_settls __NR_arc_settls +#endif +#ifdef __NR_arc_usr_cmpxchg +# define SYS_arc_usr_cmpxchg __NR_arc_usr_cmpxchg +#endif +#ifdef __NR_arch_prctl +# define SYS_arch_prctl __NR_arch_prctl +#endif +#ifdef __NR_arch_specific_syscall +# define SYS_arch_specific_syscall __NR_arch_specific_syscall +#endif +#ifdef __NR_arm_fadvise64_64 +# define SYS_arm_fadvise64_64 __NR_arm_fadvise64_64 +#endif +#ifdef __NR_atomic_barrier +# define SYS_atomic_barrier __NR_atomic_barrier +#endif +#ifdef __NR_atomic_cmpxchg_32 +# define SYS_atomic_cmpxchg_32 __NR_atomic_cmpxchg_32 +#endif +#ifdef __NR_bdflush +# define SYS_bdflush __NR_bdflush +#endif +#ifdef __NR_bind +# define SYS_bind __NR_bind +#endif +#ifdef __NR_bpf +# define SYS_bpf __NR_bpf +#endif +#ifdef __NR_brk +# define SYS_brk __NR_brk +#endif +#ifdef __NR_cachectl +# define SYS_cachectl __NR_cachectl +#endif +#ifdef __NR_cacheflush +# define SYS_cacheflush __NR_cacheflush +#endif +#ifdef __NR_capget +# define SYS_capget __NR_capget +#endif +#ifdef __NR_capset +# define SYS_capset __NR_capset +#endif +#ifdef __NR_chdir +# define SYS_chdir __NR_chdir +#endif +#ifdef __NR_chmod +# define SYS_chmod __NR_chmod +#endif +#ifdef __NR_chown +# define SYS_chown __NR_chown +#endif +#ifdef __NR_chown32 +# define SYS_chown32 __NR_chown32 +#endif +#ifdef __NR_chroot +# define SYS_chroot __NR_chroot +#endif +#ifdef __NR_clock_adjtime +# define SYS_clock_adjtime __NR_clock_adjtime +#endif +#ifdef __NR_clock_adjtime64 +# define SYS_clock_adjtime64 __NR_clock_adjtime64 +#endif +#ifdef __NR_clock_getres +# define SYS_clock_getres __NR_clock_getres +#endif +#ifdef __NR_clock_getres_time64 +# define SYS_clock_getres_time64 __NR_clock_getres_time64 +#endif +#ifdef __NR_clock_gettime +# define SYS_clock_gettime __NR_clock_gettime +#endif +#ifdef __NR_clock_gettime64 +# define SYS_clock_gettime64 __NR_clock_gettime64 +#endif +#ifdef __NR_clock_nanosleep +# define SYS_clock_nanosleep __NR_clock_nanosleep +#endif +#ifdef __NR_clock_nanosleep_time64 +# define SYS_clock_nanosleep_time64 __NR_clock_nanosleep_time64 +#endif +#ifdef __NR_clock_settime +# define SYS_clock_settime __NR_clock_settime +#endif +#ifdef __NR_clock_settime64 +# define SYS_clock_settime64 __NR_clock_settime64 +#endif +#ifdef __NR_clone +# define SYS_clone __NR_clone +#endif +#ifdef __NR_clone2 +# define SYS_clone2 __NR_clone2 +#endif +#ifdef __NR_clone3 +# define SYS_clone3 __NR_clone3 +#endif +#ifdef __NR_close +# define SYS_close __NR_close +#endif +#ifdef __NR_close_range +# define SYS_close_range __NR_close_range +#endif +#ifdef __NR_connect +# define SYS_connect __NR_connect +#endif +#ifdef __NR_copy_file_range +# define SYS_copy_file_range __NR_copy_file_range +#endif +#ifdef __NR_creat +# define SYS_creat __NR_creat +#endif +#ifdef __NR_create_module +# define SYS_create_module __NR_create_module +#endif +#ifdef __NR_delete_module +# define SYS_delete_module __NR_delete_module +#endif +#ifdef __NR_dipc +# define SYS_dipc __NR_dipc +#endif +#ifdef __NR_dup +# define SYS_dup __NR_dup +#endif +#ifdef __NR_dup2 +# define SYS_dup2 __NR_dup2 +#endif +#ifdef __NR_dup3 +# define SYS_dup3 __NR_dup3 +#endif +#ifdef __NR_epoll_create +# define SYS_epoll_create __NR_epoll_create +#endif +#ifdef __NR_epoll_create1 +# define SYS_epoll_create1 __NR_epoll_create1 +#endif +#ifdef __NR_epoll_ctl +# define SYS_epoll_ctl __NR_epoll_ctl +#endif +#ifdef __NR_epoll_ctl_old +# define SYS_epoll_ctl_old __NR_epoll_ctl_old +#endif +#ifdef __NR_epoll_pwait +# define SYS_epoll_pwait __NR_epoll_pwait +#endif +#ifdef __NR_epoll_pwait2 +# define SYS_epoll_pwait2 __NR_epoll_pwait2 +#endif +#ifdef __NR_epoll_wait +# define SYS_epoll_wait __NR_epoll_wait +#endif +#ifdef __NR_epoll_wait_old +# define SYS_epoll_wait_old __NR_epoll_wait_old +#endif +#ifdef __NR_eventfd +# define SYS_eventfd __NR_eventfd +#endif +#ifdef __NR_eventfd2 +# define SYS_eventfd2 __NR_eventfd2 +#endif +#ifdef __NR_exec_with_loader +# define SYS_exec_with_loader __NR_exec_with_loader +#endif +#ifdef __NR_execv +# define SYS_execv __NR_execv +#endif +#ifdef __NR_execve +# define SYS_execve __NR_execve +#endif +#ifdef __NR_execveat +# define SYS_execveat __NR_execveat +#endif +#ifdef __NR_exit +# define SYS_exit __NR_exit +#endif +#ifdef __NR_exit_group +# define SYS_exit_group __NR_exit_group +#endif +#ifdef __NR_faccessat +# define SYS_faccessat __NR_faccessat +#endif +#ifdef __NR_faccessat2 +# define SYS_faccessat2 __NR_faccessat2 +#endif +#ifdef __NR_fadvise64 +# define SYS_fadvise64 __NR_fadvise64 +#endif +#ifdef __NR_fadvise64_64 +# define SYS_fadvise64_64 __NR_fadvise64_64 +#endif +#ifdef __NR_fallocate +# define SYS_fallocate __NR_fallocate +#endif +#ifdef __NR_fanotify_init +# define SYS_fanotify_init __NR_fanotify_init +#endif +#ifdef __NR_fanotify_mark +# define SYS_fanotify_mark __NR_fanotify_mark +#endif +#ifdef __NR_fchdir +# define SYS_fchdir __NR_fchdir +#endif +#ifdef __NR_fchmod +# define SYS_fchmod __NR_fchmod +#endif +#ifdef __NR_fchmodat +# define SYS_fchmodat __NR_fchmodat +#endif +#ifdef __NR_fchown +# define SYS_fchown __NR_fchown +#endif +#ifdef __NR_fchown32 +# define SYS_fchown32 __NR_fchown32 +#endif +#ifdef __NR_fchownat +# define SYS_fchownat __NR_fchownat +#endif +#ifdef __NR_fcntl +# define SYS_fcntl __NR_fcntl +#endif +#ifdef __NR_fcntl64 +# define SYS_fcntl64 __NR_fcntl64 +#endif +#ifdef __NR_fdatasync +# define SYS_fdatasync __NR_fdatasync +#endif +#ifdef __NR_fgetxattr +# define SYS_fgetxattr __NR_fgetxattr +#endif +#ifdef __NR_finit_module +# define SYS_finit_module __NR_finit_module +#endif +#ifdef __NR_flistxattr +# define SYS_flistxattr __NR_flistxattr +#endif +#ifdef __NR_flock +# define SYS_flock __NR_flock +#endif +#ifdef __NR_fork +# define SYS_fork __NR_fork +#endif +#ifdef __NR_fremovexattr +# define SYS_fremovexattr __NR_fremovexattr +#endif +#ifdef __NR_fsconfig +# define SYS_fsconfig __NR_fsconfig +#endif +#ifdef __NR_fsetxattr +# define SYS_fsetxattr __NR_fsetxattr +#endif +#ifdef __NR_fsmount +# define SYS_fsmount __NR_fsmount +#endif +#ifdef __NR_fsopen +# define SYS_fsopen __NR_fsopen +#endif +#ifdef __NR_fspick +# define SYS_fspick __NR_fspick +#endif +#ifdef __NR_fstat +# define SYS_fstat __NR_fstat +#endif +#ifdef __NR_fstat64 +# define SYS_fstat64 __NR_fstat64 +#endif +#ifdef __NR_fstatat64 +# define SYS_fstatat64 __NR_fstatat64 +#endif +#ifdef __NR_fstatfs +# define SYS_fstatfs __NR_fstatfs +#endif +#ifdef __NR_fstatfs64 +# define SYS_fstatfs64 __NR_fstatfs64 +#endif +#ifdef __NR_fsync +# define SYS_fsync __NR_fsync +#endif +#ifdef __NR_ftruncate +# define SYS_ftruncate __NR_ftruncate +#endif +#ifdef __NR_ftruncate64 +# define SYS_ftruncate64 __NR_ftruncate64 +#endif +#ifdef __NR_futex +# define SYS_futex __NR_futex +#endif +#ifdef __NR_futex_time64 +# define SYS_futex_time64 __NR_futex_time64 +#endif +#ifdef __NR_futex_waitv +# define SYS_futex_waitv __NR_futex_waitv +#endif +#ifdef __NR_futimesat +# define SYS_futimesat __NR_futimesat +#endif +#ifdef __NR_get_kernel_syms +# define SYS_get_kernel_syms __NR_get_kernel_syms +#endif +#ifdef __NR_get_mempolicy +# define SYS_get_mempolicy __NR_get_mempolicy +#endif +#ifdef __NR_get_robust_list +# define SYS_get_robust_list __NR_get_robust_list +#endif +#ifdef __NR_get_thread_area +# define SYS_get_thread_area __NR_get_thread_area +#endif +#ifdef __NR_getcpu +# define SYS_getcpu __NR_getcpu +#endif +#ifdef __NR_getcwd +# define SYS_getcwd __NR_getcwd +#endif +#ifdef __NR_getdents +# define SYS_getdents __NR_getdents +#endif +#ifdef __NR_getdents64 +# define SYS_getdents64 __NR_getdents64 +#endif +#ifdef __NR_getdomainname +# define SYS_getdomainname __NR_getdomainname +#endif +#ifdef __NR_getdtablesize +# define SYS_getdtablesize __NR_getdtablesize +#endif +#ifdef __NR_getegid +# define SYS_getegid __NR_getegid +#endif +#ifdef __NR_getegid32 +# define SYS_getegid32 __NR_getegid32 +#endif +#ifdef __NR_geteuid +# define SYS_geteuid __NR_geteuid +#endif +#ifdef __NR_geteuid32 +# define SYS_geteuid32 __NR_geteuid32 +#endif +#ifdef __NR_getgid +# define SYS_getgid __NR_getgid +#endif +#ifdef __NR_getgid32 +# define SYS_getgid32 __NR_getgid32 +#endif +#ifdef __NR_getgroups +# define SYS_getgroups __NR_getgroups +#endif +#ifdef __NR_getgroups32 +# define SYS_getgroups32 __NR_getgroups32 +#endif +#ifdef __NR_gethostname +# define SYS_gethostname __NR_gethostname +#endif +#ifdef __NR_getitimer +# define SYS_getitimer __NR_getitimer +#endif +#ifdef __NR_getpagesize +# define SYS_getpagesize __NR_getpagesize +#endif +#ifdef __NR_getpeername +# define SYS_getpeername __NR_getpeername +#endif +#ifdef __NR_getpgid +# define SYS_getpgid __NR_getpgid +#endif +#ifdef __NR_getpgrp +# define SYS_getpgrp __NR_getpgrp +#endif +#ifdef __NR_getpid +# define SYS_getpid __NR_getpid +#endif +#ifdef __NR_getpmsg +# define SYS_getpmsg __NR_getpmsg +#endif +#ifdef __NR_getppid +# define SYS_getppid __NR_getppid +#endif +#ifdef __NR_getpriority +# define SYS_getpriority __NR_getpriority +#endif +#ifdef __NR_getrandom +# define SYS_getrandom __NR_getrandom +#endif +#ifdef __NR_getresgid +# define SYS_getresgid __NR_getresgid +#endif +#ifdef __NR_getresgid32 +# define SYS_getresgid32 __NR_getresgid32 +#endif +#ifdef __NR_getresuid +# define SYS_getresuid __NR_getresuid +#endif +#ifdef __NR_getresuid32 +# define SYS_getresuid32 __NR_getresuid32 +#endif +#ifdef __NR_getrlimit +# define SYS_getrlimit __NR_getrlimit +#endif +#ifdef __NR_getrusage +# define SYS_getrusage __NR_getrusage +#endif +#ifdef __NR_getsid +# define SYS_getsid __NR_getsid +#endif +#ifdef __NR_getsockname +# define SYS_getsockname __NR_getsockname +#endif +#ifdef __NR_getsockopt +# define SYS_getsockopt __NR_getsockopt +#endif +#ifdef __NR_gettid +# define SYS_gettid __NR_gettid +#endif +#ifdef __NR_gettimeofday +# define SYS_gettimeofday __NR_gettimeofday +#endif +#ifdef __NR_getuid +# define SYS_getuid __NR_getuid +#endif +#ifdef __NR_getuid32 +# define SYS_getuid32 __NR_getuid32 +#endif +#ifdef __NR_getunwind +# define SYS_getunwind __NR_getunwind +#endif +#ifdef __NR_getxattr +# define SYS_getxattr __NR_getxattr +#endif +#ifdef __NR_getxgid +# define SYS_getxgid __NR_getxgid +#endif +#ifdef __NR_getxpid +# define SYS_getxpid __NR_getxpid +#endif +#ifdef __NR_getxuid +# define SYS_getxuid __NR_getxuid +#endif +#ifdef __NR_idle +# define SYS_idle __NR_idle +#endif +#ifdef __NR_init_module +# define SYS_init_module __NR_init_module +#endif +#ifdef __NR_inotify_add_watch +# define SYS_inotify_add_watch __NR_inotify_add_watch +#endif +#ifdef __NR_inotify_init +# define SYS_inotify_init __NR_inotify_init +#endif +#ifdef __NR_inotify_init1 +# define SYS_inotify_init1 __NR_inotify_init1 +#endif +#ifdef __NR_inotify_rm_watch +# define SYS_inotify_rm_watch __NR_inotify_rm_watch +#endif +#ifdef __NR_io_cancel +# define SYS_io_cancel __NR_io_cancel +#endif +#ifdef __NR_io_destroy +# define SYS_io_destroy __NR_io_destroy +#endif +#ifdef __NR_io_getevents +# define SYS_io_getevents __NR_io_getevents +#endif +#ifdef __NR_io_pgetevents +# define SYS_io_pgetevents __NR_io_pgetevents +#endif +#ifdef __NR_io_pgetevents_time64 +# define SYS_io_pgetevents_time64 __NR_io_pgetevents_time64 +#endif +#ifdef __NR_io_setup +# define SYS_io_setup __NR_io_setup +#endif +#ifdef __NR_io_submit +# define SYS_io_submit __NR_io_submit +#endif +#ifdef __NR_io_uring_enter +# define SYS_io_uring_enter __NR_io_uring_enter +#endif +#ifdef __NR_io_uring_register +# define SYS_io_uring_register __NR_io_uring_register +#endif +#ifdef __NR_io_uring_setup +# define SYS_io_uring_setup __NR_io_uring_setup +#endif +#ifdef __NR_ioctl +# define SYS_ioctl __NR_ioctl +#endif +#ifdef __NR_ioperm +# define SYS_ioperm __NR_ioperm +#endif +#ifdef __NR_iopl +# define SYS_iopl __NR_iopl +#endif +#ifdef __NR_ioprio_get +# define SYS_ioprio_get __NR_ioprio_get +#endif +#ifdef __NR_ioprio_set +# define SYS_ioprio_set __NR_ioprio_set +#endif +#ifdef __NR_ipc +# define SYS_ipc __NR_ipc +#endif +#ifdef __NR_kcmp +# define SYS_kcmp __NR_kcmp +#endif +#ifdef __NR_kern_features +# define SYS_kern_features __NR_kern_features +#endif +#ifdef __NR_kexec_file_load +# define SYS_kexec_file_load __NR_kexec_file_load +#endif +#ifdef __NR_kexec_load +# define SYS_kexec_load __NR_kexec_load +#endif +#ifdef __NR_keyctl +# define SYS_keyctl __NR_keyctl +#endif +#ifdef __NR_kill +# define SYS_kill __NR_kill +#endif +#ifdef __NR_landlock_add_rule +# define SYS_landlock_add_rule __NR_landlock_add_rule +#endif +#ifdef __NR_landlock_create_ruleset +# define SYS_landlock_create_ruleset __NR_landlock_create_ruleset +#endif +#ifdef __NR_landlock_restrict_self +# define SYS_landlock_restrict_self __NR_landlock_restrict_self +#endif +#ifdef __NR_lchown +# define SYS_lchown __NR_lchown +#endif +#ifdef __NR_lchown32 +# define SYS_lchown32 __NR_lchown32 +#endif +#ifdef __NR_lgetxattr +# define SYS_lgetxattr __NR_lgetxattr +#endif +#ifdef __NR_link +# define SYS_link __NR_link +#endif +#ifdef __NR_linkat +# define SYS_linkat __NR_linkat +#endif +#ifdef __NR_listen +# define SYS_listen __NR_listen +#endif +#ifdef __NR_listxattr +# define SYS_listxattr __NR_listxattr +#endif +#ifdef __NR_llistxattr +# define SYS_llistxattr __NR_llistxattr +#endif +#ifdef __NR_llseek +# define SYS_llseek __NR_llseek +#endif +#ifdef __NR_lookup_dcookie +# define SYS_lookup_dcookie __NR_lookup_dcookie +#endif +#ifdef __NR_lremovexattr +# define SYS_lremovexattr __NR_lremovexattr +#endif +#ifdef __NR_lseek +# define SYS_lseek __NR_lseek +#endif +#ifdef __NR_lsetxattr +# define SYS_lsetxattr __NR_lsetxattr +#endif +#ifdef __NR_lstat +# define SYS_lstat __NR_lstat +#endif +#ifdef __NR_lstat64 +# define SYS_lstat64 __NR_lstat64 +#endif +#ifdef __NR_madvise +# define SYS_madvise __NR_madvise +#endif +#ifdef __NR_mbind +# define SYS_mbind __NR_mbind +#endif +#ifdef __NR_membarrier +# define SYS_membarrier __NR_membarrier +#endif +#ifdef __NR_memfd_create +# define SYS_memfd_create __NR_memfd_create +#endif +#ifdef __NR_memfd_secret +# define SYS_memfd_secret __NR_memfd_secret +#endif +#ifdef __NR_memory_ordering +# define SYS_memory_ordering __NR_memory_ordering +#endif +#ifdef __NR_migrate_pages +# define SYS_migrate_pages __NR_migrate_pages +#endif +#ifdef __NR_mincore +# define SYS_mincore __NR_mincore +#endif +#ifdef __NR_mkdir +# define SYS_mkdir __NR_mkdir +#endif +#ifdef __NR_mkdirat +# define SYS_mkdirat __NR_mkdirat +#endif +#ifdef __NR_mknod +# define SYS_mknod __NR_mknod +#endif +#ifdef __NR_mknodat +# define SYS_mknodat __NR_mknodat +#endif +#ifdef __NR_mlock +# define SYS_mlock __NR_mlock +#endif +#ifdef __NR_mlock2 +# define SYS_mlock2 __NR_mlock2 +#endif +#ifdef __NR_mlockall +# define SYS_mlockall __NR_mlockall +#endif +#ifdef __NR_mmap +# define SYS_mmap __NR_mmap +#endif +#ifdef __NR_mmap2 +# define SYS_mmap2 __NR_mmap2 +#endif +#ifdef __NR_modify_ldt +# define SYS_modify_ldt __NR_modify_ldt +#endif +#ifdef __NR_mount +# define SYS_mount __NR_mount +#endif +#ifdef __NR_mount_setattr +# define SYS_mount_setattr __NR_mount_setattr +#endif +#ifdef __NR_move_mount +# define SYS_move_mount __NR_move_mount +#endif +#ifdef __NR_move_pages +# define SYS_move_pages __NR_move_pages +#endif +#ifdef __NR_mprotect +# define SYS_mprotect __NR_mprotect +#endif +#ifdef __NR_mq_getsetattr +# define SYS_mq_getsetattr __NR_mq_getsetattr +#endif +#ifdef __NR_mq_notify +# define SYS_mq_notify __NR_mq_notify +#endif +#ifdef __NR_mq_open +# define SYS_mq_open __NR_mq_open +#endif +#ifdef __NR_mq_timedreceive +# define SYS_mq_timedreceive __NR_mq_timedreceive +#endif +#ifdef __NR_mq_timedreceive_time64 +# define SYS_mq_timedreceive_time64 __NR_mq_timedreceive_time64 +#endif +#ifdef __NR_mq_timedsend +# define SYS_mq_timedsend __NR_mq_timedsend +#endif +#ifdef __NR_mq_timedsend_time64 +# define SYS_mq_timedsend_time64 __NR_mq_timedsend_time64 +#endif +#ifdef __NR_mq_unlink +# define SYS_mq_unlink __NR_mq_unlink +#endif +#ifdef __NR_mremap +# define SYS_mremap __NR_mremap +#endif +#ifdef __NR_msgctl +# define SYS_msgctl __NR_msgctl +#endif +#ifdef __NR_msgget +# define SYS_msgget __NR_msgget +#endif +#ifdef __NR_msgrcv +# define SYS_msgrcv __NR_msgrcv +#endif +#ifdef __NR_msgsnd +# define SYS_msgsnd __NR_msgsnd +#endif +#ifdef __NR_msync +# define SYS_msync __NR_msync +#endif +#ifdef __NR_multiplexer +# define SYS_multiplexer __NR_multiplexer +#endif +#ifdef __NR_munlock +# define SYS_munlock __NR_munlock +#endif +#ifdef __NR_munlockall +# define SYS_munlockall __NR_munlockall +#endif +#ifdef __NR_munmap +# define SYS_munmap __NR_munmap +#endif +#ifdef __NR_name_to_handle_at +# define SYS_name_to_handle_at __NR_name_to_handle_at +#endif +#ifdef __NR_nanosleep +# define SYS_nanosleep __NR_nanosleep +#endif +#ifdef __NR_newfstatat +# define SYS_newfstatat __NR_newfstatat +#endif +#ifdef __NR_nfsservctl +# define SYS_nfsservctl __NR_nfsservctl +#endif +#ifdef __NR_nice +# define SYS_nice __NR_nice +#endif +#ifdef __NR_old_adjtimex +# define SYS_old_adjtimex __NR_old_adjtimex +#endif +#ifdef __NR_old_getpagesize +# define SYS_old_getpagesize __NR_old_getpagesize +#endif +#ifdef __NR_oldfstat +# define SYS_oldfstat __NR_oldfstat +#endif +#ifdef __NR_oldlstat +# define SYS_oldlstat __NR_oldlstat +#endif +#ifdef __NR_oldolduname +# define SYS_oldolduname __NR_oldolduname +#endif +#ifdef __NR_oldstat +# define SYS_oldstat __NR_oldstat +#endif +#ifdef __NR_oldumount +# define SYS_oldumount __NR_oldumount +#endif +#ifdef __NR_olduname +# define SYS_olduname __NR_olduname +#endif +#ifdef __NR_open +# define SYS_open __NR_open +#endif +#ifdef __NR_open_by_handle_at +# define SYS_open_by_handle_at __NR_open_by_handle_at +#endif +#ifdef __NR_open_tree +# define SYS_open_tree __NR_open_tree +#endif +#ifdef __NR_openat +# define SYS_openat __NR_openat +#endif +#ifdef __NR_openat2 +# define SYS_openat2 __NR_openat2 +#endif +#ifdef __NR_or1k_atomic +# define SYS_or1k_atomic __NR_or1k_atomic +#endif +#ifdef __NR_osf_adjtime +# define SYS_osf_adjtime __NR_osf_adjtime +#endif +#ifdef __NR_osf_afs_syscall +# define SYS_osf_afs_syscall __NR_osf_afs_syscall +#endif +#ifdef __NR_osf_alt_plock +# define SYS_osf_alt_plock __NR_osf_alt_plock +#endif +#ifdef __NR_osf_alt_setsid +# define SYS_osf_alt_setsid __NR_osf_alt_setsid +#endif +#ifdef __NR_osf_alt_sigpending +# define SYS_osf_alt_sigpending __NR_osf_alt_sigpending +#endif +#ifdef __NR_osf_asynch_daemon +# define SYS_osf_asynch_daemon __NR_osf_asynch_daemon +#endif +#ifdef __NR_osf_audcntl +# define SYS_osf_audcntl __NR_osf_audcntl +#endif +#ifdef __NR_osf_audgen +# define SYS_osf_audgen __NR_osf_audgen +#endif +#ifdef __NR_osf_chflags +# define SYS_osf_chflags __NR_osf_chflags +#endif +#ifdef __NR_osf_execve +# define SYS_osf_execve __NR_osf_execve +#endif +#ifdef __NR_osf_exportfs +# define SYS_osf_exportfs __NR_osf_exportfs +#endif +#ifdef __NR_osf_fchflags +# define SYS_osf_fchflags __NR_osf_fchflags +#endif +#ifdef __NR_osf_fdatasync +# define SYS_osf_fdatasync __NR_osf_fdatasync +#endif +#ifdef __NR_osf_fpathconf +# define SYS_osf_fpathconf __NR_osf_fpathconf +#endif +#ifdef __NR_osf_fstat +# define SYS_osf_fstat __NR_osf_fstat +#endif +#ifdef __NR_osf_fstatfs +# define SYS_osf_fstatfs __NR_osf_fstatfs +#endif +#ifdef __NR_osf_fstatfs64 +# define SYS_osf_fstatfs64 __NR_osf_fstatfs64 +#endif +#ifdef __NR_osf_fuser +# define SYS_osf_fuser __NR_osf_fuser +#endif +#ifdef __NR_osf_getaddressconf +# define SYS_osf_getaddressconf __NR_osf_getaddressconf +#endif +#ifdef __NR_osf_getdirentries +# define SYS_osf_getdirentries __NR_osf_getdirentries +#endif +#ifdef __NR_osf_getdomainname +# define SYS_osf_getdomainname __NR_osf_getdomainname +#endif +#ifdef __NR_osf_getfh +# define SYS_osf_getfh __NR_osf_getfh +#endif +#ifdef __NR_osf_getfsstat +# define SYS_osf_getfsstat __NR_osf_getfsstat +#endif +#ifdef __NR_osf_gethostid +# define SYS_osf_gethostid __NR_osf_gethostid +#endif +#ifdef __NR_osf_getitimer +# define SYS_osf_getitimer __NR_osf_getitimer +#endif +#ifdef __NR_osf_getlogin +# define SYS_osf_getlogin __NR_osf_getlogin +#endif +#ifdef __NR_osf_getmnt +# define SYS_osf_getmnt __NR_osf_getmnt +#endif +#ifdef __NR_osf_getrusage +# define SYS_osf_getrusage __NR_osf_getrusage +#endif +#ifdef __NR_osf_getsysinfo +# define SYS_osf_getsysinfo __NR_osf_getsysinfo +#endif +#ifdef __NR_osf_gettimeofday +# define SYS_osf_gettimeofday __NR_osf_gettimeofday +#endif +#ifdef __NR_osf_kloadcall +# define SYS_osf_kloadcall __NR_osf_kloadcall +#endif +#ifdef __NR_osf_kmodcall +# define SYS_osf_kmodcall __NR_osf_kmodcall +#endif +#ifdef __NR_osf_lstat +# define SYS_osf_lstat __NR_osf_lstat +#endif +#ifdef __NR_osf_memcntl +# define SYS_osf_memcntl __NR_osf_memcntl +#endif +#ifdef __NR_osf_mincore +# define SYS_osf_mincore __NR_osf_mincore +#endif +#ifdef __NR_osf_mount +# define SYS_osf_mount __NR_osf_mount +#endif +#ifdef __NR_osf_mremap +# define SYS_osf_mremap __NR_osf_mremap +#endif +#ifdef __NR_osf_msfs_syscall +# define SYS_osf_msfs_syscall __NR_osf_msfs_syscall +#endif +#ifdef __NR_osf_msleep +# define SYS_osf_msleep __NR_osf_msleep +#endif +#ifdef __NR_osf_mvalid +# define SYS_osf_mvalid __NR_osf_mvalid +#endif +#ifdef __NR_osf_mwakeup +# define SYS_osf_mwakeup __NR_osf_mwakeup +#endif +#ifdef __NR_osf_naccept +# define SYS_osf_naccept __NR_osf_naccept +#endif +#ifdef __NR_osf_nfssvc +# define SYS_osf_nfssvc __NR_osf_nfssvc +#endif +#ifdef __NR_osf_ngetpeername +# define SYS_osf_ngetpeername __NR_osf_ngetpeername +#endif +#ifdef __NR_osf_ngetsockname +# define SYS_osf_ngetsockname __NR_osf_ngetsockname +#endif +#ifdef __NR_osf_nrecvfrom +# define SYS_osf_nrecvfrom __NR_osf_nrecvfrom +#endif +#ifdef __NR_osf_nrecvmsg +# define SYS_osf_nrecvmsg __NR_osf_nrecvmsg +#endif +#ifdef __NR_osf_nsendmsg +# define SYS_osf_nsendmsg __NR_osf_nsendmsg +#endif +#ifdef __NR_osf_ntp_adjtime +# define SYS_osf_ntp_adjtime __NR_osf_ntp_adjtime +#endif +#ifdef __NR_osf_ntp_gettime +# define SYS_osf_ntp_gettime __NR_osf_ntp_gettime +#endif +#ifdef __NR_osf_old_creat +# define SYS_osf_old_creat __NR_osf_old_creat +#endif +#ifdef __NR_osf_old_fstat +# define SYS_osf_old_fstat __NR_osf_old_fstat +#endif +#ifdef __NR_osf_old_getpgrp +# define SYS_osf_old_getpgrp __NR_osf_old_getpgrp +#endif +#ifdef __NR_osf_old_killpg +# define SYS_osf_old_killpg __NR_osf_old_killpg +#endif +#ifdef __NR_osf_old_lstat +# define SYS_osf_old_lstat __NR_osf_old_lstat +#endif +#ifdef __NR_osf_old_open +# define SYS_osf_old_open __NR_osf_old_open +#endif +#ifdef __NR_osf_old_sigaction +# define SYS_osf_old_sigaction __NR_osf_old_sigaction +#endif +#ifdef __NR_osf_old_sigblock +# define SYS_osf_old_sigblock __NR_osf_old_sigblock +#endif +#ifdef __NR_osf_old_sigreturn +# define SYS_osf_old_sigreturn __NR_osf_old_sigreturn +#endif +#ifdef __NR_osf_old_sigsetmask +# define SYS_osf_old_sigsetmask __NR_osf_old_sigsetmask +#endif +#ifdef __NR_osf_old_sigvec +# define SYS_osf_old_sigvec __NR_osf_old_sigvec +#endif +#ifdef __NR_osf_old_stat +# define SYS_osf_old_stat __NR_osf_old_stat +#endif +#ifdef __NR_osf_old_vadvise +# define SYS_osf_old_vadvise __NR_osf_old_vadvise +#endif +#ifdef __NR_osf_old_vtrace +# define SYS_osf_old_vtrace __NR_osf_old_vtrace +#endif +#ifdef __NR_osf_old_wait +# define SYS_osf_old_wait __NR_osf_old_wait +#endif +#ifdef __NR_osf_oldquota +# define SYS_osf_oldquota __NR_osf_oldquota +#endif +#ifdef __NR_osf_pathconf +# define SYS_osf_pathconf __NR_osf_pathconf +#endif +#ifdef __NR_osf_pid_block +# define SYS_osf_pid_block __NR_osf_pid_block +#endif +#ifdef __NR_osf_pid_unblock +# define SYS_osf_pid_unblock __NR_osf_pid_unblock +#endif +#ifdef __NR_osf_plock +# define SYS_osf_plock __NR_osf_plock +#endif +#ifdef __NR_osf_priocntlset +# define SYS_osf_priocntlset __NR_osf_priocntlset +#endif +#ifdef __NR_osf_profil +# define SYS_osf_profil __NR_osf_profil +#endif +#ifdef __NR_osf_proplist_syscall +# define SYS_osf_proplist_syscall __NR_osf_proplist_syscall +#endif +#ifdef __NR_osf_reboot +# define SYS_osf_reboot __NR_osf_reboot +#endif +#ifdef __NR_osf_revoke +# define SYS_osf_revoke __NR_osf_revoke +#endif +#ifdef __NR_osf_sbrk +# define SYS_osf_sbrk __NR_osf_sbrk +#endif +#ifdef __NR_osf_security +# define SYS_osf_security __NR_osf_security +#endif +#ifdef __NR_osf_select +# define SYS_osf_select __NR_osf_select +#endif +#ifdef __NR_osf_set_program_attributes +# define SYS_osf_set_program_attributes __NR_osf_set_program_attributes +#endif +#ifdef __NR_osf_set_speculative +# define SYS_osf_set_speculative __NR_osf_set_speculative +#endif +#ifdef __NR_osf_sethostid +# define SYS_osf_sethostid __NR_osf_sethostid +#endif +#ifdef __NR_osf_setitimer +# define SYS_osf_setitimer __NR_osf_setitimer +#endif +#ifdef __NR_osf_setlogin +# define SYS_osf_setlogin __NR_osf_setlogin +#endif +#ifdef __NR_osf_setsysinfo +# define SYS_osf_setsysinfo __NR_osf_setsysinfo +#endif +#ifdef __NR_osf_settimeofday +# define SYS_osf_settimeofday __NR_osf_settimeofday +#endif +#ifdef __NR_osf_shmat +# define SYS_osf_shmat __NR_osf_shmat +#endif +#ifdef __NR_osf_signal +# define SYS_osf_signal __NR_osf_signal +#endif +#ifdef __NR_osf_sigprocmask +# define SYS_osf_sigprocmask __NR_osf_sigprocmask +#endif +#ifdef __NR_osf_sigsendset +# define SYS_osf_sigsendset __NR_osf_sigsendset +#endif +#ifdef __NR_osf_sigstack +# define SYS_osf_sigstack __NR_osf_sigstack +#endif +#ifdef __NR_osf_sigwaitprim +# define SYS_osf_sigwaitprim __NR_osf_sigwaitprim +#endif +#ifdef __NR_osf_sstk +# define SYS_osf_sstk __NR_osf_sstk +#endif +#ifdef __NR_osf_stat +# define SYS_osf_stat __NR_osf_stat +#endif +#ifdef __NR_osf_statfs +# define SYS_osf_statfs __NR_osf_statfs +#endif +#ifdef __NR_osf_statfs64 +# define SYS_osf_statfs64 __NR_osf_statfs64 +#endif +#ifdef __NR_osf_subsys_info +# define SYS_osf_subsys_info __NR_osf_subsys_info +#endif +#ifdef __NR_osf_swapctl +# define SYS_osf_swapctl __NR_osf_swapctl +#endif +#ifdef __NR_osf_swapon +# define SYS_osf_swapon __NR_osf_swapon +#endif +#ifdef __NR_osf_syscall +# define SYS_osf_syscall __NR_osf_syscall +#endif +#ifdef __NR_osf_sysinfo +# define SYS_osf_sysinfo __NR_osf_sysinfo +#endif +#ifdef __NR_osf_table +# define SYS_osf_table __NR_osf_table +#endif +#ifdef __NR_osf_uadmin +# define SYS_osf_uadmin __NR_osf_uadmin +#endif +#ifdef __NR_osf_usleep_thread +# define SYS_osf_usleep_thread __NR_osf_usleep_thread +#endif +#ifdef __NR_osf_uswitch +# define SYS_osf_uswitch __NR_osf_uswitch +#endif +#ifdef __NR_osf_utc_adjtime +# define SYS_osf_utc_adjtime __NR_osf_utc_adjtime +#endif +#ifdef __NR_osf_utc_gettime +# define SYS_osf_utc_gettime __NR_osf_utc_gettime +#endif +#ifdef __NR_osf_utimes +# define SYS_osf_utimes __NR_osf_utimes +#endif +#ifdef __NR_osf_utsname +# define SYS_osf_utsname __NR_osf_utsname +#endif +#ifdef __NR_osf_wait4 +# define SYS_osf_wait4 __NR_osf_wait4 +#endif +#ifdef __NR_osf_waitid +# define SYS_osf_waitid __NR_osf_waitid +#endif +#ifdef __NR_pause +# define SYS_pause __NR_pause +#endif +#ifdef __NR_pciconfig_iobase +# define SYS_pciconfig_iobase __NR_pciconfig_iobase +#endif +#ifdef __NR_pciconfig_read +# define SYS_pciconfig_read __NR_pciconfig_read +#endif +#ifdef __NR_pciconfig_write +# define SYS_pciconfig_write __NR_pciconfig_write +#endif +#ifdef __NR_perf_event_open +# define SYS_perf_event_open __NR_perf_event_open +#endif +#ifdef __NR_perfctr +# define SYS_perfctr __NR_perfctr +#endif +#ifdef __NR_perfmonctl +# define SYS_perfmonctl __NR_perfmonctl +#endif +#ifdef __NR_personality +# define SYS_personality __NR_personality +#endif +#ifdef __NR_pidfd_getfd +# define SYS_pidfd_getfd __NR_pidfd_getfd +#endif +#ifdef __NR_pidfd_open +# define SYS_pidfd_open __NR_pidfd_open +#endif +#ifdef __NR_pidfd_send_signal +# define SYS_pidfd_send_signal __NR_pidfd_send_signal +#endif +#ifdef __NR_pipe +# define SYS_pipe __NR_pipe +#endif +#ifdef __NR_pipe2 +# define SYS_pipe2 __NR_pipe2 +#endif +#ifdef __NR_pivot_root +# define SYS_pivot_root __NR_pivot_root +#endif +#ifdef __NR_pkey_alloc +# define SYS_pkey_alloc __NR_pkey_alloc +#endif +#ifdef __NR_pkey_free +# define SYS_pkey_free __NR_pkey_free +#endif +#ifdef __NR_pkey_mprotect +# define SYS_pkey_mprotect __NR_pkey_mprotect +#endif +#ifdef __NR_poll +# define SYS_poll __NR_poll +#endif +#ifdef __NR_ppoll +# define SYS_ppoll __NR_ppoll +#endif +#ifdef __NR_ppoll_time64 +# define SYS_ppoll_time64 __NR_ppoll_time64 +#endif +#ifdef __NR_prctl +# define SYS_prctl __NR_prctl +#endif +#ifdef __NR_pread64 +# define SYS_pread64 __NR_pread64 +#endif +#ifdef __NR_preadv +# define SYS_preadv __NR_preadv +#endif +#ifdef __NR_preadv2 +# define SYS_preadv2 __NR_preadv2 +#endif +#ifdef __NR_prlimit64 +# define SYS_prlimit64 __NR_prlimit64 +#endif +#ifdef __NR_process_madvise +# define SYS_process_madvise __NR_process_madvise +#endif +#ifdef __NR_process_mrelease +# define SYS_process_mrelease __NR_process_mrelease +#endif +#ifdef __NR_process_vm_readv +# define SYS_process_vm_readv __NR_process_vm_readv +#endif +#ifdef __NR_process_vm_writev +# define SYS_process_vm_writev __NR_process_vm_writev +#endif +#ifdef __NR_pselect6 +# define SYS_pselect6 __NR_pselect6 +#endif +#ifdef __NR_pselect6_time64 +# define SYS_pselect6_time64 __NR_pselect6_time64 +#endif +#ifdef __NR_ptrace +# define SYS_ptrace __NR_ptrace +#endif +#ifdef __NR_pwrite64 +# define SYS_pwrite64 __NR_pwrite64 +#endif +#ifdef __NR_pwritev +# define SYS_pwritev __NR_pwritev +#endif +#ifdef __NR_pwritev2 +# define SYS_pwritev2 __NR_pwritev2 +#endif +#ifdef __NR_query_module +# define SYS_query_module __NR_query_module +#endif +#ifdef __NR_quotactl +# define SYS_quotactl __NR_quotactl +#endif +#ifdef __NR_quotactl_fd +# define SYS_quotactl_fd __NR_quotactl_fd +#endif +#ifdef __NR_read +# define SYS_read __NR_read +#endif +#ifdef __NR_readahead +# define SYS_readahead __NR_readahead +#endif +#ifdef __NR_readdir +# define SYS_readdir __NR_readdir +#endif +#ifdef __NR_readlink +# define SYS_readlink __NR_readlink +#endif +#ifdef __NR_readlinkat +# define SYS_readlinkat __NR_readlinkat +#endif +#ifdef __NR_readv +# define SYS_readv __NR_readv +#endif +#ifdef __NR_reboot +# define SYS_reboot __NR_reboot +#endif +#ifdef __NR_recv +# define SYS_recv __NR_recv +#endif +#ifdef __NR_recvfrom +# define SYS_recvfrom __NR_recvfrom +#endif +#ifdef __NR_recvmmsg +# define SYS_recvmmsg __NR_recvmmsg +#endif +#ifdef __NR_recvmmsg_time64 +# define SYS_recvmmsg_time64 __NR_recvmmsg_time64 +#endif +#ifdef __NR_recvmsg +# define SYS_recvmsg __NR_recvmsg +#endif +#ifdef __NR_remap_file_pages +# define SYS_remap_file_pages __NR_remap_file_pages +#endif +#ifdef __NR_removexattr +# define SYS_removexattr __NR_removexattr +#endif +#ifdef __NR_rename +# define SYS_rename __NR_rename +#endif +#ifdef __NR_renameat +# define SYS_renameat __NR_renameat +#endif +#ifdef __NR_renameat2 +# define SYS_renameat2 __NR_renameat2 +#endif +#ifdef __NR_request_key +# define SYS_request_key __NR_request_key +#endif +#ifdef __NR_restart_syscall +# define SYS_restart_syscall __NR_restart_syscall +#endif +#ifdef __NR_riscv_flush_icache +# define SYS_riscv_flush_icache __NR_riscv_flush_icache +#endif +#ifdef __NR_riscv_hwprobe +# define SYS_riscv_hwprobe __NR_riscv_hwprobe +#endif +#ifdef __NR_rmdir +# define SYS_rmdir __NR_rmdir +#endif +#ifdef __NR_rseq +# define SYS_rseq __NR_rseq +#endif +#ifdef __NR_rt_sigaction +# define SYS_rt_sigaction __NR_rt_sigaction +#endif +#ifdef __NR_rt_sigpending +# define SYS_rt_sigpending __NR_rt_sigpending +#endif +#ifdef __NR_rt_sigprocmask +# define SYS_rt_sigprocmask __NR_rt_sigprocmask +#endif +#ifdef __NR_rt_sigqueueinfo +# define SYS_rt_sigqueueinfo __NR_rt_sigqueueinfo +#endif +#ifdef __NR_rt_sigreturn +# define SYS_rt_sigreturn __NR_rt_sigreturn +#endif +#ifdef __NR_rt_sigsuspend +# define SYS_rt_sigsuspend __NR_rt_sigsuspend +#endif +#ifdef __NR_rt_sigtimedwait +# define SYS_rt_sigtimedwait __NR_rt_sigtimedwait +#endif +#ifdef __NR_rt_sigtimedwait_time64 +# define SYS_rt_sigtimedwait_time64 __NR_rt_sigtimedwait_time64 +#endif +#ifdef __NR_rt_tgsigqueueinfo +# define SYS_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo +#endif +#ifdef __NR_rtas +# define SYS_rtas __NR_rtas +#endif +#ifdef __NR_s390_guarded_storage +# define SYS_s390_guarded_storage __NR_s390_guarded_storage +#endif +#ifdef __NR_s390_pci_mmio_read +# define SYS_s390_pci_mmio_read __NR_s390_pci_mmio_read +#endif +#ifdef __NR_s390_pci_mmio_write +# define SYS_s390_pci_mmio_write __NR_s390_pci_mmio_write +#endif +#ifdef __NR_s390_runtime_instr +# define SYS_s390_runtime_instr __NR_s390_runtime_instr +#endif +#ifdef __NR_s390_sthyi +# define SYS_s390_sthyi __NR_s390_sthyi +#endif +#ifdef __NR_sched_get_affinity +# define SYS_sched_get_affinity __NR_sched_get_affinity +#endif +#ifdef __NR_sched_get_priority_max +# define SYS_sched_get_priority_max __NR_sched_get_priority_max +#endif +#ifdef __NR_sched_get_priority_min +# define SYS_sched_get_priority_min __NR_sched_get_priority_min +#endif +#ifdef __NR_sched_getaffinity +# define SYS_sched_getaffinity __NR_sched_getaffinity +#endif +#ifdef __NR_sched_getattr +# define SYS_sched_getattr __NR_sched_getattr +#endif +#ifdef __NR_sched_getparam +# define SYS_sched_getparam __NR_sched_getparam +#endif +#ifdef __NR_sched_getscheduler +# define SYS_sched_getscheduler __NR_sched_getscheduler +#endif +#ifdef __NR_sched_rr_get_interval +# define SYS_sched_rr_get_interval __NR_sched_rr_get_interval +#endif +#ifdef __NR_sched_rr_get_interval_time64 +# define SYS_sched_rr_get_interval_time64 __NR_sched_rr_get_interval_time64 +#endif +#ifdef __NR_sched_set_affinity +# define SYS_sched_set_affinity __NR_sched_set_affinity +#endif +#ifdef __NR_sched_setaffinity +# define SYS_sched_setaffinity __NR_sched_setaffinity +#endif +#ifdef __NR_sched_setattr +# define SYS_sched_setattr __NR_sched_setattr +#endif +#ifdef __NR_sched_setparam +# define SYS_sched_setparam __NR_sched_setparam +#endif +#ifdef __NR_sched_setscheduler +# define SYS_sched_setscheduler __NR_sched_setscheduler +#endif +#ifdef __NR_sched_yield +# define SYS_sched_yield __NR_sched_yield +#endif +#ifdef __NR_seccomp +# define SYS_seccomp __NR_seccomp +#endif +#ifdef __NR_select +# define SYS_select __NR_select +#endif +#ifdef __NR_semctl +# define SYS_semctl __NR_semctl +#endif +#ifdef __NR_semget +# define SYS_semget __NR_semget +#endif +#ifdef __NR_semop +# define SYS_semop __NR_semop +#endif +#ifdef __NR_semtimedop +# define SYS_semtimedop __NR_semtimedop +#endif +#ifdef __NR_semtimedop_time64 +# define SYS_semtimedop_time64 __NR_semtimedop_time64 +#endif +#ifdef __NR_send +# define SYS_send __NR_send +#endif +#ifdef __NR_sendfile +# define SYS_sendfile __NR_sendfile +#endif +#ifdef __NR_sendfile64 +# define SYS_sendfile64 __NR_sendfile64 +#endif +#ifdef __NR_sendmmsg +# define SYS_sendmmsg __NR_sendmmsg +#endif +#ifdef __NR_sendmsg +# define SYS_sendmsg __NR_sendmsg +#endif +#ifdef __NR_sendto +# define SYS_sendto __NR_sendto +#endif +#ifdef __NR_set_mempolicy +# define SYS_set_mempolicy __NR_set_mempolicy +#endif +#ifdef __NR_set_mempolicy_home_node +# define SYS_set_mempolicy_home_node __NR_set_mempolicy_home_node +#endif +#ifdef __NR_set_robust_list +# define SYS_set_robust_list __NR_set_robust_list +#endif +#ifdef __NR_set_thread_area +# define SYS_set_thread_area __NR_set_thread_area +#endif +#ifdef __NR_set_tid_address +# define SYS_set_tid_address __NR_set_tid_address +#endif +#ifdef __NR_setdomainname +# define SYS_setdomainname __NR_setdomainname +#endif +#ifdef __NR_setfsgid +# define SYS_setfsgid __NR_setfsgid +#endif +#ifdef __NR_setfsgid32 +# define SYS_setfsgid32 __NR_setfsgid32 +#endif +#ifdef __NR_setfsuid +# define SYS_setfsuid __NR_setfsuid +#endif +#ifdef __NR_setfsuid32 +# define SYS_setfsuid32 __NR_setfsuid32 +#endif +#ifdef __NR_setgid +# define SYS_setgid __NR_setgid +#endif +#ifdef __NR_setgid32 +# define SYS_setgid32 __NR_setgid32 +#endif +#ifdef __NR_setgroups +# define SYS_setgroups __NR_setgroups +#endif +#ifdef __NR_setgroups32 +# define SYS_setgroups32 __NR_setgroups32 +#endif +#ifdef __NR_sethae +# define SYS_sethae __NR_sethae +#endif +#ifdef __NR_sethostname +# define SYS_sethostname __NR_sethostname +#endif +#ifdef __NR_setitimer +# define SYS_setitimer __NR_setitimer +#endif +#ifdef __NR_setns +# define SYS_setns __NR_setns +#endif +#ifdef __NR_setpgid +# define SYS_setpgid __NR_setpgid +#endif +#ifdef __NR_setpgrp +# define SYS_setpgrp __NR_setpgrp +#endif +#ifdef __NR_setpriority +# define SYS_setpriority __NR_setpriority +#endif +#ifdef __NR_setregid +# define SYS_setregid __NR_setregid +#endif +#ifdef __NR_setregid32 +# define SYS_setregid32 __NR_setregid32 +#endif +#ifdef __NR_setresgid +# define SYS_setresgid __NR_setresgid +#endif +#ifdef __NR_setresgid32 +# define SYS_setresgid32 __NR_setresgid32 +#endif +#ifdef __NR_setresuid +# define SYS_setresuid __NR_setresuid +#endif +#ifdef __NR_setresuid32 +# define SYS_setresuid32 __NR_setresuid32 +#endif +#ifdef __NR_setreuid +# define SYS_setreuid __NR_setreuid +#endif +#ifdef __NR_setreuid32 +# define SYS_setreuid32 __NR_setreuid32 +#endif +#ifdef __NR_setrlimit +# define SYS_setrlimit __NR_setrlimit +#endif +#ifdef __NR_setsid +# define SYS_setsid __NR_setsid +#endif +#ifdef __NR_setsockopt +# define SYS_setsockopt __NR_setsockopt +#endif +#ifdef __NR_settimeofday +# define SYS_settimeofday __NR_settimeofday +#endif +#ifdef __NR_setuid +# define SYS_setuid __NR_setuid +#endif +#ifdef __NR_setuid32 +# define SYS_setuid32 __NR_setuid32 +#endif +#ifdef __NR_setxattr +# define SYS_setxattr __NR_setxattr +#endif +#ifdef __NR_sgetmask +# define SYS_sgetmask __NR_sgetmask +#endif +#ifdef __NR_shmat +# define SYS_shmat __NR_shmat +#endif +#ifdef __NR_shmctl +# define SYS_shmctl __NR_shmctl +#endif +#ifdef __NR_shmdt +# define SYS_shmdt __NR_shmdt +#endif +#ifdef __NR_shmget +# define SYS_shmget __NR_shmget +#endif +#ifdef __NR_shutdown +# define SYS_shutdown __NR_shutdown +#endif +#ifdef __NR_sigaction +# define SYS_sigaction __NR_sigaction +#endif +#ifdef __NR_sigaltstack +# define SYS_sigaltstack __NR_sigaltstack +#endif +#ifdef __NR_signal +# define SYS_signal __NR_signal +#endif +#ifdef __NR_signalfd +# define SYS_signalfd __NR_signalfd +#endif +#ifdef __NR_signalfd4 +# define SYS_signalfd4 __NR_signalfd4 +#endif +#ifdef __NR_sigpending +# define SYS_sigpending __NR_sigpending +#endif +#ifdef __NR_sigprocmask +# define SYS_sigprocmask __NR_sigprocmask +#endif +#ifdef __NR_sigreturn +# define SYS_sigreturn __NR_sigreturn +#endif +#ifdef __NR_sigsuspend +# define SYS_sigsuspend __NR_sigsuspend +#endif +#ifdef __NR_socket +# define SYS_socket __NR_socket +#endif +#ifdef __NR_socketcall +# define SYS_socketcall __NR_socketcall +#endif +#ifdef __NR_socketpair +# define SYS_socketpair __NR_socketpair +#endif +#ifdef __NR_spill +# define SYS_spill __NR_spill +#endif +#ifdef __NR_splice +# define SYS_splice __NR_splice +#endif +#ifdef __NR_spu_create +# define SYS_spu_create __NR_spu_create +#endif +#ifdef __NR_spu_run +# define SYS_spu_run __NR_spu_run +#endif +#ifdef __NR_ssetmask +# define SYS_ssetmask __NR_ssetmask +#endif +#ifdef __NR_stat +# define SYS_stat __NR_stat +#endif +#ifdef __NR_stat64 +# define SYS_stat64 __NR_stat64 +#endif +#ifdef __NR_statfs +# define SYS_statfs __NR_statfs +#endif +#ifdef __NR_statfs64 +# define SYS_statfs64 __NR_statfs64 +#endif +#ifdef __NR_statx +# define SYS_statx __NR_statx +#endif +#ifdef __NR_stime +# define SYS_stime __NR_stime +#endif +#ifdef __NR_subpage_prot +# define SYS_subpage_prot __NR_subpage_prot +#endif +#ifdef __NR_swapcontext +# define SYS_swapcontext __NR_swapcontext +#endif +#ifdef __NR_swapoff +# define SYS_swapoff __NR_swapoff +#endif +#ifdef __NR_swapon +# define SYS_swapon __NR_swapon +#endif +#ifdef __NR_switch_endian +# define SYS_switch_endian __NR_switch_endian +#endif +#ifdef __NR_symlink +# define SYS_symlink __NR_symlink +#endif +#ifdef __NR_symlinkat +# define SYS_symlinkat __NR_symlinkat +#endif +#ifdef __NR_sync +# define SYS_sync __NR_sync +#endif +#ifdef __NR_sync_file_range +# define SYS_sync_file_range __NR_sync_file_range +#endif +#ifdef __NR_sync_file_range2 +# define SYS_sync_file_range2 __NR_sync_file_range2 +#endif +#ifdef __NR_syncfs +# define SYS_syncfs __NR_syncfs +#endif +#ifdef __NR_sys_debug_setcontext +# define SYS_sys_debug_setcontext __NR_sys_debug_setcontext +#endif +#ifdef __NR_syscall +# define SYS_syscall __NR_syscall +#endif +#ifdef __NR_syscalls +# define SYS_syscalls __NR_syscalls +#endif +#ifdef __NR_sysfs +# define SYS_sysfs __NR_sysfs +#endif +#ifdef __NR_sysinfo +# define SYS_sysinfo __NR_sysinfo +#endif +#ifdef __NR_syslog +# define SYS_syslog __NR_syslog +#endif +#ifdef __NR_sysmips +# define SYS_sysmips __NR_sysmips +#endif +#ifdef __NR_tee +# define SYS_tee __NR_tee +#endif +#ifdef __NR_tgkill +# define SYS_tgkill __NR_tgkill +#endif +#ifdef __NR_time +# define SYS_time __NR_time +#endif +#ifdef __NR_timer_create +# define SYS_timer_create __NR_timer_create +#endif +#ifdef __NR_timer_delete +# define SYS_timer_delete __NR_timer_delete +#endif +#ifdef __NR_timer_getoverrun +# define SYS_timer_getoverrun __NR_timer_getoverrun +#endif +#ifdef __NR_timer_gettime +# define SYS_timer_gettime __NR_timer_gettime +#endif +#ifdef __NR_timer_gettime64 +# define SYS_timer_gettime64 __NR_timer_gettime64 +#endif +#ifdef __NR_timer_settime +# define SYS_timer_settime __NR_timer_settime +#endif +#ifdef __NR_timer_settime64 +# define SYS_timer_settime64 __NR_timer_settime64 +#endif +#ifdef __NR_timerfd +# define SYS_timerfd __NR_timerfd +#endif +#ifdef __NR_timerfd_create +# define SYS_timerfd_create __NR_timerfd_create +#endif +#ifdef __NR_timerfd_gettime +# define SYS_timerfd_gettime __NR_timerfd_gettime +#endif +#ifdef __NR_timerfd_gettime64 +# define SYS_timerfd_gettime64 __NR_timerfd_gettime64 +#endif +#ifdef __NR_timerfd_settime +# define SYS_timerfd_settime __NR_timerfd_settime +#endif +#ifdef __NR_timerfd_settime64 +# define SYS_timerfd_settime64 __NR_timerfd_settime64 +#endif +#ifdef __NR_times +# define SYS_times __NR_times +#endif +#ifdef __NR_tkill +# define SYS_tkill __NR_tkill +#endif +#ifdef __NR_truncate +# define SYS_truncate __NR_truncate +#endif +#ifdef __NR_truncate64 +# define SYS_truncate64 __NR_truncate64 +#endif +#ifdef __NR_ugetrlimit +# define SYS_ugetrlimit __NR_ugetrlimit +#endif +#ifdef __NR_umask +# define SYS_umask __NR_umask +#endif +#ifdef __NR_umount +# define SYS_umount __NR_umount +#endif +#ifdef __NR_umount2 +# define SYS_umount2 __NR_umount2 +#endif +#ifdef __NR_uname +# define SYS_uname __NR_uname +#endif +#ifdef __NR_unlink +# define SYS_unlink __NR_unlink +#endif +#ifdef __NR_unlinkat +# define SYS_unlinkat __NR_unlinkat +#endif +#ifdef __NR_unshare +# define SYS_unshare __NR_unshare +#endif +#ifdef __NR_uselib +# define SYS_uselib __NR_uselib +#endif +#ifdef __NR_userfaultfd +# define SYS_userfaultfd __NR_userfaultfd +#endif +#ifdef __NR_ustat +# define SYS_ustat __NR_ustat +#endif +#ifdef __NR_utime +# define SYS_utime __NR_utime +#endif +#ifdef __NR_utimensat +# define SYS_utimensat __NR_utimensat +#endif +#ifdef __NR_utimensat_time64 +# define SYS_utimensat_time64 __NR_utimensat_time64 +#endif +#ifdef __NR_utimes +# define SYS_utimes __NR_utimes +#endif +#ifdef __NR_utrap_install +# define SYS_utrap_install __NR_utrap_install +#endif +#ifdef __NR_vfork +# define SYS_vfork __NR_vfork +#endif +#ifdef __NR_vhangup +# define SYS_vhangup __NR_vhangup +#endif +#ifdef __NR_vm86 +# define SYS_vm86 __NR_vm86 +#endif +#ifdef __NR_vm86old +# define SYS_vm86old __NR_vm86old +#endif +#ifdef __NR_vmsplice +# define SYS_vmsplice __NR_vmsplice +#endif +#ifdef __NR_wait4 +# define SYS_wait4 __NR_wait4 +#endif +#ifdef __NR_waitid +# define SYS_waitid __NR_waitid +#endif +#ifdef __NR_waitpid +# define SYS_waitpid __NR_waitpid +#endif +#ifdef __NR_write +# define SYS_write __NR_write +#endif +#ifdef __NR_writev +# define SYS_writev __NR_writev +#endif +#endif /* __MLIBC_SYSCALL_ALIAS_BIT */ diff --git a/lib/mlibc/sysdeps/linux/include/mlibc/thread-entry.hpp b/lib/mlibc/sysdeps/linux/include/mlibc/thread-entry.hpp new file mode 100644 index 0000000..a20cab5 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/mlibc/thread-entry.hpp @@ -0,0 +1,12 @@ +#ifndef MLIBC_THREAD_ENTRY + +#include <mlibc/tcb.hpp> + +extern "C" int __mlibc_spawn_thread(int flags, void *stack, void *pid_out, void *child_tid, void *tcb); +extern "C" void __mlibc_enter_thread(void *entry, void *user_arg); + +namespace mlibc { + void *prepare_stack(void *entry, void *user_arg); +} + +#endif // MLIBC_THREAD_ENTRY diff --git a/lib/mlibc/sysdeps/linux/include/sys/syscall.h b/lib/mlibc/sysdeps/linux/include/sys/syscall.h new file mode 100644 index 0000000..2084103 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/sys/syscall.h @@ -0,0 +1,12 @@ +#ifndef _SYS_SYSCALL_H +#define _SYS_SYSCALL_H + +/* On GNU/Linux, this header provides includes __NR_-prefixed syscall numbers, + * and their SYS_ aliases. We defer to kernel headers for the numbers + * (linux-headers, or an autogenerated stub while building), and an + * autogenerated file containing SYS_ defines. + */ +#include <linux/unistd.h> +#include <bits/syscall_aliases.h> + +#endif // _SYS_SYSCALL_H diff --git a/lib/mlibc/sysdeps/linux/include/syscall.h b/lib/mlibc/sysdeps/linux/include/syscall.h new file mode 100644 index 0000000..4c30578 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/include/syscall.h @@ -0,0 +1 @@ +#include <sys/syscall.h> diff --git a/lib/mlibc/sysdeps/linux/meson.build b/lib/mlibc/sysdeps/linux/meson.build new file mode 100644 index 0000000..0809237 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/meson.build @@ -0,0 +1,143 @@ +rtdl_dso_sources += files( + host_machine.cpu_family() / 'arch-syscall.cpp', + 'generic/sysdeps.cpp', +) + +linux_include_dirs = [ + include_directories(host_machine.cpu_family()), + include_directories('include-internal/'), +] + +rtdl_include_dirs += linux_include_dirs +libc_include_dirs += linux_include_dirs +libc_sources += files( + host_machine.cpu_family() / 'signals.S', + host_machine.cpu_family() / 'arch-syscall.cpp', + 'generic/entry.cpp', + 'generic/sysdeps.cpp', +) + +if not disable_posix_option + libc_sources += files( + 'generic/thread.cpp', + host_machine.cpu_family() / 'cp_syscall.S', + host_machine.cpu_family() / 'thread_entry.S' + ) +endif + +if not no_headers + install_headers( + 'include/abi-bits/auxv.h', + 'include/abi-bits/seek-whence.h', + 'include/abi-bits/vm-flags.h', + 'include/abi-bits/errno.h', + 'include/abi-bits/fcntl.h', + 'include/abi-bits/in.h', + 'include/abi-bits/stat.h', + 'include/abi-bits/signal.h', + 'include/abi-bits/reboot.h', + 'include/abi-bits/resource.h', + 'include/abi-bits/socket.h', + 'include/abi-bits/termios.h', + 'include/abi-bits/time.h', + 'include/abi-bits/blkcnt_t.h', + 'include/abi-bits/blksize_t.h', + 'include/abi-bits/dev_t.h', + 'include/abi-bits/gid_t.h', + 'include/abi-bits/ino_t.h', + 'include/abi-bits/mode_t.h', + 'include/abi-bits/nlink_t.h', + 'include/abi-bits/pid_t.h', + 'include/abi-bits/uid_t.h', + 'include/abi-bits/access.h', + 'include/abi-bits/wait.h', + 'include/abi-bits/limits.h', + 'include/abi-bits/utsname.h', + 'include/abi-bits/ptrace.h', + 'include/abi-bits/vt.h', + 'include/abi-bits/ptrace.h', + 'include/abi-bits/poll.h', + 'include/abi-bits/epoll.h', + 'include/abi-bits/packet.h', + 'include/abi-bits/inotify.h', + 'include/abi-bits/clockid_t.h', + 'include/abi-bits/shm.h', + 'include/abi-bits/mqueue.h', + 'include/abi-bits/suseconds_t.h', + 'include/abi-bits/fsfilcnt_t.h', + 'include/abi-bits/fsblkcnt_t.h', + 'include/abi-bits/socklen_t.h', + 'include/abi-bits/statfs.h', + 'include/abi-bits/statvfs.h', + 'include/abi-bits/ioctls.h', + 'include/abi-bits/xattr.h', + 'include/abi-bits/msg.h', + subdir: 'abi-bits', + follow_symlinks: true + ) + + install_headers('include/syscall.h') + install_headers('include/sys/syscall.h', subdir: 'sys') + install_headers( + 'include/bits/syscall.h', + 'include/bits/syscall_aliases.h', + subdir: 'bits' + ) +endif + +if not headers_only + crt = custom_target('crt1', + build_by_default: true, + command: c_compiler.cmd_array() + ['-c', '-o', '@OUTPUT@', '@INPUT@'], + input: host_machine.cpu_family() / 'crt-src/crt1.S', + output: 'crt1.o', + install: true, + install_dir: get_option('libdir') + ) + + crt_pie = custom_target('Scrt1', + build_by_default: true, + command: c_compiler.cmd_array() + ['-fPIE', '-c', '-o', '@OUTPUT@', '@INPUT@'], + input: host_machine.cpu_family() / 'crt-src/Scrt1.S', + output: 'Scrt1.o', + install: true, + install_dir: get_option('libdir') + ) + + custom_target('crti', + build_by_default: true, + command: c_compiler.cmd_array() + ['-c', '-o', '@OUTPUT@', '@INPUT@'], + input: host_machine.cpu_family() / 'crt-src/crti.S', + output: 'crti.o', + install: true, + install_dir: get_option('libdir') + ) + + custom_target('crtn', + build_by_default: true, + command: c_compiler.cmd_array() + ['-c', '-o', '@OUTPUT@', '@INPUT@'], + input: host_machine.cpu_family() / 'crt-src/crtn.S', + output: 'crtn.o', + install: true, + install_dir: get_option('libdir') + ) + + wrapper_conf = configuration_data() + wrapper_conf.set('LIBDIR', get_option('libdir')) + wrapper_conf.set('PREFIX', get_option('prefix')) + specs = configure_file(input: 'mlibc-gcc.specs.in', + output: 'mlibc-gcc.specs', + configuration: wrapper_conf) + + wrapper_script = configure_file(input: 'mlibc-gcc.in', + output: 'mlibc-gcc', + configuration: wrapper_conf) + + install_data(specs, + install_dir: get_option('libdir') + ) + + install_data(wrapper_script, + install_dir: get_option('bindir') + ) +endif diff --git a/lib/mlibc/sysdeps/linux/mlibc-gcc.in b/lib/mlibc/sysdeps/linux/mlibc-gcc.in new file mode 100755 index 0000000..6236bd6 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/mlibc-gcc.in @@ -0,0 +1,2 @@ +#!/bin/sh +exec "${REALGCC:-gcc}" "$@" -specs "@PREFIX@/@LIBDIR@/mlibc-gcc.specs" diff --git a/lib/mlibc/sysdeps/linux/mlibc-gcc.specs.in b/lib/mlibc/sysdeps/linux/mlibc-gcc.specs.in new file mode 100644 index 0000000..4304c4d --- /dev/null +++ b/lib/mlibc/sysdeps/linux/mlibc-gcc.specs.in @@ -0,0 +1,32 @@ +%rename cpp_options old_cpp_options + +*cpp_options: +-nostdinc -isystem @PREFIX@/include -isystem include%s %(old_cpp_options) + +*cc1: +%(cc1_cpu) -nostdinc -isystem @PREFIX@/include -isystem include%s + +*link_libgcc: +-L@PREFIX@/@LIBDIR@ -L .%s + +*libgcc: +libgcc.a%s %:if-exists(libgcc_eh.a%s) + +*startfile: +%{!shared: @PREFIX@/@LIBDIR@/Scrt1.o} @PREFIX@/@LIBDIR@/crti.o crtbeginS.o%s + +*endfile: +crtendS.o%s @PREFIX@/@LIBDIR@/crtn.o + +*link: +-dynamic-linker @PREFIX@/@LIBDIR@/ld.so -rpath @PREFIX@/@LIBDIR@ -nostdlib %{shared:-shared} %{static:-static} %{rdynamic:-export-dynamic} + +*esp_link: + + +*esp_options: + + +*esp_cpp_options: + + diff --git a/lib/mlibc/sysdeps/linux/riscv64/arch-syscall.cpp b/lib/mlibc/sysdeps/linux/riscv64/arch-syscall.cpp new file mode 100644 index 0000000..18ac6b0 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/arch-syscall.cpp @@ -0,0 +1,117 @@ +#include <sys/syscall.h> +#include <bits/syscall.h> + +using sc_word_t = __sc_word_t; + +sc_word_t __do_syscall0(long sc) { + register int sc_reg asm("a7") = sc; + register sc_word_t ret asm("a0"); + asm volatile ("ecall" : "=r"(ret) : "r"(sc_reg) : "memory", "a1"); + return ret; +} + +sc_word_t __do_syscall1(long sc, + sc_word_t arg1) { + register int sc_reg asm("a7") = sc; + register sc_word_t arg1_reg asm("a0") = arg1; + register sc_word_t ret asm("a0"); + asm volatile ("ecall" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg) + : "memory", "a1"); + return ret; +} + +sc_word_t __do_syscall2(long sc, + sc_word_t arg1, sc_word_t arg2) { + register int sc_reg asm("a7") = sc; + register sc_word_t arg1_reg asm("a0") = arg1; + register sc_word_t arg2_reg asm("a1") = arg2; + register sc_word_t ret asm("a0"); + asm volatile ("ecall" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall3(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3) { + register int sc_reg asm("a7") = sc; + register sc_word_t arg1_reg asm("a0") = arg1; + register sc_word_t arg2_reg asm("a1") = arg2; + register sc_word_t arg3_reg asm("a2") = arg3; + register sc_word_t ret asm("a0"); + asm volatile ("ecall" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg), + "r"(arg3_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall4(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4) { + register int sc_reg asm("a7") = sc; + register sc_word_t arg1_reg asm("a0") = arg1; + register sc_word_t arg2_reg asm("a1") = arg2; + register sc_word_t arg3_reg asm("a2") = arg3; + register sc_word_t arg4_reg asm("a3") = arg4; + register sc_word_t ret asm("a0"); + asm volatile ("ecall" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg), + "r"(arg3_reg), + "r"(arg4_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall5(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5) { + register int sc_reg asm("a7") = sc; + register sc_word_t arg1_reg asm("a0") = arg1; + register sc_word_t arg2_reg asm("a1") = arg2; + register sc_word_t arg3_reg asm("a2") = arg3; + register sc_word_t arg4_reg asm("a3") = arg4; + register sc_word_t arg5_reg asm("a4") = arg5; + register sc_word_t ret asm("a0"); + asm volatile ("ecall" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg), + "r"(arg3_reg), + "r"(arg4_reg), + "r"(arg5_reg) + : "memory"); + return ret; +} + +sc_word_t __do_syscall6(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5, sc_word_t arg6) { + register int sc_reg asm("a7") = sc; + register sc_word_t arg1_reg asm("a0") = arg1; + register sc_word_t arg2_reg asm("a1") = arg2; + register sc_word_t arg3_reg asm("a2") = arg3; + register sc_word_t arg4_reg asm("a3") = arg4; + register sc_word_t arg5_reg asm("a4") = arg5; + register sc_word_t arg6_reg asm("a5") = arg6; + register sc_word_t ret asm("a0"); + asm volatile ("ecall" : "=r"(ret) : + "r"(sc_reg), + "r"(arg1_reg), + "r"(arg2_reg), + "r"(arg3_reg), + "r"(arg4_reg), + "r"(arg5_reg), + "r"(arg6_reg) + : "memory" + ); + return ret; +} diff --git a/lib/mlibc/sysdeps/linux/riscv64/cp_syscall.S b/lib/mlibc/sysdeps/linux/riscv64/cp_syscall.S new file mode 100644 index 0000000..8d3175d --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/cp_syscall.S @@ -0,0 +1,30 @@ +.section .text +.global __mlibc_do_asm_cp_syscall +.global __mlibc_syscall_begin +.global __mlibc_syscall_end +.type __mlibc_do_asm_cp_syscall, "function" +__mlibc_do_asm_cp_syscall: + sd a7, -8(sp) + mv a7, a0 + mv a0, a1 + mv a1, a2 + mv a2, a3 + mv a3, a4 + mv a4, a5 + mv a5, a6 + ld a6, -8(sp) // a7 + lw t0, -96(tp) // Tcb::cancelBits. See asserts in tcb.hpp. +__mlibc_syscall_begin: + // tcbCancelEnableBit && tcbCancelTriggerBit + li t1, (1 << 0) | (1 << 2) + and t0, t0, t1 + beq t0, t1, cancel + ecall +__mlibc_syscall_end: + ret + +cancel: + call __mlibc_do_cancel + unimp +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/riscv64/crt-src/Scrt1.S b/lib/mlibc/sysdeps/linux/riscv64/crt-src/Scrt1.S new file mode 100644 index 0000000..9ee8625 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/crt-src/Scrt1.S @@ -0,0 +1,18 @@ +.section .text +.global _start +_start: + .weak __global_pointer$ + .hidden __global_pointer$ + .option push + .option norelax + lla gp, __global_pointer$ + .option pop + + mv a0, sp + la a1, main + call __mlibc_entry@plt + unimp + + +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/riscv64/crt-src/crt1.S b/lib/mlibc/sysdeps/linux/riscv64/crt-src/crt1.S new file mode 100644 index 0000000..16c79d6 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/crt-src/crt1.S @@ -0,0 +1,15 @@ +.section .text +.global _start +_start: + .weak __global_pointer$ + .hidden __global_pointer$ + .option push + .option norelax + lla gp, __global_pointer$ + .option pop + + mv a0, sp + la a1, main + call __mlibc_entry +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/riscv64/crt-src/crti.S b/lib/mlibc/sysdeps/linux/riscv64/crt-src/crti.S new file mode 100644 index 0000000..69f23ea --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/crt-src/crti.S @@ -0,0 +1,11 @@ +.section .init +.global _init +_init: + unimp + +.section .fini +.global _fini +_fini: + unimp +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/riscv64/crt-src/crtn.S b/lib/mlibc/sysdeps/linux/riscv64/crt-src/crtn.S new file mode 100644 index 0000000..525efd6 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/crt-src/crtn.S @@ -0,0 +1,7 @@ +.section .init + unimp + +.section .fini + unimp +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/riscv64/signals.S b/lib/mlibc/sysdeps/linux/riscv64/signals.S new file mode 100644 index 0000000..7769043 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/signals.S @@ -0,0 +1,12 @@ +.section .text + +.global __mlibc_signal_restore +.type __mlibc_signal_restore, @function +__mlibc_signal_restore: +.global __mlibc_signal_restore_rt +.type __mlibc_signal_restore_rt, @function +__mlibc_signal_restore_rt: + li a7, 139 + ecall +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/riscv64/syscallnos.h b/lib/mlibc/sysdeps/linux/riscv64/syscallnos.h new file mode 100644 index 0000000..a5a11bb --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/syscallnos.h @@ -0,0 +1,314 @@ +#ifndef __MLIBC_SYSCALLNOS_h +#define __MLIBC_SYSCALLNOS_h +/* This file is autogenerated. Don't bother. */ +/* Generator script: sysdeps/linux/update-syscall-list.py. */ +#define __NR_io_setup 0 +#define __NR_io_destroy 1 +#define __NR_io_submit 2 +#define __NR_io_cancel 3 +#define __NR_io_getevents 4 +#define __NR_setxattr 5 +#define __NR_lsetxattr 6 +#define __NR_fsetxattr 7 +#define __NR_getxattr 8 +#define __NR_lgetxattr 9 +#define __NR_fgetxattr 10 +#define __NR_listxattr 11 +#define __NR_llistxattr 12 +#define __NR_flistxattr 13 +#define __NR_removexattr 14 +#define __NR_lremovexattr 15 +#define __NR_fremovexattr 16 +#define __NR_getcwd 17 +#define __NR_lookup_dcookie 18 +#define __NR_eventfd2 19 +#define __NR_epoll_create1 20 +#define __NR_epoll_ctl 21 +#define __NR_epoll_pwait 22 +#define __NR_dup 23 +#define __NR_dup3 24 +#define __NR_fcntl 25 +#define __NR_inotify_init1 26 +#define __NR_inotify_add_watch 27 +#define __NR_inotify_rm_watch 28 +#define __NR_ioctl 29 +#define __NR_ioprio_set 30 +#define __NR_ioprio_get 31 +#define __NR_flock 32 +#define __NR_mknodat 33 +#define __NR_mkdirat 34 +#define __NR_unlinkat 35 +#define __NR_symlinkat 36 +#define __NR_linkat 37 +#define __NR_umount2 39 +#define __NR_mount 40 +#define __NR_pivot_root 41 +#define __NR_nfsservctl 42 +#define __NR_statfs 43 +#define __NR_fstatfs 44 +#define __NR_truncate 45 +#define __NR_ftruncate 46 +#define __NR_fallocate 47 +#define __NR_faccessat 48 +#define __NR_chdir 49 +#define __NR_fchdir 50 +#define __NR_chroot 51 +#define __NR_fchmod 52 +#define __NR_fchmodat 53 +#define __NR_fchownat 54 +#define __NR_fchown 55 +#define __NR_openat 56 +#define __NR_close 57 +#define __NR_vhangup 58 +#define __NR_pipe2 59 +#define __NR_quotactl 60 +#define __NR_getdents64 61 +#define __NR_lseek 62 +#define __NR_read 63 +#define __NR_write 64 +#define __NR_readv 65 +#define __NR_writev 66 +#define __NR_pread64 67 +#define __NR_pwrite64 68 +#define __NR_preadv 69 +#define __NR_pwritev 70 +#define __NR_sendfile 71 +#define __NR_pselect6 72 +#define __NR_ppoll 73 +#define __NR_signalfd4 74 +#define __NR_vmsplice 75 +#define __NR_splice 76 +#define __NR_tee 77 +#define __NR_readlinkat 78 +#define __NR_newfstatat 79 +#define __NR_fstat 80 +#define __NR_sync 81 +#define __NR_fsync 82 +#define __NR_fdatasync 83 +#define __NR_sync_file_range 84 +#define __NR_timerfd_create 85 +#define __NR_timerfd_settime 86 +#define __NR_timerfd_gettime 87 +#define __NR_utimensat 88 +#define __NR_acct 89 +#define __NR_capget 90 +#define __NR_capset 91 +#define __NR_personality 92 +#define __NR_exit 93 +#define __NR_exit_group 94 +#define __NR_waitid 95 +#define __NR_set_tid_address 96 +#define __NR_unshare 97 +#define __NR_futex 98 +#define __NR_set_robust_list 99 +#define __NR_get_robust_list 100 +#define __NR_nanosleep 101 +#define __NR_getitimer 102 +#define __NR_setitimer 103 +#define __NR_kexec_load 104 +#define __NR_init_module 105 +#define __NR_delete_module 106 +#define __NR_timer_create 107 +#define __NR_timer_gettime 108 +#define __NR_timer_getoverrun 109 +#define __NR_timer_settime 110 +#define __NR_timer_delete 111 +#define __NR_clock_settime 112 +#define __NR_clock_gettime 113 +#define __NR_clock_getres 114 +#define __NR_clock_nanosleep 115 +#define __NR_syslog 116 +#define __NR_ptrace 117 +#define __NR_sched_setparam 118 +#define __NR_sched_setscheduler 119 +#define __NR_sched_getscheduler 120 +#define __NR_sched_getparam 121 +#define __NR_sched_setaffinity 122 +#define __NR_sched_getaffinity 123 +#define __NR_sched_yield 124 +#define __NR_sched_get_priority_max 125 +#define __NR_sched_get_priority_min 126 +#define __NR_sched_rr_get_interval 127 +#define __NR_restart_syscall 128 +#define __NR_kill 129 +#define __NR_tkill 130 +#define __NR_tgkill 131 +#define __NR_sigaltstack 132 +#define __NR_rt_sigsuspend 133 +#define __NR_rt_sigaction 134 +#define __NR_rt_sigprocmask 135 +#define __NR_rt_sigpending 136 +#define __NR_rt_sigtimedwait 137 +#define __NR_rt_sigqueueinfo 138 +#define __NR_rt_sigreturn 139 +#define __NR_setpriority 140 +#define __NR_getpriority 141 +#define __NR_reboot 142 +#define __NR_setregid 143 +#define __NR_setgid 144 +#define __NR_setreuid 145 +#define __NR_setuid 146 +#define __NR_setresuid 147 +#define __NR_getresuid 148 +#define __NR_setresgid 149 +#define __NR_getresgid 150 +#define __NR_setfsuid 151 +#define __NR_setfsgid 152 +#define __NR_times 153 +#define __NR_setpgid 154 +#define __NR_getpgid 155 +#define __NR_getsid 156 +#define __NR_setsid 157 +#define __NR_getgroups 158 +#define __NR_setgroups 159 +#define __NR_uname 160 +#define __NR_sethostname 161 +#define __NR_setdomainname 162 +#define __NR_getrlimit 163 +#define __NR_setrlimit 164 +#define __NR_getrusage 165 +#define __NR_umask 166 +#define __NR_prctl 167 +#define __NR_getcpu 168 +#define __NR_gettimeofday 169 +#define __NR_settimeofday 170 +#define __NR_adjtimex 171 +#define __NR_getpid 172 +#define __NR_getppid 173 +#define __NR_getuid 174 +#define __NR_geteuid 175 +#define __NR_getgid 176 +#define __NR_getegid 177 +#define __NR_gettid 178 +#define __NR_sysinfo 179 +#define __NR_mq_open 180 +#define __NR_mq_unlink 181 +#define __NR_mq_timedsend 182 +#define __NR_mq_timedreceive 183 +#define __NR_mq_notify 184 +#define __NR_mq_getsetattr 185 +#define __NR_msgget 186 +#define __NR_msgctl 187 +#define __NR_msgrcv 188 +#define __NR_msgsnd 189 +#define __NR_semget 190 +#define __NR_semctl 191 +#define __NR_semtimedop 192 +#define __NR_semop 193 +#define __NR_shmget 194 +#define __NR_shmctl 195 +#define __NR_shmat 196 +#define __NR_shmdt 197 +#define __NR_socket 198 +#define __NR_socketpair 199 +#define __NR_bind 200 +#define __NR_listen 201 +#define __NR_accept 202 +#define __NR_connect 203 +#define __NR_getsockname 204 +#define __NR_getpeername 205 +#define __NR_sendto 206 +#define __NR_recvfrom 207 +#define __NR_setsockopt 208 +#define __NR_getsockopt 209 +#define __NR_shutdown 210 +#define __NR_sendmsg 211 +#define __NR_recvmsg 212 +#define __NR_readahead 213 +#define __NR_brk 214 +#define __NR_munmap 215 +#define __NR_mremap 216 +#define __NR_add_key 217 +#define __NR_request_key 218 +#define __NR_keyctl 219 +#define __NR_clone 220 +#define __NR_execve 221 +#define __NR_mmap 222 +#define __NR_fadvise64 223 +#define __NR_swapon 224 +#define __NR_swapoff 225 +#define __NR_mprotect 226 +#define __NR_msync 227 +#define __NR_mlock 228 +#define __NR_munlock 229 +#define __NR_mlockall 230 +#define __NR_munlockall 231 +#define __NR_mincore 232 +#define __NR_madvise 233 +#define __NR_remap_file_pages 234 +#define __NR_mbind 235 +#define __NR_get_mempolicy 236 +#define __NR_set_mempolicy 237 +#define __NR_migrate_pages 238 +#define __NR_move_pages 239 +#define __NR_rt_tgsigqueueinfo 240 +#define __NR_perf_event_open 241 +#define __NR_accept4 242 +#define __NR_recvmmsg 243 +#define __NR_arch_specific_syscall 244 +#define __NR_riscv_hwprobe 258 +#define __NR_riscv_flush_icache 259 +#define __NR_wait4 260 +#define __NR_prlimit64 261 +#define __NR_fanotify_init 262 +#define __NR_fanotify_mark 263 +#define __NR_name_to_handle_at 264 +#define __NR_open_by_handle_at 265 +#define __NR_clock_adjtime 266 +#define __NR_syncfs 267 +#define __NR_setns 268 +#define __NR_sendmmsg 269 +#define __NR_process_vm_readv 270 +#define __NR_process_vm_writev 271 +#define __NR_kcmp 272 +#define __NR_finit_module 273 +#define __NR_sched_setattr 274 +#define __NR_sched_getattr 275 +#define __NR_renameat2 276 +#define __NR_seccomp 277 +#define __NR_getrandom 278 +#define __NR_memfd_create 279 +#define __NR_bpf 280 +#define __NR_execveat 281 +#define __NR_userfaultfd 282 +#define __NR_membarrier 283 +#define __NR_mlock2 284 +#define __NR_copy_file_range 285 +#define __NR_preadv2 286 +#define __NR_pwritev2 287 +#define __NR_pkey_mprotect 288 +#define __NR_pkey_alloc 289 +#define __NR_pkey_free 290 +#define __NR_statx 291 +#define __NR_io_pgetevents 292 +#define __NR_rseq 293 +#define __NR_kexec_file_load 294 +#define __NR_pidfd_send_signal 424 +#define __NR_io_uring_setup 425 +#define __NR_io_uring_enter 426 +#define __NR_io_uring_register 427 +#define __NR_open_tree 428 +#define __NR_move_mount 429 +#define __NR_fsopen 430 +#define __NR_fsconfig 431 +#define __NR_fsmount 432 +#define __NR_fspick 433 +#define __NR_pidfd_open 434 +#define __NR_clone3 435 +#define __NR_close_range 436 +#define __NR_openat2 437 +#define __NR_pidfd_getfd 438 +#define __NR_faccessat2 439 +#define __NR_process_madvise 440 +#define __NR_epoll_pwait2 441 +#define __NR_mount_setattr 442 +#define __NR_quotactl_fd 443 +#define __NR_landlock_create_ruleset 444 +#define __NR_landlock_add_rule 445 +#define __NR_landlock_restrict_self 446 +#define __NR_memfd_secret 447 +#define __NR_process_mrelease 448 +#define __NR_futex_waitv 449 +#define __NR_set_mempolicy_home_node 450 +#define __NR_syscalls 451 +#endif /* __MLIBC_SYSCALLNOS_h */ diff --git a/lib/mlibc/sysdeps/linux/riscv64/thread_entry.S b/lib/mlibc/sysdeps/linux/riscv64/thread_entry.S new file mode 100644 index 0000000..fe170fa --- /dev/null +++ b/lib/mlibc/sysdeps/linux/riscv64/thread_entry.S @@ -0,0 +1,29 @@ +.section .text +.global __mlibc_spawn_thread +.type __mlibc_spawn_thread, "function" +__mlibc_spawn_thread: + // __mlibc_spawn_thread(flags, stack, pid_out, child_tid, tls) + // a0, a1, a2, a3, a4 + // syscall(NR_clone, flags, stack, ptid, tls, ctid) + // a7, a0, a1, a2, a3, a4 + + // Swap a3 <-> a4 + mv a5, a4 + mv a4, a3 + mv a3, a5 + + li a7, 220 // NR_clone + ecall + bnez a0, .parent + + ld a0, 0(sp) + ld a1, 8(sp) + addi sp, sp, 8 + andi sp, sp, -16 + call __mlibc_enter_thread + unimp + +.parent: + ret +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/update-syscall-list.py b/lib/mlibc/sysdeps/linux/update-syscall-list.py new file mode 100755 index 0000000..58825f7 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/update-syscall-list.py @@ -0,0 +1,332 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: MIT + +import argparse +import hashlib +import io +import json +import logging +import os +import os.path as path +import pathlib +import subprocess +import tarfile +import tempfile +import urllib.request as urr +from dataclasses import dataclass + +KERNEL_RELEASES = "https://www.kernel.org/releases.json" +NR_PREFIX = "__NR_" +logging.basicConfig(level=logging.DEBUG) +LOGGER = logging.getLogger(__name__) + +# ADD NEW ARCHITECTURES HERE: these should match directory names in Linuxes arch/ +# directory or the second element of one of the harnesses below +WANTED_ARCHES = ["riscv64", "x86_64", "arm64", "i386"] +# How to translate from Linux arch directory names to gnutools architecture fields +LINUX_GNU_TRANSLATION = { + "arm64": "aarch64", + "i386": "x86", +} + +argp = argparse.ArgumentParser() +argp.add_argument("kver", help="Kernel version to download", default="latest") + + +@dataclass +class Kernel: + version: str + srchash: str + srcdir: pathlib.Path + + +@dataclass +class Context: + dirpath: pathlib.Path + + +def run(args: list[str], **kwargs): + LOGGER.debug("running %s", args) + subprocess.check_call(args, **kwargs) + + +def collect(args: list[str], **kwargs): + LOGGER.debug("running %s (kw: %s)", args, kwargs) + kwargs.setdefault("text", True) + return subprocess.check_output(args, **kwargs) + + +def fetch_kernel(ctx: Context, kver: str) -> Kernel: + LOGGER.debug("fetching %s", KERNEL_RELEASES) + with urr.urlopen(KERNEL_RELEASES) as f: + if f.status != 200: + LOGGER.error("meta fetch failed: %s", f) + raise RuntimeError("failed to get kernel meta") + metadata = json.load(f) + + if kver == "latest": + kver = metadata["latest_stable"]["version"] + + LOGGER.debug("figured out kernel version: %s", kver) + + for rel in metadata["releases"]: + if rel["version"] == kver: + kernel_release = rel + break + else: + raise RuntimeError("failed to find kver " + kver) + + kurl = kernel_release["source"] + LOGGER.debug("kernel src url: %s", kurl) + source_path = ctx.dirpath / ("source.tar" + path.splitext(kurl)[1]) + + with urr.urlopen(kurl) as f, open(source_path, "wb") as g: + if f.status != 200: + LOGGER.error("ksrc fetch failed: %s", f) + raise RuntimeError("failed to get kernel source") + + hasher = hashlib.blake2b() + while buf := f.read(16 * 1024): + hasher.update(buf) + g.write(buf) + + srchash = hasher.hexdigest() + srcpath = ctx.dirpath / "src" + + with tarfile.open(source_path) as srctar: + memb: tarfile.TarInfo + for memb in srctar: + if not memb.name.startswith("linux-"): + raise RuntimeError( + "malformed tar member in %s (%s): %s has bad prefix".format( + kurl, srchash, memb.name + ) + ) + memb.name = "./" + memb.name[memb.name.find("/") + 1 :] + srctar.extract(memb, path=srcpath) + + return Kernel( + version=kver, + srchash=srchash, + srcdir=srcpath, + ) + + +def run_harness(ctx: Context, kernel: Kernel, harness: (str, str)) -> dict[str, int]: + LOGGER.debug("running harness %s", harness) + (archdir, arch, defines) = harness + flags = [f"-D{x}" for x in defines] + archout = ctx.dirpath / "headers" / archdir + if not archout.exists(): + run( + [ + "make", + "-sC", + kernel.srcdir, + f"ARCH={archdir}", + f"O={archout}", + "headers_install", + ] + ) + + hdrdir = archout / "usr/include" + callset = set() + for x in collect( + ["gcc", "-E", "-dM", "-I", hdrdir, *flags, "-"], input="#include <asm/unistd.h>" + ).splitlines(): + x = x.split(maxsplit=2) + if len(x) < 2 or x[0] != "#define": + # skip invalid lines + continue + + defname = x[1] + if not defname.startswith(NR_PREFIX): + # not a syscall + continue + + defname = defname[len(NR_PREFIX) :] + + if ( + "SYSCALL" in defname + or defname.startswith("available") + or defname.startswith("reserved") + or defname.startswith("unused") + ): + continue + + # dead syscalls + if defname in [ + "Linux", + "afs_syscall", + "break", + "ftime", + "gtty", + "lock", + "mpx", + "oldwait4", + "prof", + "profil", + "putpmsg", + "security", + "stty", + "tuxcall", + "ulimit", + "vserver", + "arm_sync_file_range", + "utimesat", + "ni_syscall", + "xtensa", + ]: + continue + callset.add(defname) + + # alright, we have the set of all syscalls, time to produce their numbers + syscall_dumper = """ +/* my sincerest apologies */ +#include <stdio.h> +""" + + for x in defines: + syscall_dumper += "#define {}\n".format(x.replace("=", " ")) + + syscall_dumper += """ +#include <asm/unistd.h> + +int main() { + puts("{"); + """ + + comma = "" + for x in callset: + syscall_dumper += 'printf("{comma}\\"{sc}\\": %d\\n", {pfx}{sc});\n '.format( + sc=x, comma=comma, pfx=NR_PREFIX + ) + comma = "," + + syscall_dumper += """ + puts("}"); +} +""" + + dumper = archout / "dumper" + with tempfile.NamedTemporaryFile(suffix=".c") as src: + src.write(syscall_dumper.encode()) + run(["gcc", "-o", dumper, "-I", hdrdir, src.name]) + return json.loads(collect([dumper])) + + +def main(ctx: Context): + args = argp.parse_args() + kernel = fetch_kernel(ctx, args.kver) + + LOGGER.info("got kernel version %s (%s)", kernel.version, kernel.srchash) + + archlist = os.listdir(kernel.srcdir / "arch") + archlist.remove("Kconfig") + archlist.remove("um") + + # harnesses converted from + # https://github.com/hrw/syscalls-table/blob/c638834d9b5d71bb40a555755ea07735cace58f2/do_all_tables.sh + # (arch_dirname, archname, list[defines]) + harnesses: (str, str, list[str]) + harnesses = [ + (arch,) + x + for arch in archlist + if not arch.startswith(".") + for x in { + # arch specific overrides + # format: (archname, list[defines]), gets prefixed with archdir outside + "arm": [ + ("armoabi", []), + ("arm", ["__ARM_EABI_"]), + ], + "loongarch": [ + ("loongarch64", ["_LOONGARCH_SZLONG=64"]), + ], + "mips": [ + ("mipso32", ["_MIPS_SIM=_MIPS_SIM_ABI32"]), + ("mips64n32", ["_MIPS_SIM=_MIPS_SIM_NABI32"]), + ("mips64", ["_MIPS_SIM=_MIPS_SIM_ABI64"]), + ], + "powerpc": [ + ("powerpc", []), + ("powerpc64", []), + ], + "riscv": [ + ("riscv32", ["__SIZEOF_POINTER__=4"]), + ("riscv64", ["__LP64__"]), + ], + "s390": [ + ("s390", []), + ("s390x", []), + ], + "sparc": [ + ("sparc", ["__32bit_syscall_numbers__"]), + ("sparc64", ["__arch64__"]), + ], + "tile": [ + ("tile", []), + ("tile64", ["__LP64__", "__tilegx__"]), + ], + "x86": [ + ("i386", ["__i386__"]), + ("x32", ["__ILP32__"]), + ("x86_64", ["__LP64__"]), + ], + }.get(arch, [(arch, [])]) + ] + + syscall_set = set() + + for x in harnesses: + syscalls = run_harness(ctx, kernel, x) + syscall_set |= syscalls.keys() + + wanted_arch = x[1] + if wanted_arch not in WANTED_ARCHES: + continue + + wanted_arch = LINUX_GNU_TRANSLATION.get(wanted_arch, wanted_arch) + + pathlib.Path(wanted_arch).mkdir(exist_ok=True) + + with open(wanted_arch + "/syscallnos.h", "w") as f: + print("#ifndef __MLIBC_SYSCALLNOS_h", file=f) + print("#define __MLIBC_SYSCALLNOS_h", file=f) + print("/* This file is autogenerated. Don't bother. */", file=f) + print( + "/* Generator script: sysdeps/linux/update-syscall-list.py. */", file=f + ) + + for name, num in sorted(syscalls.items(), key=lambda x: x[1]): + print("#define {p}{sc} {n}".format(p=NR_PREFIX, sc=name, n=num), file=f) + + print("#endif /* __MLIBC_SYSCALLNOS_h */", file=f) + + with open("include/bits/syscall_aliases.h", "w") as f: + print("#ifndef __MLIBC_SYSCALL_ALIAS_BIT", file=f) + print("#define __MLIBC_SYSCALL_ALIAS_BIT", file=f) + print("/* This file is autogenerated. Don't bother. */", file=f) + print("/* Generator script: sysdeps/linux/update-syscall-list.py. */", file=f) + + for x in sorted(list(syscall_set)): + print( + f"""\ +#ifdef\t{NR_PREFIX}{x} +#\tdefine SYS_{x} {NR_PREFIX}{x} +#endif +""", + end="", + file=f, + ) + + print("#endif /* __MLIBC_SYSCALL_ALIAS_BIT */", file=f) + + +if __name__ == "__main__": + with tempfile.TemporaryDirectory() as td: + main( + Context( + dirpath=pathlib.Path(td), + ) + ) diff --git a/lib/mlibc/sysdeps/linux/x86/arch-syscall.cpp b/lib/mlibc/sysdeps/linux/x86/arch-syscall.cpp new file mode 100644 index 0000000..35fc8aa --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/arch-syscall.cpp @@ -0,0 +1,90 @@ +#include <bits/syscall.h> +#include <sys/syscall.h> + +using sc_word_t = __sc_word_t; + +// Note: ebx is used for PIC (it holds a reference to the GOT), so we can't clobber it with gcc apparently, +// and also need to make sure to restore it after a syscall + +sc_word_t __do_syscall0(long sc) { + sc_word_t ret; + asm volatile("int $0x80" : "=a"(ret) : "a"(sc) : "memory"); + return ret; +} + +sc_word_t __do_syscall1(long sc, sc_word_t arg1) { + sc_word_t ret; + asm volatile("xchg %%ebx, %%edi;" + "int $0x80;" + "xchg %%edi, %%ebx;" + : "=a"(ret) + : "a"(sc), "D"(arg1) + : "memory"); + return ret; +} + +sc_word_t __do_syscall2(long sc, sc_word_t arg1, sc_word_t arg2) { + sc_word_t ret; + asm volatile("xchg %%ebx, %%edi;" + "int $0x80;" + "xchg %%edi, %%ebx;" + : "=a"(ret) + : "a"(sc), "D"(arg1), "c"(arg2) + : "memory"); + return ret; +} + +sc_word_t __do_syscall3(long sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3) { + sc_word_t ret; + asm volatile("xchg %%ebx, %%edi;" + "int $0x80;" + "xchg %%edi, %%ebx;" + : "=a"(ret) + : "a"(sc), "D"(arg1), "c"(arg2), "d"(arg3) + : "memory"); + return ret; +} + +sc_word_t __do_syscall4(long sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, sc_word_t arg4) { + sc_word_t ret; + asm volatile("xchg %%ebx, %%edi;" + "int $0x80;" + "xchg %%edi, %%ebx;" + : "=a"(ret) + : "a"(sc), "D"(arg1), "c"(arg2), "d"(arg3), "S"(arg4) + : "memory"); + return ret; +} + +sc_word_t __do_syscall5(long sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, sc_word_t arg4, + sc_word_t arg5) { + sc_word_t ret; + asm volatile("pushl %2;" + "push %%ebx;" + "mov 4(%%esp), %%ebx;" + "int $0x80;" + "pop %%ebx;" + "add $4, %%esp;" + : "=a"(ret) + : "a"(sc), "g"(arg1), "c"(arg2), "d"(arg3), "S"(arg4), "D"(arg5) + : "memory"); + return ret; +} + +sc_word_t __do_syscall6(long sc, sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, sc_word_t arg4, + sc_word_t arg5, sc_word_t arg6) { + sc_word_t ret; + sc_word_t a1a6[2] = { arg1, arg6 }; + asm volatile ("pushl %1;" + "push %%ebx;" + "push %%ebp;" + "mov 8(%%esp),%%ebx;" + "mov 4(%%ebx),%%ebp;" + "mov (%%ebx),%%ebx;" + "int $0x80;" + "pop %%ebp;" + "pop %%ebx;" + "add $4,%%esp;" + : "=a"(ret) : "g"(&a1a6), "a"(sc), "c"(arg2), "d"(arg3), "S"(arg4), "D"(arg5) : "memory"); + return ret; +} diff --git a/lib/mlibc/sysdeps/linux/x86/cp_syscall.S b/lib/mlibc/sysdeps/linux/x86/cp_syscall.S new file mode 100644 index 0000000..b89e1f4 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/cp_syscall.S @@ -0,0 +1,42 @@ + +.section .text +.global __mlibc_do_asm_cp_syscall +.global __mlibc_syscall_begin +.global __mlibc_syscall_end +.type __mlibc_do_asm_cp_syscall, "function" +__mlibc_do_asm_cp_syscall: + push %ebx + push %esi + push %edi + push %ebp + ; mov 16(%esp), %eax + mov 24(%esp), %ebx + mov 28(%esp), %ecx + mov 32(%esp), %edx + mov 36(%esp), %esi + mov 40(%esp), %edi + mov 44(%esp), %ebp + mov %gs:0x18, %al +__mlibc_syscall_begin: + /* tcbCancelEnableBit && tcbCancelTriggerBit */ + and $((1 << 0) | (1 << 2)), %al + cmp $((1 << 0) | (1 << 2)), %al + je cancel + mov 20(%esp), %eax + int $0x80 +__mlibc_syscall_end: + pop %ebp + pop %edi + pop %esi + pop %ebx + ret + +cancel: + pop %ebp + pop %edi + pop %esi + pop %ebx + call __mlibc_do_cancel@PLT + hlt + +.section .note.GNU-stack,"",%progbits diff --git a/lib/mlibc/sysdeps/linux/x86/crt-src/Scrt1.S b/lib/mlibc/sysdeps/linux/x86/crt-src/Scrt1.S new file mode 100644 index 0000000..a62b127 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/crt-src/Scrt1.S @@ -0,0 +1,29 @@ +.section .text + +.type __stack_chk_fail_local, %function +.weak __stack_chk_fail_local +__stack_chk_fail_local: + call __stack_chk_fail@plt + +.global _start + +.type _start, %function +.type main, %function +.type __mlibc_entry, %function + +.cfi_startproc +_start: +.cfi_undefined eip + xor %ebp, %ebp + mov %esp, %edi + call 1f + +1: + pop %ebx + addl $_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx + push main@GOT(%ebx) + push %edi + call __mlibc_entry@plt +.cfi_endproc + +.section .note.GNU-stack,"",%progbits diff --git a/lib/mlibc/sysdeps/linux/x86/crt-src/crt1.S b/lib/mlibc/sysdeps/linux/x86/crt-src/crt1.S new file mode 100644 index 0000000..ed45da3 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/crt-src/crt1.S @@ -0,0 +1,18 @@ +.section .text +.global _start + +.type _start, %function +.type main, %function +.type __mlibc_entry, %function + +.cfi_startproc +_start: +.cfi_undefined eip + xor %ebp, %ebp + mov %esp, %ecx + push $main + push %ecx + call __mlibc_entry +.cfi_endproc + +.section .note.GNU-stack,"",%progbits diff --git a/lib/mlibc/sysdeps/linux/x86/crt-src/crti.S b/lib/mlibc/sysdeps/linux/x86/crt-src/crti.S new file mode 100644 index 0000000..e232557 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/crt-src/crti.S @@ -0,0 +1,11 @@ +.section .init +.global _init +_init: + pushl %eax + +.section .fini +.global _fini +_fini: + pushl %eax + +.section .note.GNU-stack,"",%progbits diff --git a/lib/mlibc/sysdeps/linux/x86/crt-src/crtn.S b/lib/mlibc/sysdeps/linux/x86/crt-src/crtn.S new file mode 100644 index 0000000..d890289 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/crt-src/crtn.S @@ -0,0 +1,9 @@ +.section .init + popl %eax + ret + +.section .fini + popl %eax + ret + +.section .note.GNU-stack,"",%progbits diff --git a/lib/mlibc/sysdeps/linux/x86/signals.S b/lib/mlibc/sysdeps/linux/x86/signals.S new file mode 100644 index 0000000..8127ee4 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/signals.S @@ -0,0 +1,18 @@ +.section .text + +.global __mlibc_signal_restore +.type __mlibc_signal_restore, @function +__mlibc_signal_restore: + popl %eax + mov $119, %eax + int $0x80 + ud2 + +.global __mlibc_signal_restore_rt +.type __mlibc_signal_restore_rt, @function +__mlibc_signal_restore_rt: + mov $173, %eax + int $0x80 + ud2 + +.section .note.GNU-stack,"",%progbits diff --git a/lib/mlibc/sysdeps/linux/x86/syscallnos.h b/lib/mlibc/sysdeps/linux/x86/syscallnos.h new file mode 100644 index 0000000..f75eb0a --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/syscallnos.h @@ -0,0 +1,433 @@ +#ifndef __MLIBC_SYSCALLNOS_h +#define __MLIBC_SYSCALLNOS_h +/* This file is autogenerated. Don't bother. */ +/* Generator script: sysdeps/linux/update-syscall-list.py. */ +#define __NR_restart_syscall 0 +#define __NR_exit 1 +#define __NR_fork 2 +#define __NR_read 3 +#define __NR_write 4 +#define __NR_open 5 +#define __NR_close 6 +#define __NR_waitpid 7 +#define __NR_creat 8 +#define __NR_link 9 +#define __NR_unlink 10 +#define __NR_execve 11 +#define __NR_chdir 12 +#define __NR_time 13 +#define __NR_mknod 14 +#define __NR_chmod 15 +#define __NR_lchown 16 +#define __NR_oldstat 18 +#define __NR_lseek 19 +#define __NR_getpid 20 +#define __NR_mount 21 +#define __NR_umount 22 +#define __NR_setuid 23 +#define __NR_getuid 24 +#define __NR_stime 25 +#define __NR_ptrace 26 +#define __NR_alarm 27 +#define __NR_oldfstat 28 +#define __NR_pause 29 +#define __NR_utime 30 +#define __NR_access 33 +#define __NR_nice 34 +#define __NR_sync 36 +#define __NR_kill 37 +#define __NR_rename 38 +#define __NR_mkdir 39 +#define __NR_rmdir 40 +#define __NR_dup 41 +#define __NR_pipe 42 +#define __NR_times 43 +#define __NR_brk 45 +#define __NR_setgid 46 +#define __NR_getgid 47 +#define __NR_signal 48 +#define __NR_geteuid 49 +#define __NR_getegid 50 +#define __NR_acct 51 +#define __NR_umount2 52 +#define __NR_ioctl 54 +#define __NR_fcntl 55 +#define __NR_setpgid 57 +#define __NR_oldolduname 59 +#define __NR_umask 60 +#define __NR_chroot 61 +#define __NR_ustat 62 +#define __NR_dup2 63 +#define __NR_getppid 64 +#define __NR_getpgrp 65 +#define __NR_setsid 66 +#define __NR_sigaction 67 +#define __NR_sgetmask 68 +#define __NR_ssetmask 69 +#define __NR_setreuid 70 +#define __NR_setregid 71 +#define __NR_sigsuspend 72 +#define __NR_sigpending 73 +#define __NR_sethostname 74 +#define __NR_setrlimit 75 +#define __NR_getrlimit 76 +#define __NR_getrusage 77 +#define __NR_gettimeofday 78 +#define __NR_settimeofday 79 +#define __NR_getgroups 80 +#define __NR_setgroups 81 +#define __NR_select 82 +#define __NR_symlink 83 +#define __NR_oldlstat 84 +#define __NR_readlink 85 +#define __NR_uselib 86 +#define __NR_swapon 87 +#define __NR_reboot 88 +#define __NR_readdir 89 +#define __NR_mmap 90 +#define __NR_munmap 91 +#define __NR_truncate 92 +#define __NR_ftruncate 93 +#define __NR_fchmod 94 +#define __NR_fchown 95 +#define __NR_getpriority 96 +#define __NR_setpriority 97 +#define __NR_statfs 99 +#define __NR_fstatfs 100 +#define __NR_ioperm 101 +#define __NR_socketcall 102 +#define __NR_syslog 103 +#define __NR_setitimer 104 +#define __NR_getitimer 105 +#define __NR_stat 106 +#define __NR_lstat 107 +#define __NR_fstat 108 +#define __NR_olduname 109 +#define __NR_iopl 110 +#define __NR_vhangup 111 +#define __NR_idle 112 +#define __NR_vm86old 113 +#define __NR_wait4 114 +#define __NR_swapoff 115 +#define __NR_sysinfo 116 +#define __NR_ipc 117 +#define __NR_fsync 118 +#define __NR_sigreturn 119 +#define __NR_clone 120 +#define __NR_setdomainname 121 +#define __NR_uname 122 +#define __NR_modify_ldt 123 +#define __NR_adjtimex 124 +#define __NR_mprotect 125 +#define __NR_sigprocmask 126 +#define __NR_create_module 127 +#define __NR_init_module 128 +#define __NR_delete_module 129 +#define __NR_get_kernel_syms 130 +#define __NR_quotactl 131 +#define __NR_getpgid 132 +#define __NR_fchdir 133 +#define __NR_bdflush 134 +#define __NR_sysfs 135 +#define __NR_personality 136 +#define __NR_setfsuid 138 +#define __NR_setfsgid 139 +#define __NR__llseek 140 +#define __NR_getdents 141 +#define __NR__newselect 142 +#define __NR_flock 143 +#define __NR_msync 144 +#define __NR_readv 145 +#define __NR_writev 146 +#define __NR_getsid 147 +#define __NR_fdatasync 148 +#define __NR__sysctl 149 +#define __NR_mlock 150 +#define __NR_munlock 151 +#define __NR_mlockall 152 +#define __NR_munlockall 153 +#define __NR_sched_setparam 154 +#define __NR_sched_getparam 155 +#define __NR_sched_setscheduler 156 +#define __NR_sched_getscheduler 157 +#define __NR_sched_yield 158 +#define __NR_sched_get_priority_max 159 +#define __NR_sched_get_priority_min 160 +#define __NR_sched_rr_get_interval 161 +#define __NR_nanosleep 162 +#define __NR_mremap 163 +#define __NR_setresuid 164 +#define __NR_getresuid 165 +#define __NR_vm86 166 +#define __NR_query_module 167 +#define __NR_poll 168 +#define __NR_nfsservctl 169 +#define __NR_setresgid 170 +#define __NR_getresgid 171 +#define __NR_prctl 172 +#define __NR_rt_sigreturn 173 +#define __NR_rt_sigaction 174 +#define __NR_rt_sigprocmask 175 +#define __NR_rt_sigpending 176 +#define __NR_rt_sigtimedwait 177 +#define __NR_rt_sigqueueinfo 178 +#define __NR_rt_sigsuspend 179 +#define __NR_pread64 180 +#define __NR_pwrite64 181 +#define __NR_chown 182 +#define __NR_getcwd 183 +#define __NR_capget 184 +#define __NR_capset 185 +#define __NR_sigaltstack 186 +#define __NR_sendfile 187 +#define __NR_getpmsg 188 +#define __NR_vfork 190 +#define __NR_ugetrlimit 191 +#define __NR_mmap2 192 +#define __NR_truncate64 193 +#define __NR_ftruncate64 194 +#define __NR_stat64 195 +#define __NR_lstat64 196 +#define __NR_fstat64 197 +#define __NR_lchown32 198 +#define __NR_getuid32 199 +#define __NR_getgid32 200 +#define __NR_geteuid32 201 +#define __NR_getegid32 202 +#define __NR_setreuid32 203 +#define __NR_setregid32 204 +#define __NR_getgroups32 205 +#define __NR_setgroups32 206 +#define __NR_fchown32 207 +#define __NR_setresuid32 208 +#define __NR_getresuid32 209 +#define __NR_setresgid32 210 +#define __NR_getresgid32 211 +#define __NR_chown32 212 +#define __NR_setuid32 213 +#define __NR_setgid32 214 +#define __NR_setfsuid32 215 +#define __NR_setfsgid32 216 +#define __NR_pivot_root 217 +#define __NR_mincore 218 +#define __NR_madvise 219 +#define __NR_getdents64 220 +#define __NR_fcntl64 221 +#define __NR_gettid 224 +#define __NR_readahead 225 +#define __NR_setxattr 226 +#define __NR_lsetxattr 227 +#define __NR_fsetxattr 228 +#define __NR_getxattr 229 +#define __NR_lgetxattr 230 +#define __NR_fgetxattr 231 +#define __NR_listxattr 232 +#define __NR_llistxattr 233 +#define __NR_flistxattr 234 +#define __NR_removexattr 235 +#define __NR_lremovexattr 236 +#define __NR_fremovexattr 237 +#define __NR_tkill 238 +#define __NR_sendfile64 239 +#define __NR_futex 240 +#define __NR_sched_setaffinity 241 +#define __NR_sched_getaffinity 242 +#define __NR_set_thread_area 243 +#define __NR_get_thread_area 244 +#define __NR_io_setup 245 +#define __NR_io_destroy 246 +#define __NR_io_getevents 247 +#define __NR_io_submit 248 +#define __NR_io_cancel 249 +#define __NR_fadvise64 250 +#define __NR_exit_group 252 +#define __NR_lookup_dcookie 253 +#define __NR_epoll_create 254 +#define __NR_epoll_ctl 255 +#define __NR_epoll_wait 256 +#define __NR_remap_file_pages 257 +#define __NR_set_tid_address 258 +#define __NR_timer_create 259 +#define __NR_timer_settime 260 +#define __NR_timer_gettime 261 +#define __NR_timer_getoverrun 262 +#define __NR_timer_delete 263 +#define __NR_clock_settime 264 +#define __NR_clock_gettime 265 +#define __NR_clock_getres 266 +#define __NR_clock_nanosleep 267 +#define __NR_statfs64 268 +#define __NR_fstatfs64 269 +#define __NR_tgkill 270 +#define __NR_utimes 271 +#define __NR_fadvise64_64 272 +#define __NR_mbind 274 +#define __NR_get_mempolicy 275 +#define __NR_set_mempolicy 276 +#define __NR_mq_open 277 +#define __NR_mq_unlink 278 +#define __NR_mq_timedsend 279 +#define __NR_mq_timedreceive 280 +#define __NR_mq_notify 281 +#define __NR_mq_getsetattr 282 +#define __NR_kexec_load 283 +#define __NR_waitid 284 +#define __NR_add_key 286 +#define __NR_request_key 287 +#define __NR_keyctl 288 +#define __NR_ioprio_set 289 +#define __NR_ioprio_get 290 +#define __NR_inotify_init 291 +#define __NR_inotify_add_watch 292 +#define __NR_inotify_rm_watch 293 +#define __NR_migrate_pages 294 +#define __NR_openat 295 +#define __NR_mkdirat 296 +#define __NR_mknodat 297 +#define __NR_fchownat 298 +#define __NR_futimesat 299 +#define __NR_fstatat64 300 +#define __NR_unlinkat 301 +#define __NR_renameat 302 +#define __NR_linkat 303 +#define __NR_symlinkat 304 +#define __NR_readlinkat 305 +#define __NR_fchmodat 306 +#define __NR_faccessat 307 +#define __NR_pselect6 308 +#define __NR_ppoll 309 +#define __NR_unshare 310 +#define __NR_set_robust_list 311 +#define __NR_get_robust_list 312 +#define __NR_splice 313 +#define __NR_sync_file_range 314 +#define __NR_tee 315 +#define __NR_vmsplice 316 +#define __NR_move_pages 317 +#define __NR_getcpu 318 +#define __NR_epoll_pwait 319 +#define __NR_utimensat 320 +#define __NR_signalfd 321 +#define __NR_timerfd_create 322 +#define __NR_eventfd 323 +#define __NR_fallocate 324 +#define __NR_timerfd_settime 325 +#define __NR_timerfd_gettime 326 +#define __NR_signalfd4 327 +#define __NR_eventfd2 328 +#define __NR_epoll_create1 329 +#define __NR_dup3 330 +#define __NR_pipe2 331 +#define __NR_inotify_init1 332 +#define __NR_preadv 333 +#define __NR_pwritev 334 +#define __NR_rt_tgsigqueueinfo 335 +#define __NR_perf_event_open 336 +#define __NR_recvmmsg 337 +#define __NR_fanotify_init 338 +#define __NR_fanotify_mark 339 +#define __NR_prlimit64 340 +#define __NR_name_to_handle_at 341 +#define __NR_open_by_handle_at 342 +#define __NR_clock_adjtime 343 +#define __NR_syncfs 344 +#define __NR_sendmmsg 345 +#define __NR_setns 346 +#define __NR_process_vm_readv 347 +#define __NR_process_vm_writev 348 +#define __NR_kcmp 349 +#define __NR_finit_module 350 +#define __NR_sched_setattr 351 +#define __NR_sched_getattr 352 +#define __NR_renameat2 353 +#define __NR_seccomp 354 +#define __NR_getrandom 355 +#define __NR_memfd_create 356 +#define __NR_bpf 357 +#define __NR_execveat 358 +#define __NR_socket 359 +#define __NR_socketpair 360 +#define __NR_bind 361 +#define __NR_connect 362 +#define __NR_listen 363 +#define __NR_accept4 364 +#define __NR_getsockopt 365 +#define __NR_setsockopt 366 +#define __NR_getsockname 367 +#define __NR_getpeername 368 +#define __NR_sendto 369 +#define __NR_sendmsg 370 +#define __NR_recvfrom 371 +#define __NR_recvmsg 372 +#define __NR_shutdown 373 +#define __NR_userfaultfd 374 +#define __NR_membarrier 375 +#define __NR_mlock2 376 +#define __NR_copy_file_range 377 +#define __NR_preadv2 378 +#define __NR_pwritev2 379 +#define __NR_pkey_mprotect 380 +#define __NR_pkey_alloc 381 +#define __NR_pkey_free 382 +#define __NR_statx 383 +#define __NR_arch_prctl 384 +#define __NR_io_pgetevents 385 +#define __NR_rseq 386 +#define __NR_semget 393 +#define __NR_semctl 394 +#define __NR_shmget 395 +#define __NR_shmctl 396 +#define __NR_shmat 397 +#define __NR_shmdt 398 +#define __NR_msgget 399 +#define __NR_msgsnd 400 +#define __NR_msgrcv 401 +#define __NR_msgctl 402 +#define __NR_clock_gettime64 403 +#define __NR_clock_settime64 404 +#define __NR_clock_adjtime64 405 +#define __NR_clock_getres_time64 406 +#define __NR_clock_nanosleep_time64 407 +#define __NR_timer_gettime64 408 +#define __NR_timer_settime64 409 +#define __NR_timerfd_gettime64 410 +#define __NR_timerfd_settime64 411 +#define __NR_utimensat_time64 412 +#define __NR_pselect6_time64 413 +#define __NR_ppoll_time64 414 +#define __NR_io_pgetevents_time64 416 +#define __NR_recvmmsg_time64 417 +#define __NR_mq_timedsend_time64 418 +#define __NR_mq_timedreceive_time64 419 +#define __NR_semtimedop_time64 420 +#define __NR_rt_sigtimedwait_time64 421 +#define __NR_futex_time64 422 +#define __NR_sched_rr_get_interval_time64 423 +#define __NR_pidfd_send_signal 424 +#define __NR_io_uring_setup 425 +#define __NR_io_uring_enter 426 +#define __NR_io_uring_register 427 +#define __NR_open_tree 428 +#define __NR_move_mount 429 +#define __NR_fsopen 430 +#define __NR_fsconfig 431 +#define __NR_fsmount 432 +#define __NR_fspick 433 +#define __NR_pidfd_open 434 +#define __NR_clone3 435 +#define __NR_close_range 436 +#define __NR_openat2 437 +#define __NR_pidfd_getfd 438 +#define __NR_faccessat2 439 +#define __NR_process_madvise 440 +#define __NR_epoll_pwait2 441 +#define __NR_mount_setattr 442 +#define __NR_quotactl_fd 443 +#define __NR_landlock_create_ruleset 444 +#define __NR_landlock_add_rule 445 +#define __NR_landlock_restrict_self 446 +#define __NR_memfd_secret 447 +#define __NR_process_mrelease 448 +#define __NR_futex_waitv 449 +#define __NR_set_mempolicy_home_node 450 +#endif /* __MLIBC_SYSCALLNOS_h */ diff --git a/lib/mlibc/sysdeps/linux/x86/thread_entry.S b/lib/mlibc/sysdeps/linux/x86/thread_entry.S new file mode 100644 index 0000000..031a6aa --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86/thread_entry.S @@ -0,0 +1,61 @@ +#define FLAGS 4 +#define STACK FLAGS+4 +#define PTID STACK+4 +#define CTID PTID+4 +#define TLS CTID+4 + +.section .text +.global __mlibc_spawn_thread +.type __mlibc_spawn_thread, "function" +.cfi_startproc +__mlibc_spawn_thread: + push %ebx + .cfi_adjust_cfa_offset 4 + .cfi_rel_offset ebx, 0 + push %esi + .cfi_adjust_cfa_offset 4 + .cfi_rel_offset esi, 0 + push %edi + .cfi_adjust_cfa_offset 4 + .cfi_rel_offset edi, 0 + + xor %eax, %eax + mov 12+FLAGS(%esp), %ebx + mov 12+STACK(%esp), %ecx + mov 12+PTID(%esp), %edx + /* On x86-32 tls and child_tid have to be reversed */ + mov 12+TLS(%esp), %esi + mov 12+CTID(%esp), %edi + mov $120, %al + + int $0x80 + + test %eax, %eax + jnz .parent_exit + + xor %ebp, %ebp + .cfi_undefined %eip + .cfi_undefined %ebp + + call 1f +1: + pop %ebx + addl $_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx + + call __mlibc_enter_thread@plt + hlt + +.parent_exit: + pop %edi + .cfi_adjust_cfa_offset -4 + .cfi_restore edi + pop %esi + .cfi_adjust_cfa_offset -4 + .cfi_restore esi + pop %ebx + .cfi_adjust_cfa_offset -4 + .cfi_restore ebx + ret +.cfi_endproc + +.section .note.GNU-stack,"",%progbits diff --git a/lib/mlibc/sysdeps/linux/x86_64/arch-syscall.cpp b/lib/mlibc/sysdeps/linux/x86_64/arch-syscall.cpp new file mode 100644 index 0000000..d2ebbe7 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/arch-syscall.cpp @@ -0,0 +1,78 @@ +#include <sys/syscall.h> +#include <bits/syscall.h> + +using sc_word_t = __sc_word_t; + +sc_word_t __do_syscall0(long sc) { + sc_word_t ret; + asm volatile ("syscall" : "=a"(ret) + : "a"(sc) + : "rcx", "r11", "memory"); + return ret; +} + +sc_word_t __do_syscall1(long sc, + sc_word_t arg1) { + sc_word_t ret; + asm volatile ("syscall" : "=a"(ret) + : "a"(sc), "D"(arg1) + : "rcx", "r11", "memory"); + return ret; +} + +sc_word_t __do_syscall2(long sc, + sc_word_t arg1, sc_word_t arg2) { + sc_word_t ret; + asm volatile ("syscall" : "=a"(ret) + : "a"(sc), "D"(arg1), "S"(arg2) + : "rcx", "r11", "memory"); + return ret; +} + +sc_word_t __do_syscall3(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3) { + sc_word_t ret; + asm volatile ("syscall" : "=a"(ret) + : "a"(sc), "D"(arg1), "S"(arg2), "d"(arg3) + : "rcx", "r11", "memory"); + return ret; +} + +sc_word_t __do_syscall4(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4) { + sc_word_t ret; + register sc_word_t arg4_reg asm("r10") = arg4; + asm volatile ("syscall" : "=a"(ret) + : "a"(sc), "D"(arg1), "S"(arg2), "d"(arg3), + "r"(arg4_reg) + : "rcx", "r11", "memory"); + return ret; +} + +sc_word_t __do_syscall5(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5) { + sc_word_t ret; + register sc_word_t arg4_reg asm("r10") = arg4; + register sc_word_t arg5_reg asm("r8") = arg5; + asm volatile ("syscall" : "=a"(ret) + : "a"(sc), "D"(arg1), "S"(arg2), "d"(arg3), + "r"(arg4_reg), "r"(arg5_reg) + : "rcx", "r11", "memory"); + return ret; +} + +sc_word_t __do_syscall6(long sc, + sc_word_t arg1, sc_word_t arg2, sc_word_t arg3, + sc_word_t arg4, sc_word_t arg5, sc_word_t arg6) { + sc_word_t ret; + register sc_word_t arg4_reg asm("r10") = arg4; + register sc_word_t arg5_reg asm("r8") = arg5; + register sc_word_t arg6_reg asm("r9") = arg6; + asm volatile ("syscall" : "=a"(ret) + : "a"(sc), "D"(arg1), "S"(arg2), "d"(arg3), + "r"(arg4_reg), "r"(arg5_reg), "r"(arg6_reg) + : "rcx", "r11", "memory"); + return ret; +} diff --git a/lib/mlibc/sysdeps/linux/x86_64/cp_syscall.S b/lib/mlibc/sysdeps/linux/x86_64/cp_syscall.S new file mode 100644 index 0000000..5db1f1d --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/cp_syscall.S @@ -0,0 +1,29 @@ + +.section .text +.global __mlibc_do_asm_cp_syscall +.global __mlibc_syscall_begin +.global __mlibc_syscall_end +.type __mlibc_do_asm_cp_syscall, "function" +__mlibc_do_asm_cp_syscall: + mov %rdi, %rax + mov %rsi, %rdi + mov %rdx, %rsi + mov %rcx, %rdx + mov %r8, %r10 + mov %r9, %r8 + mov 8(%rsp), %r9 + mov %fs:0x30, %r11 +__mlibc_syscall_begin: + /* tcbCancelEnableBit && tcbCancelTriggerBit */ + and $((1 << 0) | (1 << 2)), %r11 + cmp $((1 << 0) | (1 << 2)), %r11 + je cancel + syscall +__mlibc_syscall_end: + ret + +cancel: + call __mlibc_do_cancel + hlt +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/x86_64/crt-src/Scrt1.S b/lib/mlibc/sysdeps/linux/x86_64/crt-src/Scrt1.S new file mode 100644 index 0000000..d0e8213 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/crt-src/Scrt1.S @@ -0,0 +1,8 @@ +.section .text +.global _start +_start: + mov %rsp, %rdi + lea main(%rip), %rsi + call __mlibc_entry +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/x86_64/crt-src/crt1.S b/lib/mlibc/sysdeps/linux/x86_64/crt-src/crt1.S new file mode 100644 index 0000000..9b77ee7 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/crt-src/crt1.S @@ -0,0 +1,8 @@ +.section .text +.global _start +_start: + mov %rsp, %rdi + mov $main, %rsi + call __mlibc_entry +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/x86_64/crt-src/crti.S b/lib/mlibc/sysdeps/linux/x86_64/crt-src/crti.S new file mode 100644 index 0000000..911b078 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/crt-src/crti.S @@ -0,0 +1,11 @@ +.section .init +.global _init +_init: + push %rax + +.section .fini +.global _fini +_fini: + push %rax +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/x86_64/crt-src/crtn.S b/lib/mlibc/sysdeps/linux/x86_64/crt-src/crtn.S new file mode 100644 index 0000000..0187e50 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/crt-src/crtn.S @@ -0,0 +1,9 @@ +.section .init + pop %rax + ret + +.section .fini + pop %rax + ret +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/x86_64/signals.S b/lib/mlibc/sysdeps/linux/x86_64/signals.S new file mode 100644 index 0000000..09b4387 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/signals.S @@ -0,0 +1,14 @@ + +.section .text + +.global __mlibc_signal_restore +.type __mlibc_signal_restore, @function +__mlibc_signal_restore: +.global __mlibc_signal_restore_rt +.type __mlibc_signal_restore_rt, @function +__mlibc_signal_restore_rt: + mov $15, %rax + syscall + ud2 +.section .note.GNU-stack,"",%progbits + diff --git a/lib/mlibc/sysdeps/linux/x86_64/syscallnos.h b/lib/mlibc/sysdeps/linux/x86_64/syscallnos.h new file mode 100644 index 0000000..6c07e69 --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/syscallnos.h @@ -0,0 +1,362 @@ +#ifndef __MLIBC_SYSCALLNOS_h +#define __MLIBC_SYSCALLNOS_h +/* This file is autogenerated. Don't bother. */ +/* Generator script: sysdeps/linux/update-syscall-list.py. */ +#define __NR_read 0 +#define __NR_write 1 +#define __NR_open 2 +#define __NR_close 3 +#define __NR_stat 4 +#define __NR_fstat 5 +#define __NR_lstat 6 +#define __NR_poll 7 +#define __NR_lseek 8 +#define __NR_mmap 9 +#define __NR_mprotect 10 +#define __NR_munmap 11 +#define __NR_brk 12 +#define __NR_rt_sigaction 13 +#define __NR_rt_sigprocmask 14 +#define __NR_rt_sigreturn 15 +#define __NR_ioctl 16 +#define __NR_pread64 17 +#define __NR_pwrite64 18 +#define __NR_readv 19 +#define __NR_writev 20 +#define __NR_access 21 +#define __NR_pipe 22 +#define __NR_select 23 +#define __NR_sched_yield 24 +#define __NR_mremap 25 +#define __NR_msync 26 +#define __NR_mincore 27 +#define __NR_madvise 28 +#define __NR_shmget 29 +#define __NR_shmat 30 +#define __NR_shmctl 31 +#define __NR_dup 32 +#define __NR_dup2 33 +#define __NR_pause 34 +#define __NR_nanosleep 35 +#define __NR_getitimer 36 +#define __NR_alarm 37 +#define __NR_setitimer 38 +#define __NR_getpid 39 +#define __NR_sendfile 40 +#define __NR_socket 41 +#define __NR_connect 42 +#define __NR_accept 43 +#define __NR_sendto 44 +#define __NR_recvfrom 45 +#define __NR_sendmsg 46 +#define __NR_recvmsg 47 +#define __NR_shutdown 48 +#define __NR_bind 49 +#define __NR_listen 50 +#define __NR_getsockname 51 +#define __NR_getpeername 52 +#define __NR_socketpair 53 +#define __NR_setsockopt 54 +#define __NR_getsockopt 55 +#define __NR_clone 56 +#define __NR_fork 57 +#define __NR_vfork 58 +#define __NR_execve 59 +#define __NR_exit 60 +#define __NR_wait4 61 +#define __NR_kill 62 +#define __NR_uname 63 +#define __NR_semget 64 +#define __NR_semop 65 +#define __NR_semctl 66 +#define __NR_shmdt 67 +#define __NR_msgget 68 +#define __NR_msgsnd 69 +#define __NR_msgrcv 70 +#define __NR_msgctl 71 +#define __NR_fcntl 72 +#define __NR_flock 73 +#define __NR_fsync 74 +#define __NR_fdatasync 75 +#define __NR_truncate 76 +#define __NR_ftruncate 77 +#define __NR_getdents 78 +#define __NR_getcwd 79 +#define __NR_chdir 80 +#define __NR_fchdir 81 +#define __NR_rename 82 +#define __NR_mkdir 83 +#define __NR_rmdir 84 +#define __NR_creat 85 +#define __NR_link 86 +#define __NR_unlink 87 +#define __NR_symlink 88 +#define __NR_readlink 89 +#define __NR_chmod 90 +#define __NR_fchmod 91 +#define __NR_chown 92 +#define __NR_fchown 93 +#define __NR_lchown 94 +#define __NR_umask 95 +#define __NR_gettimeofday 96 +#define __NR_getrlimit 97 +#define __NR_getrusage 98 +#define __NR_sysinfo 99 +#define __NR_times 100 +#define __NR_ptrace 101 +#define __NR_getuid 102 +#define __NR_syslog 103 +#define __NR_getgid 104 +#define __NR_setuid 105 +#define __NR_setgid 106 +#define __NR_geteuid 107 +#define __NR_getegid 108 +#define __NR_setpgid 109 +#define __NR_getppid 110 +#define __NR_getpgrp 111 +#define __NR_setsid 112 +#define __NR_setreuid 113 +#define __NR_setregid 114 +#define __NR_getgroups 115 +#define __NR_setgroups 116 +#define __NR_setresuid 117 +#define __NR_getresuid 118 +#define __NR_setresgid 119 +#define __NR_getresgid 120 +#define __NR_getpgid 121 +#define __NR_setfsuid 122 +#define __NR_setfsgid 123 +#define __NR_getsid 124 +#define __NR_capget 125 +#define __NR_capset 126 +#define __NR_rt_sigpending 127 +#define __NR_rt_sigtimedwait 128 +#define __NR_rt_sigqueueinfo 129 +#define __NR_rt_sigsuspend 130 +#define __NR_sigaltstack 131 +#define __NR_utime 132 +#define __NR_mknod 133 +#define __NR_uselib 134 +#define __NR_personality 135 +#define __NR_ustat 136 +#define __NR_statfs 137 +#define __NR_fstatfs 138 +#define __NR_sysfs 139 +#define __NR_getpriority 140 +#define __NR_setpriority 141 +#define __NR_sched_setparam 142 +#define __NR_sched_getparam 143 +#define __NR_sched_setscheduler 144 +#define __NR_sched_getscheduler 145 +#define __NR_sched_get_priority_max 146 +#define __NR_sched_get_priority_min 147 +#define __NR_sched_rr_get_interval 148 +#define __NR_mlock 149 +#define __NR_munlock 150 +#define __NR_mlockall 151 +#define __NR_munlockall 152 +#define __NR_vhangup 153 +#define __NR_modify_ldt 154 +#define __NR_pivot_root 155 +#define __NR__sysctl 156 +#define __NR_prctl 157 +#define __NR_arch_prctl 158 +#define __NR_adjtimex 159 +#define __NR_setrlimit 160 +#define __NR_chroot 161 +#define __NR_sync 162 +#define __NR_acct 163 +#define __NR_settimeofday 164 +#define __NR_mount 165 +#define __NR_umount2 166 +#define __NR_swapon 167 +#define __NR_swapoff 168 +#define __NR_reboot 169 +#define __NR_sethostname 170 +#define __NR_setdomainname 171 +#define __NR_iopl 172 +#define __NR_ioperm 173 +#define __NR_create_module 174 +#define __NR_init_module 175 +#define __NR_delete_module 176 +#define __NR_get_kernel_syms 177 +#define __NR_query_module 178 +#define __NR_quotactl 179 +#define __NR_nfsservctl 180 +#define __NR_getpmsg 181 +#define __NR_gettid 186 +#define __NR_readahead 187 +#define __NR_setxattr 188 +#define __NR_lsetxattr 189 +#define __NR_fsetxattr 190 +#define __NR_getxattr 191 +#define __NR_lgetxattr 192 +#define __NR_fgetxattr 193 +#define __NR_listxattr 194 +#define __NR_llistxattr 195 +#define __NR_flistxattr 196 +#define __NR_removexattr 197 +#define __NR_lremovexattr 198 +#define __NR_fremovexattr 199 +#define __NR_tkill 200 +#define __NR_time 201 +#define __NR_futex 202 +#define __NR_sched_setaffinity 203 +#define __NR_sched_getaffinity 204 +#define __NR_set_thread_area 205 +#define __NR_io_setup 206 +#define __NR_io_destroy 207 +#define __NR_io_getevents 208 +#define __NR_io_submit 209 +#define __NR_io_cancel 210 +#define __NR_get_thread_area 211 +#define __NR_lookup_dcookie 212 +#define __NR_epoll_create 213 +#define __NR_epoll_ctl_old 214 +#define __NR_epoll_wait_old 215 +#define __NR_remap_file_pages 216 +#define __NR_getdents64 217 +#define __NR_set_tid_address 218 +#define __NR_restart_syscall 219 +#define __NR_semtimedop 220 +#define __NR_fadvise64 221 +#define __NR_timer_create 222 +#define __NR_timer_settime 223 +#define __NR_timer_gettime 224 +#define __NR_timer_getoverrun 225 +#define __NR_timer_delete 226 +#define __NR_clock_settime 227 +#define __NR_clock_gettime 228 +#define __NR_clock_getres 229 +#define __NR_clock_nanosleep 230 +#define __NR_exit_group 231 +#define __NR_epoll_wait 232 +#define __NR_epoll_ctl 233 +#define __NR_tgkill 234 +#define __NR_utimes 235 +#define __NR_mbind 237 +#define __NR_set_mempolicy 238 +#define __NR_get_mempolicy 239 +#define __NR_mq_open 240 +#define __NR_mq_unlink 241 +#define __NR_mq_timedsend 242 +#define __NR_mq_timedreceive 243 +#define __NR_mq_notify 244 +#define __NR_mq_getsetattr 245 +#define __NR_kexec_load 246 +#define __NR_waitid 247 +#define __NR_add_key 248 +#define __NR_request_key 249 +#define __NR_keyctl 250 +#define __NR_ioprio_set 251 +#define __NR_ioprio_get 252 +#define __NR_inotify_init 253 +#define __NR_inotify_add_watch 254 +#define __NR_inotify_rm_watch 255 +#define __NR_migrate_pages 256 +#define __NR_openat 257 +#define __NR_mkdirat 258 +#define __NR_mknodat 259 +#define __NR_fchownat 260 +#define __NR_futimesat 261 +#define __NR_newfstatat 262 +#define __NR_unlinkat 263 +#define __NR_renameat 264 +#define __NR_linkat 265 +#define __NR_symlinkat 266 +#define __NR_readlinkat 267 +#define __NR_fchmodat 268 +#define __NR_faccessat 269 +#define __NR_pselect6 270 +#define __NR_ppoll 271 +#define __NR_unshare 272 +#define __NR_set_robust_list 273 +#define __NR_get_robust_list 274 +#define __NR_splice 275 +#define __NR_tee 276 +#define __NR_sync_file_range 277 +#define __NR_vmsplice 278 +#define __NR_move_pages 279 +#define __NR_utimensat 280 +#define __NR_epoll_pwait 281 +#define __NR_signalfd 282 +#define __NR_timerfd_create 283 +#define __NR_eventfd 284 +#define __NR_fallocate 285 +#define __NR_timerfd_settime 286 +#define __NR_timerfd_gettime 287 +#define __NR_accept4 288 +#define __NR_signalfd4 289 +#define __NR_eventfd2 290 +#define __NR_epoll_create1 291 +#define __NR_dup3 292 +#define __NR_pipe2 293 +#define __NR_inotify_init1 294 +#define __NR_preadv 295 +#define __NR_pwritev 296 +#define __NR_rt_tgsigqueueinfo 297 +#define __NR_perf_event_open 298 +#define __NR_recvmmsg 299 +#define __NR_fanotify_init 300 +#define __NR_fanotify_mark 301 +#define __NR_prlimit64 302 +#define __NR_name_to_handle_at 303 +#define __NR_open_by_handle_at 304 +#define __NR_clock_adjtime 305 +#define __NR_syncfs 306 +#define __NR_sendmmsg 307 +#define __NR_setns 308 +#define __NR_getcpu 309 +#define __NR_process_vm_readv 310 +#define __NR_process_vm_writev 311 +#define __NR_kcmp 312 +#define __NR_finit_module 313 +#define __NR_sched_setattr 314 +#define __NR_sched_getattr 315 +#define __NR_renameat2 316 +#define __NR_seccomp 317 +#define __NR_getrandom 318 +#define __NR_memfd_create 319 +#define __NR_kexec_file_load 320 +#define __NR_bpf 321 +#define __NR_execveat 322 +#define __NR_userfaultfd 323 +#define __NR_membarrier 324 +#define __NR_mlock2 325 +#define __NR_copy_file_range 326 +#define __NR_preadv2 327 +#define __NR_pwritev2 328 +#define __NR_pkey_mprotect 329 +#define __NR_pkey_alloc 330 +#define __NR_pkey_free 331 +#define __NR_statx 332 +#define __NR_io_pgetevents 333 +#define __NR_rseq 334 +#define __NR_pidfd_send_signal 424 +#define __NR_io_uring_setup 425 +#define __NR_io_uring_enter 426 +#define __NR_io_uring_register 427 +#define __NR_open_tree 428 +#define __NR_move_mount 429 +#define __NR_fsopen 430 +#define __NR_fsconfig 431 +#define __NR_fsmount 432 +#define __NR_fspick 433 +#define __NR_pidfd_open 434 +#define __NR_clone3 435 +#define __NR_close_range 436 +#define __NR_openat2 437 +#define __NR_pidfd_getfd 438 +#define __NR_faccessat2 439 +#define __NR_process_madvise 440 +#define __NR_epoll_pwait2 441 +#define __NR_mount_setattr 442 +#define __NR_quotactl_fd 443 +#define __NR_landlock_create_ruleset 444 +#define __NR_landlock_add_rule 445 +#define __NR_landlock_restrict_self 446 +#define __NR_memfd_secret 447 +#define __NR_process_mrelease 448 +#define __NR_futex_waitv 449 +#define __NR_set_mempolicy_home_node 450 +#endif /* __MLIBC_SYSCALLNOS_h */ diff --git a/lib/mlibc/sysdeps/linux/x86_64/thread_entry.S b/lib/mlibc/sysdeps/linux/x86_64/thread_entry.S new file mode 100644 index 0000000..954c6dd --- /dev/null +++ b/lib/mlibc/sysdeps/linux/x86_64/thread_entry.S @@ -0,0 +1,23 @@ + +.section .text +.global __mlibc_spawn_thread +.type __mlibc_spawn_thread, "function" +__mlibc_spawn_thread: + xor %eax, %eax + /* The rest of the args are already in the right registers, + * only need to fixup rcx to r10 + */ + mov %rcx, %r10 + mov $56, %al + syscall + test %eax, %eax + jnz 1f + xor %ebp, %ebp + pop %rdi + pop %rsi + call __mlibc_enter_thread + hlt +1: + ret +.section .note.GNU-stack,"",%progbits + |