mirror of
https://github.com/fluencelabs/wasmer
synced 2025-03-16 00:00:49 +00:00
refactor everything
This commit is contained in:
parent
8432ce9238
commit
7c9e537443
9
Cargo.lock
generated
9
Cargo.lock
generated
@ -1,5 +1,3 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
[[package]]
|
||||
name = "MacTypes-sys"
|
||||
version = "2.1.0"
|
||||
@ -1543,7 +1541,7 @@ dependencies = [
|
||||
"tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"uuid 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"uuid 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@ -2125,7 +2123,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
name = "uuid"
|
||||
version = "0.7.2"
|
||||
version = "0.7.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -2310,6 +2308,7 @@ version = "0.2.1"
|
||||
dependencies = [
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"hashbrown 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"tar 0.4.22 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"tempdir 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"wasmer-runtime-core 0.2.1",
|
||||
@ -2752,7 +2751,7 @@ dependencies = [
|
||||
"checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
|
||||
"checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
|
||||
"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
|
||||
"checksum uuid 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0238db0c5b605dd1cf51de0f21766f97fba2645897024461d6a00c036819a768"
|
||||
"checksum uuid 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "600ef8213e9f8a0ac1f876e470e90780ae0478eabce7f76aff41b0f4ef0fd5c0"
|
||||
"checksum vcpkg 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "def296d3eb3b12371b2c7d0e83bfe1403e4db2d7a0bba324a12b21c4ee13143d"
|
||||
"checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
|
||||
"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
|
||||
|
@ -16,11 +16,13 @@ lazy_static = "1.2.0"
|
||||
libc = "0.2.49"
|
||||
time = "0.1.41"
|
||||
wasmer-runtime-core = { path = "../runtime-core", version = "0.2.1" }
|
||||
wasmer-runtime-abi = { path = "../runtime-abi", optional = true }
|
||||
wasmer-clif-backend = { path = "../clif-backend", version = "0.2.0" }
|
||||
wasmer-dynasm-backend = { path = "../dynasm-backend", version = "0.1.0", optional = true }
|
||||
wasmer-llvm-backend = { path = "../llvm-backend", version = "0.1.0", optional = true }
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
wasmer-runtime-abi = { path = "../runtime-abi", optional = true }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
rand = "0.6"
|
||||
|
||||
|
27
lib/emscripten/src/env/mod.rs
vendored
27
lib/emscripten/src/env/mod.rs
vendored
@ -75,30 +75,3 @@ pub fn ___assert_fail(_ctx: &mut Ctx, _a: c_int, _b: c_int, _c: c_int, _d: c_int
|
||||
// TODO: Implement like emscripten expects regarding memory/page size
|
||||
// TODO raise an error
|
||||
}
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub fn _getgrnam(ctx: &mut Ctx, name_ptr: c_int) -> c_int {
|
||||
debug!("emscripten::_getgrnam {}", name_ptr);
|
||||
#[cfg(not(feature = "debug"))]
|
||||
let _ = name_ptr;
|
||||
|
||||
#[repr(C)]
|
||||
struct GuestGroup {
|
||||
gr_name: u32,
|
||||
gr_passwd: u32,
|
||||
gr_gid: u32,
|
||||
gr_mem: u32,
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let group_struct_offset = call_malloc(ctx, std::mem::size_of::<GuestGroup>() as _);
|
||||
let group_struct_ptr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), group_struct_offset) as *mut GuestGroup;
|
||||
(*group_struct_ptr).gr_name = 0;
|
||||
(*group_struct_ptr).gr_passwd = 0;
|
||||
(*group_struct_ptr).gr_gid = 0;
|
||||
(*group_struct_ptr).gr_mem = 0;
|
||||
group_struct_offset as c_int
|
||||
}
|
||||
}
|
||||
|
2
lib/emscripten/src/env/unix/mod.rs
vendored
2
lib/emscripten/src/env/unix/mod.rs
vendored
@ -100,7 +100,6 @@ pub fn _getpwnam(ctx: &mut Ctx, name_ptr: c_int) -> c_int {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub fn _getgrnam(ctx: &mut Ctx, name_ptr: c_int) -> c_int {
|
||||
debug!("emscripten::_getgrnam {}", name_ptr);
|
||||
@ -144,7 +143,6 @@ pub fn _initgroups(_ctx: &mut Ctx, _user_offset: u32, _gid: u32) -> c_int {
|
||||
0
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
unsafe fn copy_terminated_array_of_cstrs(_ctx: &mut Ctx, cstrs: *mut *mut c_char) -> u32 {
|
||||
let _total_num = {
|
||||
let mut ptr = cstrs;
|
||||
|
1
lib/emscripten/src/env/windows/mod.rs
vendored
1
lib/emscripten/src/env/windows/mod.rs
vendored
@ -97,7 +97,6 @@ pub fn _getpwnam(ctx: &mut Ctx, name_ptr: c_int) -> c_int {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub fn _getgrnam(ctx: &mut Ctx, name_ptr: c_int) -> c_int {
|
||||
debug!("emscripten::_getgrnam {}", name_ptr);
|
||||
|
@ -54,10 +54,10 @@ pub use self::utils::{
|
||||
get_emscripten_table_size, is_emscripten_module,
|
||||
};
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(feature = "vfs", not(target_os = "windows")))]
|
||||
use crate::syscalls::EmscriptenVfs;
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(feature = "vfs", not(target_os = "windows")))]
|
||||
use wasmer_runtime_abi::vfs::vfs::Vfs;
|
||||
|
||||
// TODO: Magic number - how is this calculated?
|
||||
@ -124,7 +124,7 @@ pub struct EmscriptenData<'a> {
|
||||
pub dyn_call_vijiii: Option<Func<'a, (i32, i32, i32, i32, i32, i32, i32)>>,
|
||||
pub dyn_call_vijj: Option<Func<'a, (i32, i32, i32, i32, i32, i32)>>,
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(feature = "vfs", not(target_os = "windows")))]
|
||||
pub vfs: Option<EmscriptenVfs>,
|
||||
}
|
||||
|
||||
@ -222,7 +222,7 @@ impl<'a> EmscriptenData<'a> {
|
||||
dyn_call_viji,
|
||||
dyn_call_vijiii,
|
||||
dyn_call_vijj,
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(feature = "vfs", not(target_os = "windows")))]
|
||||
vfs: None,
|
||||
}
|
||||
}
|
||||
@ -240,7 +240,7 @@ pub fn run_emscripten_instance(
|
||||
// This is behind a feature flag for now, but will be default in the future
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
let _ = module;
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(feature = "vfs", not(target_os = "windows")))]
|
||||
{
|
||||
data.vfs = match module.info().custom_sections.get("wasmer:fs") {
|
||||
Some(bytes) => match Vfs::from_compressed_bytes(&bytes[..]) {
|
||||
|
@ -1,13 +1,6 @@
|
||||
use wasmer_runtime_core::memory::Memory;
|
||||
macro_rules! emscripten_memory_pointer {
|
||||
($memory:expr, $pointer:expr) => {{
|
||||
use std::cell::Cell;
|
||||
(&$memory.view::<u8>()[($pointer as usize)..]).as_ptr() as *mut Cell<u8> as *mut u8
|
||||
}};
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn emscripten_memory_ptr(memory: &Memory, offset: u32) -> *mut u8 {
|
||||
use std::cell::Cell;
|
||||
(&memory.view::<u8>()[(offset as usize)..]).as_ptr() as *mut Cell<u8> as *mut u8
|
||||
}
|
||||
|
@ -1,148 +1,151 @@
|
||||
use std::cmp::{Eq, Ord, Ordering, PartialEq};
|
||||
use std::cell::RefCell;
|
||||
use std::collections::BTreeMap;
|
||||
use std::fmt::Display;
|
||||
use std::io;
|
||||
use std::path::Path;
|
||||
use std::rc::Rc;
|
||||
use wasmer_runtime_abi::vfs::device_file;
|
||||
use wasmer_runtime_abi::vfs::file_like::{FileLike, Metadata};
|
||||
use wasmer_runtime_abi::vfs::vfs::Vfs;
|
||||
|
||||
pub type Fd = i32;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct VirtualFd(pub Fd);
|
||||
|
||||
impl Ord for VirtualFd {
|
||||
fn cmp(&self, other: &Self) -> Ordering {
|
||||
self.0.cmp(&other.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialOrd for VirtualFd {
|
||||
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||
Some(self.0.cmp(&other.0))
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for VirtualFd {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.0 == other.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Eq for VirtualFd {}
|
||||
|
||||
impl Display for VirtualFd {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
||||
write!(f, "Fd({})", self.0)
|
||||
}
|
||||
}
|
||||
|
||||
pub enum FileHandle {
|
||||
VirtualFile(Fd),
|
||||
Socket(Fd),
|
||||
Vf(Rc<RefCell<dyn FileLike>>),
|
||||
}
|
||||
|
||||
pub type Map<K, V> = BTreeMap<K, V>;
|
||||
pub type FdMap = Map<VirtualFd, FileHandle>;
|
||||
|
||||
pub struct EmscriptenVfs {
|
||||
pub fd_map: FdMap,
|
||||
pub fd_map: BTreeMap<i32, FileHandle>,
|
||||
pub vfs: Vfs,
|
||||
}
|
||||
|
||||
impl EmscriptenVfs {
|
||||
pub fn new(vfs: Vfs) -> Self {
|
||||
let mut fd_map = FdMap::new();
|
||||
pub fn new(mut vfs: Vfs) -> Self {
|
||||
let mut fd_map = BTreeMap::new();
|
||||
|
||||
vfs.fd_map
|
||||
.keys()
|
||||
.map(|handle| (handle, handle))
|
||||
.for_each(|(virtual_handle, handle)| {
|
||||
let vfd = VirtualFd(*virtual_handle);
|
||||
fd_map.insert(vfd, FileHandle::VirtualFile(*handle));
|
||||
});
|
||||
let stdin = Rc::new(RefCell::new(device_file::Stdin));
|
||||
vfs.create_device_file("/dev/stdin", stdin.clone());
|
||||
fd_map.insert(0, FileHandle::Vf(stdin));
|
||||
|
||||
// let _ = repo.create_dir(PathBuf::from("/dev/"));
|
||||
// let stdin = repo.create_file(PathBuf::from("/dev/stdin"))?;
|
||||
// let stdout = repo.create_file(PathBuf::from("/dev/stdout"))?;
|
||||
// let stderr = repo.create_file(PathBuf::from("/dev/stderr"))?;
|
||||
let stdout = Rc::new(RefCell::new(device_file::Stdout));
|
||||
vfs.create_device_file("/dev/stdout", stdout.clone());
|
||||
fd_map.insert(1, FileHandle::Vf(stdout));
|
||||
|
||||
let stdin_fd = VirtualFd(0);
|
||||
let stdin_handle = FileHandle::VirtualFile(0);
|
||||
let stdout_fd = VirtualFd(1);
|
||||
let stdout_handle = FileHandle::VirtualFile(1);
|
||||
let stderr_fd = VirtualFd(2);
|
||||
let stderr_handle = FileHandle::VirtualFile(2);
|
||||
|
||||
fd_map.insert(stdin_fd, stdin_handle);
|
||||
fd_map.insert(stdout_fd, stdout_handle);
|
||||
fd_map.insert(stderr_fd, stderr_handle);
|
||||
let stderr = Rc::new(RefCell::new(device_file::Stderr));
|
||||
vfs.create_device_file("/dev/stderr", stderr.clone());
|
||||
fd_map.insert(2, FileHandle::Vf(stderr));
|
||||
|
||||
EmscriptenVfs { fd_map, vfs }
|
||||
}
|
||||
|
||||
pub fn close(&mut self, vfd: &VirtualFd) -> () {
|
||||
match self.fd_map.get(&vfd) {
|
||||
Some(FileHandle::VirtualFile(handle)) => {
|
||||
self.vfs.close(handle).unwrap();
|
||||
}
|
||||
Some(FileHandle::Socket(fd)) => unsafe {
|
||||
libc::close(*fd);
|
||||
},
|
||||
None => panic!(),
|
||||
}
|
||||
self.fd_map.remove(&vfd);
|
||||
pub fn make_dir<P: AsRef<Path>>(&mut self, path: P) -> () {
|
||||
self.vfs.make_dir(path);
|
||||
}
|
||||
|
||||
pub fn next_lowest_fd(&self) -> VirtualFd {
|
||||
next_lowest(&self.fd_map)
|
||||
}
|
||||
|
||||
pub fn get_host_socket_fd(&self, vfd: &VirtualFd) -> Option<Fd> {
|
||||
match self.fd_map.get(&vfd) {
|
||||
Some(FileHandle::Socket(fd)) => {
|
||||
if *fd < 0 {
|
||||
panic!()
|
||||
}
|
||||
Some(*fd)
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_virtual_file_handle(&self, vfd: VirtualFd) -> Option<Fd> {
|
||||
match self.fd_map.get(&vfd) {
|
||||
Some(FileHandle::VirtualFile(fd)) => Some(*fd),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn open_file<P: AsRef<std::path::Path>>(&mut self, path: P) -> VirtualFd {
|
||||
let fd = self.vfs.open_file(path).unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
let file = FileHandle::VirtualFile(fd);
|
||||
self.fd_map.insert(vfd.clone(), file);
|
||||
vfd
|
||||
}
|
||||
|
||||
pub fn new_socket_fd(&mut self, host_fd: Fd) -> VirtualFd {
|
||||
let vfd = self.next_lowest_fd();
|
||||
if host_fd < 0 {
|
||||
panic!()
|
||||
}
|
||||
self.fd_map.insert(vfd.clone(), FileHandle::Socket(host_fd));
|
||||
vfd
|
||||
}
|
||||
}
|
||||
|
||||
fn next_lowest(fd_map: &FdMap) -> VirtualFd {
|
||||
let mut next_lowest_fd = 0;
|
||||
for (vfd, _) in fd_map.iter() {
|
||||
let host_fd = vfd.0;
|
||||
if host_fd == next_lowest_fd {
|
||||
next_lowest_fd += 1;
|
||||
} else if host_fd < next_lowest_fd {
|
||||
panic!("Should not be here.");
|
||||
pub fn path_metadata<P: AsRef<Path>>(&mut self, path: P) -> Option<Metadata> {
|
||||
if let Some(file) = self.vfs.open_file(path) {
|
||||
RefCell::borrow(&file).metadata().ok()
|
||||
} else {
|
||||
break;
|
||||
None
|
||||
}
|
||||
}
|
||||
VirtualFd(next_lowest_fd)
|
||||
|
||||
pub fn close_file_descriptor(&mut self, fd: i32) -> i32 {
|
||||
match self.fd_map.remove(&fd) {
|
||||
Some(FileHandle::Vf(_)) => 0,
|
||||
Some(FileHandle::Socket(fd)) => unsafe { libc::close(fd) },
|
||||
_ => -1,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn next_lowest_fd_raw(&self) -> i32 {
|
||||
let fd_map = &self.fd_map;
|
||||
let mut next_lowest_fd = 0;
|
||||
for (vfd, _) in fd_map.iter() {
|
||||
let host_fd = *vfd;
|
||||
if host_fd == next_lowest_fd {
|
||||
next_lowest_fd += 1;
|
||||
} else if host_fd < next_lowest_fd {
|
||||
panic!("Should not be here.");
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
next_lowest_fd
|
||||
}
|
||||
|
||||
pub fn get_host_socket_fd(&self, fd: i32) -> Option<Fd> {
|
||||
match self.fd_map.get(&fd) {
|
||||
Some(FileHandle::Socket(fd)) => Some(*fd),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn open_file<P: AsRef<std::path::Path>>(&mut self, path: P) -> i32 {
|
||||
match self.vfs.open_file(path) {
|
||||
Some(file) => {
|
||||
let fd = self.next_lowest_fd_raw();
|
||||
let handle = FileHandle::Vf(file);
|
||||
self.fd_map.insert(fd, handle);
|
||||
fd
|
||||
}
|
||||
None => -1,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn write_file(
|
||||
&mut self,
|
||||
fd: i32,
|
||||
buf_slice: &mut [u8],
|
||||
count: usize,
|
||||
) -> Result<usize, EmscriptenVfsError> {
|
||||
match self.fd_map.get(&fd) {
|
||||
Some(FileHandle::Vf(file)) => {
|
||||
let mut mut_ref = RefCell::borrow_mut(file);
|
||||
mut_ref
|
||||
.write_file(buf_slice, 0)
|
||||
.map_err(|e| EmscriptenVfsError::Io(e))
|
||||
}
|
||||
Some(FileHandle::Socket(host_fd)) => unsafe {
|
||||
let result = libc::write(*host_fd, buf_slice.as_ptr() as _, count as _);
|
||||
if result == -1 {
|
||||
Err(EmscriptenVfsError::Errno(errno::errno()))
|
||||
} else {
|
||||
Ok(result as usize)
|
||||
}
|
||||
},
|
||||
_ => Err(EmscriptenVfsError::FileSystemError),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_file(&self, fd: i32, buf_slice: &mut [u8]) -> usize {
|
||||
match self.fd_map.get(&fd) {
|
||||
Some(FileHandle::Vf(file)) => {
|
||||
let count = {
|
||||
let mut result = RefCell::borrow_mut(&file);
|
||||
let result = result.read(buf_slice);
|
||||
result.unwrap()
|
||||
};
|
||||
count as _
|
||||
}
|
||||
Some(FileHandle::Socket(host_fd)) => unsafe {
|
||||
let buf_addr = buf_slice.as_ptr() as _;
|
||||
libc::write(*host_fd, buf_addr, buf_slice.len()) as usize
|
||||
},
|
||||
_ => 0,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_socket_fd(&mut self, host_fd: Fd) -> Fd {
|
||||
let fd = self.next_lowest_fd_raw();
|
||||
self.fd_map.insert(fd, FileHandle::Socket(host_fd));
|
||||
fd
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum EmscriptenVfsError {
|
||||
Io(io::Error),
|
||||
Errno(errno::Errno),
|
||||
FileSystemError,
|
||||
}
|
||||
|
@ -4,7 +4,7 @@ mod unix;
|
||||
#[cfg(windows)]
|
||||
mod windows;
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(feature = "vfs", not(target_os = "windows")))]
|
||||
mod emscripten_vfs;
|
||||
|
||||
#[cfg(unix)]
|
||||
@ -13,7 +13,7 @@ pub use self::unix::*;
|
||||
#[cfg(windows)]
|
||||
pub use self::windows::*;
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(feature = "vfs", not(target_os = "windows")))]
|
||||
pub use self::emscripten_vfs::*;
|
||||
|
||||
use super::varargs::VarArgs;
|
||||
|
@ -1,7 +1,6 @@
|
||||
use crate::utils::{copy_stat_into_wasm, read_string_from_wasm};
|
||||
use crate::utils::copy_stat_into_wasm;
|
||||
use crate::varargs::VarArgs;
|
||||
use libc::{c_int, c_void, ioctl, sockaddr, socklen_t};
|
||||
use std::slice;
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
/// read
|
||||
@ -14,7 +13,6 @@ pub fn ___syscall3(ctx: &mut Ctx, _which: i32, mut varargs: VarArgs) -> i32 {
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut c_void;
|
||||
let ret = unsafe { libc::read(fd, buf_addr, count as _) };
|
||||
debug!("=> ret: {}", ret);
|
||||
debug!("read: '{}'", read_string_from_wasm(ctx.memory(0), buf));
|
||||
ret as _
|
||||
}
|
||||
|
||||
@ -27,7 +25,6 @@ pub fn ___syscall4(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int
|
||||
debug!("=> fd: {}, buf: {}, count: {}", fd, buf, count);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *const c_void;
|
||||
let ret = unsafe { libc::write(fd, buf_addr, count as _) as i32 };
|
||||
debug!("wrote: '{}'", read_string_from_wasm(ctx.memory(0), buf));
|
||||
ret
|
||||
}
|
||||
|
||||
@ -423,52 +420,16 @@ pub fn ___syscall142(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let nfds: i32 = varargs.get(ctx);
|
||||
let readfds: u32 = varargs.get(ctx);
|
||||
let writefds: u32 = varargs.get(ctx);
|
||||
let exceptfds: u32 = varargs.get(ctx);
|
||||
let _exceptfds: u32 = varargs.get(ctx);
|
||||
let _timeout: i32 = varargs.get(ctx);
|
||||
|
||||
let readfds_set_ptr = emscripten_memory_pointer!(ctx.memory(0), readfds) as *mut _;
|
||||
let readfds_set_u8_ptr = readfds_set_ptr as *mut u8;
|
||||
let writefds_set_ptr = emscripten_memory_pointer!(ctx.memory(0), writefds) as *mut _;
|
||||
let writefds_set_u8_ptr = writefds_set_ptr as *mut u8;
|
||||
|
||||
let nfds = nfds as _;
|
||||
let readfds_slice = unsafe { slice::from_raw_parts_mut(readfds_set_u8_ptr, nfds) };
|
||||
let _writefds_slice = unsafe { slice::from_raw_parts_mut(writefds_set_u8_ptr, nfds) };
|
||||
let nfds = nfds as _;
|
||||
|
||||
use bit_field::BitArray;
|
||||
|
||||
let mut bits = vec![];
|
||||
for virtual_fd in 0..nfds {
|
||||
let bit_flag = readfds_slice.get_bit(virtual_fd as usize);
|
||||
if !bit_flag {
|
||||
continue;
|
||||
}
|
||||
bits.push(virtual_fd);
|
||||
}
|
||||
|
||||
let readfds_ptr = emscripten_memory_pointer!(ctx.memory(0), readfds) as _;
|
||||
let writefds_ptr = emscripten_memory_pointer!(ctx.memory(0), writefds) as _;
|
||||
|
||||
let _err = errno::errno();
|
||||
debug!("set read descriptors BEFORE select: {:?}", bits);
|
||||
|
||||
let result = unsafe { libc::select(nfds, readfds_ptr, writefds_ptr, 0 as _, 0 as _) };
|
||||
|
||||
let mut set_file_descriptors = vec![];
|
||||
for virtual_fd in 0..nfds {
|
||||
let bit_flag = readfds_slice.get_bit(virtual_fd as usize);
|
||||
if !bit_flag {
|
||||
continue;
|
||||
}
|
||||
set_file_descriptors.push(virtual_fd);
|
||||
}
|
||||
debug!(
|
||||
"set read descriptors AFTER select: {:?}",
|
||||
set_file_descriptors
|
||||
);
|
||||
debug!("select returns {}", result);
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
@ -519,11 +480,8 @@ pub fn ___syscall180(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
assert_eq!(zero, 0);
|
||||
}
|
||||
let offset: i64 = varargs.get(ctx);
|
||||
|
||||
let buf_ptr = emscripten_memory_pointer!(ctx.memory(0), buf) as _;
|
||||
|
||||
let pread_result = unsafe { libc::pread(fd, buf_ptr, count as _, offset) as _ };
|
||||
debug!("read: '{}'", read_string_from_wasm(ctx.memory(0), buf));
|
||||
pread_result
|
||||
}
|
||||
|
||||
@ -538,14 +496,12 @@ pub fn ___syscall181(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
assert_eq!(zero, 0);
|
||||
}
|
||||
let offset: i64 = varargs.get(ctx);
|
||||
|
||||
let buf_ptr = emscripten_memory_pointer!(ctx.memory(0), buf) as _;
|
||||
let status = unsafe { libc::pwrite(fd, buf_ptr, count as _, offset) as _ };
|
||||
debug!(
|
||||
"=> fd: {}, buf: {}, count: {}, offset: {} = status:{}",
|
||||
fd, buf, count, offset, status
|
||||
);
|
||||
debug!("wrote: '{}'", read_string_from_wasm(ctx.memory(0), buf));
|
||||
status
|
||||
}
|
||||
|
||||
|
@ -3,7 +3,7 @@ use crate::varargs::VarArgs;
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub mod host_fs;
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(not(target_os = "windows"), feature = "vfs"))]
|
||||
pub mod vfs;
|
||||
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
@ -30,7 +30,6 @@ extern "C" {
|
||||
pub fn wait4(pid: pid_t, status: *mut c_int, options: c_int, rusage: *mut rusage) -> pid_t;
|
||||
}
|
||||
|
||||
use crate::utils::read_string_from_wasm;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use libc::wait4;
|
||||
|
||||
@ -68,7 +67,10 @@ pub fn ___syscall122(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
debug!("=> buf: {}", buf);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut utsname;
|
||||
let uname_result = unsafe { uname(buf_addr) };
|
||||
debug!("uname buf: {}", read_string_from_wasm(ctx.memory(0), buf));
|
||||
debug!(
|
||||
"uname buf: {}",
|
||||
crate::utils::read_string_from_wasm(ctx.memory(0), buf)
|
||||
);
|
||||
uname_result
|
||||
}
|
||||
|
||||
|
@ -1,16 +1,26 @@
|
||||
use crate::macros::emscripten_memory_ptr;
|
||||
use crate::syscalls::emscripten_vfs::{EmscriptenVfs, VirtualFd};
|
||||
use crate::syscalls::emscripten_vfs::EmscriptenVfs;
|
||||
use crate::varargs::VarArgs;
|
||||
use crate::EmscriptenData;
|
||||
use wasmer_runtime_core::memory::Memory;
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
#[inline]
|
||||
pub fn emscripten_memory_ptr(memory: &Memory, offset: u32) -> *mut u8 {
|
||||
use std::cell::Cell;
|
||||
(&memory.view::<u8>()[(offset as usize)..]).as_ptr() as *mut Cell<u8> as *mut u8
|
||||
}
|
||||
|
||||
fn translate_to_host_file_descriptors(
|
||||
vfs: &EmscriptenVfs,
|
||||
set_ptr: *mut libc::fd_set,
|
||||
nfds: i32,
|
||||
) -> (i32, Vec<i32>) {
|
||||
) -> Option<(i32, Vec<i32>)> {
|
||||
let pairs = (0..nfds)
|
||||
.map(|vfd| (vfd, vfs.get_host_socket_fd(&VirtualFd(vfd)).unwrap_or(-1)))
|
||||
.map(|vfd| {
|
||||
let host_fd = vfs.get_host_socket_fd(vfd).unwrap_or(-1);
|
||||
(vfd, host_fd)
|
||||
})
|
||||
.filter(|(_, host_fd)| *host_fd >= 0)
|
||||
.filter(|(vfd, _)| unsafe { libc::FD_ISSET(*vfd, set_ptr) })
|
||||
.collect::<Vec<_>>();
|
||||
let max = pairs
|
||||
@ -21,13 +31,19 @@ fn translate_to_host_file_descriptors(
|
||||
+ 1;
|
||||
let mut internal_handles = vec![0; max as usize];
|
||||
unsafe { libc::FD_ZERO(set_ptr) };
|
||||
pairs.iter().for_each(|(vfd, host_fd)| {
|
||||
|
||||
for (vfd, host_fd) in pairs.iter() {
|
||||
let index = *host_fd as usize;
|
||||
if internal_handles.get(index).is_none() {
|
||||
// index is out of range and we are in a bad state...push back up and let the application handle failure
|
||||
return None;
|
||||
}
|
||||
internal_handles[*host_fd as usize] = *vfd;
|
||||
unsafe {
|
||||
libc::FD_SET(*host_fd, set_ptr);
|
||||
};
|
||||
});
|
||||
(max, internal_handles)
|
||||
}
|
||||
Some((max, internal_handles))
|
||||
}
|
||||
|
||||
fn translate_to_virtual_file_descriptors(set_ptr: *mut libc::fd_set, internal_handles: Vec<i32>) {
|
||||
@ -57,14 +73,23 @@ pub fn ___syscall142(ctx: &mut Ctx, _: libc::c_int, mut varargs: VarArgs) -> lib
|
||||
let read_set_ptr = emscripten_memory_ptr(emscripten_memory, readfds) as _;
|
||||
let write_set_ptr = emscripten_memory_ptr(emscripten_memory, writefds) as _;
|
||||
let vfs = unsafe { (*(ctx.data as *const EmscriptenData)).vfs.as_ref().unwrap() };
|
||||
let (read_host_nfds, read_lookup) = translate_to_host_file_descriptors(vfs, read_set_ptr, nfds);
|
||||
let (write_host_nfds, write_lookup) =
|
||||
translate_to_host_file_descriptors(vfs, write_set_ptr, nfds);
|
||||
|
||||
// read descriptors and write descriptors, if any didn't work, then fail
|
||||
let (read_host_nfds, read_lookup, write_host_nfds, write_lookup) = match (
|
||||
translate_to_host_file_descriptors(vfs, read_set_ptr, nfds),
|
||||
translate_to_host_file_descriptors(vfs, write_set_ptr, nfds),
|
||||
) {
|
||||
(None, _) => return -1,
|
||||
(_, None) => return -1,
|
||||
(Some((read_host_nfds, read_lookup)), Some((write_host_nfds, write_lookup))) => {
|
||||
(read_host_nfds, read_lookup, write_host_nfds, write_lookup)
|
||||
}
|
||||
};
|
||||
|
||||
let host_nfds = std::cmp::max(read_host_nfds, write_host_nfds);
|
||||
// TODO: timeout and except fds set
|
||||
let result = unsafe { libc::select(host_nfds, read_set_ptr, write_set_ptr, 0 as _, 0 as _) };
|
||||
translate_to_virtual_file_descriptors(read_set_ptr, read_lookup);
|
||||
translate_to_virtual_file_descriptors(write_set_ptr, write_lookup);
|
||||
debug!("select returns {}", result);
|
||||
result
|
||||
}
|
||||
|
@ -1,14 +1,20 @@
|
||||
use crate::macros::emscripten_memory_ptr;
|
||||
use crate::syscalls::emscripten_vfs::FileHandle::{Socket, VirtualFile};
|
||||
use crate::syscalls::emscripten_vfs::{FileHandle, VirtualFd};
|
||||
use crate::syscalls::emscripten_vfs::FileHandle;
|
||||
use crate::utils::{copy_stat_into_wasm, read_string_from_wasm};
|
||||
use crate::varargs::VarArgs;
|
||||
use libc::stat;
|
||||
use std::cell::RefCell;
|
||||
use std::ffi::c_void;
|
||||
use std::os::raw::c_int;
|
||||
use std::slice;
|
||||
use wasmer_runtime_core::memory::Memory;
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
#[inline]
|
||||
pub fn emscripten_memory_ptr(memory: &Memory, offset: u32) -> *mut u8 {
|
||||
use std::cell::Cell;
|
||||
(&memory.view::<u8>()[(offset as usize)..]).as_ptr() as *mut Cell<u8> as *mut u8
|
||||
}
|
||||
|
||||
/// read
|
||||
pub fn ___syscall3(ctx: &mut Ctx, _: i32, mut varargs: VarArgs) -> i32 {
|
||||
debug!("emscripten::___syscall3 (read - vfs)",);
|
||||
@ -16,17 +22,11 @@ pub fn ___syscall3(ctx: &mut Ctx, _: i32, mut varargs: VarArgs) -> i32 {
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: i32 = varargs.get(ctx);
|
||||
debug!("=> fd: {}, buf_offset: {}, count: {}", fd, buf, count);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut u8;
|
||||
let mut buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
let buf_addr = emscripten_memory_ptr(ctx.memory(0), buf) as *mut u8;
|
||||
let buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
let virtual_file_handle = vfs.get_virtual_file_handle(vfd).unwrap();
|
||||
let ret = vfs
|
||||
.vfs
|
||||
.read_file(virtual_file_handle as _, &mut buf_slice)
|
||||
.unwrap();
|
||||
let ret = vfs.read_file(fd, buf_slice);
|
||||
debug!("=> read syscall returns: {}", ret);
|
||||
debug!("read: '{}'", read_string_from_wasm(ctx.memory(0), buf));
|
||||
ret as _
|
||||
}
|
||||
|
||||
@ -36,89 +36,32 @@ pub fn ___syscall4(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: i32 = varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf);
|
||||
let buf_addr = emscripten_memory_ptr(ctx.memory(0), buf);
|
||||
let buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
let vfd = VirtualFd(fd);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let (host_fd, count) = match vfs.fd_map.get(&vfd) {
|
||||
Some(FileHandle::VirtualFile(handle)) => {
|
||||
vfs.vfs
|
||||
.write_file(*handle as _, buf_slice, count as _, 0)
|
||||
.unwrap();
|
||||
(*handle, count as usize)
|
||||
}
|
||||
Some(FileHandle::Socket(host_fd)) => unsafe {
|
||||
(
|
||||
*host_fd,
|
||||
libc::write(*host_fd, buf_addr as _, count as _) as usize,
|
||||
)
|
||||
},
|
||||
None => panic!(),
|
||||
};
|
||||
debug!("wrote: {}", read_string_from_wasm(ctx.memory(0), buf));
|
||||
debug!(
|
||||
"=> fd: {} (host {}), buf: {}, count: {}\n",
|
||||
vfd.0, host_fd, buf, count
|
||||
);
|
||||
count as c_int
|
||||
match vfs.write_file(fd, buf_slice, count as usize) {
|
||||
Ok(count) => count as _,
|
||||
Err(_) => -1,
|
||||
}
|
||||
}
|
||||
|
||||
/// open
|
||||
pub fn ___syscall5(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall5 (open vfs) {}", _which);
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let pathname_addr = emscripten_memory_pointer!(ctx.memory(0), pathname) as *const i8;
|
||||
let pathname_addr = emscripten_memory_ptr(ctx.memory(0), pathname) as *const i8;
|
||||
let path_str = unsafe { std::ffi::CStr::from_ptr(pathname_addr).to_str().unwrap() };
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let fd = vfs.vfs.open_file(path_str).unwrap();
|
||||
let virtual_file_handle = FileHandle::VirtualFile(fd);
|
||||
let next_lowest_virtual_fd = vfs.next_lowest_fd();
|
||||
assert!(
|
||||
!vfs.fd_map.contains_key(&next_lowest_virtual_fd),
|
||||
"Emscripten vfs should not contain file descriptor."
|
||||
);
|
||||
vfs.fd_map
|
||||
.insert(next_lowest_virtual_fd.clone(), virtual_file_handle);
|
||||
debug!(
|
||||
"=> opening `{}` with new virtual fd: {} (zbox handle {})",
|
||||
path_str,
|
||||
next_lowest_virtual_fd.clone(),
|
||||
fd
|
||||
);
|
||||
debug!("{}", path_str);
|
||||
return next_lowest_virtual_fd.0 as _;
|
||||
let fd = vfs.open_file(path_str);
|
||||
fd
|
||||
}
|
||||
|
||||
/// close
|
||||
pub fn ___syscall6(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall6 (close vfs) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
debug!("closing virtual fd {}...", fd);
|
||||
|
||||
// let emscripten_data = crate::env::get_emscripten_data(ctx);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
|
||||
let close_result = match vfs.fd_map.get(&vfd) {
|
||||
Some(VirtualFile(handle)) => {
|
||||
debug!("closing virtual fd {} (virtual file {})...", fd, handle);
|
||||
vfs.vfs.close(handle).unwrap();
|
||||
vfs.fd_map.remove(&vfd);
|
||||
0
|
||||
}
|
||||
Some(Socket(host_fd)) => unsafe {
|
||||
debug!("closing virtual fd {} (socket {})...", fd, host_fd);
|
||||
let result = libc::close(*host_fd);
|
||||
if result == 0 {
|
||||
vfs.fd_map.remove(&vfd);
|
||||
0
|
||||
} else {
|
||||
-1
|
||||
}
|
||||
},
|
||||
_ => -1,
|
||||
};
|
||||
debug!("close returns {}", close_result);
|
||||
let close_result = vfs.close_file_descriptor(fd);
|
||||
close_result
|
||||
}
|
||||
|
||||
@ -137,44 +80,14 @@ pub fn ___syscall39(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int
|
||||
let path = read_string_from_wasm(ctx.memory(0), pathname);
|
||||
let root = std::path::PathBuf::from("/");
|
||||
let absolute_path = root.join(&path);
|
||||
// debug!("mkdir: {}", absolute_path.display());
|
||||
let emscripten_data = crate::env::get_emscripten_data(ctx);
|
||||
let ret = if let Some(vfs) = &mut emscripten_data.vfs {
|
||||
match vfs.vfs.make_dir(&absolute_path) {
|
||||
Ok(_) => 0,
|
||||
Err(_) => -1,
|
||||
}
|
||||
} else {
|
||||
-1
|
||||
};
|
||||
ret
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
vfs.make_dir(&absolute_path);
|
||||
0
|
||||
}
|
||||
|
||||
/// pipe
|
||||
pub fn ___syscall42(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
unimplemented!();
|
||||
debug!("emscripten::___syscall42 (pipe)");
|
||||
// offset to a file descriptor, which contains a read end and write end, 2 integers
|
||||
let fd_offset: u32 = varargs.get(ctx);
|
||||
|
||||
let emscripten_memory = ctx.memory(0);
|
||||
|
||||
// convert the file descriptor into a vec with two slots
|
||||
let mut fd_vec: Vec<c_int> = emscripten_memory.view()[((fd_offset / 4) as usize)..]
|
||||
.iter()
|
||||
.map(|pipe_end: &std::cell::Cell<c_int>| pipe_end.get())
|
||||
.take(2)
|
||||
.collect();
|
||||
|
||||
// get it as a mutable pointer
|
||||
let fd_ptr = fd_vec.as_mut_ptr();
|
||||
|
||||
// call pipe and store the pointers in this array
|
||||
#[cfg(target_os = "windows")]
|
||||
let result: c_int = unsafe { libc::pipe(fd_ptr, 2048, 0) };
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
let result: c_int = unsafe { libc::pipe(fd_ptr) };
|
||||
result
|
||||
pub fn ___syscall42(_ctx: &mut Ctx, _which: c_int, mut _varargs: VarArgs) -> c_int {
|
||||
unimplemented!("emscripten::___syscall42 (pipe)");
|
||||
}
|
||||
|
||||
/// ioctl
|
||||
@ -185,12 +98,9 @@ pub fn ___syscall54(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int
|
||||
debug!("virtual fd: {}, op: {}", fd, request);
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
|
||||
let host_fd = match vfs.fd_map.get(&vfd) {
|
||||
Some(Socket(host_fd)) => *host_fd,
|
||||
Some(_) => 0,
|
||||
_ => panic!("Should not ioctl on a vbox file."),
|
||||
let host_fd = match vfs.get_host_socket_fd(fd) {
|
||||
Some(host_fd) => host_fd,
|
||||
_ => return -1,
|
||||
};
|
||||
|
||||
// Got the equivalents here: https://code.woboq.org/linux/linux/include/uapi/asm-generic/ioctls.h.html
|
||||
@ -198,7 +108,7 @@ pub fn ___syscall54(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int
|
||||
21537 => {
|
||||
// FIONBIO
|
||||
let argp: u32 = varargs.get(ctx);
|
||||
let argp_ptr = emscripten_memory_pointer!(ctx.memory(0), argp) as *mut c_void;
|
||||
let argp_ptr = emscripten_memory_ptr(ctx.memory(0), argp) as *mut c_void;
|
||||
let ret = unsafe { libc::ioctl(host_fd, libc::FIONBIO, argp_ptr) };
|
||||
debug!("ret(FIONBIO): {}", ret);
|
||||
ret
|
||||
@ -207,7 +117,7 @@ pub fn ___syscall54(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int
|
||||
21523 => {
|
||||
// TIOCGWINSZ
|
||||
let argp: u32 = varargs.get(ctx);
|
||||
let argp_ptr = emscripten_memory_pointer!(ctx.memory(0), argp) as *mut c_void;
|
||||
let argp_ptr = emscripten_memory_ptr(ctx.memory(0), argp) as *mut c_void;
|
||||
let ret = unsafe { libc::ioctl(host_fd, libc::TIOCGWINSZ, argp_ptr) };
|
||||
debug!("ret(TIOCGWINSZ): {} (harcoded to 0)", ret);
|
||||
// ret
|
||||
@ -232,15 +142,9 @@ pub fn ___syscall54(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int
|
||||
/// dup2
|
||||
pub fn ___syscall63(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall63 (dup2) {}", _which);
|
||||
|
||||
let src: i32 = varargs.get(ctx);
|
||||
let dst: i32 = varargs.get(ctx);
|
||||
|
||||
let src = VirtualFd(src);
|
||||
let dst = VirtualFd(dst);
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
|
||||
// if the src is a valid file descriptor, then continue
|
||||
if !vfs.fd_map.contains_key(&src) {
|
||||
return -1;
|
||||
@ -249,33 +153,20 @@ pub fn ___syscall63(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int
|
||||
if src == dst {
|
||||
return 0;
|
||||
}
|
||||
// test if the destination needs to closed first, if so, close it atomically (or fake it)
|
||||
if vfs.fd_map.contains_key(&dst) {
|
||||
vfs.close(&dst);
|
||||
}
|
||||
|
||||
let _ = vfs.fd_map.remove(&dst);
|
||||
let dst_file_handle = match vfs.fd_map.get(&src) {
|
||||
Some(FileHandle::VirtualFile(handle)) => {
|
||||
let new_handle: i32 = vfs.vfs.duplicate_handle(handle);
|
||||
FileHandle::VirtualFile(new_handle)
|
||||
}
|
||||
Some(FileHandle::Socket(src_host_fd)) => unsafe {
|
||||
Some(FileHandle::Vf(file)) => FileHandle::Vf(file.clone()),
|
||||
Some(FileHandle::Socket(src_host_fd)) => {
|
||||
// get a dst file descriptor, or just use the underlying dup syscall
|
||||
let dst_host_fd = libc::dup(*src_host_fd);
|
||||
if dst_host_fd < 0 {
|
||||
panic!()
|
||||
match unsafe { libc::dup(*src_host_fd) } {
|
||||
-1 => return -1,
|
||||
dst_host_fd => FileHandle::Socket(dst_host_fd),
|
||||
}
|
||||
FileHandle::Socket(dst_host_fd)
|
||||
},
|
||||
None => panic!(),
|
||||
}
|
||||
None => return -1,
|
||||
};
|
||||
|
||||
vfs.fd_map.insert(dst.clone(), dst_file_handle);
|
||||
|
||||
let dst = dst.0;
|
||||
|
||||
vfs.fd_map.insert(dst, dst_file_handle);
|
||||
debug!("emscripten::___syscall63 (dup2) returns {}", dst);
|
||||
|
||||
dst
|
||||
}
|
||||
|
||||
@ -286,33 +177,18 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let call: u32 = varargs.get(ctx);
|
||||
let mut socket_varargs: VarArgs = varargs.get(ctx);
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
type libc_sa_family_t = u16;
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
type libc_sa_family_t = libc::sa_family_t;
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
type libc_in_port_t = u16;
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
type libc_in_port_t = libc::in_port_t;
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
type libc_in_addr_t = u32;
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
type libc_in_addr_t = libc::in_addr_t;
|
||||
|
||||
#[repr(C)]
|
||||
pub struct GuestSockaddrIn {
|
||||
pub sin_family: libc_sa_family_t, // u16
|
||||
pub sin_port: libc_in_port_t, // u16
|
||||
pub sin_addr: GuestInAddr, // u32
|
||||
pub sin_zero: [u8; 8], // u8 * 8
|
||||
// 2 + 2 + 4 + 8 = 16
|
||||
pub sin_family: libc::sa_family_t, // u16
|
||||
pub sin_port: libc::in_port_t, // u16
|
||||
pub sin_addr: GuestInAddr, // u32
|
||||
pub sin_zero: [u8; 8], // u8 * 8
|
||||
// 2 + 2 + 4 + 8 = 16
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
pub struct GuestInAddr {
|
||||
pub s_addr: libc_in_addr_t, // u32
|
||||
pub s_addr: libc::in_addr_t, // u32
|
||||
}
|
||||
|
||||
pub struct LinuxSockAddr {
|
||||
@ -350,7 +226,7 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
"=> domain: {} (AF_INET/2), type: {} (SOCK_STREAM/1), protocol: {} = fd: {}",
|
||||
domain, ty, protocol, vfd
|
||||
);
|
||||
vfd.0 as _
|
||||
vfd
|
||||
}
|
||||
2 => {
|
||||
debug!("socket: bind");
|
||||
@ -359,21 +235,18 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len = socket_varargs.get(ctx);
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address = emscripten_memory_ptr(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
|
||||
// Debug received address
|
||||
let _proper_address = address as *const GuestSockaddrIn;
|
||||
let _other_proper_address = address as *const libc::sockaddr;
|
||||
unsafe {
|
||||
debug!(
|
||||
"=> address.sin_family: {:?}, address.sin_port: {:?}, address.sin_addr.s_addr: {:?}",
|
||||
(*_proper_address).sin_family, (*_proper_address).sin_port, (*_proper_address).sin_addr.s_addr
|
||||
);
|
||||
}
|
||||
debug!(
|
||||
"=> address.sin_family: {:?}, address.sin_port: {:?}, address.sin_addr.s_addr: {:?}",
|
||||
unsafe { (*_proper_address).sin_family }, unsafe { (*_proper_address).sin_port }, unsafe { (*_proper_address).sin_addr.s_addr }
|
||||
);
|
||||
let status = unsafe { libc::bind(host_socket_fd as _, address, address_len) };
|
||||
// debug!("=> status: {}", status);
|
||||
debug!(
|
||||
@ -390,11 +263,10 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len = socket_varargs.get(ctx);
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address = emscripten_memory_ptr(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
unsafe { libc::connect(host_socket_fd as _, address, address_len) }
|
||||
}
|
||||
4 => {
|
||||
@ -402,10 +274,8 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
// listen (socket: c_int, backlog: c_int) -> c_int
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let backlog: i32 = socket_varargs.get(ctx);
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
let status = unsafe { libc::listen(host_socket_fd, backlog) };
|
||||
debug!(
|
||||
"=> socketfd: {}, backlog: {} = status: {}",
|
||||
@ -418,15 +288,13 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address_addr: u32 = socket_varargs.get(ctx);
|
||||
let address_len: u32 = socket_varargs.get(ctx);
|
||||
let address =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_addr) as *mut libc::sockaddr;
|
||||
let address = emscripten_memory_ptr(ctx.memory(0), address_addr) as *mut libc::sockaddr;
|
||||
let address_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
emscripten_memory_ptr(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
|
||||
let host_socket_fd = {
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
host_socket_fd
|
||||
};
|
||||
|
||||
@ -444,7 +312,7 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
|
||||
unsafe {
|
||||
let address_linux =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_addr) as *mut LinuxSockAddr;
|
||||
emscripten_memory_ptr(ctx.memory(0), address_addr) as *mut LinuxSockAddr;
|
||||
(*address_linux).sa_family = (*address).sa_family as u16;
|
||||
(*address_linux).sa_data = (*address).sa_data;
|
||||
};
|
||||
@ -455,9 +323,9 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let new_vfd = vfs.new_socket_fd(new_accept_host_fd);
|
||||
|
||||
debug!("new accept fd: {}(host {})", new_vfd.0, new_accept_host_fd);
|
||||
debug!("new accept fd: {}(host {})", new_vfd, new_accept_host_fd);
|
||||
|
||||
new_vfd.0 as _
|
||||
new_vfd
|
||||
}
|
||||
6 => {
|
||||
debug!("socket: getsockname");
|
||||
@ -465,13 +333,12 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len: u32 = socket_varargs.get(ctx);
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address = emscripten_memory_ptr(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
emscripten_memory_ptr(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
|
||||
unsafe { libc::getsockname(host_socket_fd as _, address, address_len_addr) }
|
||||
}
|
||||
@ -481,13 +348,12 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len: u32 = socket_varargs.get(ctx);
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address = emscripten_memory_ptr(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
emscripten_memory_ptr(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
|
||||
unsafe { libc::getpeername(host_socket_fd as _, address, address_len_addr) }
|
||||
}
|
||||
@ -500,12 +366,11 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let len: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len = socket_varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as _;
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let buf_addr = emscripten_memory_ptr(ctx.memory(0), buf) as _;
|
||||
let address = emscripten_memory_ptr(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
|
||||
unsafe {
|
||||
libc::sendto(
|
||||
@ -527,14 +392,13 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let len: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len: u32 = socket_varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as _;
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let buf_addr = emscripten_memory_ptr(ctx.memory(0), buf) as _;
|
||||
let address = emscripten_memory_ptr(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
emscripten_memory_ptr(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
|
||||
let recv_result = unsafe {
|
||||
libc::recvfrom(
|
||||
@ -550,12 +414,6 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
"recvfrom: socket: {}, flags: {}, len: {}, result: {}",
|
||||
socket, flags, len, recv_result
|
||||
);
|
||||
if recv_result < 0 {
|
||||
panic!(
|
||||
"recvfrom result was less than zero. Errno: {}",
|
||||
errno::errno()
|
||||
);
|
||||
}
|
||||
recv_result
|
||||
}
|
||||
14 => {
|
||||
@ -575,11 +433,10 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let _: u32 = socket_varargs.get(ctx);
|
||||
let value: u32 = socket_varargs.get(ctx);
|
||||
let option_len = socket_varargs.get(ctx);
|
||||
let value_addr = emscripten_memory_pointer!(ctx.memory(0), value) as _; // Endian problem
|
||||
let value_addr = emscripten_memory_ptr(ctx.memory(0), value) as _; // Endian problem
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
|
||||
let ret = unsafe {
|
||||
libc::setsockopt(host_socket_fd as _, level, name, value_addr, option_len)
|
||||
@ -600,14 +457,17 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
|
||||
let value: u32 = socket_varargs.get(ctx);
|
||||
let option_len: u32 = socket_varargs.get(ctx);
|
||||
let value_addr = emscripten_memory_pointer!(ctx.memory(0), value) as _;
|
||||
let value_addr = emscripten_memory_ptr(ctx.memory(0), value) as _;
|
||||
let option_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), option_len) as *mut socklen_t;
|
||||
emscripten_memory_ptr(ctx.memory(0), option_len) as *mut socklen_t;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
let host_socket_fd = match vfs.get_host_socket_fd(socket) {
|
||||
Some(host_fd) => host_fd,
|
||||
None => {
|
||||
return -1;
|
||||
}
|
||||
};
|
||||
let result = unsafe {
|
||||
libc::getsockopt(
|
||||
host_socket_fd,
|
||||
@ -617,12 +477,6 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
option_len_addr,
|
||||
)
|
||||
};
|
||||
|
||||
if result == -1 {
|
||||
let err = errno::errno();
|
||||
debug!("socket: getsockopt -- error -- {}", err);
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
16 => {
|
||||
@ -631,11 +485,10 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let msg: u32 = socket_varargs.get(ctx);
|
||||
let flags: i32 = socket_varargs.get(ctx);
|
||||
let msg_addr = emscripten_memory_pointer!(ctx.memory(0), msg) as *const libc::msghdr;
|
||||
let msg_addr = emscripten_memory_ptr(ctx.memory(0), msg) as *const libc::msghdr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
|
||||
unsafe { libc::sendmsg(host_socket_fd as _, msg_addr, flags) as i32 }
|
||||
}
|
||||
@ -645,11 +498,10 @@ pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let msg: u32 = socket_varargs.get(ctx);
|
||||
let flags: i32 = socket_varargs.get(ctx);
|
||||
let msg_addr = emscripten_memory_pointer!(ctx.memory(0), msg) as *mut libc::msghdr;
|
||||
let msg_addr = emscripten_memory_ptr(ctx.memory(0), msg) as *mut libc::msghdr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let host_socket_fd = vfs.get_host_socket_fd(socket).unwrap();
|
||||
|
||||
unsafe { libc::recvmsg(host_socket_fd as _, msg_addr, flags) as i32 }
|
||||
}
|
||||
@ -675,50 +527,48 @@ pub fn ___syscall146(ctx: &mut Ctx, _which: i32, mut varargs: VarArgs) -> i32 {
|
||||
iov_len: i32,
|
||||
}
|
||||
|
||||
let mut err = false;
|
||||
let iov_array_offset = iov_array_offset as u32;
|
||||
let count = (0..iovcnt as u32).fold(0, |acc, iov_array_index| {
|
||||
unsafe {
|
||||
let iov_offset = iov_array_offset + iov_array_index * 8; // get the offset to the iov
|
||||
|
||||
let (iov_buf_slice, iov_buf_ptr, count) = {
|
||||
let emscripten_memory = ctx.memory(0);
|
||||
let guest_iov_ptr =
|
||||
emscripten_memory_ptr(emscripten_memory, iov_offset) as *mut GuestIovec;
|
||||
let iov_base_offset = (*guest_iov_ptr).iov_base as u32;
|
||||
let iov_buf_ptr =
|
||||
emscripten_memory_ptr(emscripten_memory, iov_base_offset) as *const c_void;
|
||||
let iov_len = (*guest_iov_ptr).iov_len as usize;
|
||||
let iov_buf_slice =
|
||||
unsafe { slice::from_raw_parts(iov_buf_ptr as *const u8, iov_len) };
|
||||
(iov_buf_slice, iov_buf_ptr, iov_len)
|
||||
};
|
||||
|
||||
let vfd = VirtualFd(fd);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let count: usize = match vfs.fd_map.get(&vfd) {
|
||||
Some(FileHandle::VirtualFile(handle)) => {
|
||||
vfs.vfs
|
||||
.write_file(*handle as _, iov_buf_slice, count, 0)
|
||||
.unwrap();
|
||||
count as usize
|
||||
}
|
||||
Some(FileHandle::Socket(host_fd)) => unsafe {
|
||||
let count = libc::write(*host_fd, iov_buf_ptr, count);
|
||||
if count < 0 {
|
||||
panic!(
|
||||
"the count from write was less than zero. errno: {}",
|
||||
errno::errno()
|
||||
);
|
||||
let iov_offset = iov_array_offset + iov_array_index * 8; // get the offset to the iov
|
||||
let (iov_buf_slice, iov_buf_ptr, count) = {
|
||||
let emscripten_memory = ctx.memory(0);
|
||||
let guest_iov_ptr =
|
||||
emscripten_memory_ptr(emscripten_memory, iov_offset) as *mut GuestIovec;
|
||||
let iov_base_offset = unsafe { (*guest_iov_ptr).iov_base as u32 };
|
||||
let iov_buf_ptr =
|
||||
emscripten_memory_ptr(emscripten_memory, iov_base_offset) as *const c_void;
|
||||
let iov_len = unsafe { (*guest_iov_ptr).iov_len as usize };
|
||||
let iov_buf_slice = unsafe { slice::from_raw_parts(iov_buf_ptr as *const u8, iov_len) };
|
||||
(iov_buf_slice, iov_buf_ptr, iov_len)
|
||||
};
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let count: usize = match vfs.fd_map.get(&fd) {
|
||||
Some(FileHandle::Vf(file)) => {
|
||||
match RefCell::borrow_mut(file).write_file(iov_buf_slice, 0) {
|
||||
Ok(count) => count,
|
||||
_ => {
|
||||
err = true;
|
||||
0
|
||||
}
|
||||
count as usize
|
||||
},
|
||||
None => panic!(),
|
||||
};
|
||||
|
||||
acc + count
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(FileHandle::Socket(host_fd)) => unsafe {
|
||||
let count = libc::write(*host_fd, iov_buf_ptr, count);
|
||||
count as usize
|
||||
},
|
||||
None => {
|
||||
err = true;
|
||||
0
|
||||
}
|
||||
};
|
||||
acc + count
|
||||
});
|
||||
|
||||
if err {
|
||||
return -1;
|
||||
}
|
||||
|
||||
debug!(
|
||||
"=> fd: {}, iov: {}, iovcnt = {}, returning {}",
|
||||
fd, iov_array_offset, iovcnt, count
|
||||
@ -733,16 +583,11 @@ pub fn ___syscall180(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: i32 = varargs.get(ctx);
|
||||
let offset: i32/*i64*/ = varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut u8;
|
||||
let buf_addr = emscripten_memory_ptr(ctx.memory(0), buf) as *mut u8;
|
||||
let buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
let mut buf_slice_with_offset: &mut [u8] = &mut buf_slice[(offset as usize)..];
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
let virtual_file_handle = vfs.get_virtual_file_handle(vfd).unwrap();
|
||||
let ret = vfs
|
||||
.vfs
|
||||
.read_file(virtual_file_handle as _, &mut buf_slice_with_offset)
|
||||
.unwrap();
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_ref().unwrap(); //.as_mut().unwrap();
|
||||
let ret = vfs.read_file(fd, &mut buf_slice_with_offset);
|
||||
debug!("read: '{}'", read_string_from_wasm(ctx.memory(0), buf));
|
||||
ret as _
|
||||
}
|
||||
@ -753,17 +598,17 @@ pub fn ___syscall181(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: u32 = varargs.get(ctx);
|
||||
let offset: i32 = varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf);
|
||||
let _offset: i32 = varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_ptr(ctx.memory(0), buf);
|
||||
let buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
let vfd = VirtualFd(fd);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let virtual_file_handle = vfs.get_virtual_file_handle(vfd).unwrap();
|
||||
vfs.vfs
|
||||
.write_file(virtual_file_handle as _, buf_slice, count as _, offset as _)
|
||||
.unwrap();
|
||||
debug!("wrote: '{}'", read_string_from_wasm(ctx.memory(0), buf));
|
||||
count as _
|
||||
match vfs.write_file(fd, buf_slice, count as _) {
|
||||
Ok(count) => count as _,
|
||||
Err(e) => {
|
||||
eprintln!("{:?}", e);
|
||||
-1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// stat64
|
||||
@ -778,8 +623,8 @@ pub fn ___syscall195(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let emscripten_data = crate::env::get_emscripten_data(ctx);
|
||||
let ret = match &mut emscripten_data.vfs {
|
||||
Some(vfs) => {
|
||||
let metadata = vfs.vfs.get_path_metadata(&path).unwrap();
|
||||
let len = metadata.content_len();
|
||||
let metadata = vfs.path_metadata(&path).unwrap();
|
||||
let len = metadata.len;
|
||||
unsafe {
|
||||
let mut stat: stat = std::mem::zeroed();
|
||||
stat.st_size = len as _;
|
||||
@ -800,10 +645,10 @@ pub fn ___syscall197(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
let fd: c_int = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
let ret = match vfs.fd_map.get(&vfd) {
|
||||
Some(FileHandle::VirtualFile(internal_handle)) => {
|
||||
let metadata = vfs.vfs.get_file_metadata(internal_handle).unwrap();
|
||||
let ret = match vfs.fd_map.get(&fd) {
|
||||
Some(FileHandle::Vf(file)) => {
|
||||
let metadata = file.borrow_mut().metadata().unwrap();
|
||||
// let metadata = vfs.vfs.get_file_metadata(internal_handle).unwrap();
|
||||
let len = metadata.len;
|
||||
let mode = if metadata.is_file {
|
||||
libc::S_IFREG
|
||||
@ -827,36 +672,6 @@ pub fn ___syscall197(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_in
|
||||
}
|
||||
|
||||
/// dup3
|
||||
pub fn ___syscall330(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> libc::pid_t {
|
||||
pub fn ___syscall330(_ctx: &mut Ctx, _which: c_int, mut _varargs: VarArgs) -> libc::pid_t {
|
||||
unimplemented!();
|
||||
// Implementation based on description at https://linux.die.net/man/2/dup3
|
||||
debug!("emscripten::___syscall330 (dup3)");
|
||||
let oldfd: c_int = varargs.get(ctx);
|
||||
let newfd: c_int = varargs.get(ctx);
|
||||
let flags: c_int = varargs.get(ctx);
|
||||
|
||||
if oldfd == newfd {
|
||||
return libc::EINVAL;
|
||||
}
|
||||
|
||||
let res = unsafe { libc::dup2(oldfd, newfd) };
|
||||
|
||||
// Set flags on newfd (https://www.gnu.org/software/libc/manual/html_node/Descriptor-Flags.html)
|
||||
let mut old_flags = unsafe { libc::fcntl(newfd, libc::F_GETFD, 0) };
|
||||
|
||||
if old_flags > 0 {
|
||||
old_flags |= flags;
|
||||
} else if old_flags == 0 {
|
||||
old_flags &= !flags;
|
||||
}
|
||||
|
||||
unsafe {
|
||||
libc::fcntl(newfd, libc::F_SETFD, old_flags);
|
||||
}
|
||||
|
||||
debug!(
|
||||
"=> oldfd: {}, newfd: {}, flags: {} = pid: {}",
|
||||
oldfd, newfd, flags, res
|
||||
);
|
||||
res
|
||||
}
|
||||
|
@ -1,16 +1,3 @@
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub mod host_fs;
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
pub mod vfs;
|
||||
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub use host_fs::*;
|
||||
|
||||
#[cfg(feature = "vfs")]
|
||||
pub use vfs::*;
|
||||
|
||||
use crate::env::get_emscripten_data;
|
||||
use crate::utils::copy_cstr_into_wasm;
|
||||
use crate::varargs::VarArgs;
|
||||
use libc::mkdir;
|
||||
@ -27,7 +14,6 @@ use wasmer_runtime_core::vm::Ctx;
|
||||
type pid_t = c_int;
|
||||
|
||||
/// open
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub fn ___syscall5(ctx: &mut Ctx, which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall5 (open) {}", which);
|
||||
#[cfg(not(feature = "debug"))]
|
||||
@ -81,7 +67,6 @@ pub fn ___syscall212(_ctx: &mut Ctx, which: c_int, mut _varargs: VarArgs) -> c_i
|
||||
}
|
||||
|
||||
// mkdir
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub fn ___syscall39(ctx: &mut Ctx, which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall39 (mkdir) {}", which);
|
||||
#[cfg(not(feature = "debug"))]
|
||||
@ -119,7 +104,6 @@ pub fn ___syscall54(_ctx: &mut Ctx, which: c_int, mut _varargs: VarArgs) -> c_in
|
||||
}
|
||||
|
||||
// socketcall
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub fn ___syscall102(_ctx: &mut Ctx, which: c_int, mut _varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall102 (socketcall) {}", which);
|
||||
@ -128,18 +112,16 @@ pub fn ___syscall102(_ctx: &mut Ctx, which: c_int, mut _varargs: VarArgs) -> c_i
|
||||
-1
|
||||
}
|
||||
|
||||
/// pread
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub fn ___syscall180(ctx: &mut Ctx, which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
// pread
|
||||
pub fn ___syscall180(_ctx: &mut Ctx, which: c_int, mut _varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall180 (pread) {}", which);
|
||||
#[cfg(not(feature = "debug"))]
|
||||
let _ = which;
|
||||
-1
|
||||
}
|
||||
|
||||
/// pwrite
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub fn ___syscall181(ctx: &mut Ctx, which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
// pwrite
|
||||
pub fn ___syscall181(_ctx: &mut Ctx, which: c_int, mut _varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall181 (pwrite) {}", which);
|
||||
#[cfg(not(feature = "debug"))]
|
||||
let _ = which;
|
@ -1,35 +0,0 @@
|
||||
/// read
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub fn ___syscall3(ctx: &mut Ctx, _which: i32, mut varargs: VarArgs) -> i32 {
|
||||
// -> ssize_t
|
||||
debug!("emscripten::___syscall3 (read) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: i32 = varargs.get(ctx);
|
||||
debug!("=> fd: {}, buf_offset: {}, count: {}", fd, buf, count);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut c_void;
|
||||
let ret = unsafe { libc::read(fd, buf_addr, count as _) };
|
||||
debug!("=> ret: {}", ret);
|
||||
ret as _
|
||||
}
|
||||
|
||||
/// write
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub fn ___syscall4(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall4 (write) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: i32 = varargs.get(ctx);
|
||||
debug!("=> fd: {}, buf: {}, count: {}", fd, buf, count);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *const c_void;
|
||||
unsafe { write(fd, buf_addr, count as _) as i32 }
|
||||
}
|
||||
|
||||
/// close
|
||||
#[cfg(not(feature = "vfs"))]
|
||||
pub fn ___syscall6(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall6 (close) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
debug!("fd: {}", fd);
|
||||
unsafe { libc::close(fd) }
|
||||
}
|
@ -1,885 +0,0 @@
|
||||
use crate::utils::{copy_stat_into_wasm, read_string_from_wasm};
|
||||
use crate::varargs::VarArgs;
|
||||
use libc::stat;
|
||||
use std::os::raw::c_int;
|
||||
use std::slice;
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
// Another conditional constant for name resolution: Macos et iOS use
|
||||
// SO_NOSIGPIPE as a setsockopt flag to disable SIGPIPE emission on socket.
|
||||
// Other platforms do otherwise.
|
||||
use crate::syscalls::emscripten_vfs::FileHandle::{Socket, VirtualFile};
|
||||
use crate::syscalls::emscripten_vfs::{FileHandle, VirtualFd};
|
||||
#[cfg(target_os = "darwin")]
|
||||
use libc::SO_NOSIGPIPE;
|
||||
use std::ffi::c_void;
|
||||
|
||||
#[cfg(not(target_os = "darwin"))]
|
||||
const SO_NOSIGPIPE: c_int = 0;
|
||||
|
||||
/// read
|
||||
pub fn ___syscall3(ctx: &mut Ctx, _: i32, mut varargs: VarArgs) -> i32 {
|
||||
debug!("emscripten::___syscall3 (read - vfs)",);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: i32 = varargs.get(ctx);
|
||||
|
||||
debug!("=> fd: {}, buf_offset: {}, count: {}", fd, buf, count);
|
||||
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut u8;
|
||||
let mut buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
let virtual_file_handle = vfs.get_virtual_file_handle(vfd).unwrap();
|
||||
|
||||
let ret = vfs
|
||||
.vfs
|
||||
.read_file(virtual_file_handle as _, &mut buf_slice)
|
||||
.unwrap();
|
||||
debug!("=> read syscall returns: {}", ret);
|
||||
ret as _
|
||||
}
|
||||
|
||||
/// write
|
||||
pub fn ___syscall4(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall4 (write - vfs) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: i32 = varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf);
|
||||
|
||||
let buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
let vfd = VirtualFd(fd);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
|
||||
let count: usize = match vfs.fd_map.get(&vfd) {
|
||||
Some(FileHandle::VirtualFile(handle)) => {
|
||||
vfs.vfs
|
||||
.write_file(*handle as _, buf_slice, count as _, 0)
|
||||
.unwrap();
|
||||
count as usize
|
||||
}
|
||||
Some(FileHandle::Socket(host_fd)) => unsafe {
|
||||
libc::write(*host_fd, buf_addr as _, count as _) as usize
|
||||
},
|
||||
None => panic!(),
|
||||
};
|
||||
|
||||
let string = read_string_from_wasm(ctx.memory(0), buf);
|
||||
|
||||
debug!(
|
||||
"=> fd: {} (host {}), buf: {}, count: {}\n",
|
||||
vfd.0, fd, buf, count
|
||||
);
|
||||
debug!("=> data:\n \"{}\"", string);
|
||||
count as c_int
|
||||
}
|
||||
|
||||
/// open
|
||||
pub fn ___syscall5(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall5 (open vfs) {}", _which);
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let pathname_addr = emscripten_memory_pointer!(ctx.memory(0), pathname) as *const i8;
|
||||
let path_str = unsafe { std::ffi::CStr::from_ptr(pathname_addr).to_str().unwrap() };
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let fd = vfs.vfs.open_file(path_str).unwrap();
|
||||
let virtual_file_handle = FileHandle::VirtualFile(fd);
|
||||
let virtual_fd = vfs.next_lowest_fd();
|
||||
let fd = virtual_fd.0;
|
||||
assert!(
|
||||
!vfs.fd_map.contains_key(&virtual_fd),
|
||||
"Emscripten vfs should not contain file descriptor."
|
||||
);
|
||||
vfs.fd_map.insert(virtual_fd, virtual_file_handle);
|
||||
debug!("=> opening `{}` with new virtual fd: {}", path_str, fd);
|
||||
debug!("{}", path_str);
|
||||
return fd as _;
|
||||
}
|
||||
|
||||
/// close
|
||||
pub fn ___syscall6(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall6 (close vfs) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
debug!("closing virtual fd {}...", fd);
|
||||
|
||||
// let emscripten_data = crate::env::get_emscripten_data(ctx);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
|
||||
match vfs.fd_map.get(&vfd) {
|
||||
Some(VirtualFile(handle)) => {
|
||||
vfs.vfs.close(handle).unwrap();
|
||||
vfs.fd_map.remove(&vfd);
|
||||
0
|
||||
}
|
||||
Some(Socket(host_fd)) => unsafe {
|
||||
let result = libc::close(*host_fd);
|
||||
if result == 0 {
|
||||
vfs.fd_map.remove(&vfd);
|
||||
0
|
||||
} else {
|
||||
-1
|
||||
}
|
||||
},
|
||||
_ => -1,
|
||||
}
|
||||
}
|
||||
|
||||
/// chmod
|
||||
pub fn ___syscall15(_ctx: &mut Ctx, _one: i32, _two: i32) -> i32 {
|
||||
debug!("emscripten::___syscall15 (chmod)");
|
||||
debug!("chmod always returns 0.");
|
||||
0
|
||||
}
|
||||
|
||||
// mkdir
|
||||
pub fn ___syscall39(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall39 (mkdir vfs) {}", _which);
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let _mode: u32 = varargs.get(ctx);
|
||||
let path = read_string_from_wasm(ctx.memory(0), pathname);
|
||||
let root = std::path::PathBuf::from("/");
|
||||
let absolute_path = root.join(&path);
|
||||
// debug!("mkdir: {}", absolute_path.display());
|
||||
let emscripten_data = crate::env::get_emscripten_data(ctx);
|
||||
let ret = if let Some(vfs) = &mut emscripten_data.vfs {
|
||||
match vfs.vfs.make_dir(&absolute_path) {
|
||||
Ok(_) => 0,
|
||||
Err(_) => -1,
|
||||
}
|
||||
} else {
|
||||
-1
|
||||
};
|
||||
// debug!("mkdir returns {}", ret);
|
||||
ret
|
||||
}
|
||||
|
||||
/// ioctl
|
||||
pub fn ___syscall54(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall54 (ioctl) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let request: u32 = varargs.get(ctx);
|
||||
debug!("virtual fd: {}, op: {}", fd, request);
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
|
||||
let host_fd = match vfs.fd_map.get(&vfd) {
|
||||
Some(Socket(host_fd)) => *host_fd,
|
||||
Some(_) => 0,
|
||||
_ => panic!("Should not ioctl on a vbox file."),
|
||||
};
|
||||
|
||||
// Got the equivalents here: https://code.woboq.org/linux/linux/include/uapi/asm-generic/ioctls.h.html
|
||||
match request as _ {
|
||||
21537 => {
|
||||
// FIONBIO
|
||||
let argp: u32 = varargs.get(ctx);
|
||||
let argp_ptr = emscripten_memory_pointer!(ctx.memory(0), argp) as *mut c_void;
|
||||
let ret = unsafe { libc::ioctl(host_fd, libc::FIONBIO, argp_ptr) };
|
||||
debug!("ret(FIONBIO): {}", ret);
|
||||
ret
|
||||
// 0
|
||||
}
|
||||
21523 => {
|
||||
// TIOCGWINSZ
|
||||
let argp: u32 = varargs.get(ctx);
|
||||
let argp_ptr = emscripten_memory_pointer!(ctx.memory(0), argp) as *mut c_void;
|
||||
let ret = unsafe { libc::ioctl(host_fd, libc::TIOCGWINSZ, argp_ptr) };
|
||||
debug!("ret(TIOCGWINSZ): {} (harcoded to 0)", ret);
|
||||
// ret
|
||||
// TODO: We hardcode the value to have emscripten tests pass, as for some reason
|
||||
// when the capturer is active, ioctl returns -1 instead of 0
|
||||
if ret == -1 {
|
||||
0
|
||||
} else {
|
||||
ret
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
debug!(
|
||||
"emscripten::___syscall54 -> non implemented case {}",
|
||||
request
|
||||
);
|
||||
0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// dup2
|
||||
pub fn ___syscall63(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall63 (dup2) {}", _which);
|
||||
|
||||
let src: i32 = varargs.get(ctx);
|
||||
let dst: i32 = varargs.get(ctx);
|
||||
|
||||
let src = VirtualFd(src);
|
||||
let dst = VirtualFd(dst);
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
|
||||
// if the src is a valid file descriptor, then continue
|
||||
if !vfs.fd_map.contains_key(&src) {
|
||||
return -1;
|
||||
}
|
||||
// if src and dst are identical, do nothing
|
||||
if src == dst {
|
||||
return 0;
|
||||
}
|
||||
// test if the destination needs to closed first, if so, close it atomically (or fake it)
|
||||
if vfs.fd_map.contains_key(&dst) {
|
||||
vfs.close(&dst);
|
||||
}
|
||||
|
||||
let dst_file_handle = match vfs.fd_map.get(&src) {
|
||||
Some(FileHandle::VirtualFile(handle)) => {
|
||||
let new_handle: i32 = vfs.vfs.duplicate_handle(handle);
|
||||
FileHandle::VirtualFile(new_handle)
|
||||
}
|
||||
Some(FileHandle::Socket(src_host_fd)) => unsafe {
|
||||
// get a dst file descriptor, or just use the underlying dup syscall
|
||||
let dst_host_fd = libc::dup(*src_host_fd);
|
||||
if dst_host_fd == -1 {
|
||||
panic!()
|
||||
}
|
||||
FileHandle::Socket(dst_host_fd)
|
||||
},
|
||||
None => panic!(),
|
||||
};
|
||||
|
||||
vfs.fd_map.insert(dst.clone(), dst_file_handle);
|
||||
|
||||
let dst = dst.0;
|
||||
|
||||
debug!("emscripten::___syscall63 (dup2) returns {}", dst);
|
||||
|
||||
dst
|
||||
}
|
||||
|
||||
/// pread
|
||||
pub fn ___syscall180(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall180 (pread) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: i32 = varargs.get(ctx);
|
||||
let offset: i32/*i64*/ = varargs.get(ctx);
|
||||
// debug!(
|
||||
// "=> fd: {}, buf_offset: {}, count: {}, offset: {}",
|
||||
// fd, buf, count, offset
|
||||
// );
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut u8;
|
||||
let buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
let mut buf_slice_with_offset: &mut [u8] = &mut buf_slice[(offset as usize)..];
|
||||
|
||||
// let emscripten_data = crate::env::get_emscripten_data(ctx);
|
||||
// let ret = match &mut emscripten_data.vfs {
|
||||
// Some(vfs) => vfs.vfs.read_file(fd as _, &mut buf_slice_with_offset).unwrap(),
|
||||
// None => 0,
|
||||
// };
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
let virtual_file_handle = vfs.get_virtual_file_handle(vfd).unwrap();
|
||||
let ret = vfs
|
||||
.vfs
|
||||
.read_file(virtual_file_handle as _, &mut buf_slice_with_offset)
|
||||
.unwrap();
|
||||
|
||||
// debug!("=> pread returns: {}", ret);
|
||||
ret as _
|
||||
}
|
||||
|
||||
/// pwrite
|
||||
pub fn ___syscall181(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall181 (pwrite) {}", _which);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: u32 = varargs.get(ctx);
|
||||
let offset: i32 = varargs.get(ctx);
|
||||
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf);
|
||||
|
||||
let buf_slice = unsafe { slice::from_raw_parts_mut(buf_addr, count as _) };
|
||||
|
||||
// let emscripten_data = crate::env::get_emscripten_data(ctx);
|
||||
// let count = if let Some(vfs) = &mut emscripten_data.vfs {
|
||||
// vfs.vfs.write_file(fd as _, buf_slice, count as _, offset as _)
|
||||
// .unwrap()
|
||||
// } else {
|
||||
// 0
|
||||
// };
|
||||
|
||||
let vfd = VirtualFd(fd);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let virtual_file_handle = vfs.get_virtual_file_handle(vfd).unwrap();
|
||||
vfs.vfs
|
||||
.write_file(virtual_file_handle as _, buf_slice, count as _, offset as _)
|
||||
.unwrap();
|
||||
|
||||
count as _
|
||||
}
|
||||
|
||||
// stat64
|
||||
#[cfg(feature = "vfs")]
|
||||
pub fn ___syscall195(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall195 (stat64) {}", _which);
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let path_string = read_string_from_wasm(ctx.memory(0), pathname);
|
||||
debug!("path extract for `stat` syscall: {}", &path_string);
|
||||
let path = std::path::PathBuf::from(path_string);
|
||||
|
||||
let emscripten_data = crate::env::get_emscripten_data(ctx);
|
||||
let ret = match &mut emscripten_data.vfs {
|
||||
Some(vfs) => {
|
||||
let metadata = vfs.vfs.get_path_metadata(&path).unwrap();
|
||||
let len = metadata.len();
|
||||
unsafe {
|
||||
let mut stat: stat = std::mem::zeroed();
|
||||
stat.st_size = len as _;
|
||||
debug!("stat size: {}", len);
|
||||
copy_stat_into_wasm(ctx, buf, &stat as _);
|
||||
}
|
||||
0
|
||||
}
|
||||
None => -1,
|
||||
};
|
||||
debug!("stat return: {}", ret);
|
||||
ret
|
||||
}
|
||||
|
||||
/// fstat64
|
||||
pub fn ___syscall197(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall197 (fstat64) {}", _which);
|
||||
let fd: c_int = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(fd);
|
||||
let ret = match vfs.fd_map.get(&vfd) {
|
||||
Some(FileHandle::VirtualFile(internal_handle)) => {
|
||||
let metadata = vfs.vfs.get_file_metadata(internal_handle).unwrap();
|
||||
let len = metadata.len;
|
||||
let mode = if metadata.is_file {
|
||||
libc::S_IFREG
|
||||
} else {
|
||||
libc::S_IFDIR
|
||||
};
|
||||
unsafe {
|
||||
let mut stat: stat = std::mem::zeroed();
|
||||
stat.st_mode = mode as _;
|
||||
stat.st_size = len as _;
|
||||
debug!("fstat size: {}", len);
|
||||
copy_stat_into_wasm(ctx, buf, &stat as _);
|
||||
}
|
||||
0
|
||||
}
|
||||
Some(FileHandle::Socket(_host_fd)) => panic!(),
|
||||
None => -1,
|
||||
};
|
||||
debug!("fstat return: {}", ret);
|
||||
ret
|
||||
}
|
||||
|
||||
// getgid
|
||||
//pub fn ___syscall201(_ctx: &mut Ctx, _one: i32, _two: i32) -> i32 {
|
||||
// debug!("emscripten::___syscall201 (getgid)");
|
||||
// 0
|
||||
//}
|
||||
|
||||
// socketcall
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub fn ___syscall102(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall102 (socketcall) {}", _which);
|
||||
let call: u32 = varargs.get(ctx);
|
||||
let mut socket_varargs: VarArgs = varargs.get(ctx);
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
type libc_sa_family_t = u16;
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
type libc_sa_family_t = libc::sa_family_t;
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
type libc_in_port_t = u16;
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
type libc_in_port_t = libc::in_port_t;
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
type libc_in_addr_t = u32;
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
type libc_in_addr_t = libc::in_addr_t;
|
||||
|
||||
#[repr(C)]
|
||||
pub struct GuestSockaddrIn {
|
||||
pub sin_family: libc_sa_family_t, // u16
|
||||
pub sin_port: libc_in_port_t, // u16
|
||||
pub sin_addr: GuestInAddr, // u32
|
||||
pub sin_zero: [u8; 8], // u8 * 8
|
||||
// 2 + 2 + 4 + 8 = 16
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
pub struct GuestInAddr {
|
||||
pub s_addr: libc_in_addr_t, // u32
|
||||
}
|
||||
|
||||
pub struct LinuxSockAddr {
|
||||
pub sa_family: u16,
|
||||
pub sa_data: [libc::c_char; 14],
|
||||
}
|
||||
|
||||
match call {
|
||||
1 => {
|
||||
debug!("socket: socket");
|
||||
// socket (domain: c_int, ty: c_int, protocol: c_int) -> c_int
|
||||
let domain: i32 = socket_varargs.get(ctx);
|
||||
let ty: i32 = socket_varargs.get(ctx);
|
||||
let protocol: i32 = socket_varargs.get(ctx);
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
|
||||
let _test_errno = errno::errno();
|
||||
|
||||
// create the host socket
|
||||
let host_fd = unsafe { libc::socket(domain, ty, protocol) };
|
||||
let vfd = vfs.new_socket_fd(host_fd);
|
||||
|
||||
debug!("--- host fd from libc::socket: {} ---", host_fd);
|
||||
debug!("--- reference fd in vfs from libc::socket: {} ---", vfd);
|
||||
|
||||
// set_cloexec
|
||||
let _ioctl_result = unsafe { libc::ioctl(host_fd, libc::FIOCLEX) };
|
||||
|
||||
use libc::{setsockopt, SOL_SOCKET};
|
||||
|
||||
let _err = errno::errno();
|
||||
|
||||
type T = u32;
|
||||
let payload = 1 as *const T as _;
|
||||
let _setsockopt_result = unsafe {
|
||||
setsockopt(
|
||||
host_fd,
|
||||
SOL_SOCKET,
|
||||
SO_NOSIGPIPE,
|
||||
payload,
|
||||
std::mem::size_of::<T>() as libc::socklen_t,
|
||||
)
|
||||
};
|
||||
|
||||
let _err2 = errno::errno();
|
||||
|
||||
debug!(
|
||||
"=> domain: {} (AF_INET/2), type: {} (SOCK_STREAM/1), protocol: {} = fd: {}",
|
||||
domain, ty, protocol, vfd
|
||||
);
|
||||
|
||||
vfd.0 as _
|
||||
}
|
||||
2 => {
|
||||
debug!("socket: bind");
|
||||
// bind (socket: c_int, address: *const sockaddr, address_len: socklen_t) -> c_int
|
||||
// TODO: Emscripten has a different signature.
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len = socket_varargs.get(ctx);
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
// Debug received address
|
||||
let _proper_address = address as *const GuestSockaddrIn;
|
||||
let _other_proper_address = address as *const libc::sockaddr;
|
||||
unsafe {
|
||||
debug!(
|
||||
"=> address.sin_family: {:?}, address.sin_port: {:?}, address.sin_addr.s_addr: {:?}",
|
||||
(*_proper_address).sin_family, (*_proper_address).sin_port, (*_proper_address).sin_addr.s_addr
|
||||
);
|
||||
}
|
||||
let status = unsafe { libc::bind(host_socket_fd as _, address, address_len) };
|
||||
// debug!("=> status: {}", status);
|
||||
debug!(
|
||||
"=> socketfd: {}, address: {:?}, address_len: {} = status: {}",
|
||||
socket, address, address_len, status
|
||||
);
|
||||
status
|
||||
// -1
|
||||
}
|
||||
3 => {
|
||||
debug!("socket: connect");
|
||||
// connect (socket: c_int, address: *const sockaddr, len: socklen_t) -> c_int
|
||||
// TODO: Emscripten has a different signature.
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len = socket_varargs.get(ctx);
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
unsafe { libc::connect(host_socket_fd as _, address, address_len) }
|
||||
}
|
||||
4 => {
|
||||
debug!("socket: listen");
|
||||
// listen (socket: c_int, backlog: c_int) -> c_int
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let backlog: i32 = socket_varargs.get(ctx);
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
let status = unsafe { libc::listen(host_socket_fd, backlog) };
|
||||
debug!(
|
||||
"=> socketfd: {}, backlog: {} = status: {}",
|
||||
socket, backlog, status
|
||||
);
|
||||
status
|
||||
}
|
||||
5 => {
|
||||
debug!("socket: accept");
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address_addr: u32 = socket_varargs.get(ctx);
|
||||
let address_len: u32 = socket_varargs.get(ctx);
|
||||
let address =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_addr) as *mut libc::sockaddr;
|
||||
let address_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
|
||||
let host_socket_fd = {
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
host_socket_fd
|
||||
};
|
||||
|
||||
debug!(
|
||||
"=> socket: {}(host {}), address: {:?}, address_len: {}",
|
||||
socket, host_socket_fd, address, address_len
|
||||
);
|
||||
|
||||
let new_accept_host_fd =
|
||||
unsafe { libc::accept(host_socket_fd, address, address_len_addr) };
|
||||
|
||||
unsafe {
|
||||
let address_linux =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_addr) as *mut LinuxSockAddr;
|
||||
(*address_linux).sa_family = (*address).sa_family as u16;
|
||||
(*address_linux).sa_data = (*address).sa_data;
|
||||
};
|
||||
|
||||
// set_cloexec
|
||||
let _ioctl_result = unsafe { libc::ioctl(new_accept_host_fd, libc::FIOCLEX) };
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let new_vfd = vfs.new_socket_fd(new_accept_host_fd);
|
||||
|
||||
debug!("new accept fd: {}(host {})", new_vfd.0, new_accept_host_fd);
|
||||
|
||||
new_vfd.0 as _
|
||||
}
|
||||
6 => {
|
||||
debug!("socket: getsockname");
|
||||
// getsockname (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len: u32 = socket_varargs.get(ctx);
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
unsafe { libc::getsockname(host_socket_fd as _, address, address_len_addr) }
|
||||
}
|
||||
7 => {
|
||||
debug!("socket: getpeername");
|
||||
// getpeername (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len: u32 = socket_varargs.get(ctx);
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
unsafe { libc::getpeername(host_socket_fd as _, address, address_len_addr) }
|
||||
}
|
||||
11 => {
|
||||
debug!("socket: sendto");
|
||||
// sendto (socket: c_int, buf: *const c_void, len: size_t, flags: c_int, addr: *const sockaddr, addrlen: socklen_t) -> ssize_t
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let buf: u32 = socket_varargs.get(ctx);
|
||||
let flags = socket_varargs.get(ctx);
|
||||
let len: i32 = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len = socket_varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as _;
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
unsafe {
|
||||
libc::sendto(
|
||||
host_socket_fd as _,
|
||||
buf_addr,
|
||||
flags,
|
||||
len,
|
||||
address,
|
||||
address_len,
|
||||
) as i32
|
||||
}
|
||||
}
|
||||
12 => {
|
||||
debug!("socket: recvfrom");
|
||||
// recvfrom (socket: c_int, buf: *const c_void, len: size_t, flags: c_int, addr: *const sockaddr, addrlen: socklen_t) -> ssize_t
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let buf: u32 = socket_varargs.get(ctx);
|
||||
let len: i32 = socket_varargs.get(ctx);
|
||||
let flags = socket_varargs.get(ctx);
|
||||
let address: u32 = socket_varargs.get(ctx);
|
||||
let address_len: u32 = socket_varargs.get(ctx);
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as _;
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut libc::sockaddr;
|
||||
let address_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut libc::socklen_t;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
unsafe {
|
||||
libc::recvfrom(
|
||||
host_socket_fd,
|
||||
buf_addr,
|
||||
flags,
|
||||
len,
|
||||
address,
|
||||
address_len_addr,
|
||||
) as i32
|
||||
}
|
||||
}
|
||||
14 => {
|
||||
debug!("socket: setsockopt");
|
||||
// NOTE: Emscripten seems to be passing the wrong values to this syscall
|
||||
// level: Em passes 1 as SOL_SOCKET; SOL_SOCKET is 0xffff in BSD
|
||||
// name: Em passes SO_ACCEPTCONN, but Nginx complains about REUSEADDR
|
||||
// https://github.com/openbsd/src/blob/master/sys/sys/socket.h#L156
|
||||
// setsockopt (socket: c_int, level: c_int, name: c_int, value: *const c_void, option_len: socklen_t) -> c_int
|
||||
|
||||
let socket = socket_varargs.get(ctx);
|
||||
// SOL_SOCKET = 0xffff (BSD, Linux)
|
||||
let level: i32 = libc::SOL_SOCKET;
|
||||
// SO_REUSEADDR = 0x4 (BSD, Linux)
|
||||
let name: i32 = libc::SO_REUSEADDR;
|
||||
let _: u32 = socket_varargs.get(ctx);
|
||||
let value: u32 = socket_varargs.get(ctx);
|
||||
let option_len = socket_varargs.get(ctx);
|
||||
let value_addr = emscripten_memory_pointer!(ctx.memory(0), value) as _; // Endian problem
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
let ret = unsafe {
|
||||
libc::setsockopt(host_socket_fd as _, level, name, value_addr, option_len)
|
||||
};
|
||||
|
||||
debug!("=> socketfd: {}, level: {} (SOL_SOCKET/0xffff), name: {} (SO_REUSEADDR/4), value_addr: {:?}, option_len: {} = status: {}", socket, level, name, value_addr, option_len, ret);
|
||||
ret
|
||||
}
|
||||
15 => {
|
||||
debug!("socket: getsockopt");
|
||||
// getsockopt (sockfd: c_int, level: c_int, optname: c_int, optval: *mut c_void, optlen: *mut socklen_t) -> c_int
|
||||
use libc::socklen_t;
|
||||
let socket = socket_varargs.get(ctx);
|
||||
let level: i32 = socket_varargs.get(ctx);
|
||||
let name: i32 = socket_varargs.get(ctx);
|
||||
let value: u32 = socket_varargs.get(ctx);
|
||||
let option_len: u32 = socket_varargs.get(ctx);
|
||||
let value_addr = emscripten_memory_pointer!(ctx.memory(0), value) as _;
|
||||
let option_len_addr =
|
||||
emscripten_memory_pointer!(ctx.memory(0), option_len) as *mut socklen_t;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
let result = unsafe {
|
||||
libc::getsockopt(host_socket_fd, level, name, value_addr, option_len_addr)
|
||||
};
|
||||
|
||||
if result == -1 {
|
||||
let err = errno::errno();
|
||||
debug!("socket: getsockopt -- error -- {}", err);
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
16 => {
|
||||
debug!("socket: sendmsg");
|
||||
// sendmsg (fd: c_int, msg: *const msghdr, flags: c_int) -> ssize_t
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let msg: u32 = socket_varargs.get(ctx);
|
||||
let flags: i32 = socket_varargs.get(ctx);
|
||||
let msg_addr = emscripten_memory_pointer!(ctx.memory(0), msg) as *const libc::msghdr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
unsafe { libc::sendmsg(host_socket_fd as _, msg_addr, flags) as i32 }
|
||||
}
|
||||
17 => {
|
||||
debug!("socket: recvmsg");
|
||||
// recvmsg (fd: c_int, msg: *mut msghdr, flags: c_int) -> ssize_t
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let msg: u32 = socket_varargs.get(ctx);
|
||||
let flags: i32 = socket_varargs.get(ctx);
|
||||
let msg_addr = emscripten_memory_pointer!(ctx.memory(0), msg) as *mut libc::msghdr;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
let vfd = VirtualFd(socket);
|
||||
let host_socket_fd = vfs.get_host_socket_fd(&vfd).unwrap();
|
||||
|
||||
unsafe { libc::recvmsg(host_socket_fd as _, msg_addr, flags) as i32 }
|
||||
}
|
||||
_ => {
|
||||
// others
|
||||
-1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// select
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub fn ___syscall142(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall142 (newselect) {}", _which);
|
||||
|
||||
let nfds: i32 = varargs.get(ctx);
|
||||
let readfds: u32 = varargs.get(ctx);
|
||||
let writefds: u32 = varargs.get(ctx);
|
||||
let _exceptfds: u32 = varargs.get(ctx);
|
||||
let timeout: i32 = varargs.get(ctx);
|
||||
|
||||
assert!(nfds <= 64, "`nfds` must be less than or equal to 64");
|
||||
// assert_eq!(exceptfds, 0, "`exceptfds` is not supporrted");
|
||||
|
||||
let readfds_set_ptr = emscripten_memory_pointer!(ctx.memory(0), readfds) as *mut _;
|
||||
let readfds_set_u8_ptr = readfds_set_ptr as *mut u8;
|
||||
let writefds_set_ptr = emscripten_memory_pointer!(ctx.memory(0), writefds) as *mut _;
|
||||
let writefds_set_u8_ptr = writefds_set_ptr as *mut u8;
|
||||
|
||||
let nfds = nfds as _;
|
||||
let readfds_slice = unsafe { slice::from_raw_parts_mut(readfds_set_u8_ptr, nfds) };
|
||||
let _writefds_slice = unsafe { slice::from_raw_parts_mut(writefds_set_u8_ptr, nfds) };
|
||||
|
||||
use bit_field::BitArray;
|
||||
|
||||
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
|
||||
|
||||
let mut file_descriptors_to_watch = vec![];
|
||||
for virtual_fd in 0..nfds {
|
||||
let bit_flag = readfds_slice.get_bit(virtual_fd as usize);
|
||||
if !bit_flag {
|
||||
continue;
|
||||
}
|
||||
file_descriptors_to_watch.push(virtual_fd);
|
||||
}
|
||||
|
||||
let mut count = 0;
|
||||
let mut max = -1;
|
||||
|
||||
let mut read_mappings = vec![];
|
||||
|
||||
for virtual_fd in 0..nfds {
|
||||
let bit_flag = readfds_slice.get_bit(virtual_fd);
|
||||
if !bit_flag {
|
||||
continue;
|
||||
}
|
||||
let virtual_file = vfs.fd_map.get(&VirtualFd(virtual_fd as _));
|
||||
match virtual_file {
|
||||
Some(FileHandle::VirtualFile(_fd)) => {
|
||||
count = count + 1;
|
||||
}
|
||||
Some(FileHandle::Socket(host_fd)) => {
|
||||
count = count + 1;
|
||||
let virtual_fd = virtual_fd as i32;
|
||||
let fd = *host_fd;
|
||||
if fd > max {
|
||||
max = fd;
|
||||
}
|
||||
read_mappings.push((virtual_fd, fd));
|
||||
}
|
||||
None => {}
|
||||
};
|
||||
}
|
||||
|
||||
for mapping in read_mappings.clone() {
|
||||
let (virtual_fd, fd) = mapping;
|
||||
unsafe {
|
||||
libc::FD_CLR(virtual_fd, readfds_set_ptr);
|
||||
libc::FD_SET(fd, readfds_set_ptr);
|
||||
}
|
||||
}
|
||||
|
||||
// #[repr(C)]
|
||||
// pub struct timeval {
|
||||
// pub tv_sec: libc::c_long, // time t
|
||||
// pub tv_usec: libc::c_long, // long int
|
||||
// }
|
||||
|
||||
let timeval_ptr = emscripten_memory_pointer!(ctx.memory(0), timeout) as *mut libc::timeval;
|
||||
let mut tval = unsafe {
|
||||
libc::timeval {
|
||||
tv_sec: (*timeval_ptr).tv_sec,
|
||||
tv_usec: (*timeval_ptr).tv_usec,
|
||||
}
|
||||
};
|
||||
let _tval_ptr: *mut libc::timeval = &mut tval;
|
||||
|
||||
let sz = max as i32 + 1;
|
||||
// let result = unsafe { libc::select(sz, readfds_set_ptr, writefds_set_ptr, 0 as _, timeval_ptr as *mut libc::timeval) };
|
||||
let result = unsafe { libc::select(sz, readfds_set_ptr, writefds_set_ptr, 0 as _, 0 as _) };
|
||||
|
||||
assert!(nfds <= 64, "`nfds` must be less than or equal to 64");
|
||||
// assert!(exceptfds == 0, "`exceptfds` is not supporrted");
|
||||
|
||||
let err = errno::errno();
|
||||
debug!("gah again: {}", err);
|
||||
|
||||
// let len = read_mappings.len();
|
||||
|
||||
for mapping in read_mappings {
|
||||
let (virtual_fd, fd) = mapping;
|
||||
unsafe {
|
||||
libc::FD_CLR(fd, readfds_set_ptr);
|
||||
libc::FD_SET(virtual_fd, readfds_set_ptr);
|
||||
}
|
||||
}
|
||||
|
||||
for input in file_descriptors_to_watch {
|
||||
unsafe {
|
||||
let in_set = libc::FD_ISSET(input as _, readfds_set_ptr);
|
||||
assert!(in_set);
|
||||
}
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
// chown
|
||||
pub fn ___syscall212(ctx: &mut Ctx, _which: c_int, mut varargs: VarArgs) -> c_int {
|
||||
debug!("emscripten::___syscall212 (chown) {}", _which);
|
||||
let _pathname: u32 = varargs.get(ctx);
|
||||
let _owner: u32 = varargs.get(ctx);
|
||||
let _group: u32 = varargs.get(ctx);
|
||||
debug!("syscall `chown` always returns 0");
|
||||
0
|
||||
}
|
@ -176,7 +176,7 @@ mod test_unary_literal;
|
||||
mod test_utf;
|
||||
mod test_varargs;
|
||||
mod test_varargs_multi;
|
||||
#[cfg(feature = "vfs")]
|
||||
#[cfg(all(feature = "vfs", not(target_os = "windows")))]
|
||||
mod test_vfs;
|
||||
mod test_vprintf;
|
||||
mod test_vsnprintf;
|
||||
|
@ -8,6 +8,7 @@ repository = "https://github.com/wasmerio/wasmer"
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
libc = "0.2.50"
|
||||
wasmer-runtime-core = { path = "../runtime-core" }
|
||||
hashbrown = "0.1"
|
||||
failure = "0.1"
|
||||
|
@ -1,25 +1,60 @@
|
||||
use crate::vfs::file_like::{FileLike, Metadata};
|
||||
use failure::Error;
|
||||
use std::io;
|
||||
use std::io::{Read, Write};
|
||||
|
||||
pub struct Stdin;
|
||||
pub struct Stdout;
|
||||
pub struct Stderr;
|
||||
|
||||
impl FileLike for Stdin {
|
||||
fn write(&mut self, _buf: &[u8], count: usize, _offset: usize) -> Result<usize, Error> {
|
||||
println!("writing to {} byte to dev stream...", count);
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
fn read(&mut self, _buf: &mut [u8]) -> Result<usize, Error> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
fn close(&self) -> Result<(), Error> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn metadata(&self) -> Result<Metadata, Error> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
fn write_file(&mut self, _buf: &[u8], _offset: usize) -> Result<usize, io::Error> {
|
||||
unimplemented!()
|
||||
}
|
||||
}
|
||||
|
||||
impl Read for Stdin {
|
||||
fn read(&mut self, _buf: &mut [u8]) -> Result<usize, io::Error> {
|
||||
unimplemented!()
|
||||
}
|
||||
}
|
||||
|
||||
impl FileLike for Stdout {
|
||||
fn metadata(&self) -> Result<Metadata, failure::Error> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
fn write_file(&mut self, buf: &[u8], _offset: usize) -> Result<usize, io::Error> {
|
||||
let stdout = io::stdout();
|
||||
let mut handle = stdout.lock();
|
||||
handle.write(buf)
|
||||
}
|
||||
}
|
||||
|
||||
impl Read for Stdout {
|
||||
fn read(&mut self, _buf: &mut [u8]) -> Result<usize, io::Error> {
|
||||
unimplemented!()
|
||||
}
|
||||
}
|
||||
|
||||
impl FileLike for Stderr {
|
||||
fn metadata(&self) -> Result<Metadata, failure::Error> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
fn write_file(&mut self, buf: &[u8], _offset: usize) -> Result<usize, io::Error> {
|
||||
let stderr = io::stderr();
|
||||
let mut handle = stderr.lock();
|
||||
handle.write(buf)
|
||||
}
|
||||
}
|
||||
|
||||
impl Read for Stderr {
|
||||
fn read(&mut self, _buf: &mut [u8]) -> Result<usize, io::Error> {
|
||||
unimplemented!()
|
||||
}
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
use std::io;
|
||||
|
||||
pub type Fd = isize;
|
||||
|
||||
#[derive(Debug)]
|
||||
@ -6,13 +8,10 @@ pub struct Metadata {
|
||||
pub is_file: bool,
|
||||
}
|
||||
|
||||
pub trait FileLike {
|
||||
/// write
|
||||
fn write(&mut self, buf: &[u8], count: usize, offset: usize) -> Result<usize, failure::Error>;
|
||||
/// like read(2), will read the data for the file descriptor
|
||||
fn read(&mut self, buf: &mut [u8]) -> Result<usize, failure::Error>;
|
||||
/// close
|
||||
fn close(&self) -> Result<(), failure::Error>;
|
||||
pub trait FileLike: std::io::Read {
|
||||
// get metadata
|
||||
fn metadata(&self) -> Result<Metadata, failure::Error>;
|
||||
|
||||
// write
|
||||
fn write_file(&mut self, buf: &[u8], offset: usize) -> Result<usize, io::Error>;
|
||||
}
|
||||
|
@ -1,7 +1,7 @@
|
||||
use crate::vfs::file_like::FileLike;
|
||||
use crate::vfs::vfs_header::{header_from_bytes, ArchiveType, CompressionType};
|
||||
use crate::vfs::virtual_file::VirtualFile;
|
||||
use std::collections::BTreeMap;
|
||||
use hashbrown::HashMap;
|
||||
use std::cell::RefCell;
|
||||
use std::io;
|
||||
use std::io::Read;
|
||||
use std::path::{Path, PathBuf};
|
||||
@ -9,12 +9,9 @@ use std::rc::Rc;
|
||||
use tar::EntryType;
|
||||
use zbox::{init_env, OpenOptions, Repo, RepoOpener};
|
||||
|
||||
pub type Fd = i32;
|
||||
|
||||
pub struct Vfs {
|
||||
repo: Repo,
|
||||
pub fd_map: BTreeMap<Fd, Rc<dyn FileLike>>,
|
||||
pub import_errors: Vec<VfsAggregateError>,
|
||||
device_files: HashMap<PathBuf, Rc<RefCell<dyn FileLike>>>,
|
||||
}
|
||||
|
||||
impl Vfs {
|
||||
@ -22,15 +19,15 @@ impl Vfs {
|
||||
pub fn from_tar_zstd_bytes<Reader: Read>(tar_bytes: Reader) -> Result<Self, failure::Error> {
|
||||
let result = zstd::decode_all(tar_bytes);
|
||||
let decompressed_data = result.unwrap();
|
||||
Vfs::from_tar_bytes(&decompressed_data[..])
|
||||
Self::from_tar_bytes(&decompressed_data[..])
|
||||
}
|
||||
|
||||
/// Match on the type of the compressed-archive and select the correct unpack method
|
||||
pub fn from_compressed_bytes(compressed_data_slice: &[u8]) -> Result<Self, failure::Error> {
|
||||
let data_bytes = &compressed_data_slice[4..];
|
||||
match header_from_bytes(compressed_data_slice)? {
|
||||
(_, CompressionType::ZSTD, ArchiveType::TAR) => Vfs::from_tar_zstd_bytes(data_bytes),
|
||||
(_, CompressionType::NONE, ArchiveType::TAR) => Vfs::from_tar_bytes(data_bytes),
|
||||
(_, CompressionType::ZSTD, ArchiveType::TAR) => Self::from_tar_zstd_bytes(data_bytes),
|
||||
(_, CompressionType::NONE, ArchiveType::TAR) => Self::from_tar_bytes(data_bytes),
|
||||
}
|
||||
}
|
||||
|
||||
@ -41,20 +38,6 @@ impl Vfs {
|
||||
.create(true)
|
||||
.open("mem://wasmer_fs", "")
|
||||
.unwrap();
|
||||
|
||||
let mut fd_map: BTreeMap<Fd, Rc<dyn FileLike>> = BTreeMap::new();
|
||||
|
||||
// TODO: What to do about the creation of the device files?
|
||||
let _ = repo.create_dir(PathBuf::from("/dev/"));
|
||||
let _stdin = repo.create_file(PathBuf::from("/dev/stdin"))?;
|
||||
let _stdout = repo.create_file(PathBuf::from("/dev/stdout"))?;
|
||||
let _stderr = repo.create_file(PathBuf::from("/dev/stderr"))?;
|
||||
|
||||
use crate::vfs::device_file;
|
||||
fd_map.insert(0, Rc::new(device_file::Stdin {}));
|
||||
fd_map.insert(1, Rc::new(device_file::Stdin {})); // TODO FIX ME
|
||||
fd_map.insert(2, Rc::new(device_file::Stdin {}));
|
||||
|
||||
let _errors = tar::Archive::new(tar_bytes)
|
||||
.entries()?
|
||||
.map(|entry| {
|
||||
@ -93,169 +76,66 @@ impl Vfs {
|
||||
|
||||
// let import_errors = errors.iter().filter_map(|e| e.err()).collect::<Vec<_>>();
|
||||
|
||||
let vfs = Vfs {
|
||||
let vfs = Self {
|
||||
repo,
|
||||
fd_map,
|
||||
import_errors: vec![],
|
||||
device_files: HashMap::new(),
|
||||
// import_errors: vec![],
|
||||
};
|
||||
Ok(vfs)
|
||||
}
|
||||
|
||||
/// like read(2), will read the data for the file descriptor
|
||||
pub fn read_file(&mut self, fd: Fd, buf: &mut [u8]) -> Result<usize, failure::Error> {
|
||||
let mut data = self
|
||||
.fd_map
|
||||
.get_mut(&fd)
|
||||
.ok_or(VfsError::FileDescriptorNotExist(fd))?;
|
||||
match Rc::get_mut(&mut data) {
|
||||
Some(file) => file.read(buf),
|
||||
None => Err(VfsError::CouldNotGetMutableReferenceToFile.into()),
|
||||
}
|
||||
pub fn new() -> Result<(Self, Vec<VfsError>), failure::Error> {
|
||||
init_env();
|
||||
let repo = RepoOpener::new()
|
||||
.create(true)
|
||||
.open("mem://wasmer_fs", "")
|
||||
.unwrap();
|
||||
Ok((
|
||||
Vfs {
|
||||
repo,
|
||||
device_files: HashMap::new(),
|
||||
},
|
||||
vec![],
|
||||
))
|
||||
}
|
||||
|
||||
/// like open(2), creates a file descriptor for the path if it exists
|
||||
pub fn open_file<P: AsRef<Path>>(&mut self, path: P) -> Result<Fd, failure::Error> {
|
||||
pub fn open_file<P: AsRef<Path>>(&mut self, path: P) -> Option<Rc<RefCell<dyn FileLike>>> {
|
||||
init_env();
|
||||
let path = convert_to_absolute_path(path);
|
||||
let file = OpenOptions::new().write(true).open(&mut self.repo, &path)?;
|
||||
let mut next_lowest_fd = 0;
|
||||
for (fd, _) in self.fd_map.iter() {
|
||||
if *fd == next_lowest_fd {
|
||||
next_lowest_fd += 1;
|
||||
} else if *fd < next_lowest_fd {
|
||||
panic!("Should not be here.");
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let virtual_file = VirtualFile::new(file);
|
||||
self.fd_map.insert(next_lowest_fd, Rc::new(virtual_file));
|
||||
Ok(next_lowest_fd)
|
||||
}
|
||||
|
||||
fn next_lowest(&self) -> Fd {
|
||||
let mut next_lowest_fd = 0;
|
||||
for (fd, _) in self.fd_map.iter() {
|
||||
if *fd == next_lowest_fd {
|
||||
next_lowest_fd += 1;
|
||||
} else if *fd < next_lowest_fd {
|
||||
panic!("Should not be here.");
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
next_lowest_fd
|
||||
}
|
||||
|
||||
/// like dup2, but better for this abstraction layer
|
||||
pub fn duplicate_handle(&mut self, handle: &Fd) -> Fd {
|
||||
let dup = match self.fd_map.get(handle) {
|
||||
Some(file) => file.clone(),
|
||||
None => panic!(),
|
||||
};
|
||||
let new_handle = self.next_lowest();
|
||||
assert!(!self.fd_map.contains_key(&new_handle));
|
||||
self.fd_map.insert(new_handle, dup);
|
||||
new_handle
|
||||
}
|
||||
|
||||
/// like dup2
|
||||
pub fn duplicate_file_descriptor(
|
||||
&mut self,
|
||||
source_fd: Fd,
|
||||
target_fd: Fd,
|
||||
) -> Result<Fd, failure::Error> {
|
||||
// find the file and check if the target descriptor is already open
|
||||
let (target_is_open_file, file) = {
|
||||
let fd_map = &self.fd_map;
|
||||
let source_file = fd_map.get(&source_fd);
|
||||
let target_file = fd_map.get(&target_fd);
|
||||
match (source_file, target_file) {
|
||||
// the source is not already open
|
||||
(None, _) => Err(VfsError::SourceFileDescriptorDoesNotExist),
|
||||
// the target fd is already open, close it first
|
||||
(_, Some(file)) => Ok((true, file.clone())),
|
||||
// normal case
|
||||
(Some(file), None) => Ok((false, file.clone())),
|
||||
}
|
||||
}?;
|
||||
// if the target fd is already open, close it first
|
||||
if target_is_open_file {
|
||||
let fd_map = &mut self.fd_map;
|
||||
fd_map.remove(&target_fd);
|
||||
fd_map.insert(target_fd, file.clone());
|
||||
if let Ok(file) = OpenOptions::new().write(true).open(&mut self.repo, &path) {
|
||||
Some(Rc::new(RefCell::new(file)))
|
||||
} else if let Some(dev_file) = self.device_files.get(&path) {
|
||||
Some(dev_file.clone())
|
||||
} else {
|
||||
let fd_map = &mut self.fd_map;
|
||||
fd_map.insert(target_fd, file.clone());
|
||||
}
|
||||
Ok(target_fd)
|
||||
}
|
||||
|
||||
/// close
|
||||
pub fn close(&mut self, fd: &Fd) -> Result<(), failure::Error> {
|
||||
let result = if let Some(file) = self.fd_map.remove(fd) {
|
||||
file.close()
|
||||
} else {
|
||||
// this file did not exist in the virtual file system, maybe throw an error in the future
|
||||
Ok(())
|
||||
};
|
||||
assert!(!self.fd_map.contains_key(&fd));
|
||||
result
|
||||
}
|
||||
|
||||
/// get metadata with file descriptor
|
||||
pub fn get_file_metadata(
|
||||
&self,
|
||||
fd: &Fd,
|
||||
) -> Result<crate::vfs::file_like::Metadata, failure::Error> {
|
||||
match self.fd_map.get(&fd) {
|
||||
None => Err(VfsError::FileWithFileDescriptorNotExist(*fd).into()),
|
||||
Some(file) => {
|
||||
// let file = file.clone();
|
||||
let file = file.clone();
|
||||
file.metadata()
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// get metadata with path
|
||||
pub fn get_path_metadata<P: AsRef<Path>>(
|
||||
&self,
|
||||
path: P,
|
||||
) -> Result<zbox::Metadata, failure::Error> {
|
||||
let path = convert_to_absolute_path(path);
|
||||
self.repo.metadata(path).map_err(|e| e.into())
|
||||
pub fn make_dir<P: AsRef<Path>>(&mut self, path: P) {
|
||||
self.repo.create_dir_all(path).unwrap();
|
||||
}
|
||||
|
||||
pub fn make_dir<P: AsRef<Path>>(&mut self, path: P) -> Result<(), failure::Error> {
|
||||
self.repo.create_dir_all(path).map_err(|e| e.into())
|
||||
}
|
||||
|
||||
/// write to a file with the file descriptor
|
||||
pub fn write_file(
|
||||
&mut self,
|
||||
fd: Fd,
|
||||
buf: &[u8],
|
||||
count: usize,
|
||||
offset: usize,
|
||||
) -> Result<usize, failure::Error> {
|
||||
let mut file = self
|
||||
.fd_map
|
||||
.get_mut(&fd)
|
||||
.ok_or(VfsError::FileWithFileDescriptorNotExist(fd))?;
|
||||
let file = Rc::get_mut(&mut file);
|
||||
match file {
|
||||
Some(file) => file.write(buf, count, offset),
|
||||
None => Ok(count), // BAD!!! Switch to Rc<RefCell>
|
||||
}
|
||||
pub fn create_device_file<P: AsRef<Path>>(&mut self, path: P, file: Rc<RefCell<dyn FileLike>>) {
|
||||
self.device_files.insert(path.as_ref().to_path_buf(), file);
|
||||
}
|
||||
}
|
||||
|
||||
fn convert_to_absolute_path<P: AsRef<Path>>(path: P) -> PathBuf {
|
||||
let path = path.as_ref();
|
||||
if path.is_relative() {
|
||||
std::path::PathBuf::from("/").join(path)
|
||||
} else {
|
||||
path.to_path_buf()
|
||||
}
|
||||
}
|
||||
|
||||
pub type Handle = i32;
|
||||
#[derive(Debug, Fail)]
|
||||
pub enum VfsError {
|
||||
#[fail(display = "File with file descriptor \"{}\" does not exist.", _0)]
|
||||
FileWithFileDescriptorNotExist(Fd),
|
||||
FileWithFileDescriptorNotExist(Handle),
|
||||
#[fail(display = "File descriptor does not exist.")]
|
||||
FileDescriptorNotExist(Fd),
|
||||
FileDescriptorNotExist(Handle),
|
||||
#[fail(display = "Source file descriptor does not exist.")]
|
||||
SourceFileDescriptorDoesNotExist,
|
||||
#[fail(display = "Target file descriptor already exists.")]
|
||||
@ -287,369 +167,3 @@ impl std::convert::From<zbox::Error> for VfsAggregateError {
|
||||
VfsAggregateError::ZboxError(error)
|
||||
}
|
||||
}
|
||||
|
||||
fn convert_to_absolute_path<P: AsRef<Path>>(path: P) -> PathBuf {
|
||||
let path = path.as_ref();
|
||||
if path.is_relative() {
|
||||
std::path::PathBuf::from("/").join(path)
|
||||
} else {
|
||||
path.to_path_buf()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod open_test {
|
||||
use crate::vfs::vfs::Vfs;
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
|
||||
#[test]
|
||||
fn open_and_close_files() {
|
||||
// SETUP: create temp dir and files
|
||||
let tmp_dir = tempdir::TempDir::new("open_files").unwrap();
|
||||
let file_path = tmp_dir.path().join("foo.txt");
|
||||
let mut tmp_file = File::create(file_path.clone()).unwrap();
|
||||
writeln!(tmp_file, "foo foo foo").unwrap();
|
||||
let tar_data = vec![];
|
||||
let mut ar = tar::Builder::new(tar_data);
|
||||
ar.append_path_with_name(file_path, "foo.txt").unwrap();
|
||||
let archive = ar.into_inner().unwrap();
|
||||
// SETUP: create virtual filesystem with tar data
|
||||
let vfs_result = Vfs::from_tar_bytes(&archive[..]);
|
||||
// ASSERT:
|
||||
assert!(
|
||||
vfs_result.is_ok(),
|
||||
"Failed to create file system from archive"
|
||||
);
|
||||
let mut vfs = vfs_result.unwrap();
|
||||
// open the file, get a file descriptor
|
||||
let open_result = vfs.open_file("foo.txt");
|
||||
assert!(
|
||||
open_result.is_ok(),
|
||||
"Failed to open file in the virtual filesystem."
|
||||
);
|
||||
// open the same file twice, and expect different descriptors
|
||||
let fd_1 = open_result.unwrap();
|
||||
let open_result_2 = vfs.open_file("foo.txt");
|
||||
assert!(
|
||||
open_result_2.is_ok(),
|
||||
"Failed to open the same file twice in the virtual filesystem."
|
||||
);
|
||||
let fd_2 = open_result_2.unwrap();
|
||||
assert_ne!(fd_1, fd_2, "Open produced the same file descriptor twice.");
|
||||
assert!(fd_2 > 0, "File descriptor was less than 0.");
|
||||
|
||||
// try opening as absolute path
|
||||
let open_result_3 = vfs.open_file("/foo.txt");
|
||||
assert!(
|
||||
open_result_3.is_ok(),
|
||||
"Failed to open the same file twice in the virtual filesystem."
|
||||
);
|
||||
let fd_3 = open_result_3.unwrap();
|
||||
assert!(fd_3 > 0, "File descriptor was less than 0.");
|
||||
|
||||
let close_result = vfs.close(&fd_3);
|
||||
assert!(close_result.is_ok(), "Close failed.");
|
||||
|
||||
// re-open the file, assert the file descriptor is the same
|
||||
let open_result_4 = vfs.open_file("/foo.txt");
|
||||
assert!(
|
||||
open_result_4.is_ok(),
|
||||
"Failed to close a file, then the file again in the virtual filesystem."
|
||||
);
|
||||
let fd_4 = open_result_4.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
fd_3, fd_4,
|
||||
"Expected the lowest available file descriptor to be used."
|
||||
);
|
||||
|
||||
// close a lower file descriptor
|
||||
let close_result_2 = vfs.close(&fd_1);
|
||||
assert!(close_result_2.is_ok(), "Close failed");
|
||||
|
||||
// re-open the file, assert the file descriptor is the same
|
||||
let open_result_5 = vfs.open_file("/foo.txt");
|
||||
assert!(
|
||||
open_result_5.is_ok(),
|
||||
"Failed to open a file, open more files, then close the file, and then open it again and get the lowest file descriptor in in the virtual filesystem."
|
||||
);
|
||||
let fd_5 = open_result_5.unwrap();
|
||||
assert_eq!(
|
||||
fd_5, fd_1,
|
||||
"Expected the lowest available file descriptor to be used."
|
||||
);
|
||||
|
||||
// re-open the file, assert the file descriptor is correct
|
||||
let open_result_6 = vfs.open_file("/foo.txt");
|
||||
assert!(open_result_6.is_ok());
|
||||
// we re-opened a file which took the recently opened low file descriptor. Now we get the next lowest file descriptor.
|
||||
let fd_6 = open_result_6.unwrap();
|
||||
assert_eq!(fd_6, fd_4 + 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn open_non_existent_file() {
|
||||
// SETUP: create temp dir and files
|
||||
let tmp_dir = tempdir::TempDir::new("open_non_existent_file").unwrap();
|
||||
let file_path = tmp_dir.path().join("foo.txt");
|
||||
let mut tmp_file = File::create(file_path.clone()).unwrap();
|
||||
writeln!(tmp_file, "foo foo foo").unwrap();
|
||||
let tar_data = vec![];
|
||||
let mut ar = tar::Builder::new(tar_data);
|
||||
ar.append_path_with_name(file_path, "foo.txt").unwrap();
|
||||
let archive = ar.into_inner().unwrap();
|
||||
// SETUP: create virtual filesystem with tar data
|
||||
let vfs_result = Vfs::from_tar_bytes(&archive[..]);
|
||||
// ASSERT:
|
||||
assert!(
|
||||
vfs_result.is_ok(),
|
||||
"Failed to create file system from archive"
|
||||
);
|
||||
let mut vfs = vfs_result.unwrap();
|
||||
// read the file
|
||||
let open_result = vfs.open_file("foo.txt");
|
||||
assert!(open_result.is_ok(), "Failed to read file from vfs");
|
||||
// open a non-existent file
|
||||
let open_result_2 = vfs.open_file("bar.txt");
|
||||
assert!(
|
||||
open_result_2.is_err(),
|
||||
"Somehow opened a non-existent file."
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod read_test {
|
||||
use crate::vfs::vfs::Vfs;
|
||||
use std::fs;
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
use tempdir;
|
||||
|
||||
#[test]
|
||||
fn empty_archive() {
|
||||
// SETUP: create temp dir and files
|
||||
let empty_archive = vec![];
|
||||
// SETUP: create virtual filesystem with tar data
|
||||
let vfs_result = Vfs::from_tar_bytes(&empty_archive[..]);
|
||||
// ASSERT:
|
||||
assert!(
|
||||
vfs_result.is_ok(),
|
||||
"Failed to create file system from empty archive"
|
||||
);
|
||||
// assert import errors
|
||||
let vfs = vfs_result.unwrap();
|
||||
assert_eq!(
|
||||
vfs.import_errors.len(),
|
||||
0,
|
||||
"Expected no import errors. Found {} errors.",
|
||||
vfs.import_errors.len()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn single_file_archive() {
|
||||
// SETUP: create temp dir and files
|
||||
let tmp_dir = tempdir::TempDir::new("single_file_archive").unwrap();
|
||||
let foo_file_path = tmp_dir.path().join("foo.txt");
|
||||
let mut foo_tmp_file = File::create(foo_file_path.clone()).unwrap();
|
||||
writeln!(foo_tmp_file, "foo foo foo").unwrap();
|
||||
let tar_data = vec![];
|
||||
let mut ar = tar::Builder::new(tar_data);
|
||||
ar.append_path_with_name(foo_file_path, "foo.txt").unwrap();
|
||||
let archive = ar.into_inner().unwrap();
|
||||
// SETUP: create virtual filesystem with tar data
|
||||
let vfs_result = Vfs::from_tar_bytes(&archive[..]);
|
||||
// ASSERT:
|
||||
assert!(
|
||||
vfs_result.is_ok(),
|
||||
"Failed to create file system from archive"
|
||||
);
|
||||
let mut vfs = vfs_result.unwrap();
|
||||
// read the file
|
||||
let fd = vfs.open_file("foo.txt").unwrap();
|
||||
let mut actual_data: [u8; 12] = [0; 12];
|
||||
let read_result = vfs.read_file(fd, &mut actual_data);
|
||||
assert!(read_result.is_ok(), "Failed to read file from vfs");
|
||||
let expected_data = "foo foo foo\n".as_bytes();
|
||||
assert_eq!(actual_data, expected_data, "Contents were not equal");
|
||||
|
||||
// assert import errors
|
||||
assert_eq!(
|
||||
vfs.import_errors.len(),
|
||||
0,
|
||||
"Expected no import errors. Found {} errors.",
|
||||
vfs.import_errors.len()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn two_files_in_archive() {
|
||||
// SETUP: create temp dir and files
|
||||
let tmp_dir = tempdir::TempDir::new("two_files_in_archive").unwrap();
|
||||
let foo_file_path = tmp_dir.path().join("foo.txt");
|
||||
let bar_file_path = tmp_dir.path().join("bar.txt");
|
||||
let mut foo_tmp_file = File::create(foo_file_path.clone()).unwrap();
|
||||
let mut bar_tmp_file = File::create(bar_file_path.clone()).unwrap();
|
||||
writeln!(foo_tmp_file, "foo foo foo").unwrap();
|
||||
writeln!(bar_tmp_file, "bar bar").unwrap();
|
||||
let tar_data = vec![];
|
||||
let mut ar = tar::Builder::new(tar_data);
|
||||
ar.append_path_with_name(foo_file_path, "foo.txt").unwrap();
|
||||
ar.append_path_with_name(bar_file_path, "bar.txt").unwrap();
|
||||
let archive = ar.into_inner().unwrap();
|
||||
// SETUP: create virtual filesystem with tar data
|
||||
let vfs_result = Vfs::from_tar_bytes(&archive[..]);
|
||||
// ASSERT:
|
||||
assert!(
|
||||
vfs_result.is_ok(),
|
||||
"Failed to create file system from archive"
|
||||
);
|
||||
let mut vfs = vfs_result.unwrap();
|
||||
// read the file
|
||||
let foo_fd = vfs.open_file("foo.txt").unwrap();
|
||||
let bar_fd = vfs.open_file("bar.txt").unwrap();
|
||||
let mut foo_actual_data: [u8; 12] = [0; 12];
|
||||
let foo_read_result = vfs.read_file(foo_fd, &mut foo_actual_data);
|
||||
let mut bar_actual_data: [u8; 8] = [0; 8];
|
||||
let bar_read_result = vfs.read_file(bar_fd, &mut bar_actual_data);
|
||||
assert!(foo_read_result.is_ok(), "Failed to read foo.txt from vfs");
|
||||
assert!(bar_read_result.is_ok(), "Failed to read bar.txt from vfs");
|
||||
let foo_expected_data: &[u8; 12] = b"foo foo foo\n";
|
||||
let bar_expected_data: &[u8; 8] = b"bar bar\n";
|
||||
assert_eq!(
|
||||
&foo_actual_data, foo_expected_data,
|
||||
"Contents of `foo.txt` is not correct"
|
||||
);
|
||||
assert_eq!(
|
||||
&bar_actual_data, bar_expected_data,
|
||||
"Contents of `bar.txt` is not correct"
|
||||
);
|
||||
// assert import errors
|
||||
assert_eq!(
|
||||
vfs.import_errors.len(),
|
||||
0,
|
||||
"Expected no import errors. Found {} errors.",
|
||||
vfs.import_errors.len()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn two_nested_files_in_archive() {
|
||||
// SETUP: create temp dir and files
|
||||
let tmp_dir = tempdir::TempDir::new("two_nested_files_in_archive").unwrap();
|
||||
let baz_dir_path = tmp_dir.path().join("foo").join("bar");
|
||||
fs::create_dir_all(baz_dir_path.clone()).unwrap();
|
||||
let quuz_dir_path = tmp_dir.path().join("qux").join("quuz");
|
||||
fs::create_dir_all(quuz_dir_path.clone()).unwrap();
|
||||
let baz_file_path = baz_dir_path.join("baz.txt");
|
||||
let quuz_file_path = quuz_dir_path.join("quuz.txt");
|
||||
let mut baz_tmp_file = File::create(baz_file_path.clone()).unwrap();
|
||||
let mut quuz_tmp_file = File::create(quuz_file_path.clone()).unwrap();
|
||||
writeln!(baz_tmp_file, "baz baz baz baz").unwrap();
|
||||
writeln!(quuz_tmp_file, "quuz").unwrap();
|
||||
let tar_data = vec![];
|
||||
let mut ar = tar::Builder::new(tar_data);
|
||||
ar.append_path_with_name(baz_file_path, "foo/bar/baz.txt")
|
||||
.unwrap();
|
||||
ar.append_path_with_name(quuz_file_path, "qux/quux/quuz.txt")
|
||||
.unwrap();
|
||||
let archive = ar.into_inner().unwrap();
|
||||
// SETUP: create virtual filesystem with tar data
|
||||
let vfs_result = Vfs::from_tar_bytes(&archive[..]);
|
||||
// ASSERT:
|
||||
assert!(
|
||||
vfs_result.is_ok(),
|
||||
"Failed to create file system from archive"
|
||||
);
|
||||
let mut vfs = vfs_result.unwrap();
|
||||
// read the file
|
||||
let baz_fd = vfs.open_file("foo/bar/baz.txt").unwrap();
|
||||
let quuz_fd = vfs.open_file("qux/quux/quuz.txt").unwrap();
|
||||
let mut baz_actual_data: [u8; 16] = [0; 16];
|
||||
let baz_read_result = vfs.read_file(baz_fd, &mut baz_actual_data);
|
||||
let mut quuz_actual_data: [u8; 5] = [0; 5];
|
||||
let quuz_read_result = vfs.read_file(quuz_fd, &mut quuz_actual_data);
|
||||
assert!(
|
||||
baz_read_result.is_ok(),
|
||||
"Failed to read foo/bar/baz.txt from vfs"
|
||||
);
|
||||
assert!(
|
||||
quuz_read_result.is_ok(),
|
||||
"Failed to read qux/quux/quuz.txt from vfs"
|
||||
);
|
||||
let baz_expected_data: &[u8; 16] = b"baz baz baz baz\n";
|
||||
let quuz_expected_data: &[u8; 5] = b"quuz\n";
|
||||
assert_eq!(
|
||||
&baz_actual_data, baz_expected_data,
|
||||
"Contents of `foo/bar/baz.txt` is not correct"
|
||||
);
|
||||
assert_eq!(
|
||||
&quuz_actual_data, quuz_expected_data,
|
||||
"Contents of `qux/quux/quuz.txt` is not correct"
|
||||
);
|
||||
// assert import errors
|
||||
assert_eq!(
|
||||
vfs.import_errors.len(),
|
||||
0,
|
||||
"Expected no import errors. Found {} errors.",
|
||||
vfs.import_errors.len()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod dup_test {
|
||||
use crate::vfs::vfs::{Fd, Vfs};
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
use std::sync::Arc;
|
||||
|
||||
#[test]
|
||||
fn duplicates_file_descriptor() {
|
||||
// SETUP: create temp dir and files
|
||||
let tmp_dir = tempdir::TempDir::new("two_files_in_archive").unwrap();
|
||||
let foo_file_path = tmp_dir.path().join("foo.txt");
|
||||
let bar_file_path = tmp_dir.path().join("bar.txt");
|
||||
let mut foo_tmp_file = File::create(foo_file_path.clone()).unwrap();
|
||||
let mut bar_tmp_file = File::create(bar_file_path.clone()).unwrap();
|
||||
writeln!(foo_tmp_file, "foo foo foo").unwrap();
|
||||
writeln!(bar_tmp_file, "bar bar").unwrap();
|
||||
let tar_data = vec![];
|
||||
let mut ar = tar::Builder::new(tar_data);
|
||||
ar.append_path_with_name(foo_file_path, "foo.txt").unwrap();
|
||||
ar.append_path_with_name(bar_file_path, "bar.txt").unwrap();
|
||||
let archive = ar.into_inner().unwrap();
|
||||
// SETUP: create virtual filesystem with tar data
|
||||
let vfs_result = Vfs::from_tar_bytes(&archive[..]);
|
||||
// ASSERT:
|
||||
assert!(
|
||||
vfs_result.is_ok(),
|
||||
"Failed to create file system from archive"
|
||||
);
|
||||
let mut vfs = vfs_result.unwrap();
|
||||
|
||||
let source_fd = vfs.open_file("foo.txt").unwrap();
|
||||
let target_fd: Fd = 10;
|
||||
assert_ne!(
|
||||
source_fd, target_fd,
|
||||
"Test setup failed. The source descriptor is identical to desired target descriptor."
|
||||
);
|
||||
|
||||
let mut fds = vec![];
|
||||
fds.push(Arc::new(100));
|
||||
fds.push(Arc::new(200));
|
||||
|
||||
let result = vfs.duplicate_file_descriptor(source_fd, target_fd);
|
||||
|
||||
assert!(result.is_ok(), "Failed to duplicated file descriptor.");
|
||||
// assert import errors
|
||||
assert_eq!(
|
||||
vfs.import_errors.len(),
|
||||
0,
|
||||
"Expected no import errors. Found {} errors.",
|
||||
vfs.import_errors.len()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
@ -1,41 +1,23 @@
|
||||
use failure::Error;
|
||||
|
||||
use crate::vfs::file_like::{FileLike, Metadata};
|
||||
use std::io;
|
||||
use std::io::{Seek, SeekFrom, Write};
|
||||
|
||||
pub struct VirtualFile {
|
||||
zbox_file: zbox::File,
|
||||
}
|
||||
|
||||
impl VirtualFile {
|
||||
pub fn new(file: zbox::File) -> Self {
|
||||
VirtualFile { zbox_file: file }
|
||||
}
|
||||
}
|
||||
|
||||
impl FileLike for VirtualFile {
|
||||
fn write(&mut self, buf: &[u8], count: usize, offset: usize) -> Result<usize, Error> {
|
||||
use std::io::{Seek, SeekFrom};
|
||||
self.zbox_file.seek(SeekFrom::Start(offset as u64))?;
|
||||
let _ = self.zbox_file.write_once(&buf[..count])?;
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
|
||||
use std::io::Read;
|
||||
self.zbox_file.read(buf).map_err(|e| e.into())
|
||||
}
|
||||
|
||||
fn close(&self) -> Result<(), Error> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
impl FileLike for zbox::File {
|
||||
fn metadata(&self) -> Result<Metadata, Error> {
|
||||
self.zbox_file
|
||||
.metadata()
|
||||
self.metadata()
|
||||
.map(|m| Metadata {
|
||||
len: m.content_len(),
|
||||
is_file: m.is_file(),
|
||||
})
|
||||
.map_err(|e: zbox::Error| e.into())
|
||||
}
|
||||
|
||||
fn write_file(&mut self, buf: &[u8], offset: usize) -> Result<usize, io::Error> {
|
||||
self.seek(SeekFrom::Start(offset as _))?;
|
||||
let result = self.write(buf);
|
||||
self.finish().unwrap();
|
||||
result
|
||||
}
|
||||
}
|
||||
|
@ -1,10 +1,6 @@
|
||||
use crate::types::{
|
||||
FuncSig, GlobalDescriptor, MemoryDescriptor, MemoryIndex, TableDescriptor, TableIndex, Type,
|
||||
Value,
|
||||
};
|
||||
use crate::types::{FuncSig, GlobalDescriptor, MemoryDescriptor, TableDescriptor, Type, Value};
|
||||
use core::borrow::Borrow;
|
||||
use std::any::Any;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub type Result<T> = std::result::Result<T, Error>;
|
||||
pub type CompileResult<T> = std::result::Result<T, CompileError>;
|
||||
|
@ -1,8 +1,4 @@
|
||||
use crate::error::{CompileError, CompileResult};
|
||||
use crate::{
|
||||
memory::MemoryType, module::ModuleInfo, module::ModuleInner, structures::TypedIndex,
|
||||
units::Pages,
|
||||
};
|
||||
use crate::{memory::MemoryType, module::ModuleInfo, structures::TypedIndex, units::Pages};
|
||||
use std::{borrow::Cow, mem};
|
||||
|
||||
/// Represents a WebAssembly type.
|
||||
|
@ -540,7 +540,7 @@ mod vm_ctx_tests {
|
||||
use crate::backend::{
|
||||
sys::Memory, Backend, CacheGen, FuncResolver, ProtectedCaller, Token, UserTrapper,
|
||||
};
|
||||
use crate::cache::{Error as CacheError, WasmHash};
|
||||
use crate::cache::Error as CacheError;
|
||||
use crate::error::RuntimeResult;
|
||||
use crate::types::{FuncIndex, LocalFuncIndex, Value};
|
||||
use hashbrown::HashMap;
|
||||
|
Loading…
x
Reference in New Issue
Block a user