mii/wasmer
1
0
Fork 0
mirror of https://github.com/mii443/wasmer.git synced 2025-12-06 20:58:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

MemoryView lifetime tied to memory and not StoreRef

Browse Source
This commit is contained in:
ptitSeb
2022-08-11 17:00:47 +02:00
parent fcf476ef6e
commit 7ec2d603bf
17 changed files with 173 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lib/api/src/sys/externals/memory.rs vendored
View File

@@ -11,7 +11,7 @@ use std::slice;
#[cfg(feature = "tracing")]
use tracing::warn;
use wasmer_types::Pages;
use wasmer_vm::{InternalStoreHandle, MemoryError, StoreHandle, StoreObjects, VMExtern, VMMemory};
use wasmer_vm::{InternalStoreHandle, MemoryError, StoreHandle, VMExtern, VMMemory};
use super::MemoryView;
@@ -79,7 +79,7 @@ impl Memory {
/// Creates a view into the memory that then allows for
/// read and write
pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
pub fn view<'a>(&'a self, store: &impl AsStoreRef) -> MemoryView<'a> {
MemoryView::new(self, store)
}
@@ -169,7 +169,7 @@ impl<'a> Exportable<'a> for Memory {
pub(crate) struct MemoryBuffer<'a> {
pub(crate) base: *mut u8,
pub(crate) len: usize,
pub(crate) marker: PhantomData<(&'a MemoryView<'a>, &'a StoreObjects)>,
pub(crate) marker: PhantomData<&'a MemoryView<'a>>,
}
impl<'a> MemoryBuffer<'a> {

2
lib/api/src/sys/externals/memory_view.rs vendored
View File

@@ -22,7 +22,7 @@ pub struct MemoryView<'a> {
}
impl<'a> MemoryView<'a> {
pub(crate) fn new(memory: &Memory, store: &'a impl AsStoreRef) -> Self {
pub(crate) fn new(memory: &'a Memory, store: &impl AsStoreRef) -> Self {
let size = memory.handle.get(store.as_store_ref().objects()).size();
let definition = memory.handle.get(store.as_store_ref().objects()).vmmemory();

14
lib/emscripten/src/env/mod.rs vendored
View File

@@ -75,17 +75,15 @@ pub fn ___build_environment(mut ctx: FunctionEnvMut<EmEnv>, environ: c_int) {
debug!("emscripten::___build_environment {}", environ);
const MAX_ENV_VALUES: u32 = 64;
const TOTAL_ENV_SIZE: u32 = 1024;
let environment =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), environ) as *mut c_int;
let memory = ctx.data().memory(0);
let environment = emscripten_memory_pointer!(memory.view(&ctx), environ) as *mut c_int;
let (mut pool_offset, env_ptr, mut pool_ptr) = unsafe {
let (pool_offset, _pool_slice): (u32, &mut [u8]) =
allocate_on_stack(&mut ctx, TOTAL_ENV_SIZE as u32);
let (env_offset, _env_slice): (u32, &mut [u8]) =
allocate_on_stack(&mut ctx, (MAX_ENV_VALUES * 4) as u32);
let env_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), env_offset) as *mut c_int;
let pool_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), pool_offset) as *mut u8;
let env_ptr = emscripten_memory_pointer!(memory.view(&ctx), env_offset) as *mut c_int;
let pool_ptr = emscripten_memory_pointer!(memory.view(&ctx), pool_offset) as *mut u8;
*env_ptr = pool_offset as i32;
*environment = env_offset as i32;
@@ -137,8 +135,8 @@ pub fn _pathconf(ctx: FunctionEnvMut<EmEnv>, path_addr: c_int, name: c_int) -> c
"emscripten::_pathconf {} {} - UNIMPLEMENTED",
path_addr, name
);
let _path =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), path_addr) as *const c_char;
let memory = ctx.data().memory(0);
let _path = emscripten_memory_pointer!(memory.view(&ctx), path_addr) as *const c_char;
match name {
0 => 32000,
1 | 2 | 3 => 255,

54
lib/emscripten/src/env/unix/mod.rs vendored
View File

@@ -17,8 +17,8 @@ use wasmer::{FunctionEnvMut, WasmPtr};
pub fn _getenv(mut ctx: FunctionEnvMut<EmEnv>, name: i32) -> u32 {
debug!("emscripten::_getenv");
let name_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), name) as *const c_char;
let memory = ctx.data().memory(0);
let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
@@ -34,10 +34,9 @@ pub fn _getenv(mut ctx: FunctionEnvMut<EmEnv>, name: i32) -> u32 {
pub fn _setenv(ctx: FunctionEnvMut<EmEnv>, name: c_int, value: c_int, overwrite: c_int) -> c_int {
debug!("emscripten::_setenv");
let name_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), name) as *const c_char;
let value_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), value) as *const c_char;
let memory = ctx.data().memory(0);
let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
let value_addr = emscripten_memory_pointer!(memory.view(&ctx), value) as *const c_char;
debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
debug!("=> value({:?})", unsafe { CStr::from_ptr(value_addr) });
@@ -49,8 +48,8 @@ pub fn _setenv(ctx: FunctionEnvMut<EmEnv>, name: c_int, value: c_int, overwrite:
pub fn _putenv(ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
debug!("emscripten::_putenv");
let name_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), name) as *const c_char;
let memory = ctx.data().memory(0);
let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
@@ -61,8 +60,8 @@ pub fn _putenv(ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
pub fn _unsetenv(ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
debug!("emscripten::_unsetenv");
let name_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), name) as *const c_char;
let memory = ctx.data().memory(0);
let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
@@ -86,8 +85,9 @@ pub fn _getpwnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
pw_shell: u32,
}
let memory = ctx.data().memory(0);
let name = unsafe {
let memory = ctx.data().memory_view(0, &ctx);
let memory = memory.view(&ctx);
let memory_name_ptr = emscripten_memory_pointer!(&memory, name_ptr) as *const c_char;
CStr::from_ptr(memory_name_ptr)
};
@@ -96,7 +96,7 @@ pub fn _getpwnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
let passwd = &*libc_getpwnam(name.as_ptr());
let passwd_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestPasswd>() as _);
let memory = ctx.data().memory_view(0, &ctx);
let memory = memory.view(&ctx);
let passwd_struct_ptr =
emscripten_memory_pointer!(&memory, passwd_struct_offset) as *mut GuestPasswd;
(*passwd_struct_ptr).pw_name = copy_cstr_into_wasm(&mut ctx, passwd.pw_name);
@@ -123,9 +123,10 @@ pub fn _getgrnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
gr_mem: u32,
}
let memory = ctx.data().memory(0);
let name = unsafe {
let memory_name_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), name_ptr) as *const c_char;
emscripten_memory_pointer!(memory.view(&ctx), name_ptr) as *const c_char;
CStr::from_ptr(memory_name_ptr)
};
@@ -134,8 +135,7 @@ pub fn _getgrnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
let group_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestGroup>() as _);
let group_struct_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), group_struct_offset)
as *mut GuestGroup;
emscripten_memory_pointer!(memory.view(&ctx), group_struct_offset) as *mut GuestGroup;
(*group_struct_ptr).gr_name = copy_cstr_into_wasm(&mut ctx, group.gr_name);
(*group_struct_ptr).gr_passwd = copy_cstr_into_wasm(&mut ctx, group.gr_passwd);
(*group_struct_ptr).gr_gid = group.gr_gid;
@@ -158,7 +158,8 @@ pub fn _gai_strerror(mut ctx: FunctionEnvMut<EmEnv>, ecode: i32) -> i32 {
let cstr = unsafe { std::ffi::CStr::from_ptr(libc::gai_strerror(ecode)) };
let bytes = cstr.to_bytes_with_nul();
let string_on_guest: WasmPtr<c_char> = call_malloc_with_cast(&mut ctx, bytes.len() as _);
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
let writer = string_on_guest.slice(&memory, bytes.len() as _).unwrap();
for (i, byte) in bytes.iter().enumerate() {
@@ -195,10 +196,8 @@ pub fn _getaddrinfo(
let hints = if hints_ptr.is_null() {
None
} else {
let hints_guest = hints_ptr
.deref(&ctx.data().memory_view(0, &ctx))
.read()
.unwrap();
let memory = ctx.data().memory(0);
let hints_guest = hints_ptr.deref(&memory.view(&ctx)).read().unwrap();
Some(addrinfo {
ai_flags: hints_guest.ai_flags,
ai_family: hints_guest.ai_family,
@@ -252,7 +251,8 @@ pub fn _getaddrinfo(
// connect list
if let Some(prev_guest) = previous_guest_node {
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
let derefed_prev_guest = prev_guest.deref(&memory);
let mut pg = derefed_prev_guest.read().unwrap();
pg.ai_next = current_guest_node_ptr;
@@ -268,7 +268,8 @@ pub fn _getaddrinfo(
let guest_sockaddr_ptr: WasmPtr<EmSockAddr> =
call_malloc_with_cast(&mut ctx, host_addrlen as _);
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
let derefed_guest_sockaddr = guest_sockaddr_ptr.deref(&memory);
let mut gs = derefed_guest_sockaddr.read().unwrap();
gs.sa_family = (*host_sockaddr_ptr).sa_family as i16;
@@ -288,7 +289,8 @@ pub fn _getaddrinfo(
let guest_canonname: WasmPtr<c_char> =
call_malloc_with_cast(&mut ctx, str_size as _);
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
let guest_canonname_writer =
guest_canonname.slice(&memory, str_size as _).unwrap();
for (i, b) in canonname_bytes.iter().enumerate() {
@@ -304,7 +306,8 @@ pub fn _getaddrinfo(
}
};
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
let derefed_current_guest_node = current_guest_node_ptr.deref(&memory);
let mut cgn = derefed_current_guest_node.read().unwrap();
cgn.ai_flags = (*current_host_node).ai_flags;
@@ -325,8 +328,9 @@ pub fn _getaddrinfo(
head_of_list.unwrap_or_else(|| WasmPtr::new(0))
};
let memory = ctx.data().memory(0);
res_val_ptr
.deref(&ctx.data().memory_view(0, &ctx))
.deref(&memory.view(&ctx))
.write(head_of_list)
.unwrap();

3
lib/emscripten/src/exec.rs
View File

@@ -7,7 +7,8 @@ use wasmer::{FunctionEnvMut, WasmPtr};
pub fn execvp(ctx: FunctionEnvMut<EmEnv>, command_name_offset: u32, argv_offset: u32) -> i32 {
// a single reference to re-use
let emscripten_memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let emscripten_memory = memory.view(&ctx);
// read command name as string
let command_name_string_vec = WasmPtr::<u8>::new(command_name_offset)

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

@@ -28,9 +28,10 @@ pub fn getprotobynumber(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
/// sigdelset
pub fn sigdelset(ctx: FunctionEnvMut<EmEnv>, set: i32, signum: i32) -> i32 {
debug!("emscripten::sigdelset");
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let view = memory.view(&ctx);
#[allow(clippy::cast_ptr_alignment)]
let ptr = emscripten_memory_pointer!(&memory, set) as *mut i32;
let ptr = emscripten_memory_pointer!(&view, set) as *mut i32;
unsafe { *ptr &= !(1 << (signum - 1)) }
@@ -40,9 +41,10 @@ pub fn sigdelset(ctx: FunctionEnvMut<EmEnv>, set: i32, signum: i32) -> i32 {
/// sigfillset
pub fn sigfillset(ctx: FunctionEnvMut<EmEnv>, set: i32) -> i32 {
debug!("emscripten::sigfillset");
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let view = memory.view(&ctx);
#[allow(clippy::cast_ptr_alignment)]
let ptr = emscripten_memory_pointer!(&memory, set) as *mut i32;
let ptr = emscripten_memory_pointer!(&view, set) as *mut i32;
unsafe {
*ptr = -1;

6
lib/emscripten/src/io/unix.rs
View File

@@ -15,7 +15,7 @@ pub fn putchar(_ctx: FunctionEnvMut<EmEnv>, chr: i32) {
pub fn printf(ctx: FunctionEnvMut<EmEnv>, memory_offset: i32, extra: i32) -> i32 {
debug!("emscripten::printf {}, {}", memory_offset, extra);
unsafe {
let addr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), memory_offset) as _;
let addr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), memory_offset) as _;
_printf(addr, extra)
}
}
@@ -23,7 +23,7 @@ pub fn printf(ctx: FunctionEnvMut<EmEnv>, memory_offset: i32, extra: i32) -> i32
/// chroot
pub fn chroot(ctx: FunctionEnvMut<EmEnv>, name_ptr: i32) -> i32 {
debug!("emscripten::chroot");
let name = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), name_ptr) as *const i8;
let name = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), name_ptr) as *const i8;
unsafe { _chroot(name as *const _) }
}
@@ -47,7 +47,7 @@ pub fn getpwuid(mut ctx: FunctionEnvMut<EmEnv>, uid: i32) -> i32 {
let passwd = &*_getpwuid(uid as _);
let passwd_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestPasswd>() as _);
let passwd_struct_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), passwd_struct_offset)
emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), passwd_struct_offset)
as *mut GuestPasswd;
assert_eq!(
passwd_struct_ptr as usize % std::mem::align_of::<GuestPasswd>(),

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

@@ -23,9 +23,9 @@ use std::f64;
use std::path::PathBuf;
use std::sync::{Arc, Mutex, RwLock};
use wasmer::{
imports, namespace, AsStoreMut, AsStoreRef, ExportError, Exports, Function, FunctionEnv,
FunctionEnvMut, FunctionType, Global, Imports, Instance, Memory, MemoryType, MemoryView,
Module, Pages, RuntimeError, Table, TableType, TypedFunction, Value, WasmPtr,
imports, namespace, AsStoreMut, ExportError, Exports, Function, FunctionEnv, FunctionEnvMut,
FunctionType, Global, Imports, Instance, Memory, MemoryType, Module, Pages, RuntimeError,
Table, TableType, TypedFunction, Value, WasmPtr,
};
use wasmer_types::Type as ValType;
@@ -108,11 +108,6 @@ impl EmEnv {
(&*self.memory.read().unwrap()).as_ref().cloned().unwrap()
}
/// Get a reference to the memory view
pub fn memory_view<'a>(&self, mem_idx: u32, store: &'a impl AsStoreRef) -> MemoryView<'a> {
self.memory(mem_idx).view(store)
}
pub fn set_functions(&mut self, funcs: EmscriptenFunctions) {
self.funcs = Arc::new(Mutex::new(funcs));
}

3
lib/emscripten/src/libc.rs
View File

@@ -52,7 +52,8 @@ pub fn killpg(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
#[cfg(unix)]
pub fn pathconf(ctx: FunctionEnvMut<EmEnv>, path_ptr: i32, name: i32) -> i32 {
debug!("emscripten::pathconf");
let path = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), path_ptr) as *const i8;
let memory = ctx.data().memory(0);
let path = emscripten_memory_pointer!(memory.view(&ctx), path_ptr) as *const i8;
unsafe { libc::pathconf(path as *const _, name).try_into().unwrap() }
}

21
lib/emscripten/src/memory.rs
View File

@@ -11,9 +11,9 @@ pub fn _emscripten_memcpy_big(ctx: FunctionEnvMut<EmEnv>, dest: u32, src: u32, l
"emscripten::_emscripten_memcpy_big {}, {}, {}",
dest, src, len
);
let dest_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), dest) as *mut c_void;
let src_addr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), src) as *mut c_void;
let memory = ctx.data().memory(0);
let dest_addr = emscripten_memory_pointer!(memory.view(&ctx), dest) as *mut c_void;
let src_addr = emscripten_memory_pointer!(memory.view(&ctx), src) as *mut c_void;
unsafe {
memcpy(dest_addr, src_addr, len as size_t);
}
@@ -21,7 +21,8 @@ pub fn _emscripten_memcpy_big(ctx: FunctionEnvMut<EmEnv>, dest: u32, src: u32, l
}
fn get_heap_size(ctx: &FunctionEnvMut<EmEnv>) -> u32 {
ctx.data().memory_view(0, &ctx).size().bytes().0 as u32
let memory = ctx.data().memory(0);
memory.view(&ctx).size().bytes().0 as u32
}
/// emscripten: _emscripten_get_heap_size
@@ -43,7 +44,8 @@ fn align_up(mut val: usize, multiple: usize) -> usize {
fn resize_heap(ctx: &mut FunctionEnvMut<EmEnv>, requested_size: u32) -> u32 {
debug!("emscripten::_emscripten_resize_heap {}", requested_size);
let current_memory_pages = ctx.data().memory_view(0, &ctx).size();
let memory = ctx.data().memory(0);
let current_memory_pages = memory.view(&ctx).size();
let current_memory = current_memory_pages.bytes().0 as u32;
// implementation from emscripten
@@ -94,7 +96,8 @@ pub fn sbrk(mut ctx: FunctionEnvMut<EmEnv>, increment: i32) -> i32 {
let dynamictop_ptr = WasmPtr::<i32>::new(top_ptr);
let old_dynamic_top = {
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
dynamictop_ptr.deref(&memory).read().unwrap()
};
let new_dynamic_top: i32 = old_dynamic_top + increment;
@@ -118,7 +121,8 @@ pub fn sbrk(mut ctx: FunctionEnvMut<EmEnv>, increment: i32) -> i32 {
}
}
// re-borrow the top ptr
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
let dynamictop_ptr = WasmPtr::<i32>::new(top_ptr).deref(&memory);
dynamictop_ptr.write(new_dynamic_top).unwrap();
old_dynamic_top as _
@@ -129,7 +133,8 @@ pub fn get_total_memory(ctx: FunctionEnvMut<EmEnv>) -> u32 {
debug!("emscripten::get_total_memory");
// instance.memories[0].current_pages()
// TODO: Fix implementation
ctx.data().memory_view(0, &ctx).size().bytes().0 as u32
let memory = ctx.data().memory(0);
memory.view(&ctx).size().bytes().0 as u32
}
/// emscripten: enlargeMemory

6
lib/emscripten/src/signal.rs
View File

@@ -5,7 +5,8 @@ use wasmer::FunctionEnvMut;
#[allow(clippy::cast_ptr_alignment)]
pub fn _sigemptyset(ctx: FunctionEnvMut<EmEnv>, set: u32) -> i32 {
debug!("emscripten::_sigemptyset");
let set_addr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), set) as *mut u32;
let memory = ctx.data().memory(0);
let set_addr = emscripten_memory_pointer!(memory.view(&ctx), set) as *mut u32;
unsafe {
*set_addr = 0;
}
@@ -25,7 +26,8 @@ pub fn _siginterrupt(_ctx: FunctionEnvMut<EmEnv>, _a: u32, _b: u32) -> i32 {
#[allow(clippy::cast_ptr_alignment)]
pub fn _sigaddset(ctx: FunctionEnvMut<EmEnv>, set: u32, signum: u32) -> i32 {
debug!("emscripten::_sigaddset {}, {}", set, signum);
let set_addr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), set) as *mut u32;
let memory = ctx.data().memory(0);
let set_addr = emscripten_memory_pointer!(memory.view(&ctx), set) as *mut u32;
unsafe {
*set_addr |= 1 << (signum - 1);
}

48
lib/emscripten/src/syscalls/mod.rs
View File

@@ -67,7 +67,8 @@ pub fn ___syscall3(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs
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.data().memory_view(0, &ctx), buf) as *mut c_void;
let memory = ctx.data().memory(0);
let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut c_void;
let ret = unsafe { read(fd, buf_addr, count as _) };
debug!("=> ret: {}", ret);
ret as _
@@ -80,8 +81,8 @@ pub fn ___syscall4(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarAr
let buf: i32 = varargs.get(&ctx);
let count: i32 = varargs.get(&ctx);
debug!("=> fd: {}, buf: {}, count: {}", fd, buf, count);
let buf_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), buf) as *const c_void;
let memory = ctx.data().memory(0);
let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *const c_void;
unsafe { write(fd, buf_addr, count as _) as i32 }
}
@@ -209,7 +210,8 @@ pub fn ___syscall42(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarA
// 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.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let emscripten_memory = memory.view(&ctx);
// convert the file descriptor into a vec with two slots
let mut fd_vec: [c_int; 2] = WasmPtr::<[c_int; 2]>::new(fd_offset)
@@ -355,7 +357,8 @@ pub fn ___syscall183(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs:
let path = get_current_directory(ctx.as_mut());
let path_string = path.unwrap().display().to_string();
let len = path_string.len();
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
let buf_writer = buf_offset.slice(&memory, len as u32 + 1).unwrap();
for (i, byte) in path_string.bytes().enumerate() {
@@ -385,8 +388,8 @@ pub fn ___syscall192(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs:
// ENOMEM
return -12;
}
let real_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), ptr) as *const u8;
let memory = ctx.data().memory(0);
let real_ptr = emscripten_memory_pointer!(memory.view(&ctx), ptr) as *const u8;
env::call_memset(&mut ctx, ptr, 0, len);
for i in 0..(len as usize) {
unsafe {
@@ -412,7 +415,8 @@ pub fn ___syscall140(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarAr
let whence: i32 = varargs.get(&ctx);
let offset = offset_low;
let ret = unsafe { lseek(fd, offset as _, whence) as i64 };
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let memory = memory.view(&ctx);
let result_ptr = result_ptr_value.deref(&memory);
result_ptr.write(ret).unwrap();
@@ -449,13 +453,11 @@ pub fn ___syscall145(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let mut ret = 0;
unsafe {
for i in 0..iovcnt {
let memory = ctx.data().memory(0);
let guest_iov_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), (iov + i * 8))
as *mut GuestIovec;
let iov_base = emscripten_memory_pointer!(
ctx.data().memory_view(0, &ctx),
(*guest_iov_addr).iov_base
) as *mut c_void;
emscripten_memory_pointer!(memory.view(&ctx), (iov + i * 8)) as *mut GuestIovec;
let iov_base = emscripten_memory_pointer!(memory.view(&ctx), (*guest_iov_addr).iov_base)
as *mut c_void;
let iov_len = (*guest_iov_addr).iov_len as _;
// debug!("=> iov_addr: {:?}, {:?}", iov_base, iov_len);
let curr = read(fd, iov_base, iov_len);
@@ -488,13 +490,11 @@ pub fn ___syscall146(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarAr
let mut ret = 0;
for i in 0..iovcnt {
unsafe {
let memory = ctx.data().memory(0);
let guest_iov_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), (iov + i * 8))
as *mut GuestIovec;
let iov_base = emscripten_memory_pointer!(
ctx.data().memory_view(0, &ctx),
(*guest_iov_addr).iov_base
) as *const c_void;
emscripten_memory_pointer!(memory.view(&ctx), (iov + i * 8)) as *mut GuestIovec;
let iov_base = emscripten_memory_pointer!(memory.view(&ctx), (*guest_iov_addr).iov_base)
as *const c_void;
let iov_len = (*guest_iov_addr).iov_len as _;
// debug!("=> iov_addr: {:?}, {:?}", iov_base, iov_len);
let curr = write(fd, iov_base, iov_len);
@@ -522,8 +522,8 @@ pub fn ___syscall191(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarAr
_resource
);
let rlim_emptr: i32 = varargs.get(&ctx);
let rlim_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), rlim_emptr) as *mut u8;
let memory = ctx.data().memory(0);
let rlim_ptr = emscripten_memory_pointer!(memory.view(&ctx), rlim_emptr) as *mut u8;
let rlim = unsafe { slice::from_raw_parts_mut(rlim_ptr, 16) };
// set all to RLIM_INIFINTY
@@ -727,8 +727,8 @@ pub fn ___syscall340(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
if old_limit != 0 {
// just report no limits
let buf_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), old_limit) as *mut u8;
let memory = ctx.data().memory(0);
let buf_ptr = emscripten_memory_pointer!(memory.view(&ctx), old_limit) as *mut u8;
let buf = unsafe { slice::from_raw_parts_mut(buf_ptr, 16) };
LittleEndian::write_i64(&mut *buf, val);

84
lib/emscripten/src/syscalls/unix.rs
View File

@@ -202,9 +202,9 @@ pub fn ___syscall77(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarA
let resource: c_int = varargs.get(&ctx);
let rusage_ptr: c_int = varargs.get(&ctx);
let memory = ctx.data().memory(0);
#[allow(clippy::cast_ptr_alignment)]
let rusage =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), rusage_ptr) as *mut rusage;
let rusage = emscripten_memory_pointer!(memory.view(&ctx), rusage_ptr) as *mut rusage;
assert_eq!(8, mem::align_of_val(&rusage));
unsafe { getrusage(resource, rusage) }
}
@@ -312,8 +312,9 @@ pub fn ___syscall205(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let ngroups_max: c_int = varargs.get(&ctx);
let groups: c_int = varargs.get(&ctx);
let memory = ctx.data().memory(0);
#[allow(clippy::cast_ptr_alignment)]
let gid_ptr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), groups) as *mut gid_t;
let gid_ptr = emscripten_memory_pointer!(memory.view(&ctx), groups) as *mut gid_t;
assert_eq!(4, mem::align_of_val(&gid_ptr));
let result = unsafe { getgroups(ngroups_max, gid_ptr) };
debug!(
@@ -348,7 +349,8 @@ pub fn ___syscall219(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let len: usize = varargs.get(&ctx);
let advice: c_int = varargs.get(&ctx);
let addr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), addr_ptr) as *mut c_void;
let memory = ctx.data().memory(0);
let addr = emscripten_memory_pointer!(memory.view(&ctx), addr_ptr) as *mut c_void;
unsafe { madvise(addr, len, advice) }
}
@@ -487,8 +489,8 @@ pub fn ___syscall54(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarA
WASM_FIOCLEX | WASM_FIONBIO | WASM_TIOCGWINSZ | WASM_TIOCSPGRP | WASM_TCGETS
| WASM_TCSETSW => {
let argp: u32 = varargs.get(&ctx);
let argp_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), argp) as *mut c_void;
let memory = ctx.data().memory(0);
let argp_ptr = emscripten_memory_pointer!(memory.view(&ctx), argp) as *mut c_void;
let translated_request = translate_ioctl(request);
let ret = unsafe { ioctl(fd, translated_request as _, argp_ptr) };
debug!(
@@ -522,7 +524,8 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
debug!("emscripten::___syscall102 (socketcall) {}", _which);
let call: u32 = varargs.get(&ctx);
let mut socket_varargs: VarArgs = varargs.get(&ctx);
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let view = memory.view(&ctx);
// migrating to EmSockAddr, port being separate here is nice, should update that too
#[repr(C)]
@@ -587,7 +590,7 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let socket = socket_varargs.get(&ctx);
let address: u32 = socket_varargs.get(&ctx);
let address_len = socket_varargs.get(&ctx);
let address = emscripten_memory_pointer!(&memory, address) as *mut sockaddr;
let address = emscripten_memory_pointer!(&view, address) as *mut sockaddr;
// Debug received address
let _proper_address = address as *const GuestSockaddrIn;
@@ -612,7 +615,7 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let socket = socket_varargs.get(&ctx);
let address: u32 = socket_varargs.get(&ctx);
let address_len = socket_varargs.get(&ctx);
let address = emscripten_memory_pointer!(&memory, address) as *mut sockaddr;
let address = emscripten_memory_pointer!(&view, address) as *mut sockaddr;
unsafe { connect(socket, address, address_len) }
}
4 => {
@@ -637,10 +640,10 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
debug!(
"=> socket: {}, address: {:?}, address_len: {}",
socket,
address.deref(&memory).read().unwrap(),
address_len.deref(&memory).read().unwrap()
address.deref(&view).read().unwrap(),
address_len.deref(&view).read().unwrap()
);
let mut address_len_addr = address_len.deref(&memory).read().unwrap();
let mut address_len_addr = address_len.deref(&view).read().unwrap();
// let mut address_len_addr: socklen_t = 0;
let mut host_address: sockaddr = sockaddr {
@@ -650,7 +653,7 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
sa_len: Default::default(),
};
let fd = unsafe { accept(socket, &mut host_address, &mut address_len_addr) };
let mut address_addr = address.deref(&memory).read().unwrap();
let mut address_addr = address.deref(&view).read().unwrap();
address_addr.sa_family = host_address.sa_family as _;
address_addr.sa_data = host_address.sa_data;
@@ -674,7 +677,7 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let socket: i32 = socket_varargs.get(&ctx);
let address: WasmPtr<EmSockAddr> = socket_varargs.get(&ctx);
let address_len: WasmPtr<u32> = socket_varargs.get(&ctx);
let address_len_addr = address_len.deref(&memory).read().unwrap();
let address_len_addr = address_len.deref(&view).read().unwrap();
let mut sock_addr_host: sockaddr = sockaddr {
sa_family: Default::default(),
@@ -690,7 +693,7 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
)
};
// translate from host data into emscripten data
let mut address_mut = address.deref(&memory).read().unwrap();
let mut address_mut = address.deref(&view).read().unwrap();
address_mut.sa_family = sock_addr_host.sa_family as _;
address_mut.sa_data = sock_addr_host.sa_data;
@@ -707,9 +710,8 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let socket = socket_varargs.get(&ctx);
let address: u32 = socket_varargs.get(&ctx);
let address_len: u32 = socket_varargs.get(&ctx);
let address = emscripten_memory_pointer!(memory, address) as *mut sockaddr;
let address_len_addr =
emscripten_memory_pointer!(memory, address_len) as *mut socklen_t;
let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
let address_len_addr = emscripten_memory_pointer!(view, address_len) as *mut socklen_t;
unsafe { getpeername(socket, address, address_len_addr) }
}
11 => {
@@ -721,8 +723,8 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
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!(memory, buf) as _;
let address = emscripten_memory_pointer!(memory, address) as *mut sockaddr;
let buf_addr = emscripten_memory_pointer!(view, buf) as _;
let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
unsafe { sendto(socket, buf_addr, flags, len, address, address_len) as i32 }
}
12 => {
@@ -734,10 +736,9 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let flags: 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!(memory, buf) as _;
let address = emscripten_memory_pointer!(memory, address) as *mut sockaddr;
let address_len_addr =
emscripten_memory_pointer!(memory, address_len) as *mut socklen_t;
let buf_addr = emscripten_memory_pointer!(view, buf) as _;
let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
let address_len_addr = emscripten_memory_pointer!(view, address_len) as *mut socklen_t;
unsafe {
recvfrom(
socket,
@@ -761,7 +762,7 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let untranslated_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!(memory, value) as *const libc::c_void;
let value_addr = emscripten_memory_pointer!(view, value) as *const libc::c_void;
let name: i32 = translate_socket_name_flag(untranslated_name);
let ret = unsafe { setsockopt(socket, level, name, value_addr, option_len) };
@@ -779,8 +780,8 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let name: i32 = translate_socket_name_flag(untranslated_name);
let value: u32 = socket_varargs.get(&ctx);
let option_len: u32 = socket_varargs.get(&ctx);
let value_addr = emscripten_memory_pointer!(memory, value) as _;
let option_len_addr = emscripten_memory_pointer!(memory, option_len) as *mut socklen_t;
let value_addr = emscripten_memory_pointer!(view, value) as _;
let option_len_addr = emscripten_memory_pointer!(view, option_len) as *mut socklen_t;
unsafe { getsockopt(socket, level, name, value_addr, option_len_addr) }
}
16 => {
@@ -789,7 +790,7 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
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!(memory, msg) as *const msghdr;
let msg_addr = emscripten_memory_pointer!(view, msg) as *const msghdr;
unsafe { sendmsg(socket, msg_addr, flags) as i32 }
}
17 => {
@@ -798,7 +799,7 @@ pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
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!(memory, msg) as *mut msghdr;
let msg_addr = emscripten_memory_pointer!(view, msg) as *mut msghdr;
unsafe { recvmsg(socket, msg_addr, flags) as i32 }
}
_ => {
@@ -860,9 +861,10 @@ pub fn ___syscall168(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarAr
let fds: WasmPtr<EmPollFd> = varargs.get(&ctx);
let nfds: u32 = varargs.get(&ctx);
let timeout: i32 = varargs.get(&ctx);
let memory = ctx.data().memory_view(0, &ctx);
let memory = ctx.data().memory(0);
let view = memory.view(&ctx);
let mut fds_mut = fds.deref(&memory).read().unwrap();
let mut fds_mut = fds.deref(&view).read().unwrap();
unsafe {
libc::poll(
@@ -885,7 +887,7 @@ pub fn ___syscall180(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
}
let offset: i64 = varargs.get(&ctx);
let buf_ptr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), buf) as _;
let buf_ptr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as _;
unsafe { pread(fd, buf_ptr, count as _, offset) as _ }
}
@@ -902,7 +904,7 @@ pub fn ___syscall181(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
}
let offset: i64 = varargs.get(&ctx);
let buf_ptr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), buf) as _;
let buf_ptr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as _;
let status = unsafe { pwrite(fd, buf_ptr, count as _, offset) as _ };
debug!(
"=> fd: {}, buf: {}, count: {}, offset: {} = status:{}",
@@ -927,11 +929,10 @@ pub fn ___syscall114(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
let status: u32 = varargs.get(&ctx);
let options: c_int = varargs.get(&ctx);
let rusage: u32 = varargs.get(&ctx);
let status_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), status) as *mut c_int;
let memory = ctx.data().memory(0);
let status_addr = emscripten_memory_pointer!(memory.view(&ctx), status) as *mut c_int;
let rusage_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), rusage) as *mut rusage;
let rusage_addr = emscripten_memory_pointer!(memory.view(&ctx), rusage) as *mut rusage;
let res = unsafe { wait4(pid, status_addr, options, rusage_addr) };
debug!(
"=> pid: {}, status: {:?}, options: {}, rusage: {:?} = pid: {}",
@@ -964,8 +965,9 @@ pub fn ___syscall142(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
}
assert!(exceptfds == 0, "`exceptfds` is not supporrted");
let readfds_ptr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), readfds) as _;
let writefds_ptr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), writefds) as _;
let memory = ctx.data().memory(0);
let readfds_ptr = emscripten_memory_pointer!(memory.view(&ctx), readfds) as _;
let writefds_ptr = emscripten_memory_pointer!(memory.view(&ctx), writefds) as _;
unsafe { select(nfds, readfds_ptr, writefds_ptr, 0 as _, 0 as _) }
}
@@ -1000,7 +1002,7 @@ pub fn ___syscall122(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: Var
debug!("emscripten::___syscall122 (uname) {}", _which);
let buf: u32 = varargs.get(&ctx);
debug!("=> buf: {}", buf);
let buf_addr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), buf) as *mut utsname;
let buf_addr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as *mut utsname;
unsafe { uname(buf_addr) }
}
@@ -1059,7 +1061,7 @@ pub fn ___syscall220(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarAr
fd, dirp_addr, count
);
let dirp = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), dirp_addr) as *mut u8;
let dirp = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), dirp_addr) as *mut u8;
let data = &mut get_emscripten_data(&ctx);
let opened_dirs = &mut data.as_mut().unwrap().opened_dirs;

