fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-06-22 13:11:32 +00:00
Code Issues Projects Releases Wiki Activity

this commit makes the whole thing work

Browse Source
This commit is contained in:
Mackenzie Clark
2019-03-22 15:35:38 -07:00
parent eedb6b9d72
commit b7c5f27b37
4 changed files with 167 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,10 +1,10 @@
use wasmer_runtime_core::vm::Ctx;
use crate::macros::emscripten_memory_ptr;
use crate::syscalls::emscripten_vfs::{FileHandle, VirtualFd};
use crate::varargs::VarArgs;
use std::collections::HashMap;
use std::slice;
use crate::syscalls::emscripten_vfs::{FileHandle, VirtualFd};
use std::ffi::c_void;
use crate::macros::emscripten_memory_ptr;
use std::slice;
use wasmer_runtime_core::vm::Ctx;
#[cfg(feature = "vfs")]
#[derive(Debug)]
@ -14,8 +14,12 @@ struct FdPair {
}
#[cfg(feature = "vfs")]
fn translate_to_host_file_descriptors(ctx: &mut Ctx, mut varargs: &mut VarArgs, nfds: i32, fds_set_offset: u32) -> (i32, HashMap<i32, i32>, Vec<FdPair>) {
fn translate_to_host_file_descriptors(
ctx: &mut Ctx,
mut varargs: &mut VarArgs,
nfds: i32,
fds_set_offset: u32,
) -> (i32, HashMap<i32, i32>, Vec<FdPair>) {
let set_ptr = emscripten_memory_ptr(ctx.memory(0), fds_set_offset) as *mut _; // e.g. libc::unix::bsd::fd_set
let set_u8_ptr = set_ptr as *mut u8;
@ -23,12 +27,12 @@ fn translate_to_host_file_descriptors(ctx: &mut Ctx, mut varargs: &mut VarArgs,
let end_offset = fds_set_offset as usize + bit_array_size;
let set_view = &ctx.memory(0).view::<u8>()[(fds_set_offset as usize)..end_offset];
use bit_field::BitArray;
// let check = set_ptr.get_bit(1);
// let check = set_ptr.get_bit(1);
let fds_slice = unsafe { slice::from_raw_parts(set_u8_ptr, bit_array_size) };
// (0usize..nfds as usize).filter_map(|x| fds_slice.get_bit(x));
// let ofds = (0..nfds).filter_map(|v| fd_slice.v)
// (0usize..nfds as usize).filter_map(|x| fds_slice.get_bit(x));
// let ofds = (0..nfds).filter_map(|v| fd_slice.v)
let original_fds: Vec<i32> = (0..nfds)
.filter_map(|virtual_fd| {
if fds_slice.get_bit(virtual_fd as usize) {
@ -36,18 +40,22 @@ fn translate_to_host_file_descriptors(ctx: &mut Ctx, mut varargs: &mut VarArgs,
} else {
None
}
}).collect::<Vec<_>>();
})
.collect::<Vec<_>>();
let vfs = crate::env::get_emscripten_data(ctx).vfs.as_mut().unwrap();
// virtual read and write file descriptors
let file_descriptor_pairs = original_fds.iter()
let file_descriptor_pairs = original_fds
.iter()
.filter(|vfd| {
if let FileHandle::VirtualFile(handle) = vfs.fd_map.get(&VirtualFd(**vfd)).unwrap() {
debug!("skipping virtual fd {} (vbox handle {}) because is a virtual file", *vfd, *handle);
debug!(
"skipping virtual fd {} (vbox handle {}) because is a virtual file",
*vfd, *handle
);
false
}
else {
} else {
true
}
})
@ -56,7 +64,7 @@ fn translate_to_host_file_descriptors(ctx: &mut Ctx, mut varargs: &mut VarArgs,
let file_handle = vfs.fd_map.get(&vfd).unwrap();
let host_fd = match file_handle {
FileHandle::Socket(host_fd) => host_fd,
// FileHandle::VirtualFile(handle) => handle,
// FileHandle::VirtualFile(handle) => handle,
_ => panic!(),
};
let pair = FdPair {
@ -77,8 +85,10 @@ fn translate_to_host_file_descriptors(ctx: &mut Ctx, mut varargs: &mut VarArgs,
// helper look up tables
let mut lookup = HashMap::new();
for pair in file_descriptor_pairs.iter() {
// if pair.virtual_fd > sz { sz = pair.host_fd }
if pair.host_fd > sz { sz = pair.host_fd }
// if pair.virtual_fd > sz { sz = pair.host_fd }
if pair.host_fd > sz {
sz = pair.host_fd
}
lookup.insert(pair.host_fd, pair.virtual_fd);
}
@ -86,9 +96,13 @@ fn translate_to_host_file_descriptors(ctx: &mut Ctx, mut varargs: &mut VarArgs,
(max_file_descriptor, lookup, file_descriptor_pairs)
}
#[cfg(feature = "vfs")]
fn translate_to_virtual_file_descriptors(ctx: &mut Ctx, nfds: i32, fds_set_offset: u32, lookup: HashMap<i32, i32>) -> Vec<FdPair> {
fn translate_to_virtual_file_descriptors(
ctx: &mut Ctx,
nfds: i32,
fds_set_offset: u32,
lookup: HashMap<i32, i32>,
) -> Vec<FdPair> {
let set_ptr = emscripten_memory_pointer!(ctx.memory(0), fds_set_offset) as *mut _;
let set_u8_ptr = set_ptr as *mut u8;
let fds_slice = unsafe { slice::from_raw_parts_mut(set_u8_ptr, nfds as usize) };
@ -101,20 +115,28 @@ fn translate_to_virtual_file_descriptors(ctx: &mut Ctx, nfds: i32, fds_set_offse
} else {
None
}
}).collect::<Vec<_>>();
})
.collect::<Vec<_>>();
// swap descriptors back
let pairs = fds.iter()
let pairs = fds
.iter()
.filter_map(|host_fd| {
lookup.get(&host_fd).map(|virtual_fd| (*virtual_fd, host_fd))
lookup
.get(&host_fd)
.map(|virtual_fd| (*virtual_fd, host_fd))
})
.map(|(virtual_fd, host_fd)| {
unsafe {
libc::FD_CLR(*host_fd, set_ptr);
libc::FD_SET(virtual_fd, set_ptr);
}
FdPair { virtual_fd, host_fd: *host_fd }
}).collect::<Vec<_>>();
FdPair {
virtual_fd,
host_fd: *host_fd,
}
})
.collect::<Vec<_>>();
pairs
}
@ -132,35 +154,93 @@ pub fn ___syscall142(ctx: &mut Ctx, _which: libc::c_int, mut varargs: VarArgs) -
let readfds_set_ptr = emscripten_memory_pointer!(ctx.memory(0), readfds) as *mut _;
let writefds_set_ptr = emscripten_memory_pointer!(ctx.memory(0), writefds) as *mut _;
// debug!(" select read descriptors: {:?}", read_fds);
//
// debug!("select write descriptors: {:?}", write_fds);
// debug!(" select read descriptors: {:?}", read_fds);
//
// debug!("select write descriptors: {:?}", write_fds);
let (read_max, read_lookup, read_pairs)
= translate_to_host_file_descriptors(ctx, &mut varargs, nfds, readfds);
let (write_max, write_lookup, write_pairs)
= translate_to_host_file_descriptors(ctx, &mut varargs, nfds, writefds);
let (read_max, read_lookup, read_pairs) =
translate_to_host_file_descriptors(ctx, &mut varargs, nfds, readfds);
let (write_max, write_lookup, write_pairs) =
translate_to_host_file_descriptors(ctx, &mut varargs, nfds, writefds);
let max = if read_max > write_max { read_max } else { write_max };
let max = if read_max > write_max {
read_max
} else {
write_max
};
debug!("max host fd for select: {}", max);
let mut sz = max;
debug!("set read descriptors BEFORE select: {:?}", read_pairs);
debug!("set write descriptors BEFORE select: {:?}", write_pairs);
debug!(
"set read descriptors BEFORE select: {:?}",
read_pairs // .iter()
// .map(|pair| pair.virtual_fd)
// .collect::<Vec<_>>()
);
debug!(
"set write descriptors BEFORE select: {:?}",
write_pairs // .iter()
// .map(|pair| pair.virtual_fd)
// .collect::<Vec<_>>()
);
// call `select`
sz = sz + 1;
debug!(
"readfds_set_ptr: {:?}",
read_pairs
.iter()
.map(|pair| pair.host_fd)
.collect::<Vec<_>>()
);
let fds_slice = unsafe { slice::from_raw_parts(readfds_set_ptr as *const u8, 4) } as &[u8];
debug!("host read set before: {:?}", fds_slice);
let mut result = unsafe { libc::select(sz, readfds_set_ptr, writefds_set_ptr, 0 as _, 0 as _) };
debug!("host read set after: {:?}", fds_slice);
unsafe {
use libc::FD_ISSET;
let s = 3;
let x = [
FD_ISSET(s, readfds_set_ptr),
FD_ISSET(s + 1, readfds_set_ptr),
FD_ISSET(s + 2, readfds_set_ptr),
FD_ISSET(s + 3, readfds_set_ptr),
FD_ISSET(s + 4, readfds_set_ptr),
FD_ISSET(s + 5, readfds_set_ptr),
FD_ISSET(s + 6, readfds_set_ptr),
FD_ISSET(s + 7, readfds_set_ptr),
FD_ISSET(s + 8, readfds_set_ptr),
FD_ISSET(s + 9, readfds_set_ptr),
FD_ISSET(s + 10, readfds_set_ptr),
FD_ISSET(s + 11, readfds_set_ptr),
];
debug!("sets (start with fd #{}: {:?}", s, x);
}
if result == -1 {
panic!("result returned from select was -1. The errno code: {}", errno::errno());
panic!(
"result returned from select was -1. The errno code: {}",
errno::errno()
);
}
let read_pairs = translate_to_virtual_file_descriptors(ctx, sz, readfds, read_lookup);
debug!("select read descriptors after select completes: {:?}", read_pairs);
debug!(
"select read descriptors after select completes: {:?}",
read_pairs // .iter()
// .map(|pair| pair.virtual_fd)
// .collect::<Vec<_>>()
);
let write_pairs = translate_to_virtual_file_descriptors(ctx, sz, writefds, write_lookup);
debug!("select write descriptors after select completes: {:?}", write_pairs);
debug!(
"select write descriptors after select completes: {:?}",
write_pairs // .iter()
// .map(|pair| pair.virtual_fd)
// .collect::<Vec<_>>()
);
debug!("select returns {}", result);
result