Amortize mallocs made in syscalls

Author: alexcrichton

libc-bottom-half/headers/public/wasi/libc-find-relpath.h

@@ -10,18 +10,19 @@ extern "C" {
  * map. If a suitable entry is found, then the file descriptor for that entry
  * is returned. Additionally the absolute path of the directory's file
  * descriptor is returned in `abs_prefix` and the relative portion that needs
- * to be opened is stored in `relative_path`.
+ * to be opened is stored in `relative_path`. The size of the `relative_path`
+ * buffer is provided in the `relative_path_len` argument.
  *
- * Returns -1 if no directories were suitable or if an allocation error
- * happens.
+ * Returns -1 on failure. Errno is set to either:
  *
- * On success the `relative_path` points to a malloc'd string, so you'll
- * need to call `free` on it. The `abs_prefix` return does not need to be
- * free'd.
+ *  * ENOMEM - failed to allocate memory for internal routines.
+ *  * ENOENT - the `path` could not be found relative to any preopened dir.
+ *  * ERANGE - the `relative_path` buffer is too small to hold the relative path.
  */
 int __wasilibc_find_relpath(const char *path,
                             const char **__restrict__ abs_prefix,
-                            char **__restrict__ relative_path);
+                            char *relative_path,
+                            size_t relative_path_len);
 
 #ifdef __cplusplus
 }

libc-bottom-half/sources/chdir.c

@@ -8,54 +8,63 @@
 #include <wasi/libc-find-relpath.h>
 #include <wasi/libc.h>
 
-char *__wasilibc_cwd = "/";
+extern char *__wasilibc_cwd;
 static int __wasilibc_cwd_mallocd = 0;
 
 int chdir(const char *path)
 {
-  // Find a preopen'd directory as well as a relative path we're anchored
-  // from which we're changing directories to.
-  char *relative;
-  const char *abs;
-  int parent_fd = __wasilibc_find_relpath(path, &abs, &relative);
-  if (parent_fd == -1) {
-    errno = ENOENT;
-    return -1;
-  }
+    static char *relative_buf = NULL;
+    static size_t relative_buf_len = 0;
 
-  // Make sure that this directory we're accessing is indeed a directory.
-  struct stat dirinfo;
-  int ret = fstatat(parent_fd, relative, &dirinfo, 0);
-  if (ret == -1) {
-    free(relative);
-    return -1;
-  }
-  if (!S_ISDIR(dirinfo.st_mode)) {
-    free(relative);
-    errno = ENOTDIR;
-    return -1;
-  }
+    // Find a preopen'd directory as well as a relative path we're anchored
+    // from which we're changing directories to.
+    const char *abs;
+    int parent_fd;
+    while (1) {
+        parent_fd = __wasilibc_find_relpath(path, &abs, relative_buf, relative_buf_len);
+        if (parent_fd != -1)
+            break;
+        if (errno != ERANGE)
+            return -1;
+        size_t new_len = relative_buf_len == 0 ? 16 : 2 * relative_buf_len;
+        relative_buf = realloc(relative_buf, new_len);
+        if (relative_buf == NULL) {
+            errno = ENOMEM;
+            return -1;
+        }
+        relative_buf_len = new_len;
+    }
 
-  // Copy over our new absolute path into `__wasilibc_cwd`. Only copy over
-  // the relative portion of the path if it's not equal to `.`
-  size_t len = strlen(abs);
-  int copy_relative = strcmp(relative, ".") != 0;
-  char *new_cwd = malloc(len + (copy_relative ? strlen(relative) : 0));
-  if (new_cwd == NULL) {
-    errno = ENOMEM;
-    return -1;
-  }
-  strcpy(new_cwd, abs);
-  if (copy_relative)
-    strcpy(new_cwd + strlen(abs), relative);
-  free(relative);
+    // Make sure that this directory we're accessing is indeed a directory.
+    struct stat dirinfo;
+    int ret = fstatat(parent_fd, relative_buf, &dirinfo, 0);
+    if (ret == -1) {
+        return -1;
+    }
+    if (!S_ISDIR(dirinfo.st_mode)) {
+        errno = ENOTDIR;
+        return -1;
+    }
 
-  // And set our new malloc'd buffer into the global cwd, freeing the
-  // previous one if necessary.
-  char *prev_cwd = __wasilibc_cwd;
-  __wasilibc_cwd = new_cwd;
-  if (__wasilibc_cwd_mallocd)
-    free(prev_cwd);
-  __wasilibc_cwd_mallocd = 1;
-  return 0;
+    // Copy over our new absolute path into `__wasilibc_cwd`. Only copy over
+    // the relative portion of the path if it's not equal to `.`
+    size_t len = strlen(abs);
+    int copy_relative = strcmp(relative_buf, ".") != 0;
+    char *new_cwd = malloc(len + (copy_relative ? strlen(relative_buf) : 0));
+    if (new_cwd == NULL) {
+        errno = ENOMEM;
+        return -1;
+    }
+    strcpy(new_cwd, abs);
+    if (copy_relative)
+        strcpy(new_cwd + strlen(abs), relative_buf);
+
+    // And set our new malloc'd buffer into the global cwd, freeing the
+    // previous one if necessary.
+    char *prev_cwd = __wasilibc_cwd;
+    __wasilibc_cwd = new_cwd;
+    if (__wasilibc_cwd_mallocd)
+        free(prev_cwd);
+    __wasilibc_cwd_mallocd = 1;
+    return 0;
 }

libc-bottom-half/sources/getcwd.c

@@ -2,24 +2,24 @@
 #include <errno.h>
 #include <string.h>
 
-extern char *__wasilibc_cwd;
+char *__wasilibc_cwd = "/";
 
 char *getcwd(char *buf, size_t size)
 {
-  if (!buf) {
-    buf = strdup(__wasilibc_cwd);
     if (!buf) {
-      errno = ENOMEM;
-      return -1;
+        buf = strdup(__wasilibc_cwd);
+        if (!buf) {
+            errno = ENOMEM;
+            return NULL;
+        }
+    } else {
+        size_t len = strlen(__wasilibc_cwd);
+        if (size < strlen(__wasilibc_cwd) + 1) {
+            errno = ERANGE;
+            return NULL;
+        }
+        strcpy(buf, __wasilibc_cwd);
     }
-  } else {
-    size_t len = strlen(__wasilibc_cwd);
-    if (size < strlen(__wasilibc_cwd) + 1) {
-      errno = ERANGE;
-      return 0;
-    }
-    strcpy(buf, __wasilibc_cwd);
-  }
-  return buf;
+    return buf;
 }