diff --git a/libc-test/build.rs b/libc-test/build.rs index a847f46448938..5419e7763aea3 100644 --- a/libc-test/build.rs +++ b/libc-test/build.rs @@ -11,7 +11,7 @@ use std::{env, io}; fn do_cc() { let target = env::var("TARGET").unwrap(); if cfg!(unix) { - let exclude = ["redox", "wasi"]; + let exclude = ["redox", "wasi", "wasm32-linux-musl"]; if !exclude.iter().any(|x| target.contains(x)) { let mut cmsg = cc::Build::new(); @@ -23,7 +23,7 @@ fn do_cc() { cmsg.compile("cmsg"); } - if target.contains("linux") + if (target.contains("linux") && !target.contains("wasm32")) || target.contains("android") || target.contains("emscripten") || target.contains("fuchsia") @@ -32,10 +32,10 @@ fn do_cc() { cc::Build::new().file("src/makedev.c").compile("makedev"); } } - if target.contains("android") || target.contains("linux") { + if target.contains("android") || (target.contains("linux") && !target.contains("wasm32")) { cc::Build::new().file("src/errqueue.c").compile("errqueue"); } - if target.contains("linux") + if (target.contains("linux") && !target.contains("wasm32")) || target.contains("l4re") || target.contains("android") || target.contains("emscripten") @@ -52,7 +52,8 @@ fn do_ctest() { t if t.contains("emscripten") => return test_emscripten(t), t if t.contains("freebsd") => return test_freebsd(t), t if t.contains("haiku") => return test_haiku(t), - t if t.contains("linux") => return test_linux(t), + t if t.contains("linux") && !t.contains("wasm32") => return test_linux(t), + t if t.contains("linux") && t.contains("wasm32") => return test_wali(t), t if t.contains("netbsd") => return test_netbsd(t), t if t.contains("openbsd") => return test_openbsd(t), t if t.contains("redox") => return test_redox(t), @@ -3925,10 +3926,1019 @@ fn test_linux(target: &str) { | "MFD_EXEC" | "MFD_NOEXEC_SEAL" | "SECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECV" - if sparc64 => true, + => true, + + // FIXME: Not currently available in headers on ARM and musl. + "NETLINK_GET_STRICT_CHK" if arm || musl => true, + + // kernel constants not available in uclibc 1.0.34 + | "EXTPROC" + | "IPPROTO_BEETPH" + | "IPPROTO_MPLS" + | "IPV6_HDRINCL" + | "IPV6_MULTICAST_ALL" + | "IPV6_PMTUDISC_INTERFACE" + | "IPV6_PMTUDISC_OMIT" + | "IPV6_ROUTER_ALERT_ISOLATE" + | "PACKET_MR_UNICAST" + | "RUSAGE_THREAD" + | "SHM_EXEC" + | "UDP_GRO" + | "UDP_SEGMENT" + if uclibc => true, + + // headers conflicts with linux/pidfd.h + "PIDFD_NONBLOCK" => true, + + // is a private value for kernel usage normally + "FUSE_SUPER_MAGIC" => true, + + // linux 5.17 min + "PR_SET_VMA" | "PR_SET_VMA_ANON_NAME" => true, + + // present in recent kernels only + "PR_SCHED_CORE" | "PR_SCHED_CORE_CREATE" | "PR_SCHED_CORE_GET" | "PR_SCHED_CORE_MAX" | "PR_SCHED_CORE_SCOPE_PROCESS_GROUP" | "PR_SCHED_CORE_SCOPE_THREAD" | "PR_SCHED_CORE_SCOPE_THREAD_GROUP" | "PR_SCHED_CORE_SHARE_FROM" | "PR_SCHED_CORE_SHARE_TO" => true, + + // present in recent kernels only >= 5.13 + "PR_PAC_SET_ENABLED_KEYS" | "PR_PAC_GET_ENABLED_KEYS" => true, + // present in recent kernels only >= 5.19 + "PR_SME_SET_VL" | "PR_SME_GET_VL" | "PR_SME_VL_LEN_MAX" | "PR_SME_SET_VL_INHERIT" | "PR_SME_SET_VL_ONE_EXEC" => true, + + // Added in Linux 5.14 + "FUTEX_LOCK_PI2" => true, + + // Added in linux 6.1 + "STATX_DIOALIGN" + | "CAN_RAW_XL_FRAMES" + | "CANXL_HDR_SIZE" + | "CANXL_MAX_DLC" + | "CANXL_MAX_DLC_MASK" + | "CANXL_MAX_DLEN" + | "CANXL_MAX_MTU" + | "CANXL_MIN_DLC" + | "CANXL_MIN_DLEN" + | "CANXL_MIN_MTU" + | "CANXL_MTU" + | "CANXL_PRIO_BITS" + | "CANXL_PRIO_MASK" + | "CANXL_SEC" + | "CANXL_XLF" + => true, + + // FIXME: Parts of netfilter/nfnetlink*.h require more recent kernel headers: + | "RTNLGRP_MCTP_IFADDR" // linux v5.17+ + | "RTNLGRP_TUNNEL" // linux v5.18+ + | "RTNLGRP_STATS" // linux v5.18+ + => true, + + // FIXME: The below is no longer const in glibc 2.34: + // https://github.com/bminor/glibc/commit/5d98a7dae955bafa6740c26eaba9c86060ae0344 + | "PTHREAD_STACK_MIN" + | "SIGSTKSZ" + | "MINSIGSTKSZ" + if gnu => true, + + // FIXME: Linux >= 5.16 changed its value: + // https://github.com/torvalds/linux/commit/42df6e1d221dddc0f2acf2be37e68d553ad65f96 + "NF_NETDEV_NUMHOOKS" => true, + + // FIXME: requires Linux >= 5.6: + | "RESOLVE_BENEATH" + | "RESOLVE_CACHED" + | "RESOLVE_IN_ROOT" + | "RESOLVE_NO_MAGICLINKS" + | "RESOLVE_NO_SYMLINKS" + | "RESOLVE_NO_XDEV" if musl => true, + + // FIXME: requires Linux >= 5.4: + | "CAN_J1939" + | "CAN_NPROTO" if musl => true, + + // FIXME: requires Linux >= 5.6 + "GRND_INSECURE" if musl => true, + + // FIXME: requires Linux >= 5.7: + "MREMAP_DONTUNMAP" if musl => true, + + // FIXME: requires Linux >= v5.8 + "IF_LINK_MODE_TESTING" if musl || sparc64 => true, + + // FIXME: Requires more recent kernel headers (5.9 / 5.11): + | "CLOSE_RANGE_UNSHARE" + | "CLOSE_RANGE_CLOEXEC" if musl => true, + + // FIXME: requires Linux >= 5.12: + "MPOL_F_NUMA_BALANCING" if musl => true, + + // FIXME: Requires more recent kernel headers + | "NFNL_SUBSYS_COUNT" // bumped in v5.14 + | "NFNL_SUBSYS_HOOK" // v5.14+ + | "NFULA_VLAN" // v5.4+ + | "NFULA_L2HDR" // v5.4+ + | "NFULA_VLAN_PROTO" // v5.4+ + | "NFULA_VLAN_TCI" // v5.4+ + | "NFULA_VLAN_UNSPEC" // v5.4+ + | "RTNLGRP_NEXTHOP" // linux v5.3+ + | "RTNLGRP_BRVLAN" // linux v5.6+ + if musl => true, + + | "MADV_COLD" + | "MADV_PAGEOUT" + | "MADV_POPULATE_READ" + | "MADV_POPULATE_WRITE" + if musl => true, + "CLONE_CLEAR_SIGHAND" | "CLONE_INTO_CGROUP" => true, + + // kernel 6.1 minimum + "MADV_COLLAPSE" => true, + + // kernel 6.2 minimum + "TUN_F_USO4" | "TUN_F_USO6" | "IFF_NO_CARRIER" => true, + + // FIXME: Requires more recent kernel headers + | "IFLA_PARENT_DEV_NAME" // linux v5.13+ + | "IFLA_PARENT_DEV_BUS_NAME" // linux v5.13+ + | "IFLA_GRO_MAX_SIZE" // linux v5.16+ + | "IFLA_TSO_MAX_SIZE" // linux v5.18+ + | "IFLA_TSO_MAX_SEGS" // linux v5.18+ + | "IFLA_ALLMULTI" // linux v6.0+ + | "MADV_DONTNEED_LOCKED" // linux v5.18+ + => true, + "SCTP_FUTURE_ASSOC" | "SCTP_CURRENT_ASSOC" | "SCTP_ALL_ASSOC" | "SCTP_PEER_ADDR_THLDS_V2" => true, // linux 5.5+ + + // FIXME: Requires more recent kernel headers + "HWTSTAMP_TX_ONESTEP_P2P" if musl => true, // linux v5.6+ + + // kernel 6.5 minimum + "MOVE_MOUNT_BENEATH" => true, + // FIXME: Requires linux 6.1 + "ALG_SET_KEY_BY_KEY_SERIAL" | "ALG_SET_DRBG_ENTROPY" => true, + + // FIXME: Requires more recent kernel headers + | "FAN_FS_ERROR" // linux v5.16+ + | "FAN_RENAME" // linux v5.17+ + | "FAN_REPORT_TARGET_FID" // linux v5.17+ + | "FAN_REPORT_DFID_NAME_TARGET" // linux v5.17+ + | "FAN_MARK_EVICTABLE" // linux v5.19+ + | "FAN_MARK_IGNORE" // linux v6.0+ + | "FAN_MARK_IGNORE_SURV" // linux v6.0+ + | "FAN_EVENT_INFO_TYPE_ERROR" // linux v5.16+ + | "FAN_EVENT_INFO_TYPE_OLD_DFID_NAME" // linux v5.17+ + | "FAN_EVENT_INFO_TYPE_NEW_DFID_NAME" // linux v5.17+ + | "FAN_RESPONSE_INFO_NONE" // linux v5.16+ + | "FAN_RESPONSE_INFO_AUDIT_RULE" // linux v5.16+ + | "FAN_INFO" // linux v5.16+ + => true, + + // FIXME: Requires linux 5.15+ + "FAN_REPORT_PIDFD" if musl => true, + + // FIXME: Requires linux 5.9+ + | "FAN_REPORT_DIR_FID" + | "FAN_REPORT_NAME" + | "FAN_REPORT_DFID_NAME" + | "FAN_EVENT_INFO_TYPE_DFID_NAME" + | "FAN_EVENT_INFO_TYPE_DFID" + | "FAN_EVENT_INFO_TYPE_PIDFD" + | "FAN_NOPIDFD" + | "FAN_EPIDFD" + if musl => true, + + // FIXME: Requires linux 6.5 + "NFT_MSG_MAX" => true, + + // FIXME: Requires >= 5.1 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "TLS_1_3_VERSION" + | "TLS_1_3_VERSION_MAJOR" + | "TLS_1_3_VERSION_MINOR" + | "TLS_CIPHER_AES_GCM_256" + | "TLS_CIPHER_AES_GCM_256_IV_SIZE" + | "TLS_CIPHER_AES_GCM_256_KEY_SIZE" + | "TLS_CIPHER_AES_GCM_256_SALT_SIZE" + | "TLS_CIPHER_AES_GCM_256_TAG_SIZE" + | "TLS_CIPHER_AES_GCM_256_REC_SEQ_SIZE" + if (aarch64 || arm || i686 || s390x || x86_64) && musl => + { + true + } + + // FIXME: Requires >= 5.11 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "TLS_CIPHER_CHACHA20_POLY1305" + | "TLS_CIPHER_CHACHA20_POLY1305_IV_SIZE" + | "TLS_CIPHER_CHACHA20_POLY1305_KEY_SIZE" + | "TLS_CIPHER_CHACHA20_POLY1305_SALT_SIZE" + | "TLS_CIPHER_CHACHA20_POLY1305_TAG_SIZE" + | "TLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZE" + if (aarch64 || arm || i686 || s390x || x86_64) && musl => + { + true + } + + // FIXME: Requires >= 5.3 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "XDP_OPTIONS_ZEROCOPY" | "XDP_OPTIONS" + if musl => + { + true + } + + // FIXME: Requires >= 5.4 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "XSK_UNALIGNED_BUF_OFFSET_SHIFT" + | "XSK_UNALIGNED_BUF_ADDR_MASK" + | "XDP_UMEM_UNALIGNED_CHUNK_FLAG" + | "XDP_RING_NEED_WAKEUP" + | "XDP_USE_NEED_WAKEUP" + if musl => + { + true + } + + // FIXME: Requires >= 6.6 kernel headers. + "XDP_USE_SG" + | "XDP_PKT_CONTD" + => + { + true + } + + // FIXME: seems to not be available all the time (from : + "PF_VCPU" + | "PF_IDLE" + | "PF_EXITING" + | "PF_POSTCOREDUMP" + | "PF_IO_WORKER" + | "PF_WQ_WORKER" + | "PF_FORKNOEXEC" + | "PF_MCE_PROCESS" + | "PF_SUPERPRIV" + | "PF_DUMPCORE" + | "PF_SIGNALED" + | "PF_MEMALLOC" + | "PF_NPROC_EXCEEDED" + | "PF_USED_MATH" + | "PF_USER_WORKER" + | "PF_NOFREEZE" + | "PF_KSWAPD" + | "PF_MEMALLOC_NOFS" + | "PF_MEMALLOC_NOIO" + | "PF_LOCAL_THROTTLE" + | "PF_KTHREAD" + | "PF_RANDOMIZE" + | "PF_NO_SETAFFINITY" + | "PF_MCE_EARLY" + | "PF_MEMALLOC_PIN" => true, + + "SCHED_FLAG_KEEP_POLICY" + | "SCHED_FLAG_KEEP_PARAMS" + | "SCHED_FLAG_UTIL_CLAMP_MIN" + | "SCHED_FLAG_UTIL_CLAMP_MAX" + | "SCHED_FLAG_KEEP_ALL" + | "SCHED_FLAG_UTIL_CLAMP" + | "SCHED_FLAG_ALL" if musl => true, // Needs more recent linux headers. + + _ => false, + } + }); + + cfg.skip_fn(move |name| { + // skip those that are manually verified + match name { + // FIXME: https://github.com/rust-lang/libc/issues/1272 + "execv" | "execve" | "execvp" | "execvpe" | "fexecve" => true, + + // There are two versions of the sterror_r function, see + // + // https://linux.die.net/man/3/strerror_r + // + // An XSI-compliant version provided if: + // + // (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) + // && ! _GNU_SOURCE + // + // and a GNU specific version provided if _GNU_SOURCE is defined. + // + // libc provides bindings for the XSI-compliant version, which is + // preferred for portable applications. + // + // We skip the test here since here _GNU_SOURCE is defined, and + // test the XSI version below. + "strerror_r" => true, + + // FIXME: Our API is unsound. The Rust API allows aliasing + // pointers, but the C API requires pointers not to alias. + // We should probably be at least using `&`/`&mut` here, see: + // https://github.com/gnzlbg/ctest/issues/68 + "lio_listio" if musl => true, + + // Needs glibc 2.34 or later. + "posix_spawn_file_actions_addclosefrom_np" if gnu && sparc64 => true, + // Needs glibc 2.35 or later. + "posix_spawn_file_actions_addtcsetpgrp_np" if gnu && sparc64 => true, + + // FIXME: Deprecated since glibc 2.30. Remove fn once upstream does. + "sysctl" if gnu => true, + + // FIXME: It now takes c_void instead of timezone since glibc 2.31. + "gettimeofday" if gnu => true, + + // These are all implemented as static inline functions in uclibc, so + // they cannot be linked against. + // If implementations are required, they might need to be implemented + // in this crate. + "posix_spawnattr_init" if uclibc => true, + "posix_spawnattr_destroy" if uclibc => true, + "posix_spawnattr_getsigdefault" if uclibc => true, + "posix_spawnattr_setsigdefault" if uclibc => true, + "posix_spawnattr_getsigmask" if uclibc => true, + "posix_spawnattr_setsigmask" if uclibc => true, + "posix_spawnattr_getflags" if uclibc => true, + "posix_spawnattr_setflags" if uclibc => true, + "posix_spawnattr_getpgroup" if uclibc => true, + "posix_spawnattr_setpgroup" if uclibc => true, + "posix_spawnattr_getschedpolicy" if uclibc => true, + "posix_spawnattr_setschedpolicy" if uclibc => true, + "posix_spawnattr_getschedparam" if uclibc => true, + "posix_spawnattr_setschedparam" if uclibc => true, + "posix_spawn_file_actions_init" if uclibc => true, + "posix_spawn_file_actions_destroy" if uclibc => true, + + // uclibc defines the flags type as a uint, but dependent crates + // assume it's a int instead. + "getnameinfo" if uclibc => true, + + // FIXME: This needs musl 1.2.2 or later. + "gettid" if musl => true, + + // Needs glibc 2.33 or later. + "mallinfo2" => true, + + "reallocarray" if musl => true, + + // Not defined in uclibc as of 1.0.34 + "gettid" if uclibc => true, + + // Needs musl 1.2.3 or later. + "pthread_getname_np" if musl => true, + + // pthread_sigqueue uses sigval, which was initially declared + // as a struct but should be defined as a union. However due + // to the issues described here: https://github.com/rust-lang/libc/issues/2816 + // it can't be changed from struct. + "pthread_sigqueue" => true, + + // There are two versions of basename(3) on Linux with glibc, see + // + // https://man7.org/linux/man-pages/man3/basename.3.html + // + // If libgen.h is included, then the POSIX version will be available; + // If _GNU_SOURCE is defined and string.h is included, then the GNU one + // will be used. + // + // libc exposes both of them, providing a prefix to differentiate between + // them. + // + // Because the name with prefix is not a valid symbol in C, we have to + // skip the tests. + "posix_basename" if gnu => true, + "gnu_basename" if gnu => true, + + // FIXME: function pointers changed since Ubuntu 23.10 + "strtol" | "strtoll" | "strtoul" | "strtoull" | "fscanf" | "scanf" | "sscanf" => true, + + // Added in musl 1.2.5 + "preadv2" | "pwritev2" if musl => true, + + _ => false, + } + }); + + cfg.skip_field_type(move |struct_, field| { + // This is a weird union, don't check the type. + (struct_ == "ifaddrs" && field == "ifa_ifu") || + // sighandler_t type is super weird + (struct_ == "sigaction" && field == "sa_sigaction") || + // __timeval type is a patch which doesn't exist in glibc + (struct_ == "utmpx" && field == "ut_tv") || + // sigval is actually a union, but we pretend it's a struct + (struct_ == "sigevent" && field == "sigev_value") || + // this one is an anonymous union + (struct_ == "ff_effect" && field == "u") || + // `__exit_status` type is a patch which is absent in musl + (struct_ == "utmpx" && field == "ut_exit" && musl) || + // `can_addr` is an anonymous union + (struct_ == "sockaddr_can" && field == "can_addr") + }); + + cfg.volatile_item(|i| { + use ctest::VolatileItemKind::*; + match i { + // aio_buf is a volatile void** but since we cannot express that in + // Rust types, we have to explicitly tell the checker about it here: + StructField(ref n, ref f) if n == "aiocb" && f == "aio_buf" => true, + _ => false, + } + }); + + cfg.skip_field(move |struct_, field| { + // this is actually a union on linux, so we can't represent it well and + // just insert some padding. + (struct_ == "siginfo_t" && field == "_pad") || + // musl names this __dummy1 but it's still there + (musl && struct_ == "glob_t" && field == "gl_flags") || + // musl seems to define this as an *anonymous* bitfield + (musl && struct_ == "statvfs" && field == "__f_unused") || + // sigev_notify_thread_id is actually part of a sigev_un union + (struct_ == "sigevent" && field == "sigev_notify_thread_id") || + // signalfd had SIGSYS fields added in Linux 4.18, but no libc release + // has them yet. + (struct_ == "signalfd_siginfo" && (field == "ssi_addr_lsb" || + field == "_pad2" || + field == "ssi_syscall" || + field == "ssi_call_addr" || + field == "ssi_arch")) || + // FIXME: After musl 1.1.24, it have only one field `sched_priority`, + // while other fields become reserved. + (struct_ == "sched_param" && [ + "sched_ss_low_priority", + "sched_ss_repl_period", + "sched_ss_init_budget", + "sched_ss_max_repl", + ].contains(&field) && musl) || + // FIXME: After musl 1.1.24, the type becomes `int` instead of `unsigned short`. + (struct_ == "ipc_perm" && field == "__seq" && aarch64_musl) || + // glibc uses unnamed fields here and Rust doesn't support that yet + (struct_ == "timex" && field.starts_with("__unused")) || + // FIXME: It now takes mode_t since glibc 2.31 on some targets. + (struct_ == "ipc_perm" && field == "mode" + && ((x86_64 || i686 || arm || riscv64) && gnu || x86_64_gnux32) + ) || + // the `u` field is in fact an anonymous union + (gnu && struct_ == "ptrace_syscall_info" && (field == "u" || field == "pad")) || + // the vregs field is a `__uint128_t` C's type. + (struct_ == "user_fpsimd_struct" && field == "vregs") || + // Linux >= 5.11 tweaked the `svm_zero` field of the `sockaddr_vm` struct. + // https://github.com/torvalds/linux/commit/dc8eeef73b63ed8988224ba6b5ed19a615163a7f + (struct_ == "sockaddr_vm" && field == "svm_zero") || + // the `ifr_ifru` field is an anonymous union + (struct_ == "ifreq" && field == "ifr_ifru") || + // the `ifc_ifcu` field is an anonymous union + (struct_ == "ifconf" && field == "ifc_ifcu") || + // glibc uses a single array `uregs` instead of individual fields. + (struct_ == "user_regs" && arm) + }); + + cfg.skip_roundtrip(move |s| match s { + // FIXME: + "mcontext_t" if s390x => true, + // FIXME: This is actually a union. + "fpreg_t" if s390x => true, + + // The test doesn't work on some env: + "ipv6_mreq" + | "ip_mreq_source" + | "sockaddr_in6" + | "sockaddr_ll" + | "in_pktinfo" + | "arpreq" + | "arpreq_old" + | "sockaddr_un" + | "ff_constant_effect" + | "ff_ramp_effect" + | "ff_condition_effect" + | "Elf32_Ehdr" + | "Elf32_Chdr" + | "ucred" + | "in6_pktinfo" + | "sockaddr_nl" + | "termios" + | "nlmsgerr" + if sparc64 && gnu => + { + true + } + + // The `inotify_event` and `cmsghdr` types contain Flexible Array Member fields (the + // `name` and `data` fields respectively) which have unspecified calling convention. + // The roundtripping tests deliberately pass the structs by value to check "by value" + // layout consistency, but this would be UB for the these types. + "inotify_event" => true, + "cmsghdr" => true, + + // FIXME: the call ABI of max_align_t is incorrect on these platforms: + "max_align_t" if i686 || ppc64 => true, + + _ => false, + }); + + cfg.generate("../src/lib.rs", "main.rs"); + + test_linux_like_apis(target); +} + +// Wasm32 WALI tests +// Skips the following subcomponents: +// * Linux headers +// * Architecture-specific features +// * Dynamic linking (until Wasm gains support) +// Currently only supports the 'musl' environment +fn test_wali(target: &str) { + assert!(target.contains("linux")); + + // target_env + let gnu = target.contains("gnu"); + let musl = target.contains("musl") || target.contains("ohos"); + let uclibc = target.contains("uclibc"); + + match (gnu, musl, uclibc) { + (true, false, false) => (), + (false, true, false) => (), + (false, false, true) => (), + (_, _, _) => panic!( + "linux target lib is gnu: {}, musl: {}, uclibc: {}", + gnu, musl, uclibc + ), + } + + let mut cfg = ctest_cfg(); + cfg.define("_GNU_SOURCE", None); + // This macro re-defines fscanf,scanf,sscanf to link to the symbols that are + // deprecated since glibc >= 2.29. This allows Rust binaries to link against + // glibc versions older than 2.29. + cfg.define("__GLIBC_USE_DEPRECATED_SCANF", None); + + headers! { cfg: + "ctype.h", + "dirent.h", + "dlfcn.h", + "elf.h", + "fcntl.h", + "getopt.h", + "glob.h", + "grp.h", + "iconv.h", + "ifaddrs.h", + "langinfo.h", + "libgen.h", + "limits.h", + "link.h", + "linux/sysctl.h", + "locale.h", + "malloc.h", + "mntent.h", + "mqueue.h", + "net/ethernet.h", + "net/if.h", + "net/if_arp.h", + "net/route.h", + "netdb.h", + "netinet/in.h", + "netinet/ip.h", + "netinet/tcp.h", + "netinet/udp.h", + "netpacket/packet.h", + "poll.h", + "pthread.h", + "pty.h", + "pwd.h", + "regex.h", + "resolv.h", + "sched.h", + "semaphore.h", + "shadow.h", + "signal.h", + "spawn.h", + "stddef.h", + "stdint.h", + "stdio.h", + "stdlib.h", + "string.h", + "sys/epoll.h", + "sys/eventfd.h", + "sys/file.h", + "sys/fsuid.h", + "sys/inotify.h", + "sys/ioctl.h", + "sys/ipc.h", + "sys/mman.h", + "sys/mount.h", + "sys/msg.h", + "sys/personality.h", + "sys/prctl.h", + "sys/ptrace.h", + "sys/quota.h", + "sys/random.h", + "sys/reboot.h", + "sys/resource.h", + "sys/sem.h", + "sys/sendfile.h", + "sys/shm.h", + "sys/signalfd.h", + "sys/socket.h", + "sys/stat.h", + "sys/statvfs.h", + "sys/swap.h", + "sys/syscall.h", + "sys/time.h", + "sys/timerfd.h", + "sys/times.h", + "sys/timex.h", + "sys/types.h", + "sys/uio.h", + "sys/un.h", + "sys/user.h", + "sys/utsname.h", + "sys/vfs.h", + "sys/wait.h", + "syslog.h", + "termios.h", + "time.h", + "ucontext.h", + "unistd.h", + "utime.h", + "utmp.h", + "utmpx.h", + "wchar.h", + "errno.h", + } + + // note: aio.h must be included before sys/mount.h + headers! { + cfg: + "sys/xattr.h", + "sys/sysinfo.h", + // AIO is not supported by uclibc: + [!uclibc]: "aio.h", + } + + cfg.type_name(move |ty, is_struct, is_union| { + match ty { + // Just pass all these through, no need for a "struct" prefix + "FILE" | "fd_set" | "DIR" => ty.to_string(), + + "Ioctl" if gnu => "unsigned long".to_string(), + "Ioctl" => "int".to_string(), + + // LFS64 types have been removed in musl 1.2.4+ + "off64_t" if musl => "off_t".to_string(), + + // typedefs don't need any keywords + t if t.ends_with("_t") => t.to_string(), + // put `struct` in front of all structs:. + t if is_struct => format!("struct {}", t), + // put `union` in front of all unions: + t if is_union => format!("union {}", t), + + t => t.to_string(), + } + }); + + cfg.field_name(move |struct_, field| { + match field { + // Our stat *_nsec fields normally don't actually exist but are part + // of a timeval struct + s if s.ends_with("_nsec") && struct_.starts_with("stat") => { + s.replace("e_nsec", ".tv_nsec") + } + // FIXME: epoll_event.data is actually a union in C, but in Rust + // it is only a u64 because we only expose one field + // http://man7.org/linux/man-pages/man2/epoll_wait.2.html + "u64" if struct_ == "epoll_event" => "data.u64".to_string(), + // The following structs have a field called `type` in C, + // but `type` is a Rust keyword, so these fields are translated + // to `type_` in Rust. + "type_" + if struct_ == "input_event" + || struct_ == "input_mask" + || struct_ == "ff_effect" => + { + "type".to_string() + } + + s => s.to_string(), + } + }); + + cfg.skip_type(move |ty| { + match ty { + // FIXME: `sighandler_t` type is incorrect, see: + // https://github.com/rust-lang/libc/issues/1359 + "sighandler_t" => true, + + // These cannot be tested when "resolv.h" is included and are tested + // in the `linux_elf.rs` file. + "Elf64_Phdr" | "Elf32_Phdr" => true, + + // This type is private on Linux. It is implemented as a C `enum` + // (`c_uint`) and this clashes with the type of the `rlimit` APIs + // which expect a `c_int` even though both are ABI compatible. + "__rlimit_resource_t" => true, + // on Linux, this is a volatile int + "pthread_spinlock_t" => true, + + // For internal use only, to define architecture specific ioctl constants with a libc + // specific type. + "Ioctl" => true, + + // FIXME: requires >= 5.4.1 kernel headers + "pgn_t" if musl => true, + "priority_t" if musl => true, + "name_t" if musl => true, + + t => { + if musl { + // LFS64 types have been removed in musl 1.2.4+ + t.ends_with("64") || t.ends_with("64_t") + } else { + false + } + } + } + }); + + cfg.skip_struct(move |ty| { + if ty.starts_with("__c_anonymous_") { + return true; + } + // FIXME: musl CI has old headers + if musl && ty.starts_with("uinput_") { + return true; + } + if musl && ty == "seccomp_notif" { + return true; + } + if musl && ty == "seccomp_notif_addfd" { + return true; + } + if musl && ty == "seccomp_notif_resp" { + return true; + } + if musl && ty == "seccomp_notif_sizes" { + return true; + } + + // LFS64 types have been removed in musl 1.2.4+ + if musl && (ty.ends_with("64") || ty.ends_with("64_t")) { + return true; + } + match ty { + // These cannot be tested when "resolv.h" is included and are tested + // in the `linux_elf.rs` file. + "Elf64_Phdr" | "Elf32_Phdr" => true, + + // On Linux, the type of `ut_tv` field of `struct utmpx` + // can be an anonymous struct, so an extra struct, + // which is absent in glibc, has to be defined. + "__timeval" => true, + + // FIXME: This is actually a union, not a struct + "sigval" => true, + + // This type is tested in the `linux_termios.rs` file since there + // are header conflicts when including them with all the other + // structs. + "termios2" => true, + + // FIXME: remove once we set minimum supported glibc version. + // ucontext_t added a new field as of glibc 2.28; our struct definition is + // conservative and omits the field, but that means the size doesn't match for newer + // glibcs (see https://github.com/rust-lang/libc/issues/1410) + "ucontext_t" if gnu => true, + + // FIXME: Somehow we cannot include headers correctly in glibc 2.30. + // So let's ignore for now and re-visit later. + // Probably related: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91085 + "statx" => true, + "statx_timestamp" => true, + + // On Linux, the type of `ut_exit` field of struct `utmpx` + // can be an anonymous struct, so an extra struct, + // which is absent in musl, has to be defined. + "__exit_status" if musl => true, + + // clone_args might differ b/w libc versions + "clone_args" => true, + + // Might differ between kernel versions + "open_how" => true, + + "sctp_initmsg" | "sctp_sndrcvinfo" | "sctp_sndinfo" | "sctp_rcvinfo" + | "sctp_nxtinfo" | "sctp_prinfo" | "sctp_authinfo" => true, + + // FIXME: requires >= 6.1 kernel headers + "canxl_frame" => true, + + // FIXME: The size of `iv` has been changed since Linux v6.0 + // https://github.com/torvalds/linux/commit/94dfc73e7cf4a31da66b8843f0b9283ddd6b8381 + "af_alg_iv" => true, + + // FIXME: Requires >= 5.1 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "tls12_crypto_info_aes_gcm_256" if musl => true, + + // FIXME: Requires >= 5.11 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "tls12_crypto_info_chacha20_poly1305" if musl => true, + + // FIXME: Requires >= 5.3 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "xdp_options" if musl => true, + + // FIXME: Requires >= 5.4 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "xdp_umem_reg" | "xdp_ring_offset" | "xdp_mmap_offsets" if musl => true, + + // FIXME: Requires >= 5.9 kernel headers. + // Everything that uses install-musl.sh has 4.19 kernel headers. + "xdp_statistics" if musl => true, + + // A new field was added in kernel 5.4, this is the old version for backwards compatibility. + // https://github.com/torvalds/linux/commit/77cd0d7b3f257fd0e3096b4fdcff1a7d38e99e10 + "xdp_ring_offset_v1" | "xdp_mmap_offsets_v1" => true, + + // Multiple new fields were added in kernel 5.9, this is the old version for backwards compatibility. + // https://github.com/torvalds/linux/commit/77cd0d7b3f257fd0e3096b4fdcff1a7d38e99e10 + "xdp_statistics_v1" => true, + + // A new field was added in kernel 5.4, this is the old version for backwards compatibility. + // https://github.com/torvalds/linux/commit/c05cd3645814724bdeb32a2b4d953b12bdea5f8c + "xdp_umem_reg_v1" => true, + + // Is defined in `` but if this file is included at the same time + // as ``, the `struct sched_param` is defined twice, causing the compilation to + // fail. The problem doesn't seem to be present in more recent versions of the linux + // kernel so we can drop this and test the type once this new version is used in CI. + "sched_attr" => true, + + _ => false, + } + }); + + cfg.skip_const(move |name| { + if !gnu { + // Skip definitions from the kernel on non-glibc Linux targets. + // They're libc-independent, so we only need to check them on one + // libc. We don't want to break CI if musl or another libc doesn't + // have the definitions yet. (We do still want to check them on + // every glibc target, though, as some of them can vary by + // architecture.) + // + // This is not an exhaustive list of kernel constants, just a list + // of prefixes of all those that have appeared here or that get + // updated regularly and seem likely to cause breakage. + if name.starts_with("AF_") + || name.starts_with("ARPHRD_") + || name.starts_with("EPOLL") + || name.starts_with("F_") + || name.starts_with("FALLOC_FL_") + || name.starts_with("IFLA_") + || name.starts_with("KEXEC_") + || name.starts_with("MS_") + || name.starts_with("MSG_") + || name.starts_with("OPEN_TREE_") + || name.starts_with("P_") + || name.starts_with("PF_") + || name.starts_with("RLIMIT_") + || name.starts_with("RTEXT_FILTER_") + || name.starts_with("SOL_") + || name.starts_with("STATX_") + || name.starts_with("SW_") + || name.starts_with("SYS_") + || name.starts_with("TCP_") + || name.starts_with("UINPUT_") + || name.starts_with("VMADDR_") + { + return true; + } + } + if musl { + // FIXME: Requires >= 5.0 kernel headers + if name == "SECCOMP_GET_NOTIF_SIZES" + || name == "SECCOMP_FILTER_FLAG_NEW_LISTENER" + || name == "SECCOMP_FILTER_FLAG_TSYNC_ESRCH" + || name == "SECCOMP_USER_NOTIF_FLAG_CONTINUE" // requires >= 5.5 + || name == "SECCOMP_ADDFD_FLAG_SETFD" // requires >= 5.9 + || name == "SECCOMP_ADDFD_FLAG_SEND" // requires >= 5.9 + || name == "SECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECV" // requires >= 5.19 + { + return true; + } + // FIXME: Requires >= 5.4.1 kernel headers + if name.starts_with("J1939") + || name.starts_with("RTEXT_FILTER_") + || name.starts_with("SO_J1939") + || name.starts_with("SCM_J1939") + { + return true; + } + // FIXME: Requires >= 5.10 kernel headers + if name.starts_with("MEMBARRIER_CMD_REGISTER") + || name.starts_with("MEMBARRIER_CMD_PRIVATE") + { + return true; + } + // LFS64 types have been removed in musl 1.2.4+ + if name.starts_with("RLIM64") { + return true; + } + // CI fails because musl targets use Linux v4 kernel + if name.starts_with("NI_IDN") { + return true; + } + // FIXME: Requires >= 6.3 kernel headers + if name == "MFD_NOEXEC_SEAL" || name == "MFD_EXEC" { + return true; + } + } + match name { + // These constants are not available if gnu headers have been included + // and can therefore not be tested here + // + // The IPV6 constants are tested in the `linux_ipv6.rs` tests: + | "IPV6_FLOWINFO" + | "IPV6_FLOWLABEL_MGR" + | "IPV6_FLOWINFO_SEND" + | "IPV6_FLOWINFO_FLOWLABEL" + | "IPV6_FLOWINFO_PRIORITY" + // The F_ fnctl constants are tested in the `linux_fnctl.rs` tests: + | "F_CANCELLK" + | "F_ADD_SEALS" + | "F_GET_SEALS" + | "F_SEAL_SEAL" + | "F_SEAL_SHRINK" + | "F_SEAL_GROW" + | "F_SEAL_WRITE" => true, + // The `ARPHRD_CAN` is tested in the `linux_if_arp.rs` tests + // because including `linux/if_arp.h` causes some conflicts: + "ARPHRD_CAN" => true, + + // FIXME: deprecated: not available in any header + // See: https://github.com/rust-lang/libc/issues/1356 + "ENOATTR" => true, + + // FIXME: SIGUNUSED was removed in glibc 2.26 + // Users should use SIGSYS instead. + "SIGUNUSED" => true, + + // FIXME: conflicts with glibc headers and is tested in + // `linux_termios.rs` below: + | "BOTHER" + | "IBSHIFT" + | "TCGETS2" + | "TCSETS2" + | "TCSETSW2" + | "TCSETSF2" => true, + + // FIXME: on musl the pthread types are defined a little differently + // - these constants are used by the glibc implementation. + n if musl && n.contains("__SIZEOF_PTHREAD") => true, + + // FIXME: It was extended to 4096 since glibc 2.31 (Linux 5.4). + // We should do so after a while. + "SOMAXCONN" if gnu => true, + + // deprecated: not available from Linux kernel 5.6: + "VMADDR_CID_RESERVED" => true, + + // IPPROTO_MAX was increased in 5.6 for IPPROTO_MPTCP: + | "IPPROTO_MAX" + | "IPPROTO_ETHERNET" + | "IPPROTO_MPTCP" => true, + + // FIXME: Not defined in WALI + "SYS_clone3" => true, + + // FIXME: Not defined in WALI. + "SYS_memfd_secret" => true, + + // FIXME: Added in Linux 5.16 + // https://github.com/torvalds/linux/commit/039c0ec9bb77446d7ada7f55f90af9299b28ca49 + "SYS_futex_waitv" => true, + + // FIXME: Added in Linux 5.17 + // https://github.com/torvalds/linux/commit/c6018b4b254971863bd0ad36bb5e7d0fa0f0ddb0 + "SYS_set_mempolicy_home_node" => true, + + // FIXME: Added in Linux 5.18 + // https://github.com/torvalds/linux/commit/8b5413647262dda8d8d0e07e14ea1de9ac7cf0b2 + "NFQA_PRIORITY" => true, + + // FIXME: requires more recent kernel headers on CI + | "UINPUT_VERSION" + | "SW_MAX" + | "SW_CNT" + => true, + + // FIXME: requires more recent kernel headers on CI + | "MFD_EXEC" + | "MFD_NOEXEC_SEAL" + | "SECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECV" + => true, // FIXME: Not currently available in headers on ARM and musl. - "NETLINK_GET_STRICT_CHK" if arm || musl => true, + "NETLINK_GET_STRICT_CHK" if musl => true, // kernel constants not available in uclibc 1.0.34 | "EXTPROC" @@ -4020,7 +5030,7 @@ fn test_linux(target: &str) { "MREMAP_DONTUNMAP" if musl => true, // FIXME: requires Linux >= v5.8 - "IF_LINK_MODE_TESTING" if musl || sparc64 => true, + "IF_LINK_MODE_TESTING" if musl => true, // FIXME: Requires more recent kernel headers (5.9 / 5.11): | "CLOSE_RANGE_UNSHARE" @@ -4117,7 +5127,7 @@ fn test_linux(target: &str) { | "TLS_CIPHER_AES_GCM_256_SALT_SIZE" | "TLS_CIPHER_AES_GCM_256_TAG_SIZE" | "TLS_CIPHER_AES_GCM_256_REC_SEQ_SIZE" - if (aarch64 || arm || i686 || s390x || x86_64) && musl => + if musl => { true } @@ -4130,7 +5140,7 @@ fn test_linux(target: &str) { | "TLS_CIPHER_CHACHA20_POLY1305_SALT_SIZE" | "TLS_CIPHER_CHACHA20_POLY1305_TAG_SIZE" | "TLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZE" - if (aarch64 || arm || i686 || s390x || x86_64) && musl => + if musl => { true } @@ -4233,9 +5243,9 @@ fn test_linux(target: &str) { "lio_listio" if musl => true, // Needs glibc 2.34 or later. - "posix_spawn_file_actions_addclosefrom_np" if gnu && sparc64 => true, + "posix_spawn_file_actions_addclosefrom_np" if gnu => true, // Needs glibc 2.35 or later. - "posix_spawn_file_actions_addtcsetpgrp_np" if gnu && sparc64 => true, + "posix_spawn_file_actions_addtcsetpgrp_np" if gnu => true, // FIXME: Deprecated since glibc 2.30. Remove fn once upstream does. "sysctl" if gnu => true, @@ -4366,14 +5376,8 @@ fn test_linux(target: &str) { "sched_ss_init_budget", "sched_ss_max_repl", ].contains(&field) && musl) || - // FIXME: After musl 1.1.24, the type becomes `int` instead of `unsigned short`. - (struct_ == "ipc_perm" && field == "__seq" && aarch64_musl) || // glibc uses unnamed fields here and Rust doesn't support that yet (struct_ == "timex" && field.starts_with("__unused")) || - // FIXME: It now takes mode_t since glibc 2.31 on some targets. - (struct_ == "ipc_perm" && field == "mode" - && ((x86_64 || i686 || arm || riscv64) && gnu || x86_64_gnux32) - ) || // the `u` field is in fact an anonymous union (gnu && struct_ == "ptrace_syscall_info" && (field == "u" || field == "pad")) || // the vregs field is a `__uint128_t` C's type. @@ -4384,16 +5388,14 @@ fn test_linux(target: &str) { // the `ifr_ifru` field is an anonymous union (struct_ == "ifreq" && field == "ifr_ifru") || // the `ifc_ifcu` field is an anonymous union - (struct_ == "ifconf" && field == "ifc_ifcu") || - // glibc uses a single array `uregs` instead of individual fields. - (struct_ == "user_regs" && arm) + (struct_ == "ifconf" && field == "ifc_ifcu") }); cfg.skip_roundtrip(move |s| match s { // FIXME: - "mcontext_t" if s390x => true, + "mcontext_t" => true, // FIXME: This is actually a union. - "fpreg_t" if s390x => true, + "fpreg_t" => true, // The test doesn't work on some env: "ipv6_mreq" @@ -4414,7 +5416,7 @@ fn test_linux(target: &str) { | "sockaddr_nl" | "termios" | "nlmsgerr" - if sparc64 && gnu => + if gnu => { true } @@ -4426,9 +5428,6 @@ fn test_linux(target: &str) { "inotify_event" => true, "cmsghdr" => true, - // FIXME: the call ABI of max_align_t is incorrect on these platforms: - "max_align_t" if i686 || ppc64 => true, - _ => false, }); @@ -4443,6 +5442,7 @@ fn test_linux_like_apis(target: &str) { let gnu = target.contains("gnu"); let musl = target.contains("musl") || target.contains("ohos"); let linux = target.contains("linux"); + let wali = target.contains("linux") && target.contains("wasm32"); let emscripten = target.contains("emscripten"); let android = target.contains("android"); assert!(linux || android || emscripten); @@ -4495,24 +5495,26 @@ fn test_linux_like_apis(target: &str) { if linux || android { // test termios let mut cfg = ctest_cfg(); - cfg.header("asm/termbits.h"); - cfg.header("linux/termios.h"); - cfg.skip_type(|_| true) - .skip_static(|_| true) - .skip_fn(|_| true) - .skip_const(|c| match c { - "BOTHER" | "IBSHIFT" => false, - "TCGETS2" | "TCSETS2" | "TCSETSW2" | "TCSETSF2" => false, - _ => true, - }) - .skip_struct(|s| s != "termios2") - .type_name(move |ty, is_struct, is_union| match ty { - "Ioctl" if gnu => "unsigned long".to_string(), - "Ioctl" => "int".to_string(), - t if is_struct => format!("struct {}", t), - t if is_union => format!("union {}", t), - t => t.to_string(), - }); + if !wali { + cfg.header("asm/termbits.h"); + cfg.header("linux/termios.h"); + cfg.skip_type(|_| true) + .skip_static(|_| true) + .skip_fn(|_| true) + .skip_const(|c| match c { + "BOTHER" | "IBSHIFT" => false, + "TCGETS2" | "TCSETS2" | "TCSETSW2" | "TCSETSF2" => false, + _ => true, + }) + .skip_struct(|s| s != "termios2") + .type_name(move |ty, is_struct, is_union| match ty { + "Ioctl" if gnu => "unsigned long".to_string(), + "Ioctl" => "int".to_string(), + t if is_struct => format!("struct {}", t), + t if is_union => format!("union {}", t), + t => t.to_string(), + }); + } cfg.generate("../src/lib.rs", "linux_termios.rs"); } @@ -4550,34 +5552,38 @@ fn test_linux_like_apis(target: &str) { // "resolve.h" defines a `p_type` macro that expands to `__p_type` // making the tests for these fails when both are included. let mut cfg = ctest_cfg(); - cfg.header("elf.h"); - cfg.skip_fn(|_| true) - .skip_static(|_| true) - .skip_const(|_| true) - .type_name(move |ty, _is_struct, _is_union| ty.to_string()) - .skip_struct(move |ty| match ty { - "Elf64_Phdr" | "Elf32_Phdr" => false, - _ => true, - }) - .skip_type(move |ty| match ty { - "Elf64_Phdr" | "Elf32_Phdr" => false, - _ => true, - }); + if !wali { + cfg.header("elf.h"); + cfg.skip_fn(|_| true) + .skip_static(|_| true) + .skip_const(|_| true) + .type_name(move |ty, _is_struct, _is_union| ty.to_string()) + .skip_struct(move |ty| match ty { + "Elf64_Phdr" | "Elf32_Phdr" => false, + _ => true, + }) + .skip_type(move |ty| match ty { + "Elf64_Phdr" | "Elf32_Phdr" => false, + _ => true, + }); + } cfg.generate("../src/lib.rs", "linux_elf.rs"); } if linux || android { // Test `ARPHRD_CAN`. let mut cfg = ctest_cfg(); - cfg.header("linux/if_arp.h"); - cfg.skip_fn(|_| true) - .skip_static(|_| true) - .skip_const(move |name| match name { - "ARPHRD_CAN" => false, - _ => true, - }) - .skip_struct(|_| true) - .skip_type(|_| true); + if !wali { + cfg.header("linux/if_arp.h"); + cfg.skip_fn(|_| true) + .skip_static(|_| true) + .skip_const(move |name| match name { + "ARPHRD_CAN" => false, + _ => true, + }) + .skip_struct(|_| true) + .skip_type(|_| true); + } cfg.generate("../src/lib.rs", "linux_if_arp.rs"); } } diff --git a/src/lib.rs b/src/lib.rs index 764d8e4cd096a..b7e289a493b10 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,6 +1,8 @@ //! libc - Raw FFI bindings to platforms' system libraries #![crate_name = "libc"] #![crate_type = "rlib"] +#![feature(c_variadic)] +#![feature(concat_idents)] #![allow( renamed_and_removed_lints, // Keep this order. unknown_lints, // Keep this order. diff --git a/src/unix/linux_like/linux/arch/generic/mod.rs b/src/unix/linux_like/linux/arch/generic/mod.rs index 2f437e16db26a..4e9c70d594c74 100644 --- a/src/unix/linux_like/linux/arch/generic/mod.rs +++ b/src/unix/linux_like/linux/arch/generic/mod.rs @@ -231,7 +231,8 @@ cfg_if! { target_arch = "riscv64", target_arch = "aarch64", target_arch = "s390x", - target_arch = "loongarch64"))] { + target_arch = "loongarch64", + target_arch = "wasm32"))] { pub const FS_IOC_GETFLAGS: ::Ioctl = 0x80086601; pub const FS_IOC_SETFLAGS: ::Ioctl = 0x40086602; pub const FS_IOC_GETVERSION: ::Ioctl = 0x80087601; diff --git a/src/unix/linux_like/linux/mod.rs b/src/unix/linux_like/linux/mod.rs index 164a03ea42f1d..b8b1bfb0646b2 100644 --- a/src/unix/linux_like/linux/mod.rs +++ b/src/unix/linux_like/linux/mod.rs @@ -5201,7 +5201,7 @@ extern "C" { pub fn vhangup() -> ::c_int; pub fn sync(); pub fn syncfs(fd: ::c_int) -> ::c_int; - pub fn syscall(num: ::c_long, ...) -> ::c_long; + pub fn sched_getaffinity(pid: ::pid_t, cpusetsize: ::size_t, cpuset: *mut cpu_set_t) -> ::c_int; pub fn sched_setaffinity( @@ -5622,6 +5622,22 @@ extern "C" { ) -> ::ssize_t; } +// Syscall libc stub for non Wasm32-WALI targets +// In wasm32-linux, all syscalls are name-bound and typed. +// The 'syscall' implementation from C library is avoided since +// higher level libraries do not explicitly typecast arguments to +// 64-bit register sizes, which is expected of C variadic arguments. +// To overcome this, a wrapper 'syscall' method is implemented, +// which binds the syscall types statically at compile time +// and binds their numbers at runtime +cfg_if!( + if #[cfg(not(target_arch = "wasm32"))] { + extern "C" { + pub fn syscall(num: ::c_long, ...) -> ::c_long; + } + } +); + // LFS64 extensions // // * musl has 64-bit versions only so aliases the LFS64 symbols to the standard ones diff --git a/src/unix/linux_like/linux/musl/b64/mod.rs b/src/unix/linux_like/linux/musl/b64/mod.rs index d59343064c52e..20a8a3162b3b0 100644 --- a/src/unix/linux_like/linux/musl/b64/mod.rs +++ b/src/unix/linux_like/linux/musl/b64/mod.rs @@ -160,6 +160,9 @@ cfg_if! { } else if #[cfg(any(target_arch = "loongarch64"))] { mod loongarch64; pub use self::loongarch64::*; + } else if #[cfg(any(target_arch = "wasm32"))] { + mod wasm32; + pub use self::wasm32::*; } else { // Unknown target_arch } diff --git a/src/unix/linux_like/linux/musl/b64/wasm32/mod.rs b/src/unix/linux_like/linux/musl/b64/wasm32/mod.rs new file mode 100644 index 0000000000000..d6e0982ca4fa5 --- /dev/null +++ b/src/unix/linux_like/linux/musl/b64/wasm32/mod.rs @@ -0,0 +1,919 @@ +/* Wasm32 WALI target + * This is a moving target -- commented defintions may be included in + * as WALI develops */ +pub type c_char = i8; +pub type wchar_t = i32; +pub type nlink_t = u64; +pub type blksize_t = ::c_long; +pub type __u64 = ::c_ulonglong; +pub type __s64 = ::c_longlong; +pub type greg_t = i64; + +s! { + pub struct stat { + pub st_dev: ::dev_t, + pub st_ino: ::ino_t, + pub st_nlink: ::nlink_t, + pub st_mode: ::mode_t, + pub st_uid: ::uid_t, + pub st_gid: ::gid_t, + __pad0: ::c_int, + pub st_rdev: ::dev_t, + pub st_size: ::off_t, + pub st_blksize: ::blksize_t, + pub st_blocks: ::blkcnt_t, + pub st_atime: ::time_t, + pub st_atime_nsec: ::c_long, + pub st_mtime: ::time_t, + pub st_mtime_nsec: ::c_long, + pub st_ctime: ::time_t, + pub st_ctime_nsec: ::c_long, + __unused: [::c_long; 3], + } + + pub struct stat64 { + pub st_dev: ::dev_t, + pub st_ino: ::ino64_t, + pub st_nlink: ::nlink_t, + pub st_mode: ::mode_t, + pub st_uid: ::uid_t, + pub st_gid: ::gid_t, + __pad0: ::c_int, + pub st_rdev: ::dev_t, + pub st_size: ::off_t, + pub st_blksize: ::blksize_t, + pub st_blocks: ::blkcnt64_t, + pub st_atime: ::time_t, + pub st_atime_nsec: ::c_long, + pub st_mtime: ::time_t, + pub st_mtime_nsec: ::c_long, + pub st_ctime: ::time_t, + pub st_ctime_nsec: ::c_long, + __reserved: [::c_long; 3], + } + + //pub struct user_regs_struct { + // pub r15: ::c_ulong, + // pub r14: ::c_ulong, + // pub r13: ::c_ulong, + // pub r12: ::c_ulong, + // pub rbp: ::c_ulong, + // pub rbx: ::c_ulong, + // pub r11: ::c_ulong, + // pub r10: ::c_ulong, + // pub r9: ::c_ulong, + // pub r8: ::c_ulong, + // pub rax: ::c_ulong, + // pub rcx: ::c_ulong, + // pub rdx: ::c_ulong, + // pub rsi: ::c_ulong, + // pub rdi: ::c_ulong, + // pub orig_rax: ::c_ulong, + // pub rip: ::c_ulong, + // pub cs: ::c_ulong, + // pub eflags: ::c_ulong, + // pub rsp: ::c_ulong, + // pub ss: ::c_ulong, + // pub fs_base: ::c_ulong, + // pub gs_base: ::c_ulong, + // pub ds: ::c_ulong, + // pub es: ::c_ulong, + // pub fs: ::c_ulong, + // pub gs: ::c_ulong, + //} + + //pub struct user { + // pub regs: user_regs_struct, + // pub u_fpvalid: ::c_int, + // pub i387: user_fpregs_struct, + // pub u_tsize: ::c_ulong, + // pub u_dsize: ::c_ulong, + // pub u_ssize: ::c_ulong, + // pub start_code: ::c_ulong, + // pub start_stack: ::c_ulong, + // pub signal: ::c_long, + // __reserved: ::c_int, + // #[cfg(target_pointer_width = "32")] + // __pad1: u32, + // pub u_ar0: *mut user_regs_struct, + // #[cfg(target_pointer_width = "32")] + // __pad2: u32, + // pub u_fpstate: *mut user_fpregs_struct, + // pub magic: ::c_ulong, + // pub u_comm: [::c_char; 32], + // pub u_debugreg: [::c_ulong; 8], + //} + + // GitHub repo: ifduyue/musl/ + // commit: b4b1e10364c8737a632be61582e05a8d3acf5690 + // file: arch/x86_64/bits/signal.h#L80-L84 + //pub struct mcontext_t { + // pub gregs: [greg_t; 23], + // __private: [u64; 9], + //} + + pub struct ipc_perm { + pub __ipc_perm_key: ::key_t, + pub uid: ::uid_t, + pub gid: ::gid_t, + pub cuid: ::uid_t, + pub cgid: ::gid_t, + pub mode: ::mode_t, + pub __seq: ::c_int, + __unused1: ::c_long, + __unused2: ::c_long + } +} + +s_no_extra_traits! { + //pub struct user_fpregs_struct { + // pub cwd: ::c_ushort, + // pub swd: ::c_ushort, + // pub ftw: ::c_ushort, + // pub fop: ::c_ushort, + // pub rip: ::c_ulong, + // pub rdp: ::c_ulong, + // pub mxcsr: ::c_uint, + // pub mxcr_mask: ::c_uint, + // pub st_space: [::c_uint; 32], + // pub xmm_space: [::c_uint; 64], + // padding: [::c_uint; 24], + //} + + //pub struct ucontext_t { + // pub uc_flags: ::c_ulong, + // pub uc_link: *mut ucontext_t, + // pub uc_stack: ::stack_t, + // pub uc_mcontext: mcontext_t, + // pub uc_sigmask: ::sigset_t, + // __private: [u8; 512], + //} +} + +cfg_if! { + if #[cfg(feature = "extra_traits")] { + //impl PartialEq for user_fpregs_struct { + // fn eq(&self, other: &user_fpregs_struct) -> bool { + // self.cwd == other.cwd + // && self.swd == other.swd + // && self.ftw == other.ftw + // && self.fop == other.fop + // && self.rip == other.rip + // && self.rdp == other.rdp + // && self.mxcsr == other.mxcsr + // && self.mxcr_mask == other.mxcr_mask + // && self.st_space == other.st_space + // && self + // .xmm_space + // .iter() + // .zip(other.xmm_space.iter()) + // .all(|(a,b)| a == b) + // // Ignore padding field + // } + //} + + //impl Eq for user_fpregs_struct {} + + //impl ::fmt::Debug for user_fpregs_struct { + // fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { + // f.debug_struct("user_fpregs_struct") + // .field("cwd", &self.cwd) + // .field("ftw", &self.ftw) + // .field("fop", &self.fop) + // .field("rip", &self.rip) + // .field("rdp", &self.rdp) + // .field("mxcsr", &self.mxcsr) + // .field("mxcr_mask", &self.mxcr_mask) + // .field("st_space", &self.st_space) + // // FIXME: .field("xmm_space", &self.xmm_space) + // // Ignore padding field + // .finish() + // } + //} + + //impl ::hash::Hash for user_fpregs_struct { + // fn hash(&self, state: &mut H) { + // self.cwd.hash(state); + // self.ftw.hash(state); + // self.fop.hash(state); + // self.rip.hash(state); + // self.rdp.hash(state); + // self.mxcsr.hash(state); + // self.mxcr_mask.hash(state); + // self.st_space.hash(state); + // self.xmm_space.hash(state); + // // Ignore padding field + // } + //} + + //impl PartialEq for ucontext_t { + // fn eq(&self, other: &ucontext_t) -> bool { + // self.uc_flags == other.uc_flags + // && self.uc_link == other.uc_link + // && self.uc_stack == other.uc_stack + // && self.uc_mcontext == other.uc_mcontext + // && self.uc_sigmask == other.uc_sigmask + // && self + // .__private + // .iter() + // .zip(other.__private.iter()) + // .all(|(a,b)| a == b) + // } + //} + + //impl Eq for ucontext_t {} + + //impl ::fmt::Debug for ucontext_t { + // fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { + // f.debug_struct("ucontext_t") + // .field("uc_flags", &self.uc_flags) + // .field("uc_link", &self.uc_link) + // .field("uc_stack", &self.uc_stack) + // .field("uc_mcontext", &self.uc_mcontext) + // .field("uc_sigmask", &self.uc_sigmask) + // // Ignore __private field + // .finish() + // } + //} + + //impl ::hash::Hash for ucontext_t { + // fn hash(&self, state: &mut H) { + // self.uc_flags.hash(state); + // self.uc_link.hash(state); + // self.uc_stack.hash(state); + // self.uc_mcontext.hash(state); + // self.uc_sigmask.hash(state); + // self.__private.hash(state); + // } + //} + } +} + +// Syscall table +pub const SYS_read: ::c_long = 0; +pub const SYS_write: ::c_long = 1; +pub const SYS_open: ::c_long = 2; +pub const SYS_close: ::c_long = 3; +pub const SYS_stat: ::c_long = 4; +pub const SYS_fstat: ::c_long = 5; +pub const SYS_lstat: ::c_long = 6; +pub const SYS_poll: ::c_long = 7; +pub const SYS_lseek: ::c_long = 8; +pub const SYS_mmap: ::c_long = 9; +pub const SYS_mprotect: ::c_long = 10; +pub const SYS_munmap: ::c_long = 11; +pub const SYS_brk: ::c_long = 12; +pub const SYS_rt_sigaction: ::c_long = 13; +pub const SYS_rt_sigprocmask: ::c_long = 14; +pub const SYS_rt_sigreturn: ::c_long = 15; +pub const SYS_ioctl: ::c_long = 16; +pub const SYS_pread64: ::c_long = 17; +pub const SYS_pwrite64: ::c_long = 18; +pub const SYS_readv: ::c_long = 19; +pub const SYS_writev: ::c_long = 20; +pub const SYS_access: ::c_long = 21; +pub const SYS_pipe: ::c_long = 22; +pub const SYS_select: ::c_long = 23; +pub const SYS_sched_yield: ::c_long = 24; +pub const SYS_mremap: ::c_long = 25; +pub const SYS_msync: ::c_long = 26; +pub const SYS_mincore: ::c_long = 27; +pub const SYS_madvise: ::c_long = 28; +pub const SYS_shmget: ::c_long = 29; +pub const SYS_shmat: ::c_long = 30; +pub const SYS_shmctl: ::c_long = 31; +pub const SYS_dup: ::c_long = 32; +pub const SYS_dup2: ::c_long = 33; +pub const SYS_pause: ::c_long = 34; +pub const SYS_nanosleep: ::c_long = 35; +pub const SYS_getitimer: ::c_long = 36; +pub const SYS_alarm: ::c_long = 37; +pub const SYS_setitimer: ::c_long = 38; +pub const SYS_getpid: ::c_long = 39; +pub const SYS_sendfile: ::c_long = 40; +pub const SYS_socket: ::c_long = 41; +pub const SYS_connect: ::c_long = 42; +pub const SYS_accept: ::c_long = 43; +pub const SYS_sendto: ::c_long = 44; +pub const SYS_recvfrom: ::c_long = 45; +pub const SYS_sendmsg: ::c_long = 46; +pub const SYS_recvmsg: ::c_long = 47; +pub const SYS_shutdown: ::c_long = 48; +pub const SYS_bind: ::c_long = 49; +pub const SYS_listen: ::c_long = 50; +pub const SYS_getsockname: ::c_long = 51; +pub const SYS_getpeername: ::c_long = 52; +pub const SYS_socketpair: ::c_long = 53; +pub const SYS_setsockopt: ::c_long = 54; +pub const SYS_getsockopt: ::c_long = 55; +pub const SYS_clone: ::c_long = 56; +pub const SYS_fork: ::c_long = 57; +pub const SYS_vfork: ::c_long = 58; +pub const SYS_execve: ::c_long = 59; +pub const SYS_exit: ::c_long = 60; +pub const SYS_wait4: ::c_long = 61; +pub const SYS_kill: ::c_long = 62; +pub const SYS_uname: ::c_long = 63; +pub const SYS_semget: ::c_long = 64; +pub const SYS_semop: ::c_long = 65; +pub const SYS_semctl: ::c_long = 66; +pub const SYS_shmdt: ::c_long = 67; +pub const SYS_msgget: ::c_long = 68; +pub const SYS_msgsnd: ::c_long = 69; +pub const SYS_msgrcv: ::c_long = 70; +pub const SYS_msgctl: ::c_long = 71; +pub const SYS_fcntl: ::c_long = 72; +pub const SYS_flock: ::c_long = 73; +pub const SYS_fsync: ::c_long = 74; +pub const SYS_fdatasync: ::c_long = 75; +pub const SYS_truncate: ::c_long = 76; +pub const SYS_ftruncate: ::c_long = 77; +pub const SYS_getdents: ::c_long = 78; +pub const SYS_getcwd: ::c_long = 79; +pub const SYS_chdir: ::c_long = 80; +pub const SYS_fchdir: ::c_long = 81; +pub const SYS_rename: ::c_long = 82; +pub const SYS_mkdir: ::c_long = 83; +pub const SYS_rmdir: ::c_long = 84; +pub const SYS_creat: ::c_long = 85; +pub const SYS_link: ::c_long = 86; +pub const SYS_unlink: ::c_long = 87; +pub const SYS_symlink: ::c_long = 88; +pub const SYS_readlink: ::c_long = 89; +pub const SYS_chmod: ::c_long = 90; +pub const SYS_fchmod: ::c_long = 91; +pub const SYS_chown: ::c_long = 92; +pub const SYS_fchown: ::c_long = 93; +pub const SYS_lchown: ::c_long = 94; +pub const SYS_umask: ::c_long = 95; +pub const SYS_gettimeofday: ::c_long = 96; +pub const SYS_getrlimit: ::c_long = 97; +pub const SYS_getrusage: ::c_long = 98; +pub const SYS_sysinfo: ::c_long = 99; +pub const SYS_times: ::c_long = 100; +pub const SYS_ptrace: ::c_long = 101; +pub const SYS_getuid: ::c_long = 102; +pub const SYS_syslog: ::c_long = 103; +pub const SYS_getgid: ::c_long = 104; +pub const SYS_setuid: ::c_long = 105; +pub const SYS_setgid: ::c_long = 106; +pub const SYS_geteuid: ::c_long = 107; +pub const SYS_getegid: ::c_long = 108; +pub const SYS_setpgid: ::c_long = 109; +pub const SYS_getppid: ::c_long = 110; +pub const SYS_getpgrp: ::c_long = 111; +pub const SYS_setsid: ::c_long = 112; +pub const SYS_setreuid: ::c_long = 113; +pub const SYS_setregid: ::c_long = 114; +pub const SYS_getgroups: ::c_long = 115; +pub const SYS_setgroups: ::c_long = 116; +pub const SYS_setresuid: ::c_long = 117; +pub const SYS_getresuid: ::c_long = 118; +pub const SYS_setresgid: ::c_long = 119; +pub const SYS_getresgid: ::c_long = 120; +pub const SYS_getpgid: ::c_long = 121; +pub const SYS_setfsuid: ::c_long = 122; +pub const SYS_setfsgid: ::c_long = 123; +pub const SYS_getsid: ::c_long = 124; +pub const SYS_capget: ::c_long = 125; +pub const SYS_capset: ::c_long = 126; +pub const SYS_rt_sigpending: ::c_long = 127; +pub const SYS_rt_sigtimedwait: ::c_long = 128; +pub const SYS_rt_sigqueueinfo: ::c_long = 129; +pub const SYS_rt_sigsuspend: ::c_long = 130; +pub const SYS_sigaltstack: ::c_long = 131; +pub const SYS_utime: ::c_long = 132; +pub const SYS_mknod: ::c_long = 133; +pub const SYS_uselib: ::c_long = 134; +pub const SYS_personality: ::c_long = 135; +pub const SYS_ustat: ::c_long = 136; +pub const SYS_statfs: ::c_long = 137; +pub const SYS_fstatfs: ::c_long = 138; +pub const SYS_sysfs: ::c_long = 139; +pub const SYS_getpriority: ::c_long = 140; +pub const SYS_setpriority: ::c_long = 141; +pub const SYS_sched_setparam: ::c_long = 142; +pub const SYS_sched_getparam: ::c_long = 143; +pub const SYS_sched_setscheduler: ::c_long = 144; +pub const SYS_sched_getscheduler: ::c_long = 145; +pub const SYS_sched_get_priority_max: ::c_long = 146; +pub const SYS_sched_get_priority_min: ::c_long = 147; +pub const SYS_sched_rr_get_interval: ::c_long = 148; +pub const SYS_mlock: ::c_long = 149; +pub const SYS_munlock: ::c_long = 150; +pub const SYS_mlockall: ::c_long = 151; +pub const SYS_munlockall: ::c_long = 152; +pub const SYS_vhangup: ::c_long = 153; +pub const SYS_modify_ldt: ::c_long = 154; +pub const SYS_pivot_root: ::c_long = 155; +pub const SYS__sysctl: ::c_long = 156; +pub const SYS_prctl: ::c_long = 157; +pub const SYS_arch_prctl: ::c_long = 158; +pub const SYS_adjtimex: ::c_long = 159; +pub const SYS_setrlimit: ::c_long = 160; +pub const SYS_chroot: ::c_long = 161; +pub const SYS_sync: ::c_long = 162; +pub const SYS_acct: ::c_long = 163; +pub const SYS_settimeofday: ::c_long = 164; +pub const SYS_mount: ::c_long = 165; +pub const SYS_umount2: ::c_long = 166; +pub const SYS_swapon: ::c_long = 167; +pub const SYS_swapoff: ::c_long = 168; +pub const SYS_reboot: ::c_long = 169; +pub const SYS_sethostname: ::c_long = 170; +pub const SYS_setdomainname: ::c_long = 171; +pub const SYS_iopl: ::c_long = 172; +pub const SYS_ioperm: ::c_long = 173; +pub const SYS_create_module: ::c_long = 174; +pub const SYS_init_module: ::c_long = 175; +pub const SYS_delete_module: ::c_long = 176; +pub const SYS_get_kernel_syms: ::c_long = 177; +pub const SYS_query_module: ::c_long = 178; +pub const SYS_quotactl: ::c_long = 179; +pub const SYS_nfsservctl: ::c_long = 180; +pub const SYS_getpmsg: ::c_long = 181; +pub const SYS_putpmsg: ::c_long = 182; +pub const SYS_afs_syscall: ::c_long = 183; +pub const SYS_tuxcall: ::c_long = 184; +pub const SYS_security: ::c_long = 185; +pub const SYS_gettid: ::c_long = 186; +pub const SYS_readahead: ::c_long = 187; +pub const SYS_setxattr: ::c_long = 188; +pub const SYS_lsetxattr: ::c_long = 189; +pub const SYS_fsetxattr: ::c_long = 190; +pub const SYS_getxattr: ::c_long = 191; +pub const SYS_lgetxattr: ::c_long = 192; +pub const SYS_fgetxattr: ::c_long = 193; +pub const SYS_listxattr: ::c_long = 194; +pub const SYS_llistxattr: ::c_long = 195; +pub const SYS_flistxattr: ::c_long = 196; +pub const SYS_removexattr: ::c_long = 197; +pub const SYS_lremovexattr: ::c_long = 198; +pub const SYS_fremovexattr: ::c_long = 199; +pub const SYS_tkill: ::c_long = 200; +pub const SYS_time: ::c_long = 201; +pub const SYS_futex: ::c_long = 202; +pub const SYS_sched_setaffinity: ::c_long = 203; +pub const SYS_sched_getaffinity: ::c_long = 204; +pub const SYS_set_thread_area: ::c_long = 205; +pub const SYS_io_setup: ::c_long = 206; +pub const SYS_io_destroy: ::c_long = 207; +pub const SYS_io_getevents: ::c_long = 208; +pub const SYS_io_submit: ::c_long = 209; +pub const SYS_io_cancel: ::c_long = 210; +pub const SYS_get_thread_area: ::c_long = 211; +pub const SYS_lookup_dcookie: ::c_long = 212; +pub const SYS_epoll_create: ::c_long = 213; +pub const SYS_epoll_ctl_old: ::c_long = 214; +pub const SYS_epoll_wait_old: ::c_long = 215; +pub const SYS_remap_file_pages: ::c_long = 216; +pub const SYS_getdents64: ::c_long = 217; +pub const SYS_set_tid_address: ::c_long = 218; +pub const SYS_restart_syscall: ::c_long = 219; +pub const SYS_semtimedop: ::c_long = 220; +pub const SYS_fadvise64: ::c_long = 221; +pub const SYS_timer_create: ::c_long = 222; +pub const SYS_timer_settime: ::c_long = 223; +pub const SYS_timer_gettime: ::c_long = 224; +pub const SYS_timer_getoverrun: ::c_long = 225; +pub const SYS_timer_delete: ::c_long = 226; +pub const SYS_clock_settime: ::c_long = 227; +pub const SYS_clock_gettime: ::c_long = 228; +pub const SYS_clock_getres: ::c_long = 229; +pub const SYS_clock_nanosleep: ::c_long = 230; +pub const SYS_exit_group: ::c_long = 231; +pub const SYS_epoll_wait: ::c_long = 232; +pub const SYS_epoll_ctl: ::c_long = 233; +pub const SYS_tgkill: ::c_long = 234; +pub const SYS_utimes: ::c_long = 235; +pub const SYS_vserver: ::c_long = 236; +pub const SYS_mbind: ::c_long = 237; +pub const SYS_set_mempolicy: ::c_long = 238; +pub const SYS_get_mempolicy: ::c_long = 239; +pub const SYS_mq_open: ::c_long = 240; +pub const SYS_mq_unlink: ::c_long = 241; +pub const SYS_mq_timedsend: ::c_long = 242; +pub const SYS_mq_timedreceive: ::c_long = 243; +pub const SYS_mq_notify: ::c_long = 244; +pub const SYS_mq_getsetattr: ::c_long = 245; +pub const SYS_kexec_load: ::c_long = 246; +pub const SYS_waitid: ::c_long = 247; +pub const SYS_add_key: ::c_long = 248; +pub const SYS_request_key: ::c_long = 249; +pub const SYS_keyctl: ::c_long = 250; +pub const SYS_ioprio_set: ::c_long = 251; +pub const SYS_ioprio_get: ::c_long = 252; +pub const SYS_inotify_init: ::c_long = 253; +pub const SYS_inotify_add_watch: ::c_long = 254; +pub const SYS_inotify_rm_watch: ::c_long = 255; +pub const SYS_migrate_pages: ::c_long = 256; +pub const SYS_openat: ::c_long = 257; +pub const SYS_mkdirat: ::c_long = 258; +pub const SYS_mknodat: ::c_long = 259; +pub const SYS_fchownat: ::c_long = 260; +pub const SYS_futimesat: ::c_long = 261; +pub const SYS_newfstatat: ::c_long = 262; +pub const SYS_unlinkat: ::c_long = 263; +pub const SYS_renameat: ::c_long = 264; +pub const SYS_linkat: ::c_long = 265; +pub const SYS_symlinkat: ::c_long = 266; +pub const SYS_readlinkat: ::c_long = 267; +pub const SYS_fchmodat: ::c_long = 268; +pub const SYS_faccessat: ::c_long = 269; +pub const SYS_pselect6: ::c_long = 270; +pub const SYS_ppoll: ::c_long = 271; +pub const SYS_unshare: ::c_long = 272; +pub const SYS_set_robust_list: ::c_long = 273; +pub const SYS_get_robust_list: ::c_long = 274; +pub const SYS_splice: ::c_long = 275; +pub const SYS_tee: ::c_long = 276; +pub const SYS_sync_file_range: ::c_long = 277; +pub const SYS_vmsplice: ::c_long = 278; +pub const SYS_move_pages: ::c_long = 279; +pub const SYS_utimensat: ::c_long = 280; +pub const SYS_epoll_pwait: ::c_long = 281; +pub const SYS_signalfd: ::c_long = 282; +pub const SYS_timerfd_create: ::c_long = 283; +pub const SYS_eventfd: ::c_long = 284; +pub const SYS_fallocate: ::c_long = 285; +pub const SYS_timerfd_settime: ::c_long = 286; +pub const SYS_timerfd_gettime: ::c_long = 287; +pub const SYS_accept4: ::c_long = 288; +pub const SYS_signalfd4: ::c_long = 289; +pub const SYS_eventfd2: ::c_long = 290; +pub const SYS_epoll_create1: ::c_long = 291; +pub const SYS_dup3: ::c_long = 292; +pub const SYS_pipe2: ::c_long = 293; +pub const SYS_inotify_init1: ::c_long = 294; +pub const SYS_preadv: ::c_long = 295; +pub const SYS_pwritev: ::c_long = 296; +pub const SYS_rt_tgsigqueueinfo: ::c_long = 297; +pub const SYS_perf_event_open: ::c_long = 298; +pub const SYS_recvmmsg: ::c_long = 299; +pub const SYS_fanotify_init: ::c_long = 300; +pub const SYS_fanotify_mark: ::c_long = 301; +pub const SYS_prlimit64: ::c_long = 302; +pub const SYS_name_to_handle_at: ::c_long = 303; +pub const SYS_open_by_handle_at: ::c_long = 304; +pub const SYS_clock_adjtime: ::c_long = 305; +pub const SYS_syncfs: ::c_long = 306; +pub const SYS_sendmmsg: ::c_long = 307; +pub const SYS_setns: ::c_long = 308; +pub const SYS_getcpu: ::c_long = 309; +pub const SYS_process_vm_readv: ::c_long = 310; +pub const SYS_process_vm_writev: ::c_long = 311; +pub const SYS_kcmp: ::c_long = 312; +pub const SYS_finit_module: ::c_long = 313; +pub const SYS_sched_setattr: ::c_long = 314; +pub const SYS_sched_getattr: ::c_long = 315; +pub const SYS_renameat2: ::c_long = 316; +pub const SYS_seccomp: ::c_long = 317; +pub const SYS_getrandom: ::c_long = 318; +pub const SYS_memfd_create: ::c_long = 319; +pub const SYS_kexec_file_load: ::c_long = 320; +pub const SYS_bpf: ::c_long = 321; +pub const SYS_execveat: ::c_long = 322; +pub const SYS_userfaultfd: ::c_long = 323; +pub const SYS_membarrier: ::c_long = 324; +pub const SYS_mlock2: ::c_long = 325; +pub const SYS_copy_file_range: ::c_long = 326; +pub const SYS_preadv2: ::c_long = 327; +pub const SYS_pwritev2: ::c_long = 328; +pub const SYS_pkey_mprotect: ::c_long = 329; +pub const SYS_pkey_alloc: ::c_long = 330; +pub const SYS_pkey_free: ::c_long = 331; +pub const SYS_statx: ::c_long = 332; +pub const SYS_io_pgetevents: ::c_long = 333; +pub const SYS_rseq: ::c_long = 334; +pub const SYS_pidfd_send_signal: ::c_long = 424; +pub const SYS_io_uring_setup: ::c_long = 425; +pub const SYS_io_uring_enter: ::c_long = 426; +pub const SYS_io_uring_register: ::c_long = 427; +pub const SYS_open_tree: ::c_long = 428; +pub const SYS_move_mount: ::c_long = 429; +pub const SYS_fsopen: ::c_long = 430; +pub const SYS_fsconfig: ::c_long = 431; +pub const SYS_fsmount: ::c_long = 432; +pub const SYS_fspick: ::c_long = 433; +pub const SYS_pidfd_open: ::c_long = 434; +pub const SYS_clone3: ::c_long = 435; +pub const SYS_close_range: ::c_long = 436; +pub const SYS_openat2: ::c_long = 437; +pub const SYS_pidfd_getfd: ::c_long = 438; +pub const SYS_faccessat2: ::c_long = 439; +pub const SYS_process_madvise: ::c_long = 440; +pub const SYS_epoll_pwait2: ::c_long = 441; +pub const SYS_mount_setattr: ::c_long = 442; +pub const SYS_quotactl_fd: ::c_long = 443; +pub const SYS_landlock_create_ruleset: ::c_long = 444; +pub const SYS_landlock_add_rule: ::c_long = 445; +pub const SYS_landlock_restrict_self: ::c_long = 446; +pub const SYS_memfd_secret: ::c_long = 447; +pub const SYS_process_mrelease: ::c_long = 448; +pub const SYS_futex_waitv: ::c_long = 449; +pub const SYS_set_mempolicy_home_node: ::c_long = 450; + +// offsets in user_regs_structs, from sys/reg.h +//pub const R15: ::c_int = 0; +//pub const R14: ::c_int = 1; +//pub const R13: ::c_int = 2; +//pub const R12: ::c_int = 3; +//pub const RBP: ::c_int = 4; +//pub const RBX: ::c_int = 5; +//pub const R11: ::c_int = 6; +//pub const R10: ::c_int = 7; +//pub const R9: ::c_int = 8; +//pub const R8: ::c_int = 9; +//pub const RAX: ::c_int = 10; +//pub const RCX: ::c_int = 11; +//pub const RDX: ::c_int = 12; +//pub const RSI: ::c_int = 13; +//pub const RDI: ::c_int = 14; +//pub const ORIG_RAX: ::c_int = 15; +//pub const RIP: ::c_int = 16; +//pub const CS: ::c_int = 17; +//pub const EFLAGS: ::c_int = 18; +//pub const RSP: ::c_int = 19; +//pub const SS: ::c_int = 20; +//pub const FS_BASE: ::c_int = 21; +//pub const GS_BASE: ::c_int = 22; +//pub const DS: ::c_int = 23; +//pub const ES: ::c_int = 24; +//pub const FS: ::c_int = 25; +//pub const GS: ::c_int = 26; + +// offsets in mcontext_t.gregs from bits/signal.h +// GitHub repo: ifduyue/musl/ +// commit: b4b1e10364c8737a632be61582e05a8d3acf5690 +// file: arch/x86_64/bits/signal.h#L9-L56 +//pub const REG_R8: ::c_int = 0; +//pub const REG_R9: ::c_int = 1; +//pub const REG_R10: ::c_int = 2; +//pub const REG_R11: ::c_int = 3; +//pub const REG_R12: ::c_int = 4; +//pub const REG_R13: ::c_int = 5; +//pub const REG_R14: ::c_int = 6; +//pub const REG_R15: ::c_int = 7; +//pub const REG_RDI: ::c_int = 8; +//pub const REG_RSI: ::c_int = 9; +//pub const REG_RBP: ::c_int = 10; +//pub const REG_RBX: ::c_int = 11; +//pub const REG_RDX: ::c_int = 12; +//pub const REG_RAX: ::c_int = 13; +//pub const REG_RCX: ::c_int = 14; +//pub const REG_RSP: ::c_int = 15; +//pub const REG_RIP: ::c_int = 16; +//pub const REG_EFL: ::c_int = 17; +//pub const REG_CSGSFS: ::c_int = 18; +//pub const REG_ERR: ::c_int = 19; +//pub const REG_TRAPNO: ::c_int = 20; +//pub const REG_OLDMASK: ::c_int = 21; +//pub const REG_CR2: ::c_int = 22; + +pub const MADV_SOFT_OFFLINE: ::c_int = 101; +pub const MAP_32BIT: ::c_int = 0x0040; +pub const O_APPEND: ::c_int = 1024; +pub const O_DIRECT: ::c_int = 0x4000; +pub const O_DIRECTORY: ::c_int = 0x10000; +pub const O_LARGEFILE: ::c_int = 0; +pub const O_NOFOLLOW: ::c_int = 0x20000; +pub const O_CREAT: ::c_int = 64; +pub const O_EXCL: ::c_int = 128; +pub const O_NOCTTY: ::c_int = 256; +pub const O_NONBLOCK: ::c_int = 2048; +pub const O_SYNC: ::c_int = 1052672; +pub const O_RSYNC: ::c_int = 1052672; +pub const O_DSYNC: ::c_int = 4096; +pub const O_ASYNC: ::c_int = 0x2000; + +pub const PTRACE_SYSEMU: ::c_int = 31; +pub const PTRACE_SYSEMU_SINGLESTEP: ::c_int = 32; + +pub const SIGSTKSZ: ::size_t = 8192; +pub const MINSIGSTKSZ: ::size_t = 2048; + +pub const ENAMETOOLONG: ::c_int = 36; +pub const ENOLCK: ::c_int = 37; +pub const ENOSYS: ::c_int = 38; +pub const ENOTEMPTY: ::c_int = 39; +pub const ELOOP: ::c_int = 40; +pub const ENOMSG: ::c_int = 42; +pub const EIDRM: ::c_int = 43; +pub const ECHRNG: ::c_int = 44; +pub const EL2NSYNC: ::c_int = 45; +pub const EL3HLT: ::c_int = 46; +pub const EL3RST: ::c_int = 47; +pub const ELNRNG: ::c_int = 48; +pub const EUNATCH: ::c_int = 49; +pub const ENOCSI: ::c_int = 50; +pub const EL2HLT: ::c_int = 51; +pub const EBADE: ::c_int = 52; +pub const EBADR: ::c_int = 53; +pub const EXFULL: ::c_int = 54; +pub const ENOANO: ::c_int = 55; +pub const EBADRQC: ::c_int = 56; +pub const EBADSLT: ::c_int = 57; +pub const EMULTIHOP: ::c_int = 72; +pub const EBADMSG: ::c_int = 74; +pub const EOVERFLOW: ::c_int = 75; +pub const ENOTUNIQ: ::c_int = 76; +pub const EBADFD: ::c_int = 77; +pub const EREMCHG: ::c_int = 78; +pub const ELIBACC: ::c_int = 79; +pub const ELIBBAD: ::c_int = 80; +pub const ELIBSCN: ::c_int = 81; +pub const ELIBMAX: ::c_int = 82; +pub const ELIBEXEC: ::c_int = 83; +pub const EILSEQ: ::c_int = 84; +pub const ERESTART: ::c_int = 85; +pub const ESTRPIPE: ::c_int = 86; +pub const EUSERS: ::c_int = 87; +pub const ENOTSOCK: ::c_int = 88; +pub const EDESTADDRREQ: ::c_int = 89; +pub const EMSGSIZE: ::c_int = 90; +pub const EPROTOTYPE: ::c_int = 91; +pub const ENOPROTOOPT: ::c_int = 92; +pub const EPROTONOSUPPORT: ::c_int = 93; +pub const ESOCKTNOSUPPORT: ::c_int = 94; +pub const EOPNOTSUPP: ::c_int = 95; +pub const ENOTSUP: ::c_int = EOPNOTSUPP; +pub const EPFNOSUPPORT: ::c_int = 96; +pub const EAFNOSUPPORT: ::c_int = 97; +pub const EADDRINUSE: ::c_int = 98; +pub const EADDRNOTAVAIL: ::c_int = 99; +pub const ENETDOWN: ::c_int = 100; +pub const ENETUNREACH: ::c_int = 101; +pub const ENETRESET: ::c_int = 102; +pub const ECONNABORTED: ::c_int = 103; +pub const ECONNRESET: ::c_int = 104; +pub const ENOBUFS: ::c_int = 105; +pub const EISCONN: ::c_int = 106; +pub const ENOTCONN: ::c_int = 107; +pub const ESHUTDOWN: ::c_int = 108; +pub const ETOOMANYREFS: ::c_int = 109; +pub const ETIMEDOUT: ::c_int = 110; +pub const ECONNREFUSED: ::c_int = 111; +pub const EHOSTDOWN: ::c_int = 112; +pub const EHOSTUNREACH: ::c_int = 113; +pub const EALREADY: ::c_int = 114; +pub const EINPROGRESS: ::c_int = 115; +pub const ESTALE: ::c_int = 116; +pub const EUCLEAN: ::c_int = 117; +pub const ENOTNAM: ::c_int = 118; +pub const ENAVAIL: ::c_int = 119; +pub const EISNAM: ::c_int = 120; +pub const EREMOTEIO: ::c_int = 121; +pub const EDQUOT: ::c_int = 122; +pub const ENOMEDIUM: ::c_int = 123; +pub const EMEDIUMTYPE: ::c_int = 124; +pub const ECANCELED: ::c_int = 125; +pub const ENOKEY: ::c_int = 126; +pub const EKEYEXPIRED: ::c_int = 127; +pub const EKEYREVOKED: ::c_int = 128; +pub const EKEYREJECTED: ::c_int = 129; +pub const EOWNERDEAD: ::c_int = 130; +pub const ENOTRECOVERABLE: ::c_int = 131; +pub const ERFKILL: ::c_int = 132; +pub const EHWPOISON: ::c_int = 133; + +pub const SA_ONSTACK: ::c_int = 0x08000000; +pub const SA_SIGINFO: ::c_int = 0x00000004; +pub const SA_NOCLDWAIT: ::c_int = 0x00000002; + +pub const SIGCHLD: ::c_int = 17; +pub const SIGBUS: ::c_int = 7; +pub const SIGTTIN: ::c_int = 21; +pub const SIGTTOU: ::c_int = 22; +pub const SIGXCPU: ::c_int = 24; +pub const SIGXFSZ: ::c_int = 25; +pub const SIGVTALRM: ::c_int = 26; +pub const SIGPROF: ::c_int = 27; +pub const SIGWINCH: ::c_int = 28; +pub const SIGUSR1: ::c_int = 10; +pub const SIGUSR2: ::c_int = 12; +pub const SIGCONT: ::c_int = 18; +pub const SIGSTOP: ::c_int = 19; +pub const SIGTSTP: ::c_int = 20; +pub const SIGURG: ::c_int = 23; +pub const SIGIO: ::c_int = 29; +pub const SIGSYS: ::c_int = 31; +pub const SIGSTKFLT: ::c_int = 16; +pub const SIGPOLL: ::c_int = 29; +pub const SIGPWR: ::c_int = 30; +pub const SIG_SETMASK: ::c_int = 2; +pub const SIG_BLOCK: ::c_int = 0x000000; +pub const SIG_UNBLOCK: ::c_int = 0x01; + +pub const F_GETLK: ::c_int = 5; +pub const F_GETOWN: ::c_int = 9; +pub const F_SETLK: ::c_int = 6; +pub const F_SETLKW: ::c_int = 7; +pub const F_SETOWN: ::c_int = 8; + +pub const VEOF: usize = 4; + +pub const POLLWRNORM: ::c_short = 0x100; +pub const POLLWRBAND: ::c_short = 0x200; + +pub const SOCK_STREAM: ::c_int = 1; +pub const SOCK_DGRAM: ::c_int = 2; + +pub const MAP_ANON: ::c_int = 0x0020; +pub const MAP_GROWSDOWN: ::c_int = 0x0100; +pub const MAP_DENYWRITE: ::c_int = 0x0800; +pub const MAP_EXECUTABLE: ::c_int = 0x01000; +pub const MAP_LOCKED: ::c_int = 0x02000; +pub const MAP_NORESERVE: ::c_int = 0x04000; +pub const MAP_POPULATE: ::c_int = 0x08000; +pub const MAP_NONBLOCK: ::c_int = 0x010000; +pub const MAP_STACK: ::c_int = 0x020000; +pub const MAP_HUGETLB: ::c_int = 0x040000; +pub const MAP_SYNC: ::c_int = 0x080000; + +pub const MCL_CURRENT: ::c_int = 0x0001; +pub const MCL_FUTURE: ::c_int = 0x0002; +pub const MCL_ONFAULT: ::c_int = 0x0004; +pub const CBAUD: ::tcflag_t = 0o0010017; +pub const TAB1: ::c_int = 0x00000800; +pub const TAB2: ::c_int = 0x00001000; +pub const TAB3: ::c_int = 0x00001800; +pub const CR1: ::c_int = 0x00000200; +pub const CR2: ::c_int = 0x00000400; +pub const CR3: ::c_int = 0x00000600; +pub const FF1: ::c_int = 0x00008000; +pub const BS1: ::c_int = 0x00002000; +pub const VT1: ::c_int = 0x00004000; +pub const VWERASE: usize = 14; +pub const VREPRINT: usize = 12; +pub const VSUSP: usize = 10; +pub const VSTART: usize = 8; +pub const VSTOP: usize = 9; +pub const VDISCARD: usize = 13; +pub const VTIME: usize = 5; +pub const IXON: ::tcflag_t = 0x00000400; +pub const IXOFF: ::tcflag_t = 0x00001000; +pub const ONLCR: ::tcflag_t = 0x4; +pub const CSIZE: ::tcflag_t = 0x00000030; +pub const CS6: ::tcflag_t = 0x00000010; +pub const CS7: ::tcflag_t = 0x00000020; +pub const CS8: ::tcflag_t = 0x00000030; +pub const CSTOPB: ::tcflag_t = 0x00000040; +pub const CREAD: ::tcflag_t = 0x00000080; +pub const PARENB: ::tcflag_t = 0x00000100; +pub const PARODD: ::tcflag_t = 0x00000200; +pub const HUPCL: ::tcflag_t = 0x00000400; +pub const CLOCAL: ::tcflag_t = 0x00000800; +pub const ECHOKE: ::tcflag_t = 0x00000800; +pub const ECHOE: ::tcflag_t = 0x00000010; +pub const ECHOK: ::tcflag_t = 0x00000020; +pub const ECHONL: ::tcflag_t = 0x00000040; +pub const ECHOPRT: ::tcflag_t = 0x00000400; +pub const ECHOCTL: ::tcflag_t = 0x00000200; +pub const ISIG: ::tcflag_t = 0x00000001; +pub const ICANON: ::tcflag_t = 0x00000002; +pub const PENDIN: ::tcflag_t = 0x00004000; +pub const NOFLSH: ::tcflag_t = 0x00000080; +pub const CIBAUD: ::tcflag_t = 0o02003600000; +pub const CBAUDEX: ::tcflag_t = 0o010000; +pub const VSWTC: usize = 7; +pub const OLCUC: ::tcflag_t = 0o000002; +pub const NLDLY: ::tcflag_t = 0o000400; +pub const CRDLY: ::tcflag_t = 0o003000; +pub const TABDLY: ::tcflag_t = 0o014000; +pub const BSDLY: ::tcflag_t = 0o020000; +pub const FFDLY: ::tcflag_t = 0o100000; +pub const VTDLY: ::tcflag_t = 0o040000; +pub const XTABS: ::tcflag_t = 0o014000; +pub const B57600: ::speed_t = 0o010001; +pub const B115200: ::speed_t = 0o010002; +pub const B230400: ::speed_t = 0o010003; +pub const B460800: ::speed_t = 0o010004; +pub const B500000: ::speed_t = 0o010005; +pub const B576000: ::speed_t = 0o010006; +pub const B921600: ::speed_t = 0o010007; +pub const B1000000: ::speed_t = 0o010010; +pub const B1152000: ::speed_t = 0o010011; +pub const B1500000: ::speed_t = 0o010012; +pub const B2000000: ::speed_t = 0o010013; +pub const B2500000: ::speed_t = 0o010014; +pub const B3000000: ::speed_t = 0o010015; +pub const B3500000: ::speed_t = 0o010016; +pub const B4000000: ::speed_t = 0o010017; + +pub const EDEADLK: ::c_int = 35; +pub const EDEADLOCK: ::c_int = EDEADLK; + +pub const EXTPROC: ::tcflag_t = 0x00010000; +pub const VEOL: usize = 11; +pub const VEOL2: usize = 16; +pub const VMIN: usize = 6; +pub const IEXTEN: ::tcflag_t = 0x00008000; +pub const TOSTOP: ::tcflag_t = 0x00000100; +pub const FLUSHO: ::tcflag_t = 0x00001000; + +/* Aliases to syscall constants */ +pub const SYS_fadvise: ::c_long = SYS_fadvise64; + +/* WebAssembly Linux Interface (WALI) syscall specification */ +mod syscalls_wali; +pub use self::syscalls_wali::*; diff --git a/src/unix/linux_like/linux/musl/b64/wasm32/syscalls_wali.rs b/src/unix/linux_like/linux/musl/b64/wasm32/syscalls_wali.rs new file mode 100644 index 0000000000000..8041fa5116fdd --- /dev/null +++ b/src/unix/linux_like/linux/musl/b64/wasm32/syscalls_wali.rs @@ -0,0 +1,1513 @@ +use core::concat_idents; +use core::unimplemented; + +macro_rules! syscall_match_arm { + ($name:ident, $vargs:ident, $($a:ident),*) => {{ + $( + let $a = $vargs.arg(); + )* + concat_idents!(__syscall_, $name)($($a),*) + }} +} + +// WALI -- All syscalls made from Rust are name-bound +/* Syscall Definitions (autogenerated) */ +#[link(wasm_import_module = "wali")] +extern "C" { + /* 0 */ + #[link_name = "SYS_read"] + pub fn __syscall_SYS_read(a1: i32, a2: i32, a3: u32) -> ::c_long; + /* 1 */ + #[link_name = "SYS_write"] + pub fn __syscall_SYS_write(a1: i32, a2: i32, a3: u32) -> ::c_long; + /* 2 */ + #[link_name = "SYS_open"] + pub fn __syscall_SYS_open(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 3 */ + #[link_name = "SYS_close"] + pub fn __syscall_SYS_close(a1: i32) -> ::c_long; + /* 4 */ + #[link_name = "SYS_stat"] + pub fn __syscall_SYS_stat(a1: i32, a2: i32) -> ::c_long; + /* 5 */ + #[link_name = "SYS_fstat"] + pub fn __syscall_SYS_fstat(a1: i32, a2: i32) -> ::c_long; + /* 6 */ + #[link_name = "SYS_lstat"] + pub fn __syscall_SYS_lstat(a1: i32, a2: i32) -> ::c_long; + /* 7 */ + #[link_name = "SYS_poll"] + pub fn __syscall_SYS_poll(a1: i32, a2: u32, a3: i32) -> ::c_long; + /* 8 */ + #[link_name = "SYS_lseek"] + pub fn __syscall_SYS_lseek(a1: i32, a2: i64, a3: i32) -> ::c_long; + /* 9 */ + #[link_name = "SYS_mmap"] + pub fn __syscall_SYS_mmap(a1: i32, a2: u32, a3: i32, a4: i32, a5: i32, a6: i64) -> ::c_long; + /* 10 */ + #[link_name = "SYS_mprotect"] + pub fn __syscall_SYS_mprotect(a1: i32, a2: u32, a3: i32) -> ::c_long; + /* 11 */ + #[link_name = "SYS_munmap"] + pub fn __syscall_SYS_munmap(a1: i32, a2: u32) -> ::c_long; + /* 12 */ + #[link_name = "SYS_brk"] + pub fn __syscall_SYS_brk(a1: i32) -> ::c_long; + /* 13 */ + #[link_name = "SYS_rt_sigaction"] + pub fn __syscall_SYS_rt_sigaction(a1: i32, a2: i32, a3: i32, a4: u32) -> ::c_long; + /* 14 */ + #[link_name = "SYS_rt_sigprocmask"] + pub fn __syscall_SYS_rt_sigprocmask(a1: i32, a2: i32, a3: i32, a4: u32) -> ::c_long; + /* 15 */ + #[link_name = "SYS_rt_sigreturn"] + pub fn __syscall_SYS_rt_sigreturn(a1: i64) -> ::c_long; + /* 16 */ + #[link_name = "SYS_ioctl"] + pub fn __syscall_SYS_ioctl(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 17 */ + #[link_name = "SYS_pread64"] + pub fn __syscall_SYS_pread64(a1: i32, a2: i32, a3: u32, a4: i64) -> ::c_long; + /* 18 */ + #[link_name = "SYS_pwrite64"] + pub fn __syscall_SYS_pwrite64(a1: i32, a2: i32, a3: u32, a4: i64) -> ::c_long; + /* 19 */ + #[link_name = "SYS_readv"] + pub fn __syscall_SYS_readv(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 20 */ + #[link_name = "SYS_writev"] + pub fn __syscall_SYS_writev(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 21 */ + #[link_name = "SYS_access"] + pub fn __syscall_SYS_access(a1: i32, a2: i32) -> ::c_long; + /* 22 */ + #[link_name = "SYS_pipe"] + pub fn __syscall_SYS_pipe(a1: i32) -> ::c_long; + /* 23 */ + #[link_name = "SYS_select"] + pub fn __syscall_SYS_select(a1: i32, a2: i32, a3: i32, a4: i32, a5: i32) -> ::c_long; + /* 24 */ + #[link_name = "SYS_sched_yield"] + pub fn __syscall_SYS_sched_yield() -> ::c_long; + /* 25 */ + #[link_name = "SYS_mremap"] + pub fn __syscall_SYS_mremap(a1: i32, a2: u32, a3: u32, a4: i32, a5: i32) -> ::c_long; + /* 26 */ + #[link_name = "SYS_msync"] + pub fn __syscall_SYS_msync(a1: i32, a2: u32, a3: i32) -> ::c_long; + /* 27 */ + #[link_name = "SYS_mincore"] + pub fn __syscall_SYS_mincore() -> ::c_long; + /* 28 */ + #[link_name = "SYS_madvise"] + pub fn __syscall_SYS_madvise(a1: i32, a2: u32, a3: i32) -> ::c_long; + /* 29 */ + #[link_name = "SYS_shmget"] + pub fn __syscall_SYS_shmget() -> ::c_long; + /* 30 */ + #[link_name = "SYS_shmat"] + pub fn __syscall_SYS_shmat() -> ::c_long; + /* 31 */ + #[link_name = "SYS_shmctl"] + pub fn __syscall_SYS_shmctl() -> ::c_long; + /* 32 */ + #[link_name = "SYS_dup"] + pub fn __syscall_SYS_dup(a1: i32) -> ::c_long; + /* 33 */ + #[link_name = "SYS_dup2"] + pub fn __syscall_SYS_dup2(a1: i32, a2: i32) -> ::c_long; + /* 34 */ + #[link_name = "SYS_pause"] + pub fn __syscall_SYS_pause() -> ::c_long; + /* 35 */ + #[link_name = "SYS_nanosleep"] + pub fn __syscall_SYS_nanosleep(a1: i32, a2: i32) -> ::c_long; + /* 36 */ + #[link_name = "SYS_getitimer"] + pub fn __syscall_SYS_getitimer() -> ::c_long; + /* 37 */ + #[link_name = "SYS_alarm"] + pub fn __syscall_SYS_alarm(a1: i32) -> ::c_long; + /* 38 */ + #[link_name = "SYS_setitimer"] + pub fn __syscall_SYS_setitimer(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 39 */ + #[link_name = "SYS_getpid"] + pub fn __syscall_SYS_getpid() -> ::c_long; + /* 40 */ + #[link_name = "SYS_sendfile"] + pub fn __syscall_SYS_sendfile() -> ::c_long; + /* 41 */ + #[link_name = "SYS_socket"] + pub fn __syscall_SYS_socket(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 42 */ + #[link_name = "SYS_connect"] + pub fn __syscall_SYS_connect(a1: i32, a2: i32, a3: u32) -> ::c_long; + /* 43 */ + #[link_name = "SYS_accept"] + pub fn __syscall_SYS_accept(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 44 */ + #[link_name = "SYS_sendto"] + pub fn __syscall_SYS_sendto(a1: i32, a2: i32, a3: u32, a4: i32, a5: i32, a6: u32) -> ::c_long; + /* 45 */ + #[link_name = "SYS_recvfrom"] + pub fn __syscall_SYS_recvfrom(a1: i32, a2: i32, a3: u32, a4: i32, a5: i32, a6: i32) + -> ::c_long; + /* 46 */ + #[link_name = "SYS_sendmsg"] + pub fn __syscall_SYS_sendmsg(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 47 */ + #[link_name = "SYS_recvmsg"] + pub fn __syscall_SYS_recvmsg(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 48 */ + #[link_name = "SYS_shutdown"] + pub fn __syscall_SYS_shutdown(a1: i32, a2: i32) -> ::c_long; + /* 49 */ + #[link_name = "SYS_bind"] + pub fn __syscall_SYS_bind(a1: i32, a2: i32, a3: u32) -> ::c_long; + /* 50 */ + #[link_name = "SYS_listen"] + pub fn __syscall_SYS_listen(a1: i32, a2: i32) -> ::c_long; + /* 51 */ + #[link_name = "SYS_getsockname"] + pub fn __syscall_SYS_getsockname(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 52 */ + #[link_name = "SYS_getpeername"] + pub fn __syscall_SYS_getpeername(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 53 */ + #[link_name = "SYS_socketpair"] + pub fn __syscall_SYS_socketpair(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 54 */ + #[link_name = "SYS_setsockopt"] + pub fn __syscall_SYS_setsockopt(a1: i32, a2: i32, a3: i32, a4: i32, a5: u32) -> ::c_long; + /* 55 */ + #[link_name = "SYS_getsockopt"] + pub fn __syscall_SYS_getsockopt(a1: i32, a2: i32, a3: i32, a4: i32, a5: i32) -> ::c_long; + /* 56 */ + #[link_name = "SYS_clone"] + pub fn __syscall_SYS_clone() -> ::c_long; + /* 57 */ + #[link_name = "SYS_fork"] + pub fn __syscall_SYS_fork() -> ::c_long; + /* 58 */ + #[link_name = "SYS_vfork"] + pub fn __syscall_SYS_vfork() -> ::c_long; + /* 59 */ + #[link_name = "SYS_execve"] + pub fn __syscall_SYS_execve(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 60 */ + #[link_name = "SYS_exit"] + pub fn __syscall_SYS_exit(a1: i32) -> ::c_long; + /* 61 */ + #[link_name = "SYS_wait4"] + pub fn __syscall_SYS_wait4(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 62 */ + #[link_name = "SYS_kill"] + pub fn __syscall_SYS_kill(a1: i32, a2: i32) -> ::c_long; + /* 63 */ + #[link_name = "SYS_uname"] + pub fn __syscall_SYS_uname(a1: i32) -> ::c_long; + /* 64 */ + #[link_name = "SYS_semget"] + pub fn __syscall_SYS_semget() -> ::c_long; + /* 65 */ + #[link_name = "SYS_semop"] + pub fn __syscall_SYS_semop() -> ::c_long; + /* 66 */ + #[link_name = "SYS_semctl"] + pub fn __syscall_SYS_semctl() -> ::c_long; + /* 67 */ + #[link_name = "SYS_shmdt"] + pub fn __syscall_SYS_shmdt() -> ::c_long; + /* 68 */ + #[link_name = "SYS_msgget"] + pub fn __syscall_SYS_msgget() -> ::c_long; + /* 69 */ + #[link_name = "SYS_msgsnd"] + pub fn __syscall_SYS_msgsnd() -> ::c_long; + /* 70 */ + #[link_name = "SYS_msgrcv"] + pub fn __syscall_SYS_msgrcv() -> ::c_long; + /* 71 */ + #[link_name = "SYS_msgctl"] + pub fn __syscall_SYS_msgctl() -> ::c_long; + /* 72 */ + #[link_name = "SYS_fcntl"] + pub fn __syscall_SYS_fcntl(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 73 */ + #[link_name = "SYS_flock"] + pub fn __syscall_SYS_flock(a1: i32, a2: i32) -> ::c_long; + /* 74 */ + #[link_name = "SYS_fsync"] + pub fn __syscall_SYS_fsync(a1: i32) -> ::c_long; + /* 75 */ + #[link_name = "SYS_fdatasync"] + pub fn __syscall_SYS_fdatasync(a1: i32) -> ::c_long; + /* 76 */ + #[link_name = "SYS_truncate"] + pub fn __syscall_SYS_truncate() -> ::c_long; + /* 77 */ + #[link_name = "SYS_ftruncate"] + pub fn __syscall_SYS_ftruncate(a1: i32, a2: i64) -> ::c_long; + /* 78 */ + #[link_name = "SYS_getdents"] + pub fn __syscall_SYS_getdents(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 79 */ + #[link_name = "SYS_getcwd"] + pub fn __syscall_SYS_getcwd(a1: i32, a2: u32) -> ::c_long; + /* 80 */ + #[link_name = "SYS_chdir"] + pub fn __syscall_SYS_chdir(a1: i32) -> ::c_long; + /* 81 */ + #[link_name = "SYS_fchdir"] + pub fn __syscall_SYS_fchdir(a1: i32) -> ::c_long; + /* 82 */ + #[link_name = "SYS_rename"] + pub fn __syscall_SYS_rename(a1: i32, a2: i32) -> ::c_long; + /* 83 */ + #[link_name = "SYS_mkdir"] + pub fn __syscall_SYS_mkdir(a1: i32, a2: i32) -> ::c_long; + /* 84 */ + #[link_name = "SYS_rmdir"] + pub fn __syscall_SYS_rmdir(a1: i32) -> ::c_long; + /* 85 */ + #[link_name = "SYS_creat"] + pub fn __syscall_SYS_creat() -> ::c_long; + /* 86 */ + #[link_name = "SYS_link"] + pub fn __syscall_SYS_link(a1: i32, a2: i32) -> ::c_long; + /* 87 */ + #[link_name = "SYS_unlink"] + pub fn __syscall_SYS_unlink(a1: i32) -> ::c_long; + /* 88 */ + #[link_name = "SYS_symlink"] + pub fn __syscall_SYS_symlink(a1: i32, a2: i32) -> ::c_long; + /* 89 */ + #[link_name = "SYS_readlink"] + pub fn __syscall_SYS_readlink(a1: i32, a2: i32, a3: u32) -> ::c_long; + /* 90 */ + #[link_name = "SYS_chmod"] + pub fn __syscall_SYS_chmod(a1: i32, a2: i32) -> ::c_long; + /* 91 */ + #[link_name = "SYS_fchmod"] + pub fn __syscall_SYS_fchmod(a1: i32, a2: i32) -> ::c_long; + /* 92 */ + #[link_name = "SYS_chown"] + pub fn __syscall_SYS_chown(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 93 */ + #[link_name = "SYS_fchown"] + pub fn __syscall_SYS_fchown(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 94 */ + #[link_name = "SYS_lchown"] + pub fn __syscall_SYS_lchown() -> ::c_long; + /* 95 */ + #[link_name = "SYS_umask"] + pub fn __syscall_SYS_umask(a1: i32) -> ::c_long; + /* 96 */ + #[link_name = "SYS_gettimeofday"] + pub fn __syscall_SYS_gettimeofday() -> ::c_long; + /* 97 */ + #[link_name = "SYS_getrlimit"] + pub fn __syscall_SYS_getrlimit(a1: i32, a2: i32) -> ::c_long; + /* 98 */ + #[link_name = "SYS_getrusage"] + pub fn __syscall_SYS_getrusage(a1: i32, a2: i32) -> ::c_long; + /* 99 */ + #[link_name = "SYS_sysinfo"] + pub fn __syscall_SYS_sysinfo(a1: i32) -> ::c_long; + /* 100 */ + #[link_name = "SYS_times"] + pub fn __syscall_SYS_times() -> ::c_long; + /* 101 */ + #[link_name = "SYS_ptrace"] + pub fn __syscall_SYS_ptrace() -> ::c_long; + /* 102 */ + #[link_name = "SYS_getuid"] + pub fn __syscall_SYS_getuid() -> ::c_long; + /* 103 */ + #[link_name = "SYS_syslog"] + pub fn __syscall_SYS_syslog() -> ::c_long; + /* 104 */ + #[link_name = "SYS_getgid"] + pub fn __syscall_SYS_getgid() -> ::c_long; + /* 105 */ + #[link_name = "SYS_setuid"] + pub fn __syscall_SYS_setuid(a1: i32) -> ::c_long; + /* 106 */ + #[link_name = "SYS_setgid"] + pub fn __syscall_SYS_setgid(a1: i32) -> ::c_long; + /* 107 */ + #[link_name = "SYS_geteuid"] + pub fn __syscall_SYS_geteuid() -> ::c_long; + /* 108 */ + #[link_name = "SYS_getegid"] + pub fn __syscall_SYS_getegid() -> ::c_long; + /* 109 */ + #[link_name = "SYS_setpgid"] + pub fn __syscall_SYS_setpgid(a1: i32, a2: i32) -> ::c_long; + /* 110 */ + #[link_name = "SYS_getppid"] + pub fn __syscall_SYS_getppid() -> ::c_long; + /* 111 */ + #[link_name = "SYS_getpgrp"] + pub fn __syscall_SYS_getpgrp() -> ::c_long; + /* 112 */ + #[link_name = "SYS_setsid"] + pub fn __syscall_SYS_setsid() -> ::c_long; + /* 113 */ + #[link_name = "SYS_setreuid"] + pub fn __syscall_SYS_setreuid(a1: i32, a2: i32) -> ::c_long; + /* 114 */ + #[link_name = "SYS_setregid"] + pub fn __syscall_SYS_setregid(a1: i32, a2: i32) -> ::c_long; + /* 115 */ + #[link_name = "SYS_getgroups"] + pub fn __syscall_SYS_getgroups(a1: u32, a2: i32) -> ::c_long; + /* 116 */ + #[link_name = "SYS_setgroups"] + pub fn __syscall_SYS_setgroups(a1: u32, a2: i32) -> ::c_long; + /* 117 */ + #[link_name = "SYS_setresuid"] + pub fn __syscall_SYS_setresuid(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 118 */ + #[link_name = "SYS_getresuid"] + pub fn __syscall_SYS_getresuid() -> ::c_long; + /* 119 */ + #[link_name = "SYS_setresgid"] + pub fn __syscall_SYS_setresgid(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 120 */ + #[link_name = "SYS_getresgid"] + pub fn __syscall_SYS_getresgid() -> ::c_long; + /* 121 */ + #[link_name = "SYS_getpgid"] + pub fn __syscall_SYS_getpgid(a1: i32) -> ::c_long; + /* 122 */ + #[link_name = "SYS_setfsuid"] + pub fn __syscall_SYS_setfsuid() -> ::c_long; + /* 123 */ + #[link_name = "SYS_setfsgid"] + pub fn __syscall_SYS_setfsgid() -> ::c_long; + /* 124 */ + #[link_name = "SYS_getsid"] + pub fn __syscall_SYS_getsid(a1: i32) -> ::c_long; + /* 125 */ + #[link_name = "SYS_capget"] + pub fn __syscall_SYS_capget() -> ::c_long; + /* 126 */ + #[link_name = "SYS_capset"] + pub fn __syscall_SYS_capset() -> ::c_long; + /* 127 */ + #[link_name = "SYS_rt_sigpending"] + pub fn __syscall_SYS_rt_sigpending(a1: i32, a2: u32) -> ::c_long; + /* 128 */ + #[link_name = "SYS_rt_sigtimedwait"] + pub fn __syscall_SYS_rt_sigtimedwait() -> ::c_long; + /* 129 */ + #[link_name = "SYS_rt_sigqueueinfo"] + pub fn __syscall_SYS_rt_sigqueueinfo() -> ::c_long; + /* 130 */ + #[link_name = "SYS_rt_sigsuspend"] + pub fn __syscall_SYS_rt_sigsuspend(a1: i32, a2: u32) -> ::c_long; + /* 131 */ + #[link_name = "SYS_sigaltstack"] + pub fn __syscall_SYS_sigaltstack(a1: i32, a2: i32) -> ::c_long; + /* 132 */ + #[link_name = "SYS_utime"] + pub fn __syscall_SYS_utime(a1: i32, a2: i32) -> ::c_long; + /* 133 */ + #[link_name = "SYS_mknod"] + pub fn __syscall_SYS_mknod() -> ::c_long; + /* 134 */ + #[link_name = "SYS_uselib"] + pub fn __syscall_SYS_uselib() -> ::c_long; + /* 135 */ + #[link_name = "SYS_personality"] + pub fn __syscall_SYS_personality() -> ::c_long; + /* 136 */ + #[link_name = "SYS_ustat"] + pub fn __syscall_SYS_ustat() -> ::c_long; + /* 137 */ + #[link_name = "SYS_statfs"] + pub fn __syscall_SYS_statfs(a1: i32, a2: i32) -> ::c_long; + /* 138 */ + #[link_name = "SYS_fstatfs"] + pub fn __syscall_SYS_fstatfs(a1: i32, a2: i32) -> ::c_long; + /* 139 */ + #[link_name = "SYS_sysfs"] + pub fn __syscall_SYS_sysfs() -> ::c_long; + /* 140 */ + #[link_name = "SYS_getpriority"] + pub fn __syscall_SYS_getpriority() -> ::c_long; + /* 141 */ + #[link_name = "SYS_setpriority"] + pub fn __syscall_SYS_setpriority() -> ::c_long; + /* 142 */ + #[link_name = "SYS_sched_setparam"] + pub fn __syscall_SYS_sched_setparam() -> ::c_long; + /* 143 */ + #[link_name = "SYS_sched_getparam"] + pub fn __syscall_SYS_sched_getparam() -> ::c_long; + /* 144 */ + #[link_name = "SYS_sched_setscheduler"] + pub fn __syscall_SYS_sched_setscheduler() -> ::c_long; + /* 145 */ + #[link_name = "SYS_sched_getscheduler"] + pub fn __syscall_SYS_sched_getscheduler() -> ::c_long; + /* 146 */ + #[link_name = "SYS_sched_get_priority_max"] + pub fn __syscall_SYS_sched_get_priority_max() -> ::c_long; + /* 147 */ + #[link_name = "SYS_sched_get_priority_min"] + pub fn __syscall_SYS_sched_get_priority_min() -> ::c_long; + /* 148 */ + #[link_name = "SYS_sched_rr_get_interval"] + pub fn __syscall_SYS_sched_rr_get_interval() -> ::c_long; + /* 149 */ + #[link_name = "SYS_mlock"] + pub fn __syscall_SYS_mlock() -> ::c_long; + /* 150 */ + #[link_name = "SYS_munlock"] + pub fn __syscall_SYS_munlock() -> ::c_long; + /* 151 */ + #[link_name = "SYS_mlockall"] + pub fn __syscall_SYS_mlockall() -> ::c_long; + /* 152 */ + #[link_name = "SYS_munlockall"] + pub fn __syscall_SYS_munlockall() -> ::c_long; + /* 153 */ + #[link_name = "SYS_vhangup"] + pub fn __syscall_SYS_vhangup() -> ::c_long; + /* 154 */ + #[link_name = "SYS_modify_ldt"] + pub fn __syscall_SYS_modify_ldt() -> ::c_long; + /* 155 */ + #[link_name = "SYS_pivot_root"] + pub fn __syscall_SYS_pivot_root() -> ::c_long; + /* 156 */ + #[link_name = "SYS__sysctl"] + pub fn __syscall_SYS__sysctl() -> ::c_long; + /* 157 */ + #[link_name = "SYS_prctl"] + pub fn __syscall_SYS_prctl(a1: i32, a2: u64, a3: u64, a4: u64, a5: u64) -> ::c_long; + /* 158 */ + #[link_name = "SYS_arch_prctl"] + pub fn __syscall_SYS_arch_prctl() -> ::c_long; + /* 159 */ + #[link_name = "SYS_adjtimex"] + pub fn __syscall_SYS_adjtimex() -> ::c_long; + /* 160 */ + #[link_name = "SYS_setrlimit"] + pub fn __syscall_SYS_setrlimit(a1: i32, a2: i32) -> ::c_long; + /* 161 */ + #[link_name = "SYS_chroot"] + pub fn __syscall_SYS_chroot(a1: i32) -> ::c_long; + /* 162 */ + #[link_name = "SYS_sync"] + pub fn __syscall_SYS_sync() -> ::c_long; + /* 163 */ + #[link_name = "SYS_acct"] + pub fn __syscall_SYS_acct() -> ::c_long; + /* 164 */ + #[link_name = "SYS_settimeofday"] + pub fn __syscall_SYS_settimeofday() -> ::c_long; + /* 165 */ + #[link_name = "SYS_mount"] + pub fn __syscall_SYS_mount() -> ::c_long; + /* 166 */ + #[link_name = "SYS_umount2"] + pub fn __syscall_SYS_umount2() -> ::c_long; + /* 167 */ + #[link_name = "SYS_swapon"] + pub fn __syscall_SYS_swapon() -> ::c_long; + /* 168 */ + #[link_name = "SYS_swapoff"] + pub fn __syscall_SYS_swapoff() -> ::c_long; + /* 169 */ + #[link_name = "SYS_reboot"] + pub fn __syscall_SYS_reboot() -> ::c_long; + /* 170 */ + #[link_name = "SYS_sethostname"] + pub fn __syscall_SYS_sethostname() -> ::c_long; + /* 171 */ + #[link_name = "SYS_setdomainname"] + pub fn __syscall_SYS_setdomainname() -> ::c_long; + /* 172 */ + #[link_name = "SYS_iopl"] + pub fn __syscall_SYS_iopl() -> ::c_long; + /* 173 */ + #[link_name = "SYS_ioperm"] + pub fn __syscall_SYS_ioperm() -> ::c_long; + /* 174 */ + #[link_name = "SYS_create_module"] + pub fn __syscall_SYS_create_module() -> ::c_long; + /* 175 */ + #[link_name = "SYS_init_module"] + pub fn __syscall_SYS_init_module() -> ::c_long; + /* 176 */ + #[link_name = "SYS_delete_module"] + pub fn __syscall_SYS_delete_module() -> ::c_long; + /* 177 */ + #[link_name = "SYS_get_kernel_syms"] + pub fn __syscall_SYS_get_kernel_syms() -> ::c_long; + /* 178 */ + #[link_name = "SYS_query_module"] + pub fn __syscall_SYS_query_module() -> ::c_long; + /* 179 */ + #[link_name = "SYS_quotactl"] + pub fn __syscall_SYS_quotactl() -> ::c_long; + /* 180 */ + #[link_name = "SYS_nfsservctl"] + pub fn __syscall_SYS_nfsservctl() -> ::c_long; + /* 181 */ + #[link_name = "SYS_getpmsg"] + pub fn __syscall_SYS_getpmsg() -> ::c_long; + /* 182 */ + #[link_name = "SYS_putpmsg"] + pub fn __syscall_SYS_putpmsg() -> ::c_long; + /* 183 */ + #[link_name = "SYS_afs_syscall"] + pub fn __syscall_SYS_afs_syscall() -> ::c_long; + /* 184 */ + #[link_name = "SYS_tuxcall"] + pub fn __syscall_SYS_tuxcall() -> ::c_long; + /* 185 */ + #[link_name = "SYS_security"] + pub fn __syscall_SYS_security() -> ::c_long; + /* 186 */ + #[link_name = "SYS_gettid"] + pub fn __syscall_SYS_gettid() -> ::c_long; + /* 187 */ + #[link_name = "SYS_readahead"] + pub fn __syscall_SYS_readahead() -> ::c_long; + /* 188 */ + #[link_name = "SYS_setxattr"] + pub fn __syscall_SYS_setxattr() -> ::c_long; + /* 189 */ + #[link_name = "SYS_lsetxattr"] + pub fn __syscall_SYS_lsetxattr() -> ::c_long; + /* 190 */ + #[link_name = "SYS_fsetxattr"] + pub fn __syscall_SYS_fsetxattr() -> ::c_long; + /* 191 */ + #[link_name = "SYS_getxattr"] + pub fn __syscall_SYS_getxattr() -> ::c_long; + /* 192 */ + #[link_name = "SYS_lgetxattr"] + pub fn __syscall_SYS_lgetxattr() -> ::c_long; + /* 193 */ + #[link_name = "SYS_fgetxattr"] + pub fn __syscall_SYS_fgetxattr() -> ::c_long; + /* 194 */ + #[link_name = "SYS_listxattr"] + pub fn __syscall_SYS_listxattr() -> ::c_long; + /* 195 */ + #[link_name = "SYS_llistxattr"] + pub fn __syscall_SYS_llistxattr() -> ::c_long; + /* 196 */ + #[link_name = "SYS_flistxattr"] + pub fn __syscall_SYS_flistxattr() -> ::c_long; + /* 197 */ + #[link_name = "SYS_removexattr"] + pub fn __syscall_SYS_removexattr() -> ::c_long; + /* 198 */ + #[link_name = "SYS_lremovexattr"] + pub fn __syscall_SYS_lremovexattr() -> ::c_long; + /* 199 */ + #[link_name = "SYS_fremovexattr"] + pub fn __syscall_SYS_fremovexattr() -> ::c_long; + /* 200 */ + #[link_name = "SYS_tkill"] + pub fn __syscall_SYS_tkill(a1: i32, a2: i32) -> ::c_long; + /* 201 */ + #[link_name = "SYS_time"] + pub fn __syscall_SYS_time() -> ::c_long; + /* 202 */ + #[link_name = "SYS_futex"] + pub fn __syscall_SYS_futex(a1: i32, a2: i32, a3: i32, a4: i32, a5: i32, a6: i32) -> ::c_long; + /* 203 */ + #[link_name = "SYS_sched_setaffinity"] + pub fn __syscall_SYS_sched_setaffinity() -> ::c_long; + /* 204 */ + #[link_name = "SYS_sched_getaffinity"] + pub fn __syscall_SYS_sched_getaffinity(a1: i32, a2: u32, a3: i32) -> ::c_long; + /* 205 */ + #[link_name = "SYS_set_thread_area"] + pub fn __syscall_SYS_set_thread_area() -> ::c_long; + /* 206 */ + #[link_name = "SYS_io_setup"] + pub fn __syscall_SYS_io_setup() -> ::c_long; + /* 207 */ + #[link_name = "SYS_io_destroy"] + pub fn __syscall_SYS_io_destroy() -> ::c_long; + /* 208 */ + #[link_name = "SYS_io_getevents"] + pub fn __syscall_SYS_io_getevents() -> ::c_long; + /* 209 */ + #[link_name = "SYS_io_submit"] + pub fn __syscall_SYS_io_submit() -> ::c_long; + /* 210 */ + #[link_name = "SYS_io_cancel"] + pub fn __syscall_SYS_io_cancel() -> ::c_long; + /* 211 */ + #[link_name = "SYS_get_thread_area"] + pub fn __syscall_SYS_get_thread_area() -> ::c_long; + /* 212 */ + #[link_name = "SYS_lookup_dcookie"] + pub fn __syscall_SYS_lookup_dcookie() -> ::c_long; + /* 213 */ + #[link_name = "SYS_epoll_create"] + pub fn __syscall_SYS_epoll_create() -> ::c_long; + /* 214 */ + #[link_name = "SYS_epoll_ctl_old"] + pub fn __syscall_SYS_epoll_ctl_old() -> ::c_long; + /* 215 */ + #[link_name = "SYS_epoll_wait_old"] + pub fn __syscall_SYS_epoll_wait_old() -> ::c_long; + /* 216 */ + #[link_name = "SYS_remap_file_pages"] + pub fn __syscall_SYS_remap_file_pages() -> ::c_long; + /* 217 */ + #[link_name = "SYS_getdents64"] + pub fn __syscall_SYS_getdents64(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 218 */ + #[link_name = "SYS_set_tid_address"] + pub fn __syscall_SYS_set_tid_address(a1: i32) -> ::c_long; + /* 219 */ + #[link_name = "SYS_restart_syscall"] + pub fn __syscall_SYS_restart_syscall() -> ::c_long; + /* 220 */ + #[link_name = "SYS_semtimedop"] + pub fn __syscall_SYS_semtimedop() -> ::c_long; + /* 221 */ + #[link_name = "SYS_fadvise"] + pub fn __syscall_SYS_fadvise(a1: i32, a2: i64, a3: i64, a4: i32) -> ::c_long; + /* 222 */ + #[link_name = "SYS_timer_create"] + pub fn __syscall_SYS_timer_create() -> ::c_long; + /* 223 */ + #[link_name = "SYS_timer_settime"] + pub fn __syscall_SYS_timer_settime() -> ::c_long; + /* 224 */ + #[link_name = "SYS_timer_gettime"] + pub fn __syscall_SYS_timer_gettime() -> ::c_long; + /* 225 */ + #[link_name = "SYS_timer_getoverrun"] + pub fn __syscall_SYS_timer_getoverrun() -> ::c_long; + /* 226 */ + #[link_name = "SYS_timer_delete"] + pub fn __syscall_SYS_timer_delete() -> ::c_long; + /* 227 */ + #[link_name = "SYS_clock_settime"] + pub fn __syscall_SYS_clock_settime() -> ::c_long; + /* 228 */ + #[link_name = "SYS_clock_gettime"] + pub fn __syscall_SYS_clock_gettime(a1: i32, a2: i32) -> ::c_long; + /* 229 */ + #[link_name = "SYS_clock_getres"] + pub fn __syscall_SYS_clock_getres(a1: i32, a2: i32) -> ::c_long; + /* 230 */ + #[link_name = "SYS_clock_nanosleep"] + pub fn __syscall_SYS_clock_nanosleep(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 231 */ + #[link_name = "SYS_exit_group"] + pub fn __syscall_SYS_exit_group(a1: i32) -> ::c_long; + /* 232 */ + #[link_name = "SYS_epoll_wait"] + pub fn __syscall_SYS_epoll_wait() -> ::c_long; + /* 233 */ + #[link_name = "SYS_epoll_ctl"] + pub fn __syscall_SYS_epoll_ctl(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 234 */ + #[link_name = "SYS_tgkill"] + pub fn __syscall_SYS_tgkill() -> ::c_long; + /* 235 */ + #[link_name = "SYS_utimes"] + pub fn __syscall_SYS_utimes() -> ::c_long; + /* 236 */ + #[link_name = "SYS_vserver"] + pub fn __syscall_SYS_vserver() -> ::c_long; + /* 237 */ + #[link_name = "SYS_mbind"] + pub fn __syscall_SYS_mbind() -> ::c_long; + /* 238 */ + #[link_name = "SYS_set_mempolicy"] + pub fn __syscall_SYS_set_mempolicy() -> ::c_long; + /* 239 */ + #[link_name = "SYS_get_mempolicy"] + pub fn __syscall_SYS_get_mempolicy() -> ::c_long; + /* 240 */ + #[link_name = "SYS_mq_open"] + pub fn __syscall_SYS_mq_open() -> ::c_long; + /* 241 */ + #[link_name = "SYS_mq_unlink"] + pub fn __syscall_SYS_mq_unlink() -> ::c_long; + /* 242 */ + #[link_name = "SYS_mq_timedsend"] + pub fn __syscall_SYS_mq_timedsend() -> ::c_long; + /* 243 */ + #[link_name = "SYS_mq_timedreceive"] + pub fn __syscall_SYS_mq_timedreceive() -> ::c_long; + /* 244 */ + #[link_name = "SYS_mq_notify"] + pub fn __syscall_SYS_mq_notify() -> ::c_long; + /* 245 */ + #[link_name = "SYS_mq_getsetattr"] + pub fn __syscall_SYS_mq_getsetattr() -> ::c_long; + /* 246 */ + #[link_name = "SYS_kexec_load"] + pub fn __syscall_SYS_kexec_load() -> ::c_long; + /* 247 */ + #[link_name = "SYS_waitid"] + pub fn __syscall_SYS_waitid() -> ::c_long; + /* 248 */ + #[link_name = "SYS_add_key"] + pub fn __syscall_SYS_add_key() -> ::c_long; + /* 249 */ + #[link_name = "SYS_request_key"] + pub fn __syscall_SYS_request_key() -> ::c_long; + /* 250 */ + #[link_name = "SYS_keyctl"] + pub fn __syscall_SYS_keyctl() -> ::c_long; + /* 251 */ + #[link_name = "SYS_ioprio_set"] + pub fn __syscall_SYS_ioprio_set() -> ::c_long; + /* 252 */ + #[link_name = "SYS_ioprio_get"] + pub fn __syscall_SYS_ioprio_get() -> ::c_long; + /* 253 */ + #[link_name = "SYS_inotify_init"] + pub fn __syscall_SYS_inotify_init() -> ::c_long; + /* 254 */ + #[link_name = "SYS_inotify_add_watch"] + pub fn __syscall_SYS_inotify_add_watch() -> ::c_long; + /* 255 */ + #[link_name = "SYS_inotify_rm_watch"] + pub fn __syscall_SYS_inotify_rm_watch() -> ::c_long; + /* 256 */ + #[link_name = "SYS_migrate_pages"] + pub fn __syscall_SYS_migrate_pages() -> ::c_long; + /* 257 */ + #[link_name = "SYS_openat"] + pub fn __syscall_SYS_openat(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 258 */ + #[link_name = "SYS_mkdirat"] + pub fn __syscall_SYS_mkdirat(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 259 */ + #[link_name = "SYS_mknodat"] + pub fn __syscall_SYS_mknodat() -> ::c_long; + /* 260 */ + #[link_name = "SYS_fchownat"] + pub fn __syscall_SYS_fchownat(a1: i32, a2: i32, a3: i32, a4: i32, a5: i32) -> ::c_long; + /* 261 */ + #[link_name = "SYS_futimesat"] + pub fn __syscall_SYS_futimesat() -> ::c_long; + /* 262 */ + #[link_name = "SYS_fstatat"] + pub fn __syscall_SYS_fstatat(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 263 */ + #[link_name = "SYS_unlinkat"] + pub fn __syscall_SYS_unlinkat(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 264 */ + #[link_name = "SYS_renameat"] + pub fn __syscall_SYS_renameat() -> ::c_long; + /* 265 */ + #[link_name = "SYS_linkat"] + pub fn __syscall_SYS_linkat(a1: i32, a2: i32, a3: i32, a4: i32, a5: i32) -> ::c_long; + /* 266 */ + #[link_name = "SYS_symlinkat"] + pub fn __syscall_SYS_symlinkat(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 267 */ + #[link_name = "SYS_readlinkat"] + pub fn __syscall_SYS_readlinkat(a1: i32, a2: i32, a3: i32, a4: u32) -> ::c_long; + /* 268 */ + #[link_name = "SYS_fchmodat"] + pub fn __syscall_SYS_fchmodat(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 269 */ + #[link_name = "SYS_faccessat"] + pub fn __syscall_SYS_faccessat(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 270 */ + #[link_name = "SYS_pselect6"] + pub fn __syscall_SYS_pselect6(a1: i32, a2: i32, a3: i32, a4: i32, a5: i32, a6: i32) + -> ::c_long; + /* 271 */ + #[link_name = "SYS_ppoll"] + pub fn __syscall_SYS_ppoll(a1: i32, a2: u32, a3: i32, a4: i32, a5: u32) -> ::c_long; + /* 272 */ + #[link_name = "SYS_unshare"] + pub fn __syscall_SYS_unshare() -> ::c_long; + /* 273 */ + #[link_name = "SYS_set_robust_list"] + pub fn __syscall_SYS_set_robust_list() -> ::c_long; + /* 274 */ + #[link_name = "SYS_get_robust_list"] + pub fn __syscall_SYS_get_robust_list() -> ::c_long; + /* 275 */ + #[link_name = "SYS_splice"] + pub fn __syscall_SYS_splice() -> ::c_long; + /* 276 */ + #[link_name = "SYS_tee"] + pub fn __syscall_SYS_tee() -> ::c_long; + /* 277 */ + #[link_name = "SYS_sync_file_range"] + pub fn __syscall_SYS_sync_file_range() -> ::c_long; + /* 278 */ + #[link_name = "SYS_vmsplice"] + pub fn __syscall_SYS_vmsplice() -> ::c_long; + /* 279 */ + #[link_name = "SYS_move_pages"] + pub fn __syscall_SYS_move_pages() -> ::c_long; + /* 280 */ + #[link_name = "SYS_utimensat"] + pub fn __syscall_SYS_utimensat(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 281 */ + #[link_name = "SYS_epoll_pwait"] + pub fn __syscall_SYS_epoll_pwait( + a1: i32, + a2: i32, + a3: i32, + a4: i32, + a5: i32, + a6: u32, + ) -> ::c_long; + /* 282 */ + #[link_name = "SYS_signalfd"] + pub fn __syscall_SYS_signalfd() -> ::c_long; + /* 283 */ + #[link_name = "SYS_timerfd_create"] + pub fn __syscall_SYS_timerfd_create() -> ::c_long; + /* 284 */ + #[link_name = "SYS_eventfd"] + pub fn __syscall_SYS_eventfd(a1: i32) -> ::c_long; + /* 285 */ + #[link_name = "SYS_fallocate"] + pub fn __syscall_SYS_fallocate() -> ::c_long; + /* 286 */ + #[link_name = "SYS_timerfd_settime"] + pub fn __syscall_SYS_timerfd_settime() -> ::c_long; + /* 287 */ + #[link_name = "SYS_timerfd_gettime"] + pub fn __syscall_SYS_timerfd_gettime() -> ::c_long; + /* 288 */ + #[link_name = "SYS_accept4"] + pub fn __syscall_SYS_accept4(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 289 */ + #[link_name = "SYS_signalfd4"] + pub fn __syscall_SYS_signalfd4() -> ::c_long; + /* 290 */ + #[link_name = "SYS_eventfd2"] + pub fn __syscall_SYS_eventfd2(a1: i32, a2: i32) -> ::c_long; + /* 291 */ + #[link_name = "SYS_epoll_create1"] + pub fn __syscall_SYS_epoll_create1(a1: i32) -> ::c_long; + /* 292 */ + #[link_name = "SYS_dup3"] + pub fn __syscall_SYS_dup3(a1: i32, a2: i32, a3: i32) -> ::c_long; + /* 293 */ + #[link_name = "SYS_pipe2"] + pub fn __syscall_SYS_pipe2(a1: i32, a2: i32) -> ::c_long; + /* 294 */ + #[link_name = "SYS_inotify_init1"] + pub fn __syscall_SYS_inotify_init1() -> ::c_long; + /* 295 */ + #[link_name = "SYS_preadv"] + pub fn __syscall_SYS_preadv() -> ::c_long; + /* 296 */ + #[link_name = "SYS_pwritev"] + pub fn __syscall_SYS_pwritev() -> ::c_long; + /* 297 */ + #[link_name = "SYS_rt_tgsigqueueinfo"] + pub fn __syscall_SYS_rt_tgsigqueueinfo() -> ::c_long; + /* 298 */ + #[link_name = "SYS_perf_event_open"] + pub fn __syscall_SYS_perf_event_open() -> ::c_long; + /* 299 */ + #[link_name = "SYS_recvmmsg"] + pub fn __syscall_SYS_recvmmsg() -> ::c_long; + /* 300 */ + #[link_name = "SYS_fanotify_init"] + pub fn __syscall_SYS_fanotify_init() -> ::c_long; + /* 301 */ + #[link_name = "SYS_fanotify_mark"] + pub fn __syscall_SYS_fanotify_mark() -> ::c_long; + /* 302 */ + #[link_name = "SYS_prlimit64"] + pub fn __syscall_SYS_prlimit64(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; + /* 303 */ + #[link_name = "SYS_name_to_handle_at"] + pub fn __syscall_SYS_name_to_handle_at() -> ::c_long; + /* 304 */ + #[link_name = "SYS_open_by_handle_at"] + pub fn __syscall_SYS_open_by_handle_at() -> ::c_long; + /* 305 */ + #[link_name = "SYS_clock_adjtime"] + pub fn __syscall_SYS_clock_adjtime() -> ::c_long; + /* 306 */ + #[link_name = "SYS_syncfs"] + pub fn __syscall_SYS_syncfs() -> ::c_long; + /* 307 */ + #[link_name = "SYS_sendmmsg"] + pub fn __syscall_SYS_sendmmsg() -> ::c_long; + /* 308 */ + #[link_name = "SYS_setns"] + pub fn __syscall_SYS_setns() -> ::c_long; + /* 309 */ + #[link_name = "SYS_getcpu"] + pub fn __syscall_SYS_getcpu() -> ::c_long; + /* 310 */ + #[link_name = "SYS_process_vm_readv"] + pub fn __syscall_SYS_process_vm_readv() -> ::c_long; + /* 311 */ + #[link_name = "SYS_process_vm_writev"] + pub fn __syscall_SYS_process_vm_writev() -> ::c_long; + /* 312 */ + #[link_name = "SYS_kcmp"] + pub fn __syscall_SYS_kcmp() -> ::c_long; + /* 313 */ + #[link_name = "SYS_finit_module"] + pub fn __syscall_SYS_finit_module() -> ::c_long; + /* 314 */ + #[link_name = "SYS_sched_setattr"] + pub fn __syscall_SYS_sched_setattr() -> ::c_long; + /* 315 */ + #[link_name = "SYS_sched_getattr"] + pub fn __syscall_SYS_sched_getattr() -> ::c_long; + /* 316 */ + #[link_name = "SYS_renameat2"] + pub fn __syscall_SYS_renameat2(a1: i32, a2: i32, a3: i32, a4: i32, a5: i32) -> ::c_long; + /* 317 */ + #[link_name = "SYS_seccomp"] + pub fn __syscall_SYS_seccomp() -> ::c_long; + /* 318 */ + #[link_name = "SYS_getrandom"] + pub fn __syscall_SYS_getrandom(a1: i32, a2: u32, a3: i32) -> ::c_long; + /* 319 */ + #[link_name = "SYS_memfd_create"] + pub fn __syscall_SYS_memfd_create() -> ::c_long; + /* 320 */ + #[link_name = "SYS_kexec_file_load"] + pub fn __syscall_SYS_kexec_file_load() -> ::c_long; + /* 321 */ + #[link_name = "SYS_bpf"] + pub fn __syscall_SYS_bpf() -> ::c_long; + /* 322 */ + #[link_name = "SYS_execveat"] + pub fn __syscall_SYS_execveat() -> ::c_long; + /* 323 */ + #[link_name = "SYS_userfaultfd"] + pub fn __syscall_SYS_userfaultfd() -> ::c_long; + /* 324 */ + #[link_name = "SYS_membarrier"] + pub fn __syscall_SYS_membarrier() -> ::c_long; + /* 325 */ + #[link_name = "SYS_mlock2"] + pub fn __syscall_SYS_mlock2() -> ::c_long; + /* 326 */ + #[link_name = "SYS_copy_file_range"] + pub fn __syscall_SYS_copy_file_range() -> ::c_long; + /* 327 */ + #[link_name = "SYS_preadv2"] + pub fn __syscall_SYS_preadv2() -> ::c_long; + /* 328 */ + #[link_name = "SYS_pwritev2"] + pub fn __syscall_SYS_pwritev2() -> ::c_long; + /* 329 */ + #[link_name = "SYS_pkey_mprotect"] + pub fn __syscall_SYS_pkey_mprotect() -> ::c_long; + /* 330 */ + #[link_name = "SYS_pkey_alloc"] + pub fn __syscall_SYS_pkey_alloc() -> ::c_long; + /* 331 */ + #[link_name = "SYS_pkey_free"] + pub fn __syscall_SYS_pkey_free() -> ::c_long; + /* 332 */ + #[link_name = "SYS_statx"] + pub fn __syscall_SYS_statx(a1: i32, a2: i32, a3: i32, a4: i32, a5: i32) -> ::c_long; + /* 333 */ + #[link_name = "SYS_io_pgetevents"] + pub fn __syscall_SYS_io_pgetevents() -> ::c_long; + /* 334 */ + #[link_name = "SYS_rseq"] + pub fn __syscall_SYS_rseq() -> ::c_long; + /* 439 */ + #[link_name = "SYS_faccessat2"] + pub fn __syscall_SYS_faccessat2(a1: i32, a2: i32, a3: i32, a4: i32) -> ::c_long; +} + +/* Syscall Wrapper (autogenerated) */ +/* Requires explicit typecasting of syscall arguments to appropriate size */ +#[no_mangle] +pub unsafe extern "C" fn syscall(num: ::c_long, mut args: ...) -> ::c_long { + match num { + super::SYS_read => syscall_match_arm!(SYS_read, args, a0, a1, a2), + super::SYS_write => syscall_match_arm!(SYS_write, args, a0, a1, a2), + super::SYS_open => syscall_match_arm!(SYS_open, args, a0, a1, a2), + super::SYS_close => syscall_match_arm!(SYS_close, args, a0), + super::SYS_stat => syscall_match_arm!(SYS_stat, args, a0, a1), + super::SYS_fstat => syscall_match_arm!(SYS_fstat, args, a0, a1), + super::SYS_lstat => syscall_match_arm!(SYS_lstat, args, a0, a1), + super::SYS_poll => syscall_match_arm!(SYS_poll, args, a0, a1, a2), + super::SYS_lseek => syscall_match_arm!(SYS_lseek, args, a0, a1, a2), + super::SYS_mmap => syscall_match_arm!(SYS_mmap, args, a0, a1, a2, a3, a4, a5), + super::SYS_mprotect => syscall_match_arm!(SYS_mprotect, args, a0, a1, a2), + super::SYS_munmap => syscall_match_arm!(SYS_munmap, args, a0, a1), + super::SYS_brk => syscall_match_arm!(SYS_brk, args, a0), + super::SYS_rt_sigaction => syscall_match_arm!(SYS_rt_sigaction, args, a0, a1, a2, a3), + super::SYS_rt_sigprocmask => syscall_match_arm!(SYS_rt_sigprocmask, args, a0, a1, a2, a3), + super::SYS_rt_sigreturn => syscall_match_arm!(SYS_rt_sigreturn, args, a0), + super::SYS_ioctl => syscall_match_arm!(SYS_ioctl, args, a0, a1, a2), + super::SYS_pread64 => syscall_match_arm!(SYS_pread64, args, a0, a1, a2, a3), + super::SYS_pwrite64 => syscall_match_arm!(SYS_pwrite64, args, a0, a1, a2, a3), + super::SYS_readv => syscall_match_arm!(SYS_readv, args, a0, a1, a2), + super::SYS_writev => syscall_match_arm!(SYS_writev, args, a0, a1, a2), + super::SYS_access => syscall_match_arm!(SYS_access, args, a0, a1), + super::SYS_pipe => syscall_match_arm!(SYS_pipe, args, a0), + super::SYS_select => syscall_match_arm!(SYS_select, args, a0, a1, a2, a3, a4), + super::SYS_sched_yield => syscall_match_arm!(SYS_sched_yield, args,), + super::SYS_mremap => syscall_match_arm!(SYS_mremap, args, a0, a1, a2, a3, a4), + super::SYS_msync => syscall_match_arm!(SYS_msync, args, a0, a1, a2), + super::SYS_mincore => unimplemented!("WALI syscall 'mincore' (27) unimplemented!"), + super::SYS_madvise => syscall_match_arm!(SYS_madvise, args, a0, a1, a2), + super::SYS_shmget => unimplemented!("WALI syscall 'shmget' (29) unimplemented!"), + super::SYS_shmat => unimplemented!("WALI syscall 'shmat' (30) unimplemented!"), + super::SYS_shmctl => unimplemented!("WALI syscall 'shmctl' (31) unimplemented!"), + super::SYS_dup => syscall_match_arm!(SYS_dup, args, a0), + super::SYS_dup2 => syscall_match_arm!(SYS_dup2, args, a0, a1), + super::SYS_pause => unimplemented!("WALI syscall 'pause' (34) unimplemented!"), + super::SYS_nanosleep => syscall_match_arm!(SYS_nanosleep, args, a0, a1), + super::SYS_getitimer => unimplemented!("WALI syscall 'getitimer' (36) unimplemented!"), + super::SYS_alarm => syscall_match_arm!(SYS_alarm, args, a0), + super::SYS_setitimer => syscall_match_arm!(SYS_setitimer, args, a0, a1, a2), + super::SYS_getpid => syscall_match_arm!(SYS_getpid, args,), + super::SYS_sendfile => unimplemented!("WALI syscall 'sendfile' (40) unimplemented!"), + super::SYS_socket => syscall_match_arm!(SYS_socket, args, a0, a1, a2), + super::SYS_connect => syscall_match_arm!(SYS_connect, args, a0, a1, a2), + super::SYS_accept => syscall_match_arm!(SYS_accept, args, a0, a1, a2), + super::SYS_sendto => syscall_match_arm!(SYS_sendto, args, a0, a1, a2, a3, a4, a5), + super::SYS_recvfrom => syscall_match_arm!(SYS_recvfrom, args, a0, a1, a2, a3, a4, a5), + super::SYS_sendmsg => syscall_match_arm!(SYS_sendmsg, args, a0, a1, a2), + super::SYS_recvmsg => syscall_match_arm!(SYS_recvmsg, args, a0, a1, a2), + super::SYS_shutdown => syscall_match_arm!(SYS_shutdown, args, a0, a1), + super::SYS_bind => syscall_match_arm!(SYS_bind, args, a0, a1, a2), + super::SYS_listen => syscall_match_arm!(SYS_listen, args, a0, a1), + super::SYS_getsockname => syscall_match_arm!(SYS_getsockname, args, a0, a1, a2), + super::SYS_getpeername => syscall_match_arm!(SYS_getpeername, args, a0, a1, a2), + super::SYS_socketpair => syscall_match_arm!(SYS_socketpair, args, a0, a1, a2, a3), + super::SYS_setsockopt => syscall_match_arm!(SYS_setsockopt, args, a0, a1, a2, a3, a4), + super::SYS_getsockopt => syscall_match_arm!(SYS_getsockopt, args, a0, a1, a2, a3, a4), + super::SYS_clone => unimplemented!("WALI syscall 'clone' (56) unimplemented!"), + super::SYS_fork => syscall_match_arm!(SYS_fork, args,), + super::SYS_vfork => unimplemented!("WALI syscall 'vfork' (58) unimplemented!"), + super::SYS_execve => syscall_match_arm!(SYS_execve, args, a0, a1, a2), + super::SYS_exit => syscall_match_arm!(SYS_exit, args, a0), + super::SYS_wait4 => syscall_match_arm!(SYS_wait4, args, a0, a1, a2, a3), + super::SYS_kill => syscall_match_arm!(SYS_kill, args, a0, a1), + super::SYS_uname => syscall_match_arm!(SYS_uname, args, a0), + super::SYS_semget => unimplemented!("WALI syscall 'semget' (64) unimplemented!"), + super::SYS_semop => unimplemented!("WALI syscall 'semop' (65) unimplemented!"), + super::SYS_semctl => unimplemented!("WALI syscall 'semctl' (66) unimplemented!"), + super::SYS_shmdt => unimplemented!("WALI syscall 'shmdt' (67) unimplemented!"), + super::SYS_msgget => unimplemented!("WALI syscall 'msgget' (68) unimplemented!"), + super::SYS_msgsnd => unimplemented!("WALI syscall 'msgsnd' (69) unimplemented!"), + super::SYS_msgrcv => unimplemented!("WALI syscall 'msgrcv' (70) unimplemented!"), + super::SYS_msgctl => unimplemented!("WALI syscall 'msgctl' (71) unimplemented!"), + super::SYS_fcntl => syscall_match_arm!(SYS_fcntl, args, a0, a1, a2), + super::SYS_flock => syscall_match_arm!(SYS_flock, args, a0, a1), + super::SYS_fsync => syscall_match_arm!(SYS_fsync, args, a0), + super::SYS_fdatasync => syscall_match_arm!(SYS_fdatasync, args, a0), + super::SYS_truncate => unimplemented!("WALI syscall 'truncate' (76) unimplemented!"), + super::SYS_ftruncate => syscall_match_arm!(SYS_ftruncate, args, a0, a1), + super::SYS_getdents => syscall_match_arm!(SYS_getdents, args, a0, a1, a2), + super::SYS_getcwd => syscall_match_arm!(SYS_getcwd, args, a0, a1), + super::SYS_chdir => syscall_match_arm!(SYS_chdir, args, a0), + super::SYS_fchdir => syscall_match_arm!(SYS_fchdir, args, a0), + super::SYS_rename => syscall_match_arm!(SYS_rename, args, a0, a1), + super::SYS_mkdir => syscall_match_arm!(SYS_mkdir, args, a0, a1), + super::SYS_rmdir => syscall_match_arm!(SYS_rmdir, args, a0), + super::SYS_creat => unimplemented!("WALI syscall 'creat' (85) unimplemented!"), + super::SYS_link => syscall_match_arm!(SYS_link, args, a0, a1), + super::SYS_unlink => syscall_match_arm!(SYS_unlink, args, a0), + super::SYS_symlink => syscall_match_arm!(SYS_symlink, args, a0, a1), + super::SYS_readlink => syscall_match_arm!(SYS_readlink, args, a0, a1, a2), + super::SYS_chmod => syscall_match_arm!(SYS_chmod, args, a0, a1), + super::SYS_fchmod => syscall_match_arm!(SYS_fchmod, args, a0, a1), + super::SYS_chown => syscall_match_arm!(SYS_chown, args, a0, a1, a2), + super::SYS_fchown => syscall_match_arm!(SYS_fchown, args, a0, a1, a2), + super::SYS_lchown => unimplemented!("WALI syscall 'lchown' (94) unimplemented!"), + super::SYS_umask => syscall_match_arm!(SYS_umask, args, a0), + super::SYS_gettimeofday => { + unimplemented!("WALI syscall 'gettimeofday' (96) unimplemented!") + } + super::SYS_getrlimit => syscall_match_arm!(SYS_getrlimit, args, a0, a1), + super::SYS_getrusage => syscall_match_arm!(SYS_getrusage, args, a0, a1), + super::SYS_sysinfo => syscall_match_arm!(SYS_sysinfo, args, a0), + super::SYS_times => unimplemented!("WALI syscall 'times' (100) unimplemented!"), + super::SYS_ptrace => unimplemented!("WALI syscall 'ptrace' (101) unimplemented!"), + super::SYS_getuid => syscall_match_arm!(SYS_getuid, args,), + super::SYS_syslog => unimplemented!("WALI syscall 'syslog' (103) unimplemented!"), + super::SYS_getgid => syscall_match_arm!(SYS_getgid, args,), + super::SYS_setuid => syscall_match_arm!(SYS_setuid, args, a0), + super::SYS_setgid => syscall_match_arm!(SYS_setgid, args, a0), + super::SYS_geteuid => syscall_match_arm!(SYS_geteuid, args,), + super::SYS_getegid => syscall_match_arm!(SYS_getegid, args,), + super::SYS_setpgid => syscall_match_arm!(SYS_setpgid, args, a0, a1), + super::SYS_getppid => syscall_match_arm!(SYS_getppid, args,), + super::SYS_getpgrp => unimplemented!("WALI syscall 'getpgrp' (111) unimplemented!"), + super::SYS_setsid => syscall_match_arm!(SYS_setsid, args,), + super::SYS_setreuid => syscall_match_arm!(SYS_setreuid, args, a0, a1), + super::SYS_setregid => syscall_match_arm!(SYS_setregid, args, a0, a1), + super::SYS_getgroups => syscall_match_arm!(SYS_getgroups, args, a0, a1), + super::SYS_setgroups => syscall_match_arm!(SYS_setgroups, args, a0, a1), + super::SYS_setresuid => syscall_match_arm!(SYS_setresuid, args, a0, a1, a2), + super::SYS_getresuid => unimplemented!("WALI syscall 'getresuid' (118) unimplemented!"), + super::SYS_setresgid => syscall_match_arm!(SYS_setresgid, args, a0, a1, a2), + super::SYS_getresgid => unimplemented!("WALI syscall 'getresgid' (120) unimplemented!"), + super::SYS_getpgid => syscall_match_arm!(SYS_getpgid, args, a0), + super::SYS_setfsuid => unimplemented!("WALI syscall 'setfsuid' (122) unimplemented!"), + super::SYS_setfsgid => unimplemented!("WALI syscall 'setfsgid' (123) unimplemented!"), + super::SYS_getsid => syscall_match_arm!(SYS_getsid, args, a0), + super::SYS_capget => unimplemented!("WALI syscall 'capget' (125) unimplemented!"), + super::SYS_capset => unimplemented!("WALI syscall 'capset' (126) unimplemented!"), + super::SYS_rt_sigpending => syscall_match_arm!(SYS_rt_sigpending, args, a0, a1), + super::SYS_rt_sigtimedwait => { + unimplemented!("WALI syscall 'rt_sigtimedwait' (128) unimplemented!") + } + super::SYS_rt_sigqueueinfo => { + unimplemented!("WALI syscall 'rt_sigqueueinfo' (129) unimplemented!") + } + super::SYS_rt_sigsuspend => syscall_match_arm!(SYS_rt_sigsuspend, args, a0, a1), + super::SYS_sigaltstack => syscall_match_arm!(SYS_sigaltstack, args, a0, a1), + super::SYS_utime => syscall_match_arm!(SYS_utime, args, a0, a1), + super::SYS_mknod => unimplemented!("WALI syscall 'mknod' (133) unimplemented!"), + super::SYS_uselib => unimplemented!("WALI syscall 'uselib' (134) unimplemented!"), + super::SYS_personality => unimplemented!("WALI syscall 'personality' (135) unimplemented!"), + super::SYS_ustat => unimplemented!("WALI syscall 'ustat' (136) unimplemented!"), + super::SYS_statfs => syscall_match_arm!(SYS_statfs, args, a0, a1), + super::SYS_fstatfs => syscall_match_arm!(SYS_fstatfs, args, a0, a1), + super::SYS_sysfs => unimplemented!("WALI syscall 'sysfs' (139) unimplemented!"), + super::SYS_getpriority => unimplemented!("WALI syscall 'getpriority' (140) unimplemented!"), + super::SYS_setpriority => unimplemented!("WALI syscall 'setpriority' (141) unimplemented!"), + super::SYS_sched_setparam => { + unimplemented!("WALI syscall 'sched_setparam' (142) unimplemented!") + } + super::SYS_sched_getparam => { + unimplemented!("WALI syscall 'sched_getparam' (143) unimplemented!") + } + super::SYS_sched_setscheduler => { + unimplemented!("WALI syscall 'sched_setscheduler' (144) unimplemented!") + } + super::SYS_sched_getscheduler => { + unimplemented!("WALI syscall 'sched_getscheduler' (145) unimplemented!") + } + super::SYS_sched_get_priority_max => { + unimplemented!("WALI syscall 'sched_get_priority_max' (146) unimplemented!") + } + super::SYS_sched_get_priority_min => { + unimplemented!("WALI syscall 'sched_get_priority_min' (147) unimplemented!") + } + super::SYS_sched_rr_get_interval => { + unimplemented!("WALI syscall 'sched_rr_get_interval' (148) unimplemented!") + } + super::SYS_mlock => unimplemented!("WALI syscall 'mlock' (149) unimplemented!"), + super::SYS_munlock => unimplemented!("WALI syscall 'munlock' (150) unimplemented!"), + super::SYS_mlockall => unimplemented!("WALI syscall 'mlockall' (151) unimplemented!"), + super::SYS_munlockall => unimplemented!("WALI syscall 'munlockall' (152) unimplemented!"), + super::SYS_vhangup => unimplemented!("WALI syscall 'vhangup' (153) unimplemented!"), + super::SYS_modify_ldt => unimplemented!("WALI syscall 'modify_ldt' (154) unimplemented!"), + super::SYS_pivot_root => unimplemented!("WALI syscall 'pivot_root' (155) unimplemented!"), + super::SYS__sysctl => unimplemented!("WALI syscall '_sysctl' (156) unimplemented!"), + super::SYS_prctl => syscall_match_arm!(SYS_prctl, args, a0, a1, a2, a3, a4), + super::SYS_arch_prctl => unimplemented!("WALI syscall 'arch_prctl' (158) unimplemented!"), + super::SYS_adjtimex => unimplemented!("WALI syscall 'adjtimex' (159) unimplemented!"), + super::SYS_setrlimit => syscall_match_arm!(SYS_setrlimit, args, a0, a1), + super::SYS_chroot => syscall_match_arm!(SYS_chroot, args, a0), + super::SYS_sync => unimplemented!("WALI syscall 'sync' (162) unimplemented!"), + super::SYS_acct => unimplemented!("WALI syscall 'acct' (163) unimplemented!"), + super::SYS_settimeofday => { + unimplemented!("WALI syscall 'settimeofday' (164) unimplemented!") + } + super::SYS_mount => unimplemented!("WALI syscall 'mount' (165) unimplemented!"), + super::SYS_umount2 => unimplemented!("WALI syscall 'umount2' (166) unimplemented!"), + super::SYS_swapon => unimplemented!("WALI syscall 'swapon' (167) unimplemented!"), + super::SYS_swapoff => unimplemented!("WALI syscall 'swapoff' (168) unimplemented!"), + super::SYS_reboot => unimplemented!("WALI syscall 'reboot' (169) unimplemented!"), + super::SYS_sethostname => unimplemented!("WALI syscall 'sethostname' (170) unimplemented!"), + super::SYS_setdomainname => { + unimplemented!("WALI syscall 'setdomainname' (171) unimplemented!") + } + super::SYS_iopl => unimplemented!("WALI syscall 'iopl' (172) unimplemented!"), + super::SYS_ioperm => unimplemented!("WALI syscall 'ioperm' (173) unimplemented!"), + super::SYS_create_module => { + unimplemented!("WALI syscall 'create_module' (174) unimplemented!") + } + super::SYS_init_module => unimplemented!("WALI syscall 'init_module' (175) unimplemented!"), + super::SYS_delete_module => { + unimplemented!("WALI syscall 'delete_module' (176) unimplemented!") + } + super::SYS_get_kernel_syms => { + unimplemented!("WALI syscall 'get_kernel_syms' (177) unimplemented!") + } + super::SYS_query_module => { + unimplemented!("WALI syscall 'query_module' (178) unimplemented!") + } + super::SYS_quotactl => unimplemented!("WALI syscall 'quotactl' (179) unimplemented!"), + super::SYS_nfsservctl => unimplemented!("WALI syscall 'nfsservctl' (180) unimplemented!"), + super::SYS_getpmsg => unimplemented!("WALI syscall 'getpmsg' (181) unimplemented!"), + super::SYS_putpmsg => unimplemented!("WALI syscall 'putpmsg' (182) unimplemented!"), + super::SYS_afs_syscall => unimplemented!("WALI syscall 'afs_syscall' (183) unimplemented!"), + super::SYS_tuxcall => unimplemented!("WALI syscall 'tuxcall' (184) unimplemented!"), + super::SYS_security => unimplemented!("WALI syscall 'security' (185) unimplemented!"), + super::SYS_gettid => syscall_match_arm!(SYS_gettid, args,), + super::SYS_readahead => unimplemented!("WALI syscall 'readahead' (187) unimplemented!"), + super::SYS_setxattr => unimplemented!("WALI syscall 'setxattr' (188) unimplemented!"), + super::SYS_lsetxattr => unimplemented!("WALI syscall 'lsetxattr' (189) unimplemented!"), + super::SYS_fsetxattr => unimplemented!("WALI syscall 'fsetxattr' (190) unimplemented!"), + super::SYS_getxattr => unimplemented!("WALI syscall 'getxattr' (191) unimplemented!"), + super::SYS_lgetxattr => unimplemented!("WALI syscall 'lgetxattr' (192) unimplemented!"), + super::SYS_fgetxattr => unimplemented!("WALI syscall 'fgetxattr' (193) unimplemented!"), + super::SYS_listxattr => unimplemented!("WALI syscall 'listxattr' (194) unimplemented!"), + super::SYS_llistxattr => unimplemented!("WALI syscall 'llistxattr' (195) unimplemented!"), + super::SYS_flistxattr => unimplemented!("WALI syscall 'flistxattr' (196) unimplemented!"), + super::SYS_removexattr => unimplemented!("WALI syscall 'removexattr' (197) unimplemented!"), + super::SYS_lremovexattr => { + unimplemented!("WALI syscall 'lremovexattr' (198) unimplemented!") + } + super::SYS_fremovexattr => { + unimplemented!("WALI syscall 'fremovexattr' (199) unimplemented!") + } + super::SYS_tkill => syscall_match_arm!(SYS_tkill, args, a0, a1), + super::SYS_time => unimplemented!("WALI syscall 'time' (201) unimplemented!"), + super::SYS_futex => syscall_match_arm!(SYS_futex, args, a0, a1, a2, a3, a4, a5), + super::SYS_sched_setaffinity => { + unimplemented!("WALI syscall 'sched_setaffinity' (203) unimplemented!") + } + super::SYS_sched_getaffinity => syscall_match_arm!(SYS_sched_getaffinity, args, a0, a1, a2), + super::SYS_set_thread_area => { + unimplemented!("WALI syscall 'set_thread_area' (205) unimplemented!") + } + super::SYS_io_setup => unimplemented!("WALI syscall 'io_setup' (206) unimplemented!"), + super::SYS_io_destroy => unimplemented!("WALI syscall 'io_destroy' (207) unimplemented!"), + super::SYS_io_getevents => { + unimplemented!("WALI syscall 'io_getevents' (208) unimplemented!") + } + super::SYS_io_submit => unimplemented!("WALI syscall 'io_submit' (209) unimplemented!"), + super::SYS_io_cancel => unimplemented!("WALI syscall 'io_cancel' (210) unimplemented!"), + super::SYS_get_thread_area => { + unimplemented!("WALI syscall 'get_thread_area' (211) unimplemented!") + } + super::SYS_lookup_dcookie => { + unimplemented!("WALI syscall 'lookup_dcookie' (212) unimplemented!") + } + super::SYS_epoll_create => { + unimplemented!("WALI syscall 'epoll_create' (213) unimplemented!") + } + super::SYS_epoll_ctl_old => { + unimplemented!("WALI syscall 'epoll_ctl_old' (214) unimplemented!") + } + super::SYS_epoll_wait_old => { + unimplemented!("WALI syscall 'epoll_wait_old' (215) unimplemented!") + } + super::SYS_remap_file_pages => { + unimplemented!("WALI syscall 'remap_file_pages' (216) unimplemented!") + } + super::SYS_getdents64 => syscall_match_arm!(SYS_getdents64, args, a0, a1, a2), + super::SYS_set_tid_address => syscall_match_arm!(SYS_set_tid_address, args, a0), + super::SYS_restart_syscall => { + unimplemented!("WALI syscall 'restart_syscall' (219) unimplemented!") + } + super::SYS_semtimedop => unimplemented!("WALI syscall 'semtimedop' (220) unimplemented!"), + super::SYS_fadvise => syscall_match_arm!(SYS_fadvise, args, a0, a1, a2, a3), + super::SYS_timer_create => { + unimplemented!("WALI syscall 'timer_create' (222) unimplemented!") + } + super::SYS_timer_settime => { + unimplemented!("WALI syscall 'timer_settime' (223) unimplemented!") + } + super::SYS_timer_gettime => { + unimplemented!("WALI syscall 'timer_gettime' (224) unimplemented!") + } + super::SYS_timer_getoverrun => { + unimplemented!("WALI syscall 'timer_getoverrun' (225) unimplemented!") + } + super::SYS_timer_delete => { + unimplemented!("WALI syscall 'timer_delete' (226) unimplemented!") + } + super::SYS_clock_settime => { + unimplemented!("WALI syscall 'clock_settime' (227) unimplemented!") + } + super::SYS_clock_gettime => syscall_match_arm!(SYS_clock_gettime, args, a0, a1), + super::SYS_clock_getres => syscall_match_arm!(SYS_clock_getres, args, a0, a1), + super::SYS_clock_nanosleep => syscall_match_arm!(SYS_clock_nanosleep, args, a0, a1, a2, a3), + super::SYS_exit_group => syscall_match_arm!(SYS_exit_group, args, a0), + super::SYS_epoll_wait => unimplemented!("WALI syscall 'epoll_wait' (232) unimplemented!"), + super::SYS_epoll_ctl => syscall_match_arm!(SYS_epoll_ctl, args, a0, a1, a2, a3), + super::SYS_tgkill => unimplemented!("WALI syscall 'tgkill' (234) unimplemented!"), + super::SYS_utimes => unimplemented!("WALI syscall 'utimes' (235) unimplemented!"), + super::SYS_vserver => unimplemented!("WALI syscall 'vserver' (236) unimplemented!"), + super::SYS_mbind => unimplemented!("WALI syscall 'mbind' (237) unimplemented!"), + super::SYS_set_mempolicy => { + unimplemented!("WALI syscall 'set_mempolicy' (238) unimplemented!") + } + super::SYS_get_mempolicy => { + unimplemented!("WALI syscall 'get_mempolicy' (239) unimplemented!") + } + super::SYS_mq_open => unimplemented!("WALI syscall 'mq_open' (240) unimplemented!"), + super::SYS_mq_unlink => unimplemented!("WALI syscall 'mq_unlink' (241) unimplemented!"), + super::SYS_mq_timedsend => { + unimplemented!("WALI syscall 'mq_timedsend' (242) unimplemented!") + } + super::SYS_mq_timedreceive => { + unimplemented!("WALI syscall 'mq_timedreceive' (243) unimplemented!") + } + super::SYS_mq_notify => unimplemented!("WALI syscall 'mq_notify' (244) unimplemented!"), + super::SYS_mq_getsetattr => { + unimplemented!("WALI syscall 'mq_getsetattr' (245) unimplemented!") + } + super::SYS_kexec_load => unimplemented!("WALI syscall 'kexec_load' (246) unimplemented!"), + super::SYS_waitid => unimplemented!("WALI syscall 'waitid' (247) unimplemented!"), + super::SYS_add_key => unimplemented!("WALI syscall 'add_key' (248) unimplemented!"), + super::SYS_request_key => unimplemented!("WALI syscall 'request_key' (249) unimplemented!"), + super::SYS_keyctl => unimplemented!("WALI syscall 'keyctl' (250) unimplemented!"), + super::SYS_ioprio_set => unimplemented!("WALI syscall 'ioprio_set' (251) unimplemented!"), + super::SYS_ioprio_get => unimplemented!("WALI syscall 'ioprio_get' (252) unimplemented!"), + super::SYS_inotify_init => { + unimplemented!("WALI syscall 'inotify_init' (253) unimplemented!") + } + super::SYS_inotify_add_watch => { + unimplemented!("WALI syscall 'inotify_add_watch' (254) unimplemented!") + } + super::SYS_inotify_rm_watch => { + unimplemented!("WALI syscall 'inotify_rm_watch' (255) unimplemented!") + } + super::SYS_migrate_pages => { + unimplemented!("WALI syscall 'migrate_pages' (256) unimplemented!") + } + super::SYS_openat => syscall_match_arm!(SYS_openat, args, a0, a1, a2, a3), + super::SYS_mkdirat => syscall_match_arm!(SYS_mkdirat, args, a0, a1, a2), + super::SYS_mknodat => unimplemented!("WALI syscall 'mknodat' (259) unimplemented!"), + super::SYS_fchownat => syscall_match_arm!(SYS_fchownat, args, a0, a1, a2, a3, a4), + super::SYS_futimesat => unimplemented!("WALI syscall 'futimesat' (261) unimplemented!"), + super::SYS_newfstatat => syscall_match_arm!(SYS_fstatat, args, a0, a1, a2, a3), + super::SYS_unlinkat => syscall_match_arm!(SYS_unlinkat, args, a0, a1, a2), + super::SYS_renameat => unimplemented!("WALI syscall 'renameat' (264) unimplemented!"), + super::SYS_linkat => syscall_match_arm!(SYS_linkat, args, a0, a1, a2, a3, a4), + super::SYS_symlinkat => syscall_match_arm!(SYS_symlinkat, args, a0, a1, a2), + super::SYS_readlinkat => syscall_match_arm!(SYS_readlinkat, args, a0, a1, a2, a3), + super::SYS_fchmodat => syscall_match_arm!(SYS_fchmodat, args, a0, a1, a2, a3), + super::SYS_faccessat => syscall_match_arm!(SYS_faccessat, args, a0, a1, a2, a3), + super::SYS_pselect6 => syscall_match_arm!(SYS_pselect6, args, a0, a1, a2, a3, a4, a5), + super::SYS_ppoll => syscall_match_arm!(SYS_ppoll, args, a0, a1, a2, a3, a4), + super::SYS_unshare => unimplemented!("WALI syscall 'unshare' (272) unimplemented!"), + super::SYS_set_robust_list => { + unimplemented!("WALI syscall 'set_robust_list' (273) unimplemented!") + } + super::SYS_get_robust_list => { + unimplemented!("WALI syscall 'get_robust_list' (274) unimplemented!") + } + super::SYS_splice => unimplemented!("WALI syscall 'splice' (275) unimplemented!"), + super::SYS_tee => unimplemented!("WALI syscall 'tee' (276) unimplemented!"), + super::SYS_sync_file_range => { + unimplemented!("WALI syscall 'sync_file_range' (277) unimplemented!") + } + super::SYS_vmsplice => unimplemented!("WALI syscall 'vmsplice' (278) unimplemented!"), + super::SYS_move_pages => unimplemented!("WALI syscall 'move_pages' (279) unimplemented!"), + super::SYS_utimensat => syscall_match_arm!(SYS_utimensat, args, a0, a1, a2, a3), + super::SYS_epoll_pwait => syscall_match_arm!(SYS_epoll_pwait, args, a0, a1, a2, a3, a4, a5), + super::SYS_signalfd => unimplemented!("WALI syscall 'signalfd' (282) unimplemented!"), + super::SYS_timerfd_create => { + unimplemented!("WALI syscall 'timerfd_create' (283) unimplemented!") + } + super::SYS_eventfd => syscall_match_arm!(SYS_eventfd, args, a0), + super::SYS_fallocate => unimplemented!("WALI syscall 'fallocate' (285) unimplemented!"), + super::SYS_timerfd_settime => { + unimplemented!("WALI syscall 'timerfd_settime' (286) unimplemented!") + } + super::SYS_timerfd_gettime => { + unimplemented!("WALI syscall 'timerfd_gettime' (287) unimplemented!") + } + super::SYS_accept4 => syscall_match_arm!(SYS_accept4, args, a0, a1, a2, a3), + super::SYS_signalfd4 => unimplemented!("WALI syscall 'signalfd4' (289) unimplemented!"), + super::SYS_eventfd2 => syscall_match_arm!(SYS_eventfd2, args, a0, a1), + super::SYS_epoll_create1 => syscall_match_arm!(SYS_epoll_create1, args, a0), + super::SYS_dup3 => syscall_match_arm!(SYS_dup3, args, a0, a1, a2), + super::SYS_pipe2 => syscall_match_arm!(SYS_pipe2, args, a0, a1), + super::SYS_inotify_init1 => { + unimplemented!("WALI syscall 'inotify_init1' (294) unimplemented!") + } + super::SYS_preadv => unimplemented!("WALI syscall 'preadv' (295) unimplemented!"), + super::SYS_pwritev => unimplemented!("WALI syscall 'pwritev' (296) unimplemented!"), + super::SYS_rt_tgsigqueueinfo => { + unimplemented!("WALI syscall 'rt_tgsigqueueinfo' (297) unimplemented!") + } + super::SYS_perf_event_open => { + unimplemented!("WALI syscall 'perf_event_open' (298) unimplemented!") + } + super::SYS_recvmmsg => unimplemented!("WALI syscall 'recvmmsg' (299) unimplemented!"), + super::SYS_fanotify_init => { + unimplemented!("WALI syscall 'fanotify_init' (300) unimplemented!") + } + super::SYS_fanotify_mark => { + unimplemented!("WALI syscall 'fanotify_mark' (301) unimplemented!") + } + super::SYS_prlimit64 => syscall_match_arm!(SYS_prlimit64, args, a0, a1, a2, a3), + super::SYS_name_to_handle_at => { + unimplemented!("WALI syscall 'name_to_handle_at' (303) unimplemented!") + } + super::SYS_open_by_handle_at => { + unimplemented!("WALI syscall 'open_by_handle_at' (304) unimplemented!") + } + super::SYS_clock_adjtime => { + unimplemented!("WALI syscall 'clock_adjtime' (305) unimplemented!") + } + super::SYS_syncfs => unimplemented!("WALI syscall 'syncfs' (306) unimplemented!"), + super::SYS_sendmmsg => unimplemented!("WALI syscall 'sendmmsg' (307) unimplemented!"), + super::SYS_setns => unimplemented!("WALI syscall 'setns' (308) unimplemented!"), + super::SYS_getcpu => unimplemented!("WALI syscall 'getcpu' (309) unimplemented!"), + super::SYS_process_vm_readv => { + unimplemented!("WALI syscall 'process_vm_readv' (310) unimplemented!") + } + super::SYS_process_vm_writev => { + unimplemented!("WALI syscall 'process_vm_writev' (311) unimplemented!") + } + super::SYS_kcmp => unimplemented!("WALI syscall 'kcmp' (312) unimplemented!"), + super::SYS_finit_module => { + unimplemented!("WALI syscall 'finit_module' (313) unimplemented!") + } + super::SYS_sched_setattr => { + unimplemented!("WALI syscall 'sched_setattr' (314) unimplemented!") + } + super::SYS_sched_getattr => { + unimplemented!("WALI syscall 'sched_getattr' (315) unimplemented!") + } + super::SYS_renameat2 => syscall_match_arm!(SYS_renameat2, args, a0, a1, a2, a3, a4), + super::SYS_seccomp => unimplemented!("WALI syscall 'seccomp' (317) unimplemented!"), + super::SYS_getrandom => syscall_match_arm!(SYS_getrandom, args, a0, a1, a2), + super::SYS_memfd_create => { + unimplemented!("WALI syscall 'memfd_create' (319) unimplemented!") + } + super::SYS_kexec_file_load => { + unimplemented!("WALI syscall 'kexec_file_load' (320) unimplemented!") + } + super::SYS_bpf => unimplemented!("WALI syscall 'bpf' (321) unimplemented!"), + super::SYS_execveat => unimplemented!("WALI syscall 'execveat' (322) unimplemented!"), + super::SYS_userfaultfd => unimplemented!("WALI syscall 'userfaultfd' (323) unimplemented!"), + super::SYS_membarrier => unimplemented!("WALI syscall 'membarrier' (324) unimplemented!"), + super::SYS_mlock2 => unimplemented!("WALI syscall 'mlock2' (325) unimplemented!"), + super::SYS_copy_file_range => { + unimplemented!("WALI syscall 'copy_file_range' (326) unimplemented!") + } + super::SYS_preadv2 => unimplemented!("WALI syscall 'preadv2' (327) unimplemented!"), + super::SYS_pwritev2 => unimplemented!("WALI syscall 'pwritev2' (328) unimplemented!"), + super::SYS_pkey_mprotect => { + unimplemented!("WALI syscall 'pkey_mprotect' (329) unimplemented!") + } + super::SYS_pkey_alloc => unimplemented!("WALI syscall 'pkey_alloc' (330) unimplemented!"), + super::SYS_pkey_free => unimplemented!("WALI syscall 'pkey_free' (331) unimplemented!"), + super::SYS_statx => syscall_match_arm!(SYS_statx, args, a0, a1, a2, a3, a4), + super::SYS_io_pgetevents => { + unimplemented!("WALI syscall 'io_pgetevents' (333) unimplemented!") + } + super::SYS_rseq => unimplemented!("WALI syscall 'rseq' (334) unimplemented!"), + super::SYS_faccessat2 => syscall_match_arm!(SYS_faccessat2, args, a0, a1, a2, a3), + _ => unimplemented!("WALI syscall number {} out-of-scope!", num), + } +} diff --git a/src/unix/linux_like/linux/musl/mod.rs b/src/unix/linux_like/linux/musl/mod.rs index 699c8181f8466..424121921dd03 100644 --- a/src/unix/linux_like/linux/musl/mod.rs +++ b/src/unix/linux_like/linux/musl/mod.rs @@ -918,7 +918,9 @@ cfg_if! { target_arch = "powerpc64", target_arch = "s390x", target_arch = "riscv64", - target_arch = "loongarch64"))] { + target_arch = "loongarch64", + // wasm32-linux uses the WALI specification with 64-bit struct layout + target_arch = "wasm32"))] { mod b64; pub use self::b64::*; } else if #[cfg(any(target_arch = "x86",