add uvwasi implementation to support wasi on windows [experimental] (#534)

add uvwasi implementation to support wasi on windows [experimental] and update windows.yml

Co-authored-by: Wenyong Huang <wenyong.huang@intel.com>

.github/workflows/windows.yml

@@ -21,39 +21,43 @@ jobs:
     steps:
     - uses: actions/checkout@v2
 
+    - name: clone uvwasi library
+      run: |
+        cd core/deps
+        git clone https://github.com/nodejs/uvwasi.git
     - name: Build iwasm [default]
       run: |
         cd product-mini/platforms/windows
         mkdir build && cd build
         cmake ..
         cmake --build . --config Release
-        cd .. && rm -r build
+        cd .. && rm -force -r build
     - name: Build iwasm [aot only]
       run: |
         cd product-mini/platforms/windows
         mkdir build && cd build
         cmake .. -DWAMR_BUILD_AOT=1 -DWAMR_BUILD_INTERP=0
         cmake --build . --config Release
-        cd .. && rm -r build
+        cd .. && rm -force -r build
     - name: Build iwasm [interp only]
       run: |
         cd product-mini/platforms/windows
         mkdir build && cd build
         cmake .. -DWAMR_BUILD_AOT=0
         cmake --build . --config Release
-        cd .. && rm -r build
+        cd .. && rm -force -r build
     - name: Build iwasm [tail call]
       run: |
         cd product-mini/platforms/windows
         mkdir build && cd build
         cmake .. -DWAMR_BUILD_TAIL_CALL=1
         cmake --build . --config Release
-        cd .. && rm -r build
+        cd .. && rm -force -r build
     - name: Build iwasm [custom name section]
       run: |
         cd product-mini/platforms/windows
         mkdir build && cd build
         cmake .. -DWAMR_BUILD_CUSTOM_NAME_SECTION=1
         cmake --build . --config Release
-        cd .. && rm -r build
+        cd .. && rm -force -r build
 

build-scripts/config_common.cmake

@@ -119,7 +119,9 @@ if (WAMR_BUILD_LIBC_BUILTIN EQUAL 1)
 else ()
   message ("     Libc builtin disabled")
 endif ()
-if (WAMR_BUILD_LIBC_WASI EQUAL 1)
+if (WAMR_BUILD_LIBC_UVWASI EQUAL 1)
+  message ("     Libc WASI enabled with uvwasi implementation")
+elseif (WAMR_BUILD_LIBC_WASI EQUAL 1)
   message ("     Libc WASI enabled")
 else ()
   message ("     Libc WASI disabled")

build-scripts/runtime_lib.cmake

@@ -75,7 +75,9 @@ if (WAMR_BUILD_LIBC_BUILTIN EQUAL 1)
     include (${IWASM_DIR}/libraries/libc-builtin/libc_builtin.cmake)
 endif ()
 
-if (WAMR_BUILD_LIBC_WASI EQUAL 1)
+if (WAMR_BUILD_LIBC_UVWASI EQUAL 1)
+    include (${IWASM_DIR}/libraries/libc-uvwasi/libc_uvwasi.cmake)
+elseif (WAMR_BUILD_LIBC_WASI EQUAL 1)
     include (${IWASM_DIR}/libraries/libc-wasi/libc_wasi.cmake)
 endif ()
 

core/config.h

@@ -90,6 +90,10 @@
 #define WASM_ENABLE_LIBC_WASI 0
 #endif
 
+#ifndef WASM_ENABLE_UVWASI
+#define WASM_ENABLE_UVWASI 0
+#endif
+
 /* Default disable libc emcc */
 #ifndef WASM_ENABLE_LIBC_EMCC
 #define WASM_ENABLE_LIBC_EMCC 0

core/iwasm/common/wasm_runtime_common.c

@@ -1656,6 +1656,7 @@ wasm_runtime_set_wasi_args(WASMModuleCommon *module,
     }
 }
 
+#if WASM_ENABLE_UVWASI == 0
 bool
 wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
                        const char *dir_list[], uint32 dir_count,
@@ -1848,6 +1849,128 @@ fail:
         wasm_runtime_free(env_list);
     return false;
 }
+#else /* else of WASM_ENABLE_UVWASI == 0 */
+static void *
+wasm_uvwasi_malloc(size_t size, void *mem_user_data)
+{
+    return runtime_malloc(size, NULL, NULL, 0);
+    (void)mem_user_data;
+}
+
+static void
+wasm_uvwasi_free(void *ptr, void *mem_user_data)
+{
+    if (ptr)
+        wasm_runtime_free(ptr);
+    (void)mem_user_data;
+}
+
+static void *
+wasm_uvwasi_calloc(size_t nmemb, size_t size,
+                   void *mem_user_data)
+{
+    uint64 total_size = (uint64)nmemb * size;
+    return runtime_malloc(total_size, NULL, NULL, 0);
+    (void)mem_user_data;
+}
+
+static void *
+wasm_uvwasi_realloc(void *ptr, size_t size,
+                    void *mem_user_data)
+{
+    if (size >= UINT32_MAX) {
+        return NULL;
+    }
+    return wasm_runtime_realloc(ptr, (uint32)size);
+}
+
+static uvwasi_mem_t uvwasi_allocator = {
+    .mem_user_data = 0,
+    .malloc = wasm_uvwasi_malloc,
+    .free = wasm_uvwasi_free,
+    .calloc = wasm_uvwasi_calloc,
+    .realloc = wasm_uvwasi_realloc
+};
+
+bool
+wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
+                       const char *dir_list[], uint32 dir_count,
+                       const char *map_dir_list[], uint32 map_dir_count,
+                       const char *env[], uint32 env_count,
+                       char *argv[], uint32 argc,
+                       char *error_buf, uint32 error_buf_size)
+{
+    uvwasi_t *uvwasi = NULL;
+    uvwasi_options_t init_options;
+    const char **envp = NULL;
+    uint64 total_size;
+    uint32 i;
+    bool ret = false;
+
+    uvwasi = runtime_malloc(sizeof(uvwasi_t), module_inst,
+                            error_buf, error_buf_size);
+    if (!uvwasi)
+        return false;
+
+    /* Setup the initialization options */
+    uvwasi_options_init(&init_options);
+    init_options.allocator = &uvwasi_allocator;
+    init_options.argc = argc;
+    init_options.argv = (const char **)argv;
+
+    if (dir_count > 0) {
+        init_options.preopenc = dir_count;
+
+        total_size = sizeof(uvwasi_preopen_t) * (uint64)init_options.preopenc;
+        init_options.preopens =
+            (uvwasi_preopen_t *)runtime_malloc(total_size, module_inst,
+                                               error_buf, error_buf_size);
+        if (init_options.preopens == NULL)
+            goto fail;
+
+        for (i = 0; i < init_options.preopenc; i++) {
+            init_options.preopens[i].real_path = dir_list[i];
+            init_options.preopens[i].mapped_path =
+                    (i < map_dir_count) ? map_dir_list[i] : dir_list[i];
+        }
+    }
+
+    if (env_count > 0) {
+        total_size = sizeof(char *) * (uint64)(env_count + 1);
+        envp = runtime_malloc(total_size, module_inst,
+                              error_buf, error_buf_size);
+        if (envp == NULL)
+            goto fail;
+
+        for (i = 0; i < env_count; i++) {
+            envp[i] = env[i];
+        }
+        envp[env_count] = NULL;
+        init_options.envp = envp;
+    }
+
+    if (UVWASI_ESUCCESS != uvwasi_init(uvwasi, &init_options)) {
+        set_error_buf(error_buf, error_buf_size, "uvwasi init failed");
+        goto fail;
+    }
+
+    wasm_runtime_set_wasi_ctx(module_inst, uvwasi);
+
+    ret = true;
+
+fail:
+    if (envp)
+        wasm_runtime_free(envp);
+
+    if (init_options.preopens)
+        wasm_runtime_free(init_options.preopens);
+
+    if (!ret && uvwasi)
+        wasm_runtime_free(uvwasi);
+
+    return ret;
+}
+#endif /* end of WASM_ENABLE_UVWASI */
 
 bool
 wasm_runtime_is_wasi_mode(WASMModuleInstanceCommon *module_inst)
