mirror of
https://github.com/fluencelabs/wasmer
synced 2025-06-21 12:41:32 +00:00
Make emscripten work again
This commit is contained in:
Syrus
@ -10,7 +10,7 @@
|
||||
```
|
||||
- **abort** ✅ 🔥 [:top:](#host-apis)
|
||||
```rust
|
||||
fn abort(message: u32, vmctx: &mut Ctx)
|
||||
fn abort(message: u32, ctx: &mut Ctx)
|
||||
```
|
||||
- **abort_on_cannot_grow_memory** ✅ [:top:](#host-apis)
|
||||
```rust
|
||||
@ -28,11 +28,11 @@
|
||||
|
||||
- **\_getenv** ✅ [:top:](#host-apis)
|
||||
```rust
|
||||
fn _getenv(name: c_int, vmctx: &mut Ctx)
|
||||
fn _getenv(name: c_int, ctx: &mut Ctx)
|
||||
```
|
||||
- **\_putenv** ✅ [:top:](#host-apis)
|
||||
```rust
|
||||
fn _putenv(name: c_int, vmctx: &mut Ctx)
|
||||
fn _putenv(name: c_int, ctx: &mut Ctx)
|
||||
```
|
||||
- **\_setenv** ✅ [:top:](#host-apis)
|
||||
```rust
|
||||
@ -40,7 +40,7 @@
|
||||
```
|
||||
- **\_unsetenv** ✅ [:top:](#host-apis)
|
||||
```rust
|
||||
fn _unsetenv(name: c_int, vmctx: &mut Ctx)
|
||||
fn _unsetenv(name: c_int, ctx: &mut Ctx)
|
||||
```
|
||||
|
||||
###### THREAD
|
||||
@ -70,7 +70,7 @@
|
||||
|
||||
- **\_emscripten_memcpy_big** ✅ 🔥 [:top:](#host-apis)
|
||||
```rust
|
||||
fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, vmctx: &mut Ctx) -> u32
|
||||
fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, ctx: &mut Ctx) -> u32
|
||||
```
|
||||
- **enlarge_memory** ✅ [:top:](#host-apis)
|
||||
```rust
|
||||
@ -78,7 +78,7 @@
|
||||
```
|
||||
- **get_total_memory** ✅ [:top:](#host-apis)
|
||||
```rust
|
||||
fn get_total_memory(vmctx: &mut Ctx) -> u32
|
||||
fn get_total_memory(ctx: &mut Ctx) -> u32
|
||||
```
|
||||
|
||||
###### TIMING
|
||||
@ -337,7 +337,7 @@
|
||||
```
|
||||
- **open** (\_\_\_syscall5) ✅ ❗️ 🔥 [:top:](#host-apis)
|
||||
```rust
|
||||
fn open(path: u32, flags: c_int, mode: c_int, vmctx: &mut Ctx) -> c_int
|
||||
fn open(path: u32, flags: c_int, mode: c_int, ctx: &mut Ctx) -> c_int
|
||||
```
|
||||
- **openat** (\_\_\_syscall295) [:top:](#host-apis)
|
||||
```rust
|
||||
@ -385,7 +385,7 @@
|
||||
```
|
||||
- **read** (\_\_\_syscall3) ✅ ❗️ [:top:](#host-apis)
|
||||
```rust
|
||||
fn read(fd: c_int, buf: u32, count: size_t, vmctx: &mut Ctx) -> ssize_t
|
||||
fn read(fd: c_int, buf: u32, count: size_t, ctx: &mut Ctx) -> ssize_t
|
||||
```
|
||||
- **readlink** (\_\_\_syscall85) [:top:](#host-apis)
|
||||
```rust
|
||||
|
||||
@ -16,7 +16,7 @@ use wasmer_runtime_core::vm::Ctx;
|
||||
pub extern "C" fn _getenv(name: c_int, ctx: &mut Ctx) -> u32 {
|
||||
debug!("emscripten::_getenv");
|
||||
|
||||
let name_addr = ctx.memory(0)[name as usize] as *const c_char;
|
||||
let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char;
|
||||
|
||||
debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
|
||||
|
||||
@ -32,8 +32,8 @@ pub extern "C" fn _getenv(name: c_int, ctx: &mut Ctx) -> u32 {
|
||||
pub extern "C" fn _setenv(name: c_int, value: c_int, overwrite: c_int, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::_setenv");
|
||||
|
||||
let name_addr = ctx.memory(0)[name as usize] as *const c_char;
|
||||
let value_addr = ctx.memory(0)[value as usize] as *const c_char;
|
||||
let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char;
|
||||
let value_addr = emscripten_memory_pointer!(ctx.memory(0), value) as *const c_char;
|
||||
|
||||
debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
|
||||
debug!("=> value({:?})", unsafe { CStr::from_ptr(value_addr) });
|
||||
@ -45,7 +45,7 @@ pub extern "C" fn _setenv(name: c_int, value: c_int, overwrite: c_int, ctx: &mut
|
||||
pub extern "C" fn _putenv(name: c_int, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::_putenv");
|
||||
|
||||
let name_addr = ctx.memory(0)[name as usize] as *const c_char;
|
||||
let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char;
|
||||
|
||||
debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
|
||||
|
||||
@ -56,7 +56,7 @@ pub extern "C" fn _putenv(name: c_int, ctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn _unsetenv(name: c_int, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::_unsetenv");
|
||||
|
||||
let name_addr = ctx.memory(0)[name as usize] as *const c_char;
|
||||
let name_addr = emscripten_memory_pointer!(ctx.memory(0), name) as *const c_char;
|
||||
|
||||
debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
|
||||
|
||||
@ -79,7 +79,7 @@ pub extern "C" fn _getpwnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int {
|
||||
}
|
||||
|
||||
let name = unsafe {
|
||||
let memory_name_ptr = ctx.memory(0)[name_ptr as usize] as *const c_char;
|
||||
let memory_name_ptr = emscripten_memory_pointer!(ctx.memory(0), name_ptr) as *const c_char;
|
||||
CStr::from_ptr(memory_name_ptr)
|
||||
};
|
||||
|
||||
@ -87,7 +87,7 @@ pub extern "C" fn _getpwnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int {
|
||||
let passwd = &*libc_getpwnam(name.as_ptr());
|
||||
let passwd_struct_offset = call_malloc(mem::size_of::<GuestPasswd>() as _, ctx);
|
||||
|
||||
let passwd_struct_ptr = ctx.memory(0)[passwd_struct_offset as usize] as *mut GuestPasswd;
|
||||
let passwd_struct_ptr = emscripten_memory_pointer!(ctx.memory(0), passwd_struct_offset) as *mut GuestPasswd;
|
||||
(*passwd_struct_ptr).pw_name = copy_cstr_into_wasm(ctx, passwd.pw_name);
|
||||
(*passwd_struct_ptr).pw_passwd = copy_cstr_into_wasm(ctx, passwd.pw_passwd);
|
||||
(*passwd_struct_ptr).pw_gecos = copy_cstr_into_wasm(ctx, passwd.pw_gecos);
|
||||
@ -113,7 +113,7 @@ pub extern "C" fn _getgrnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int {
|
||||
}
|
||||
|
||||
let name = unsafe {
|
||||
let memory_name_ptr = ctx.memory(0)[name_ptr as usize] as *const c_char;
|
||||
let memory_name_ptr = emscripten_memory_pointer!(ctx.memory(0), name_ptr) as *const c_char;
|
||||
CStr::from_ptr(memory_name_ptr)
|
||||
};
|
||||
|
||||
@ -121,7 +121,7 @@ pub extern "C" fn _getgrnam(name_ptr: c_int, ctx: &mut Ctx) -> c_int {
|
||||
let group = &*libc_getgrnam(name.as_ptr());
|
||||
let group_struct_offset = call_malloc(mem::size_of::<GuestGroup>() as _, ctx);
|
||||
|
||||
let group_struct_ptr = ctx.memory(0)[group_struct_offset as usize] as *mut GuestGroup;
|
||||
let group_struct_ptr = emscripten_memory_pointer!(ctx.memory(0), group_struct_offset) as *mut GuestGroup;
|
||||
(*group_struct_ptr).gr_name = copy_cstr_into_wasm(ctx, group.gr_name);
|
||||
(*group_struct_ptr).gr_passwd = copy_cstr_into_wasm(ctx, group.gr_passwd);
|
||||
(*group_struct_ptr).gr_gid = group.gr_gid;
|
||||
@ -157,14 +157,14 @@ pub extern "C" fn ___build_environment(environ: c_int, ctx: &mut Ctx) {
|
||||
debug!("emscripten::___build_environment {}", environ);
|
||||
const MAX_ENV_VALUES: u32 = 64;
|
||||
const TOTAL_ENV_SIZE: u32 = 1024;
|
||||
let environment = ctx.memory(0)[environ as usize] as *mut c_int;
|
||||
let environment = emscripten_memory_pointer!(ctx.memory(0), environ) as *mut c_int;
|
||||
unsafe {
|
||||
let (pool_offset, _pool_slice): (u32, &mut [u8]) =
|
||||
allocate_on_stack(TOTAL_ENV_SIZE as u32, ctx);
|
||||
let (env_offset, _env_slice): (u32, &mut [u8]) =
|
||||
allocate_on_stack((MAX_ENV_VALUES * 4) as u32, ctx);
|
||||
let env_ptr = ctx.memory(0)[env_offset as usize] as *mut c_int;
|
||||
let mut _pool_ptr = ctx.memory(0)[pool_offset as usize] as *mut c_int;
|
||||
let env_ptr = emscripten_memory_pointer!(ctx.memory(0), env_offset) as *mut c_int;
|
||||
let mut _pool_ptr = emscripten_memory_pointer!(ctx.memory(0), pool_offset) as *mut c_int;
|
||||
*env_ptr = pool_offset as i32;
|
||||
*environment = env_offset as i32;
|
||||
|
||||
|
||||
@ -3,14 +3,14 @@ use super::process::_abort;
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
/// emscripten: ___cxa_allocate_exception
|
||||
pub extern "C" fn ___cxa_allocate_exception(size: u32, vmctx: &mut Ctx) -> u32 {
|
||||
pub extern "C" fn ___cxa_allocate_exception(size: u32, ctx: &mut Ctx) -> u32 {
|
||||
debug!("emscripten::___cxa_allocate_exception");
|
||||
env::call_malloc(size as _, vmctx)
|
||||
env::call_malloc(size as _, ctx)
|
||||
}
|
||||
|
||||
/// emscripten: ___cxa_throw
|
||||
/// TODO: We don't have support for exceptions yet
|
||||
pub extern "C" fn ___cxa_throw(_ptr: u32, _ty: u32, _destructor: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn ___cxa_throw(_ptr: u32, _ty: u32, _destructor: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::___cxa_throw");
|
||||
_abort();
|
||||
}
|
||||
|
||||
@ -10,7 +10,7 @@ pub extern "C" fn __setjmp(env_addr: u32, ctx: &mut Ctx) -> c_int {
|
||||
// Rather than using the env as the holder of the jump buffer pointer,
|
||||
// we use the environment address to store the index relative to jumps
|
||||
// so the address of the jump it's outside the wasm memory itself.
|
||||
let jump_index = ctx.memory(0)[env_addr as usize] as *mut i8;
|
||||
let jump_index = ctx.memory(0).as_ptr().add(env_addr as usize) as *mut i8;
|
||||
// We create the jump buffer outside of the wasm memory
|
||||
let jump_buf: UnsafeCell<[c_int; 27]> = UnsafeCell::new([0; 27]);
|
||||
let jumps = &mut get_emscripten_data(ctx).jumps;
|
||||
@ -28,7 +28,7 @@ pub extern "C" fn __longjmp(env_addr: u32, val: c_int, ctx: &mut Ctx) -> ! {
|
||||
debug!("emscripten::__longjmp (longmp)");
|
||||
unsafe {
|
||||
// We retrieve the jump index from the env address
|
||||
let jump_index = ctx.memory(0)[env_addr as usize] as *mut i8;
|
||||
let jump_index = emscripten_memory_pointer!(ctx.memory(0), env_addr) as *mut i8;
|
||||
let jumps = &mut get_emscripten_data(ctx).jumps;
|
||||
// We get the real jump buffer from the jumps vector, using the retrieved index
|
||||
let jump_buf = &jumps[*jump_index as usize];
|
||||
|
||||
@ -1556,7 +1556,7 @@ pub fn generate_emscripten_env(globals: &mut EmscriptenGlobals) -> ImportObject
|
||||
env_namespace.insert(
|
||||
"___clock_gettime",
|
||||
Export::Function {
|
||||
func: func!(time, ___clock_gettime),
|
||||
func: func!(time, _clock_gettime),
|
||||
ctx: Context::Internal,
|
||||
signature: FuncSig {
|
||||
params: vec![I32, I32],
|
||||
|
||||
@ -2,16 +2,16 @@ use libc::c_int;
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
// NOTE: Not implemented by Emscripten
|
||||
pub extern "C" fn ___lock(what: c_int, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn ___lock(what: c_int, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::___lock {}", what);
|
||||
}
|
||||
|
||||
// NOTE: Not implemented by Emscripten
|
||||
pub extern "C" fn ___unlock(what: c_int, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn ___unlock(what: c_int, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::___unlock {}", what);
|
||||
}
|
||||
|
||||
// NOTE: Not implemented by Emscripten
|
||||
pub extern "C" fn ___wait(_which: c_int, _varargs: c_int, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn ___wait(_which: c_int, _varargs: c_int, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::___wait");
|
||||
}
|
||||
|
||||
@ -2,3 +2,9 @@ macro_rules! debug {
|
||||
($fmt:expr) => (if cfg!(any(debug_assertions, feature="debug")) { println!(concat!("wasmer-runtime(:{})::", $fmt), line!()) });
|
||||
($fmt:expr, $($arg:tt)*) => (if cfg!(any(debug_assertions, feature="debug")) { println!(concat!("wasmer-runtime(:{})::", $fmt, "\n"), line!(), $($arg)*) });
|
||||
}
|
||||
|
||||
macro_rules! emscripten_memory_pointer {
|
||||
($memory:expr, $pointer:expr) => {
|
||||
unsafe { $memory.as_ptr().add($pointer as usize) }
|
||||
}
|
||||
}
|
||||
@ -3,13 +3,13 @@ use libc::{c_int, c_void, memcpy, size_t};
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
/// emscripten: _emscripten_memcpy_big
|
||||
pub extern "C" fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, vmctx: &mut Ctx) -> u32 {
|
||||
pub extern "C" fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, ctx: &mut Ctx) -> u32 {
|
||||
debug!(
|
||||
"emscripten::_emscripten_memcpy_big {}, {}, {}",
|
||||
dest, src, len
|
||||
);
|
||||
let dest_addr = vmctx.memory(0)[dest as usize] as *mut c_void;
|
||||
let src_addr = vmctx.memory(0)[src as usize] as *mut c_void;
|
||||
let dest_addr = emscripten_memory_pointer!(ctx.memory(0), dest) as *mut c_void;
|
||||
let src_addr = emscripten_memory_pointer!(ctx.memory(0), src) as *mut c_void;
|
||||
unsafe {
|
||||
memcpy(dest_addr, src_addr, len as size_t);
|
||||
}
|
||||
@ -17,7 +17,7 @@ pub extern "C" fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, vmctx: &
|
||||
}
|
||||
|
||||
/// emscripten: getTotalMemory
|
||||
pub extern "C" fn get_total_memory(_vmctx: &mut Ctx) -> u32 {
|
||||
pub extern "C" fn get_total_memory(_ctx: &mut Ctx) -> u32 {
|
||||
debug!("emscripten::get_total_memory");
|
||||
// instance.memories[0].current_pages()
|
||||
// TODO: Fix implementation
|
||||
@ -25,7 +25,7 @@ pub extern "C" fn get_total_memory(_vmctx: &mut Ctx) -> u32 {
|
||||
}
|
||||
|
||||
/// emscripten: enlargeMemory
|
||||
pub extern "C" fn enlarge_memory(_vmctx: &mut Ctx) -> u32 {
|
||||
pub extern "C" fn enlarge_memory(_ctx: &mut Ctx) -> u32 {
|
||||
debug!("emscripten::enlarge_memory");
|
||||
// instance.memories[0].grow(100);
|
||||
// TODO: Fix implementation
|
||||
|
||||
@ -1,67 +1,67 @@
|
||||
use super::process::abort_with_message;
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
pub extern "C" fn nullfunc_i(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_i(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_i {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'i'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_ii(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_ii(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_ii {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'ii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_iii(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_iii(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_iii {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'iii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_iiii(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_iiii(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_iiii {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'iiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_iiiii(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_iiiii(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_iiiii {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'iiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_iiiiii(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_iiiiii(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_iiiiii {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'iiiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_v(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_v(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_v {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'v'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_vi(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_vi(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_vi {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'vi'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_vii(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_vii(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_vii {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'vii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_viii(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_viii(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_viii {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'viii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_viiii(x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_viiii(x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_viiii {}", x);
|
||||
abort_with_message("Invalid function pointer called with signature 'viiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_viiiii(_x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_viiiii(_x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_viiiii");
|
||||
abort_with_message("Invalid function pointer called with signature 'viiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
pub extern "C" fn nullfunc_viiiiii(_x: u32, _vmctx: &mut Ctx) {
|
||||
pub extern "C" fn nullfunc_viiiiii(_x: u32, _ctx: &mut Ctx) {
|
||||
debug!("emscripten::nullfunc_viiiiii");
|
||||
abort_with_message("Invalid function pointer called with signature 'viiiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");
|
||||
}
|
||||
|
||||
@ -16,7 +16,7 @@ pub extern "C" fn _abort() {
|
||||
}
|
||||
}
|
||||
|
||||
pub extern "C" fn _fork(_vmctx: &mut Ctx) -> pid_t {
|
||||
pub extern "C" fn _fork(_ctx: &mut Ctx) -> pid_t {
|
||||
debug!("emscripten::_fork");
|
||||
// unsafe {
|
||||
// fork()
|
||||
@ -24,14 +24,14 @@ pub extern "C" fn _fork(_vmctx: &mut Ctx) -> pid_t {
|
||||
-1
|
||||
}
|
||||
|
||||
pub extern "C" fn _exit(status: c_int, _vmctx: &mut Ctx) -> ! {
|
||||
pub extern "C" fn _exit(status: c_int, _ctx: &mut Ctx) -> ! {
|
||||
debug!("emscripten::_exit {}", status);
|
||||
unsafe { exit(status) }
|
||||
}
|
||||
|
||||
pub extern "C" fn em_abort(message: u32, vmctx: &mut Ctx) {
|
||||
pub extern "C" fn em_abort(message: u32, ctx: &mut Ctx) {
|
||||
debug!("emscripten::em_abort {}", message);
|
||||
let message_addr = vmctx.memory(0)[message as usize] as *mut c_char;
|
||||
let message_addr = emscripten_memory_pointer!(ctx.memory(0), message) as *mut c_char;
|
||||
unsafe {
|
||||
let message = CStr::from_ptr(message_addr)
|
||||
.to_str()
|
||||
|
||||
@ -2,24 +2,24 @@
|
||||
use wasmer_runtime_core::vm::Ctx;
|
||||
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn _sigemptyset(set: u32, vmctx: &mut Ctx) -> i32 {
|
||||
pub extern "C" fn _sigemptyset(set: u32, ctx: &mut Ctx) -> i32 {
|
||||
debug!("emscripten::_sigemptyset");
|
||||
let set_addr = vmctx.memory(0)[set as usize] as *mut u32;
|
||||
let set_addr = emscripten_memory_pointer!(ctx.memory(0), set) as *mut u32;
|
||||
unsafe {
|
||||
*set_addr = 0;
|
||||
}
|
||||
0
|
||||
}
|
||||
|
||||
pub extern "C" fn _sigaction(signum: u32, act: u32, oldact: u32, _vmctx: &mut Ctx) -> i32 {
|
||||
pub extern "C" fn _sigaction(signum: u32, act: u32, oldact: u32, _ctx: &mut Ctx) -> i32 {
|
||||
debug!("emscripten::_sigaction {}, {}, {}", signum, act, oldact);
|
||||
0
|
||||
}
|
||||
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn _sigaddset(set: u32, signum: u32, vmctx: &mut Ctx) -> i32 {
|
||||
pub extern "C" fn _sigaddset(set: u32, signum: u32, ctx: &mut Ctx) -> i32 {
|
||||
debug!("emscripten::_sigaddset {}, {}", set, signum);
|
||||
let set_addr = vmctx.memory(0)[set as usize] as *mut u32;
|
||||
let set_addr = emscripten_memory_pointer!(ctx.memory(0), set) as *mut u32;
|
||||
unsafe {
|
||||
*set_addr |= 1 << (signum - 1);
|
||||
}
|
||||
@ -31,7 +31,7 @@ pub extern "C" fn _sigprocmask() -> i32 {
|
||||
0
|
||||
}
|
||||
|
||||
pub extern "C" fn _signal(sig: u32, _vmctx: &mut Ctx) -> i32 {
|
||||
pub extern "C" fn _signal(sig: u32, _ctx: &mut Ctx) -> i32 {
|
||||
debug!("emscripten::_signal ({})", sig);
|
||||
0
|
||||
}
|
||||
|
||||
@ -96,45 +96,45 @@ use libc::SO_NOSIGPIPE;
|
||||
const SO_NOSIGPIPE: c_int = 0;
|
||||
|
||||
/// exit
|
||||
pub extern "C" fn ___syscall1(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) {
|
||||
pub extern "C" fn ___syscall1(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) {
|
||||
debug!("emscripten::___syscall1 (exit) {}", which);
|
||||
let status: i32 = varargs.get(vmctx);
|
||||
let status: i32 = varargs.get(ctx);
|
||||
unsafe {
|
||||
exit(status);
|
||||
}
|
||||
}
|
||||
|
||||
/// read
|
||||
pub extern "C" fn ___syscall3(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> ssize_t {
|
||||
pub extern "C" fn ___syscall3(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> ssize_t {
|
||||
debug!("emscripten::___syscall3 (read) {}", which);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let buf: u32 = varargs.get(vmctx);
|
||||
let count: usize = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: usize = varargs.get(ctx);
|
||||
debug!("=> fd: {}, buf_offset: {}, count: {}", fd, buf, count);
|
||||
let buf_addr = vmctx.memory(0)[buf as usize] as *mut c_void;
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut c_void;
|
||||
let ret = unsafe { read(fd, buf_addr, count) };
|
||||
debug!("=> ret: {}", ret);
|
||||
ret
|
||||
}
|
||||
|
||||
/// write
|
||||
pub extern "C" fn ___syscall4(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall4(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall4 (write) {}", which);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let buf: u32 = varargs.get(vmctx);
|
||||
let count: u32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: u32 = varargs.get(ctx);
|
||||
debug!("=> fd: {}, buf: {}, count: {}", fd, buf, count);
|
||||
let buf_addr = vmctx.memory(0)[buf as usize] as *const c_void;
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *const c_void;
|
||||
unsafe { write(fd, buf_addr, count as usize) as i32 }
|
||||
}
|
||||
|
||||
/// open
|
||||
pub extern "C" fn ___syscall5(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall5(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall5 (open) {}", which);
|
||||
let pathname: u32 = varargs.get(vmctx);
|
||||
let flags: i32 = varargs.get(vmctx);
|
||||
let mode: u32 = varargs.get(vmctx);
|
||||
let pathname_addr = vmctx.memory(0)[pathname as usize] as *const i8;
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let flags: i32 = varargs.get(ctx);
|
||||
let mode: 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 fd = unsafe { open(pathname_addr, flags, mode) };
|
||||
debug!(
|
||||
@ -145,19 +145,19 @@ pub extern "C" fn ___syscall5(which: c_int, mut varargs: VarArgs, vmctx: &mut Ct
|
||||
}
|
||||
|
||||
/// close
|
||||
pub extern "C" fn ___syscall6(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall6(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall6 (close) {}", which);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
debug!("fd: {}", fd);
|
||||
unsafe { close(fd) }
|
||||
}
|
||||
|
||||
// chdir
|
||||
pub extern "C" fn ___syscall12(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall12(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall12 (chdir) {}", which);
|
||||
let path_addr: i32 = varargs.get(vmctx);
|
||||
let path_addr: i32 = varargs.get(ctx);
|
||||
unsafe {
|
||||
let path_ptr = vmctx.memory(0)[path_addr as usize] as *const i8;
|
||||
let path_ptr = emscripten_memory_pointer!(ctx.memory(0), path_addr) as *const i8;
|
||||
let path = std::ffi::CStr::from_ptr(path_ptr);
|
||||
let ret = chdir(path_ptr);
|
||||
debug!("=> path: {:?}, ret: {}", path, ret);
|
||||
@ -172,34 +172,34 @@ pub extern "C" fn ___syscall20() -> pid_t {
|
||||
}
|
||||
|
||||
// mkdir
|
||||
pub extern "C" fn ___syscall39(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall39(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall39 (mkdir) {}", which);
|
||||
let pathname: u32 = varargs.get(vmctx);
|
||||
let mode: u32 = varargs.get(vmctx);
|
||||
let pathname_addr = vmctx.memory(0)[pathname as usize] as *const i8;
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let mode: u32 = varargs.get(ctx);
|
||||
let pathname_addr = emscripten_memory_pointer!(ctx.memory(0), pathname) as *const i8;
|
||||
unsafe { mkdir(pathname_addr, mode as _) }
|
||||
}
|
||||
|
||||
// rmdir
|
||||
pub extern "C" fn ___syscall40(_which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall40(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall40 (rmdir)");
|
||||
let pathname: u32 = varargs.get(vmctx);
|
||||
let pathname_addr = vmctx.memory(0)[pathname as usize] as *const i8;
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let pathname_addr = emscripten_memory_pointer!(ctx.memory(0), pathname) as *const i8;
|
||||
unsafe { rmdir(pathname_addr) }
|
||||
}
|
||||
|
||||
/// ioctl
|
||||
pub extern "C" fn ___syscall54(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall54(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall54 (ioctl) {}", which);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let request: u32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let request: u32 = varargs.get(ctx);
|
||||
debug!("fd: {}, op: {}", fd, request);
|
||||
// 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(vmctx);
|
||||
let argp_ptr = vmctx.memory(0)[argp as usize] as *mut c_void;
|
||||
let argp: u32 = varargs.get(ctx);
|
||||
let argp_ptr = emscripten_memory_pointer!(ctx.memory(0), argp) as *mut c_void;
|
||||
let ret = unsafe { ioctl(fd, FIONBIO, argp_ptr) };
|
||||
debug!("ret(FIONBIO): {}", ret);
|
||||
ret
|
||||
@ -207,8 +207,8 @@ pub extern "C" fn ___syscall54(which: c_int, mut varargs: VarArgs, vmctx: &mut C
|
||||
}
|
||||
21523 => {
|
||||
// TIOCGWINSZ
|
||||
let argp: u32 = varargs.get(vmctx);
|
||||
let argp_ptr = vmctx.memory(0)[argp as usize] as *mut c_void;
|
||||
let argp: u32 = varargs.get(ctx);
|
||||
let argp_ptr = emscripten_memory_pointer!(ctx.memory(0), argp) as *mut c_void;
|
||||
let ret = unsafe { ioctl(fd, TIOCGWINSZ, argp_ptr) };
|
||||
debug!("ret(TIOCGWINSZ): {} (harcoded to 0)", ret);
|
||||
// ret
|
||||
@ -231,19 +231,19 @@ pub extern "C" fn ___syscall54(which: c_int, mut varargs: VarArgs, vmctx: &mut C
|
||||
}
|
||||
|
||||
// setpgid
|
||||
pub extern "C" fn ___syscall57(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall57(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall57 (setpgid) {}", which);
|
||||
let pid: i32 = varargs.get(vmctx);
|
||||
let pgid: i32 = varargs.get(vmctx);
|
||||
let pid: i32 = varargs.get(ctx);
|
||||
let pgid: i32 = varargs.get(ctx);
|
||||
unsafe { setpgid(pid, pgid) }
|
||||
}
|
||||
|
||||
// dup2
|
||||
pub extern "C" fn ___syscall63(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall63(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall63 (dup2) {}", which);
|
||||
|
||||
let src: i32 = varargs.get(vmctx);
|
||||
let dst: i32 = varargs.get(vmctx);
|
||||
let src: i32 = varargs.get(ctx);
|
||||
let dst: i32 = varargs.get(ctx);
|
||||
|
||||
unsafe { dup2(src, dst) }
|
||||
}
|
||||
@ -256,10 +256,10 @@ pub extern "C" fn ___syscall64() -> pid_t {
|
||||
|
||||
// socketcall
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall102 (socketcall) {}", which);
|
||||
let call: u32 = varargs.get(vmctx);
|
||||
let mut socket_varargs: VarArgs = varargs.get(vmctx);
|
||||
let call: u32 = varargs.get(ctx);
|
||||
let mut socket_varargs: VarArgs = varargs.get(ctx);
|
||||
|
||||
#[repr(C)]
|
||||
pub struct GuestSockaddrIn {
|
||||
@ -286,9 +286,9 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
1 => {
|
||||
debug!("socket: socket");
|
||||
// socket (domain: c_int, ty: c_int, protocol: c_int) -> c_int
|
||||
let domain: i32 = socket_varargs.get(vmctx);
|
||||
let ty: i32 = socket_varargs.get(vmctx);
|
||||
let protocol: i32 = socket_varargs.get(vmctx);
|
||||
let domain: i32 = socket_varargs.get(ctx);
|
||||
let ty: i32 = socket_varargs.get(ctx);
|
||||
let protocol: i32 = socket_varargs.get(ctx);
|
||||
let fd = unsafe { socket(domain, ty, protocol) };
|
||||
// set_cloexec
|
||||
unsafe {
|
||||
@ -317,10 +317,10 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
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(vmctx);
|
||||
let address: u32 = socket_varargs.get(vmctx);
|
||||
let address_len: u32 = socket_varargs.get(vmctx);
|
||||
let address = vmctx.memory(0)[address as usize] as *mut sockaddr;
|
||||
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 sockaddr;
|
||||
|
||||
// Debug received address
|
||||
unsafe {
|
||||
@ -344,17 +344,17 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
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(vmctx);
|
||||
let address: u32 = socket_varargs.get(vmctx);
|
||||
let address_len: u32 = socket_varargs.get(vmctx);
|
||||
let address = vmctx.memory(0)[address as usize] as *mut sockaddr;
|
||||
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 sockaddr;
|
||||
unsafe { connect(socket, address, address_len) }
|
||||
}
|
||||
4 => {
|
||||
debug!("socket: listen");
|
||||
// listen (socket: c_int, backlog: c_int) -> c_int
|
||||
let socket: i32 = socket_varargs.get(vmctx);
|
||||
let backlog: i32 = socket_varargs.get(vmctx);
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let backlog: i32 = socket_varargs.get(ctx);
|
||||
let status = unsafe { listen(socket, backlog) };
|
||||
debug!(
|
||||
"=> socketfd: {}, backlog: {} = status: {}",
|
||||
@ -365,22 +365,22 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
5 => {
|
||||
debug!("socket: accept");
|
||||
// accept (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
|
||||
let socket: i32 = socket_varargs.get(vmctx);
|
||||
let address_addr: u32 = socket_varargs.get(vmctx);
|
||||
let address_len: u32 = socket_varargs.get(vmctx);
|
||||
let address = vmctx.memory(0)[address_addr as usize] as *mut sockaddr;
|
||||
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 sockaddr;
|
||||
|
||||
debug!(
|
||||
"=> socket: {}, address: {:?}, address_len: {}",
|
||||
socket, address, address_len
|
||||
);
|
||||
let address_len_addr = vmctx.memory(0)[address_len as usize] as *mut socklen_t;
|
||||
let address_len_addr = emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut socklen_t;
|
||||
// let mut address_len_addr: socklen_t = 0;
|
||||
|
||||
let fd = unsafe { accept(socket, address, address_len_addr) };
|
||||
|
||||
unsafe {
|
||||
let address_linux = vmctx.memory(0)[address_addr as usize] as *mut LinuxSockAddr;
|
||||
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;
|
||||
};
|
||||
@ -397,48 +397,48 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
6 => {
|
||||
debug!("socket: getsockname");
|
||||
// getsockname (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
|
||||
let socket: i32 = socket_varargs.get(vmctx);
|
||||
let address: u32 = socket_varargs.get(vmctx);
|
||||
let address_len: u32 = socket_varargs.get(vmctx);
|
||||
let address = vmctx.memory(0)[address as usize] as *mut sockaddr;
|
||||
let address_len_addr = vmctx.memory(0)[address_len as usize] as *mut socklen_t;
|
||||
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 sockaddr;
|
||||
let address_len_addr = emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut socklen_t;
|
||||
unsafe { getsockname(socket, 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(vmctx);
|
||||
let address: u32 = socket_varargs.get(vmctx);
|
||||
let address_len: u32 = socket_varargs.get(vmctx);
|
||||
let address = vmctx.memory(0)[address as usize] as *mut sockaddr;
|
||||
let address_len_addr = vmctx.memory(0)[address_len as usize] as *mut socklen_t;
|
||||
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 sockaddr;
|
||||
let address_len_addr = emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut socklen_t;
|
||||
unsafe { getpeername(socket, 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(vmctx);
|
||||
let buf: u32 = socket_varargs.get(vmctx);
|
||||
let flags: usize = socket_varargs.get(vmctx);
|
||||
let len: i32 = socket_varargs.get(vmctx);
|
||||
let address: u32 = socket_varargs.get(vmctx);
|
||||
let address_len: u32 = socket_varargs.get(vmctx);
|
||||
let buf_addr = vmctx.memory(0)[buf as usize] as *mut c_void;
|
||||
let address = vmctx.memory(0)[address as usize] as *mut sockaddr;
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let buf: u32 = socket_varargs.get(ctx);
|
||||
let flags: usize = socket_varargs.get(ctx);
|
||||
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 *mut c_void;
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut sockaddr;
|
||||
unsafe { sendto(socket, 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(vmctx);
|
||||
let buf: u32 = socket_varargs.get(vmctx);
|
||||
let flags: usize = socket_varargs.get(vmctx);
|
||||
let len: i32 = socket_varargs.get(vmctx);
|
||||
let address: u32 = socket_varargs.get(vmctx);
|
||||
let address_len: u32 = socket_varargs.get(vmctx);
|
||||
let buf_addr = vmctx.memory(0)[buf as usize] as *mut c_void;
|
||||
let address = vmctx.memory(0)[address as usize] as *mut sockaddr;
|
||||
let address_len_addr = vmctx.memory(0)[address_len as usize] as *mut socklen_t;
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
let buf: u32 = socket_varargs.get(ctx);
|
||||
let flags: usize = socket_varargs.get(ctx);
|
||||
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 *mut c_void;
|
||||
let address = emscripten_memory_pointer!(ctx.memory(0), address) as *mut sockaddr;
|
||||
let address_len_addr = emscripten_memory_pointer!(ctx.memory(0), address_len) as *mut socklen_t;
|
||||
unsafe { recvfrom(socket, buf_addr, flags, len, address, address_len_addr) as i32 }
|
||||
}
|
||||
14 => {
|
||||
@ -449,16 +449,16 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
// 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: i32 = socket_varargs.get(vmctx);
|
||||
let socket: i32 = socket_varargs.get(ctx);
|
||||
// SOL_SOCKET = 0xffff (BSD, Linux)
|
||||
let level: i32 = SOL_SOCKET;
|
||||
let _: u32 = socket_varargs.get(vmctx);
|
||||
let _: u32 = socket_varargs.get(ctx);
|
||||
// SO_REUSEADDR = 0x4 (BSD, Linux)
|
||||
let name: i32 = SO_REUSEADDR;
|
||||
let _: u32 = socket_varargs.get(vmctx);
|
||||
let value: u32 = socket_varargs.get(vmctx);
|
||||
let option_len: u32 = socket_varargs.get(vmctx);
|
||||
let value_addr = vmctx.memory(0)[value as usize] as *mut c_void; // Endian problem
|
||||
let _: u32 = 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 *mut c_void; // Endian problem
|
||||
let ret = unsafe { setsockopt(socket, 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);
|
||||
@ -467,31 +467,31 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
15 => {
|
||||
debug!("socket: getsockopt");
|
||||
// getsockopt (sockfd: c_int, level: c_int, optname: c_int, optval: *mut c_void, optlen: *mut socklen_t) -> c_int
|
||||
let socket: i32 = socket_varargs.get(vmctx);
|
||||
let level: i32 = socket_varargs.get(vmctx);
|
||||
let name: i32 = socket_varargs.get(vmctx);
|
||||
let value: u32 = socket_varargs.get(vmctx);
|
||||
let option_len: u32 = socket_varargs.get(vmctx);
|
||||
let value_addr = vmctx.memory(0)[value as usize] as *mut c_void;
|
||||
let option_len_addr = vmctx.memory(0)[option_len as usize] as *mut socklen_t;
|
||||
let socket: i32 = 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 *mut c_void;
|
||||
let option_len_addr = emscripten_memory_pointer!(ctx.memory(0), option_len) as *mut socklen_t;
|
||||
unsafe { getsockopt(socket, level, name, value_addr, option_len_addr) }
|
||||
}
|
||||
16 => {
|
||||
debug!("socket: sendmsg");
|
||||
// sendmsg (fd: c_int, msg: *const msghdr, flags: c_int) -> ssize_t
|
||||
let socket: i32 = socket_varargs.get(vmctx);
|
||||
let msg: u32 = socket_varargs.get(vmctx);
|
||||
let flags: i32 = socket_varargs.get(vmctx);
|
||||
let msg_addr = vmctx.memory(0)[msg as usize] as *const msghdr;
|
||||
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 msghdr;
|
||||
unsafe { sendmsg(socket, 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(vmctx);
|
||||
let msg: u32 = socket_varargs.get(vmctx);
|
||||
let flags: i32 = socket_varargs.get(vmctx);
|
||||
let msg_addr = vmctx.memory(0)[msg as usize] as *mut msghdr;
|
||||
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 msghdr;
|
||||
unsafe { recvmsg(socket, msg_addr, flags) as i32 }
|
||||
}
|
||||
_ => {
|
||||
@ -503,14 +503,14 @@ pub extern "C" fn ___syscall102(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
|
||||
/// wait4
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn ___syscall114(_which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> pid_t {
|
||||
pub extern "C" fn ___syscall114(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> pid_t {
|
||||
debug!("emscripten::___syscall114 (wait4)");
|
||||
let pid: pid_t = varargs.get(vmctx);
|
||||
let status: u32 = varargs.get(vmctx);
|
||||
let options: c_int = varargs.get(vmctx);
|
||||
let rusage: u32 = varargs.get(vmctx);
|
||||
let status_addr = vmctx.memory(0)[status as usize] as *mut c_int;
|
||||
let rusage_addr = vmctx.memory(0)[rusage as usize] as *mut rusage;
|
||||
let pid: pid_t = varargs.get(ctx);
|
||||
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.memory(0), status) as *mut c_int;
|
||||
let rusage_addr = emscripten_memory_pointer!(ctx.memory(0), rusage) as *mut rusage;
|
||||
let res = unsafe { wait4(pid, status_addr, options, rusage_addr) };
|
||||
debug!(
|
||||
"=> pid: {}, status: {:?}, options: {}, rusage: {:?} = pid: {}",
|
||||
@ -521,54 +521,54 @@ pub extern "C" fn ___syscall114(_which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
|
||||
/// uname
|
||||
// NOTE: Wondering if we should return custom utsname, like Emscripten.
|
||||
pub extern "C" fn ___syscall122(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall122(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall122 (uname) {}", which);
|
||||
let buf: u32 = varargs.get(vmctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
debug!("=> buf: {}", buf);
|
||||
let buf_addr = vmctx.memory(0)[buf as usize] as *mut utsname;
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut utsname;
|
||||
unsafe { uname(buf_addr) }
|
||||
}
|
||||
|
||||
// select
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn ___syscall142(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall142(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall142 (newselect) {}", which);
|
||||
|
||||
let nfds: i32 = varargs.get(vmctx);
|
||||
let readfds: u32 = varargs.get(vmctx);
|
||||
let writefds: u32 = varargs.get(vmctx);
|
||||
let exceptfds: u32 = varargs.get(vmctx);
|
||||
let _timeout: i32 = varargs.get(vmctx);
|
||||
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!(exceptfds == 0, "`exceptfds` is not supporrted");
|
||||
|
||||
let readfds_ptr = vmctx.memory(0)[readfds as usize] as _;
|
||||
let writefds_ptr = vmctx.memory(0)[writefds as usize] as _;
|
||||
let readfds_ptr = emscripten_memory_pointer!(ctx.memory(0), readfds) as _;
|
||||
let writefds_ptr = emscripten_memory_pointer!(ctx.memory(0), writefds) as _;
|
||||
|
||||
unsafe { select(nfds, readfds_ptr, writefds_ptr, 0 as _, 0 as _) }
|
||||
}
|
||||
|
||||
// mmap2
|
||||
pub extern "C" fn ___syscall192(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall192(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall192 (mmap2) {}", which);
|
||||
let addr: i32 = varargs.get(vmctx);
|
||||
let len: u32 = varargs.get(vmctx);
|
||||
let prot: i32 = varargs.get(vmctx);
|
||||
let flags: i32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let off: i32 = varargs.get(vmctx);
|
||||
let addr: i32 = varargs.get(ctx);
|
||||
let len: u32 = varargs.get(ctx);
|
||||
let prot: i32 = varargs.get(ctx);
|
||||
let flags: i32 = varargs.get(ctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let off: i32 = varargs.get(ctx);
|
||||
debug!(
|
||||
"=> addr: {}, len: {}, prot: {}, flags: {}, fd: {}, off: {}",
|
||||
addr, len, prot, flags, fd, off
|
||||
);
|
||||
|
||||
if fd == -1 {
|
||||
let ptr = env::call_memalign(16384, len, vmctx);
|
||||
let ptr = env::call_memalign(16384, len, ctx);
|
||||
if ptr == 0 {
|
||||
return -1;
|
||||
}
|
||||
env::call_memset(ptr, 0, len, vmctx);
|
||||
env::call_memset(ptr, 0, len, ctx);
|
||||
ptr as _
|
||||
} else {
|
||||
-1
|
||||
@ -576,29 +576,29 @@ pub extern "C" fn ___syscall192(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
}
|
||||
|
||||
/// lseek
|
||||
pub extern "C" fn ___syscall140(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> off_t {
|
||||
pub extern "C" fn ___syscall140(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> off_t {
|
||||
debug!("emscripten::___syscall140 (lseek) {}", which);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let offset: i64 = varargs.get(vmctx);
|
||||
let whence: i32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let offset: i64 = varargs.get(ctx);
|
||||
let whence: i32 = varargs.get(ctx);
|
||||
debug!("=> fd: {}, offset: {}, whence = {}", fd, offset, whence);
|
||||
unsafe { lseek(fd, offset, whence) }
|
||||
}
|
||||
|
||||
/// readv
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn ___syscall145(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> ssize_t {
|
||||
pub extern "C" fn ___syscall145(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> ssize_t {
|
||||
debug!("emscripten::___syscall145 (readv) {}", which);
|
||||
// let fd: i32 = varargs.get(vmctx);
|
||||
// let iov: u32 = varargs.get(vmctx);
|
||||
// let iovcnt: i32 = varargs.get(vmctx);
|
||||
// let fd: i32 = varargs.get(ctx);
|
||||
// let iov: u32 = varargs.get(ctx);
|
||||
// let iovcnt: i32 = varargs.get(ctx);
|
||||
// debug!("=> fd: {}, iov: {}, iovcnt = {}", fd, iov, iovcnt);
|
||||
// let iov_addr = vmctx.memory(0)[iov as usize] as *mut iovec;
|
||||
// let iov_addr = emscripten_memory_pointer!(ctx.memory(0), iov) as *mut iovec;
|
||||
// unsafe { readv(fd, iov_addr, iovcnt) }
|
||||
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let iov: i32 = varargs.get(vmctx);
|
||||
let iovcnt: i32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let iov: i32 = varargs.get(ctx);
|
||||
let iovcnt: i32 = varargs.get(ctx);
|
||||
|
||||
#[repr(C)]
|
||||
struct GuestIovec {
|
||||
@ -610,8 +610,8 @@ pub extern "C" fn ___syscall145(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
let mut ret = 0;
|
||||
unsafe {
|
||||
for i in 0..iovcnt {
|
||||
let guest_iov_addr = vmctx.memory(0)[(iov + i * 8) as usize] as *mut GuestIovec;
|
||||
let iov_base = vmctx.memory(0)[(*guest_iov_addr).iov_base as usize] as *mut c_void;
|
||||
let guest_iov_addr = emscripten_memory_pointer!(ctx.memory(0), (iov + i * 8)) as *mut GuestIovec;
|
||||
let iov_base = emscripten_memory_pointer!(ctx.memory(0), (*guest_iov_addr).iov_base) as *mut c_void;
|
||||
let iov_len: usize = (*guest_iov_addr).iov_len as _;
|
||||
// debug!("=> iov_addr: {:?}, {:?}", iov_base, iov_len);
|
||||
let curr = read(fd, iov_base, iov_len);
|
||||
@ -627,11 +627,11 @@ pub extern "C" fn ___syscall145(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
|
||||
// writev
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn ___syscall146(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> ssize_t {
|
||||
pub extern "C" fn ___syscall146(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> ssize_t {
|
||||
debug!("emscripten::___syscall146 (writev) {}", which);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let iov: i32 = varargs.get(vmctx);
|
||||
let iovcnt: i32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let iov: i32 = varargs.get(ctx);
|
||||
let iovcnt: i32 = varargs.get(ctx);
|
||||
|
||||
#[repr(C)]
|
||||
struct GuestIovec {
|
||||
@ -643,8 +643,8 @@ pub extern "C" fn ___syscall146(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
let mut ret = 0;
|
||||
unsafe {
|
||||
for i in 0..iovcnt {
|
||||
let guest_iov_addr = vmctx.memory(0)[(iov + i * 8) as usize] as *mut GuestIovec;
|
||||
let iov_base = vmctx.memory(0)[(*guest_iov_addr).iov_base as usize] as *const c_void;
|
||||
let guest_iov_addr = emscripten_memory_pointer!(ctx.memory(0), (iov + i * 8)) as *mut GuestIovec;
|
||||
let iov_base = emscripten_memory_pointer!(ctx.memory(0), (*guest_iov_addr).iov_base) as *const c_void;
|
||||
let iov_len: usize = (*guest_iov_addr).iov_len as _;
|
||||
// debug!("=> iov_addr: {:?}, {:?}", iov_base, iov_len);
|
||||
let curr = write(fd, iov_base, iov_len);
|
||||
@ -659,35 +659,35 @@ pub extern "C" fn ___syscall146(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
}
|
||||
|
||||
// pread
|
||||
pub extern "C" fn ___syscall180(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall180(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall180 (pread) {}", which);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let buf: u32 = varargs.get(vmctx);
|
||||
let count: u32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: u32 = varargs.get(ctx);
|
||||
{
|
||||
let zero: u32 = varargs.get(vmctx);
|
||||
let zero: u32 = varargs.get(ctx);
|
||||
assert_eq!(zero, 0);
|
||||
}
|
||||
let offset: i64 = varargs.get(vmctx);
|
||||
let offset: i64 = varargs.get(ctx);
|
||||
|
||||
let buf_ptr = vmctx.memory(0)[buf as usize] as _;
|
||||
let buf_ptr = emscripten_memory_pointer!(ctx.memory(0), buf) as _;
|
||||
|
||||
unsafe { pread(fd, buf_ptr, count as _, offset) as _ }
|
||||
}
|
||||
|
||||
// pwrite
|
||||
pub extern "C" fn ___syscall181(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall181(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall181 (pwrite) {}", which);
|
||||
let fd: i32 = varargs.get(vmctx);
|
||||
let buf: u32 = varargs.get(vmctx);
|
||||
let count: u32 = varargs.get(vmctx);
|
||||
let fd: i32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
let count: u32 = varargs.get(ctx);
|
||||
{
|
||||
let zero: u32 = varargs.get(vmctx);
|
||||
let zero: u32 = varargs.get(ctx);
|
||||
assert_eq!(zero, 0);
|
||||
}
|
||||
let offset: i64 = varargs.get(vmctx);
|
||||
let offset: i64 = varargs.get(ctx);
|
||||
|
||||
let buf_ptr = vmctx.memory(0)[buf as usize] as _;
|
||||
let buf_ptr = emscripten_memory_pointer!(ctx.memory(0), buf) as _;
|
||||
let status = unsafe { pwrite(fd, buf_ptr, count as _, offset) as _ };
|
||||
debug!(
|
||||
"=> fd: {}, buf: {}, count: {}, offset: {} = status:{}",
|
||||
@ -697,12 +697,12 @@ pub extern "C" fn ___syscall181(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
}
|
||||
|
||||
// stat64
|
||||
pub extern "C" fn ___syscall195(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall195(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall195 (stat64) {}", which);
|
||||
let pathname: u32 = varargs.get(vmctx);
|
||||
let buf: u32 = varargs.get(vmctx);
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
|
||||
let pathname_addr = vmctx.memory(0)[pathname as usize] as *const i8;
|
||||
let pathname_addr = emscripten_memory_pointer!(ctx.memory(0), pathname) as *const i8;
|
||||
|
||||
unsafe {
|
||||
let mut _stat: stat = std::mem::zeroed();
|
||||
@ -711,16 +711,16 @@ pub extern "C" fn ___syscall195(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
if ret != 0 {
|
||||
return ret;
|
||||
}
|
||||
copy_stat_into_wasm(vmctx, buf, &_stat);
|
||||
copy_stat_into_wasm(ctx, buf, &_stat);
|
||||
}
|
||||
0
|
||||
}
|
||||
|
||||
// fstat64
|
||||
pub extern "C" fn ___syscall197(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall197(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall197 (fstat64) {}", which);
|
||||
let fd: c_int = varargs.get(vmctx);
|
||||
let buf: u32 = varargs.get(vmctx);
|
||||
let fd: c_int = varargs.get(ctx);
|
||||
let buf: u32 = varargs.get(ctx);
|
||||
|
||||
unsafe {
|
||||
let mut stat = std::mem::zeroed();
|
||||
@ -729,7 +729,7 @@ pub extern "C" fn ___syscall197(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
if ret != 0 {
|
||||
return ret;
|
||||
}
|
||||
copy_stat_into_wasm(vmctx, buf, &stat);
|
||||
copy_stat_into_wasm(ctx, buf, &stat);
|
||||
}
|
||||
|
||||
0
|
||||
@ -754,24 +754,24 @@ pub extern "C" fn ___syscall202() -> gid_t {
|
||||
}
|
||||
|
||||
// chown
|
||||
pub extern "C" fn ___syscall212(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall212(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall212 (chown) {}", which);
|
||||
|
||||
let pathname: u32 = varargs.get(vmctx);
|
||||
let owner: u32 = varargs.get(vmctx);
|
||||
let group: u32 = varargs.get(vmctx);
|
||||
let pathname: u32 = varargs.get(ctx);
|
||||
let owner: u32 = varargs.get(ctx);
|
||||
let group: u32 = varargs.get(ctx);
|
||||
|
||||
let pathname_addr = vmctx.memory(0)[pathname as usize] as *const i8;
|
||||
let pathname_addr = emscripten_memory_pointer!(ctx.memory(0), pathname) as *const i8;
|
||||
|
||||
unsafe { chown(pathname_addr, owner, group) }
|
||||
}
|
||||
|
||||
// fcntl64
|
||||
pub extern "C" fn ___syscall221(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall221(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall221 (fcntl64) {}", which);
|
||||
// fcntl64
|
||||
let _fd: i32 = varargs.get(vmctx);
|
||||
let cmd: u32 = varargs.get(vmctx);
|
||||
let _fd: i32 = varargs.get(ctx);
|
||||
let cmd: u32 = varargs.get(ctx);
|
||||
match cmd {
|
||||
2 => 0,
|
||||
_ => -1,
|
||||
@ -779,12 +779,12 @@ pub extern "C" fn ___syscall221(which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
}
|
||||
|
||||
/// dup3
|
||||
pub extern "C" fn ___syscall330(_which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> pid_t {
|
||||
pub extern "C" fn ___syscall330(_which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> pid_t {
|
||||
// Implementation based on description at https://linux.die.net/man/2/dup3
|
||||
debug!("emscripten::___syscall330 (dup3)");
|
||||
let oldfd: c_int = varargs.get(vmctx);
|
||||
let newfd: c_int = varargs.get(vmctx);
|
||||
let flags: c_int = varargs.get(vmctx);
|
||||
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 EINVAL;
|
||||
@ -813,17 +813,17 @@ pub extern "C" fn ___syscall330(_which: c_int, mut varargs: VarArgs, vmctx: &mut
|
||||
}
|
||||
|
||||
// prlimit64
|
||||
pub extern "C" fn ___syscall340(which: c_int, mut varargs: VarArgs, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___syscall340(which: c_int, mut varargs: VarArgs, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___syscall340 (prlimit64), {}", which);
|
||||
// NOTE: Doesn't really matter. Wasm modules cannot exceed WASM_PAGE_SIZE anyway.
|
||||
let _pid: i32 = varargs.get(vmctx);
|
||||
let _resource: i32 = varargs.get(vmctx);
|
||||
let _new_limit: u32 = varargs.get(vmctx);
|
||||
let old_limit: u32 = varargs.get(vmctx);
|
||||
let _pid: i32 = varargs.get(ctx);
|
||||
let _resource: i32 = varargs.get(ctx);
|
||||
let _new_limit: u32 = varargs.get(ctx);
|
||||
let old_limit: u32 = varargs.get(ctx);
|
||||
|
||||
if old_limit != 0 {
|
||||
// just report no limits
|
||||
let buf_ptr = vmctx.memory(0)[old_limit as usize] as *mut u8;
|
||||
let buf_ptr = emscripten_memory_pointer!(ctx.memory(0), old_limit) as *mut u8;
|
||||
let buf = unsafe { slice::from_raw_parts_mut(buf_ptr, 16) };
|
||||
|
||||
LittleEndian::write_i32(&mut buf[..], -1); // RLIM_INFINITY
|
||||
|
||||
@ -26,7 +26,7 @@ const CLOCK_MONOTONIC_COARSE: libc::clockid_t = 6;
|
||||
|
||||
/// emscripten: _gettimeofday
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn _gettimeofday(tp: c_int, tz: c_int, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn _gettimeofday(tp: c_int, tz: c_int, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::_gettimeofday {} {}", tp, tz);
|
||||
#[repr(C)]
|
||||
struct GuestTimeVal {
|
||||
@ -41,7 +41,7 @@ pub extern "C" fn _gettimeofday(tp: c_int, tz: c_int, vmctx: &mut Ctx) -> c_int
|
||||
unsafe {
|
||||
let now = SystemTime::now();
|
||||
let since_epoch = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
|
||||
let timeval_struct_ptr = vmctx.memory(0)[tp as usize] as *mut GuestTimeVal;
|
||||
let timeval_struct_ptr = emscripten_memory_pointer!(ctx.memory(0), tp) as *mut GuestTimeVal;
|
||||
|
||||
(*timeval_struct_ptr).tv_sec = since_epoch.as_secs() as _;
|
||||
(*timeval_struct_ptr).tv_usec = since_epoch.subsec_nanos() as _;
|
||||
@ -51,8 +51,9 @@ pub extern "C" fn _gettimeofday(tp: c_int, tz: c_int, vmctx: &mut Ctx) -> c_int
|
||||
|
||||
/// emscripten: _clock_gettime
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn _clock_gettime(clk_id: libc::clockid_t, tp: c_int, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn _clock_gettime(clk_id: libc::clockid_t, tp: c_int, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::_clock_gettime {} {}", clk_id, tp);
|
||||
// debug!("Memory {:?}", ctx.memory(0)[..]);
|
||||
#[repr(C)]
|
||||
struct GuestTimeSpec {
|
||||
tv_sec: i32,
|
||||
@ -72,7 +73,7 @@ pub extern "C" fn _clock_gettime(clk_id: libc::clockid_t, tp: c_int, vmctx: &mut
|
||||
};
|
||||
|
||||
unsafe {
|
||||
let timespec_struct_ptr = vmctx.memory(0)[tp as usize] as *mut GuestTimeSpec;
|
||||
let timespec_struct_ptr = emscripten_memory_pointer!(ctx.memory(0), tp) as *mut GuestTimeSpec;
|
||||
(*timespec_struct_ptr).tv_sec = timespec.sec as _;
|
||||
(*timespec_struct_ptr).tv_nsec = timespec.nsec as _;
|
||||
}
|
||||
@ -80,9 +81,9 @@ pub extern "C" fn _clock_gettime(clk_id: libc::clockid_t, tp: c_int, vmctx: &mut
|
||||
}
|
||||
|
||||
/// emscripten: ___clock_gettime
|
||||
pub extern "C" fn ___clock_gettime(clk_id: libc::clockid_t, tp: c_int, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn ___clock_gettime(clk_id: libc::clockid_t, tp: c_int, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::___clock_gettime {} {}", clk_id, tp);
|
||||
_clock_gettime(clk_id, tp, vmctx)
|
||||
_clock_gettime(clk_id, tp, ctx)
|
||||
}
|
||||
|
||||
/// emscripten: _clock
|
||||
@ -119,8 +120,8 @@ pub extern "C" fn _tvset() {
|
||||
|
||||
/// formats time as a C string
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
unsafe extern "C" fn fmt_time(time: u32, vmctx: &mut Ctx) -> *const c_char {
|
||||
let date = &*(vmctx.memory(0)[time as usize] as *mut guest_tm);
|
||||
unsafe extern "C" fn fmt_time(time: u32, ctx: &mut Ctx) -> *const c_char {
|
||||
let date = &*(emscripten_memory_pointer!(ctx.memory(0), time) as *mut guest_tm);
|
||||
|
||||
let days = vec!["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
|
||||
let months = vec![
|
||||
@ -144,21 +145,21 @@ unsafe extern "C" fn fmt_time(time: u32, vmctx: &mut Ctx) -> *const c_char {
|
||||
}
|
||||
|
||||
/// emscripten: _asctime
|
||||
pub extern "C" fn _asctime(time: u32, vmctx: &mut Ctx) -> u32 {
|
||||
pub extern "C" fn _asctime(time: u32, ctx: &mut Ctx) -> u32 {
|
||||
debug!("emscripten::_asctime {}", time);
|
||||
|
||||
unsafe {
|
||||
let time_str_ptr = fmt_time(time, vmctx);
|
||||
copy_cstr_into_wasm(vmctx, time_str_ptr)
|
||||
let time_str_ptr = fmt_time(time, ctx);
|
||||
copy_cstr_into_wasm(ctx, time_str_ptr)
|
||||
|
||||
// let c_str = vmctx.memory(0)[res as usize] as *mut i8;
|
||||
// let c_str = emscripten_memory_pointer!(ctx.memory(0), res) as *mut i8;
|
||||
// use std::ffi::CStr;
|
||||
// debug!("#### cstr = {:?}", CStr::from_ptr(c_str));
|
||||
}
|
||||
}
|
||||
|
||||
/// emscripten: _asctime_r
|
||||
pub extern "C" fn _asctime_r(time: u32, buf: u32, vmctx: &mut Ctx) -> u32 {
|
||||
pub extern "C" fn _asctime_r(time: u32, buf: u32, ctx: &mut Ctx) -> u32 {
|
||||
debug!("emscripten::_asctime_r {}, {}", time, buf);
|
||||
|
||||
unsafe {
|
||||
@ -166,10 +167,10 @@ pub extern "C" fn _asctime_r(time: u32, buf: u32, vmctx: &mut Ctx) -> u32 {
|
||||
// to write out more than 26 bytes (including the null terminator).
|
||||
// See http://pubs.opengroup.org/onlinepubs/9699919799/functions/asctime.html
|
||||
// Our undefined behavior is to truncate the write to at most 26 bytes, including null terminator.
|
||||
let time_str_ptr = fmt_time(time, vmctx);
|
||||
write_to_buf(time_str_ptr, buf, 26, vmctx)
|
||||
let time_str_ptr = fmt_time(time, ctx);
|
||||
write_to_buf(time_str_ptr, buf, 26, ctx)
|
||||
|
||||
// let c_str = vmctx.memory(0)[res as usize] as *mut i8;
|
||||
// let c_str = emscripten_memory_pointer!(ctx.memory(0), res) as *mut i8;
|
||||
// use std::ffi::CStr;
|
||||
// debug!("#### cstr = {:?}", CStr::from_ptr(c_str));
|
||||
}
|
||||
@ -177,21 +178,21 @@ pub extern "C" fn _asctime_r(time: u32, buf: u32, vmctx: &mut Ctx) -> u32 {
|
||||
|
||||
/// emscripten: _localtime
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn _localtime(time_p: u32, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn _localtime(time_p: u32, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::_localtime {}", time_p);
|
||||
// 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 timespec = unsafe {
|
||||
let time_p_addr = vmctx.memory(0)[time_p as usize] as *mut i64;
|
||||
let time_p_addr = emscripten_memory_pointer!(ctx.memory(0), time_p) as *mut i64;
|
||||
let seconds = *time_p_addr.clone();
|
||||
time::Timespec::new(seconds, 0)
|
||||
};
|
||||
let result_tm = time::at(timespec);
|
||||
|
||||
unsafe {
|
||||
let tm_struct_offset = env::call_malloc(mem::size_of::<guest_tm>() as _, vmctx);
|
||||
let tm_struct_ptr = vmctx.memory(0)[tm_struct_offset as usize] as *mut guest_tm;
|
||||
let tm_struct_offset = env::call_malloc(mem::size_of::<guest_tm>() as _, ctx);
|
||||
let tm_struct_ptr = emscripten_memory_pointer!(ctx.memory(0), 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,
|
||||
@ -214,14 +215,14 @@ pub extern "C" fn _localtime(time_p: u32, vmctx: &mut Ctx) -> c_int {
|
||||
}
|
||||
/// emscripten: _localtime_r
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn _localtime_r(time_p: u32, result: u32, vmctx: &mut Ctx) -> c_int {
|
||||
pub extern "C" fn _localtime_r(time_p: u32, result: u32, ctx: &mut Ctx) -> c_int {
|
||||
debug!("emscripten::_localtime_r {}", time_p);
|
||||
|
||||
// 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
|
||||
|
||||
unsafe {
|
||||
let seconds = vmctx.memory(0)[time_p as usize] as *const i32;
|
||||
let seconds = emscripten_memory_pointer!(ctx.memory(0), time_p) as *const i32;
|
||||
let timespec = time::Timespec::new(*seconds as _, 0);
|
||||
let result_tm = time::at(timespec);
|
||||
|
||||
@ -231,7 +232,7 @@ pub extern "C" fn _localtime_r(time_p: u32, result: u32, vmctx: &mut Ctx) -> c_i
|
||||
// result_tm.tm_mon, result_tm.tm_year, result_tm.tm_wday, result_tm.tm_yday,
|
||||
// );
|
||||
|
||||
let result_addr = vmctx.memory(0)[result as usize] as *mut guest_tm;
|
||||
let result_addr = emscripten_memory_pointer!(ctx.memory(0), result) as *mut guest_tm;
|
||||
|
||||
(*result_addr).tm_sec = result_tm.tm_sec;
|
||||
(*result_addr).tm_min = result_tm.tm_min;
|
||||
@ -251,11 +252,11 @@ pub extern "C" fn _localtime_r(time_p: u32, result: u32, vmctx: &mut Ctx) -> c_i
|
||||
|
||||
/// emscripten: _time
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub extern "C" fn _time(time_p: u32, vmctx: &mut Ctx) -> time_t {
|
||||
pub extern "C" fn _time(time_p: u32, ctx: &mut Ctx) -> time_t {
|
||||
debug!("emscripten::_time {}", time_p);
|
||||
|
||||
unsafe {
|
||||
let time_p_addr = vmctx.memory(0)[time_p as usize] as *mut i64;
|
||||
let time_p_addr = emscripten_memory_pointer!(ctx.memory(0), time_p) as *mut i64;
|
||||
libc_time(time_p_addr)
|
||||
}
|
||||
}
|
||||
@ -266,7 +267,7 @@ pub extern "C" fn _strftime(
|
||||
maxsize: u32,
|
||||
format_ptr: c_int,
|
||||
tm_ptr: c_int,
|
||||
_vmctx: &mut Ctx,
|
||||
_ctx: &mut Ctx,
|
||||
) -> time_t {
|
||||
debug!(
|
||||
"emscripten::_strftime {} {} {} {}",
|
||||
|
||||
@ -18,7 +18,7 @@ pub fn is_emscripten_module(module: &Module) -> bool {
|
||||
}
|
||||
|
||||
pub unsafe fn write_to_buf(string: *const c_char, buf: u32, max: u32, ctx: &mut Ctx) -> u32 {
|
||||
let buf_addr = ctx.memory(0)[buf as usize] as *mut c_char;
|
||||
let buf_addr = emscripten_memory_pointer!(ctx.memory(0), buf) as *mut c_char;
|
||||
|
||||
for i in 0..max {
|
||||
*buf_addr.add(i as _) = *string.add(i as _);
|
||||
@ -32,7 +32,7 @@ pub unsafe fn copy_cstr_into_wasm(ctx: &mut Ctx, cstr: *const c_char) -> u32 {
|
||||
let s = CStr::from_ptr(cstr).to_str().unwrap();
|
||||
let cstr_len = s.len();
|
||||
let space_offset = env::call_malloc((cstr_len as i32) + 1, ctx);
|
||||
let raw_memory = ctx.memory(0)[space_offset as usize] as *mut u8;
|
||||
let raw_memory = emscripten_memory_pointer!(ctx.memory(0), space_offset) as *mut u8;
|
||||
let slice = slice::from_raw_parts_mut(raw_memory, cstr_len);
|
||||
|
||||
for (byte, loc) in s.bytes().zip(slice.iter_mut()) {
|
||||
@ -48,7 +48,7 @@ pub unsafe fn copy_cstr_into_wasm(ctx: &mut Ctx, cstr: *const c_char) -> u32 {
|
||||
|
||||
pub unsafe fn allocate_on_stack<'a, T: Copy>(count: u32, ctx: &'a mut Ctx) -> (u32, &'a mut [T]) {
|
||||
let offset = (get_emscripten_data(ctx).stack_alloc)(count * (size_of::<T>() as u32), ctx);
|
||||
let addr = ctx.memory(0)[offset as usize] as *mut T;
|
||||
let addr = emscripten_memory_pointer!(ctx.memory(0), offset) as *mut T;
|
||||
let slice = slice::from_raw_parts_mut(addr, count as usize);
|
||||
|
||||
(offset, slice)
|
||||
@ -104,7 +104,7 @@ pub struct GuestStat {
|
||||
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
pub unsafe fn copy_stat_into_wasm(ctx: &mut Ctx, buf: u32, stat: &stat) {
|
||||
let stat_ptr = ctx.memory(0)[buf as usize] as *mut GuestStat;
|
||||
let stat_ptr = emscripten_memory_pointer!(ctx.memory(0), 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 _;
|
||||
|
||||
@ -7,8 +7,8 @@ pub struct VarArgs {
|
||||
}
|
||||
|
||||
impl VarArgs {
|
||||
pub fn get<T: Sized>(&mut self, vmctx: &mut Ctx) -> T {
|
||||
let ptr = vmctx.memory(0)[self.pointer as usize];
|
||||
pub fn get<T: Sized>(&mut self, ctx: &mut Ctx) -> T {
|
||||
let ptr = emscripten_memory_pointer!(ctx.memory(0), self.pointer);
|
||||
self.pointer += mem::size_of::<T>() as u32;
|
||||
unsafe { (ptr as *const T).read() }
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user