Protect preopens.c against concurrent access

Author: abrown

libc-bottom-half/sources/preopens.c

@@ -2,14 +2,11 @@
 //! environment, with associated path prefixes, which can be used to map
 //! absolute paths to capabilities with relative paths.
 
-#ifdef _REENTRANT
-//#error "__wasilibc_register_preopened_fd doesn't yet support multiple threads"
-#endif
-
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
+#include <lock.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
@@ -32,6 +29,10 @@ static preopen *preopens;
 static size_t num_preopens;
 static size_t preopen_capacity;
 
+/// Access to the the above preopen must be protected in the presence of
+/// threads.
+static volatile int lock[1];
+
 #ifdef NDEBUG
 #define assert_invariants() // assertions disabled
 #else
@@ -55,13 +56,15 @@ static void assert_invariants(void) {
 
 /// Allocate space for more preopens. Returns 0 on success and -1 on failure.
 static int resize(void) {
+    LOCK(lock);
     size_t start_capacity = 4;
     size_t old_capacity = preopen_capacity;
     size_t new_capacity = old_capacity == 0 ? start_capacity : old_capacity * 2;
 
     preopen *old_preopens = preopens;
     preopen *new_preopens = calloc(sizeof(preopen), new_capacity);
     if (new_preopens == NULL)
+        UNLOCK(lock);
         return -1;
 
     memcpy(new_preopens, old_preopens, num_preopens * sizeof(preopen));
@@ -70,6 +73,7 @@ static int resize(void) {
     free(old_preopens);
 
     assert_invariants();
+    UNLOCK(lock);
     return 0;
 }
 
@@ -97,21 +101,26 @@ static const char *strip_prefixes(const char *path) {
 ///
 /// This function takes ownership of `prefix`.
 static int internal_register_preopened_fd(__wasi_fd_t fd, const char *relprefix) {
+    LOCK(lock);
+
     // Check preconditions.
     assert_invariants();
     assert(fd != AT_FDCWD);
     assert(fd != -1);
     assert(relprefix != NULL);
 
     if (num_preopens == preopen_capacity && resize() != 0)
+        UNLOCK(lock);
         return -1;
 
     char *prefix = strdup(strip_prefixes(relprefix));
     if (prefix == NULL)
+        UNLOCK(lock);
         return -1;
     preopens[num_preopens++] = (preopen) { prefix, fd, };
 
     assert_invariants();
+    UNLOCK(lock);
     return 0;
 }
 
@@ -166,6 +175,7 @@ int __wasilibc_find_abspath(const char *path,
     // recently added preopens take precedence over less recently addded ones.
     size_t match_len = 0;
     int fd = -1;
+    LOCK(lock);
     for (size_t i = num_preopens; i > 0; --i) {
         const preopen *pre = &preopens[i - 1];
         const char *prefix = pre->prefix;
@@ -182,6 +192,7 @@ int __wasilibc_find_abspath(const char *path,
             *abs_prefix = prefix;
         }
     }
+    UNLOCK(lock);
 
     if (fd == -1) {
         errno = ENOENT;