@@ -1915,6 +2038,7 @@ wasm_runtime_lookup_wasi_start_function(WASMModuleInstanceCommon *module_inst)
     return NULL;
 }
 
+#if WASM_ENABLE_UVWASI == 0
 void
 wasm_runtime_destroy_wasi(WASMModuleInstanceCommon *module_inst)
 {
@@ -1944,6 +2068,18 @@ wasm_runtime_destroy_wasi(WASMModuleInstanceCommon *module_inst)
         wasm_runtime_free(wasi_ctx);
     }
 }
+#else
+void
+wasm_runtime_destroy_wasi(WASMModuleInstanceCommon *module_inst)
+{
+    WASIContext *wasi_ctx = wasm_runtime_get_wasi_ctx(module_inst);
+
+    if (wasi_ctx) {
+        uvwasi_destroy(wasi_ctx);
+        wasm_runtime_free(wasi_ctx);
+    }
+}
+#endif
 
 WASIContext *
 wasm_runtime_get_wasi_ctx(WASMModuleInstanceCommon *module_inst)

core/iwasm/common/wasm_runtime_common.h

@@ -13,8 +13,12 @@
 #include "../include/wasm_export.h"
 #include "../interpreter/wasm.h"
 #if WASM_ENABLE_LIBC_WASI != 0
+#if WASM_ENABLE_UVWASI == 0
 #include "wasmtime_ssp.h"
 #include "posix.h"
+#else
+#include "uvwasi.h"
+#endif
 #endif
 
 #ifdef __cplusplus
@@ -73,6 +77,7 @@ typedef struct WASMModuleInstMemConsumption {
 } WASMModuleInstMemConsumption;
 
 #if WASM_ENABLE_LIBC_WASI != 0
