Merge dev/zephyr_file_socket into main (#4347)

zephyr: Enable WASI support for file system and sockets on zephyr (#3633)

This work also implements the WASI support on Zephyr.

* Added os_is_* methods for stdin/stdout/stderr.  Fixed issues in os_renameat
* Zephyr platform fixes for WASI sockets Addressed numerous of build warnings on Zephyr
* Updated `os_writev` to use `fwrite` for STDOUT/STDERR
* Temporarily reverted change to `writev` to work around an issue.
* Fixes: fstat, fstatat, and unlink
* Add initial support for directories in os_openat. Partial implementation — just avoids a hard fault.
* Directory support WIP. readdir works but I think we have a memory leak somewhere
* Fix: always use standard stream fds. Fix unlinkat and renameat. fd 0, 1, and 2 will always be supplied for standard streams. Unlinkat and renameat work exclusively based on supplied paths.
* Fix: use macro for free()
* Added a temporary workaround for issue identified in PR#4377
* Fixed reference to file descriptor and cleaned up dead/commented code.

Note that some comments haven't been addressed and will be fixed in the
further patches.

Signed-off-by: Stephen Berard <stephen.berard@outlook.com>
Co-authored-by: Lucas Abad <149054121+lucasAbadFr@users.noreply.github.com>
Co-authored-by: Stephen Berard <srberard@users.noreply.github.com>
Co-authored-by: Dan Kouba <dan@atym.io>

core/iwasm/common/wasm_application.c

@@ -712,7 +712,10 @@ execute_func(WASMModuleInstanceCommon *module_inst, const char *name,
             }
             case VALUE_TYPE_F32:
             {
-                os_printf("%.7g:f32", *(float32 *)(argv1 + k));
+                // Explicit cast to double to avoid warning.
+                // Float arguments are promoted to double in variadic
+                // functions per section 6.5.2.2 of the C99 standard.
+                os_printf("%.7g:f32", (double)*(float32 *)(argv1 + k));
                 k++;
                 break;
             }

core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c

@@ -1016,12 +1016,10 @@ update_clock_subscription_data(wasi_subscription_t *in, uint32 nsubscriptions,
 }
 
 static wasi_errno_t
-execute_interruptible_poll_oneoff(
+execute_interruptible_poll_oneoff(struct fd_table *curfds,
-#if !defined(WASMTIME_SSP_STATIC_CURFDS)
+                                  const __wasi_subscription_t *in,
-    struct fd_table *curfds,
+                                  __wasi_event_t *out, size_t nsubscriptions,
-#endif
+                                  size_t *nevents, wasm_exec_env_t exec_env)
-    const __wasi_subscription_t *in, __wasi_event_t *out, size_t nsubscriptions,
-    size_t *nevents, wasm_exec_env_t exec_env)
 {
     if (nsubscriptions == 0) {
         *nevents = 0;
@@ -2118,15 +2116,16 @@ wasi_sock_recv(wasm_exec_env_t exec_env, wasi_fd_t sock, iovec_app_t *ri_data,
                wasi_roflags_t *ro_flags)
 {
     wasm_module_inst_t module_inst = get_module_inst(exec_env);
-    __wasi_addr_t src_addr;
     wasi_errno_t error;
 
     if (!validate_native_addr(ro_flags, (uint64)sizeof(wasi_roflags_t)))
         return __WASI_EINVAL;
 
+    // We call `recvfrom` with NULL source address as `recv` doesn't
+    // return the source address and this parameter is not used.
+    *ro_data_len = 0;
     error = wasi_sock_recv_from(exec_env, sock, ri_data, ri_data_len, ri_flags,
-                                &src_addr, ro_data_len);
+                                NULL, ro_data_len);
-    *ro_flags = ri_flags;
 
     return error;
 }

core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/blocking_op.c

@@ -175,14 +175,14 @@ blocking_op_openat(wasm_exec_env_t exec_env, os_file_handle handle,
 #ifndef BH_PLATFORM_WINDOWS
 /* REVISIT: apply the os_file_handle style abstraction for pollfd? */
 __wasi_errno_t
-blocking_op_poll(wasm_exec_env_t exec_env, struct pollfd *pfds, nfds_t nfds,
+blocking_op_poll(wasm_exec_env_t exec_env, os_poll_file_handle *pfds,
-                 int timeout_ms, int *retp)
+                 os_nfds_t nfds, int timeout_ms, int *retp)
 {
     int ret;
     if (!wasm_runtime_begin_blocking_op(exec_env)) {
         return __WASI_EINTR;
     }
-    ret = poll(pfds, nfds, timeout_ms);
+    ret = os_poll(pfds, nfds, timeout_ms);
     wasm_runtime_end_blocking_op(exec_env);
     if (ret == -1) {
         return convert_errno(errno);

core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/blocking_op.h

@@ -57,8 +57,8 @@ blocking_op_openat(wasm_exec_env_t exec_env, os_file_handle handle,
 
 #ifndef BH_PLATFORM_WINDOWS
 __wasi_errno_t
-blocking_op_poll(wasm_exec_env_t exec_env, struct pollfd *pfds, nfds_t nfds,
+blocking_op_poll(wasm_exec_env_t exec_env, os_poll_file_handle *pfds,
-                 int timeout, int *retp);
+                 os_nfds_t nfds, int timeout, int *retp);
 #endif
 
 #endif /* end of _BLOCKING_OP_H_ */

core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/locking.h

@@ -196,8 +196,12 @@ static inline bool
 cond_timedwait(struct cond *cond, struct mutex *lock, uint64_t timeout,
                bool abstime) REQUIRES_EXCLUSIVE(*lock) NO_LOCK_ANALYSIS
 {
+#if defined(BH_PLATFORM_ZEPHYR)
+    // TODO: Implement this for Zephyr
+    return false;
+#else
     int ret;
-    struct timespec ts = {
+    os_timespec ts = {
         .tv_sec = (time_t)(timeout / 1000000000),
         .tv_nsec = (long)(timeout % 1000000000),
     };
@@ -210,8 +214,8 @@ cond_timedwait(struct cond *cond, struct mutex *lock, uint64_t timeout,
          * realtime clock.
          */
         if (cond->clock != CLOCK_REALTIME) {
-            struct timespec ts_monotonic;
+            os_timespec ts_monotonic;
-            struct timespec ts_realtime;
+            os_timespec ts_realtime;
 
             clock_gettime(cond->clock, &ts_monotonic);
             ts.tv_sec -= ts_monotonic.tv_sec;
@@ -229,7 +233,7 @@ cond_timedwait(struct cond *cond, struct mutex *lock, uint64_t timeout,
                 ++ts.tv_sec;
             }
         }
-#endif
+#endif /* !CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK */
     }
     else {
 #if CONFIG_HAS_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
@@ -241,7 +245,7 @@ cond_timedwait(struct cond *cond, struct mutex *lock, uint64_t timeout,
         return ret == ETIMEDOUT;
 #else
         /* Convert to absolute timeout. */
-        struct timespec ts_now;
+        os_timespec ts_now;
 #if CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK
         clock_gettime(cond->clock, &ts_now);
 #else
@@ -253,13 +257,14 @@ cond_timedwait(struct cond *cond, struct mutex *lock, uint64_t timeout,
             ts.tv_nsec -= 1000000000;
             ++ts.tv_sec;
         }
-#endif
+#endif /* CONFIG_HAS_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP */
     }
 
     ret = pthread_cond_timedwait(&cond->object, &lock->object, &ts);
     bh_assert((ret == 0 || ret == ETIMEDOUT)
               && "pthread_cond_timedwait() failed");
     return ret == ETIMEDOUT;
+#endif /* BH_PLATFORM_ZEPHYR */
 }
 #endif
 

core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/posix.c

@@ -356,16 +356,20 @@ fd_table_get_entry(struct fd_table *ft, __wasi_fd_t fd,
     REQUIRES_SHARED(ft->lock)
 {
     // Test for file descriptor existence.
-    if (fd >= ft->size)
+    if (fd >= ft->size) {
         return __WASI_EBADF;
+    }
+
     struct fd_entry *fe = &ft->entries[fd];
-    if (fe->object == NULL)
+    if (fe->object == NULL) {
         return __WASI_EBADF;
+    }
 
     // Validate rights.
     if ((~fe->rights_base & rights_base) != 0
-        || (~fe->rights_inheriting & rights_inheriting) != 0)
+        || (~fe->rights_inheriting & rights_inheriting) != 0) {
         return __WASI_ENOTCAPABLE;
+    }
     *ret = fe;
     return 0;
 }
@@ -426,15 +430,15 @@ fd_table_attach(struct fd_table *ft, __wasi_fd_t fd, struct fd_object *fo,
                 __wasi_rights_t rights_base, __wasi_rights_t rights_inheriting)
     REQUIRES_EXCLUSIVE(ft->lock) CONSUMES(fo->refcount)
 {
-    assert(ft->size > fd && "File descriptor table too small");
+    bh_assert(ft->size > fd && "File descriptor table too small");
     struct fd_entry *fe = &ft->entries[fd];
-    assert(fe->object == NULL
+    bh_assert(fe->object == NULL
-           && "Attempted to overwrite an existing descriptor");
+              && "Attempted to overwrite an existing descriptor");
     fe->object = fo;
     fe->rights_base = rights_base;
     fe->rights_inheriting = rights_inheriting;
     ++ft->used;
-    assert(ft->size >= ft->used * 2 && "File descriptor too full");
+    bh_assert(ft->size >= ft->used * 2 && "File descriptor too full");
 }
 
 // Detaches a file descriptor from the file descriptor table.
@@ -442,12 +446,12 @@ static void
 fd_table_detach(struct fd_table *ft, __wasi_fd_t fd, struct fd_object **fo)
     REQUIRES_EXCLUSIVE(ft->lock) PRODUCES((*fo)->refcount)
 {
-    assert(ft->size > fd && "File descriptor table too small");
+    bh_assert(ft->size > fd && "File descriptor table too small");
     struct fd_entry *fe = &ft->entries[fd];
     *fo = fe->object;
-    assert(*fo != NULL && "Attempted to detach nonexistent descriptor");
+    bh_assert(*fo != NULL && "Attempted to detach nonexistent descriptor");
     fe->object = NULL;
-    assert(ft->used > 0 && "Reference count mismatch");
+    bh_assert(ft->used > 0 && "Reference count mismatch");
     --ft->used;
 }
 
@@ -636,7 +640,7 @@ fd_table_insert_existing(struct fd_table *ft, __wasi_fd_t in,
 static __wasi_errno_t
 fd_table_unused(struct fd_table *ft, __wasi_fd_t *out) REQUIRES_SHARED(ft->lock)
 {
-    assert(ft->size > ft->used && "File descriptor table has no free slots");
+    bh_assert(ft->size > ft->used && "File descriptor table has no free slots");
     for (;;) {
         uintmax_t random_fd = 0;
         __wasi_errno_t error = random_uniform(ft->size, &random_fd);
@@ -1550,7 +1554,8 @@ path_put(struct path_access *pa) UNLOCKS(pa->fd_object->refcount)
 {
     if (pa->path_start)
         wasm_runtime_free(pa->path_start);
-    if (pa->fd_object->file_handle != pa->fd)
+    /* Can't use `!=` operator when `os_file_handle` is a struct */
+    if (!os_compare_file_handle(pa->fd_object->file_handle, pa->fd))
         os_close(pa->fd, false);
     fd_object_release(NULL, pa->fd_object);
 }
@@ -1891,7 +1896,7 @@ wasmtime_ssp_fd_filestat_get(wasm_exec_env_t exec_env, struct fd_table *curfds,
 }
 
 static void
-convert_timestamp(__wasi_timestamp_t in, struct timespec *out)
+convert_timestamp(__wasi_timestamp_t in, os_timespec *out)
 {
     // Store sub-second remainder.
 #if defined(__SYSCALL_SLONG_TYPE)
@@ -1899,10 +1904,10 @@ convert_timestamp(__wasi_timestamp_t in, struct timespec *out)
 #else
     out->tv_nsec = (long)(in % 1000000000);
 #endif
-    in /= 1000000000;
+    __wasi_timestamp_t temp = in / 1000000000;
 
     // Clamp to the maximum in case it would overflow our system's time_t.
-    out->tv_sec = (time_t)in < BH_TIME_T_MAX ? (time_t)in : BH_TIME_T_MAX;
+    out->tv_sec = (time_t)temp < BH_TIME_T_MAX ? (time_t)temp : BH_TIME_T_MAX;
 }
 
 __wasi_errno_t
@@ -2089,7 +2094,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
                          size_t nsubscriptions,
                          size_t *nevents) NO_LOCK_ANALYSIS
 {
-#ifdef BH_PLATFORM_WINDOWS
+#if defined(BH_PLATFORM_WINDOWS)
     return __WASI_ENOSYS;
 #else
     // Sleeping.
@@ -2101,7 +2106,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
 #if CONFIG_HAS_CLOCK_NANOSLEEP
         clockid_t clock_id;
         if (wasi_clockid_to_clockid(in[0].u.u.clock.clock_id, &clock_id)) {
-            struct timespec ts;
+            os_timespec ts;
             convert_timestamp(in[0].u.u.clock.timeout, &ts);
             int ret = clock_nanosleep(
                 clock_id,
@@ -2128,7 +2133,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
                 else {
                     // Perform relative sleeps on the monotonic clock also using
                     // nanosleep(). This is incorrect, but good enough for now.
-                    struct timespec ts;
+                    os_timespec ts;
                     convert_timestamp(in[0].u.u.clock.timeout, &ts);
                     nanosleep(&ts, NULL);
                 }
@@ -2156,7 +2161,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
                 }
                 else {
                     // Relative sleeps can be done using nanosleep().
-                    struct timespec ts;
+                    os_timespec ts;
                     convert_timestamp(in[0].u.u.clock.timeout, &ts);
                     nanosleep(&ts, NULL);
                 }
@@ -2181,7 +2186,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
         wasm_runtime_malloc((uint32)(nsubscriptions * sizeof(*fos)));
     if (fos == NULL)
         return __WASI_ENOMEM;
-    struct pollfd *pfds =
+    os_poll_file_handle *pfds =
         wasm_runtime_malloc((uint32)(nsubscriptions * sizeof(*pfds)));
     if (pfds == NULL) {
         wasm_runtime_free(fos);
@@ -2205,9 +2210,16 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
                     fd_object_get_locked(&fos[i], ft, s->u.u.fd_readwrite.fd,
                                          __WASI_RIGHT_POLL_FD_READWRITE, 0);
                 if (error == 0) {
+
+// Temporary workaround (see PR#4377)
+#ifdef BH_PLATFORM_ZEPHYR
+                    os_file_handle tfd = fos[i]->file_handle->fd;
+#else
+                    os_file_handle tfd = fos[i]->file_handle;
+#endif
                     // Proper file descriptor on which we can poll().
-                    pfds[i] = (struct pollfd){
+                    pfds[i] = (os_poll_file_handle){
-                        .fd = fos[i]->file_handle,
+                        .fd = tfd,
                         .events = s->u.type == __WASI_EVENTTYPE_FD_READ
                                       ? POLLIN
                                       : POLLOUT,
@@ -2216,7 +2228,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
                 else {
                     // Invalid file descriptor or rights missing.
                     fos[i] = NULL;
-                    pfds[i] = (struct pollfd){ .fd = -1 };
+                    pfds[i] = (os_poll_file_handle){ .fd = -1 };
                     out[(*nevents)++] = (__wasi_event_t){
                         .userdata = s->userdata,
                         .error = error,
@@ -2231,7 +2243,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
                            == 0) {
                     // Relative timeout.
                     fos[i] = NULL;
-                    pfds[i] = (struct pollfd){ .fd = -1 };
+                    pfds[i] = (os_poll_file_handle){ .fd = -1 };
                     clock_subscription = s;
                     break;
                 }
@@ -2239,7 +2251,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
             default:
                 // Unsupported event.
                 fos[i] = NULL;
-                pfds[i] = (struct pollfd){ .fd = -1 };
+                pfds[i] = (os_poll_file_handle){ .fd = -1 };
                 out[(*nevents)++] = (__wasi_event_t){
                     .userdata = s->userdata,
                     .error = __WASI_ENOSYS,
@@ -2283,7 +2295,7 @@ wasmtime_ssp_poll_oneoff(wasm_exec_env_t exec_env, struct fd_table *curfds,
                 __wasi_filesize_t nbytes = 0;
                 if (in[i].u.type == __WASI_EVENTTYPE_FD_READ) {
                     int l;
-                    if (ioctl(fos[i]->file_handle, FIONREAD, &l) == 0)
+                    if (os_ioctl(fos[i]->file_handle, FIONREAD, &l) == 0)
                         nbytes = (__wasi_filesize_t)l;
                 }
                 if ((pfds[i].revents & POLLNVAL) != 0) {
@@ -2449,7 +2461,7 @@ wasi_addr_to_string(const __wasi_addr_t *addr, char *buf, size_t buflen)
     if (addr->kind == IPv4) {
         const char *format = "%u.%u.%u.%u";
 
-        assert(buflen >= 16);
+        bh_assert(buflen >= 16);
 
         snprintf(buf, buflen, format, addr->addr.ip4.addr.n0,
                  addr->addr.ip4.addr.n1, addr->addr.ip4.addr.n2,
@@ -2461,14 +2473,13 @@ wasi_addr_to_string(const __wasi_addr_t *addr, char *buf, size_t buflen)
         const char *format = "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x";
         __wasi_addr_ip6_t ipv6 = addr->addr.ip6.addr;
 
-        assert(buflen >= 40);
+        bh_assert(buflen >= 40);
 
         snprintf(buf, buflen, format, ipv6.n0, ipv6.n1, ipv6.n2, ipv6.n3,
                  ipv6.h0, ipv6.h1, ipv6.h2, ipv6.h3);
 
         return true;
     }
-
     return false;
 }
 
@@ -2575,9 +2586,11 @@ wasi_ssp_sock_connect(wasm_exec_env_t exec_env, struct fd_table *curfds,
     }
 
     error = fd_object_get(curfds, &fo, fd, __WASI_RIGHT_SOCK_BIND, 0);
-    if (error != __WASI_ESUCCESS)
+    if (error != __WASI_ESUCCESS) {
         return error;
+    }
 
+    /* Consume __wasi_addr_t */
     ret = blocking_op_socket_connect(exec_env, fo->file_handle, buf,
                                      addr->kind == IPv4 ? addr->addr.ip4.port
                                                         : addr->addr.ip6.port);
@@ -2726,10 +2739,10 @@ wasi_ssp_sock_open(wasm_exec_env_t exec_env, struct fd_table *curfds,
     }
 
     if (SOCKET_DGRAM == socktype) {
-        assert(wasi_type == __WASI_FILETYPE_SOCKET_DGRAM);
+        bh_assert(wasi_type == __WASI_FILETYPE_SOCKET_DGRAM);
     }
     else {
-        assert(wasi_type == __WASI_FILETYPE_SOCKET_STREAM);
+        bh_assert(wasi_type == __WASI_FILETYPE_SOCKET_STREAM);
     }
 
     // TODO: base rights and inheriting rights ?
@@ -2839,7 +2852,7 @@ wasmtime_ssp_sock_recv_from(wasm_exec_env_t exec_env, struct fd_table *curfds,
 {
     struct fd_object *fo;
     __wasi_errno_t error;
-    bh_sockaddr_t sockaddr;
+    bh_sockaddr_t sockaddr, *sockaddr_ptr = NULL;
     int ret;
 
     error = fd_object_get(curfds, &fo, sock, __WASI_RIGHT_FD_READ, 0);
@@ -2847,14 +2860,26 @@ wasmtime_ssp_sock_recv_from(wasm_exec_env_t exec_env, struct fd_table *curfds,
         return error;
     }
 
+    // If the source address is not NULL, the caller is requesting the source
+    // address to be returned if the protocol supports it.  If the value is
+    // NULL, the POSIX standard states that the address is not returned.
+    if (src_addr != NULL) {
+        sockaddr_ptr = &sockaddr;
+    }
+
+    /* Consume bh_sockaddr_t instead of __wasi_addr_t */
     ret = blocking_op_socket_recv_from(exec_env, fo->file_handle, buf, buf_len,
-                                       0, &sockaddr);
+                                       0, sockaddr_ptr);
     fd_object_release(exec_env, fo);
     if (-1 == ret) {
         return convert_errno(errno);
     }
 
-    bh_sockaddr_to_wasi_addr(&sockaddr, src_addr);
+    // If the source address is not NULL, we need to convert the sockaddr
+    // back to __wasi_addr_t format.
+    if (src_addr != NULL) {
+        bh_sockaddr_to_wasi_addr(sockaddr_ptr, src_addr);
+    }
 
     *recv_len = (size_t)ret;
     return __WASI_ESUCCESS;
@@ -2912,6 +2937,7 @@ wasmtime_ssp_sock_send_to(wasm_exec_env_t exec_env, struct fd_table *curfds,
 
     wasi_addr_to_bh_sockaddr(dest_addr, &sockaddr);
 
+    /* Consume bh_sockaddr instead of __wasi_addr_t */
     ret = blocking_op_socket_send_to(exec_env, fo->file_handle, buf, buf_len, 0,
                                      &sockaddr);
     fd_object_release(exec_env, fo);
@@ -2943,8 +2969,10 @@ wasmtime_ssp_sock_shutdown(wasm_exec_env_t exec_env, struct fd_table *curfds,
 __wasi_errno_t
 wasmtime_ssp_sched_yield(void)
 {
-#ifdef BH_PLATFORM_WINDOWS
+#if defined(BH_PLATFORM_WINDOWS)
     SwitchToThread();
+#elif defined(BH_PLATFORM_ZEPHYR)
+    k_yield();
 #else
     if (sched_yield() < 0)
         return convert_errno(errno);

core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/random.c

@@ -66,6 +66,20 @@ random_buf(void *buf, size_t len)
     return ret ? __WASI_EINVAL : __WASI_ESUCCESS;
 }
 
+#elif defined(BH_PLATFORM_ZEPHYR)
+#include <zephyr/random/random.h>
+// Maybe having an OS abstraction api would be a good idea
+// because every platform is implementing this function.
+// we could have a function like `os_random_buf`
+// and call `os_random_buf.` in the SSP wrapper `random_buf`.
+
+__wasi_errno_t
+random_buf(void *buf, size_t len)
+{
+    sys_rand_get(buf, len);
+    return __WASI_ESUCCESS;
+}
+
 #else
 
 static int urandom = -1;

core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/ssp_config.h

@@ -42,7 +42,8 @@
 #define CONFIG_HAS_GETRANDOM 0
 #endif
 
-#if defined(__CloudABI__) || defined(BH_PLATFORM_FREERTOS)
+#if defined(__CloudABI__) || defined(BH_PLATFORM_FREERTOS) \
+    || defined(BH_PLATFORM_ZEPHYR)
 #define CONFIG_HAS_CAP_ENTER 1
 #else
 #define CONFIG_HAS_CAP_ENTER 0
@@ -50,7 +51,7 @@
 
 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__EMSCRIPTEN__) \
     && !defined(ESP_PLATFORM) && !defined(DISABLE_CLOCK_NANOSLEEP)           \
-    && !defined(BH_PLATFORM_FREERTOS)
+    && !defined(BH_PLATFORM_FREERTOS) && !defined(BH_PLATFORM_ZEPHYR)
 #define CONFIG_HAS_CLOCK_NANOSLEEP 1
 #else
 #define CONFIG_HAS_CLOCK_NANOSLEEP 0
@@ -63,7 +64,8 @@
 #endif
 
 #if !defined(__APPLE__) && !defined(BH_PLATFORM_LINUX_SGX) && !defined(_WIN32) \
-    && !defined(__COSMOPOLITAN__) && !defined(BH_PLATFORM_FREERTOS)
+    && !defined(__COSMOPOLITAN__) && !defined(BH_PLATFORM_FREERTOS)            \
+    && !defined(BH_PLATFORM_ZEPHYR)
 #define CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK 1
 #else
 #define CONFIG_HAS_PTHREAD_CONDATTR_SETCLOCK 0

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

@@ -6,7 +6,9 @@
 #include "ems_gc.h"
 #include "ems_gc_internal.h"
 
+#ifndef GB // Some platforms define already, causing build warnings.
 #define GB (1 << 30UL)
+#endif
 
 #define MARK_NODE_OBJ_CNT 256
 

core/shared/platform/alios/platform_internal.h

@@ -75,6 +75,9 @@ int isnan(double x);
 typedef int os_file_handle;
 typedef void *os_dir_stream;
 typedef int os_raw_file_handle;
+typedef int os_poll_file_handle;
+typedef unsigned int os_nfds_t;
+typedef int os_timespec;
 
 static inline os_file_handle
 os_get_invalid_handle(void)

core/shared/platform/android/platform_internal.h

@@ -150,6 +150,12 @@ typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
 
+/* The below types are used in platform_api_extension.h,
+   we just define them to make the compiler happy */
+typedef struct pollfd os_poll_file_handle;
+typedef nfds_t os_nfds_t;
+typedef struct timespec os_timespec;
+
 static inline os_file_handle
 os_get_invalid_handle(void)
 {

core/shared/platform/common/posix/posix_file.c

@@ -1039,3 +1039,31 @@ os_invalid_raw_handle(void)
 {
     return -1;
 }
+
+// Better to define the function here, as Linux-SGX will
+// use this file to implement the `_os` functions.
+// So we don't need to define them in the Linux-SGX platform.
+int
+os_ioctl(os_file_handle handle, int request, ...)
+{
+    int ret = -1;
+    va_list args;
+
+    va_start(args, request);
+    ret = ioctl(handle, request, args);
+    va_end(args);
+
+    return ret;
+}
+
+int
+os_poll(os_poll_file_handle *fds, os_nfds_t nfs, int timeout)
+{
+    return poll(fds, nfs, timeout);
+}
+
+bool
+os_compare_file_handle(os_file_handle handle1, os_file_handle handle2)
+{
+    return handle1 == handle2;
+}

core/shared/platform/common/posix/posix_socket.c

@@ -1035,4 +1035,4 @@ os_socket_addr_remote(bh_socket_t socket, bh_sockaddr_t *sockaddr)
     }
 
     return sockaddr_to_bh_sockaddr((struct sockaddr *)&addr_storage, sockaddr);
-}
+}

core/shared/platform/cosmopolitan/platform_internal.h

@@ -67,6 +67,9 @@ typedef sem_t korp_sem;
 typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
+typedef struct pollfd os_poll_file_handle;
+typedef nfds_t os_nfds_t;
+typedef struct timespec os_timespec;
 
 static inline os_file_handle
 os_get_invalid_handle(void)

core/shared/platform/darwin/platform_internal.h

@@ -112,6 +112,9 @@ os_set_signal_number_for_blocking_op(int signo);
 typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
+typedef struct pollfd os_poll_file_handle;
+typedef nfds_t os_nfds_t;
+typedef struct timespec os_timespec;
 
 static inline os_file_handle
 os_get_invalid_handle(void)

core/shared/platform/esp-idf/espidf_file.c

@@ -1039,3 +1039,15 @@ os_invalid_raw_handle(void)
 {
     return -1;
 }
+
+int
+os_ioctl(os_file_handle handle, int request, ...)
+{
+    return BHT_ERROR;
+}
+
+int
+os_poll(os_poll_file_handle *fds, os_nfds_t nfs, int timeout)
+{
+    return BHT_ERROR;
+}

core/shared/platform/esp-idf/platform_internal.h

@@ -144,6 +144,12 @@ typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
 
+/* The below types are used in platform_api_extension.h,
+   we just define them to make the compiler happy */
+typedef int os_poll_file_handle;
+typedef unsigned int os_nfds_t;
+typedef int os_timespec;
+
 static inline os_file_handle
 os_get_invalid_handle(void)
 {

core/shared/platform/freebsd/platform_internal.h

@@ -69,6 +69,9 @@ typedef sem_t korp_sem;
 typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
+typedef struct pollfd os_poll_file_handle;
+typedef nfds_t os_nfds_t;
+typedef struct timespec os_timespec;
 
 #if WASM_DISABLE_HW_BOUND_CHECK == 0
 #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)            \

core/shared/platform/include/platform_api_extension.h

@@ -1673,4 +1673,24 @@ os_clock_time_get(__wasi_clockid_t clock_id, __wasi_timestamp_t precision,
 }
 #endif
 
+/* Experimental */
+
+/* Used in posix.c around L2259 and expect the return code
+ * of ioctl() directly.
+ */
+int
+os_ioctl(os_file_handle handle, int request, ...);
+
+/* Higher level API:
+ * __wasi_errno_t
+ * blocking_op_poll(wasm_exec_env_t exec_env, os_poll_file_handle *pfds,
+ *             os_nfds_t nfds, int timeout_ms, int *retp)
+ * Already format the errno and expect the return code of poll() directly.
+ */
+int
+os_poll(os_poll_file_handle *pfds, os_nfds_t nfs, int timeout);
+
+bool
+os_compare_file_handle(os_file_handle handle1, os_file_handle handle2);
+
 #endif /* #ifndef PLATFORM_API_EXTENSION_H */

core/shared/platform/include/platform_wasi_types.h

@@ -173,7 +173,7 @@ typedef uint8_t __wasi_eventtype_t;
 
 typedef uint32_t __wasi_exitcode_t;
 
-typedef uint32_t __wasi_fd_t;
+typedef int32_t __wasi_fd_t;
 
 typedef uint16_t __wasi_fdflags_t;
 #define __WASI_FDFLAG_APPEND   (0x0001)
@@ -539,7 +539,10 @@ typedef enum {
 
 typedef uint16_t __wasi_ip_port_t;
 
-typedef enum { IPv4 = 0, IPv6 } __wasi_addr_type_t;
+/* Ensure that __wasi_addr_type_t has a size of 4 byte (I32).
+   However, it will not have the type safety of enum. */
+typedef uint32_t __wasi_addr_type_t;
+enum { IPv4 = 0, IPv6 };
 
 /* n0.n1.n2.n3 */
 typedef struct __wasi_addr_ip4_t {

core/shared/platform/linux-sgx/platform_internal.h

@@ -73,6 +73,16 @@ typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
 
+struct _pollfd {
+    int fd;
+    short events;
+    short revents;
+};
+
+typedef struct _pollfd os_poll_file_handle;
+typedef unsigned long os_nfds_t;
+typedef struct timespec os_timespec;
+
 static inline os_file_handle
 os_get_invalid_handle(void)
 {

core/shared/platform/linux/platform_internal.h

@@ -126,6 +126,10 @@ typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
 
+typedef struct pollfd os_poll_file_handle;
+typedef nfds_t os_nfds_t;
+typedef struct timespec os_timespec;
+
 static inline os_file_handle
 os_get_invalid_handle(void)
 {

core/shared/platform/nuttx/platform_internal.h

@@ -132,9 +132,14 @@ fdopendir(int fd);
 void
 os_set_signal_number_for_blocking_op(int signo);
 
+/* The below types are used in platform_api_extension.h,
+   we just define them to make the compiler happy */
 typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
+typedef struct pollfd os_poll_file_handle;
+typedef nfds_t os_nfds_t;
+typedef struct timespec os_timespec;
 
 static inline os_file_handle
 os_get_invalid_handle(void)

core/shared/platform/riot/platform_internal.h

@@ -63,6 +63,9 @@ typedef struct korp_cond {
 typedef int os_file_handle;
 typedef void *os_dir_stream;
 typedef int os_raw_file_handle;
+typedef int os_poll_file_handle;
+typedef unsigned int os_nfds_t;
+typedef int os_timespec;
 
 #if WA_MATH
 /* clang-format off */

core/shared/platform/rt-thread/platform_internal.h

@@ -122,6 +122,9 @@ typedef rt_int64_t int64_t;
 typedef int os_file_handle;
 typedef void *os_dir_stream;
 typedef int os_raw_file_handle;
+typedef int os_poll_file_handle;
+typedef unsigned int os_nfds_t;
+typedef int os_timespec;
 
 static inline os_file_handle
 os_get_invalid_handle(void)

core/shared/platform/vxworks/platform_internal.h

@@ -65,6 +65,12 @@ typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
 
+/* The below types are used in platform_api_extension.h,
+   we just define them to make the compiler happy */
+typedef struct pollfd os_poll_file_handle;
+typedef nfds_t os_nfds_t;
+typedef timespec os_timespec;
+
 #if WASM_DISABLE_HW_BOUND_CHECK == 0
 #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \
     || defined(BUILD_TARGET_AARCH64)

core/shared/platform/windows/platform_internal.h

@@ -186,6 +186,12 @@ typedef uint32_t os_raw_file_handle;
 
 #define bh_socket_t windows_handle *
 
+/* The below types are used in platform_api_extension.h,
+   we just define them to make the compiler happy */
+typedef int os_poll_file_handle;
+typedef unsigned int os_nfds_t;
+typedef struct timespec os_timespec;
+
 // UWP apps do not have stdout/stderr handles so provide a default
 // implementation of vprintf on debug builds so output from WASI libc is sent to
 // the debugger and not lost completely.

core/shared/platform/windows/win_file.c

@@ -1816,3 +1816,39 @@ os_invalid_raw_handle(void)
 {
     return INVALID_HANDLE_VALUE;
 }
+
+bool
+os_compare_file_handle(os_file_handle handle1, os_file_handle handle2)
+{
+    if (handle1->type != handle2->type) {
+        return false;
+    }
+
+    if (handle1->fdflags != handle2->fdflags
+        || handle1->access_mode != handle2->access_mode) {
+        return false;
+    }
+
+    switch (handle1->type) {
+        case windows_handle_type_file:
+            return handle1->raw.handle == handle2->raw.handle;
+        case windows_handle_type_socket:
+            return handle1->raw.socket == handle2->raw.socket;
+        default:
+            // Unknown handle type
+            return false;
+    }
+}
+
+int
+os_ioctl(os_file_handle handle, int request, ...)
+{
+    return BHT_ERROR;
+}
+
+// Should not be called because locked by ifdef.
+int
+os_poll(os_poll_file_handle *fds, os_nfds_t nfs, int timeout)
+{
+    return BHT_ERROR;
+}

core/shared/platform/zephyr/platform_internal.h

@@ -50,6 +50,7 @@
 #include <zephyr/net/net_ip.h>
 #include <zephyr/net/net_core.h>
 #include <zephyr/net/net_context.h>
+#include <zephyr/net/socket.h>
 #endif /* end of KERNEL_VERSION_NUMBER < 0x030200 */
 
 #ifdef CONFIG_USERSPACE
@@ -79,29 +80,51 @@
 #define BH_PLATFORM_ZEPHYR
 #endif
 
-// Synchronization primitives for usermode
+#include <limits.h>
+
+#ifndef PATH_MAX
+#define PATH_MAX 256
+#endif
+
+#ifndef STDIN_FILENO
+#define STDIN_FILENO 0
+#endif
+
+#ifndef STDOUT_FILENO
+#define STDOUT_FILENO 1
+#endif
+
+#ifndef STDERR_FILENO
+#define STDERR_FILENO 2
+#endif
+
+/* Synchronization primitives for usermode.
+ * The macros are prefixed with 'z' because when building
+ * with WAMR_BUILD_LIBC_WASI the same functions are defined,
+ * and used in the sandboxed-system-primitives (see locking.h)
+ */
 #ifdef CONFIG_USERSPACE
-#define mutex_t struct sys_mutex
+#define zmutex_t struct sys_mutex
-#define mutex_init(mtx) sys_mutex_init(mtx)
+#define zmutex_init(mtx) sys_mutex_init(mtx)
-#define mutex_lock(mtx, timeout) sys_mutex_lock(mtx, timeout)
+#define zmutex_lock(mtx, timeout) sys_mutex_lock(mtx, timeout)
-#define mutex_unlock(mtx) sys_mutex_unlock(mtx)
+#define zmutex_unlock(mtx) sys_mutex_unlock(mtx)
 
-#define sem_t struct sys_sem
+#define zsem_t struct sys_sem
-#define sem_init(sem, init_count, limit) sys_sem_init(sem, init_count, limit)
+#define zsem_init(sem, init_count, limit) sys_sem_init(sem, init_count, limit)
-#define sem_give(sem) sys_sem_give(sem)
+#define zsem_give(sem) sys_sem_give(sem)
-#define sem_take(sem, timeout) sys_sem_take(sem, timeout)
+#define zsem_take(sem, timeout) sys_sem_take(sem, timeout)
-#define sem_count_get(sem) sys_sem_count_get(sem)
+#define zsem_count_get(sem) sys_sem_count_get(sem)
 #else /* else of CONFIG_USERSPACE */
-#define mutex_t struct k_mutex
+#define zmutex_t struct k_mutex
-#define mutex_init(mtx) k_mutex_init(mtx)
+#define zmutex_init(mtx) k_mutex_init(mtx)
-#define mutex_lock(mtx, timeout) k_mutex_lock(mtx, timeout)
+#define zmutex_lock(mtx, timeout) k_mutex_lock(mtx, timeout)
-#define mutex_unlock(mtx) k_mutex_unlock(mtx)
+#define zmutex_unlock(mtx) k_mutex_unlock(mtx)
 
-#define sem_t struct k_sem
+#define zsem_t struct k_sem
-#define sem_init(sem, init_count, limit) k_sem_init(sem, init_count, limit)
+#define zsem_init(sem, init_count, limit) k_sem_init(sem, init_count, limit)
-#define sem_give(sem) k_sem_give(sem)
+#define zsem_give(sem) k_sem_give(sem)
-#define sem_take(sem, timeout) k_sem_take(sem, timeout)
+#define zsem_take(sem, timeout) k_sem_take(sem, timeout)
-#define sem_count_get(sem) k_sem_count_get(sem)
+#define zsem_count_get(sem) k_sem_count_get(sem)
 #endif /* end of CONFIG_USERSPACE */
 
 #define BH_APPLET_PRESERVED_STACK_SIZE (2 * BH_KB)
@@ -111,22 +134,32 @@
 
 typedef struct k_thread korp_thread;
 typedef korp_thread *korp_tid;
-typedef mutex_t korp_mutex;
+typedef zmutex_t korp_mutex;
 typedef unsigned int korp_sem;
 
 /* korp_rwlock is used in platform_api_extension.h,
    we just define the type to make the compiler happy */
-typedef struct {
-    int dummy;
-} korp_rwlock;
-
 struct os_thread_wait_node;
 typedef struct os_thread_wait_node *os_thread_wait_list;
 typedef struct korp_cond {
-    mutex_t wait_list_lock;
+    zmutex_t wait_list_lock;
     os_thread_wait_list thread_wait_list;
 } korp_cond;
 
+typedef struct {
+    struct k_mutex mtx; // Mutex for exclusive access
+    struct k_sem sem;   // Semaphore for shared access
+    int read_count;     // Number of readers
+} korp_rwlock;
+
+// TODO: Conform to Zephyr POSIX definition of rwlock:
+// struct posix_rwlock {
+// 	struct k_sem rd_sem;
+// 	struct k_sem wr_sem;
+// 	struct k_sem reader_active; /* blocks WR till reader has acquired lock */
+// 	k_tid_t wr_owner;
+// };
+
 #ifndef Z_TIMEOUT_MS
 #define Z_TIMEOUT_MS(ms) ms
 #endif
@@ -204,14 +237,68 @@ set_exec_mem_alloc_func(exec_mem_alloc_func_t alloc_func,
 
 /* The below types are used in platform_api_extension.h,
    we just define them to make the compiler happy */
-typedef int os_file_handle;
+typedef int os_dir_stream;
-typedef void *os_dir_stream;
 typedef int os_raw_file_handle;
 
+#define OS_DIR_STREAM_INVALID 0
+
+// handle for file system descriptor
+typedef struct zephyr_fs_desc {
+    char *path;
+    union {
+        struct fs_file_t file;
+        struct fs_dir_t dir;
+    };
+    bool is_dir;
+    bool used;
+    uint32_t dir_index; // DSK: supprt for rewind and seek
+} zephyr_fs_desc;
+
+// definition of zephyr_handle
+typedef struct zephyr_handle {
+    int fd;
+    bool is_sock;
+} zephyr_handle;
+
+typedef struct zephyr_handle *os_file_handle;
+#define bh_socket_t zephyr_handle *
+
+typedef struct zsock_pollfd os_poll_file_handle;
+typedef unsigned int os_nfds_t;
+
+// Some of these definitions will throw warning for macros
+// redefinition if CONFIG_POSIX_API=y, but it's fine.
+// Warning: the CONFIG_POSIX_API will surely be deprecated and
+// split into more macros, so we may use some ifdefs to avoid
+// the warning in the future.
+#define POLLIN ZSOCK_POLLIN
+#define POLLPRI ZSOCK_POLLPRI
+#define POLLOUT ZSOCK_POLLOUT
+#define POLLERR ZSOCK_POLLERR
+#define POLLHUP ZSOCK_POLLHUP
+#define POLLNVAL ZSOCK_POLLNVAL
+
+#define FIONREAD ZFD_IOCTL_FIONREAD
+
+typedef struct timespec os_timespec;
+
+#ifndef CLOCK_REALTIME
+#define CLOCK_REALTIME 1
+#endif
+
+#define CLOCK_MONOTONIC 4
+
+static inline int
+os_sched_yield(void)
+{
+    k_yield();
+    return 0;
+}
+
 static inline os_file_handle
 os_get_invalid_handle(void)
 {
-    return -1;
+    return NULL;
 }
 
 static inline int

core/shared/platform/zephyr/shared_platform.cmake

@@ -8,11 +8,20 @@ add_definitions(-DBH_PLATFORM_ZEPHYR)
 include_directories(${PLATFORM_SHARED_DIR})
 include_directories(${PLATFORM_SHARED_DIR}/../include)
 
-if(${CONFIG_MINIMAL_LIBC})
-    include (${CMAKE_CURRENT_LIST_DIR}/../common/math/platform_api_math.cmake)
-endif()
-
 file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
 
-set (PLATFORM_SHARED_SOURCE ${source_all} ${PLATFORM_COMMON_MATH_SOURCE})
+if(${CONFIG_MINIMAL_LIBC})
+    include (${CMAKE_CURRENT_LIST_DIR}/../common/math/platform_api_math.cmake)
+    set (source_all ${source_all} ${PLATFORM_COMMON_MATH_SOURCE})
+endif()
 
+if (NOT WAMR_BUILD_LIBC_WASI EQUAL 1)
+    list(REMOVE_ITEM source_all ${PLATFORM_SHARED_DIR}/zephyr_socket.c)
+    list(REMOVE_ITEM source_all ${PLATFORM_SHARED_DIR}/zephyr_file.c)
+    list(REMOVE_ITEM source_all ${PLATFORM_SHARED_DIR}/zephyr_clock.c)
+else()
+  include (${CMAKE_CURRENT_LIST_DIR}/../common/libc-util/platform_common_libc_util.cmake)
+  set(source_all ${source_all} ${PLATFORM_COMMON_LIBC_UTIL_SOURCE})
+endif ()
+
+set (PLATFORM_SHARED_SOURCE ${source_all})

core/shared/platform/zephyr/zephyr_clock.c

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2024 Grenoble INP - ESISAR.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "platform_api_extension.h"
+#include "platform_api_vmcore.h"
+#include "libc_errno.h"
+
+#include <zephyr/kernel.h>
+
+/* Notes:
+ * We are using the same implementation for __WASI_CLOCK_REALTIME and
+ * __WASI_CLOCK_MONOTONIC, because it is a practical solution when there
+ * is no RTC or external time source available.
+ * The implementation is based on the Zephyr `k_cycle_get_32()` function or
+ * the 64bits variant if available.
+ * We could have used `k_uptime_get()` instead, but it is not as precise,
+ * it has a millisecond resolution or depend on CONFIG_SYS_CLOCK_TICKS_PER_SEC.
+ * Feel free to change the implementation if you have a better solution.
+ * May look at
+ * https://github.com/zephyrproject-rtos/zephyr/blob/main/lib/posix/options/clock.c
+ * for reference.
+ */
+
+#define NANOSECONDS_PER_SECOND 1000000000ULL
+
+__wasi_errno_t
+os_clock_res_get(__wasi_clockid_t clock_id, __wasi_timestamp_t *resolution)
+{
+    switch (clock_id) {
+        case __WASI_CLOCK_PROCESS_CPUTIME_ID:
+        case __WASI_CLOCK_THREAD_CPUTIME_ID:
+            return __WASI_ENOTSUP;
+        case __WASI_CLOCK_REALTIME:
+        case __WASI_CLOCK_MONOTONIC:
+            *resolution =
+                NANOSECONDS_PER_SECOND / CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
+            return __WASI_ESUCCESS;
+        default:
+            return __WASI_EINVAL;
+    }
+}
+
+__wasi_errno_t
+os_clock_time_get(__wasi_clockid_t clock_id, __wasi_timestamp_t precision,
+                  __wasi_timestamp_t *time)
+{
+    (void)precision;
+
+    switch (clock_id) {
+        case __WASI_CLOCK_PROCESS_CPUTIME_ID:
+        case __WASI_CLOCK_THREAD_CPUTIME_ID:
+            return __WASI_ENOTSUP;
+        case __WASI_CLOCK_REALTIME:
+        case __WASI_CLOCK_MONOTONIC:
+#ifdef CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER
+            *time = k_cycle_get_64();
+#else
+            *time = k_cycle_get_32();
+#endif
+            return __WASI_ESUCCESS;
+        default:
+            return __WASI_EINVAL;
+    }
+}

core/shared/platform/zephyr/zephyr_thread.c

@@ -34,22 +34,22 @@
 static K_THREAD_STACK_ARRAY_DEFINE(mpu_stacks, BH_ZEPHYR_MPU_STACK_COUNT,
                                    BH_ZEPHYR_MPU_STACK_SIZE);
 static bool mpu_stack_allocated[BH_ZEPHYR_MPU_STACK_COUNT];
-static mutex_t mpu_stack_lock;
+static zmutex_t mpu_stack_lock;
 
 static char *
 mpu_stack_alloc()
 {
     int i;
 
-    mutex_lock(&mpu_stack_lock, K_FOREVER);
+    zmutex_lock(&mpu_stack_lock, K_FOREVER);
     for (i = 0; i < BH_ZEPHYR_MPU_STACK_COUNT; i++) {
         if (!mpu_stack_allocated[i]) {
             mpu_stack_allocated[i] = true;
-            mutex_unlock(&mpu_stack_lock);
+            zmutex_unlock(&mpu_stack_lock);
             return (char *)mpu_stacks[i];
         }
     }
-    mutex_unlock(&mpu_stack_lock);
+    zmutex_unlock(&mpu_stack_lock);
     return NULL;
 }
 
@@ -58,17 +58,17 @@ mpu_stack_free(char *stack)
 {
     int i;
 
-    mutex_lock(&mpu_stack_lock, K_FOREVER);
+    zmutex_lock(&mpu_stack_lock, K_FOREVER);
     for (i = 0; i < BH_ZEPHYR_MPU_STACK_COUNT; i++) {
         if ((char *)mpu_stacks[i] == stack)
             mpu_stack_allocated[i] = false;
     }
-    mutex_unlock(&mpu_stack_lock);
+    zmutex_unlock(&mpu_stack_lock);
 }
 #endif
 
 typedef struct os_thread_wait_node {
-    sem_t sem;
+    zsem_t sem;
     os_thread_wait_list next;
 } os_thread_wait_node;
 
@@ -80,7 +80,7 @@ typedef struct os_thread_data {
     /* Jeff thread local root */
     void *tlr;
     /* Lock for waiting list */
-    mutex_t wait_list_lock;
+    zmutex_t wait_list_lock;
     /* Waiting list of other threads who are joining this thread */
     os_thread_wait_list thread_wait_list;
     /* Thread stack size */
@@ -107,13 +107,13 @@ static bool is_thread_sys_inited = false;
 static os_thread_data supervisor_thread_data;
 
 /* Lock for thread data list */
-static mutex_t thread_data_lock;
+static zmutex_t thread_data_lock;
 
 /* Thread data list */
 static os_thread_data *thread_data_list = NULL;
 
 /* Lock for thread object list */
-static mutex_t thread_obj_lock;
+static zmutex_t thread_obj_lock;
 
 /* Thread object list */
 static os_thread_obj *thread_obj_list = NULL;
@@ -121,7 +121,7 @@ static os_thread_obj *thread_obj_list = NULL;
 static void
 thread_data_list_add(os_thread_data *thread_data)
 {
-    mutex_lock(&thread_data_lock, K_FOREVER);
+    zmutex_lock(&thread_data_lock, K_FOREVER);
     if (!thread_data_list)
         thread_data_list = thread_data;
     else {
@@ -129,7 +129,7 @@ thread_data_list_add(os_thread_data *thread_data)
         os_thread_data *p = thread_data_list;
         while (p) {
             if (p == thread_data) {
-                mutex_unlock(&thread_data_lock);
+                zmutex_unlock(&thread_data_lock);
                 return;
             }
             p = p->next;
@@ -139,13 +139,13 @@ thread_data_list_add(os_thread_data *thread_data)
         thread_data->next = thread_data_list;
         thread_data_list = thread_data;
     }
-    mutex_unlock(&thread_data_lock);
+    zmutex_unlock(&thread_data_lock);
 }
 
 static void
 thread_data_list_remove(os_thread_data *thread_data)
 {
-    mutex_lock(&thread_data_lock, K_FOREVER);
+    zmutex_lock(&thread_data_lock, K_FOREVER);
     if (thread_data_list) {
         if (thread_data_list == thread_data)
             thread_data_list = thread_data_list->next;
@@ -158,32 +158,32 @@ thread_data_list_remove(os_thread_data *thread_data)
                 p->next = p->next->next;
         }
     }
-    mutex_unlock(&thread_data_lock);
+    zmutex_unlock(&thread_data_lock);
 }
 
 static os_thread_data *
 thread_data_list_lookup(k_tid_t tid)
 {
-    mutex_lock(&thread_data_lock, K_FOREVER);
+    zmutex_lock(&thread_data_lock, K_FOREVER);
     if (thread_data_list) {
         os_thread_data *p = thread_data_list;
         while (p) {
             if (p->tid == tid) {
                 /* Found */
-                mutex_unlock(&thread_data_lock);
+                zmutex_unlock(&thread_data_lock);
                 return p;
             }
             p = p->next;
         }
     }
-    mutex_unlock(&thread_data_lock);
+    zmutex_unlock(&thread_data_lock);
     return NULL;
 }
 
 static void
 thread_obj_list_add(os_thread_obj *thread_obj)
 {
-    mutex_lock(&thread_obj_lock, K_FOREVER);
+    zmutex_lock(&thread_obj_lock, K_FOREVER);
     if (!thread_obj_list)
         thread_obj_list = thread_obj;
     else {
@@ -191,14 +191,14 @@ thread_obj_list_add(os_thread_obj *thread_obj)
         thread_obj->next = thread_obj_list;
         thread_obj_list = thread_obj;
     }
-    mutex_unlock(&thread_obj_lock);
+    zmutex_unlock(&thread_obj_lock);
 }
 
 static void
 thread_obj_list_reclaim()
 {
     os_thread_obj *p, *p_prev;
-    mutex_lock(&thread_obj_lock, K_FOREVER);
+    zmutex_lock(&thread_obj_lock, K_FOREVER);
     p_prev = NULL;
     p = thread_obj_list;
     while (p) {
@@ -219,7 +219,7 @@ thread_obj_list_reclaim()
             p = p->next;
         }
     }
-    mutex_unlock(&thread_obj_lock);
+    zmutex_unlock(&thread_obj_lock);
 }
 
 int
@@ -229,10 +229,10 @@ os_thread_sys_init()
         return BHT_OK;
 
 #if BH_ENABLE_ZEPHYR_MPU_STACK != 0
-    mutex_init(&mpu_stack_lock);
+    zmutex_init(&mpu_stack_lock);
 #endif
-    mutex_init(&thread_data_lock);
+    zmutex_init(&thread_data_lock);
-    mutex_init(&thread_obj_lock);
+    zmutex_init(&thread_obj_lock);
 
     /* Initialize supervisor thread data */
     memset(&supervisor_thread_data, 0, sizeof(supervisor_thread_data));
@@ -265,19 +265,19 @@ os_thread_cleanup(void)
     os_thread_data *thread_data = thread_data_current();
 
     bh_assert(thread_data != NULL);
-    mutex_lock(&thread_data->wait_list_lock, K_FOREVER);
+    zmutex_lock(&thread_data->wait_list_lock, K_FOREVER);
     if (thread_data->thread_wait_list) {
         /* Signal each joining thread */
         os_thread_wait_list head = thread_data->thread_wait_list;
         while (head) {
             os_thread_wait_list next = head->next;
-            sem_give(&head->sem);
+            zsem_give(&head->sem);
             /* head will be freed by joining thread */
             head = next;
         }
         thread_data->thread_wait_list = NULL;
     }
-    mutex_unlock(&thread_data->wait_list_lock);
+    zmutex_unlock(&thread_data->wait_list_lock);
 
     thread_data_list_remove(thread_data);
     /* Set flag to true for the next thread creating to
@@ -342,7 +342,7 @@ os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
     }
 
     memset(thread_data, 0, thread_data_size);
-    mutex_init(&thread_data->wait_list_lock);
+    zmutex_init(&thread_data->wait_list_lock);
     thread_data->stack_size = stack_size;
     thread_data->tid = tid;
 
@@ -407,10 +407,10 @@ os_thread_join(korp_tid thread, void **value_ptr)
     if (!(node = BH_MALLOC(sizeof(os_thread_wait_node))))
         return BHT_ERROR;
 
-    sem_init(&node->sem, 0, 1);
+    zsem_init(&node->sem, 0, 1);
     node->next = NULL;
 
-    mutex_lock(&thread_data->wait_list_lock, K_FOREVER);
+    zmutex_lock(&thread_data->wait_list_lock, K_FOREVER);
     if (!thread_data->thread_wait_list)
         thread_data->thread_wait_list = node;
     else {
@@ -420,10 +420,10 @@ os_thread_join(korp_tid thread, void **value_ptr)
             p = p->next;
         p->next = node;
     }
-    mutex_unlock(&thread_data->wait_list_lock);
+    zmutex_unlock(&thread_data->wait_list_lock);
 
     /* Wait the sem */
-    sem_take(&node->sem, K_FOREVER);
+    zsem_take(&node->sem, K_FOREVER);
 
     /* Wait some time for the thread to be actually terminated */
     k_sleep(Z_TIMEOUT_MS(100));
@@ -436,14 +436,14 @@ os_thread_join(korp_tid thread, void **value_ptr)
 int
 os_mutex_init(korp_mutex *mutex)
 {
-    mutex_init(mutex);
+    zmutex_init(mutex);
     return BHT_OK;
 }
 
 int
 os_recursive_mutex_init(korp_mutex *mutex)
 {
-    mutex_init(mutex);
+    zmutex_init(mutex);
     return BHT_OK;
 }
 
@@ -457,16 +457,16 @@ os_mutex_destroy(korp_mutex *mutex)
 int
 os_mutex_lock(korp_mutex *mutex)
 {
-    return mutex_lock(mutex, K_FOREVER);
+    return zmutex_lock(mutex, K_FOREVER);
 }
 
 int
 os_mutex_unlock(korp_mutex *mutex)
 {
 #if KERNEL_VERSION_NUMBER >= 0x020200 /* version 2.2.0 */
-    return mutex_unlock(mutex);
+    return zmutex_unlock(mutex);
 #else
-    mutex_unlock(mutex);
+    zmutex_unlock(mutex);
     return 0;
 #endif
 }
@@ -474,7 +474,7 @@ os_mutex_unlock(korp_mutex *mutex)
 int
 os_cond_init(korp_cond *cond)
 {
-    mutex_init(&cond->wait_list_lock);
+    zmutex_init(&cond->wait_list_lock);
     cond->thread_wait_list = NULL;
     return BHT_OK;
 }
@@ -495,10 +495,10 @@ os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed, int mills)
     if (!(node = BH_MALLOC(sizeof(os_thread_wait_node))))
         return BHT_ERROR;
 
-    sem_init(&node->sem, 0, 1);
+    zsem_init(&node->sem, 0, 1);
     node->next = NULL;
 
-    mutex_lock(&cond->wait_list_lock, K_FOREVER);
+    zmutex_lock(&cond->wait_list_lock, K_FOREVER);
     if (!cond->thread_wait_list)
         cond->thread_wait_list = node;
     else {
@@ -508,15 +508,15 @@ os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed, int mills)
             p = p->next;
         p->next = node;
     }
-    mutex_unlock(&cond->wait_list_lock);
+    zmutex_unlock(&cond->wait_list_lock);
 
     /* Unlock mutex, wait sem and lock mutex again */
-    mutex_unlock(mutex);
+    zmutex_unlock(mutex);
-    sem_take(&node->sem, timed ? Z_TIMEOUT_MS(mills) : K_FOREVER);
+    zsem_take(&node->sem, timed ? Z_TIMEOUT_MS(mills) : K_FOREVER);
-    mutex_lock(mutex, K_FOREVER);
+    zmutex_lock(mutex, K_FOREVER);
 
     /* Remove wait node from wait list */
-    mutex_lock(&cond->wait_list_lock, K_FOREVER);
+    zmutex_lock(&cond->wait_list_lock, K_FOREVER);
     if (cond->thread_wait_list == node)
         cond->thread_wait_list = node->next;
     else {
@@ -527,7 +527,7 @@ os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex, bool timed, int mills)
         p->next = node->next;
     }
     BH_FREE(node);
-    mutex_unlock(&cond->wait_list_lock);
+    zmutex_unlock(&cond->wait_list_lock);
 
     return BHT_OK;
 }
@@ -565,10 +565,10 @@ int
 os_cond_signal(korp_cond *cond)
 {
     /* Signal the head wait node of wait list */
-    mutex_lock(&cond->wait_list_lock, K_FOREVER);
+    zmutex_lock(&cond->wait_list_lock, K_FOREVER);
     if (cond->thread_wait_list)
-        sem_give(&cond->thread_wait_list->sem);
+        zsem_give(&cond->thread_wait_list->sem);
-    mutex_unlock(&cond->wait_list_lock);
+    zmutex_unlock(&cond->wait_list_lock);
 
     return BHT_OK;
 }
@@ -588,6 +588,67 @@ void
 os_thread_jit_write_protect_np(bool enabled)
 {}
 
+int
+os_rwlock_init(korp_rwlock *lock)
+{
+    if (!lock) {
+        return BHT_ERROR;
+    }
+
+    k_mutex_init(&lock->mtx);
+    k_sem_init(&lock->sem, 0, K_SEM_MAX_LIMIT);
+    lock->read_count = 0;
+
+    return BHT_OK;
+}
+
+int
+os_rwlock_rdlock(korp_rwlock *lock)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
+int
+os_rwlock_wrlock(korp_rwlock *lock)
+{
+    // Acquire the mutex to ensure exclusive access
+    if (k_mutex_lock(&lock->mtx, K_FOREVER) != 0) {
+        return BHT_ERROR;
+    }
+
+    // Wait until there are no readers
+    while (lock->read_count > 0) {
+        // Release the mutex while we're waiting
+        k_mutex_unlock(&lock->mtx);
+
+        // Wait for a short time
+        k_sleep(K_MSEC(1));
+
+        // Re-acquire the mutex
+        if (k_mutex_lock(&lock->mtx, K_FOREVER) != 0) {
+            return BHT_ERROR;
+        }
+    }
+    // At this point, we hold the mutex and there are no readers, so we have the
+    // write lock
+    return BHT_OK;
+}
+
+int
+os_rwlock_unlock(korp_rwlock *lock)
+{
+    k_mutex_unlock(&lock->mtx);
+    return BHT_OK;
+}
+
+int
+os_rwlock_destroy(korp_rwlock *lock)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
 int
 os_thread_detach(korp_tid thread)
 {
@@ -607,13 +668,88 @@ int
 os_cond_broadcast(korp_cond *cond)
 {
     os_thread_wait_node *node;
-    mutex_lock(&cond->wait_list_lock, K_FOREVER);
+    zmutex_lock(&cond->wait_list_lock, K_FOREVER);
     node = cond->thread_wait_list;
     while (node) {
         os_thread_wait_node *next = node->next;
-        sem_give(&node->sem);
+        zsem_give(&node->sem);
         node = next;
     }
-    mutex_unlock(&cond->wait_list_lock);
+    zmutex_unlock(&cond->wait_list_lock);
     return BHT_OK;
 }
+
+korp_sem *
+os_sem_open(const char *name, int oflags, int mode, int val)
+{
+    /* Not implemented */
+    return NULL;
+}
+
+int
+os_sem_close(korp_sem *sem)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
+int
+os_sem_wait(korp_sem *sem)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
+int
+os_sem_trywait(korp_sem *sem)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
+int
+os_sem_post(korp_sem *sem)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
+int
+os_sem_getvalue(korp_sem *sem, int *sval)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
+int
+os_sem_unlink(const char *name)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
+int
+os_blocking_op_init()
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}
+
+void
+os_begin_blocking_op()
+{
+    /* Not implemented */
+}
+
+void
+os_end_blocking_op()
+{
+    /* Not implemented */
+}
+
+int
+os_wakeup_blocking_op(korp_tid tid)
+{
+    /* Not implemented */
+    return BHT_ERROR;
+}

product-mini/platforms/zephyr/simple-file/CMakeLists.txt

@@ -0,0 +1,91 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+cmake_minimum_required(VERSION 3.8.2)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(wamr)
+
+enable_language (ASM)
+
+set (WAMR_BUILD_PLATFORM "zephyr")
+
+# WAMR Configuration:
+set (WAMR_BUILD_TARGET "THUMB")
+set (WAMR_BUILD_INTERP 1)
+set (WAMR_BUILD_FAST_INTERP 0)
+set (WAMR_BUILD_AOT 1)
+set (WAMR_BUILD_LIBC_BUILTIN 1) # printf
+set (WAMR_BUILD_LIBC_WASI 1)
+set (WAMR_BUILD_LIB_PTHREAD 0)
+set (WAMR_BUILD_GLOBAL_HEAP_POOL 1)
+set (WAMR_BUILD_GLOBAL_HEAP_SIZE 131072) # 128 KB
+# set (WAMR_BUILD_GLOBAL_HEAP_SIZE 65536) # 64 KB
+
+# Environment variables:
+
+# Check if WAMR_ROOT_DIR is set 
+if(DEFINED ENV{WAMR_ROOT_DIR})
+  set(WAMR_ROOT_DIR $ENV{WAMR_ROOT_DIR})
+else()
+  message(FATAL_ERROR "'WAMR_ROOT_DIR' need to be specified")
+endif()
+message("wasi-sdk was found at ${WAMR_ROOT_DIR}")
+
+# Check if WASI_SDK_PATH is set 
+if(NOT $ENV{WASI_SDK_PATH} STREQUAL "")
+  set(WASI_SDK_PATH $ENV{WASI_SDK_PATH})
+else()
+  find_program(WASM_C_COMPILER clang /opt/wasi-sdk/bin NO_DEFAULT_PATH)
+  if(NOT WASM_C_COMPILER)
+    message(FATAL_ERROR "'wasi-sdk' not found, please ensure wasi-sdk is installed.\
+                         You can download and install it from\
+                         https://github.com/WebAssembly/wasi-sdk/releases")
+  else()
+    set(WASI_SDK_PATH /opt/wasi-sdk)
+  endif()
+endif()
+message("wasi-sdk was found at ${WASI_SDK_PATH}")
+
+# Check if WAMR_APP_FRAMEWORK_DIR is set
+if (DEFINED ENV{WAMR_APP_FRAMEWORK_DIR})
+  set(WAMR_APP_FRAMEWORK_DIR $ENV{WAMR_APP_FRAMEWORK_DIR})
+else()
+  message(FATAL_ERROR "'wamr-app-framework' not found, please ensure they are installed.\
+                       You can download and install them from\
+                       https://github.com/bytecodealliance/wamr-app-framework")
+endif()
+message("wamr-app-framework was found at ${WAMR_APP_FRAMEWORK_DIR}")
+
+# set the WAMR_SDK_DIR with the path specified in the environment variable
+set(WAMR_SDK_DIR
+    ${WAMR_APP_FRAMEWORK_DIR}/wamr-sdk
+)
+
+# set the WAMR_LIBC_BUILTIN_DIR
+set(WAMR_LIBC_BUILTIN_DIR
+    ${WAMR_SDK_DIR}/wamr-sdk/app/libc-builtin-sysroot
+)
+
+# set the WAMR_SDK_PACKAGE_OUT_DIR 
+set(WAMR_SDK_PACKAGE_OUT_DIR
+    ${CMAKE_CURRENT_BINARY_DIR}/wamr-sdk/app-sdk/wamr-app-framework
+)
+
+# # Reset linker flags
+# set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")
+# set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
+
+include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
+# include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake) # in socket-api sample
+
+# Build the WAMR runtime 
+target_sources(app PRIVATE
+               ${WAMR_RUNTIME_LIB_SOURCE}
+               src/main.c)
+
+# Link libraries like in samples.
+set(WASI_LIBM "${WASI_SDK_PATH}/share/wasi-sysroot/lib/wasm32-wasi/libm.a")
+set(WASI_LIBDL "${WASI_SDK_PATH}/share/wasi-sysroot/lib/wasm32-wasi/libdl.a")
+
+target_link_libraries(app PUBLIC ${WASI_LIBM} ${WASI_LIBDL})

product-mini/platforms/zephyr/simple-file/README.md

@@ -0,0 +1,91 @@
+# File sample 
+This sample demonstrates the use of WASI API to interact with the file system.
+
+> 🛠️ **Work in progress:** The sample is functional but be aware that just a small part of WASI File System API was tested.
+> Actual Zephyr APIs: 
+> * directory creation = `fs_mkdir`
+> * file opening/creation = `fs_open`
+> * file write = `fs_write`
+> * file offset = `fs_seek`
+> * file read = `fs_read`
+> * file close = `fs_close`
+> * directory close = `fs_closedir`
+
+## Run Command
+* **Zephyr Build**
+    1. **Build:** Replace `nucleo_h743zi` with your board name and the `WAMR_BUILD_TARGET` in `CMakeList.txt` with your target architecture.
+        ```bash
+        ZEPHYR_BASE=~/zephyrproject/zephyr \
+        WAMR_ROOT_DIR=~/wasm-micro-runtime \
+        WASI_SDK_PATH=~/wasi-sdk-21.0 \
+        WAMR_APP_FRAMEWORK_DIR=~/wamr-app-framework \
+        west build . -b nucleo_h563zi -p always 
+        ```
+        ⚠️ **Warning:** The flags `ZEPHYR_BASE`, `WAMR_ROOT_DIR`, `WASI_SDK_PATH`, and `WAMR_APP_FRAMEWORK_DIR` need to be set otherwise the build will fail.
+
+    2. **Flash:** 
+        ```bash
+        ZEPHYR_BASE=~/zephyrproject/zephyr west flash
+        ```
+
+    3. **Monitor:** Use a serial link to monitor the output. Personally, I use minicom.
+        ```bash
+        minicom -D /dev/ttyACM0
+        ```
+
+    4. **Debug:** Curently investigating.
+
+* **WebAssembly Module**
+
+    ❗ **Important:** I used wasi-sdk 21 to compile the module. I still haven't tried the module with the new wasi-sdk 22.
+
+    1. **Compile:** in the `wasm-apps` folder. 
+        ```bash
+        ~/wasi-sdk-21.0/bin/clang --sysroot=/home/user/wasi-sdk-21.0/share/wasi-sysroot -nodefaultlibs -lc -o file.wasm file.c -z stack-size=8192 -Wl,--initial-memory=65536 -Wl,--export=__heap_base -Wl,--export=__data_end
+        ```
+    2. **generate a C header:** Use `xxd` or other tool, I also put simple python script. At application root `simple-file/`.
+        ```bash
+        python3 to_c_header.py
+        ```
+        Be free to modify the script to fit your needs.
+
+## Output
+The output should be similar to the following:
+```bash
+*** Booting Zephyr OS build v3.6.0-4305-g2ec8f442a505 ***
+Area 3 at 0x1f0000 on flash-controller@40022000 for 65536 bytes
+[00:00:00.067,000] <inf> littlefs: LittleFS version 2.8, disk version 2.1
+[00:00:00.074,000] <inf> littlefs: FS at flash-controller@40022000:0x1f0000 is 8 0x2000-byte blocks with 512 cycle
+[00:00:00.085,000] <inf> littlefs: sizes: rd 16 ; pr 16 ; ca 64 ; la 32
+[00:00:00.092,000] <err> littlefs: WEST_TOPDIR/modules/fs/littlefs/lfs.c:1351: Corrupted dir pair at {0x0, 0x1}
+[00:00:00.103,000] <wrn> littlefs: can't mount (LFS -84); formatting
+[00:00:00.114,000] <inf> littlefs: /lfs mounted
+/lfs mount: 0
+[00:00:00.120,000] <inf> main: stdin = 0
+[00:00:00.124,000] <inf> main: stdout = 1
+[00:00:00.128,000] <inf> main: stderr = 2
+[00:00:00.133,000] <inf> main: global heap size: 131072
+[00:00:00.142,000] <inf> main: Wasm file size: 34682
+[00:00:00:000 - 2000AFE0]: WASI context initialization: START
+
+[OS] os_rwlock_init
+[OS] os_rwlock_init
+[00:00:00:000 - 2000AFE0]: WASI context initialization: END
+
+[00:00:00.190,000] <inf> main: main found
+Hello WebAssembly Module !
+
+mkdir returned 0
+fopen Succeed
+fwrite returned 13
+fseek returned 0
+fread returned 13
+buffer read = Hello, World!
+
+[00:00:00.225,000] <inf> main: main executed
+[00:00:00.230,000] <inf> main: wasi exit code: 0
+[00:00:00.239,000] <inf> main: elapsed: 178ms
+[00:00:03.158,000] <inf> phy_mii: PHY (0) Link speed 100 Mb, full duplex
+
+[00:00:00.051,000] <inf> phy_mii: PHY (0) ID 7C131
+```

product-mini/platforms/zephyr/simple-file/prj.conf

@@ -0,0 +1,40 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# Log config
+CONFIG_PRINTK=y
+CONFIG_LOG=y
+CONFIG_LOG_MODE_IMMEDIATE=y  
+# CONFIG_LOG_MODE_DEFERRED=y
+
+CONFIG_MAIN_STACK_SIZE=8192
+# CONFIG_HEAP_MEM_POOL_SIZE=32768
+CONFIG_REQUIRES_FULL_LIBC=y
+
+# Config File System
+CONFIG_POSIX_API=n
+CONFIG_FILE_SYSTEM=y
+CONFIG_FILE_SYSTEM_LITTLEFS=y
+# CONFIG_FS_LITTLEFS_BLK_DEV=y
+
+# Temp Build Network stack to compile.
+CONFIG_NETWORKING=y
+CONFIG_NET_IPV4=y
+CONFIG_NET_IPV6=y
+CONFIG_NET_TCP=y
+CONFIG_NET_SOCKETS=y
+
+
+# Random generator
+CONFIG_TEST_RANDOM_GENERATOR=y
+
+# Stack conf
+CONFIG_STACK_SENTINEL=y
+CONFIG_HW_STACK_PROTECTION=y
+
+# Flash
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y
+
+# Debug
+CONFIG_DEBUG=y

product-mini/platforms/zephyr/simple-file/src/main.c

@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+// #include <autoconf.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include "bh_platform.h"
+#include "bh_assert.h"
+#include "bh_log.h"
+#include "wasm_export.h"
+#include "file.h"
+
+#include <zephyr/kernel.h>
+#include <zephyr/device.h>
+#include <zephyr/devicetree.h>
+#include <zephyr/fs/fs.h>
+#include <zephyr/fs/littlefs.h>
+#include <zephyr/logging/log.h>
+#include <unistd.h>
+
+#define CONFIG_HEAP_MEM_POOL_SIZE WASM_GLOBAL_HEAP_SIZE
+#define CONFIG_APP_STACK_SIZE 16384
+#define CONFIG_APP_HEAP_SIZE 16384
+
+LOG_MODULE_REGISTER(main);
+
+static char global_heap_buf[CONFIG_HEAP_MEM_POOL_SIZE] = { 0 };
+
+static int app_argc;
+static char **app_argv;
+
+//-------------------------------------------------------------------------------------------//
+static int
+littlefs_flash_erase(unsigned int id)
+{
+    const struct flash_area *pfa;
+    int rc;
+
+    rc = flash_area_open(id, &pfa);
+    if (rc < 0) {
+        LOG_ERR("FAIL: unable to find flash area %u: %d\n", id, rc);
+        return rc;
+    }
+
+    LOG_PRINTK("Area %u at 0x%x on %s for %u bytes\n", id,
+               (unsigned int)pfa->fa_off, pfa->fa_dev->name,
+               (unsigned int)pfa->fa_size);
+
+    /* Optional wipe flash contents */
+    if (IS_ENABLED(CONFIG_APP_WIPE_STORAGE)) {
+        rc = flash_area_erase(pfa, 0, pfa->fa_size);
+        LOG_ERR("Erasing flash area ... %d", rc);
+    }
+
+    flash_area_close(pfa);
+    return rc;
+}
+#define PARTITION_NODE DT_NODELABEL(lfs1)
+
+#if DT_NODE_EXISTS(PARTITION_NODE)
+FS_FSTAB_DECLARE_ENTRY(PARTITION_NODE);
+#else  /* PARTITION_NODE */
+FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(storage);
+static struct fs_mount_t lfs_storage_mnt = {
+    .type = FS_LITTLEFS,
+    .fs_data = &storage,
+    .storage_dev = (void *)FIXED_PARTITION_ID(storage_partition),
+    .mnt_point = "/lfs",
+};
+#endif /* PARTITION_NODE */
+
+struct fs_mount_t *mountpoint =
+#if DT_NODE_EXISTS(PARTITION_NODE)
+    &FS_FSTAB_ENTRY(PARTITION_NODE)
+#else
+    &lfs_storage_mnt
+#endif
+    ;
+
+static int
+littlefs_mount(struct fs_mount_t *mp)
+{
+    int rc;
+
+    rc = littlefs_flash_erase((uintptr_t)mp->storage_dev);
+    if (rc < 0) {
+        return rc;
+    }
+
+    /* Do not mount if auto-mount has been enabled */
+#if !DT_NODE_EXISTS(PARTITION_NODE) \
+    || !(FSTAB_ENTRY_DT_MOUNT_FLAGS(PARTITION_NODE) & FS_MOUNT_FLAG_AUTOMOUNT)
+    rc = fs_mount(mp);
+    if (rc < 0) {
+        LOG_PRINTK("FAIL: mount id %" PRIuPTR " at %s: %d\n",
+                   (uintptr_t)mp->storage_dev, mp->mnt_point, rc);
+        return rc;
+    }
+    LOG_PRINTK("%s mount: %d\n", mp->mnt_point, rc);
+#else
+    LOG_PRINTK("%s automounted\n", mp->mnt_point);
+#endif
+
+    return 0;
+}
+
+//-------------------------------------------------------------------------------------------//
+int
+main(void)
+{
+    int start, end;
+    start = k_uptime_get_32();
+    uint8 *wasm_file_buf = NULL;
+    uint32 wasm_file_size;
+    wasm_module_t wasm_module = NULL;
+    wasm_module_inst_t wasm_module_inst = NULL;
+    RuntimeInitArgs init_args;
+    char error_buf[128];
+    const char *exception;
+    int rc;
+
+    int log_verbose_level = 2;
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+
+    rc = littlefs_mount(mountpoint);
+    if (rc < 0) {
+        LOG_ERR("FAIL: mounting %s: %d\n", mountpoint->mnt_point, rc);
+        return 0;
+    }
+
+#if WASM_ENABLE_GLOBAL_HEAP_POOL != 0
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
+    init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
+    LOG_INF("global heap size: %d", sizeof(global_heap_buf));
+#else
+#error "memory allocation scheme is not defined."
+#endif
+
+    /* initialize runtime environment */
+    if (!wasm_runtime_full_init(&init_args)) {
+        LOG_ERR("Init runtime environment failed.");
+        return;
+    }
+
+    /* load WASM byte buffer from byte buffer of include file */
+    wasm_file_buf = (uint8 *)wasm_test_file;
+    wasm_file_size = sizeof(wasm_test_file);
+    LOG_INF("Wasm file size: %d", wasm_file_size);
+
+    /* load WASM module */
+    if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
+                                          error_buf, sizeof(error_buf)))) {
+        LOG_ERR("Failed to load module: %s", error_buf);
+        goto fail1;
+    }
+
+    /* Set the WASI context */
+#if WASM_ENABLE_LIBC_WASI != 0
+#define DIR_LIST_SIZE 1
+    const char *dir_list[DIR_LIST_SIZE] = {
+        "/lfs",
+    };
+    /* No dir list => No file system
+     * dir_cont = 0
+     * No mapped dir list => No file system
+     * map_dir_cont = 0
+     * No environment variables
+     * env_count = 0
+     * No command line arguments
+     * argv  0
+     */
+    wasm_runtime_set_wasi_args(wasm_module, dir_list, DIR_LIST_SIZE, NULL, 0,
+                               NULL, 0, NULL, 0);
+#endif
+
+    /* instantiate the module */
+    if (!(wasm_module_inst = wasm_runtime_instantiate(
+              wasm_module, CONFIG_APP_STACK_SIZE, CONFIG_APP_HEAP_SIZE,
+              error_buf, sizeof(error_buf)))) {
+        LOG_ERR("Failed to instantiate module: %s", error_buf);
+        goto fail2;
+    }
+
+    /* invoke the main function */
+    if (wasm_runtime_lookup_function(wasm_module_inst, "_start")
+        || wasm_runtime_lookup_function(wasm_module_inst, "__main_argc_argv")
+        || wasm_runtime_lookup_function(wasm_module_inst, "main")) {
+
+        LOG_INF("main found");
+        wasm_application_execute_main(wasm_module_inst, 0, NULL);
+        LOG_INF("main executed");
+    }
+    else {
+        LOG_ERR("Failed to lookup function main");
+        return -1;
+    }
+
+    if ((exception = wasm_runtime_get_exception(wasm_module_inst)))
+        LOG_ERR("get exception: %s", exception);
+
+    rc = wasm_runtime_get_wasi_exit_code(wasm_module_inst);
+    LOG_INF("wasi exit code: %d", rc);
+
+    /* destroy the module instance */
+    wasm_runtime_deinstantiate(wasm_module_inst);
+
+fail2:
+    /* unload the module */
+    wasm_runtime_unload(wasm_module);
+
+fail1:
+    /* destroy runtime environment */
+    wasm_runtime_destroy();
+
+    end = k_uptime_get_32();
+
+    LOG_INF("elapsed: %dms", (end - start));
+
+    return 0;
+}

product-mini/platforms/zephyr/simple-file/to_c_header.py

@@ -0,0 +1,32 @@
+# Copyright (C) 2024 Grenoble INP - ESISAR.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# Python script to convert wasm file to byte array in a .h file
+import os
+
+CWD = os.getcwd()
+CMAKE_CURRENT_BINARY_DIR = os.getenv('CMAKE_CURRENT_BINARY_DIR', CWD)
+CMAKE_CURRENT_SOURCE_DIR = os.getenv('CMAKE_CURRENT_SOURCE_DIR', f'{CWD}/../src')
+
+LICENCE_HEADER = """/*
+ * Copyright (C) 2024 Grenoble INP - ESISAR.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+"""
+
+print('CMAKE_CURRENT_BINARY_DIR:', CMAKE_CURRENT_BINARY_DIR)
+print('CMAKE_CURRENT_SOURCE_DIR:', CMAKE_CURRENT_SOURCE_DIR)
+
+# Open the wasm file in binary mode and read the data
+with open(f'{CWD}/wasm-apps/file.wasm', 'rb') as f:
+    wasm_bytes = f.read()
+
+# Convert the bytes to a comma-separated string of hex values
+byte_array = ', '.join(f'0x{byte:02x}' for byte in wasm_bytes)
+
+# Create the output string
+output = f'{LICENCE_HEADER}\nunsigned char __aligned(4) wasm_test_file[] = {{ {byte_array} }};'
+
+# Write the output string to the .h file
+with open(f'{CWD}/src/file.h', 'w') as f:
+    f.write(output)

product-mini/platforms/zephyr/simple-file/wasm-apps/file.c

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2024 Grenoble INP - ESISAR.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+// Zephyr
+#define CWD "/lfs"
+#define FOLDER_PATH CWD "/folder"
+#define FILE_PATH CWD "folder/test.txt"
+
+int
+main(int argc, char **argv)
+{
+    int rc;
+    const int zero = 0;
+    printf("Hello WebAssembly Module !\n");
+
+    rc = mkdir(FOLDER_PATH, 0777);
+    if (rc < 0) {
+        rc = errno;
+        printf("mkdir failed with error %d\n", rc);
+        return -1;
+    }
+    printf("mkdir returned %d\n", rc);
+
+    FILE *file = fopen(FILE_PATH, "w+");
+    if (!file) {
+        printf("fopen Failed to open\n");
+        return -1;
+    }
+    printf("fopen Succeed\n");
+
+    const char *data = "Hello, World!";
+    size_t len = 13;
+    size_t nitems = fwrite(data, sizeof(char), 13, file);
+    printf("fwrite returned %d\n", (int)nitems);
+
+    rc = fseek(file, 0, SEEK_SET);
+    printf("fseek returned %d\n", rc);
+
+    char buffer[32];
+    nitems = fread(buffer, sizeof(char), 32, file);
+    printf("fread returned %d\n", (int)nitems);
+    printf("buffer read = %s\n", buffer);
+
+    fclose(file);
+
+    return 0;
+}

product-mini/platforms/zephyr/simple-http/CMakeLists.txt

@@ -0,0 +1,89 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+cmake_minimum_required(VERSION 3.8.2)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(wamr)
+
+enable_language (ASM)
+
+set (WAMR_BUILD_PLATFORM "zephyr")
+
+# WAMR Configuration:
+set (WAMR_BUILD_TARGET "THUMB")
+set (WAMR_BUILD_INTERP 1)
+set (WAMR_BUILD_AOT 0)
+set (WAMR_BUILD_LIBC_BUILTIN 1) # printf
+set (WAMR_BUILD_LIBC_WASI 1)
+set (WAMR_BUILD_LIB_PTHREAD 0)
+set (WAMR_BUILD_GLOBAL_HEAP_POOL 1)
+set (WAMR_BUILD_GLOBAL_HEAP_SIZE 98304) # 96 KB
+
+# Environment variables:
+
+# Check if WAMR_ROOT_DIR is set 
+if(DEFINED ENV{WAMR_ROOT_DIR})
+  set(WAMR_ROOT_DIR $ENV{WAMR_ROOT_DIR})
+else()
+  message(FATAL_ERROR "'WAMR_ROOT_DIR' need to be specified")
+endif()
+message("wasi-sdk was found at ${WAMR_ROOT_DIR}")
+
+# Check if WASI_SDK_PATH is set 
+if(NOT $ENV{WASI_SDK_PATH} STREQUAL "")
+  set(WASI_SDK_PATH $ENV{WASI_SDK_PATH})
+else()
+  find_program(WASM_C_COMPILER clang /opt/wasi-sdk/bin NO_DEFAULT_PATH)
+  if(NOT WASM_C_COMPILER)
+    message(FATAL_ERROR "'wasi-sdk' not found, please ensure wasi-sdk is installed.\
+                         You can download and install it from\
+                         https://github.com/WebAssembly/wasi-sdk/releases")
+  else()
+    set(WASI_SDK_PATH /opt/wasi-sdk)
+  endif()
+endif()
+message("wasi-sdk was found at ${WASI_SDK_PATH}")
+
+# Check if WAMR_APP_FRAMEWORK_DIR is set
+if (DEFINED ENV{WAMR_APP_FRAMEWORK_DIR})
+  set(WAMR_APP_FRAMEWORK_DIR $ENV{WAMR_APP_FRAMEWORK_DIR})
+else()
+  message(FATAL_ERROR "'wamr-app-framework' not found, please ensure they are installed.\
+                       You can download and install them from\
+                       https://github.com/bytecodealliance/wamr-app-framework")
+endif()
+message("wamr-app-framework was found at ${WAMR_APP_FRAMEWORK_DIR}")
+
+# set the WAMR_SDK_DIR with the path specified in the environment variable
+set(WAMR_SDK_DIR
+    ${WAMR_APP_FRAMEWORK_DIR}/wamr-sdk
+)
+
+# set the WAMR_LIBC_BUILTIN_DIR
+set(WAMR_LIBC_BUILTIN_DIR
+    ${WAMR_SDK_DIR}/wamr-sdk/app/libc-builtin-sysroot
+)
+
+# set the WAMR_SDK_PACKAGE_OUT_DIR 
+set(WAMR_SDK_PACKAGE_OUT_DIR
+    ${CMAKE_CURRENT_BINARY_DIR}/wamr-sdk/app-sdk/wamr-app-framework
+)
+
+# # Reset linker flags
+# set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")
+# set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
+
+include (${WAMR_ROOT_DIR}/build-scripts/runtime_lib.cmake)
+# include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake) # in socket-api sample
+
+# Build the WAMR runtime 
+target_sources(app PRIVATE
+               ${WAMR_RUNTIME_LIB_SOURCE}
+               src/main.c)
+
+# Link libraries like in samples.
+set(WASI_LIBM "${WASI_SDK_PATH}/share/wasi-sysroot/lib/wasm32-wasi/libm.a")
+set(WASI_LIBDL "${WASI_SDK_PATH}/share/wasi-sysroot/lib/wasm32-wasi/libdl.a")
+
+target_link_libraries(app PUBLIC ${WASI_LIBM} ${WASI_LIBDL})

product-mini/platforms/zephyr/simple-http/README.md

@@ -0,0 +1,143 @@
+# Socket sample 
+this sample demonstrates the use of WASI API to interact with sockets.
+
+> ❗ **Important:** This sample was ported/adapted from the http_get zephyr sample. The original sample can be found [here]( https://github.com/zephyrproject-rtos/zephyr/blob/main/samples/net/sockets/http_get/src/http_get.c).
+
+> 🛠️ **Work in progress:** The sample is functional but be aware that just a small part of WASI socket API was tested.
+> Actual Zephyr APIs: 
+> * socket creation = `zsock_socket`
+> * socket connection = `zsock_connect`
+> * socket emission = `zsock_sendto`
+> * socket reception = `zsock_recvfrom`
+> * socket destruction = `zsock_close`
+>
+> With the sockets most API are in fact provided by the runtime instead of WASI because of the lack of socket support in WASI preview1.
+
+## Setup
+1. Connect a network cable to the board ethernet port.
+2. Configure the network interface on the host machine
+    ```
+    Internet Protocol Version 4 (TCP/IPv4) Properties:
+        IP Address:         192.0.2.10
+        Subnet Mask:        255.255.255.0
+        Default Gateway:    192.0.2.2
+    ```
+3. Start a simple HTTP server on the host machine.
+    ```bash
+    python3 -m http.server --bind 0.0.0.0
+    ```
+4. Disable any firewall that may block the connection.
+
+## Configuration
+To configure the server side IP address and port modify the following lines in the `http_get.c` file.
+
+1. The `HTTP_HOST` and `HTTP_PORT` macros define the server IP address and port.
+    ```c
+    /* HTTP server to connect to */
+    #define HTTP_HOST "192.0.2.10"
+    /* Port to connect to, as string */
+    #define HTTP_PORT "8000"
+    /* HTTP path to request */
+    #define HTTP_PATH "/"
+
+    // ...
+
+    #define REQUEST "GET " HTTP_PATH " HTTP/1.0\r\nHost: " HTTP_HOST "\r\n\r\n"
+    ```
+    > 📄 **Notes:** These macros are used to build the request string, but they are not used to instantiate the address structure. Because at one point we didn't want to use `inet_pton` to convert the string to an address and it remained like this.
+
+2. The `addr` structure is used to store the server address.
+    ```c
+    addr.sin_port = htons(8000);
+        addr.sin_addr.s_addr =
+            htonl(0xC000020A); // hard coded IP address for 192.0.2.10
+    ```
+
+To configure the authorized IP address(es) modify the following lines in the `main.c` file. WAMR will only allow the IP addresses in the pool to connect to the server.
+```c
+#define ADDRESS_POOL_SIZE 1
+    const char *addr_pool[ADDRESS_POOL_SIZE] = {
+        "192.0.2.10/24",
+    };
+```
+## Run Command
+* **Zephyr Build**
+    1. **Build:** Replace `nucleo_h743zi` with your board name and the `WAMR_BUILD_TARGET` in `CMakeList.txt` with your target architecture.
+        ```bash
+        ZEPHYR_BASE=~/zephyrproject/zephyr \
+        WAMR_ROOT_DIR=~/wasm-micro-runtime \
+        WASI_SDK_PATH=~/wasi-sdk-21.0 \
+        WAMR_APP_FRAMEWORK_DIR=~/wamr-app-framework \
+        west build . -b nucleo_h563zi -p always 
+        ```
+        ⚠️ **Warning:** The flags `ZEPHYR_BASE`, `WAMR_ROOT_DIR`, `WASI_SDK_PATH`, and `WAMR_APP_FRAMEWORK_DIR` need to be set otherwise the build will fail.
+
+    2. **Flash:** 
+        ```bash
+        ZEPHYR_BASE=~/zephyrproject/zephyr west flash
+        ```
+
+    3. **Monitor:** Use a serial link to monitor the output. Personally, I use minicom.
+        ```bash
+        minicom -D /dev/ttyACM0
+        ```
+
+    4. **Debug:** Curently investigating.
+
+* **WebAssembly Module**
+
+    ❗ **Important:** I used wasi-sdk 21 to compile the module. I still haven't tried the module with the new wasi-sdk 22.
+
+    0. **Compile a static lib:** in the `wasm-apps` folder. 
+        * **Compile the an object:**
+        ```bash
+        ~/wasi-sdk-21.0/bin/clang --sysroot=/home/user/wasi-sdk-21.0/share/wasi-sysroot -Iinc/ -c inc/wasi_socket_ext.c -o inc/wasi_socket_ext.o
+        ```
+        * **Create a static lib:**
+        ```bash
+        ~/wasi-sdk-21.0/bin/llvm-ar rcs inc/libwasi_socket_ext.a inc/wasi_socket_ext.o
+        ```
+    1. **Compile:** in the `wasm-apps` folder. 
+        ```bash
+        ~/wasi-sdk-21.0/bin/clang --sysroot=/home/user/wasi-sdk-21.0/share/wasi-sysroot -Iinc/ -nodefaultlibs -o http_get.wasm http_get.c -lc -Linc/ -lwasi_socket_ext -z stack-size=8192 -Wl,--initial-memory=65536 -Wl,--export=__heap_base -Wl,--export=__data_end  -Wl,--allow-undefined
+        ```
+    2. **generate a C header:** Use `xxd` or other tool, I also put simple python script. At application root `simple-http/`.
+        ```bash
+        python3 to_c_header.py
+        ```
+        Be free to modify the script to fit your needs.
+
+## Output
+The output should be similar to the following:
+```bash
+*** Booting Zephyr OS build v3.6.0-4305-g2ec8f442a505 ***
+[00:00:00.061,000] <inf> net_config: Initializing network
+[00:00:00.067,000] <inf> net_config: Waiting interface 1 (0x2000a910) to be up...
+[00:00:03.158,000] <inf> phy_mii: PHY (0) Link speed 100 Mb, full duplex
+
+[00:00:03.288,000] <inf> net_config: Interface 1 (0x2000a910) coming up
+[00:00:03.295,000] <inf> net_config: IPv4 address: 192.0.2.1
+global heap size: 131072
+Wasm file size: 36351
+main found
+[wasm-mod] Preparing HTTP GET request for http://192.0.2.10:8000/
+[wasm-mod] sock = 3
+[wasm-mod] connect rc = 0
+[wasm-mod] send rc = 36
+[wasm-mod] Response:
+
+HTTP/1.0 200 OK
+Server: SimpleHTTP/0.6 Python/3.10.10
+Date: Fri, 14 Jun 2024 07:26:56 GMT
+Content-type: text/html; charset=utf-8
+Content-Length: 2821
+
+# Skip the HTML content
+
+[wasm-mod] len = 0 break
+
+[wasm-mod] Connection closed
+main executed
+wasi exit code: 0
+elapsed: 405ms
+```

product-mini/platforms/zephyr/simple-http/prj.conf

@@ -0,0 +1,61 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# Log config
+CONFIG_PRINTK=y
+CONFIG_LOG=y
+CONFIG_LOG_MODE_IMMEDIATE=y
+CONFIG_NET_LOG=y
+
+CONFIG_MAIN_STACK_SIZE=8192
+# CONFIG_HEAP_MEM_POOL_SIZE=32768
+CONFIG_REQUIRES_FULL_LIBC=y
+
+# Networking config
+CONFIG_NETWORKING=y
+CONFIG_NET_IPV4=y
+CONFIG_NET_IPV6=y
+CONFIG_NET_TCP=y
+CONFIG_NET_SOCKETS=y
+CONFIG_POSIX_API=n
+
+# Stack conf
+# CONFIG_NO_OPTIMIZATIONS=y
+CONFIG_STACK_SENTINEL=y
+CONFIG_HW_STACK_PROTECTION=y
+# CONFIG_STACK_CANARIES=y
+# CONFIG_ISR_STACK_SIZE=4096
+
+# Network driver config
+CONFIG_TEST_RANDOM_GENERATOR=y
+
+# Network address config
+CONFIG_NET_CONFIG_SETTINGS=y
+CONFIG_NET_CONFIG_NEED_IPV4=y
+CONFIG_NET_CONFIG_MY_IPV4_ADDR="192.0.2.1"
+CONFIG_NET_CONFIG_PEER_IPV4_ADDR="192.0.2.2"
+CONFIG_NET_CONFIG_MY_IPV4_GW="192.0.2.2"
+
+# Config File System
+CONFIG_FILE_SYSTEM=y
+CONFIG_FILE_SYSTEM_LITTLEFS=y
+# Flash
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y
+
+# CONFIG_DNS_RESOLVER=y
+# CONFIG_DNS_SERVER_IP_ADDRESSES=y
+# CONFIG_DNS_SERVER1="192.0.2.2"
+
+# Config init stack
+# CONFIG_INIT_STACKS=y 
+# CONFIG_NET_PKT_RX_COUNT=100
+# CONFIG_NET_PKT_TX_COUNT=100
+# CONFIG_NET_BUF_RX_COUNT=100
+# CONFIG_NET_BUF_TX_COUNT=100
+
+# Flash
+CONFIG_FLASH=y
+
+# Debug
+CONFIG_DEBUG=y

product-mini/platforms/zephyr/simple-http/src/main.c

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+// #include <autoconf.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include "bh_platform.h"
+#include "bh_assert.h"
+#include "bh_log.h"
+#include "wasm_export.h"
+#include "http_get.h"
+
+#include <zephyr/kernel.h>
+#include <zephyr/device.h>
+#include <zephyr/devicetree.h>
+#include <zephyr/net/net_ip.h>
+#include <zephyr/net/socket.h>
+#include <zephyr/net/http/client.h>
+
+#define CONFIG_HEAP_MEM_POOL_SIZE WASM_GLOBAL_HEAP_SIZE
+#define CONFIG_APP_STACK_SIZE 8192
+#define CONFIG_APP_HEAP_SIZE 8192
+
+static char global_heap_buf[CONFIG_HEAP_MEM_POOL_SIZE] = { 0 };
+
+static int app_argc;
+static char **app_argv;
+
+int
+main(void)
+{
+    int start, end;
+    start = k_uptime_get_32();
+    uint8 *wasm_file_buf = NULL;
+    uint32 wasm_file_size;
+    wasm_module_t wasm_module = NULL;
+    wasm_module_inst_t wasm_module_inst = NULL;
+    RuntimeInitArgs init_args;
+    char error_buf[128];
+    const char *exception;
+
+    int log_verbose_level = 2;
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+
+#if WASM_ENABLE_GLOBAL_HEAP_POOL != 0
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
+    init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
+    printf("global heap size: %d\n", sizeof(global_heap_buf));
+#else
+#error "memory allocation scheme is not defined."
+#endif
+
+    /* initialize runtime environment */
+    if (!wasm_runtime_full_init(&init_args)) {
+        printf("Init runtime environment failed.\n");
+        return;
+    }
+
+    bh_log_set_verbose_level(log_verbose_level);
+
+    /* load WASM byte buffer from byte buffer of include file */
+    wasm_file_buf = (uint8 *)wasm_test_file;
+    wasm_file_size = sizeof(wasm_test_file);
+    printf("Wasm file size: %d\n", wasm_file_size);
+
+    /* load WASM module */
+    if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
+                                          error_buf, sizeof(error_buf)))) {
+        printf("Failed to load module: %s\n", error_buf);
+        goto fail1;
+    }
+
+    /* Set the WASI context */
+#if WASM_ENABLE_LIBC_WASI != 0
+#define ADDRESS_POOL_SIZE 1
+    const char *addr_pool[ADDRESS_POOL_SIZE] = {
+        "192.0.2.10/24",
+    };
+    /* No dir list => No file system
+     * dir_cont = 0
+     * No mapped dir list => No file system
+     * map_dir_cont = 0
+     * No environment variables
+     * env_count = 0
+     * No command line arguments
+     * argv  0
+     */
+    wasm_runtime_set_wasi_args(wasm_module, NULL, 0, NULL, 0, NULL, 0, NULL, 0);
+    wasm_runtime_set_wasi_addr_pool(wasm_module, addr_pool, ADDRESS_POOL_SIZE);
+    wasm_runtime_set_wasi_ns_lookup_pool(wasm_module, NULL, 0);
+#endif
+
+    /* instantiate the module */
+    if (!(wasm_module_inst = wasm_runtime_instantiate(
+              wasm_module, CONFIG_APP_STACK_SIZE, CONFIG_APP_HEAP_SIZE,
+              error_buf, sizeof(error_buf)))) {
+        printf("Failed to instantiate module: %s\n", error_buf);
+        goto fail2;
+    }
+
+    /* invoke the main function */
+    if (wasm_runtime_lookup_function(wasm_module_inst, "_start")
+        || wasm_runtime_lookup_function(wasm_module_inst, "__main_argc_argv")) {
+
+        printf("main found\n");
+        wasm_application_execute_main(wasm_module_inst, 0, NULL);
+        printf("main executed\n");
+    }
+    else {
+        printf("Failed to lookup function main\n");
+        return -1;
+    }
+
+    if ((exception = wasm_runtime_get_exception(wasm_module_inst)))
+        printf("%s\n", exception);
+
+    int rc = wasm_runtime_get_wasi_exit_code(wasm_module_inst);
+    printf("wasi exit code: %d\n", rc); // 1 = _WASI_E2BIG
+
+    /* destroy the module instance */
+    wasm_runtime_deinstantiate(wasm_module_inst);
+
+fail2:
+    /* unload the module */
+    wasm_runtime_unload(wasm_module);
+
+fail1:
+    /* destroy runtime environment */
+    wasm_runtime_destroy();
+
+    end = k_uptime_get_32();
+
+    printf("elapsed: %dms\n", (end - start));
+
+    return 0;
+}

product-mini/platforms/zephyr/simple-http/to_c_header.py

@@ -0,0 +1,34 @@
+# Copyright (C) 2024 Grenoble INP - ESISAR.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# Python script to convert wasm file to byte array in a .h file
+import os
+
+CWD = os.getcwd()
+CMAKE_CURRENT_BINARY_DIR = os.getenv('CMAKE_CURRENT_BINARY_DIR', CWD)
+CMAKE_CURRENT_SOURCE_DIR = os.getenv('CMAKE_CURRENT_SOURCE_DIR', f'{CWD}/../src')
+
+LICENCE_HEADER = """/*
+ * Copyright (c) 2017 Linaro Limited
+ * Copyright (C) 2024 Grenoble INP - ESISAR Limited
+ * 
+ * SPDX-License-Identifier: Apache-2.0
+ */
+"""
+
+print('CMAKE_CURRENT_BINARY_DIR:', CMAKE_CURRENT_BINARY_DIR)
+print('CMAKE_CURRENT_SOURCE_DIR:', CMAKE_CURRENT_SOURCE_DIR)
+
+# Open the wasm file in binary mode and read the data
+with open(f'{CWD}/wasm-apps/http_get.wasm', 'rb') as f:
+    wasm_bytes = f.read()
+
+# Convert the bytes to a comma-separated string of hex values
+byte_array = ', '.join(f'0x{byte:02x}' for byte in wasm_bytes)
+
+# Create the output string
+output = f'unsigned char __aligned(4) wasm_test_file[] = {{ {byte_array} }};'
+
+# Write the output string to the .h file
+with open(f'{CWD}/src/http_get.h', 'w') as f:
+    f.write(output)

product-mini/platforms/zephyr/simple-http/wasm-apps/http_get.c

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2017 Linaro Limited
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+
+#ifdef __wasi__
+#include <wasi_socket_ext.h>
+#endif
+
+/* HTTP server to connect to */
+#define HTTP_HOST "192.0.2.10"
+/* Port to connect to, as string */
+#define HTTP_PORT "8000"
+/* HTTP path to request */
+#define HTTP_PATH "/"
+
+#define SSTRLEN(s) (sizeof(s) - 1)
+// #define CHECK(r) { if (r == -1) { printf("Error %d: " #r "\n", errno);
+// exit(1); } }
+
+#define REQUEST "GET " HTTP_PATH " HTTP/1.0\r\nHost: " HTTP_HOST "\r\n\r\n"
+
+static char response[1024];
+
+int
+main(int argc, char **argv)
+{
+    int st, sock;
+    struct sockaddr_in addr;
+    int rc = 0;
+
+    printf("[wasm-mod] Preparing HTTP GET request for http://" HTTP_HOST
+           ":" HTTP_PORT HTTP_PATH "\n");
+
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(8000);
+    addr.sin_addr.s_addr =
+        htonl(0xC000020A); // hard coded IP address for 192.0.2.10
+
+    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    printf("[wasm-mod] sock = %d\n", sock);
+
+    rc = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
+    printf("[wasm-mod] connect rc = %d\n", rc);
+
+    rc = sendto(sock, (const void *)REQUEST, SSTRLEN(REQUEST), 0,
+                (struct sockaddr *)&addr, sizeof(addr));
+    printf("[wasm-mod] send rc = %d\n", rc);
+    if (rc < 0) {
+        printf("[wasm-mod] Error %d\n", errno);
+        return 0;
+    }
+
+    printf("[wasm-mod] Response:\n\n");
+
+    while (1) {
+        socklen_t socklen = sizeof(struct sockaddr_in);
+        int len = recvfrom(sock, response, sizeof(response) - 1, 0,
+                           (struct sockaddr *)&addr, &socklen);
+
+        if (len < 0) {
+            printf("[wasm-mod] Error %d\n", errno);
+            return 0;
+        }
+
+        response[len] = 0;
+        printf("%s", response);
+
+        if (len == 0) {
+            printf("[wasm-mod] len = 0 break\n");
+            break;
+        }
+    }
+
+    printf("\n");
+
+    (void)close(sock);
+    printf("[wasm-mod] Connection closed\n");
+    return 0;
+}

product-mini/platforms/zephyr/simple-http/wasm-apps/inc/location.md

@@ -0,0 +1,5 @@
+The lib source code are located there: 
+* [wasi_socket_ext.h](../../../../../../core/iwasm/libraries/lib-socket/inc/wasi_socket_ext.h)
+* [wasi_socket_ext.c](../../../../../../core/iwasm/libraries/lib-socket/src/wasi/wasi_socket_ext.c)
+
+

samples/socket-api/wasm-src/CMakeLists.txt

@@ -88,4 +88,4 @@ compile_with_clang(udp_server.c)
 compile_with_clang(multicast_client.c)
 compile_with_clang(multicast_server.c)
 compile_with_clang(timeout_client.c)
-compile_with_clang(timeout_server.c)
+compile_with_clang(timeout_server.c)