#![allow(clippy::cast_possible_truncation)]
#![allow(clippy::cast_possible_wrap)]
#![allow(clippy::cast_sign_loss)]
#![allow(clippy::missing_errors_doc)]
#![allow(clippy::missing_safety_doc)]
#![allow(clippy::similar_names)]
#![allow(clippy::wildcard_imports)]
extern crate alloc;
use crate::c_str::CString;
use crate::path::Path;
use crate::syscalls::*;
use crate::sysno::*;
use crate::types::*;
pub unsafe fn accept(
sockfd: i32,
addr: &mut sockaddr_in_t,
addrlen: &mut socklen_t,
) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let addr_ptr = addr as *mut sockaddr_in_t as usize;
let addrlen_ptr = addrlen as *mut socklen_t as usize;
syscall3(SYS_ACCEPT, sockfd, addr_ptr, addrlen_ptr).map(drop)
}
pub unsafe fn access<P: AsRef<Path>>(filename: P, mode: i32) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let mode = mode as usize;
syscall2(SYS_ACCESS, filename_ptr, mode).map(drop)
}
pub unsafe fn acct<P: AsRef<Path>>(filename: P) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
syscall1(SYS_ACCT, filename_ptr).map(drop)
}
pub unsafe fn bind(sockfd: i32, addr: &sockaddr_in_t, addrlen: socklen_t) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let addr_ptr = addr as *const sockaddr_in_t as usize;
let addrlen = addrlen as usize;
syscall3(SYS_BIND, sockfd, addr_ptr, addrlen).map(drop)
}
pub unsafe fn chdir<P: AsRef<Path>>(filename: P) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
syscall1(SYS_CHDIR, filename_ptr).map(drop)
}
pub unsafe fn chmod<P: AsRef<Path>>(filename: P, mode: mode_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let mode = mode as usize;
syscall2(SYS_CHMOD, filename_ptr, mode).map(drop)
}
pub unsafe fn chown<P: AsRef<Path>>(filename: P, user: uid_t, group: gid_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let user = user as usize;
let group = group as usize;
syscall3(SYS_CHOWN, filename_ptr, user, group).map(drop)
}
pub unsafe fn chroot<P: AsRef<Path>>(filename: P) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
syscall1(SYS_CHROOT, filename_ptr).map(drop)
}
pub unsafe fn close(fd: i32) -> Result<(), Errno> {
let fd = fd as usize;
syscall1(SYS_CLOSE, fd).map(drop)
}
pub unsafe fn connect(sockfd: i32, addr: &sockaddr_in_t, addrlen: socklen_t) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let addr_ptr = addr as *const sockaddr_in_t as usize;
let addrlen = addrlen as usize;
syscall3(SYS_CONNECT, sockfd, addr_ptr, addrlen).map(drop)
}
pub unsafe fn dup(oldfd: i32) -> Result<i32, Errno> {
let oldfd = oldfd as usize;
syscall1(SYS_DUP, oldfd).map(|ret| ret as i32)
}
pub unsafe fn dup2(oldfd: i32, newfd: i32) -> Result<(), Errno> {
let oldfd = oldfd as usize;
let newfd = newfd as usize;
syscall2(SYS_DUP2, oldfd, newfd).map(drop)
}
pub unsafe fn execve<P: AsRef<Path>>(
filename: P,
argv: &[&str],
env: &[&str],
) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let argv_ptr = argv.as_ptr() as usize;
let env_ptr = env.as_ptr() as usize;
syscall3(SYS_EXECVE, filename_ptr, argv_ptr, env_ptr).map(drop)
}
pub unsafe fn exit(status: i32) -> ! {
let status = status as usize;
let _ret = syscall1(SYS_EXIT, status);
unreachable!();
}
pub unsafe fn faccessat<P: AsRef<Path>>(dfd: i32, filename: P, mode: i32) -> Result<(), Errno> {
let dfd = dfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let mode = mode as usize;
syscall3(SYS_FACCESSAT, dfd, filename_ptr, mode).map(drop)
}
pub unsafe fn fchdir(fd: i32) -> Result<(), Errno> {
let fd = fd as usize;
syscall1(SYS_FCHDIR, fd).map(drop)
}
pub unsafe fn fchmod(fd: i32, mode: mode_t) -> Result<(), Errno> {
let fd = fd as usize;
let mode = mode as usize;
syscall2(SYS_FCHMOD, fd, mode).map(drop)
}
pub unsafe fn fchmodat<P: AsRef<Path>>(dirfd: i32, filename: P, mode: mode_t) -> Result<(), Errno> {
let dirfd = dirfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let mode = mode as usize;
syscall3(SYS_FCHMODAT, dirfd, filename_ptr, mode).map(drop)
}
pub unsafe fn fchown(fd: i32, user: uid_t, group: gid_t) -> Result<(), Errno> {
let fd = fd as usize;
let user = user as usize;
let group = group as usize;
syscall3(SYS_FCHOWN, fd, user, group).map(drop)
}
pub unsafe fn fchownat<P: AsRef<Path>>(
dirfd: i32,
filename: P,
user: uid_t,
group: gid_t,
flag: i32,
) -> Result<(), Errno> {
let dirfd = dirfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let user = user as usize;
let group = group as usize;
let flag = flag as usize;
syscall5(SYS_FCHOWNAT, dirfd, filename_ptr, user, group, flag).map(drop)
}
pub unsafe fn fcntl(fd: i32, cmd: i32, arg: usize) -> Result<i32, Errno> {
let fd = fd as usize;
let cmd = cmd as usize;
syscall3(SYS_FCNTL, fd, cmd, arg).map(|ret| ret as i32)
}
pub unsafe fn fdatasync(fd: i32) -> Result<(), Errno> {
let fd = fd as usize;
syscall1(SYS_FDATASYNC, fd).map(drop)
}
pub unsafe fn fgetxattr<P: AsRef<Path>>(
fd: i32,
name: P,
value: usize,
size: size_t,
) -> Result<ssize_t, Errno> {
let fd = fd as usize;
let name = CString::new(name.as_ref());
let name_ptr = name.as_ptr() as usize;
syscall4(SYS_FGETXATTR, fd, name_ptr, value, size).map(|ret| ret as ssize_t)
}
pub unsafe fn flistxattr(fd: i32, list: usize, size: size_t) -> Result<ssize_t, Errno> {
let fd = fd as usize;
syscall3(SYS_FLISTXATTR, fd, list, size).map(|ret| ret as ssize_t)
}
pub unsafe fn flock(fd: i32, operation: i32) -> Result<(), Errno> {
let fd = fd as usize;
let operation = operation as usize;
syscall2(SYS_FLOCK, fd, operation).map(drop)
}
pub unsafe fn fork() -> Result<pid_t, Errno> {
syscall0(SYS_FORK).map(|ret| ret as pid_t)
}
pub unsafe fn fremovexattr<P: AsRef<Path>>(fd: i32, name: P) -> Result<(), Errno> {
let fd = fd as usize;
let name = CString::new(name.as_ref());
let name_ptr = name.as_ptr() as usize;
syscall2(SYS_FREMOVEXATTR, fd, name_ptr).map(drop)
}
pub unsafe fn fsetxattr<P: AsRef<Path>>(
fd: i32,
name: P,
value: usize,
size: size_t,
flags: i32,
) -> Result<(), Errno> {
let fd = fd as usize;
let name = CString::new(name.as_ref());
let name_ptr = name.as_ptr() as usize;
let flags = flags as usize;
syscall5(SYS_FSETXATTR, fd, name_ptr, value, size, flags).map(drop)
}
pub unsafe fn fstat(fd: i32, statbuf: &mut stat_t) -> Result<(), Errno> {
let fd = fd as usize;
let statbuf_ptr = statbuf as *mut stat_t as usize;
syscall2(SYS_FSTAT, fd, statbuf_ptr).map(drop)
}
pub unsafe fn fstat64(fd: i32, statbuf: &mut stat64_t) -> Result<(), Errno> {
let fd = fd as usize;
let statbuf_ptr = statbuf as *mut stat64_t as usize;
syscall2(SYS_FSTAT64, fd, statbuf_ptr).map(drop)
}
pub unsafe fn fstatat<P: AsRef<Path>>(
dfd: i32,
filename: P,
statbuf: &mut stat_t,
flag: i32,
) -> Result<(), Errno> {
let dfd = dfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let statbuf_ptr = statbuf as *mut stat_t as usize;
let flag = flag as usize;
syscall4(SYS_FSTATAT, dfd, filename_ptr, statbuf_ptr, flag).map(drop)
}
pub unsafe fn fstatat64<P: AsRef<Path>>(
dfd: i32,
filename: P,
statbuf: &mut stat64_t,
flag: i32,
) -> Result<(), Errno> {
let dfd = dfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let statbuf_ptr = statbuf as *mut stat64_t as usize;
let flag = flag as usize;
syscall4(SYS_FSTATAT64, dfd, filename_ptr, statbuf_ptr, flag).map(drop)
}
pub unsafe fn fstatfs(fd: i32, buf: &mut statfs_t) -> Result<(), Errno> {
let fd = fd as usize;
let buf_ptr = buf as *mut statfs_t as usize;
syscall2(SYS_FSTATFS, fd, buf_ptr).map(drop)
}
pub unsafe fn fstatfs64(fd: i32, buf: &mut statfs64_t) -> Result<(), Errno> {
let fd = fd as usize;
let buf_ptr = buf as *mut statfs64_t as usize;
syscall2(SYS_FSTATFS64, fd, buf_ptr).map(drop)
}
pub unsafe fn fsync(fd: i32) -> Result<(), Errno> {
let fd = fd as usize;
syscall1(SYS_FSYNC, fd).map(drop)
}
pub unsafe fn ftruncate(fd: i32, length: off_t) -> Result<(), Errno> {
let fd = fd as usize;
let length = length as usize;
syscall2(SYS_FTRUNCATE, fd, length).map(drop)
}
#[must_use]
pub unsafe fn getegid() -> gid_t {
syscall0(SYS_GETEGID).expect("getegid() failed") as gid_t
}
#[must_use]
pub unsafe fn geteuid() -> uid_t {
syscall0(SYS_GETEUID).expect("geteuid() failed") as uid_t
}
#[must_use]
pub unsafe fn getgid() -> gid_t {
syscall0(SYS_GETGID).expect("getgid() failed") as gid_t
}
pub unsafe fn getgroups(size: i32, group_list: &mut [gid_t]) -> Result<i32, Errno> {
let size = size as usize;
let group_ptr = group_list.as_mut_ptr() as usize;
syscall2(SYS_GETGROUPS, size, group_ptr).map(|ret| ret as i32)
}
pub unsafe fn getitimer(which: i32, curr_val: &mut itimerval_t) -> Result<(), Errno> {
let which = which as usize;
let curr_val_ptr = curr_val as *mut itimerval_t as usize;
syscall2(SYS_GETITIMER, which, curr_val_ptr).map(drop)
}
pub unsafe fn getpeername(
sockfd: i32,
addr: &mut sockaddr_in_t,
addrlen: &mut socklen_t,
) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let addr_ptr = addr as *mut sockaddr_in_t as usize;
let addrlen_ptr = addrlen as *mut socklen_t as usize;
syscall3(SYS_GETPEERNAME, sockfd, addr_ptr, addrlen_ptr).map(drop)
}
pub unsafe fn getpgid(pid: pid_t) -> Result<pid_t, Errno> {
let pid = pid as usize;
syscall1(SYS_GETPGID, pid).map(|ret| ret as pid_t)
}
#[must_use]
pub unsafe fn getpgrp() -> pid_t {
syscall0(SYS_GETPGRP).expect("getpgrp() failed") as pid_t
}
#[must_use]
pub unsafe fn getpid() -> pid_t {
syscall0(SYS_GETPID).expect("getpid() failed") as pid_t
}
#[must_use]
pub unsafe fn getppid() -> pid_t {
syscall0(SYS_GETPPID).expect("getppid() failed") as pid_t
}
pub unsafe fn getpriority(which: i32, who: i32) -> Result<i32, Errno> {
let which = which as usize;
let who = who as usize;
syscall2(SYS_GETPRIORITY, which, who).map(|ret| {
let ret = ret as i32;
if ret > PRIO_MAX {
return PRIO_MAX - ret;
}
ret
})
}
pub unsafe fn getrlimit(resource: i32, rlim: &mut rlimit_t) -> Result<(), Errno> {
let resource = resource as usize;
let rlim_ptr = rlim as *mut rlimit_t as usize;
syscall2(SYS_GETRLIMIT, resource, rlim_ptr).map(drop)
}
pub unsafe fn getrusage(who: i32, usage: &mut rusage_t) -> Result<(), Errno> {
let who = who as usize;
let usage_ptr = usage as *mut rusage_t as usize;
syscall2(SYS_GETRUSAGE, who, usage_ptr).map(drop)
}
#[must_use]
pub unsafe fn getsid(pid: pid_t) -> pid_t {
let pid = pid as usize;
syscall1(SYS_GETSID, pid).expect("getsid() failed") as pid_t
}
pub unsafe fn getsockname(
sockfd: i32,
addr: &mut sockaddr_in_t,
addrlen: &mut socklen_t,
) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let addr_ptr = addr as *mut sockaddr_in_t as usize;
let addrlen_ptr = addrlen as *mut socklen_t as usize;
syscall3(SYS_GETSOCKNAME, sockfd, addr_ptr, addrlen_ptr).map(drop)
}
pub unsafe fn getsockopt(
sockfd: i32,
level: i32,
optname: i32,
optval: &mut usize,
optlen: &mut socklen_t,
) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let level = level as usize;
let optname = optname as usize;
let optval_ptr = optval as *mut usize as usize;
let optlen_ptr = optlen as *mut socklen_t as usize;
syscall5(
SYS_GETSOCKOPT,
sockfd,
level,
optname,
optval_ptr,
optlen_ptr,
)
.map(drop)
}
#[must_use]
pub unsafe fn gettid() -> pid_t {
syscall0(SYS_GETTID).expect("getpid() failed") as pid_t
}
pub unsafe fn gettimeofday(timeval: &mut timeval_t, tz: &mut timezone_t) -> Result<(), Errno> {
let timeval_ptr = timeval as *mut timeval_t as usize;
let tz_ptr = tz as *mut timezone_t as usize;
syscall2(SYS_GETTIMEOFDAY, timeval_ptr, tz_ptr).map(drop)
}
#[must_use]
pub unsafe fn getuid() -> uid_t {
syscall0(SYS_GETUID).expect("getuid() failed") as uid_t
}
pub unsafe fn getxattr<P: AsRef<Path>>(
filename: P,
name: P,
value: usize,
size: size_t,
) -> Result<ssize_t, Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let name = CString::new(name.as_ref());
let name_ptr = name.as_ptr() as usize;
syscall4(SYS_GETXATTR, filename_ptr, name_ptr, value, size).map(|ret| ret as ssize_t)
}
pub unsafe fn ioctl(fd: i32, cmd: i32, arg: usize) -> Result<(), Errno> {
let fd = fd as usize;
let cmd = cmd as usize;
syscall3(SYS_IOCTL, fd, cmd, arg).map(drop)
}
pub unsafe fn kill(pid: pid_t, signal: i32) -> Result<(), Errno> {
let pid = pid as usize;
let signal = signal as usize;
syscall2(SYS_KILL, pid, signal).map(drop)
}
pub unsafe fn lchown<P: AsRef<Path>>(filename: P, user: uid_t, group: gid_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let user = user as usize;
let group = group as usize;
syscall3(SYS_LCHOWN, filename_ptr, user, group).map(drop)
}
pub unsafe fn link<P: AsRef<Path>>(old_filename: P, new_filename: P) -> Result<(), Errno> {
let old_filename = CString::new(old_filename.as_ref());
let old_filename_ptr = old_filename.as_ptr() as usize;
let new_filename = CString::new(new_filename.as_ref());
let new_filename_ptr = new_filename.as_ptr() as usize;
syscall2(SYS_LINK, old_filename_ptr, new_filename_ptr).map(drop)
}
pub unsafe fn linkat<P: AsRef<Path>>(
olddfd: i32,
oldfilename: P,
newdfd: i32,
newfilename: P,
flags: i32,
) -> Result<(), Errno> {
let olddfd = olddfd as usize;
let oldfilename = CString::new(oldfilename.as_ref());
let oldfilename_ptr = oldfilename.as_ptr() as usize;
let newdfd = newdfd as usize;
let newfilename = CString::new(newfilename.as_ref());
let newfilename_ptr = newfilename.as_ptr() as usize;
let flags = flags as usize;
syscall5(
SYS_LINKAT,
olddfd,
oldfilename_ptr,
newdfd,
newfilename_ptr,
flags,
)
.map(drop)
}
pub unsafe fn listen(sockfd: i32, backlog: i32) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let backlog = backlog as usize;
syscall2(SYS_LISTEN, sockfd, backlog).map(drop)
}
pub unsafe fn listxattr<P: AsRef<Path>>(
filename: P,
list: usize,
size: size_t,
) -> Result<ssize_t, Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
syscall3(SYS_LISTXATTR, filename_ptr, list, size).map(|ret| ret as ssize_t)
}
pub unsafe fn lseek(fd: i32, offset: off_t, whence: i32) -> Result<(), Errno> {
let fd = fd as usize;
let offset = offset as usize;
let whence = whence as usize;
syscall3(SYS_LSEEK, fd, offset, whence).map(drop)
}
pub unsafe fn lstat<P: AsRef<Path>>(filename: P, statbuf: &mut stat_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let statbuf_ptr = statbuf as *mut stat_t as usize;
syscall2(SYS_LSTAT, filename_ptr, statbuf_ptr).map(drop)
}
pub unsafe fn lstat64<P: AsRef<Path>>(filename: P, statbuf: &mut stat64_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let statbuf_ptr = statbuf as *mut stat64_t as usize;
syscall2(SYS_LSTAT64, filename_ptr, statbuf_ptr).map(drop)
}
pub unsafe fn madvise(addr: usize, len: size_t, advice: i32) -> Result<(), Errno> {
let advice = advice as usize;
syscall3(SYS_MADVISE, addr, len, advice).map(drop)
}
pub unsafe fn mincore(start: usize, len: size_t, vec: *const u8) -> Result<(), Errno> {
let vec_ptr = vec as usize;
syscall3(SYS_MINCORE, start, len, vec_ptr).map(drop)
}
pub unsafe fn mkdir<P: AsRef<Path>>(filename: P, mode: mode_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let mode = mode as usize;
syscall2(SYS_MKDIR, filename_ptr, mode).map(drop)
}
pub unsafe fn mkdirat<P: AsRef<Path>>(dirfd: i32, filename: P, mode: mode_t) -> Result<(), Errno> {
let dirfd = dirfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let mode = mode as usize;
syscall3(SYS_MKDIRAT, dirfd, filename_ptr, mode).map(drop)
}
pub unsafe fn mknod<P: AsRef<Path>>(filename: P, mode: mode_t, dev: dev_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let mode = mode as usize;
let dev = dev as usize;
syscall3(SYS_MKNOD, filename_ptr, mode, dev).map(drop)
}
pub unsafe fn mlock(addr: usize, len: size_t) -> Result<(), Errno> {
syscall2(SYS_MLOCK, addr, len).map(drop)
}
pub unsafe fn mlockall(flags: i32) -> Result<(), Errno> {
let flags = flags as usize;
syscall1(SYS_MLOCKALL, flags).map(drop)
}
pub unsafe fn mmap(
start: usize,
len: size_t,
prot: i32,
flags: i32,
fd: i32,
offset: off_t,
) -> Result<usize, Errno> {
let prot = prot as usize;
let flags = flags as usize;
let fd = fd as usize;
let offset = offset as usize;
syscall6(SYS_MMAP, start, len, prot, flags, fd, offset)
}
pub unsafe fn mount<P: AsRef<Path>>(
dev_name: P,
dir_name: P,
fs_type: P,
flags: usize,
data: usize,
) -> Result<(), Errno> {
let dev_name = CString::new(dev_name.as_ref());
let dev_name_ptr = dev_name.as_ptr() as usize;
let dir_name = CString::new(dir_name.as_ref());
let dir_name_ptr = dir_name.as_ptr() as usize;
let fs_type = CString::new(fs_type.as_ref());
let fs_type_ptr = fs_type.as_ptr() as usize;
syscall5(
SYS_MOUNT,
dev_name_ptr,
dir_name_ptr,
fs_type_ptr,
flags,
data,
)
.map(drop)
}
pub unsafe fn mprotect(addr: usize, len: size_t, prot: i32) -> Result<(), Errno> {
let prot = prot as usize;
syscall3(SYS_MPROTECT, addr, len, prot).map(drop)
}
pub unsafe fn msgctl(msqid: i32, cmd: i32, buf: &mut msqid_ds_t) -> Result<i32, Errno> {
let msqid = msqid as usize;
let cmd = cmd as usize;
let buf_ptr = buf as *mut msqid_ds_t as usize;
syscall3(SYS_MSGCTL, msqid, cmd, buf_ptr).map(|ret| ret as i32)
}
pub unsafe fn msgget(key: key_t, msgflg: i32) -> Result<i32, Errno> {
let key = key as usize;
let msgflg = msgflg as usize;
syscall2(SYS_MSGGET, key, msgflg).map(|ret| ret as i32)
}
pub unsafe fn msgrcv(
msqid: i32,
msgq: usize,
msgsz: size_t,
msgtyp: isize,
msgflg: i32,
) -> Result<ssize_t, Errno> {
let msqid = msqid as usize;
let msgtyp = msgtyp as usize;
let msgflg = msgflg as usize;
syscall5(SYS_MSGRCV, msqid, msgq, msgsz, msgtyp, msgflg).map(|ret| ret as ssize_t)
}
pub unsafe fn msgsnd(msqid: i32, msgq: usize, msgsz: size_t, msgflg: i32) -> Result<(), Errno> {
let msqid = msqid as usize;
let msgflg = msgflg as usize;
syscall4(SYS_MSGSND, msqid, msgq, msgsz, msgflg).map(drop)
}
pub unsafe fn msync(addr: usize, len: size_t, flags: i32) -> Result<(), Errno> {
let flags = flags as usize;
syscall3(SYS_MSYNC, addr, len, flags).map(drop)
}
pub unsafe fn munlock(addr: usize, len: size_t) -> Result<(), Errno> {
syscall2(SYS_MUNLOCK, addr, len).map(drop)
}
pub unsafe fn munlockall() -> Result<(), Errno> {
syscall0(SYS_MUNLOCKALL).map(drop)
}
pub unsafe fn munmap(addr: usize, len: size_t) -> Result<(), Errno> {
syscall2(SYS_MUNMAP, addr, len).map(drop)
}
pub unsafe fn open<P: AsRef<Path>>(filename: P, flags: i32, mode: mode_t) -> Result<i32, Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let flags = flags as usize;
let mode = mode as usize;
syscall3(SYS_OPEN, filename_ptr, flags, mode).map(|ret| ret as i32)
}
pub unsafe fn openat<P: AsRef<Path>>(
dirfd: i32,
filename: P,
flags: i32,
mode: mode_t,
) -> Result<i32, Errno> {
let dirfd = dirfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let flags = flags as usize;
let mode = mode as usize;
syscall4(SYS_OPENAT, dirfd, filename_ptr, flags, mode).map(|ret| ret as i32)
}
pub unsafe fn pipe(pipefd: &mut [i32; 2]) -> Result<(), Errno> {
let pipefd_ptr = pipefd.as_mut_ptr() as usize;
syscall1(SYS_PIPE, pipefd_ptr).map(drop)
}
pub unsafe fn pivot_root<P: AsRef<Path>>(new_root: P, put_old: P) -> Result<(), Errno> {
let new_root = CString::new(new_root.as_ref());
let new_root_ptr = new_root.as_ptr() as usize;
let put_old = CString::new(put_old.as_ref());
let put_old_ptr = put_old.as_ptr() as usize;
syscall2(SYS_PIVOT_ROOT, new_root_ptr, put_old_ptr).map(drop)
}
pub unsafe fn poll(fds: &mut [pollfd_t], timeout: i32) -> Result<(), Errno> {
let fds_ptr = fds.as_mut_ptr() as usize;
let nfds = fds.len();
let timeout = timeout as usize;
syscall3(SYS_POLL, fds_ptr, nfds, timeout).map(drop)
}
pub unsafe fn preadv(
fd: i32,
vec: &mut [iovec_t],
pos_l: usize,
pos_h: usize,
) -> Result<ssize_t, Errno> {
let fd = fd as usize;
let vec_ptr = vec.as_mut_ptr() as usize;
let vec_len = vec.len();
syscall5(SYS_PREADV, fd, vec_ptr, vec_len, pos_l, pos_h).map(|ret| ret as ssize_t)
}
pub unsafe fn ptrace(request: i32, pid: pid_t, addr: usize, data: usize) -> Result<isize, Errno> {
let request = request as usize;
let pid = pid as usize;
syscall4(SYS_PTRACE, request, pid, addr, data).map(|ret| ret as isize)
}
pub unsafe fn pwritev(
fd: i32,
vec: &[iovec_t],
pos_l: usize,
pos_h: usize,
) -> Result<ssize_t, Errno> {
let fd = fd as usize;
let vec_ptr = vec.as_ptr() as usize;
let vec_len = vec.len();
syscall5(SYS_PWRITEV, fd, vec_ptr, vec_len, pos_l, pos_h).map(|ret| ret as ssize_t)
}
pub unsafe fn quotactl<P: AsRef<Path>>(
path: P,
cmd: i32,
id: i32,
addr: usize,
) -> Result<(), Errno> {
let path = CString::new(path.as_ref());
let path_ptr = path.as_ptr() as usize;
let cmd = cmd as usize;
let id = id as usize;
syscall4(SYS_QUOTACTL, path_ptr, cmd, id, addr).map(drop)
}
pub unsafe fn read(fd: i32, buf_ptr: usize, count: size_t) -> Result<ssize_t, Errno> {
let fd = fd as usize;
syscall3(SYS_READ, fd, buf_ptr, count).map(|ret| ret as ssize_t)
}
pub unsafe fn readlink<P: AsRef<Path>>(
filename: P,
buf: &mut [u8],
buf_len: size_t,
) -> Result<ssize_t, Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let buf_ptr = buf.as_mut_ptr() as usize;
syscall3(SYS_READLINK, filename_ptr, buf_ptr, buf_len).map(|ret| ret as ssize_t)
}
pub unsafe fn readlinkat<P: AsRef<Path>>(
dirfd: i32,
filename: P,
buf: &mut [u8],
buf_len: size_t,
) -> Result<ssize_t, Errno> {
let dirfd = dirfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let buf_ptr = buf.as_mut_ptr() as usize;
syscall4(SYS_READLINKAT, dirfd, filename_ptr, buf_ptr, buf_len).map(|ret| ret as ssize_t)
}
pub unsafe fn readv(fd: i32, iov: &mut [iovec_t]) -> Result<ssize_t, Errno> {
let fd = fd as usize;
let iov_ptr = iov.as_mut_ptr() as usize;
let len = iov.len();
syscall3(SYS_READV, fd, iov_ptr, len).map(|ret| ret as ssize_t)
}
pub unsafe fn reboot(magic: i32, magci2: i32, cmd: u32, arg: usize) -> Result<(), Errno> {
let magic = magic as usize;
let magic2 = magci2 as usize;
let cmd = cmd as usize;
syscall4(SYS_REBOOT, magic, magic2, cmd, arg).map(drop)
}
pub unsafe fn recvfrom(
sockfd: i32,
buf: &mut [u8],
flags: i32,
src_addr: &mut sockaddr_in_t,
addrlen: &mut socklen_t,
) -> Result<ssize_t, Errno> {
let sockfd = sockfd as usize;
let buf_ptr = buf.as_mut_ptr() as usize;
let buflen = buf.len();
let flags = flags as usize;
let src_addr_ptr = src_addr as *mut sockaddr_in_t as usize;
let addrlen_ptr = addrlen as *mut socklen_t as usize;
syscall6(
SYS_RECVFROM,
sockfd,
buf_ptr,
buflen,
flags,
src_addr_ptr,
addrlen_ptr,
)
.map(|ret| ret as ssize_t)
}
pub unsafe fn recvmsg(sockfd: i32, msg: &mut msghdr_t, flags: i32) -> Result<ssize_t, Errno> {
let sockfd = sockfd as usize;
let msg_ptr = msg as *mut msghdr_t as usize;
let flags = flags as usize;
syscall3(SYS_RECVMSG, sockfd, msg_ptr, flags).map(|ret| ret as ssize_t)
}
pub unsafe fn removexattr<P: AsRef<Path>>(filename: P, name: P) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let name = CString::new(name.as_ref());
let name_ptr = name.as_ptr() as usize;
syscall2(SYS_REMOVEXATTR, filename_ptr, name_ptr).map(drop)
}
pub unsafe fn rename<P: AsRef<Path>>(oldfilename: P, newfilename: P) -> Result<(), Errno> {
let oldfilename = CString::new(oldfilename.as_ref());
let oldfilename_ptr = oldfilename.as_ptr() as usize;
let newfilename = CString::new(newfilename.as_ref());
let newfilename_ptr = newfilename.as_ptr() as usize;
syscall2(SYS_RENAME, oldfilename_ptr, newfilename_ptr).map(drop)
}
pub unsafe fn renameat<P: AsRef<Path>>(
olddfd: i32,
oldfilename: P,
newdfd: i32,
newfilename: P,
) -> Result<(), Errno> {
let olddfd = olddfd as usize;
let oldfilename = CString::new(oldfilename.as_ref());
let oldfilename_ptr = oldfilename.as_ptr() as usize;
let newdfd = newdfd as usize;
let newfilename = CString::new(newfilename.as_ref());
let newfilename_ptr = newfilename.as_ptr() as usize;
syscall4(
SYS_RENAMEAT,
olddfd,
oldfilename_ptr,
newdfd,
newfilename_ptr,
)
.map(drop)
}
pub unsafe fn rmdir<P: AsRef<Path>>(filename: P) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
syscall1(SYS_RMDIR, filename_ptr).map(drop)
}
pub unsafe fn select(
nfds: i32,
readfds: &mut fd_set_t,
writefds: &mut fd_set_t,
exceptfds: &mut fd_set_t,
timeout: &mut timeval_t,
) -> Result<i32, Errno> {
let nfds = nfds as usize;
let readfds_ptr = readfds as *mut fd_set_t as usize;
let writefds_ptr = writefds as *mut fd_set_t as usize;
let exceptfds_ptr = exceptfds as *mut fd_set_t as usize;
let timeout_ptr = timeout as *mut timeval_t as usize;
syscall5(
SYS_SELECT,
nfds,
readfds_ptr,
writefds_ptr,
exceptfds_ptr,
timeout_ptr,
)
.map(|ret| ret as i32)
}
pub unsafe fn semctl(semid: i32, semnum: i32, cmd: i32, arg: usize) -> Result<i32, Errno> {
let semid = semid as usize;
let semnum = semnum as usize;
let cmd = cmd as usize;
syscall4(SYS_SEMCTL, semid, semnum, cmd, arg).map(|ret| ret as i32)
}
pub unsafe fn semget(key: key_t, nsems: i32, semflg: i32) -> Result<i32, Errno> {
let key = key as usize;
let nsems = nsems as usize;
let semflg = semflg as usize;
syscall3(SYS_SEMGET, key, nsems, semflg).map(|ret| ret as i32)
}
pub unsafe fn semop(semid: i32, sops: &mut [sembuf_t]) -> Result<(), Errno> {
let semid = semid as usize;
let sops_ptr = sops.as_ptr() as usize;
let nops = sops.len();
syscall3(SYS_SEMOP, semid, sops_ptr, nops).map(drop)
}
pub unsafe fn sendfile(
out_fd: i32,
in_fd: i32,
offset: &mut off_t,
count: size_t,
) -> Result<ssize_t, Errno> {
let out_fd = out_fd as usize;
let in_fd = in_fd as usize;
let offset_ptr = offset as *mut off_t as usize;
syscall4(SYS_SENDFILE, out_fd, in_fd, offset_ptr, count).map(|ret| ret as ssize_t)
}
pub unsafe fn sendmsg(sockfd: i32, msg: &msghdr_t, flags: i32) -> Result<ssize_t, Errno> {
let sockfd = sockfd as usize;
let msg_ptr = msg as *const msghdr_t as usize;
let flags = flags as usize;
syscall3(SYS_SENDMSG, sockfd, msg_ptr, flags).map(|ret| ret as ssize_t)
}
pub unsafe fn sendto(
sockfd: i32,
buf: &[u8],
len: size_t,
flags: i32,
dest_addr: &sockaddr_in_t,
addrlen: socklen_t,
) -> Result<ssize_t, Errno> {
let sockfd = sockfd as usize;
let buf_ptr = buf.as_ptr() as usize;
let flags = flags as usize;
let dest_addr_ptr = dest_addr as *const sockaddr_in_t as usize;
let addrlen = addrlen as usize;
syscall6(
SYS_SENDTO,
sockfd,
buf_ptr,
len,
flags,
dest_addr_ptr,
addrlen,
)
.map(|ret| ret as ssize_t)
}
pub unsafe fn setgid(gid: gid_t) -> Result<(), Errno> {
let gid = gid as usize;
syscall1(SYS_SETGID, gid).map(drop)
}
pub unsafe fn setgroups(group_list: &[gid_t]) -> Result<(), Errno> {
let group_len = group_list.len();
let group_ptr = group_list.as_ptr() as usize;
syscall2(SYS_SETGROUPS, group_len, group_ptr).map(drop)
}
pub unsafe fn setitimer(
which: i32,
new_val: &itimerval_t,
old_val: &mut itimerval_t,
) -> Result<(), Errno> {
let which = which as usize;
let new_val_ptr = new_val as *const itimerval_t as usize;
let old_val_ptr = old_val as *mut itimerval_t as usize;
syscall3(SYS_SETITIMER, which, new_val_ptr, old_val_ptr).map(drop)
}
pub unsafe fn setpgid(pid: pid_t, pgid: pid_t) -> Result<(), Errno> {
let pid = pid as usize;
let pgid = pgid as usize;
syscall2(SYS_SETPGID, pid, pgid).map(drop)
}
pub unsafe fn setpriority(which: i32, who: i32, prio: i32) -> Result<(), Errno> {
let which = which as usize;
let who = who as usize;
let prio = prio as usize;
syscall3(SYS_SETPRIORITY, which, who, prio).map(drop)
}
pub unsafe fn setregid(rgid: gid_t, egid: gid_t) -> Result<(), Errno> {
let rgid = rgid as usize;
let egid = egid as usize;
syscall2(SYS_SETREGID, rgid, egid).map(drop)
}
pub unsafe fn setreuid(ruid: uid_t, euid: uid_t) -> Result<(), Errno> {
let ruid = ruid as usize;
let euid = euid as usize;
syscall2(SYS_SETREUID, ruid, euid).map(drop)
}
pub unsafe fn setrlimit(resource: i32, rlimit: &rlimit_t) -> Result<(), Errno> {
let resource = resource as usize;
let rlimit_ptr = rlimit as *const rlimit_t as usize;
syscall2(SYS_SETRLIMIT, resource, rlimit_ptr).map(drop)
}
pub unsafe fn setsid() -> Result<pid_t, Errno> {
syscall0(SYS_SETSID).map(|ret| ret as pid_t)
}
pub unsafe fn setsockopt(
sockfd: i32,
level: i32,
optname: i32,
optval: usize,
optlen: socklen_t,
) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let level = level as usize;
let optname = optname as usize;
let optlen = optlen as usize;
syscall5(SYS_SETSOCKOPT, sockfd, level, optname, optval, optlen).map(drop)
}
pub unsafe fn settimeofday(timeval: &timeval_t, tz: &timezone_t) -> Result<(), Errno> {
let timeval_ptr = timeval as *const timeval_t as usize;
let tz_ptr = tz as *const timezone_t as usize;
syscall2(SYS_SETTIMEOFDAY, timeval_ptr, tz_ptr).map(drop)
}
pub unsafe fn setuid(uid: uid_t) -> Result<(), Errno> {
let uid = uid as usize;
syscall1(SYS_SETUID, uid).map(drop)
}
pub unsafe fn setxattr<P: AsRef<Path>>(
filename: P,
name: P,
value: usize,
size: size_t,
flags: i32,
) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let name = CString::new(name.as_ref());
let name_ptr = name.as_ptr() as usize;
let flags = flags as usize;
syscall5(SYS_SETXATTR, filename_ptr, name_ptr, value, size, flags).map(drop)
}
pub unsafe fn shmat(shmid: i32, shmaddr: usize, shmflg: i32) -> Result<usize, Errno> {
let shmid = shmid as usize;
let shmflg = shmflg as usize;
syscall3(SYS_SHMAT, shmid, shmaddr, shmflg)
}
pub unsafe fn shmctl(shmid: i32, cmd: i32, buf: &mut shmid_ds_t) -> Result<i32, Errno> {
let shmid = shmid as usize;
let cmd = cmd as usize;
let buf_ptr = buf as *mut shmid_ds_t as usize;
syscall3(SYS_SHMCTL, shmid, cmd, buf_ptr).map(|ret| ret as i32)
}
pub unsafe fn shmdt(shmaddr: usize) -> Result<(), Errno> {
syscall1(SYS_SHMDT, shmaddr).map(drop)
}
pub unsafe fn shmget(key: key_t, size: size_t, shmflg: i32) -> Result<i32, Errno> {
let key = key as usize;
let shmflg = shmflg as usize;
syscall3(SYS_SHMGET, key, size, shmflg).map(|ret| ret as i32)
}
pub unsafe fn shutdown(sockfd: i32, how: i32) -> Result<(), Errno> {
let sockfd = sockfd as usize;
let how = how as usize;
syscall2(SYS_SHUTDOWN, sockfd, how).map(drop)
}
pub unsafe fn sigaction(
sig: i32,
act: &sigaction_t,
old_act: &mut sigaction_t,
) -> Result<(), Errno> {
let sig = sig as usize;
let act_ptr = act as *const sigaction_t as usize;
let old_act_ptr = old_act as *mut sigaction_t as usize;
syscall3(SYS_SIGACTION, sig, act_ptr, old_act_ptr).map(drop)
}
pub unsafe fn sigaltstack(uss: &sigaltstack_t, uoss: &mut sigaltstack_t) -> Result<(), Errno> {
let uss_ptr = uss as *const sigaltstack_t as usize;
let uoss_ptr = uoss as *mut sigaltstack_t as usize;
syscall2(SYS_SIGALTSTACK, uss_ptr, uoss_ptr).map(drop)
}
pub unsafe fn sigpending(set: &mut sigset_t) -> Result<(), Errno> {
let set_ptr = set as *mut sigset_t as usize;
syscall1(SYS_SIGPENDING, set_ptr).map(drop)
}
pub unsafe fn sigprocmask(
how: i32,
newset: &mut sigset_t,
oldset: &mut sigset_t,
) -> Result<(), Errno> {
let how = how as usize;
let newset_ptr = newset as *mut sigset_t as usize;
let oldset_ptr = oldset as *mut sigset_t as usize;
syscall3(SYS_SIGPROCMASK, how, newset_ptr, oldset_ptr).map(drop)
}
pub unsafe fn sigreturn() {
let _ = syscall0(SYS_SIGRETURN);
}
pub unsafe fn sigsuspend(mask: &old_sigset_t) -> Result<(), Errno> {
let mask_ptr = mask as *const old_sigset_t as usize;
syscall1(SYS_SIGSUSPEND, mask_ptr).map(drop)
}
pub unsafe fn socket(domain: i32, sock_type: i32, protocol: i32) -> Result<i32, Errno> {
let domain = domain as usize;
let sock_type = sock_type as usize;
let protocol = protocol as usize;
syscall3(SYS_SOCKET, domain, sock_type, protocol).map(|ret| ret as i32)
}
pub unsafe fn socketpair(
domain: i32,
type_: i32,
protocol: i32,
sv: [i32; 2],
) -> Result<(), Errno> {
let domain = domain as usize;
let type_ = type_ as usize;
let protocol = protocol as usize;
let sv_ptr = sv.as_ptr() as usize;
syscall4(SYS_SOCKETPAIR, domain, type_, protocol, sv_ptr).map(drop)
}
pub unsafe fn stat<P: AsRef<Path>>(filename: P, statbuf: &mut stat_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let statbuf_ptr = statbuf as *mut stat_t as usize;
syscall2(SYS_STAT, filename_ptr, statbuf_ptr).map(drop)
}
pub unsafe fn stat64<P: AsRef<Path>>(filename: P, statbuf: &mut stat64_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let statbuf_ptr = statbuf as *mut stat64_t as usize;
syscall2(SYS_STAT64, filename_ptr, statbuf_ptr).map(drop)
}
pub unsafe fn statfs<P: AsRef<Path>>(filename: P, buf: &mut statfs_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let buf_ptr = buf as *mut statfs_t as usize;
syscall2(SYS_STATFS, filename_ptr, buf_ptr).map(drop)
}
pub unsafe fn statfs64<P: AsRef<Path>>(filename: P, buf: &mut statfs64_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let buf_ptr = buf as *mut statfs64_t as usize;
syscall2(SYS_STATFS64, filename_ptr, buf_ptr).map(drop)
}
pub unsafe fn swapon<P: AsRef<Path>>(filename: P, flags: i32) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let flags = flags as usize;
syscall2(SYS_SWAPON, filename_ptr, flags).map(drop)
}
pub unsafe fn symlink<P: AsRef<Path>>(oldname: P, newname: P) -> Result<(), Errno> {
let oldname = CString::new(oldname.as_ref());
let oldname_ptr = oldname.as_ptr() as usize;
let newname = CString::new(newname.as_ref());
let newname_ptr = newname.as_ptr() as usize;
syscall2(SYS_SYMLINK, oldname_ptr, newname_ptr).map(drop)
}
pub unsafe fn symlinkat<P: AsRef<Path>>(
oldname: P,
newdirfd: i32,
newname: P,
) -> Result<(), Errno> {
let oldname = CString::new(oldname.as_ref());
let oldname_ptr = oldname.as_ptr() as usize;
let newname = CString::new(newname.as_ref());
let newname_ptr = newname.as_ptr() as usize;
let newdirfd = newdirfd as usize;
syscall3(SYS_SYMLINKAT, oldname_ptr, newdirfd, newname_ptr).map(drop)
}
pub unsafe fn sync() -> Result<(), Errno> {
syscall0(SYS_SYNC).map(drop)
}
pub unsafe fn truncate<P: AsRef<Path>>(filename: P, length: off_t) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let length = length as usize;
syscall2(SYS_TRUNCATE, filename_ptr, length).map(drop)
}
pub unsafe fn umask(mode: mode_t) -> Result<mode_t, Errno> {
let mode = mode as usize;
syscall1(SYS_UMASK, mode).map(|ret| ret as mode_t)
}
pub unsafe fn unlink<P: AsRef<Path>>(filename: P) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
syscall1(SYS_UNLINK, filename_ptr).map(drop)
}
pub unsafe fn unlinkat<P: AsRef<Path>>(dfd: i32, filename: P, flag: i32) -> Result<(), Errno> {
let dfd = dfd as usize;
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let flag = flag as usize;
syscall3(SYS_UNLINKAT, dfd, filename_ptr, flag).map(drop)
}
pub unsafe fn utimes<P: AsRef<Path>>(filename: P, times: &[timeval_t; 2]) -> Result<(), Errno> {
let filename = CString::new(filename.as_ref());
let filename_ptr = filename.as_ptr() as usize;
let times_ptr = times.as_ptr() as usize;
syscall2(SYS_UTIMES, filename_ptr, times_ptr).map(drop)
}
pub unsafe fn vfork() -> Result<pid_t, Errno> {
syscall0(SYS_VFORK).map(|ret| ret as pid_t)
}
pub unsafe fn wait4(
pid: pid_t,
wstatus: &mut i32,
options: i32,
rusage: &mut rusage_t,
) -> Result<pid_t, Errno> {
let pid = pid as usize;
let wstatus_ptr = wstatus as *mut i32 as usize;
let options = options as usize;
let rusage_ptr = rusage as *mut rusage_t as usize;
syscall4(SYS_WAIT4, pid, wstatus_ptr, options, rusage_ptr).map(|ret| ret as pid_t)
}
pub unsafe fn waitid(
which: i32,
pid: pid_t,
info: &mut siginfo_t,
options: i32,
ru: &mut rusage_t,
) -> Result<(), Errno> {
let which = which as usize;
let pid = pid as usize;
let info_ptr = info as *mut siginfo_t as usize;
let options = options as usize;
let ru_ptr = ru as *mut rusage_t as usize;
syscall5(SYS_WAITID, which, pid, info_ptr, options, ru_ptr).map(drop)
}
pub unsafe fn write(fd: i32, buf_ptr: usize, count: size_t) -> Result<ssize_t, Errno> {
let fd = fd as usize;
syscall3(SYS_WRITE, fd, buf_ptr, count).map(|ret| ret as ssize_t)
}
pub unsafe fn writev(fd: i32, iov: &[iovec_t]) -> Result<ssize_t, Errno> {
let fd = fd as usize;
let iov_ptr = iov.as_ptr() as usize;
let len = iov.len();
syscall3(SYS_WRITEV, fd, iov_ptr, len).map(|ret| ret as ssize_t)
}