xbintsc 0.5.20 → 0.5.21

package/runtime/ext_node/fs/async_complete.c

@@ -0,0 +1,99 @@
+/*
+ * Main-thread half of `fs/promises`: turn worker results into values.
+ *
+ * Runs on the reactor thread, so `xt_value` construction, promise settlement
+ * and the collector are all safe here. Everything the job owns is freed by
+ * `xt_fs_job_release` after this returns (except the entry table handed over to
+ * a `Dir` object).
+ */
+
+#include "async_job.h"
+
+static void xt_fs_job_resolve(xt_fs_job *job, xt_value value) {
+  xt_promise_fulfill(job->base.roots[0], value);
+}
+
+static void xt_fs_job_reject(xt_fs_job *job) {
+  xt_value error = xt_fs_error_object(job->err, job->syscall, job->error_path);
+  xt_promise_reject_value(job->base.roots[0], error);
+}
+
+static xt_value xt_fs_statfs_value(const long long *numbers) {
+  xt_value object = xt_object_new();
+  xt_object_set(object, xt_string_from_cstr("type"), xt_number((double)numbers[0]));
+  xt_object_set(object, xt_string_from_cstr("bsize"), xt_number((double)numbers[1]));
+  xt_object_set(object, xt_string_from_cstr("blocks"), xt_number((double)numbers[2]));
+  xt_object_set(object, xt_string_from_cstr("bfree"), xt_number((double)numbers[3]));
+  xt_object_set(object, xt_string_from_cstr("bavail"), xt_number((double)numbers[4]));
+  xt_object_set(object, xt_string_from_cstr("files"), xt_number((double)numbers[5]));
+  xt_object_set(object, xt_string_from_cstr("ffree"), xt_number((double)numbers[6]));
+  return object;
+}
+
+static xt_value xt_fs_readdir_value(xt_fs_job *job) {
+  xt_value list = xt_array_new(0, NULL);
+  for (size_t i = 0; i < job->entry_count; i++) {
+    xt_fs_entry *entry = &job->entries[i];
+    if (job->with_types) {
+      xt_array_push(list, xt_node_dirent_named(entry->bare ? entry->bare : entry->name, entry->mode));
+    } else {
+      xt_array_push(list, xt_string_from_cstr(entry->name));
+    }
+  }
+  return list;
+}
+
+static xt_value xt_fs_glob_value(xt_fs_job *job) {
+  xt_value list = xt_array_new(0, NULL);
+  for (size_t i = 0; i < job->entry_count; i++) {
+    xt_array_push(list, xt_string_from_cstr(job->entries[i].name));
+  }
+  return list;
+}
+
+static xt_value xt_fs_read_bytes_value(xt_fs_job *job) {
+  return xt_fs_encode_bytes(job->bytes, job->bytes_length, job->text);
+}
+
+static void xt_fs_fd_read_complete(xt_fs_job *job) {
+  xt_value buffer = job->base.roots[1];
+  uint32_t offset = (uint32_t)job->offset;
+  for (size_t i = 0; i < job->bytes_length; i++) {
+    xt_node_buffer_set(buffer, offset + (uint32_t)i, job->bytes[i]);
+  }
+  xt_fs_job_resolve(job, xt_number((double)job->bytes_length));
+}
+
+void xt_fs_job_complete(xt_async_job *base) {
+  xt_fs_job *job = (xt_fs_job *)base;
+  if (job->err) {
+    xt_fs_job_reject(job);
+    return;
+  }
+  switch (job->kind) {
+    case XT_FS_JOB_READ_FILE:
+    case XT_FS_JOB_FD_READ_FILE: xt_fs_job_resolve(job, xt_fs_read_bytes_value(job)); break;
+    case XT_FS_JOB_READDIR: xt_fs_job_resolve(job, xt_fs_readdir_value(job)); break;
+    case XT_FS_JOB_GLOB: xt_fs_job_resolve(job, xt_fs_glob_value(job)); break;
+    case XT_FS_JOB_OPENDIR: {
+      xt_value dir = xt_node_dir_from_entries(job->path, job->entries, job->entry_count);
+      job->entries = NULL;
+      job->entry_count = 0;
+      xt_fs_job_resolve(job, dir);
+      break;
+    }
+    case XT_FS_JOB_REALPATH:
+    case XT_FS_JOB_READLINK:
+    case XT_FS_JOB_MKDTEMP:
+      xt_fs_job_resolve(job, job->string ? xt_string_from_cstr(job->string) : XT_UNDEFINED);
+      break;
+    case XT_FS_JOB_STAT:
+    case XT_FS_JOB_LSTAT:
+    case XT_FS_JOB_FD_STAT: xt_fs_job_resolve(job, xt_node_stat_result(&job->stat)); break;
+    case XT_FS_JOB_STATFS: xt_fs_job_resolve(job, xt_fs_statfs_value(job->numbers)); break;
+    case XT_FS_JOB_OPEN: xt_fs_job_resolve(job, xt_fh_new(xt_number((double)job->result_fd))); break;
+    case XT_FS_JOB_FD_READ: xt_fs_fd_read_complete(job); break;
+    case XT_FS_JOB_FD_WRITE: xt_fs_job_resolve(job, xt_number((double)job->written)); break;
+    default: xt_fs_job_resolve(job, XT_UNDEFINED); break;
+  }
+}