3
lib/emscripten/src/syscalls/windows.rs
View File

@@ -45,7 +45,8 @@ pub fn ___syscall5(mut ctx: FunctionEnvMut<EmEnv>, which: c_int, mut varargs: Va
let _ = urandom_file.write_all(&random_bytes).unwrap();
// put the file path string into wasm memory
let urandom_file_offset = unsafe { copy_cstr_into_wasm(&mut ctx, ptr) };
let memory = ctx.data().memory_view(0, &ctx);
let mem = ctx.data().memory(0);
let memory = mem.view(&ctx);
let raw_pointer_to_urandom_file =
emscripten_memory_pointer!(&memory, urandom_file_offset) as *const i8;
let fd = unsafe { open(raw_pointer_to_urandom_file, flags, mode) };

40
lib/emscripten/src/time.rs
View File

@@ -67,8 +67,9 @@ pub fn _gettimeofday(ctx: FunctionEnvMut<EmEnv>, tp: c_int, tz: c_int) -> c_int
unsafe {
let now = SystemTime::now();
let since_epoch = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
let memory = ctx.data().memory(0);
let timeval_struct_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), tp) as *mut GuestTimeVal;
emscripten_memory_pointer!(memory.view(&ctx), tp) as *mut GuestTimeVal;
(*timeval_struct_ptr).tv_sec = since_epoch.as_secs() as _;
(*timeval_struct_ptr).tv_usec = since_epoch.subsec_nanos() as _;
@@ -108,8 +109,9 @@ pub fn _clock_gettime(ctx: FunctionEnvMut<EmEnv>, clk_id: clockid_t, tp: c_int)
};
unsafe {
let memory = ctx.data().memory(0);
let timespec_struct_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), tp) as *mut GuestTimeSpec;
emscripten_memory_pointer!(memory.view(&ctx), tp) as *mut GuestTimeSpec;
(*timespec_struct_ptr).tv_sec = (duration / 1_000_000_000) as _;
(*timespec_struct_ptr).tv_nsec = (duration % 1_000_000_000) as _;
}
@@ -178,8 +180,8 @@ pub fn _tvset(mut _ctx: FunctionEnvMut<EmEnv>) {
/// formats time as a C string
#[allow(clippy::cast_ptr_alignment)]
unsafe fn fmt_time(ctx: FunctionEnvMut<EmEnv>, time: u32) -> *const c_char {
let date =
&*(emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), time) as *mut guest_tm);
let memory = ctx.data().memory(0);
let date = &*(emscripten_memory_pointer!(memory.view(&ctx), time) as *mut guest_tm);
let days = vec!["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
let months = vec![
@@ -241,9 +243,9 @@ pub fn _localtime(mut ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> c_int {
// NOTE: emscripten seems to want tzset() called in this function
// https://stackoverflow.com/questions/19170721/real-time-awareness-of-timezone-change-in-localtime-vs-localtime-r
let memory = ctx.data().memory(0);
let timespec = unsafe {
let time_p_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), time_p) as *mut i64;
let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *mut i64;
let seconds = *time_p_addr;
time::OffsetDateTime::from_unix_timestamp(seconds)
};
@@ -251,8 +253,7 @@ pub fn _localtime(mut ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> c_int {
unsafe {
let tm_struct_offset = env::call_malloc(&mut ctx, mem::size_of::<guest_tm>() as _);
let tm_struct_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), tm_struct_offset)
as *mut guest_tm;
emscripten_memory_pointer!(memory.view(&ctx), tm_struct_offset) as *mut guest_tm;
// debug!(
// ">>>>>>> time = {}, {}, {}, {}, {}, {}, {}, {}",
// result_tm.tm_sec, result_tm.tm_min, result_tm.tm_hour, result_tm.tm_mday,
@@ -281,9 +282,9 @@ pub fn _localtime_r(ctx: FunctionEnvMut<EmEnv>, time_p: u32, result: u32) -> c_i
// NOTE: emscripten seems to want tzset() called in this function
// https://stackoverflow.com/questions/19170721/real-time-awareness-of-timezone-change-in-localtime-vs-localtime-r
let memory = ctx.data().memory(0);
unsafe {
let seconds =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), time_p) as *const i32;
let seconds = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *const i32;
let timespec = time::OffsetDateTime::from_unix_timestamp_nanos(*seconds as _);
// debug!(
@@ -292,8 +293,7 @@ pub fn _localtime_r(ctx: FunctionEnvMut<EmEnv>, time_p: u32, result: u32) -> c_i
// result_tm.tm_mon, result_tm.tm_year, result_tm.tm_wday, result_tm.tm_yday,
// );
let result_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), result) as *mut guest_tm;
let result_addr = emscripten_memory_pointer!(memory.view(&ctx), result) as *mut guest_tm;
(*result_addr).tm_sec = timespec.second() as _;
(*result_addr).tm_min = timespec.minute() as _;
@@ -317,8 +317,8 @@ pub fn _time(ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> i32 {
debug!("emscripten::_time {}", time_p);
unsafe {
let time_p_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), time_p) as *mut i64;
let memory = ctx.data().memory(0);
let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *mut i64;
libc_time(time_p_addr) as i32 // TODO review i64
}
}
@@ -347,8 +347,8 @@ pub fn _timegm(ctx: FunctionEnvMut<EmEnv>, time_ptr: u32) -> i32 {
debug!("emscripten::_timegm {}", time_ptr);
unsafe {
let time_p_addr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), time_ptr) as *mut guest_tm;
let memory = ctx.data().memory(0);
let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_ptr) as *mut guest_tm;
let x: *mut c_char = CString::new("").expect("CString::new failed").into_raw();
let mut rust_tm = libc_tm {
@@ -405,13 +405,13 @@ pub fn _strftime(
s_ptr, maxsize, format_ptr, tm_ptr
);
let memory = ctx.data().memory(0);
#[allow(clippy::cast_ptr_alignment)]
let s = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), s_ptr) as *mut c_char;
let s = emscripten_memory_pointer!(memory.view(&ctx), s_ptr) as *mut c_char;
#[allow(clippy::cast_ptr_alignment)]
let format =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), format_ptr) as *const c_char;
let format = emscripten_memory_pointer!(memory.view(&ctx), format_ptr) as *const c_char;
#[allow(clippy::cast_ptr_alignment)]
let tm = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), tm_ptr) as *const guest_tm;
let tm = emscripten_memory_pointer!(memory.view(&ctx), tm_ptr) as *const guest_tm;
let format_string = unsafe { std::ffi::CStr::from_ptr(format).to_str().unwrap() };