+#if WASM_ENABLE_UVWASI == 0
 typedef struct WASIContext {
     struct fd_table *curfds;
     struct fd_prestats *prestats;
@@ -82,6 +87,9 @@ typedef struct WASIContext {
     char *env_buf;
     char **env_list;
 } WASIContext;
+#else
+typedef uvwasi_t WASIContext;
+#endif
 #endif
 
 #if WASM_ENABLE_MULTI_MODULE != 0

core/iwasm/libraries/libc-uvwasi/libc_uvwasi.cmake

@@ -0,0 +1,30 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+set (LIBC_WASI_DIR ${CMAKE_CURRENT_LIST_DIR})
+set (UVWASI_DIR ${CMAKE_CURRENT_LIST_DIR}/../../../deps/uvwasi)
+set (LIBUV_VERSION v1.39.0)
+
+add_definitions (-DWASM_ENABLE_LIBC_WASI=1 -DWASM_ENABLE_UVWASI=1)
+
+include(FetchContent)
+## https://libuv.org
+FetchContent_Declare(
+    libuv
+    GIT_REPOSITORY https://github.com/libuv/libuv.git
+    GIT_TAG ${LIBUV_VERSION})
+
+FetchContent_GetProperties(libuv)
+if(NOT libuv_POPULATED)
+    message ("-- Fetching libuv ..")
+    FetchContent_Populate(libuv)
+    include_directories("${libuv_SOURCE_DIR}/include")
+    add_subdirectory(${libuv_SOURCE_DIR} ${libuv_BINARY_DIR} EXCLUDE_FROM_ALL)
+    set (UV_A_LIBS uv_a)
+endif()
+
+include_directories(${UVWASI_DIR}/include)
+
+file (GLOB_RECURSE source_all ${LIBC_WASI_DIR}/*.c ${UVWASI_DIR}/src/*.c)
+
+set (LIBC_WASI_SOURCE ${source_all})

core/iwasm/libraries/libc-uvwasi/libc_uvwasi_wrapper.c

@@ -0,0 +1,1168 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "uvwasi.h"
+#include "bh_platform.h"
+#include "wasm_export.h"
+
+#define get_module_inst(exec_env) \
+    wasm_runtime_get_module_inst(exec_env)
+
+#define get_wasi_ctx(module_inst) \
+    wasm_runtime_get_wasi_ctx(module_inst)
+
+#define validate_app_addr(offset, size) \
+    wasm_runtime_validate_app_addr(module_inst, offset, size)
+
+#define validate_native_addr(addr, size) \
+    wasm_runtime_validate_native_addr(module_inst, addr, size)
+
+#define addr_app_to_native(offset) \
+    wasm_runtime_addr_app_to_native(module_inst, offset)
+
+#define addr_native_to_app(ptr) \
+    wasm_runtime_addr_native_to_app(module_inst, ptr)
+
+#define module_malloc(size, p_native_addr) \
+    wasm_runtime_module_malloc(module_inst, size, p_native_addr)
+
+#define module_free(offset) \
+    wasm_runtime_module_free(module_inst, offset)
+
+#define wasi_errno_t uvwasi_errno_t
+#define wasi_fd_t uvwasi_fd_t
+#define wasi_clockid_t uvwasi_clockid_t
+#define wasi_timestamp_t uvwasi_timestamp_t
+#define wasi_filesize_t uvwasi_filesize_t
+#define wasi_prestat_app_t uvwasi_prestat_app_t
+#define wasi_filedelta_t uvwasi_filedelta_t
+#define wasi_whence_t uvwasi_whence_t
+#define wasi_fdflags_t uvwasi_fdflags_t
+#define wasi_rights_t uvwasi_rights_t
+#define wasi_advice_t uvwasi_advice_t
+#define wasi_lookupflags_t uvwasi_lookupflags_t
+#define wasi_preopentype_t uvwasi_preopentype_t
+#define wasi_fdstat_t uvwasi_fdstat_t
+#define wasi_oflags_t uvwasi_oflags_t
+#define wasi_dircookie_t uvwasi_dircookie_t
+#define wasi_filestat_t uvwasi_filestat_t
+#define wasi_fstflags_t uvwasi_fstflags_t
+#define wasi_subscription_t uvwasi_subscription_t
+#define wasi_event_t uvwasi_event_t
+#define wasi_exitcode_t uvwasi_exitcode_t
+#define wasi_signal_t uvwasi_signal_t
+#define wasi_riflags_t uvwasi_riflags_t
+#define wasi_roflags_t uvwasi_roflags_t
+#define wasi_siflags_t uvwasi_siflags_t
+#define wasi_sdflags_t uvwasi_sdflags_t
+#define wasi_iovec_t uvwasi_iovec_t
+#define wasi_ciovec_t uvwasi_ciovec_t
+
+typedef struct wasi_prestat_app {
+    wasi_preopentype_t pr_type;
+    uint32 pr_name_len;
+} wasi_prestat_app_t;
+
+typedef struct iovec_app {
+    uint32 buf_offset;
+    uint32 buf_len;
+} iovec_app_t;
+
+void *
+wasm_runtime_get_wasi_ctx(wasm_module_inst_t module_inst);
+
+static wasi_errno_t
+wasi_args_get(wasm_exec_env_t exec_env, uint32 *argv_offsets, char *argv_buf)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    uvwasi_size_t argc, argv_buf_size, i;
+    char **argv;
+    uint64 total_size;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_args_sizes_get(uvwasi, &argc, &argv_buf_size);
+    if (err)
+        return err;
+
+    total_size = sizeof(int32) * ((uint64)argc + 1);
+    if (total_size >= UINT32_MAX
+        || !validate_native_addr(argv_offsets, (uint32)total_size)
+        || argv_buf_size >= UINT32_MAX
+        || !validate_native_addr(argv_buf, (uint32)argv_buf_size))
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(char *) * ((uint64)argc + 1);
+    if (total_size >= UINT32_MAX
+        || !(argv = wasm_runtime_malloc((uint32)total_size)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_args_get(uvwasi, argv, argv_buf);
+    if (err) {
+        wasm_runtime_free(argv);
+        return err;
+    }
+
+    for (i = 0; i < argc; i++)
+        argv_offsets[i] = addr_native_to_app(argv[i]);
+    argv_offsets[argc] = 0;
+
+    wasm_runtime_free(argv);
+    return 0;
+}
+
+static wasi_errno_t
+wasi_args_sizes_get(wasm_exec_env_t exec_env,
+                    uint32 *argc_app, uint32 *argv_buf_size_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    uvwasi_size_t argc, argv_buf_size;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(argc_app, sizeof(uint32))
+        || !validate_native_addr(argv_buf_size_app, sizeof(uint32)))
+        return (wasi_errno_t)-1;
+
+
+    err = uvwasi_args_sizes_get(uvwasi, &argc, &argv_buf_size);
+    if (err)
+        return err;
+
+    *argc_app = (uint32)argc;
+    *argv_buf_size_app = (uint32)argv_buf_size;
+    return 0;
+}
+
+static wasi_errno_t
+wasi_clock_res_get(wasm_exec_env_t exec_env,
+                   wasi_clockid_t clock_id,
+                   wasi_timestamp_t *resolution)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!validate_native_addr(resolution, sizeof(wasi_timestamp_t)))
+        return (wasi_errno_t)-1;
+
+    return uvwasi_clock_res_get(uvwasi, clock_id, resolution);
+}
+
+static wasi_errno_t
+wasi_clock_time_get(wasm_exec_env_t exec_env,
+                    wasi_clockid_t clock_id,
+                    wasi_timestamp_t precision,
+                    wasi_timestamp_t *time)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!validate_native_addr(time, sizeof(wasi_timestamp_t)))
+        return (wasi_errno_t)-1;
+
+    return uvwasi_clock_time_get(uvwasi, clock_id, precision, time);
+}
+
+static wasi_errno_t
+wasi_environ_get(wasm_exec_env_t exec_env,
+                 uint32 *environ_offsets, char *environ_buf)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    uvwasi_size_t environ_count, environ_buf_size, i;
+    uint64 total_size;
+    char **environs;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_environ_sizes_get(uvwasi, &environ_count, &environ_buf_size);
+    if (err)
+        return err;
+
+    total_size = sizeof(int32) * ((uint64)environ_count + 1);
+    if (total_size >= UINT32_MAX
+        || !validate_native_addr(environ_offsets, (uint32)total_size)
+        || environ_buf_size >= UINT32_MAX
+        || !validate_native_addr(environ_buf, (uint32)environ_buf_size))
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(char *) * (((uint64)environ_count + 1));
+
+    if (total_size >= UINT32_MAX
+        || !(environs = wasm_runtime_malloc((uint32)total_size)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_environ_get(uvwasi, environs, environ_buf);
+    if (err) {
+        wasm_runtime_free(environs);
+        return err;
+    }
+
+    for (i = 0; i < environ_count; i++)
+        environ_offsets[i] = addr_native_to_app(environs[i]);
+    environ_offsets[environ_count] = 0;
+
+    wasm_runtime_free(environs);
+    return 0;
+}
+
+static wasi_errno_t
+wasi_environ_sizes_get(wasm_exec_env_t exec_env,
+                       uint32 *environ_count_app, uint32 *environ_buf_size_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    uvwasi_size_t environ_count, environ_buf_size;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(environ_count_app, sizeof(uint32))
+        || !validate_native_addr(environ_buf_size_app, sizeof(uint32)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_environ_sizes_get(uvwasi, &environ_count, &environ_buf_size);
+    if (err)
+        return err;
+
+    *environ_count_app = (uint32)environ_count;
+    *environ_buf_size_app = (uint32)environ_buf_size;
+    return 0;
+}
+
+static wasi_errno_t
+wasi_fd_prestat_get(wasm_exec_env_t exec_env,
+                    wasi_fd_t fd, wasi_prestat_app_t *prestat_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    uvwasi_prestat_t prestat;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(prestat_app, sizeof(wasi_prestat_app_t)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_fd_prestat_get(uvwasi, fd, &prestat);
+    if (err)
+        return err;
+
+    prestat_app->pr_type = prestat.pr_type;
+    prestat_app->pr_name_len = (uint32)prestat.u.dir.pr_name_len;
+    return 0;
+}
+
+static wasi_errno_t
+wasi_fd_prestat_dir_name(wasm_exec_env_t exec_env,
+                         wasi_fd_t fd, char *path, uint32 path_len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_prestat_dir_name(uvwasi, fd, path, path_len);
+}
+
+static wasi_errno_t
+wasi_fd_close(wasm_exec_env_t exec_env, wasi_fd_t fd)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_close(uvwasi, fd);
+}
+
+static wasi_errno_t
+wasi_fd_datasync(wasm_exec_env_t exec_env, wasi_fd_t fd)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_datasync(uvwasi, fd);
+}
+
+static wasi_errno_t
+wasi_fd_pread(wasm_exec_env_t exec_env,
+              wasi_fd_t fd, iovec_app_t *iovec_app, uint32 iovs_len,
+              wasi_filesize_t offset, uint32 *nread_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    wasi_iovec_t *iovec, *iovec_begin;
+    uint64 total_size;
+    uvwasi_size_t nread;
+    uint32 i;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
+    if (!validate_native_addr(nread_app, (uint32)sizeof(uint32))
+        || total_size >= UINT32_MAX
+        || !validate_native_addr(iovec_app, (uint32)total_size))
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len;
+    if (total_size >= UINT32_MAX
+        || !(iovec_begin = wasm_runtime_malloc((uint32)total_size)))
+        return (wasi_errno_t)-1;
+
+    iovec = iovec_begin;
+    for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) {
+        if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) {
+            err = (wasi_errno_t)-1;
+            goto fail;
+        }
+        iovec->buf = (void*)addr_app_to_native(iovec_app->buf_offset);
+        iovec->buf_len = iovec_app->buf_len;
+    }
+
+    err = uvwasi_fd_pread(uvwasi, fd, iovec_begin,
+                          iovs_len, offset, &nread);
+    if (err)
+        goto fail;
+
+    *nread_app = (uint32)nread;
+
+    /* success */
+    err = 0;
+
+fail:
+    wasm_runtime_free(iovec_begin);
+    return err;
+}
+
+static wasi_errno_t
+wasi_fd_pwrite(wasm_exec_env_t exec_env,
+               wasi_fd_t fd, const iovec_app_t *iovec_app, uint32 iovs_len,
+               wasi_filesize_t offset, uint32 *nwritten_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    wasi_ciovec_t *ciovec, *ciovec_begin;
+    uint64 total_size;
+    uvwasi_size_t nwritten;
+    uint32 i;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
+    if (!validate_native_addr(nwritten_app, (uint32)sizeof(uint32))
+        || total_size >= UINT32_MAX
+        || !validate_native_addr((void*)iovec_app, (uint32)total_size))
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len;
+    if (total_size >= UINT32_MAX
+        || !(ciovec_begin = wasm_runtime_malloc((uint32)total_size)))
+        return (wasi_errno_t)-1;
+
+    ciovec = ciovec_begin;
+    for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) {
+        if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) {
+            err = (wasi_errno_t)-1;
+            goto fail;
+        }
+        ciovec->buf = (char*)addr_app_to_native(iovec_app->buf_offset);
+        ciovec->buf_len = iovec_app->buf_len;
+    }
+
+    err = uvwasi_fd_pwrite(uvwasi, fd, ciovec_begin,
+                           iovs_len, offset, &nwritten);
+    if (err)
+        goto fail;
+
+    *nwritten_app = (uint32)nwritten;
+
+    /* success */
+    err = 0;
+
+fail:
+    wasm_runtime_free(ciovec_begin);
+    return err;
+}
+
+static wasi_errno_t
+wasi_fd_read(wasm_exec_env_t exec_env,
+             wasi_fd_t fd, const iovec_app_t *iovec_app, uint32 iovs_len,
+             uint32 *nread_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    wasi_iovec_t *iovec, *iovec_begin;
+    uint64 total_size;
+    uvwasi_size_t nread;
+    uint32 i;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
+    if (!validate_native_addr(nread_app, (uint32)sizeof(uint32))
+        || total_size >= UINT32_MAX
+        || !validate_native_addr((void*)iovec_app, (uint32)total_size))
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(wasi_iovec_t) * (uint64)iovs_len;
+    if (total_size >= UINT32_MAX
+        || !(iovec_begin = wasm_runtime_malloc((uint32)total_size)))
+        return (wasi_errno_t)-1;
+
+    iovec = iovec_begin;
+    for (i = 0; i < iovs_len; i++, iovec_app++, iovec++) {
+        if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) {
+            err = (wasi_errno_t)-1;
+            goto fail;
+        }
+        iovec->buf = (void*)addr_app_to_native(iovec_app->buf_offset);
+        iovec->buf_len = iovec_app->buf_len;
+    }
+
+    err = uvwasi_fd_read(uvwasi, fd,
+                               iovec_begin, iovs_len, &nread);
+    if (err)
+        goto fail;
+
+    *nread_app = (uint32)nread;
+
+    /* success */
+    err = 0;
+
+fail:
+    wasm_runtime_free(iovec_begin);
+    return err;
+}
+
+static wasi_errno_t
+wasi_fd_renumber(wasm_exec_env_t exec_env, wasi_fd_t from, wasi_fd_t to)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_renumber(uvwasi, from, to);
+}
+
+static wasi_errno_t
+wasi_fd_seek(wasm_exec_env_t exec_env,
+             wasi_fd_t fd, wasi_filedelta_t offset, wasi_whence_t whence,
+             wasi_filesize_t *newoffset)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(newoffset, sizeof(wasi_filesize_t)))
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_seek(uvwasi, fd, offset, whence, newoffset);
+}
+
+static wasi_errno_t
+wasi_fd_tell(wasm_exec_env_t exec_env,
+             wasi_fd_t fd, wasi_filesize_t *newoffset)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(newoffset, sizeof(wasi_filesize_t)))
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_tell(uvwasi, fd, newoffset);
+}
+
+static wasi_errno_t
+wasi_fd_fdstat_get(wasm_exec_env_t exec_env,
+                   wasi_fd_t fd, wasi_fdstat_t *fdstat_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    wasi_fdstat_t fdstat;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(fdstat_app, sizeof(wasi_fdstat_t)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_fd_fdstat_get(uvwasi, fd, &fdstat);
+    if (err)
+        return err;
+
+    memcpy(fdstat_app, &fdstat, sizeof(wasi_fdstat_t));
+    return 0;
+}
+
+static wasi_errno_t
+wasi_fd_fdstat_set_flags(wasm_exec_env_t exec_env,
+                         wasi_fd_t fd, wasi_fdflags_t flags)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_fdstat_set_flags(uvwasi, fd, flags);
+}
+
+static wasi_errno_t
+wasi_fd_fdstat_set_rights(wasm_exec_env_t exec_env,
+                          wasi_fd_t fd,
+                          wasi_rights_t fs_rights_base,
+                          wasi_rights_t fs_rights_inheriting)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_fdstat_set_rights(uvwasi, fd,
+                                       fs_rights_base, fs_rights_inheriting);
+}
+
+static wasi_errno_t
+wasi_fd_sync(wasm_exec_env_t exec_env, wasi_fd_t fd)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_sync(uvwasi, fd);
+}
+
+static wasi_errno_t
+wasi_fd_write(wasm_exec_env_t exec_env, wasi_fd_t fd,
+              const iovec_app_t *iovec_app, uint32 iovs_len,
+              uint32 *nwritten_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    wasi_ciovec_t *ciovec, *ciovec_begin;
+    uint64 total_size;
+    uvwasi_size_t nwritten;
+    uint32 i;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(iovec_app_t) * (uint64)iovs_len;
+    if (!validate_native_addr(nwritten_app, (uint32)sizeof(uint32))
+        || total_size >= UINT32_MAX
+        || !validate_native_addr((void*)iovec_app, (uint32)total_size))
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(wasi_ciovec_t) * (uint64)iovs_len;
+    if (total_size >= UINT32_MAX
+        || !(ciovec_begin = wasm_runtime_malloc((uint32)total_size)))
+        return (wasi_errno_t)-1;
+
+    ciovec = ciovec_begin;
+    for (i = 0; i < iovs_len; i++, iovec_app++, ciovec++) {
+        if (!validate_app_addr(iovec_app->buf_offset, iovec_app->buf_len)) {
+            err = (wasi_errno_t)-1;
+            goto fail;
+        }
+        ciovec->buf = (char*)addr_app_to_native(iovec_app->buf_offset);
+        ciovec->buf_len = iovec_app->buf_len;
+    }
+
+    err = uvwasi_fd_write(uvwasi, fd,
+                          ciovec_begin, iovs_len, &nwritten);
+    if (err)
+        goto fail;
+
+    *nwritten_app = (uint32)nwritten;
+
+    /* success */
+    err = 0;
+
+fail:
+    wasm_runtime_free(ciovec_begin);
+    return err;
+}
+
+static wasi_errno_t
+wasi_fd_advise(wasm_exec_env_t exec_env,
+               wasi_fd_t fd,
+               wasi_filesize_t offset,
+               wasi_filesize_t len,
+               wasi_advice_t advice)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_advise(uvwasi, fd, offset, len, advice);
+}
+
+static wasi_errno_t
+wasi_fd_allocate(wasm_exec_env_t exec_env,
+                 wasi_fd_t fd,
+                 wasi_filesize_t offset,
+                 wasi_filesize_t len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_allocate(uvwasi, fd, offset, len);
+}
+
+static wasi_errno_t
+wasi_path_create_directory(wasm_exec_env_t exec_env,
+                           wasi_fd_t fd, const char *path, uint32 path_len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_path_create_directory(uvwasi, fd, path, path_len);
+}
+
+static wasi_errno_t
+wasi_path_link(wasm_exec_env_t exec_env,
+               wasi_fd_t old_fd,
+               wasi_lookupflags_t old_flags,
+               const char *old_path, uint32 old_path_len,
+               wasi_fd_t new_fd,
+               const char *new_path, uint32 new_path_len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_path_link(uvwasi,
+                            old_fd, old_flags, old_path, old_path_len,
+                            new_fd, new_path, new_path_len);
+}
+
+static wasi_errno_t
+wasi_path_open(wasm_exec_env_t exec_env,
+               wasi_fd_t dirfd,
+               wasi_lookupflags_t dirflags,
+               const char *path, uint32 path_len,
+               wasi_oflags_t oflags,
+               wasi_rights_t fs_rights_base,
+               wasi_rights_t fs_rights_inheriting,
+               wasi_fdflags_t fs_flags,
+               wasi_fd_t *fd_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    wasi_fd_t fd = (wasi_fd_t)-1; /* set fd_app -1 if path open failed */
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(fd_app, sizeof(wasi_fd_t)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_path_open(uvwasi,
+                           dirfd, dirflags,
+                           path, path_len,
+                           oflags,
+                           fs_rights_base,
+                           fs_rights_inheriting,
+                           fs_flags,
+                           &fd);
+
+    *fd_app = fd;
+    return err;
+}
+
+static wasi_errno_t
+wasi_fd_readdir(wasm_exec_env_t exec_env,
+                wasi_fd_t fd,
+                void *buf, uint32 buf_len,
+                wasi_dircookie_t cookie,
+                uint32 *bufused_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    uvwasi_size_t bufused;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(bufused_app, sizeof(uint32)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_fd_readdir(uvwasi, fd,
+                            buf, buf_len, cookie, &bufused);
+    if (err)
+        return err;
+
+    *bufused_app = (uint32)bufused;
+    return 0;
+}
+
+static wasi_errno_t
+wasi_path_readlink(wasm_exec_env_t exec_env,
+                   wasi_fd_t fd,
+                   const char *path, uint32 path_len,
+                   char *buf, uint32 buf_len,
+                   uint32 *bufused_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    uvwasi_size_t bufused;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(bufused_app, sizeof(uint32)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_path_readlink(uvwasi, fd,
+                               path, path_len,
+                               buf, buf_len, &bufused);
+    if (err)
+        return err;
+
+    *bufused_app = (uint32)bufused;
+    return 0;
+}
+
+static wasi_errno_t
+wasi_path_rename(wasm_exec_env_t exec_env,
+                 wasi_fd_t old_fd, const char *old_path, uint32 old_path_len,
+                 wasi_fd_t new_fd, const char *new_path, uint32 new_path_len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_path_rename(uvwasi,
+                              old_fd, old_path, old_path_len,
+                              new_fd, new_path, new_path_len);
+}
+
+static wasi_errno_t
+wasi_fd_filestat_get(wasm_exec_env_t exec_env,
+                     wasi_fd_t fd, wasi_filestat_t *filestat)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(filestat, sizeof(wasi_filestat_t)))
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_filestat_get(uvwasi, fd, filestat);
+}
+
+static wasi_errno_t
+wasi_fd_filestat_set_times(wasm_exec_env_t exec_env,
+                           wasi_fd_t fd,
+                           wasi_timestamp_t st_atim,
+                           wasi_timestamp_t st_mtim,
+                           wasi_fstflags_t fstflags)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_filestat_set_times(uvwasi, fd,
+                                        st_atim, st_mtim, fstflags);
+}
+
+static wasi_errno_t
+wasi_fd_filestat_set_size(wasm_exec_env_t exec_env,
+                          wasi_fd_t fd,
+                          wasi_filesize_t st_size)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_fd_filestat_set_size(uvwasi, fd, st_size);
+}
+
+static wasi_errno_t
+wasi_path_filestat_get(wasm_exec_env_t exec_env,
+                       wasi_fd_t fd,
+                       wasi_lookupflags_t flags,
+                       const char *path, uint32 path_len,
+                       wasi_filestat_t *filestat)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr(filestat, sizeof(wasi_filestat_t)))
+        return (wasi_errno_t)-1;
+
+    return uvwasi_path_filestat_get(uvwasi, fd,
+                                    flags, path, path_len, filestat);
+}
+
+static wasi_errno_t
+wasi_path_filestat_set_times(wasm_exec_env_t exec_env,
+                             wasi_fd_t fd,
+                             wasi_lookupflags_t flags,
+                             const char *path, uint32 path_len,
+                             wasi_timestamp_t st_atim,
+                             wasi_timestamp_t st_mtim,
+                             wasi_fstflags_t fstflags)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_path_filestat_set_times(uvwasi, fd,
+                                          flags, path, path_len,
+                                          st_atim, st_mtim, fstflags);
+}
+
+static wasi_errno_t
+wasi_path_symlink(wasm_exec_env_t exec_env,
+                  const char *old_path, uint32 old_path_len,
+                  wasi_fd_t fd, const char *new_path, uint32 new_path_len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_path_symlink(uvwasi,
+                               old_path, old_path_len, fd,
+                               new_path, new_path_len);
+}
+
+static wasi_errno_t
+wasi_path_unlink_file(wasm_exec_env_t exec_env,
+                      wasi_fd_t fd, const char *path, uint32 path_len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_path_unlink_file(uvwasi, fd, path, path_len);
+}
+
+static wasi_errno_t
+wasi_path_remove_directory(wasm_exec_env_t exec_env,
+                           wasi_fd_t fd, const char *path, uint32 path_len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_path_remove_directory(uvwasi, fd, path, path_len);
+}
+
+static wasi_errno_t
+wasi_poll_oneoff(wasm_exec_env_t exec_env,
+                 const wasi_subscription_t *in, wasi_event_t *out,
+                 uint32 nsubscriptions, uint32 *nevents_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    uvwasi_size_t nevents;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    if (!validate_native_addr((void*)in, sizeof(wasi_subscription_t))
+        || !validate_native_addr(out, sizeof(wasi_event_t))
+        || !validate_native_addr(nevents_app, sizeof(uint32)))
+        return (wasi_errno_t)-1;
+
+    err = uvwasi_poll_oneoff(uvwasi, in, out,
+                             nsubscriptions, &nevents);
+    if (err)
+        return err;
+
+    *nevents_app = (uint32)nevents;
+    return 0;
+}
+
+static void
+wasi_proc_exit(wasm_exec_env_t exec_env, wasi_exitcode_t rval)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    /* Here throwing exception is just to let wasm app exit,
+       the upper layer should clear the exception and return
+       as normal */
+    wasm_runtime_set_exception(module_inst, "wasi proc exit");
+}
+
+static wasi_errno_t
+wasi_proc_raise(wasm_exec_env_t exec_env, wasi_signal_t sig)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    char buf[32];
+
+    snprintf(buf, sizeof(buf), "%s%d", "wasi proc raise ", sig);
+    wasm_runtime_set_exception(module_inst, buf);
+    return 0;
+}
+
+static wasi_errno_t
+wasi_random_get(wasm_exec_env_t exec_env, void *buf, uint32 buf_len)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    return uvwasi_random_get(uvwasi, buf, buf_len);
+}
+
+static wasi_errno_t
+wasi_sock_recv(wasm_exec_env_t exec_env,
+               wasi_fd_t sock,
+               iovec_app_t *ri_data, uint32 ri_data_len,
+               wasi_riflags_t ri_flags,
+               uint32 *ro_datalen_app,
+               wasi_roflags_t *ro_flags)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    wasi_iovec_t *iovec, *iovec_begin;
+    uint64 total_size;
+    uvwasi_size_t ro_datalen;
+    uint32 i;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(iovec_app_t) * (uint64)ri_data_len;
+    if (!validate_native_addr(ro_datalen_app, (uint32)sizeof(uint32))
+        || !validate_native_addr(ro_flags, (uint32)sizeof(wasi_roflags_t))
+        || total_size >= UINT32_MAX
+        || !validate_native_addr(ri_data, (uint32)total_size))
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(wasi_iovec_t) * (uint64)ri_data_len;
+    if (total_size >= UINT32_MAX
+        || !(iovec_begin = wasm_runtime_malloc((uint32)total_size)))
+        return (wasi_errno_t)-1;
+
+    iovec = iovec_begin;
+    for (i = 0; i < ri_data_len; i++, ri_data++, iovec++) {
+        if (!validate_app_addr(ri_data->buf_offset, ri_data->buf_len)) {
+            err = (wasi_errno_t)-1;
+            goto fail;
+        }
+        iovec->buf = (void*)addr_app_to_native(ri_data->buf_offset);
+        iovec->buf_len = ri_data->buf_len;
+    }
+
+    err = uvwasi_sock_recv(uvwasi, sock,
+                           iovec_begin, ri_data_len,
+                           ri_flags, &ro_datalen,
+                           ro_flags);
+    if (err)
+        goto fail;
+
+    *(uint32*)ro_datalen_app = (uint32)ro_datalen;
+
+    /* success */
+    err = 0;
+
+fail:
+    wasm_runtime_free(iovec_begin);
+    return err;
+}
+
+static wasi_errno_t
+wasi_sock_send(wasm_exec_env_t exec_env,
+               wasi_fd_t sock,
+               const iovec_app_t *si_data, uint32 si_data_len,
+               wasi_siflags_t si_flags,
+               uint32 *so_datalen_app)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+    wasi_ciovec_t *ciovec, *ciovec_begin;
+    uint64 total_size;
+    uvwasi_size_t so_datalen;
+    uint32 i;
+    wasi_errno_t err;
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(iovec_app_t) * (uint64)si_data_len;
+    if (!validate_native_addr(so_datalen_app, sizeof(uint32))
+        || total_size >= UINT32_MAX
+        || !validate_native_addr((void*)si_data, (uint32)total_size))
+        return (wasi_errno_t)-1;
+
+    total_size = sizeof(wasi_ciovec_t) * (uint64)si_data_len;
+    if (total_size >= UINT32_MAX
+        || !(ciovec_begin = wasm_runtime_malloc((uint32)total_size)))
+        return (wasi_errno_t)-1;
+
+    ciovec = ciovec_begin;
+    for (i = 0; i < si_data_len; i++, si_data++, ciovec++) {
+        if (!validate_app_addr(si_data->buf_offset, si_data->buf_len)) {
+            err = (wasi_errno_t)-1;
+            goto fail;
+        }
+        ciovec->buf = (char*)addr_app_to_native(si_data->buf_offset);
+        ciovec->buf_len = si_data->buf_len;
+    }
+
+    err = uvwasi_sock_send(uvwasi, sock,
+                           ciovec_begin, si_data_len,
+                           si_flags, &so_datalen);
+    if (err)
+        goto fail;
+
+    *so_datalen_app = (uint32)so_datalen;
+
+    /* success */
+    err = 0;
+
+fail:
+    wasm_runtime_free(ciovec_begin);
+    return err;
+}
+
+static wasi_errno_t
+wasi_sock_shutdown(wasm_exec_env_t exec_env,
+                   wasi_fd_t sock, wasi_sdflags_t how)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    if (!uvwasi)
+        return (wasi_errno_t)-1;
+
+    return uvwasi_sock_shutdown(uvwasi, sock, how);
+}
+
+static wasi_errno_t
+wasi_sched_yield(wasm_exec_env_t exec_env)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    uvwasi_t *uvwasi = get_wasi_ctx(module_inst);
+
+    return uvwasi_sched_yield(uvwasi);
+}
+
+#define REG_NATIVE_FUNC(func_name, signature)     \
+    { #func_name, wasi_##func_name, signature, NULL }
+
+static NativeSymbol native_symbols_libc_wasi[] = {
+    REG_NATIVE_FUNC(args_get, "(**)i"),
+    REG_NATIVE_FUNC(args_sizes_get, "(**)i"),
+    REG_NATIVE_FUNC(clock_res_get, "(i*)i"),
+    REG_NATIVE_FUNC(clock_time_get, "(iI*)i"),
+    REG_NATIVE_FUNC(environ_get, "(**)i"),
+    REG_NATIVE_FUNC(environ_sizes_get, "(**)i"),
+    REG_NATIVE_FUNC(fd_prestat_get, "(i*)i"),
+    REG_NATIVE_FUNC(fd_prestat_dir_name, "(i*~)i"),
+    REG_NATIVE_FUNC(fd_close, "(i)i"),
+    REG_NATIVE_FUNC(fd_datasync, "(i)i"),
+    REG_NATIVE_FUNC(fd_pread, "(i*iI*)i"),
+    REG_NATIVE_FUNC(fd_pwrite, "(i*iI*)i"),
+    REG_NATIVE_FUNC(fd_read, "(i*i*)i"),
+    REG_NATIVE_FUNC(fd_renumber, "(ii)i"),
+    REG_NATIVE_FUNC(fd_seek, "(iIi*)i"),
+    REG_NATIVE_FUNC(fd_tell, "(i*)i"),
+    REG_NATIVE_FUNC(fd_fdstat_get, "(i*)i"),
+    REG_NATIVE_FUNC(fd_fdstat_set_flags, "(ii)i"),
+    REG_NATIVE_FUNC(fd_fdstat_set_rights, "(iII)i"),
+    REG_NATIVE_FUNC(fd_sync, "(i)i"),
+    REG_NATIVE_FUNC(fd_write, "(i*i*)i"),
+    REG_NATIVE_FUNC(fd_advise, "(iIIi)i"),
+    REG_NATIVE_FUNC(fd_allocate, "(iII)i"),
+    REG_NATIVE_FUNC(path_create_directory, "(i*~)i"),
+    REG_NATIVE_FUNC(path_link, "(ii*~i*~)i"),
+    REG_NATIVE_FUNC(path_open, "(ii*~iIIi*)i"),
+    REG_NATIVE_FUNC(fd_readdir, "(i*~I*)i"),
+    REG_NATIVE_FUNC(path_readlink, "(i*~*~*)i"),
+    REG_NATIVE_FUNC(path_rename, "(i*~i*~)i"),
+    REG_NATIVE_FUNC(fd_filestat_get, "(i*)i"),
+    REG_NATIVE_FUNC(fd_filestat_set_times, "(iIIi)i"),
+    REG_NATIVE_FUNC(fd_filestat_set_size, "(iI)i"),
+    REG_NATIVE_FUNC(path_filestat_get, "(ii*~*)i"),
+    REG_NATIVE_FUNC(path_filestat_set_times, "(ii*~IIi)i"),
+    REG_NATIVE_FUNC(path_symlink, "(*~i*~)i"),
+    REG_NATIVE_FUNC(path_unlink_file, "(i*~)i"),
+    REG_NATIVE_FUNC(path_remove_directory, "(i*~)i"),
+    REG_NATIVE_FUNC(poll_oneoff, "(**i*)i"),
+    REG_NATIVE_FUNC(proc_exit, "(i)"),
+    REG_NATIVE_FUNC(proc_raise, "(i)i"),
+    REG_NATIVE_FUNC(random_get, "(*~)i"),
+    REG_NATIVE_FUNC(sock_recv, "(i*ii**)i"),
+    REG_NATIVE_FUNC(sock_send, "(i*ii*)i"),
+    REG_NATIVE_FUNC(sock_shutdown, "(ii)i"),
+    REG_NATIVE_FUNC(sched_yield, "()i"),
+};
+
+uint32
+get_libc_wasi_export_apis(NativeSymbol **p_libc_wasi_apis)
+{
+    *p_libc_wasi_apis = native_symbols_libc_wasi;
+    return sizeof(native_symbols_libc_wasi) / sizeof(NativeSymbol);
+}
+

core/shared/mem-alloc/ems/ems_alloc.c

@@ -472,6 +472,11 @@ gc_alloc_vo_internal(void *vheap, gc_size_t size,
     if (!hmu)
         goto finish;
 
+    bh_assert(hmu_get_size(hmu) >= tot_size);
+    /* the total size allocated may be larger than
+       the required size, reset it here */
+    tot_size = hmu_get_size(hmu);
+
     g_total_malloc += tot_size;
 
     hmu_set_ut(hmu, HMU_VO);
@@ -570,6 +575,9 @@ gc_realloc_vo_internal(void *vheap, void *ptr, gc_size_t size,
     if (!hmu)
         goto finish;
 
+    bh_assert(hmu_get_size(hmu) >= tot_size);
+    /* the total size allocated may be larger than
+       the required size, reset it here */
     g_total_malloc += tot_size;
 
     hmu_set_ut(hmu, HMU_VO);

core/shared/mem-alloc/ems/ems_gc_internal.h

@@ -29,7 +29,13 @@ typedef struct hmu_struct {
 
 #if BH_ENABLE_GC_VERIFY != 0
 
+#if UINTPTR_MAX > UINT32_MAX
+/* 2 prefix paddings for 64-bit pointer */
+#define GC_OBJECT_PREFIX_PADDING_CNT 2
+#else
+/* 3 prefix paddings for 32-bit pointer */
 #define GC_OBJECT_PREFIX_PADDING_CNT 3
+#endif
 #define GC_OBJECT_SUFFIX_PADDING_CNT 4
 #define GC_OBJECT_PADDING_VALUE (0x12345678)
 

doc/build_wamr.md

@@ -43,13 +43,22 @@ cmake -DWAMR_BUILD_PLATFORM=linux -DWAMR_BUILD_TARGET=ARM
 
 #### **Configure LIBC**
 
-- **WAMR_BUILD_LIBC_BUILTIN**=1/0,  default to enable if not set
+- **WAMR_BUILD_LIBC_BUILTIN**=1/0, build the built-in libc subset for WASM app, default to enable if not set
 
-- **WAMR_BUILD_LIBC_WASI**=1/0, default to enable if not set
+- **WAMR_BUILD_LIBC_WASI**=1/0, build the [WASI](https://github.com/WebAssembly/WASI) libc subset for WASM app, default to enable if not set
+
+- **WAMR_BUILD_LIBC_UVWASI**=1/0 (Experiment), build the [WASI](https://github.com/WebAssembly/WASI) libc subset for WASM app based on [uvwasi](https://github.com/nodejs/uvwasi) implementation, default to disable if not set
+
+> Note: for platform which doesn't support **WAMR_BUILD_LIBC_WASI**, e.g. Windows, developer can try using **WAMR_BUILD_LIBC_UVWASI**. And the uvwasi source code must be cloned under core/deps:
+>
+> ```bash
+> cd <WAMR-ROOT>/core/deps
+> git clone https://github.com/nodejs/uvwasi.git
+> ```
 
 #### **Configure Debug**
 
-- **WAMR_BUILD_CUSTOM_NAME_SECTION**=1/0,  load the function name from custom name section, default to disable if not set
+- **WAMR_BUILD_CUSTOM_NAME_SECTION**=1/0, load the function name from custom name section, default to disable if not set
 
 #### **Enable dump call stack feature**
 - **WAMR_BUILD_DUMP_CALL_STACK**=1/0, default to disable if not set

product-mini/platforms/linux/CMakeLists.txt

@@ -119,7 +119,7 @@ add_executable (iwasm main.c ${UNCOMMON_SHARED_SOURCE})
 
 install (TARGETS iwasm DESTINATION bin)
 
-target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS} -lm -ldl -lpthread)
+target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl -lpthread)
 
 add_library (libiwasm SHARED ${WAMR_RUNTIME_LIB_SOURCE})
 

product-mini/platforms/windows/CMakeLists.txt

@@ -51,9 +51,9 @@ if (NOT DEFINED WAMR_BUILD_LIBC_BUILTIN)
   set (WAMR_BUILD_LIBC_BUILTIN 1)
 endif ()
 
-if (NOT DEFINED WAMR_BUILD_LIBC_WASI)
-  # Enable libc wasi support by default
-  set (WAMR_BUILD_LIBC_WASI 0)
+if (NOT DEFINED WAMR_BUILD_LIBC_UVWASI)
+  # Enable libc uvwasi support by default
+  set (WAMR_BUILD_LIBC_UVWASI 1)
 endif ()
 
 if (NOT DEFINED WAMR_BUILD_FAST_INTERP)
@@ -86,6 +86,7 @@ include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
 add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})
 
 set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
+set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
 
 # set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wformat -Wformat-security")
 # set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wconversion -Wsign-conversion")
@@ -110,7 +111,7 @@ add_executable (iwasm main.c ${UNCOMMON_SHARED_SOURCE})
 
 install (TARGETS iwasm DESTINATION bin)
 
-target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS})
+target_link_libraries (iwasm vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS})
 
 add_library (libiwasm SHARED ${WAMR_RUNTIME_LIB_SOURCE})
 
@@ -118,6 +119,6 @@ install (TARGETS libiwasm DESTINATION lib)
 
 set_target_properties (libiwasm PROPERTIES OUTPUT_NAME iwasm)
 
-target_link_libraries (libiwasm ${LLVM_AVAILABLE_LIBS})
+target_link_libraries (libiwasm ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS})
 
 target_compile_definitions(libiwasm PRIVATE COMPILING_WASM_RUNTIME_API=1)