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

@@ -13,42 +13,51 @@ static int __wasilibc_cwd_mallocd = 0;
 
 int chdir(const char *path)
 {
+  static char *relative_buf = NULL;
+  static size_t relative_buf_len = 0;
+
   // 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;
+  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;
   }
 
   // Make sure that this directory we're accessing is indeed a directory.
   struct stat dirinfo;
-  int ret = fstatat(parent_fd, relative, &dirinfo, 0);
+  int ret = fstatat(parent_fd, relative_buf, &dirinfo, 0);
   if (ret == -1) {
-    free(relative);
     return -1;
   }
   if (!S_ISDIR(dirinfo.st_mode)) {
-    free(relative);
     errno = ENOTDIR;
     return -1;
   }
 
   // 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));
+  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);
-  free(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.

libc-bottom-half/sources/getcwd.c

@@ -10,13 +10,13 @@ char *getcwd(char *buf, size_t size)
     buf = strdup(__wasilibc_cwd);
     if (!buf) {
       errno = ENOMEM;
-      return -1;
+      return NULL;
     }
   } else {
     size_t len = strlen(__wasilibc_cwd);
     if (size < strlen(__wasilibc_cwd) + 1) {
       errno = ERANGE;
-      return 0;
+      return NULL;
     }
     strcpy(buf, __wasilibc_cwd);
   }