14
lib/emscripten/src/utils.rs
View File

@@ -99,7 +99,8 @@ pub unsafe fn write_to_buf(
buf: u32,
max: u32,
) -> u32 {
let buf_addr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), buf) as *mut c_char;
let memory = ctx.data().memory(0);
let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut c_char;
for i in 0..max {
*buf_addr.add(i as _) = *string.add(i as _);
@@ -113,8 +114,8 @@ pub unsafe fn copy_cstr_into_wasm(ctx: &mut FunctionEnvMut<EmEnv>, cstr: *const
let s = CStr::from_ptr(cstr).to_str().unwrap();
let cstr_len = s.len();
let space_offset = env::call_malloc(ctx, (cstr_len as u32) + 1);
let raw_memory =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), space_offset) as *mut c_char;
let memory = ctx.data().memory(0);
let raw_memory = emscripten_memory_pointer!(memory.view(&ctx), space_offset) as *mut c_char;
let slice = slice::from_raw_parts_mut(raw_memory, cstr_len);
for (byte, loc) in s.bytes().zip(slice.iter_mut()) {
@@ -139,7 +140,8 @@ pub unsafe fn allocate_on_stack<'a, T: Copy>(
.call(&mut ctx, count * (size_of::<T>() as u32))
.unwrap();
let addr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), offset) as *mut T;
let memory = ctx.data().memory(0);
let addr = emscripten_memory_pointer!(memory.view(&ctx), offset) as *mut T;
let slice = slice::from_raw_parts_mut(addr, count as usize);
(offset, slice)
@@ -204,8 +206,8 @@ pub struct GuestStat {
#[allow(clippy::cast_ptr_alignment)]
pub unsafe fn copy_stat_into_wasm(ctx: FunctionEnvMut<EmEnv>, buf: u32, stat: &stat) {
let stat_ptr =
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), buf) as *mut GuestStat;
let memory = ctx.data().memory(0);
let stat_ptr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut GuestStat;
(*stat_ptr).st_dev = stat.st_dev as _;
(*stat_ptr).__st_dev_padding = 0;
(*stat_ptr).__st_ino_truncated = stat.st_ino as _;

6
lib/emscripten/src/varargs.rs
View File

@@ -13,7 +13,8 @@ pub struct VarArgs {
impl VarArgs {
pub fn get<T: Sized>(&mut self, ctx: &FunctionEnvMut<EmEnv>) -> T {
let ptr = emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), self.pointer);
let memory = ctx.data().memory(0);
let ptr = emscripten_memory_pointer!(memory.view(&ctx), self.pointer);
self.pointer += mem::size_of::<T>() as u32;
unsafe { (ptr as *const T).read() }
}
@@ -21,7 +22,8 @@ impl VarArgs {
// pub fn getStr<'a>(&mut self, ctx: &mut Ctx) -> &'a CStr {
pub fn get_str(&mut self, ctx: &FunctionEnvMut<EmEnv>) -> *const c_char {
let ptr_addr: u32 = self.get(ctx);
emscripten_memory_pointer!(ctx.data().memory_view(0, &ctx), ptr_addr) as *const c_char
let memory = ctx.data().memory(0);
emscripten_memory_pointer!(memory.view(&ctx), ptr_addr) as *const c_char
}
}