package/runtime/ext_node/fs/async_fh.c

@@ -0,0 +1,206 @@
+/*
+ * `FileHandle` for `fs/promises`, backed by the async I/O pool.
+ *
+ * The handle is a plain object with an `fd` property and the usual methods;
+ * each method marshals its arguments and submits an `XT_FS_JOB_FD_*` job, so a
+ * read, write, fsync or close never blocks the reactor. `read` keeps the target
+ * `Buffer` rooted in `roots[1]` while the worker fills a temporary byte array.
+ */
+
+#include "async_job.h"
+
+#include <errno.h>
+
+static int32_t xt_fh_fd(xt_value thisValue) { return (int32_t)xt_to_number(xt_object_get_cstr(thisValue, "fd")); }
+
+static xt_value xt_fh_invalid_buffer(void) {
+  return xt_promise_reject(xt_fs_error_object(EINVAL, "read", NULL));
+}
+
+static xt_value xt_fh_submit(xt_fs_job *job) { return xt_fs_job_submit(job); }
+
+static xt_value xt_fh_read(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 1 || !xt_node_is_buffer(argv[0])) return xt_fh_invalid_buffer();
+  xt_value buffer = argv[0];
+  uint32_t bufferLength = xt_node_buffer_length(buffer);
+  uint32_t offset = argc > 1 ? (uint32_t)xt_to_number(argv[1]) : 0;
+  uint32_t length = argc > 2 ? (uint32_t)xt_to_number(argv[2]) : (bufferLength > offset ? bufferLength - offset : 0);
+  int64_t position =
+      argc > 3 && !XT_IS_UNDEFINED(argv[3]) && !XT_IS_NULL(argv[3]) ? (int64_t)xt_to_number(argv[3]) : -1;
+  if (offset > bufferLength) offset = bufferLength;
+  if (length > bufferLength - offset) length = bufferLength - offset;
+
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_READ);
+  job->fd = xt_fh_fd(thisValue);
+  job->offset = (long long)offset;
+  job->length = (long long)length;
+  job->position = (long long)position;
+  job->base.roots[1] = buffer;
+  return xt_fh_submit(job);
+}
+
+/* Copy `data` into a flat byte array the worker can read. */
+static unsigned char *xt_fh_bytes(xt_value data, xt_value options, size_t *outLength, int *isBuffer) {
+  if (xt_node_is_buffer(data)) {
+    *isBuffer = 1;
+    return xt_node_buffer_bytes(data, outLength);
+  }
+  *isBuffer = 0;
+  xt_value text = xt_to_string(data);
+  const char *bytes = xt_string_data(text);
+  int32_t length = xt_string_length_value(text);
+  if (!bytes || length < 0) {
+    *outLength = 0;
+    return NULL;
+  }
+  const char *encoding = xt_fs_encoding(options);
+  return xt_fs_decode_text(bytes, (size_t)length, encoding, outLength);
+}
+
+static xt_value xt_fh_write(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  size_t length = 0;
+  int isBuffer = 0;
+  unsigned char *bytes = xt_fh_bytes(argv[0], argc > 2 ? argv[2] : XT_UNDEFINED, &length, &isBuffer);
+  uint32_t offset = 0;
+  uint32_t writeLength = (uint32_t)length;
+  int64_t position = -1;
+  if (isBuffer) {
+    if (argc > 1 && !XT_IS_UNDEFINED(argv[1]) && !XT_IS_NULL(argv[1])) offset = (uint32_t)xt_to_number(argv[1]);
+    if (argc > 2 && !XT_IS_UNDEFINED(argv[2]) && !XT_IS_NULL(argv[2])) writeLength = (uint32_t)xt_to_number(argv[2]);
+    if (argc > 3 && !XT_IS_UNDEFINED(argv[3]) && !XT_IS_NULL(argv[3])) position = (int64_t)xt_to_number(argv[3]);
+  } else if (argc > 1 && !XT_IS_UNDEFINED(argv[1]) && !XT_IS_NULL(argv[1])) {
+    position = (int64_t)xt_to_number(argv[1]);
+  }
+  if (offset > length) offset = (uint32_t)length;
+  if (writeLength > length - offset) writeLength = (uint32_t)length - offset;
+
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_WRITE);
+  job->fd = xt_fh_fd(thisValue);
+  job->position = (long long)position;
+  if (writeLength > 0 && bytes) {
+    job->data = (unsigned char *)malloc(writeLength);
+    if (!job->data) abort();
+    memcpy(job->data, bytes + offset, writeLength);
+    job->data_length = writeLength;
+  }
+  free(bytes);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_write_file(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  size_t length = 0;
+  int isBuffer = 0;
+  unsigned char *bytes = xt_fh_bytes(argv[0], argc > 1 ? argv[1] : XT_UNDEFINED, &length, &isBuffer);
+  (void)isBuffer;
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_WRITE_FILE);
+  job->fd = xt_fh_fd(thisValue);
+  job->data = bytes;
+  job->data_length = length;
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_read_file(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_READ_FILE);
+  job->fd = xt_fh_fd(thisValue);
+  job->text = xt_fs_copy_cstr(argc > 0 ? xt_fs_encoding(argv[0]) : NULL);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_close(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_CLOSE);
+  job->fd = xt_fh_fd(thisValue);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_stat(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_STAT);
+  job->fd = xt_fh_fd(thisValue);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_truncate(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_TRUNCATE);
+  job->fd = xt_fh_fd(thisValue);
+  job->length = (long long)xt_to_number(argv[0]);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_chmod(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_CHMOD);
+  job->fd = xt_fh_fd(thisValue);
+  job->mode = (int)xt_to_number(argv[0]);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_chown(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_CHOWN);
+  job->fd = xt_fh_fd(thisValue);
+  job->uid = (int)xt_to_number(argv[0]);
+  job->gid = (int)xt_to_number(argv[1]);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_utimes(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_UTIMES);
+  job->fd = xt_fh_fd(thisValue);
+  job->atime = xt_fs_time_seconds(argv[0]);
+  job->mtime = xt_fs_time_seconds(argv[1]);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_sync(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_SYNC);
+  job->fd = xt_fh_fd(thisValue);
+  return xt_fh_submit(job);
+}
+
+static xt_value xt_fh_datasync(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_FD_DATASYNC);
+  job->fd = xt_fh_fd(thisValue);
+  return xt_fh_submit(job);
+}
+
+xt_value xt_fh_new(xt_value fdValue) {
+  xt_value handle = xt_object_new();
+  xt_node_set(handle, "fd", fdValue);
+  xt_node_define_method(handle, "read", (void *)xt_fh_read);
+  xt_node_define_method(handle, "write", (void *)xt_fh_write);
+  xt_node_define_method(handle, "readFile", (void *)xt_fh_read_file);
+  xt_node_define_method(handle, "writeFile", (void *)xt_fh_write_file);
+  xt_node_define_method(handle, "appendFile", (void *)xt_fh_write_file);
+  xt_node_define_method(handle, "close", (void *)xt_fh_close);
+  xt_node_define_method(handle, "stat", (void *)xt_fh_stat);
+  xt_node_define_method(handle, "truncate", (void *)xt_fh_truncate);
+  xt_node_define_method(handle, "chmod", (void *)xt_fh_chmod);
+  xt_node_define_method(handle, "chown", (void *)xt_fh_chown);
+  xt_node_define_method(handle, "utimes", (void *)xt_fh_utimes);
+  xt_node_define_method(handle, "sync", (void *)xt_fh_sync);
+  xt_node_define_method(handle, "datasync", (void *)xt_fh_datasync);
+  return handle;
+}

