diff --git a/Cargo.toml b/Cargo.toml index d937ccd984..84b5643cd4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,6 +15,7 @@ failure = "0.1" libc = "0.2" rand = "0.6" cfg-if = "0.1.9" +log = "0.4" [target.'cfg(unix)'.dependencies] nix = "0.13" diff --git a/src/hostcalls/fs.rs b/src/hostcalls/fs.rs index ea10594472..735b6e5dda 100644 --- a/src/hostcalls/fs.rs +++ b/src/hostcalls/fs.rs @@ -1,44 +1,55 @@ #![allow(non_camel_case_types)] +use super::return_enc_errno; use crate::ctx::WasiCtx; use crate::memory::*; use crate::sys::host_impl; use crate::sys::hostcalls_impl; use crate::{host, wasm32}; +use log::trace; +use std::convert::identity; use wasi_common_cbindgen::wasi_common_cbindgen; #[wasi_common_cbindgen] pub fn fd_close(wasi_ctx: &mut WasiCtx, fd: wasm32::__wasi_fd_t) -> wasm32::__wasi_errno_t { + trace!("fd_close(fd={:?})", fd); + let fd = dec_fd(fd); if let Some(fdent) = wasi_ctx.fds.get(&fd) { // can't close preopened files if fdent.preopen_path.is_some() { - return wasm32::__WASI_ENOTSUP; + return return_enc_errno(host::__WASI_ENOTSUP); } } - if let Some(mut fdent) = wasi_ctx.fds.remove(&fd) { + let ret = if let Some(mut fdent) = wasi_ctx.fds.remove(&fd) { fdent.fd_object.needs_close = false; match hostcalls_impl::fd_close(fdent) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, } } else { - wasm32::__WASI_EBADF - } + host::__WASI_EBADF + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] pub fn fd_datasync(wasi_ctx: &WasiCtx, fd: wasm32::__wasi_fd_t) -> wasm32::__wasi_errno_t { + trace!("fd_datasync(fd={:?})", fd); + let host_fd = dec_fd(fd); let rights = host::__WASI_RIGHT_FD_DATASYNC; let fe = match wasi_ctx.get_fd_entry(host_fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match hostcalls_impl::fd_datasync(fe) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::fd_datasync(fe) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -51,25 +62,34 @@ pub fn fd_pread( offset: wasm32::__wasi_filesize_t, nread: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_pread(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, offset={}, nread={:#x?})", + fd, + iovs_ptr, + iovs_len, + offset, + nread + ); + let fd = dec_fd(fd); let iovs = match dec_iovec_slice(memory, iovs_ptr, iovs_len) { Ok(iovs) => iovs, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let rights = host::__WASI_RIGHT_FD_READ; let fe = match wasi_ctx.get_fd_entry(fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let offset = dec_filesize(offset); if offset > i64::max_value() as u64 { - return wasm32::__WASI_EIO; + return return_enc_errno(host::__WASI_EIO); } let buf_size = iovs.iter().map(|v| v.buf_len).sum(); let mut buf = vec![0; buf_size]; let host_nread = match hostcalls_impl::fd_pread(fe, &mut buf, offset) { Ok(host_nread) => host_nread, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let mut buf_offset = 0; let mut left = host_nread; @@ -83,9 +103,14 @@ pub fn fd_pread( buf_offset += vec_len; left -= vec_len; } - enc_usize_byref(memory, nread, host_nread) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + + trace!(" | *nread={:?}", host_nread); + + let ret = enc_usize_byref(memory, nread, host_nread) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -98,19 +123,28 @@ pub fn fd_pwrite( offset: wasm32::__wasi_filesize_t, nwritten: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_pwrite(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, offset={}, nwritten={:#x?})", + fd, + iovs_ptr, + iovs_len, + offset, + nwritten + ); + let fd = dec_fd(fd); let iovs = match dec_iovec_slice(memory, iovs_ptr, iovs_len) { Ok(iovs) => iovs, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let rights = host::__WASI_RIGHT_FD_READ; let fe = match wasi_ctx.get_fd_entry(fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let offset = dec_filesize(offset); if offset > i64::max_value() as u64 { - return wasm32::__WASI_EIO; + return return_enc_errno(host::__WASI_EIO); } let buf_size = iovs.iter().map(|v| v.buf_len).sum(); let mut buf = Vec::with_capacity(buf_size); @@ -121,11 +155,16 @@ pub fn fd_pwrite( } let host_nwritten = match hostcalls_impl::fd_pwrite(fe, &buf, offset) { Ok(host_nwritten) => host_nwritten, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - enc_usize_byref(memory, nwritten, host_nwritten) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + + trace!(" | *nwritten={:?}", host_nwritten); + + let ret = enc_usize_byref(memory, nwritten, host_nwritten) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -137,20 +176,28 @@ pub fn fd_read( iovs_len: wasm32::size_t, nread: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_read(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, nread={:#x?})", + fd, + iovs_ptr, + iovs_len, + nread + ); + let fd = dec_fd(fd); let mut iovs = match dec_iovec_slice(memory, iovs_ptr, iovs_len) { Ok(iovs) => iovs, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let fe = match wasi_ctx.get_fd_entry(fd, host::__WASI_RIGHT_FD_READ, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let host_nread = match hostcalls_impl::fd_read(fe, &mut iovs) { Ok(host_nread) => host_nread, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; if host_nread == 0 { @@ -159,9 +206,13 @@ pub fn fd_read( fe.fd_object.needs_close = false; } - enc_usize_byref(memory, nread, host_nread) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + trace!(" | *nread={:?}", host_nread); + + let ret = enc_usize_byref(memory, nread, host_nread) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -170,13 +221,17 @@ pub fn fd_renumber( from: wasm32::__wasi_fd_t, to: wasm32::__wasi_fd_t, ) -> wasm32::__wasi_errno_t { + trace!("fd_renumber(from={:?}, to={:?})", from, to); + let from = dec_fd(from); let to = dec_fd(to); - match hostcalls_impl::fd_renumber(wasi_ctx, from, to) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::fd_renumber(wasi_ctx, from, to) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -188,6 +243,14 @@ pub fn fd_seek( whence: wasm32::__wasi_whence_t, newoffset: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_seek(fd={:?}, offset={:?}, whence={}, newoffset={:#x?})", + fd, + offset, + wasm32::whence_to_str(whence), + newoffset + ); + let fd = dec_fd(fd); let offset = dec_filedelta(offset); let whence = dec_whence(whence); @@ -199,16 +262,20 @@ pub fn fd_seek( }; let fe = match wasi_ctx.get_fd_entry(fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let host_newoffset = match hostcalls_impl::fd_seek(fe, offset, whence) { Ok(host_newoffset) => host_newoffset, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - enc_filesize_byref(memory, newoffset, host_newoffset) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + trace!(" | *newoffset={:?}", host_newoffset); + + let ret = enc_filesize_byref(memory, newoffset, host_newoffset) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -218,21 +285,27 @@ pub fn fd_tell( fd: wasm32::__wasi_fd_t, newoffset: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!("fd_tell(fd={:?}, newoffset={:#x?})", fd, newoffset); + let fd = dec_fd(fd); let rights = host::__WASI_RIGHT_FD_TELL; let fe = match wasi_ctx.get_fd_entry(fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let host_offset = match hostcalls_impl::fd_tell(fe) { Ok(host_offset) => host_offset, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - enc_filesize_byref(memory, newoffset, host_offset) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + trace!(" | *newoffset={:?}", host_offset); + + let ret = enc_filesize_byref(memory, newoffset, host_offset) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -242,30 +315,34 @@ pub fn fd_fdstat_get( fd: wasm32::__wasi_fd_t, fdstat_ptr: wasm32::uintptr_t, // *mut wasm32::__wasi_fdstat_t ) -> wasm32::__wasi_errno_t { + trace!("fd_fdstat_get(fd={:?}, fdstat_ptr={:#x?})", fd, fdstat_ptr); + let host_fd = dec_fd(fd); let mut host_fdstat = match dec_fdstat_byref(memory, fdstat_ptr) { Ok(host_fdstat) => host_fdstat, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - let errno = if let Some(fe) = wasi_ctx.fds.get(&host_fd) { + let ret = if let Some(fe) = wasi_ctx.fds.get(&host_fd) { host_fdstat.fs_filetype = fe.fd_object.ty; host_fdstat.fs_rights_base = fe.rights_base; host_fdstat.fs_rights_inheriting = fe.rights_inheriting; host_fdstat.fs_flags = match hostcalls_impl::fd_fdstat_get(fe) { Ok(flags) => flags, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - wasm32::__WASI_ESUCCESS + host::__WASI_ESUCCESS } else { - wasm32::__WASI_EBADF + host::__WASI_EBADF }; + trace!(" | *buf={:?}", host_fdstat); + if let Err(e) = enc_fdstat_byref(memory, fdstat_ptr, host_fdstat) { - return enc_errno(e); + return return_enc_errno(e); } - errno + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -274,15 +351,19 @@ pub fn fd_fdstat_set_flags( fd: wasm32::__wasi_fd_t, fdflags: wasm32::__wasi_fdflags_t, ) -> wasm32::__wasi_errno_t { + trace!("fd_fdstat_set_flags(fd={:?}, fdflags={:#x?})", fd, fdflags); + let host_fd = dec_fd(fd); let host_fdflags = dec_fdflags(fdflags); - match wasi_ctx.fds.get(&host_fd) { + let ret = match wasi_ctx.fds.get(&host_fd) { Some(fe) => match hostcalls_impl::fd_fdstat_set_flags(fe, host_fdflags) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, }, - None => wasm32::__WASI_EBADF, - } + None => host::__WASI_EBADF, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -292,34 +373,45 @@ pub fn fd_fdstat_set_rights( fs_rights_base: wasm32::__wasi_rights_t, fs_rights_inheriting: wasm32::__wasi_rights_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_fdstat_set_rights(fd={:?}, fs_rights_base={:#x?}, fs_rights_inheriting={:#x?})", + fd, + fs_rights_base, + fs_rights_inheriting + ); + let host_fd = dec_fd(fd); let fe = match wasi_ctx.fds.get_mut(&host_fd) { Some(fe) => fe, - None => return wasm32::__WASI_EBADF, + None => return return_enc_errno(host::__WASI_EBADF), }; if fe.rights_base & fs_rights_base != fs_rights_base || fe.rights_inheriting & fs_rights_inheriting != fs_rights_inheriting { - return wasm32::__WASI_ENOTCAPABLE; + return return_enc_errno(host::__WASI_ENOTCAPABLE); } - fe.rights_base = fs_rights_base; fe.rights_inheriting = fs_rights_inheriting; - wasm32::__WASI_ESUCCESS + + return_enc_errno(host::__WASI_ESUCCESS) } #[wasi_common_cbindgen] pub fn fd_sync(wasi_ctx: &WasiCtx, fd: wasm32::__wasi_fd_t) -> wasm32::__wasi_errno_t { + trace!("fd_sync(fd={:?})", fd); + let host_fd = dec_fd(fd); let rights = host::__WASI_RIGHT_FD_SYNC; let fe = match wasi_ctx.get_fd_entry(host_fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match hostcalls_impl::fd_sync(fe) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::fd_sync(fe) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -331,23 +423,35 @@ pub fn fd_write( iovs_len: wasm32::size_t, nwritten: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_write(fd={:?}, iovs_ptr={:#x?}, iovs_len={:?}, nwritten={:#x?})", + fd, + iovs_ptr, + iovs_len, + nwritten + ); + let fd = dec_fd(fd); let iovs = match dec_iovec_slice(memory, iovs_ptr, iovs_len) { Ok(iovs) => iovs, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let fe = match wasi_ctx.get_fd_entry(fd, host::__WASI_RIGHT_FD_WRITE, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let host_nwritten = match hostcalls_impl::fd_write(fe, &iovs) { Ok(host_nwritten) => host_nwritten, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - enc_usize_byref(memory, nwritten, host_nwritten) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + trace!(" | *nwritten={:?}", host_nwritten); + + let ret = enc_usize_byref(memory, nwritten, host_nwritten) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -358,20 +462,30 @@ pub fn fd_advise( len: wasm32::__wasi_filesize_t, advice: wasm32::__wasi_advice_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_advise(fd={:?}, offset={}, len={}, advice={:?})", + fd, + offset, + len, + advice + ); + let host_fd = dec_fd(fd); let rights = host::__WASI_RIGHT_FD_ADVISE; let fe = match wasi_ctx.get_fd_entry(host_fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let advice = dec_advice(advice); let offset = dec_filesize(offset); let len = dec_filesize(len); - match hostcalls_impl::fd_advise(fe, advice, offset, len) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::fd_advise(fe, advice, offset, len) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -381,19 +495,23 @@ pub fn fd_allocate( offset: wasm32::__wasi_filesize_t, len: wasm32::__wasi_filesize_t, ) -> wasm32::__wasi_errno_t { + trace!("fd_allocate(fd={:?}, offset={}, len={})", fd, offset, len); + let host_fd = dec_fd(fd); let rights = host::__WASI_RIGHT_FD_ALLOCATE; let fe = match wasi_ctx.get_fd_entry(host_fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let offset = dec_filesize(offset); let len = dec_filesize(len); - match hostcalls_impl::fd_allocate(fe, offset, len) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::fd_allocate(fe, offset, len) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -404,16 +522,27 @@ pub fn path_create_directory( path_ptr: wasm32::uintptr_t, path_len: wasm32::size_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_create_directory(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len, + ); + let dirfd = dec_fd(dirfd); let path = match dec_slice_of::(memory, path_ptr, path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match hostcalls_impl::path_create_directory(wasi_ctx, dirfd, &path) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + trace!(" | (path_ptr,path_len)={:?}", path); + + let ret = match hostcalls_impl::path_create_directory(wasi_ctx, dirfd, &path) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -421,25 +550,39 @@ pub fn path_link( wasi_ctx: &WasiCtx, memory: &mut [u8], old_dirfd: wasm32::__wasi_fd_t, - _old_flags: wasm32::__wasi_lookupflags_t, + old_flags: wasm32::__wasi_lookupflags_t, old_path_ptr: wasm32::uintptr_t, old_path_len: wasm32::size_t, new_dirfd: wasm32::__wasi_fd_t, new_path_ptr: wasm32::uintptr_t, new_path_len: wasm32::size_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_link(old_dirfd={:?}, old_flags={:?}, old_path_ptr={:#x?}, old_path_len={}, new_dirfd={:?}, new_path_ptr={:#x?}, new_path_len={})", + old_dirfd, + old_flags, + old_path_ptr, + old_path_len, + new_dirfd, + new_path_ptr, + new_path_len, + ); + let old_dirfd = dec_fd(old_dirfd); let new_dirfd = dec_fd(new_dirfd); let old_path = match dec_slice_of::(memory, old_path_ptr, old_path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let new_path = match dec_slice_of::(memory, new_path_ptr, new_path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match hostcalls_impl::path_link( + trace!(" | (old_path_ptr,old_path_len)={:?}", old_path); + trace!(" | (new_path_ptr,new_path_len)={:?}", new_path); + + let ret = match hostcalls_impl::path_link( wasi_ctx, old_dirfd, new_dirfd, @@ -448,9 +591,11 @@ pub fn path_link( host::__WASI_RIGHT_PATH_LINK_SOURCE, host::__WASI_RIGHT_PATH_LINK_TARGET, ) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -467,6 +612,19 @@ pub fn path_open( fs_flags: wasm32::__wasi_fdflags_t, fd_out_ptr: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_open(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={:?}, oflags={:#x?}, fs_rights_base={:#x?}, fs_rights_inheriting={:#x?}, fs_flags={:#x?}, fd_out_ptr={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + oflags, + fs_rights_base, + fs_rights_inheriting, + fs_flags, + fd_out_ptr + ); + let dirfd = dec_fd(dirfd); let dirflags = dec_lookupflags(dirflags); let oflags = dec_oflags(oflags); @@ -489,10 +647,12 @@ pub fn path_open( let path = match dec_slice_of::(memory, path_ptr, path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match hostcalls_impl::path_open( + trace!(" | (path_ptr,path_len)={:?}", path); + + let ret = match hostcalls_impl::path_open( wasi_ctx, dirfd, dirflags, @@ -507,21 +667,25 @@ pub fn path_open( Ok(fe) => { let guest_fd = match wasi_ctx.insert_fd_entry(fe) { Ok(fd) => fd, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; + trace!(" | *fd={:?}", guest_fd); + enc_fd_byref(memory, fd_out_ptr, guest_fd) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity) } Err(e) => { if let Err(e) = enc_fd_byref(memory, fd_out_ptr, wasm32::__wasi_fd_t::max_value()) { - return enc_errno(e); + return return_enc_errno(e); } - enc_errno(e) + e } - } + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -534,30 +698,46 @@ pub fn fd_readdir( cookie: wasm32::__wasi_dircookie_t, buf_used: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_readdir(fd={:?}, buf={:#x?}, buf_len={}, cookie={:#x?}, buf_used={:#x?})", + fd, + buf, + buf_len, + cookie, + buf_used, + ); + match enc_usize_byref(memory, buf_used, 0) { Ok(_) => {} - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let fd = dec_fd(fd); let rights = host::__WASI_RIGHT_FD_READDIR; let fe = match wasi_ctx.get_fd_entry(fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let host_buf = match dec_slice_of_mut::(memory, buf, buf_len) { Ok(host_buf) => host_buf, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; + + trace!(" | (buf,buf_len)={:?}", host_buf); + let cookie = dec_dircookie(cookie); let host_bufused = match hostcalls_impl::fd_readdir(fe, host_buf, cookie) { Ok(host_bufused) => host_bufused, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - enc_usize_byref(memory, buf_used, host_bufused) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + trace!(" | *buf_used={:?}", host_bufused); + + let ret = enc_usize_byref(memory, buf_used, host_bufused) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -571,18 +751,31 @@ pub fn path_readlink( buf_len: wasm32::size_t, buf_used: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_readlink(dirfd={:?}, path_ptr={:#x?}, path_len={:?}, buf_ptr={:#x?}, buf_len={}, buf_used={:#x?})", + dirfd, + path_ptr, + path_len, + buf_ptr, + buf_len, + buf_used, + ); + match enc_usize_byref(memory, buf_used, 0) { Ok(_) => {} - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let dirfd = dec_fd(dirfd); let path = match dec_slice_of::(memory, path_ptr, path_len) { Ok(slice) => host_impl::path_from_raw(slice).to_owned(), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; + + trace!(" | (path_ptr,path_len)={:?}", path); + let mut buf = match dec_slice_of_mut::(memory, buf_ptr, buf_len) { Ok(slice) => slice, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let host_bufused = match hostcalls_impl::path_readlink( wasi_ctx, @@ -592,12 +785,17 @@ pub fn path_readlink( &mut buf, ) { Ok(host_bufused) => host_bufused, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match enc_usize_byref(memory, buf_used, host_bufused) { - Ok(_) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + trace!(" | (buf_ptr,*buf_used)={:?}", buf); + trace!(" | *buf_used={:?}", host_bufused); + + let ret = match enc_usize_byref(memory, buf_used, host_bufused) { + Ok(_) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -611,25 +809,41 @@ pub fn path_rename( new_path_ptr: wasm32::uintptr_t, new_path_len: wasm32::size_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_rename(old_dirfd={:?}, old_path_ptr={:#x?}, old_path_len={:?}, new_dirfd={:?}, new_path_ptr={:#x?}, new_path_len={:?})", + old_dirfd, + old_path_ptr, + old_path_len, + new_dirfd, + new_path_ptr, + new_path_len, + ); + let old_dirfd = dec_fd(old_dirfd); let new_dirfd = dec_fd(new_dirfd); let old_path = match dec_slice_of::(memory, old_path_ptr, old_path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let new_path = match dec_slice_of::(memory, new_path_ptr, new_path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; + + trace!(" | (old_path_ptr,old_path_len)={:?}", old_path); + trace!(" | (new_path_ptr,new_path_len)={:?}", new_path); + let old_rights = host::__WASI_RIGHT_PATH_RENAME_SOURCE; let new_rights = host::__WASI_RIGHT_PATH_RENAME_TARGET; - match hostcalls_impl::path_rename( + let ret = match hostcalls_impl::path_rename( wasi_ctx, old_dirfd, &old_path, old_rights, new_dirfd, &new_path, new_rights, ) { Ok(()) => host::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -639,21 +853,31 @@ pub fn fd_filestat_get( fd: wasm32::__wasi_fd_t, filestat_ptr: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_filestat_get(fd={:?}, filestat_ptr={:#x?})", + fd, + filestat_ptr + ); + let host_fd = dec_fd(fd); let fe = match wasi_ctx.fds.get(&host_fd) { Some(fe) => fe, - None => return wasm32::__WASI_EBADF, + None => return return_enc_errno(host::__WASI_EBADF), }; let host_filestat = match hostcalls_impl::fd_filestat_get(fe) { Ok(fstat) => fstat, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match enc_filestat_byref(memory, filestat_ptr, host_filestat) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + trace!(" | *filestat_ptr={:?}", host_filestat); + + let ret = match enc_filestat_byref(memory, filestat_ptr, host_filestat) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -664,20 +888,30 @@ pub fn fd_filestat_set_times( st_mtim: wasm32::__wasi_timestamp_t, fst_flags: wasm32::__wasi_fstflags_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_filestat_set_times(fd={:?}, st_atim={}, st_mtim={}, fst_flags={:#x?})", + fd, + st_atim, + st_mtim, + fst_flags + ); + let host_fd = dec_fd(fd); let rights = host::__WASI_RIGHT_FD_FILESTAT_SET_TIMES; let fe = match wasi_ctx.get_fd_entry(host_fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let st_atim = dec_timestamp(st_atim); let st_mtim = dec_timestamp(st_mtim); let fst_flags = dec_fstflags(fst_flags); - match hostcalls_impl::fd_filestat_set_times(fe, st_atim, st_mtim, fst_flags) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::fd_filestat_set_times(fe, st_atim, st_mtim, fst_flags) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -686,21 +920,25 @@ pub fn fd_filestat_set_size( fd: wasm32::__wasi_fd_t, st_size: wasm32::__wasi_filesize_t, ) -> wasm32::__wasi_errno_t { + trace!("fd_filestat_set_size(fd={:?}, st_size={})", fd, st_size); + let host_fd = dec_fd(fd); let rights = host::__WASI_RIGHT_FD_FILESTAT_SET_SIZE; let fe = match wasi_ctx.get_fd_entry(host_fd, rights, 0) { Ok(fe) => fe, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let st_size = dec_filesize(st_size); if st_size > i64::max_value() as u64 { - return wasm32::__WASI_E2BIG; + return return_enc_errno(host::__WASI_E2BIG); } - match hostcalls_impl::fd_filestat_set_size(fe, st_size) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::fd_filestat_set_size(fe, st_size) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -713,21 +951,37 @@ pub fn path_filestat_get( path_len: wasm32::size_t, filestat_ptr: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_filestat_get(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={}, filestat_ptr={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + filestat_ptr + ); + let dirfd = dec_fd(dirfd); let dirflags = dec_lookupflags(dirflags); let path = match dec_slice_of::(memory, path_ptr, path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), - }; - let host_filestat = match hostcalls_impl::path_filestat_get(wasi_ctx, dirfd, dirflags, &path) { - Ok(host_filestat) => host_filestat, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match enc_filestat_byref(memory, filestat_ptr, host_filestat) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + trace!(" | (path_ptr,path_len)={:?}", path); + + let host_filestat = match hostcalls_impl::path_filestat_get(wasi_ctx, dirfd, dirflags, &path) { + Ok(host_filestat) => host_filestat, + Err(e) => return return_enc_errno(e), + }; + + trace!(" | *filestat_ptr={:?}", host_filestat); + + let ret = match enc_filestat_byref(memory, filestat_ptr, host_filestat) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -742,23 +996,38 @@ pub fn path_filestat_set_times( st_mtim: wasm32::__wasi_timestamp_t, fst_flags: wasm32::__wasi_fstflags_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_filestat_set_times(dirfd={:?}, dirflags={:?}, path_ptr={:#x?}, path_len={}, st_atim={}, st_mtim={}, fst_flags={:#x?})", + dirfd, + dirflags, + path_ptr, + path_len, + st_atim, st_mtim, + fst_flags + ); + let dirfd = dec_fd(dirfd); let dirflags = dec_lookupflags(dirflags); let path = match dec_slice_of::(memory, path_ptr, path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; + + trace!(" | (path_ptr,path_len)={:?}", path); + let rights = host::__WASI_RIGHT_PATH_FILESTAT_SET_TIMES; let st_atim = dec_timestamp(st_atim); let st_mtim = dec_timestamp(st_mtim); let fst_flags = dec_fstflags(fst_flags); - match hostcalls_impl::path_filestat_set_times( + let ret = match hostcalls_impl::path_filestat_set_times( wasi_ctx, dirfd, dirflags, &path, rights, st_atim, st_mtim, fst_flags, ) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -771,21 +1040,36 @@ pub fn path_symlink( new_path_ptr: wasm32::uintptr_t, new_path_len: wasm32::size_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_symlink(old_path_ptr={:#x?}, old_path_len={}, dirfd={:?}, new_path_ptr={:#x?}, new_path_len={})", + old_path_ptr, + old_path_len, + dirfd, + new_path_ptr, + new_path_len + ); + let dirfd = dec_fd(dirfd); let old_path = match dec_slice_of::(memory, old_path_ptr, old_path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let new_path = match dec_slice_of::(memory, new_path_ptr, new_path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; + + trace!(" | (old_path_ptr,old_path_len)={:?}", old_path); + trace!(" | (new_path_ptr,new_path_len)={:?}", new_path); + let rights = host::__WASI_RIGHT_PATH_SYMLINK; - match hostcalls_impl::path_symlink(wasi_ctx, dirfd, rights, &old_path, &new_path) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::path_symlink(wasi_ctx, dirfd, rights, &old_path, &new_path) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -796,21 +1080,32 @@ pub fn path_unlink_file( path_ptr: wasm32::uintptr_t, path_len: wasm32::size_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_unlink_file(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len + ); + let dirfd = dec_fd(dirfd); let path = match dec_slice_of::(memory, path_ptr, path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match hostcalls_impl::path_unlink_file( + trace!(" | (path_ptr,path_len)={:?}", path); + + let ret = match hostcalls_impl::path_unlink_file( wasi_ctx, dirfd, &path, host::__WASI_RIGHT_PATH_UNLINK_FILE, ) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -821,17 +1116,29 @@ pub fn path_remove_directory( path_ptr: wasm32::uintptr_t, path_len: wasm32::size_t, ) -> wasm32::__wasi_errno_t { + trace!( + "path_remove_directory(dirfd={:?}, path_ptr={:#x?}, path_len={})", + dirfd, + path_ptr, + path_len + ); + let dirfd = dec_fd(dirfd); let path = match dec_slice_of::(memory, path_ptr, path_len) { Ok(slice) => host_impl::path_from_raw(slice), - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; + + trace!(" | (path_ptr,path_len)={:?}", path); + let rights = host::__WASI_RIGHT_PATH_REMOVE_DIRECTORY; - match hostcalls_impl::path_remove_directory(wasi_ctx, dirfd, &path, rights) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + let ret = match hostcalls_impl::path_remove_directory(wasi_ctx, dirfd, &path, rights) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -841,13 +1148,19 @@ pub fn fd_prestat_get( fd: wasm32::__wasi_fd_t, prestat_ptr: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_prestat_get(fd={:?}, prestat_ptr={:#x?})", + fd, + prestat_ptr + ); + let fd = dec_fd(fd); // TODO: is this the correct right for this? - match wasi_ctx.get_fd_entry(fd, host::__WASI_RIGHT_PATH_OPEN.into(), 0) { + let ret = match wasi_ctx.get_fd_entry(fd, host::__WASI_RIGHT_PATH_OPEN.into(), 0) { Ok(fe) => { if let Some(po_path) = &fe.preopen_path { if fe.fd_object.ty != host::__WASI_FILETYPE_DIRECTORY { - return wasm32::__WASI_ENOTDIR; + return return_enc_errno(host::__WASI_ENOTDIR); } enc_prestat_byref( memory, @@ -861,14 +1174,16 @@ pub fn fd_prestat_get( }, }, ) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(|e| e) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity) } else { - wasm32::__WASI_ENOTSUP + host::__WASI_ENOTSUP } } - Err(e) => enc_errno(e), - } + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -879,25 +1194,37 @@ pub fn fd_prestat_dir_name( path_ptr: wasm32::uintptr_t, path_len: wasm32::size_t, ) -> wasm32::__wasi_errno_t { + trace!( + "fd_prestat_dir_name(fd={:?}, path_ptr={:#x?}, path_len={})", + fd, + path_ptr, + path_len + ); + let fd = dec_fd(fd); - match wasi_ctx.get_fd_entry(fd, host::__WASI_RIGHT_PATH_OPEN.into(), 0) { + let ret = match wasi_ctx.get_fd_entry(fd, host::__WASI_RIGHT_PATH_OPEN.into(), 0) { Ok(fe) => { if let Some(po_path) = &fe.preopen_path { if fe.fd_object.ty != host::__WASI_FILETYPE_DIRECTORY { - return wasm32::__WASI_ENOTDIR; + return return_enc_errno(host::__WASI_ENOTDIR); } let path_bytes = host_impl::path_to_raw(po_path); if path_bytes.len() > dec_usize(path_len) { - return wasm32::__WASI_ENAMETOOLONG; + return return_enc_errno(host::__WASI_ENAMETOOLONG); } + + trace!(" | (path_ptr,path_len)={:?}", po_path); + enc_slice_of(memory, &path_bytes, path_ptr) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(|e| e) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity) } else { - wasm32::__WASI_ENOTSUP + host::__WASI_ENOTSUP } } - Err(e) => enc_errno(e), - } + Err(e) => e, + }; + + return_enc_errno(ret) } diff --git a/src/hostcalls/misc.rs b/src/hostcalls/misc.rs index a98c802de2..185ecda1d7 100644 --- a/src/hostcalls/misc.rs +++ b/src/hostcalls/misc.rs @@ -1,9 +1,11 @@ #![allow(non_camel_case_types)] +use super::return_enc_errno; use crate::ctx::WasiCtx; use crate::memory::*; use crate::sys::hostcalls_impl; -use crate::wasm32; -use std::convert::TryFrom; +use crate::{host, wasm32}; +use log::trace; +use std::convert::{identity, TryFrom}; use wasi_common_cbindgen::wasi_common_cbindgen; @@ -14,6 +16,12 @@ pub fn args_get( argv_ptr: wasm32::uintptr_t, argv_buf: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "args_get(argv_ptr={:#x?}, argv_buf={:#x?})", + argv_ptr, + argv_buf, + ); + let mut argv_buf_offset = 0; let mut argv = vec![]; @@ -22,7 +30,7 @@ pub fn args_get( let arg_ptr = argv_buf + argv_buf_offset; if let Err(e) = enc_slice_of(memory, arg_bytes, arg_ptr) { - return enc_errno(e); + return return_enc_errno(e); } argv.push(arg_ptr); @@ -33,13 +41,15 @@ pub fn args_get( ) { new_offset } else { - return wasm32::__WASI_EOVERFLOW; + return return_enc_errno(host::__WASI_EOVERFLOW); } } - enc_slice_of(memory, argv.as_slice(), argv_ptr) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + let ret = enc_slice_of(memory, argv.as_slice(), argv_ptr) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -49,6 +59,12 @@ pub fn args_sizes_get( argc_ptr: wasm32::uintptr_t, argv_buf_size_ptr: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "args_sizes_get(argc_ptr={:#x?}, argv_buf_size_ptr={:#x?})", + argc_ptr, + argv_buf_size_ptr, + ); + let argc = wasi_ctx.args.len(); let argv_size = wasi_ctx .args @@ -56,13 +72,19 @@ pub fn args_sizes_get( .map(|arg| arg.as_bytes_with_nul().len()) .sum(); + trace!(" | *argc_ptr={:?}", argc); + if let Err(e) = enc_usize_byref(memory, argc_ptr, argc) { - return enc_errno(e); + return return_enc_errno(e); } + + trace!(" | *argv_buf_size_ptr={:?}", argv_size); + if let Err(e) = enc_usize_byref(memory, argv_buf_size_ptr, argv_size) { - return enc_errno(e); + return return_enc_errno(e); } - wasm32::__WASI_ESUCCESS + + return_enc_errno(host::__WASI_ESUCCESS) } #[wasi_common_cbindgen] @@ -72,6 +94,12 @@ pub fn environ_get( environ_ptr: wasm32::uintptr_t, environ_buf: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "environ_get(environ_ptr={:#x?}, environ_buf={:#x?})", + environ_ptr, + environ_buf, + ); + let mut environ_buf_offset = 0; let mut environ = vec![]; @@ -80,7 +108,7 @@ pub fn environ_get( let env_ptr = environ_buf + environ_buf_offset; if let Err(e) = enc_slice_of(memory, env_bytes, env_ptr) { - return enc_errno(e); + return return_enc_errno(e); } environ.push(env_ptr); @@ -91,13 +119,15 @@ pub fn environ_get( ) { new_offset } else { - return wasm32::__WASI_EOVERFLOW; + return return_enc_errno(host::__WASI_EOVERFLOW); } } - enc_slice_of(memory, environ.as_slice(), environ_ptr) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + let ret = enc_slice_of(memory, environ.as_slice(), environ_ptr) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -107,24 +137,39 @@ pub fn environ_sizes_get( environ_count_ptr: wasm32::uintptr_t, environ_size_ptr: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "environ_sizes_get(environ_count_ptr={:#x?}, environ_size_ptr={:#x?})", + environ_count_ptr, + environ_size_ptr, + ); + let environ_count = wasi_ctx.env.len(); - if let Some(environ_size) = wasi_ctx.env.iter().try_fold(0, |acc: u32, pair| { + let ret = if let Some(environ_size) = wasi_ctx.env.iter().try_fold(0, |acc: u32, pair| { acc.checked_add(pair.as_bytes_with_nul().len() as u32) }) { + trace!(" | *environ_count_ptr={:?}", environ_count); + if let Err(e) = enc_usize_byref(memory, environ_count_ptr, environ_count) { - return enc_errno(e); + return return_enc_errno(e); } + + trace!(" | *environ_size_ptr={:?}", environ_size); + if let Err(e) = enc_usize_byref(memory, environ_size_ptr, environ_size as usize) { - return enc_errno(e); + return return_enc_errno(e); } - wasm32::__WASI_ESUCCESS + + host::__WASI_ESUCCESS } else { - wasm32::__WASI_EOVERFLOW - } + host::__WASI_EOVERFLOW + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] pub fn proc_exit(rval: wasm32::__wasi_exitcode_t) -> () { + trace!("proc_exit(rval={:?})", rval); // TODO: Rather than call std::process::exit here, we should trigger a // stack unwind similar to a trap. std::process::exit(dec_exitcode(rval) as i32); @@ -145,16 +190,18 @@ pub fn random_get( buf_ptr: wasm32::uintptr_t, buf_len: wasm32::size_t, ) -> wasm32::__wasi_errno_t { + trace!("random_get(buf_ptr={:#x?}, buf_len={:?})", buf_ptr, buf_len); + use rand::{thread_rng, RngCore}; let buf = match dec_slice_of_mut::(memory, buf_ptr, buf_len) { Ok(buf) => buf, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; thread_rng().fill_bytes(buf); - return wasm32::__WASI_ESUCCESS; + return_enc_errno(host::__WASI_ESUCCESS) } #[wasi_common_cbindgen] @@ -163,15 +210,25 @@ pub fn clock_res_get( clock_id: wasm32::__wasi_clockid_t, resolution_ptr: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "clock_res_get(clock_id={:?}, resolution_ptr={:#x?})", + clock_id, + resolution_ptr, + ); + let clock_id = dec_clockid(clock_id); let resolution = match hostcalls_impl::clock_res_get(clock_id) { Ok(resolution) => resolution, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - enc_timestamp_byref(memory, resolution_ptr, resolution) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + trace!(" | *resolution_ptr={:?}", resolution); + + let ret = enc_timestamp_byref(memory, resolution_ptr, resolution) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -180,18 +237,29 @@ pub fn clock_time_get( clock_id: wasm32::__wasi_clockid_t, // ignored for now, but will be useful once we put optional limits on precision to reduce side // channels - _precision: wasm32::__wasi_timestamp_t, + precision: wasm32::__wasi_timestamp_t, time_ptr: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "clock_time_get(clock_id={:?}, precision={:?}, time_ptr={:#x?})", + clock_id, + precision, + time_ptr, + ); + let clock_id = dec_clockid(clock_id); let time = match hostcalls_impl::clock_time_get(clock_id) { Ok(time) => time, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - enc_timestamp_byref(memory, time_ptr, time) - .map(|_| wasm32::__WASI_ESUCCESS) - .unwrap_or_else(enc_errno) + trace!(" | *time_ptr={:?}", time); + + let ret = enc_timestamp_byref(memory, time_ptr, time) + .map(|_| host::__WASI_ESUCCESS) + .unwrap_or_else(identity); + + return_enc_errno(ret) } #[wasi_common_cbindgen] @@ -202,38 +270,54 @@ pub fn poll_oneoff( nsubscriptions: wasm32::size_t, nevents: wasm32::uintptr_t, ) -> wasm32::__wasi_errno_t { + trace!( + "poll_oneoff(input={:#x?}, output={:#x?}, nsubscriptions={}, nevents={:#x?})", + input, + output, + nsubscriptions, + nevents, + ); + if nsubscriptions as u64 > wasm32::__wasi_filesize_t::max_value() { - return wasm32::__WASI_EINVAL; + return return_enc_errno(host::__WASI_EINVAL); } if let Err(e) = enc_pointee(memory, nevents, 0) { - return enc_errno(e); + return return_enc_errno(e); } let input_slice = match dec_slice_of::(memory, input, nsubscriptions) { Ok(input_slice) => input_slice, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let input: Vec<_> = input_slice.iter().map(dec_subscription).collect(); let output_slice = match dec_slice_of_mut::(memory, output, nsubscriptions) { Ok(output_slice) => output_slice, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; let events_count = match hostcalls_impl::poll_oneoff(input, output_slice) { Ok(events_count) => events_count, - Err(e) => return enc_errno(e), + Err(e) => return return_enc_errno(e), }; - match enc_pointee(memory, nevents, events_count) { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + trace!(" | *nevents={:?}", events_count); + + let ret = match enc_pointee(memory, nevents, events_count) { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } #[wasi_common_cbindgen] pub fn sched_yield() -> wasm32::__wasi_errno_t { - match hostcalls_impl::sched_yield() { - Ok(()) => wasm32::__WASI_ESUCCESS, - Err(e) => enc_errno(e), - } + trace!("sched_yield()"); + + let ret = match hostcalls_impl::sched_yield() { + Ok(()) => host::__WASI_ESUCCESS, + Err(e) => e, + }; + + return_enc_errno(ret) } diff --git a/src/hostcalls/mod.rs b/src/hostcalls/mod.rs index 5832ce7dba..925fcc4a2f 100644 --- a/src/hostcalls/mod.rs +++ b/src/hostcalls/mod.rs @@ -5,3 +5,9 @@ mod sock; pub use self::fs::*; pub use self::misc::*; pub use self::sock::*; + +fn return_enc_errno(errno: super::host::__wasi_errno_t) -> super::wasm32::__wasi_errno_t { + let errno = super::memory::enc_errno(errno); + log::trace!(" -> errno={}", super::wasm32::strerror(errno)); + errno +}