Wasip3 file, stdout, tcp, poll and pipe implementations

expected/wasm32-wasip3/defined-symbols.txt

@@ -336,6 +336,7 @@ __wasilibc_open_nomode
 __wasilibc_populate_preopens
 __wasilibc_pthread_self
 __wasilibc_random
+__wasilibc_read3
 __wasilibc_rename_newat
 __wasilibc_rename_oldat
 __wasilibc_reset_preopens
@@ -344,6 +345,7 @@ __wasilibc_stat
 __wasilibc_tell
 __wasilibc_unlinkat
 __wasilibc_utimens
+__wasilibc_write3
 __wasm_call_dtors
 __wcscoll_l
 __wcsftime_l
@@ -1003,6 +1005,7 @@ optopt
 optreset
 pathconf
 perror
+pipe
 poll
 posix_close
 posix_fadvise
@@ -1472,7 +1475,9 @@ wasip3_list_u8_free
 wasip3_option_string_free
 wasip3_string_dup
 wasip3_string_free
+wasip3_string_from_c
 wasip3_string_set
+wasip3_subtask_block_on
 wasip3_subtask_cancel
 wasip3_subtask_drop
 wasip3_task_cancel

libc-bottom-half/CMakeLists.txt

@@ -164,6 +164,8 @@ if (WASI STREQUAL "p3")
   list(APPEND bottom_half_sources
     sources/wasip3.c
     sources/wasip3_file.c
+    sources/wasip3_file_utils.c
+    sources/wasip3_pipe.c
     sources/wasip3_stdio.c
     sources/wasip3_tcp.c
     sources/wasip3_udp.c

libc-bottom-half/cloudlibc/src/common/errors.h

@@ -1,6 +1,6 @@
 #include <wasi/api.h>
 
-#ifdef __wasip2__
+#if defined(__wasip2__) || defined(__wasip3__)
 #include <errno.h>
 #include <stdlib.h>
 
@@ -9,9 +9,11 @@ static void translate_error(filesystem_error_code_t error) {
     case FILESYSTEM_ERROR_CODE_ACCESS:
         errno = EACCES;
         break;
+#ifdef __wasip2__
     case FILESYSTEM_ERROR_CODE_WOULD_BLOCK:
         errno = EAGAIN;
         break;
+#endif
     case FILESYSTEM_ERROR_CODE_ALREADY:
         errno = EALREADY;
         break;

libc-bottom-half/cloudlibc/src/libc/fcntl/openat.c

@@ -16,6 +16,10 @@
 #include <common/errors.h>
 #endif
 
+#ifdef __wasip3__
+#include <wasi/sockets_utils.h>
+#endif
+
 #ifdef __wasip1__
 static_assert(O_APPEND == __WASI_FDFLAGS_APPEND, "Value mismatch");
 static_assert(O_DSYNC == __WASI_FDFLAGS_DSYNC, "Value mismatch");
@@ -87,7 +91,7 @@ int __wasilibc_nocwd_openat_nomode(int fd, const char *path, int oflag) {
     return -1;
   }
   return newfd;
-#elif defined(__wasip2__)
+#elif defined(__wasip2__) || defined(__wasip3__)
   // Set up path flags
   filesystem_path_flags_t lookup_flags = 0;
   if ((oflag & O_NOFOLLOW) == 0)
@@ -140,6 +144,7 @@ int __wasilibc_nocwd_openat_nomode(int fd, const char *path, int oflag) {
     return -1;
 
   // Construct a WASI string for the path
+#ifdef __wasip2__
   wasip2_string_t path2;
   if (wasip2_string_from_c(path, &path2) < 0)
     return -1;
@@ -162,9 +167,28 @@ int __wasilibc_nocwd_openat_nomode(int fd, const char *path, int oflag) {
   // Update the descriptor table with the new handle
   return __wasilibc_add_file(new_handle, oflag);
 #elif defined(__wasip3__)
-  // TODO(wasip3)
-  errno = ENOTSUP;
-  return -1;
+  wasip3_string_t path2;
+  if (wasip3_string_from_c(path, &path2) < 0)
+    return -1;
+
+  // Open the file, yielding a new handle
+  filesystem_method_descriptor_open_at_args_t args;
+  args.self = file_handle;
+  args.flags = lookup_flags;
+  args.path = path2;
+  args.open_flags = open_flags;
+  args.path_flags = fs_flags;
+  filesystem_result_own_descriptor_error_code_t result;
+  wasip3_subtask_status_t status = filesystem_method_descriptor_open_at(&args, &result);
+  wasip3_subtask_block_on(status);
+  if (result.is_err) {
+    translate_error(result.val.err);
+    return -1;
+  }
+
+  // Update the descriptor table with the new handle
+  return __wasilibc_add_file(result.val.ok, oflag);
+#endif
 #else
 # error "Unsupported WASI version"
 #endif

libc-bottom-half/cloudlibc/src/libc/poll/poll.c

@@ -284,11 +284,150 @@ static int poll_impl(struct pollfd *fds, size_t nfds, int timeout) {
 }
 
 #elif defined(__wasip3__)
+#include <stdlib.h>
+
+typedef struct {
+  wasip3_subtask_status_t waitable;
+  struct pollfd *pollfd;
+} state3_t;
 
 static int poll_impl(struct pollfd *fds, size_t nfds, int timeout) {
-  // TODO(wasip3)
-  errno = ENOTSUP;
-  return -1;
+  for (size_t i = 0; i < nfds; ++i) {
+    fds[i].revents = 0;
+  }
+
+  int return_value = 0;
+  size_t max_pollables = (2 * nfds) + 1;
+  state3_t states[max_pollables];
+  size_t pollable_count = 0;
+  wasip3_subtask_status_t timeout_subtask;
+
+  wasip3_waitable_set_t set = wasip3_waitable_set_new();
+
+  for (size_t i = 0; i < nfds; ++i) {
+    struct pollfd *pollfd = fds + i;
+    if (pollfd->fd < 0)
+      continue;
+    descriptor_table_entry_t *entry = descriptor_table_get_ref(pollfd->fd);
+    if (!entry) {
+      errno = EBADF;
+      return_value = -1;
+      goto cleanup_and_exit;
+    }
+
+    // Without a custom registration handle read/write readiness
+    // below, but everything else is unsupported.
+    if (pollfd->events & ~(POLLRDNORM | POLLWRNORM)) {
+      errno = EOPNOTSUPP;
+      return_value = -1;
+      goto cleanup_and_exit;
+    }
+
+    if (pollfd->events & POLLRDNORM) {
+      if (entry->vtable->read3) {
+        waitable_t input;
+        wasip3_waitable_status_t status;
+        if (entry->vtable->read3(entry->data, 0, 0, &input, &status, NULL) < 0) {
+          return_value = -1;
+          goto cleanup_and_exit;
+        }
+        // = filesystem_stream_u8_read(input, 0, 0);
+        if (status != WASIP3_WAITABLE_STATUS_BLOCKED) {
+          pollfd->revents |= POLLRDNORM;
+          ++return_value;
+        } else if (!return_value) {
+          states[pollable_count].waitable = input;
+          states[pollable_count].pollfd = pollfd;
+          ++pollable_count;
+          wasip3_waitable_join(input, set);
+        }
+      } else {
+        errno = EOPNOTSUPP;
+        return_value = -1;
+        goto cleanup_and_exit;
+      }
+    }
+
+    if (pollfd->events & POLLWRNORM) {
+      if (entry->vtable->write3) {
+        waitable_t input;
+        wasip3_waitable_status_t status;
+        if (entry->vtable->write3(entry->data, 0, 0, &input, &status, NULL) < 0){
+          return_value = -1;
+          goto cleanup_and_exit;
+        }
+        if (status != WASIP3_WAITABLE_STATUS_BLOCKED) {
+          pollfd->revents |= POLLWRNORM;
+          ++return_value;
+        } else if (!return_value) {
+          states[pollable_count].waitable = input;
+          states[pollable_count].pollfd = pollfd;
+          ++pollable_count;
+          wasip3_waitable_join(input, set);
+        }
+      } else {
+        errno = EOPNOTSUPP;
+        return_value = -1;
+        goto cleanup_and_exit;
+      }
+    }
+  }
+
+  if (return_value) goto cleanup_and_exit;
+
+  if (timeout >= 0) {
+    timeout_subtask = monotonic_clock_wait_for(
+        ((monotonic_clock_duration_t)timeout) * 1000000);
+    if (WASIP3_SUBTASK_STATE(timeout_subtask) == WASIP3_SUBTASK_RETURNED) {
+      goto cleanup_and_exit;
+    }
+    assert(WASIP3_SUBTASK_STATE(timeout_subtask) == WASIP3_SUBTASK_STARTED);
+    wasip3_waitable_join(WASIP3_SUBTASK_HANDLE(timeout_subtask), set);
+  }
+
+  wasip3_event_t event;
+  wasip3_waitable_set_wait(set, &event);
+  return_value = 0;
+  switch (event.event) {
+    case WASIP3_EVENT_STREAM_READ:
+      for (size_t i=0; i<pollable_count; ++i) {
+        if (states[i].waitable == event.waitable) {
+          states[i].pollfd->revents |= POLLRDNORM;
+          ++return_value;
+          break;
+        }
+      }
+      break;
+    case WASIP3_EVENT_STREAM_WRITE:
+      for (size_t i=0; i<pollable_count; ++i) {
+        if (states[i].waitable == event.waitable) {
+          states[i].pollfd->revents |= POLLWRNORM;
+          ++return_value;
+          break;
+        }
+      }
+      break;
+    case WASIP3_EVENT_SUBTASK:
+      assert(event.waitable == WASIP3_SUBTASK_HANDLE(timeout_subtask));
+      break;
+    default:
+      abort();
+  }
+  if (timeout >= 0) {
+    wasip3_waitable_join(WASIP3_SUBTASK_HANDLE(timeout_subtask), 0);
+    if (return_value>0)
+      wasip3_subtask_cancel(WASIP3_SUBTASK_HANDLE(timeout_subtask));
+  }
+
+  //repeat wasip3_waitable_set_poll(set, &event); ?
+
+cleanup_and_exit:
+    for (size_t i=0; i<pollable_count; ++i) {
+      wasip3_waitable_join(states[i].waitable, 0);
+    }
+    wasip3_waitable_set_drop(set);
+
+  return return_value;
 }
 
 #else

libc-bottom-half/cloudlibc/src/libc/sys/stat/fstat.c

@@ -18,16 +18,12 @@ int fstat(int fildes, struct stat *buf) {
   }
   to_public_stat(&internal_stat, buf);
   return 0;
-#elif defined(__wasip2__)
+#elif defined(__wasip2__) || defined(__wasip3__)
   // Translate the file descriptor to an internal handle
   descriptor_table_entry_t *entry = descriptor_table_get_ref(fildes);
   if (!entry)
     return -1;
   return entry->vtable->fstat(entry->data, buf);
-#elif defined(__wasip3__)
-  // TODO(wasip3)
-  errno = ENOTSUP;
-  return -1;
 #else
 # error "Unsupported WASI version"
 #endif

libc-bottom-half/cloudlibc/src/libc/unistd/read.c

@@ -53,9 +53,35 @@ ssize_t read(int fildes, void *buf, size_t nbyte) {
     *off += contents.len;
   return contents.len;
 #elif defined(__wasip3__)
-  // TODO(wasip3)
-  errno = ENOTSUP;
-  return -1;
+  off_t *off;
+  waitable_t waitable;
+  wasip3_waitable_status_t status;
+  if (__wasilibc_read3(fildes, buf, nbyte, &waitable, &status, &off) < 0)
+    return -1;
+  if (status == WASIP3_WAITABLE_STATUS_BLOCKED) {
+    wasip3_waitable_set_t set = wasip3_waitable_set_new();
+    wasip3_waitable_join(waitable, set);
+    wasip3_event_t event;
+    wasip3_waitable_set_wait(set, &event);
+    assert(event.event == WASIP3_EVENT_STREAM_READ);
+    assert(event.waitable == waitable);
+    // remove from set
+    wasip3_waitable_join(waitable, 0);
+    wasip3_waitable_set_drop(set);
+    ssize_t bytes_read = event.code;
+    if (off)
+      *off += bytes_read;
+    return bytes_read;
+  } else if (WASIP3_WAITABLE_STATE(status) == WASIP3_WAITABLE_COMPLETED) {
+    ssize_t bytes_read = WASIP3_WAITABLE_COUNT(status);
+    if (off)
+      *off += bytes_read;
+    return bytes_read;
+  } else if (WASIP3_WAITABLE_STATE(status) == WASIP3_WAITABLE_DROPPED) {
+    return 0;
+  } else {
+    abort();
+  }
 #else
 # error "Unsupported WASI version"
 #endif

libc-bottom-half/cloudlibc/src/libc/unistd/write.c

@@ -5,6 +5,7 @@
 #include <errno.h>
 #include <unistd.h>
 #include <wasi/api.h>
+#include <stdlib.h>
 
 #ifndef __wasip1__
 #include <wasi/descriptor_table.h>
@@ -72,9 +73,33 @@ ssize_t write(int fildes, const void *buf, size_t nbyte) {
     *off += contents.len;
   return contents.len;
 #elif defined(__wasip3__)
-  // TODO(wasip3)
-  errno = ENOTSUP;
-  return -1;
+  off_t *off;
+  waitable_t output_stream;
+  wasip3_waitable_status_t status;
+  if (__wasilibc_write3(fildes, buf, nbyte, &output_stream, &status, &off) < 0)
+    return -1;
+  if (status == WASIP3_WAITABLE_STATUS_BLOCKED) {
+    wasip3_waitable_set_t set = wasip3_waitable_set_new();
+    wasip3_waitable_join(output_stream, set);
+    wasip3_event_t event;
+    wasip3_waitable_set_wait(set, &event);
+    assert(event.event == WASIP3_EVENT_STREAM_WRITE);
+    assert(event.waitable == output_stream);
+    // remove from set
+    wasip3_waitable_join(output_stream, 0);
+    wasip3_waitable_set_drop(set);
+    ssize_t bytes_written = event.code;
+    if (off)
+      *off += bytes_written;
+    return bytes_written;
+  } else if (WASIP3_WAITABLE_STATE(status) == WASIP3_WAITABLE_COMPLETED) {
+    ssize_t bytes_written = WASIP3_WAITABLE_COUNT(status);
+    if (off)
+      *off += bytes_written;
+    return bytes_written;
+  } else {
+    abort();
+  }
 #else
 # error "Unknown WASI version"
 #endif