package/runtime/ext_node/fs/async_job.c

@@ -0,0 +1,81 @@
+/*
+ * Lifecycle helpers for asynchronous `fs/promises` jobs.
+ *
+ * Allocation, submission, failure bookkeeping and release are shared by the
+ * argument marshalling (async_api.c), the FileHandle surface (async_fh.c), the
+ * worker (async_worker.c) and the completion handler (async_complete.c).
+ */
+
+#include "async_job.h"
+
+#include <errno.h>
+
+char *xt_fs_copy_cstr(const char *text) {
+  if (!text) return NULL;
+  size_t length = strlen(text);
+  char *copy = (char *)malloc(length + 1);
+  if (!copy) return NULL;
+  memcpy(copy, text, length + 1);
+  return copy;
+}
+
+char *xt_fs_take_string(xt_value value) {
+  if (XT_IS_UNDEFINED(value) || XT_IS_NULL(value)) return NULL;
+  xt_value text = xt_to_string(value);
+  const char *data = xt_string_data(text);
+  if (!data) return NULL;
+  size_t length = (size_t)xt_string_length_value(text);
+  char *copy = (char *)malloc(length + 1);
+  if (!copy) return NULL;
+  memcpy(copy, data, length);
+  copy[length] = '\0';
+  return copy;
+}
+
+xt_fs_job *xt_fs_job_new(xt_fs_job_kind kind) {
+  xt_fs_job *job = (xt_fs_job *)calloc(1, sizeof(xt_fs_job));
+  if (!job) abort();
+  job->base.run = xt_fs_job_run;
+  job->base.complete = xt_fs_job_complete;
+  job->base.release = xt_fs_job_release;
+  job->kind = kind;
+  job->fd = -1;
+  return job;
+}
+
+xt_value xt_fs_job_submit(xt_fs_job *job) {
+  xt_value promise = xt_promise_create();
+  job->base.roots[0] = promise;
+  xt_async_submit(&job->base);
+  return promise;
+}
+
+/* Record the errno of a just-failed worker syscall. `error_path` aliases a
+ * job-owned string, so release() must not free it separately. */
+void xt_fs_job_fail(xt_fs_job *job, int err, const char *syscall, const char *path) {
+  job->err = err ? err : EIO;
+  job->syscall = syscall;
+  job->error_path = (char *)path;
+}
+
+void xt_fs_job_release(xt_async_job *base) {
+  xt_fs_job *job = (xt_fs_job *)base;
+  free(job->path);
+  free(job->path2);
+  free(job->text);
+  if (job->patterns) {
+    for (size_t i = 0; i < job->pattern_count; i++) free(job->patterns[i]);
+    free(job->patterns);
+  }
+  free(job->data);
+  free(job->bytes);
+  free(job->string);
+  if (job->entries) {
+    for (size_t i = 0; i < job->entry_count; i++) {
+      free(job->entries[i].name);
+      if (job->entries[i].bare != job->entries[i].name) free(job->entries[i].bare);
+    }
+    free(job->entries);
+  }
+  free(job);
+}

