fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-03-16 00:00:49 +00:00
Code Issues Projects Releases Wiki Activity

refactor everything

Browse Source
This commit is contained in:
Mackenzie Clark 2019-03-25 19:43:52 -07:00
parent 8432ce9238
commit 7c9e537443
25 changed files with 445 additions and 2095 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Cargo.lock generated
View File

@ -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"

4
lib/emscripten/Cargo.toml
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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);

10
lib/emscripten/src/lib.rs
View File

@ -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[..]) {

7
lib/emscripten/src/macros.rs
View File

@ -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
}

245
lib/emscripten/src/syscalls/emscripten_vfs.rs
View File

@ -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
lib/emscripten/src/syscalls/mod.rs
View File

@ -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;

48
lib/emscripten/src/syscalls/unix/host_fs.rs
View File

@ -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
}

8
lib/emscripten/src/syscalls/unix/mod.rs
View File

@ -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
}

47
lib/emscripten/src/syscalls/unix/select.rs
View File

@ -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
}

475
lib/emscripten/src/syscalls/unix/vfs.rs
View File

@ -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
}

26
lib/emscripten/src/syscalls/windows/mod.rs → lib/emscripten/src/syscalls/windows.rs
View File

@ -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;

35
lib/emscripten/src/syscalls/windows/host_fs.rs
View File

@ -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) }
}

885
lib/emscripten/src/syscalls/windows/vfs.rs
View File

@ -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
}

2
lib/emscripten/tests/emtests/mod.rs
View File

@ -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;

1
lib/runtime-abi/Cargo.toml
View File

@ -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"

61
lib/runtime-abi/src/vfs/device_file.rs
View File

@ -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!()
}
}

13
lib/runtime-abi/src/vfs/file_like.rs
View File

@ -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>;
}

576
lib/runtime-abi/src/vfs/vfs.rs
View File

@ -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()
);
}
}

40
lib/runtime-abi/src/vfs/virtual_file.rs
View File

@ -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
}
}

6
lib/runtime-core/src/error.rs
View File

@ -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>;

6
lib/runtime-core/src/types.rs
View File

@ -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.

2
lib/runtime-core/src/vm.rs
View File

@ -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;