[WasmFS] Implement select() system call in terms of poll() (#25965)

This change also adds some testing of select to `test/unistd/pipe.c`
where there was none before.

Author: sbc100

system/lib/wasmfs/syscalls.cpp

@@ -1769,15 +1769,86 @@ int __syscall_fadvise64(int fd, off_t offset, off_t length, int advice) {
 }
 
 int __syscall__newselect(int nfds,
-                         intptr_t readfds_,
-                         intptr_t writefds_,
-                         intptr_t exceptfds_,
-                         intptr_t timeout_) {
-  // TODO: Implement this syscall. For now, we return an error code,
-  //       specifically ENOMEM which is valid per the docs:
-  //          ENOMEM Unable to allocate memory for internal tables
-  //          https://man7.org/linux/man-pages/man2/select.2.html
-  return -ENOMEM;
+                         intptr_t _readfds,
+                         intptr_t _writefds,
+                         intptr_t _exceptfds,
+                         intptr_t _timeout) {
+  // Implement select in terms of `poll()`
+
+  // Part 1: convert select arguments into poll arguments
+  fd_set* readfds = (fd_set*)_readfds;
+  fd_set* writefds = (fd_set*)_writefds;
+  fd_set* exceptfds = (fd_set*)_exceptfds;
+  timeval* timeout = (timeval*)_timeout;
+
+  int n = 0;
+  struct pollfd* fds = (struct pollfd*)calloc(nfds, sizeof(struct pollfd));
+
+  for (int i = 0; i < nfds; i++) {
+    if (readfds && FD_ISSET(i, readfds)) {
+      fds[n].events |= POLLIN;
+    }
+    if (writefds && FD_ISSET(i, writefds)) {
+      fds[n].events |= POLLOUT;
+    }
+    if (exceptfds && FD_ISSET(i, exceptfds)) {
+      fds[n].events |= POLLPRI;
+    }
+    if (fds[n].events) {
+      fds[n].fd = i;
+      n++;
+    }
+  }
+
+  // __syscall_poll currently ignores timeout but we calculate it here for
+  // completeness.
+  int timeout_ms = -1; // Infinite
+  if (timeout) {
+    timeout_ms = (timeout->tv_sec * 1000) + ((timeout->tv_usec + 999) / 1000);
+  }
+
+  int rtn = __syscall_poll((intptr_t)fds, n, timeout_ms);
+  if (rtn < 0) {
+    free(fds);
+    return -1;
+  }
+
+  // Part 2: Translate the result of poll into the results of select();
+
+  if (readfds)   FD_ZERO(readfds);
+  if (writefds)  FD_ZERO(writefds);
+  if (exceptfds) FD_ZERO(exceptfds);
+
+  int count = 0;
+
+  if (rtn > 0) {
+    for (int i = 0; i < n; i++) {
+      int fd = fds[i].fd;
+      short revents = fds[i].revents;
+      if (revents) {
+        // Map POLLIN to readfds
+        // POLLHUP/POLLERR usually count as readable (EOF or Error)
+        if (readfds && (revents & POLLIN || revents & POLLHUP || revents & POLLERR)) {
+          FD_SET(fd, readfds);
+          count++;
+        }
+        // Map POLLOUT to writefds
+        // POLLERR usually counts as writable (so write fails immediately)
+        if (writefds && (revents & POLLOUT || revents & POLLERR)) {
+          FD_SET(fd, writefds);
+          count++;
+        }
+        // Map POLLPRI to exceptfds
+        if (exceptfds && (revents & POLLPRI)) {
+          FD_SET(fd, exceptfds);
+          count++;
+        }
+      }
+    }
+  }
+
+  free(fds);
+  return count;
 }
 
 } // extern "C"

test/unistd/pipe.c

@@ -6,6 +6,7 @@
  */
 
 #include <unistd.h>
+#include <stdbool.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -17,8 +18,8 @@
 
 unsigned char buf[1 << 16];
 
-#define FALSE 0
-#define TRUE 1
+#define MAX(a, b) (((a) >= (b)) ? (a) : (b))
+
 
 // This test program relies on the simplest read/write behavior when
 // all the data can be read/written in one call.
@@ -40,6 +41,37 @@ void test_read(int fd0, unsigned char *ch, int size) {
   }
 }
 
+// test_select and test_poll perform the exact same actions/assertions but
+// with two different system calls.  They should always give the same
+// retult.
+
+void test_select(int *fd, bool data_available) {
+  fd_set rfds;
+  FD_ZERO(&rfds);
+  FD_SET(fd[0], &rfds);
+  FD_SET(fd[1], &rfds);
+
+  fd_set wfds;
+  FD_ZERO(&wfds);
+  FD_SET(fd[0], &wfds);
+  FD_SET(fd[1], &wfds);
+
+  // Don't block at all
+  struct timeval tv = { 0, 0};
+  int maxfd = MAX(fd[0], fd[1]) + 1;
+  int ret = select(maxfd, &rfds, &wfds, NULL, &tv);
+
+  if (data_available) {
+    assert(ret == 2);
+    assert(FD_ISSET(fd[0], &rfds));
+  } else {
+    assert(ret == 1);
+    assert(!FD_ISSET(fd[0], &rfds));
+  }
+
+  assert(FD_ISSET(fd[1], &wfds));
+}
+
 void test_poll(int *fd, int data_available) {
   struct pollfd pfds[2];
   memset(pfds, 0, sizeof pfds);
@@ -57,6 +89,9 @@ void test_poll(int *fd, int data_available) {
     assert(pfds[0].revents == 0);
   }
   assert(pfds[1].revents == POLLOUT);
+
+  // select should report the exact same status.
+  test_select(fd, data_available);
 }
 
 int test_most() {
@@ -86,13 +121,13 @@ int test_most() {
   // write about 40 Kb of data
   for (int i = 1; i < 200; ++i) {
     test_write(fd[1], &wchar, i + 2);
-    test_poll(fd, TRUE);
+    test_poll(fd, true);
     test_read (fd[0], &rchar, i);
-    test_poll(fd, TRUE);
+    test_poll(fd, true);
     test_write(fd[1], &wchar, i + 1);
-    test_poll(fd, TRUE);
+    test_poll(fd, true);
     test_read (fd[0], &rchar, i + 3);
-    test_poll(fd, FALSE);
+    test_poll(fd, false);
   }
 
   // Test reading when there is less data available than the read buffer size
@@ -126,11 +161,11 @@ int test_most() {
 #endif
 
   // Normal operations still work in non-blocking mode
-  test_poll(fd, FALSE);
+  test_poll(fd, false);
   test_write(fd[1], &wchar, 10);
-  test_poll(fd, TRUE);
+  test_poll(fd, true);
   test_read (fd[0], &rchar, 10);
-  test_poll(fd, FALSE);
+  test_poll(fd, false);
 
   // Clear buffer
   memset(buf, 0, sizeof(buf));