package/runtime/ext_node/fs/async_job.h

@@ -0,0 +1,132 @@
+/*
+ * Shared job model for the asynchronous `fs/promises` implementation.
+ *
+ * The promise API deliberately splits work in two halves:
+ *
+ *   - the worker half (async_worker.c) performs blocking syscalls and writes
+ *     plain C results into `xt_fs_job`;
+ *   - the main-thread half (async_complete.c) turns those results into
+ *     `xt_value`s, settles the promise and frees the job.
+ *
+ * Argument marshalling lives in async_api.c and the FileHandle surface in
+ * async_fh.c. Keeping the split explicit is what lets `await` yield while a
+ * large read or a slow network filesystem is in flight.
+ */
+#ifndef XT_NODE_FS_ASYNC_JOB_H
+#define XT_NODE_FS_ASYNC_JOB_H
+
+#include "../node_common.h"
+#include "fs_common.h"
+
+typedef enum {
+  XT_FS_JOB_READ_FILE,
+  XT_FS_JOB_WRITE_FILE,
+  XT_FS_JOB_MKDIR,
+  XT_FS_JOB_READDIR,
+  XT_FS_JOB_RM,
+  XT_FS_JOB_UNLINK,
+  XT_FS_JOB_RMDIR,
+  XT_FS_JOB_RENAME,
+  XT_FS_JOB_COPY_FILE,
+  XT_FS_JOB_CP,
+  XT_FS_JOB_REALPATH,
+  XT_FS_JOB_STAT,
+  XT_FS_JOB_LSTAT,
+  XT_FS_JOB_STATFS,
+  XT_FS_JOB_ACCESS,
+  XT_FS_JOB_OPEN,
+  XT_FS_JOB_CHMOD,
+  XT_FS_JOB_LCHMOD,
+  XT_FS_JOB_CHOWN,
+  XT_FS_JOB_LCHOWN,
+  XT_FS_JOB_TRUNCATE,
+  XT_FS_JOB_UTIMES,
+  XT_FS_JOB_LUTIMES,
+  XT_FS_JOB_LINK,
+  XT_FS_JOB_SYMLINK,
+  XT_FS_JOB_READLINK,
+  XT_FS_JOB_MKDTEMP,
+  XT_FS_JOB_OPENDIR,
+  XT_FS_JOB_GLOB,
+  XT_FS_JOB_FD_READ,
+  XT_FS_JOB_FD_WRITE,
+  XT_FS_JOB_FD_READ_FILE,
+  XT_FS_JOB_FD_WRITE_FILE,
+  XT_FS_JOB_FD_CLOSE,
+  XT_FS_JOB_FD_STAT,
+  XT_FS_JOB_FD_TRUNCATE,
+  XT_FS_JOB_FD_CHMOD,
+  XT_FS_JOB_FD_CHOWN,
+  XT_FS_JOB_FD_UTIMES,
+  XT_FS_JOB_FD_SYNC,
+  XT_FS_JOB_FD_DATASYNC,
+} xt_fs_job_kind;
+
+typedef struct {
+  xt_async_job base;
+  xt_fs_job_kind kind;
+
+  /* input */
+  char *path;
+  char *path2;
+  char *text; /* encoding, symlink type, or a single glob pattern */
+  char **patterns;
+  size_t pattern_count;
+  unsigned char *data;
+  size_t data_length;
+  int flags;
+  int mode;
+  int fd;
+  long long offset;
+  long long length;
+  long long position;
+  int uid;
+  int gid;
+  double atime;
+  double mtime;
+  int recursive;
+  int force;
+  int error_on_exist;
+  int dereference;
+  int preserve;
+  int with_types;
+
+  /* worker results */
+  int err;
+  const char *syscall;
+  char *error_path;
+  xt_fs_stat_t stat;
+  unsigned char *bytes;
+  size_t bytes_length;
+  char *string;
+  xt_fs_entry *entries;
+  size_t entry_count;
+  long long numbers[7];
+  int result_fd;
+  long long written;
+} xt_fs_job;
+
+/* Value builders shared with the synchronous implementation (fs_ops.c). */
+xt_value xt_node_stat_result(const xt_fs_stat_t *info);
+xt_value xt_node_dirent_named(const char *name, unsigned int mode);
+xt_value xt_node_dir_from_entries(const char *path, xt_fs_entry *entries, size_t count);
+
+/* FileHandle factory (async_fh.c). */
+xt_value xt_fh_new(xt_value fdValue);
+
+/* Job lifecycle (async_job.c). */
+xt_fs_job *xt_fs_job_new(xt_fs_job_kind kind);
+/** Create the promise and submit; returns it. */
+xt_value xt_fs_job_submit(xt_fs_job *job);
+void xt_fs_job_fail(xt_fs_job *job, int err, const char *syscall, const char *path);
+
+/* Implemented by async_worker.c / async_complete.c. */
+void xt_fs_job_run(xt_async_job *job);
+void xt_fs_job_complete(xt_async_job *job);
+void xt_fs_job_release(xt_async_job *job);
+
+/* Argument helpers (async_job.c). */
+char *xt_fs_copy_cstr(const char *text);
+char *xt_fs_take_string(xt_value value);
+
+#endif /* XT_NODE_FS_ASYNC_JOB_H */