#![allow(dead_code)]
use core::arch::asm;
pub type Fd = i32;
#[cfg(target_arch = "x86_64")]
pub mod nr {
pub const READ: usize = 0;
pub const WRITE: usize = 1;
pub const OPEN: usize = 2;
pub const CLOSE: usize = 3;
pub const POLL: usize = 7;
pub const MMAP: usize = 9;
pub const MUNMAP: usize = 11;
pub const IOCTL: usize = 16;
pub const NANOSLEEP: usize = 35;
pub const SOCKET: usize = 41;
pub const CONNECT: usize = 42;
pub const SENDMSG: usize = 46;
pub const RECVMSG: usize = 47;
pub const FTRUNCATE: usize = 77;
pub const FUTEX: usize = 202;
pub const CLOCK_GETTIME: usize = 228;
pub const MEMFD_CREATE: usize = 319;
}
#[cfg(target_arch = "aarch64")]
pub mod nr {
pub const READ: usize = 63;
pub const WRITE: usize = 64;
pub const OPENAT: usize = 56;
pub const CLOSE: usize = 57;
pub const PPOLL: usize = 73;
pub const MMAP: usize = 222;
pub const MUNMAP: usize = 215;
pub const IOCTL: usize = 29;
pub const NANOSLEEP: usize = 101;
pub const SOCKET: usize = 198;
pub const CONNECT: usize = 203;
pub const SENDMSG: usize = 211;
pub const RECVMSG: usize = 212;
pub const FTRUNCATE: usize = 46;
pub const FUTEX: usize = 98;
pub const CLOCK_GETTIME: usize = 113;
pub const MEMFD_CREATE: usize = 279;
}
#[cfg(target_arch = "x86_64")]
#[inline(always)]
pub unsafe fn syscall6(n: usize, a: usize, b: usize, c: usize, d: usize, e: usize, f: usize) -> isize {
let ret: isize;
unsafe {
asm!("syscall", inlateout("rax") n as isize => ret, in("rdi") a, in("rsi") b, in("rdx") c,
in("r10") d, in("r8") e, in("r9") f, lateout("rcx") _, lateout("r11") _,
options(nostack));
}
ret
}
#[cfg(target_arch = "aarch64")]
#[inline(always)]
pub unsafe fn syscall6(n: usize, a: usize, b: usize, c: usize, d: usize, e: usize, f: usize) -> isize {
let ret: isize;
unsafe {
asm!("svc 0", in("x8") n, inlateout("x0") a as isize => ret, in("x1") b, in("x2") c,
in("x3") d, in("x4") e, in("x5") f, options(nostack));
}
ret
}
#[inline(always)]
pub unsafe fn syscall0(n: usize) -> isize { unsafe { syscall6(n, 0, 0, 0, 0, 0, 0) } }
#[inline(always)]
pub unsafe fn syscall1(n: usize, a: usize) -> isize { unsafe { syscall6(n, a, 0, 0, 0, 0, 0) } }
#[inline(always)]
pub unsafe fn syscall2(n: usize, a: usize, b: usize) -> isize { unsafe { syscall6(n, a, b, 0, 0, 0, 0) } }
#[inline(always)]
pub unsafe fn syscall3(n: usize, a: usize, b: usize, c: usize) -> isize { unsafe { syscall6(n, a, b, c, 0, 0, 0) } }
#[inline(always)]
pub unsafe fn syscall4(n: usize, a: usize, b: usize, c: usize, d: usize) -> isize { unsafe { syscall6(n, a, b, c, d, 0, 0) } }
pub const EINTR: isize = -4;
pub const EAGAIN: isize = -11;
#[repr(C)]
#[derive(Clone, Copy, Default)]
pub struct Timespec { pub sec: i64, pub nsec: i64 }
#[repr(C)]
#[derive(Clone, Copy, Default)]
pub struct PollFd { pub fd: i32, pub events: i16, pub revents: i16 }
pub const POLLIN: i16 = 1;
pub const POLLERR: i16 = 8;
pub const POLLHUP: i16 = 16;
#[inline] pub fn pollin() -> i16 { POLLIN }
#[inline] pub fn pollerr() -> i16 { POLLERR }
#[inline] pub fn pollhup() -> i16 { POLLHUP }
#[repr(C)]
pub struct IoVec { pub base: *mut u8, pub len: usize }
#[repr(C)]
pub struct MsgHdr {
pub name: *mut u8, pub namelen: u32,
pub iov: *mut IoVec, pub iovlen: usize,
pub control: *mut u8, pub controllen: usize,
pub flags: i32,
}
#[repr(C)]
pub struct SockAddrUn { pub family: u16, pub path: [u8; 108] }
pub const AF_UNIX: usize = 1;
pub const SOCK_STREAM: usize = 1;
pub const SOCK_CLOEXEC: usize = 0o2000000;
pub const SOL_SOCKET: i32 = 1;
pub const SCM_RIGHTS: i32 = 1;
pub const MSG_NOSIGNAL: usize = 0x4000;
pub const MSG_DONTWAIT: usize = 0x40;
pub const MSG_CMSG_CLOEXEC: usize = 0x40000000;
pub const PROT_READ: usize = 1;
pub const PROT_WRITE: usize = 2;
pub const MAP_SHARED: usize = 1;
pub const MAP_PRIVATE: usize = 2;
pub const MAP_ANONYMOUS: usize = 0x20;
pub const MFD_CLOEXEC: usize = 1;
pub const CLOCK_MONOTONIC: usize = 1;
pub const FUTEX_WAIT: usize = 0;
pub const FUTEX_WAKE: usize = 1;
pub const FUTEX_PRIVATE: usize = 128;
pub fn read(fd: Fd, buf: &mut [u8]) -> isize {
unsafe { syscall3(nr::READ, fd as usize, buf.as_mut_ptr() as usize, buf.len()) }
}
pub fn write(fd: Fd, buf: &[u8]) -> isize {
unsafe { syscall3(nr::WRITE, fd as usize, buf.as_ptr() as usize, buf.len()) }
}
pub fn write_all(fd: Fd, mut buf: &[u8]) -> bool {
while !buf.is_empty() {
let n = write(fd, buf);
if n == EINTR || n == EAGAIN { continue; }
if n <= 0 { return false; }
buf = &buf[n as usize..];
}
true
}
pub fn close(fd: Fd) { unsafe { syscall1(nr::CLOSE, fd as usize); } }
pub fn open_read(path: &[u8]) -> Fd {
let mut p = [0u8; 256];
if path.len() >= p.len() { return -1; }
p[..path.len()].copy_from_slice(path);
#[cfg(target_arch = "x86_64")]
{ unsafe { syscall3(nr::OPEN, p.as_ptr() as usize, 0o2000000, 0) as Fd } }
#[cfg(target_arch = "aarch64")]
{ unsafe { syscall4(nr::OPENAT, -100isize as usize, p.as_ptr() as usize, 0o2000000, 0) as Fd } }
}
pub fn poll(fds: &mut [PollFd], timeout_ms: i32) -> isize {
#[cfg(target_arch = "x86_64")]
{ unsafe { syscall3(nr::POLL, fds.as_mut_ptr() as usize, fds.len(), timeout_ms as isize as usize) } }
#[cfg(target_arch = "aarch64")]
{
let ts = Timespec { sec: (timeout_ms / 1000) as i64, nsec: ((timeout_ms % 1000) as i64) * 1_000_000 };
let tp = if timeout_ms < 0 { 0 } else { &ts as *const _ as usize };
unsafe { syscall6(nr::PPOLL, fds.as_mut_ptr() as usize, fds.len(), tp, 0, 0, 0) }
}
}
pub fn mmap(len: usize, prot: usize, flags: usize, fd: Fd, off: usize) -> *mut u8 {
let r = unsafe { syscall6(nr::MMAP, 0, len, prot, flags, fd as isize as usize, off) };
if r < 0 && r > -4096 { core::ptr::null_mut() } else { r as *mut u8 }
}
pub fn munmap(p: *mut u8, len: usize) { unsafe { syscall2(nr::MUNMAP, p as usize, len); } }
pub fn ftruncate(fd: Fd, len: usize) -> isize { unsafe { syscall2(nr::FTRUNCATE, fd as usize, len) } }
pub fn memfd_create(name: &[u8]) -> Fd {
let mut p = [0u8; 64];
p[..name.len().min(63)].copy_from_slice(&name[..name.len().min(63)]);
unsafe { syscall2(nr::MEMFD_CREATE, p.as_ptr() as usize, MFD_CLOEXEC) as Fd }
}
pub fn ioctl(fd: Fd, req: usize, arg: usize) -> isize { unsafe { syscall3(nr::IOCTL, fd as usize, req, arg) } }
pub fn socket_unix() -> Fd { unsafe { syscall3(nr::SOCKET, AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0) as Fd } }
pub fn connect_unix(fd: Fd, path: &[u8]) -> bool {
let mut sa = SockAddrUn { family: AF_UNIX as u16, path: [0; 108] };
if path.len() > 107 { return false; }
sa.path[..path.len()].copy_from_slice(path);
let len = 2 + path.len() + if path[0] == 0 { 0 } else { 1 };
unsafe { syscall3(nr::CONNECT, fd as usize, &sa as *const _ as usize, len) == 0 }
}
pub fn send_with_fds(fd: Fd, data: &[u8], fds: &[Fd]) -> bool {
let mut iov = IoVec { base: data.as_ptr() as *mut u8, len: data.len() };
let mut cbuf = [0u64; 4]; let mut hdr = MsgHdr { name: core::ptr::null_mut(), namelen: 0, iov: &mut iov, iovlen: 1,
control: core::ptr::null_mut(), controllen: 0, flags: 0 };
if !fds.is_empty() {
let clen = 16 + 4 * fds.len();
let cb = cbuf.as_mut_ptr() as *mut u8;
unsafe {
*(cb as *mut usize) = clen; *(cb.add(8) as *mut i32) = SOL_SOCKET; *(cb.add(12) as *mut i32) = SCM_RIGHTS; for (i, f) in fds.iter().enumerate() { *(cb.add(16 + 4 * i) as *mut i32) = *f; }
}
hdr.control = cb;
hdr.controllen = (clen + 7) & !7;
}
let mut sent = 0usize;
loop {
let r = unsafe { syscall3(nr::SENDMSG, fd as usize, &hdr as *const _ as usize, MSG_NOSIGNAL) };
if r == EINTR || r == EAGAIN { continue; }
if r < 0 { return false; }
sent += r as usize;
if sent >= data.len() { return true; }
return write_all(fd, &data[sent..]);
}
}
pub fn recv_with_fds(fd: Fd, buf: &mut [u8], fds_out: &mut Vec<Fd>, nonblock: bool) -> isize {
let mut iov = IoVec { base: buf.as_mut_ptr(), len: buf.len() };
let mut cbuf = [0u64; 36]; let mut hdr = MsgHdr { name: core::ptr::null_mut(), namelen: 0, iov: &mut iov, iovlen: 1,
control: cbuf.as_mut_ptr() as *mut u8, controllen: 288, flags: 0 };
let flags = MSG_CMSG_CLOEXEC | if nonblock { MSG_DONTWAIT } else { 0 };
let r = loop {
let r = unsafe { syscall3(nr::RECVMSG, fd as usize, &mut hdr as *mut _ as usize, flags) };
if r == EINTR { continue; }
break r;
};
if r > 0 && hdr.controllen >= 16 {
let cb = cbuf.as_ptr() as *const u8;
let mut off = 0usize;
while off + 16 <= hdr.controllen {
let clen = unsafe { *(cb.add(off) as *const usize) };
let level = unsafe { *(cb.add(off + 8) as *const i32) };
let ty = unsafe { *(cb.add(off + 12) as *const i32) };
if clen < 16 { break; }
if level == SOL_SOCKET && ty == SCM_RIGHTS {
let n = (clen - 16) / 4;
for i in 0..n { fds_out.push(unsafe { *(cb.add(off + 16 + 4 * i) as *const i32) }); }
}
off += (clen + 7) & !7;
}
}
r
}
pub fn clock_monotonic_ns() -> u64 {
let mut ts = Timespec::default();
unsafe { syscall2(nr::CLOCK_GETTIME, CLOCK_MONOTONIC, &mut ts as *mut _ as usize); }
ts.sec as u64 * 1_000_000_000 + ts.nsec as u64
}
pub fn nanosleep_ns(ns: u64) {
let ts = Timespec { sec: (ns / 1_000_000_000) as i64, nsec: (ns % 1_000_000_000) as i64 };
unsafe { syscall2(nr::NANOSLEEP, &ts as *const _ as usize, 0); }
}
pub fn futex_wait(addr: &core::sync::atomic::AtomicU32, expected: u32, timeout_ns: u64) {
let ts = Timespec { sec: (timeout_ns / 1_000_000_000) as i64, nsec: (timeout_ns % 1_000_000_000) as i64 };
let tp = if timeout_ns == 0 { 0 } else { &ts as *const _ as usize };
unsafe { syscall4(nr::FUTEX, addr as *const _ as usize, FUTEX_WAIT | FUTEX_PRIVATE, expected as usize, tp); }
}
pub fn futex_wake(addr: &core::sync::atomic::AtomicU32, n: usize) {
unsafe { syscall3(nr::FUTEX, addr as *const _ as usize, FUTEX_WAKE | FUTEX_PRIVATE, n); }
}
pub fn getenv(name: &str) -> Option<String> { std::env::var(name).ok() }