wasip2: Close handles in stream-error (WebAssembly#675)

If a stream-related operation fails and it's not "closed" then there's
an `own` resource within the error. Previously this leaked in wasi-libc
but now it's deallocated on-the-spot. Error handling is also
deduplicated across a few locations.

Author: alexcrichton

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

@@ -32,15 +32,8 @@ ssize_t read(int fildes, void *buf, size_t nbyte) {
                                                  nbyte,
                                                  &contents,
                                                  &stream_error);
-
-  if (!ok) {
-    if (stream_error.tag == STREAMS_STREAM_ERROR_CLOSED)
-      return 0;
-    else {
-      errno = EIO;
-      return -1;
-    }
-  }
+  if (!ok)
+    return wasip2_handle_read_error(stream_error);
 
   // Copy the bytes allocated in the canonical ABI to `buf`
   memcpy(buf, contents.ptr, contents.len);

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

@@ -34,10 +34,8 @@ ssize_t write(int fildes, const void *buf, size_t nbyte) {
     ok = streams_method_output_stream_check_write(output_stream,
                                                   &num_bytes_permitted,
                                                   &stream_error);
-    if (!ok) {
-      errno = EIO;
-      return -1;
-    }
+    if (!ok)
+      return wasip2_handle_write_error(stream_error);
 
     if (num_bytes_permitted == 0)
       poll_method_pollable_block(pollable);
@@ -52,17 +50,14 @@ ssize_t write(int fildes, const void *buf, size_t nbyte) {
   ok = streams_method_output_stream_write(output_stream,
                                           &contents,
                                           &stream_error);
-  if (!ok) {
-    errno = EIO;
-    return -1;
-  }
+  if (!ok)
+    return wasip2_handle_write_error(stream_error);
 
   ok = streams_method_output_stream_blocking_flush(output_stream,
                                                    &stream_error);
-  if (!ok) {
-    errno = EIO;
-    return -1;
-  }
+  if (!ok)
+    return wasip2_handle_write_error(stream_error);
+
 
   if (off)
     *off += contents.len;

libc-bottom-half/headers/private/wasi/file_utils.h

@@ -2,11 +2,40 @@
 #define __wasi_file_utils_h
 
 #ifdef __wasilibc_use_wasip2
+#include <assert.h>
+#include <wasi/wasip2.h>
 #include <wasi/descriptor_table.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <errno.h>
 
+/// Handles a `wasi:io/streams.stream-error` for a `read`-style operation.
+///
+/// If the error indicates "closed" then 0 is returned to mean EOF. Otherwise
+/// the last-operation-failed handle is closed and errno is set to EIO.
+static int wasip2_handle_read_error(streams_stream_error_t error) {
+  if (error.tag == STREAMS_STREAM_ERROR_CLOSED) {
+    return 0;
+  }
+  assert(error.tag == STREAMS_STREAM_ERROR_LAST_OPERATION_FAILED);
+  io_error_error_drop_own(error.val.last_operation_failed);
+  errno = EIO;
+  return -1;
+}
+
+/// Same as `wasip2_handle_read_error` except "closed" now returns EPIPE
+/// instead of 0.
+static int wasip2_handle_write_error(streams_stream_error_t error) {
+  if (error.tag == STREAMS_STREAM_ERROR_CLOSED) {
+    errno = EPIPE;
+    return -1;
+  }
+  assert(error.tag == STREAMS_STREAM_ERROR_LAST_OPERATION_FAILED);
+  io_error_error_drop_own(error.val.last_operation_failed);
+  errno = EIO;
+  return -1;
+}
+
 // Converts the C string `s` into a WASI string stored in `out`.
 //
 // The returned `wasip2_string_t` should not be deallocated or free'd, and it

libc-bottom-half/sources/wasip2_tcp.c

@@ -8,6 +8,7 @@
 #include <wasi/sockets_utils.h>
 #include <wasi/tcp.h>
 #include <wasi/wasip2.h>
+#include <wasi/file_utils.h>
 
 const uint64_t NS_PER_S = 1000000000;
 
@@ -535,15 +536,9 @@ static ssize_t tcp_recvfrom(void *data, void *buffer,
   while (true) {
     wasip2_list_u8_t result;
     streams_stream_error_t error;
-    if (!streams_method_input_stream_read(rx_borrow, length, &result, &error)) {
-      if (error.tag == STREAMS_STREAM_ERROR_CLOSED) {
-        return 0;
-      } else {
-        // TODO wasi-sockets: wasi-sockets has no way to recover TCP stream errors yet.
-        errno = EPIPE;
-        return -1;
-      }
-    }
+    if (!streams_method_input_stream_read(rx_borrow, length, &result, &error))
+      // TODO wasi-sockets: wasi-sockets has no way to recover TCP stream errors yet.
+      return wasip2_handle_read_error(error);
 
     if (result.len) {
       memcpy(buffer, result.ptr, result.len);
@@ -624,19 +619,16 @@ static ssize_t tcp_sendto(void *data, const void *buffer,
   while (true) {
     streams_stream_error_t error;
     uint64_t count;
-    if (!streams_method_output_stream_check_write(tx_borrow, &count, &error)) {
+    if (!streams_method_output_stream_check_write(tx_borrow, &count, &error))
       // TODO wasi-sockets: wasi-sockets has no way to recover stream errors yet.
-      errno = EPIPE;
-      return -1;
-    }
+      return wasip2_handle_write_error(error);
 
     if (count) {
       count = count < length ? count : length;
       wasip2_list_u8_t list = { .ptr = (uint8_t *)buffer, .len = count };
       if (!streams_method_output_stream_write(tx_borrow, &list, &error)) {
         // TODO wasi-sockets: wasi-sockets has no way to recover TCP stream errors yet.
-        errno = EPIPE;
-        return -1;
+        return wasip2_handle_write_error(error);
       } else {
         return count;
       }