@amritk/nish-x86_64-linux 0.24.0 → 0.26.0

package/runtime/nish.mjs

@@ -84,18 +84,26 @@ globalThis.console = {
 // `Array#sort`'s UTF-16 order — the two agree on ASCII names only.
 provide("write", shim.write);
 provide("writeError", shim.writeError);
+provide("writeBytes", shim.writeBytes);
 provide("panic", shim.panic);
 provide("readFileSync", shim.readFileSync);
 provide("readFileSyncOrNull", shim.readFileSyncOrNull);
 provide("readFileBytesSync", shim.readFileBytesSync);
 provide("writeFileSync", shim.writeFileSync);
 provide("appendFileSync", shim.appendFileSync);
+provide("writeFileBytesSync", shim.writeFileBytesSync);
+provide("renameSync", shim.renameSync);
+provide("unlinkSync", shim.unlinkSync);
+provide("writeFileSyncMode", shim.writeFileSyncMode);
+provide("createFileExclusiveSync", shim.createFileExclusiveSync);
+provide("mkdirSyncMode", shim.mkdirSyncMode);
 provide("mkdirSync", shim.mkdirSync);
 provide("isDirectorySync", shim.isDirectorySync);
 provide("readdirSync", shim.readdirSync);
 provide("realpathSync", shim.realpathSync);
 provide("spawnSync", shim.spawnSync);
 provide("spawnSyncTo", shim.spawnSyncTo);
+provide("spawnPiped", shim.spawnPiped);
 // WP34 N12. `spawn` and `waitPid` throw, naming themselves: a child is reaped
 // by Node's event loop. `kill`, `availableParallelism` and `totalMemory` answer.
 provide("spawn", shim.spawn);
@@ -103,6 +111,14 @@ provide("kill", shim.kill);
 provide("waitPid", shim.waitPid);
 provide("availableParallelism", shim.availableParallelism);
 provide("totalMemory", shim.totalMemory);
+// `setNice` and `setIdlePriority` throw, naming themselves: Node has a reading
+// of the nice value (`os.setPriority`) but none of `SCHED_IDLE`, and a reading
+// of one without the other would differ from the native build on the same host.
+for (const name of ["setNice", "setIdlePriority"]) {
+  provide(name, () => {
+    throw new Error(`\`${name}\` has no reading under Node: it changes how the kernel schedules the native program`);
+  });
+}
 provide("getenv", shim.getenv);
 provide("statMtimeSync", shim.statMtimeSync);
 provide("signalFd", shim.signalFd);
@@ -130,9 +146,17 @@ for (const name of [
   "pollModify",
   "pollRemove",
   "pollWait",
+  "netSetOption",
 ]) {
   provide(name, () => shim.noNetReading(name));
 }
+// `netSetOption`'s option ids are plain numbers, so they read the same here
+// as natively: only the call that takes one throws.
+provide("NET_TCP_NODELAY", 1);
+provide("NET_TCP_QUICKACK", 2);
+provide("NET_SO_KEEPALIVE", 3);
+provide("NET_SO_SNDBUF", 4);
+provide("NET_SO_RCVBUF", 5);
 
 // `nish:term`. Whether a descriptor is a terminal and how big stdout's is have
 // Node's answers; reading stdin, waiting for it and raw mode throw, each naming
@@ -180,6 +204,7 @@ if (!("set" in Array.prototype)) {
 // describes. A printed reading can never match a native run: the two origins are
 // both arbitrary, and only the difference between two reads means anything.
 provide("monotonicNanos", shim.monotonicNanos);
+provide("wallClockNanos", shim.wallClockNanos);
 
 // Conversions. In f64 mode `toF64` is the identity and `toI32` is the one that
 // matters (it saturates, where a JavaScript cast would not).

package/runtime/node.mjs

@@ -72,6 +72,88 @@ function appendFileSync(path, data) {
   }
 }
 
+/**
+ * The negative errno a failed `fs` call names, as `runtime-os.c` answers it.
+ * Node names the errno by its code; one it gives no number for, such as the
+ * `ERR_INVALID_ARG_VALUE` a path holding a NUL throws, is -22 (`EINVAL`), the
+ * runtime's answer to that path.
+ */
+function negErrno(e) {
+  return -(os.constants.errno[e.code] ?? 22);
+}
+
+/** `ok` when `f` returns, or the negative errno of what it threw. */
+function errnoOr(ok, f) {
+  try {
+    f();
+    return ok;
+  } catch (e) {
+    return negErrno(e);
+  }
+}
+
+/** `renameSync(from, to)`: 0, or a negative errno (-18 across file systems). */
+const renameSync = (from, to) => errnoOr(0, () => fs.renameSync(from, to));
+
+/** `unlinkSync(path)`: 0, or a negative errno; a directory is refused, not removed. */
+const unlinkSync = (path) => errnoOr(0, () => fs.unlinkSync(path));
+
+/** `writeFileBytesSync(path, bytes)`: the byte count, or a negative errno; mode 0644 and `WRITE_FLAGS`. */
+const writeFileBytesSync = (path, bytes) =>
+  errnoOr(bytes.length, () => fs.writeFileSync(path, Uint8Array.from(bytes), { flag: WRITE_FLAGS, mode: 0o644 }));
+
+/**
+ * `writeFileSyncMode` and `createFileExclusiveSync`'s shared body, as
+ * `runtime-os.c`'s: the file opened with `flag`, `fchmod`ed to exactly `mode`
+ * before a byte is written, then every byte of `data`, then the count, or a
+ * negative errno. A mode outside 0..0o777 is -22 before the file is touched.
+ * After an exclusive create (`"wx"`), any failure unlinks the file it made.
+ */
+function putFileMode(path, data, flag, mode) {
+  if (!(mode >= 0 && mode <= 0o777)) return -22;
+  let fd;
+  try {
+    fd = fs.openSync(path, flag, mode);
+  } catch (e) {
+    return negErrno(e);
+  }
+  let r;
+  try {
+    fs.fchmodSync(fd, mode);
+    const buf = Buffer.from(data, "utf8");
+    for (let done = 0; done < buf.length; ) done += fs.writeSync(fd, buf, done);
+    r = buf.length;
+  } catch (e) {
+    r = negErrno(e);
+  }
+  const closed = errnoOr(0, () => fs.closeSync(fd));
+  const answer = r >= 0 && closed < 0 ? closed : r;
+  if (answer < 0 && flag === "wx") errnoOr(0, () => fs.unlinkSync(path));
+  return answer;
+}
+
+/** `writeFileSyncMode(path, data, mode)`: `WRITE_FLAGS`, so a link at the path is refused. */
+const writeFileSyncMode = (path, data, mode) => putFileMode(path, data, WRITE_FLAGS, mode);
+
+/** `createFileExclusiveSync(path, data, mode)`: `"wx"`, -17 when anything is at the path. */
+const createFileExclusiveSync = (path, data, mode) => putFileMode(path, data, "wx", mode);
+
+/** `mkdirSyncMode(path, mode)`: 0, or a negative errno; -17 for a path already there. */
+const mkdirSyncMode = (path, mode) =>
+  mode >= 0 && mode <= 0o777 ? errnoOr(0, () => fs.mkdirSync(path, { mode })) : -22;
+
+/**
+ * `writeBytes`'s write, after the core checked the range `[from, to)`: every
+ * byte to stdout, then the count, or a negative errno. `fs.writeSync` may
+ * write less than it was given, so it is asked again for the rest.
+ */
+function writeBytes(bytes, from, to) {
+  const buf = Uint8Array.from(bytes.slice(from, to));
+  return errnoOr(buf.length, () => {
+    for (let at = 0; at < buf.length; ) at += fs.writeSync(1, buf, at, buf.length - at);
+  });
+}
+
 /**
  * `mkdirSync(path)` (WP14 D4): one directory, not recursive, answering whether
  * a directory is there afterwards. Node throws where the runtime answers
@@ -226,6 +308,41 @@ function spawnSyncTo(argv, out, err) {
   return spawnImpl(argv, out, err);
 }
 
+/** The bytes `spawnPiped` keeps of one stream, as `runtime-os.c`'s `NISH_PIPED_CAP`. */
+const PIPED_CAP = 16 * 1024 * 1024;
+
+/**
+ * `spawnPiped(argv, stdin)`'s run, after the core took it apart: the status
+ * and the two streams' bytes, which the core appends to the caller's arrays.
+ * The status is `spawnImpl`'s, and -2 when a stream passed `PIPED_CAP`: Node
+ * then kills the child with `SIGKILL`, as the runtime does, and reports
+ * `ENOBUFS`, and what it read is cut to the cap here as the runtime keeps it.
+ * A child that exits without reading its stdin is not an error on either side.
+ */
+function spawnPiped(argv, input) {
+  if (argv.length === 0) return [-1, [], []];
+  let r;
+  // Node throws, rather than reporting, for an empty command or a NUL in any
+  // argument, which the runtime answers -1 for without starting a child.
+  try {
+    r = child_process.spawnSync(argv[0], argv.slice(1), {
+      input: Uint8Array.from(input),
+      maxBuffer: PIPED_CAP,
+      killSignal: "SIGKILL",
+    });
+  } catch {
+    return [-1, [], []];
+  }
+  const bytes = (b) => (b === null || b === undefined ? [] : Array.from(b.subarray(0, PIPED_CAP)));
+  const out = bytes(r.stdout);
+  const err = bytes(r.stderr);
+  // `EPIPE` is the child closing its stdin unread, which Node reports with
+  // the status it still waited for; the runtime ignores it the same way.
+  if (r.error !== undefined && r.error.code !== "EPIPE") return [r.error.code === "ENOBUFS" ? -2 : -1, out, err];
+  if (r.signal !== null && r.signal !== undefined) return [128 + (os.constants.signals[r.signal] ?? 0), out, err];
+  return [r.status === null ? -1 : r.status, out, err];
+}
+
 /**
  * `kill(pid, sig)`: 0, or a negative errno, as `runtime-os.c`'s `nish_kill`
  * answers. Only 0, 2, 9 and 15 are sent and a pid of 0 or below is refused,
@@ -234,12 +351,7 @@ function spawnSyncTo(argv, out, err) {
  */
 function kill(pid, sig) {
   if (pid <= 0 || !(sig === 0 || sig === 2 || sig === 9 || sig === 15)) return -22;
-  try {
-    process.kill(pid, sig);
-    return 0;
-  } catch (e) {
-    return -(os.constants.errno[e.code] ?? 22);
-  }
+  return errnoOr(0, () => process.kill(pid, sig));
 }
 
 /**
@@ -275,6 +387,15 @@ function monotonicNanos() {
   return process.hrtime.bigint();
 }
 
+/**
+ * `wallClockNanos()`: the wall clock in nanoseconds since the epoch, a BigInt
+ * like `monotonicNanos`'s. Node's wall clock is `Date.now`, whole
+ * milliseconds, so the last six digits are zeros where a native run has them.
+ */
+function wallClockNanos() {
+  return BigInt(Date.now()) * 1000000n;
+}
+
 /**
  * `statMtimeSync(path)`: Node's `mtimeMs` for the path, or NaN when it cannot
  * be stat'd, which is the native answer too. `mtimeMs` is the same arithmetic
@@ -344,6 +465,13 @@ const CALLS = {
   readFileBytesSync,
   writeFileSync,
   appendFileSync,
+  writeFileBytesSync,
+  renameSync,
+  unlinkSync,
+  writeFileSyncMode,
+  createFileExclusiveSync,
+  mkdirSyncMode,
+  writeBytes,
   mkdirSync,
   isDirectorySync,
   readdirSync,
@@ -353,10 +481,12 @@ const CALLS = {
   getenv,
   spawnSync,
   spawnSyncTo,
+  spawnPiped,
   kill,
   availableParallelism,
   totalMemory,
   monotonicNanos,
+  wallClockNanos,
   statMtimeSync,
   lstatOwnerModeSync,
   geteuid,

package/runtime/runtime-net.c

@@ -17,7 +17,8 @@
  * errno to it: where `signalFd` and `readSignal` answer a plain -1, a call
  * here answers the failure's errno, negated. The codes a loop branches on are Linux's numbers on every platform (-11
  * would block, -95 unsupported, -32 the peer is gone, -104 reset, -98 the
- * address is in use, -111 refused, -110 timed out, -22 a bad argument), so
+ * address is in use, -111 refused, -110 timed out, -22 a bad argument, -88
+ * not a socket), so
  * `nish_net_err` translates Darwin's; any other failure is the host's own
  * `-errno`. Nothing here allocates: the addresses a call reads or writes are
  * the caller's `u8[]`.
@@ -29,13 +30,14 @@
  * (`EAFNOSUPPORT`, as in many containers) `::` falls back to IPv4's
  * `0.0.0.0`.
  *
- * Linux and Darwin differ in five places: `SOCK_NONBLOCK | SOCK_CLOEXEC` and
+ * Linux and Darwin differ in six places: `SOCK_NONBLOCK | SOCK_CLOEXEC` and
  * `accept4` against a `socket` or `accept` followed by `fcntl`, `MSG_NOSIGNAL`
  * against the `SO_NOSIGPIPE` socket option (a write to a gone peer is -32 on
  * both, never SIGPIPE), the errno numbers, UDP's segmentation offload
  * (`UDP_SEGMENT`, `UDP_GRO`) and ECN marks, which Linux has and for which
  * Darwin answers -95, and the readiness loop, which is epoll on Linux and
- * kqueue on Darwin. Only the sending side and the GRO bind say -95 there: a
+ * kqueue on Darwin, and `TCP_QUICKACK`, which only Linux has (-95 on
+ * Darwin). Only the sending side and the GRO bind say -95 there: a
  * receive leaves `meta` at 0, 0, and a `meta[1]` of 0 is also what a real
  * Not-ECT datagram reads as, so a program learns that Darwin has no ECN from
  * the send, never from the receive. The Darwin branch is compiled by CI's Darwin bootstrap
@@ -100,6 +102,7 @@ static int32_t nish_net_err(int e) {
   if (e == EADDRINUSE) return -98;
   if (e == ECONNREFUSED) return -111;
   if (e == ETIMEDOUT) return -110;
+  if (e == ENOTSOCK) return -88;
 #endif
   return -e;
 }
@@ -383,6 +386,44 @@ int32_t nish_net_shutdown(int32_t fd, int32_t how) {
    promises on Linux, so a failure is information rather than a retry. */
 int32_t nish_net_close(int32_t fd) { return close(fd) != 0 ? nish_net_fail() : 0; }
 
+/* `netSetOption(fd, option, value)`: one option from a whitelist, named by
+   the runtime's own id rather than a level and an option number, so a
+   program can set these five and nothing else. `value` is 0 or 1 for the
+   flags and a byte count for the buffers, passed to the kernel as it is
+   (Linux stores twice a buffer size, to cover its bookkeeping). Linux does
+   not keep quick-ACK mode: the kernel leaves it of its own accord, so a
+   server that wants it on or off sets it again after each response. */
+int32_t nish_net_set_option(int32_t fd, int32_t option, int32_t value) {
+  int level = SOL_SOCKET;
+  int name;
+  switch (option) {
+  case 1:
+    level = IPPROTO_TCP;
+    name = TCP_NODELAY;
+    break;
+  case 2:
+#if defined(__linux__)
+    level = IPPROTO_TCP;
+    name = TCP_QUICKACK;
+    break;
+#else
+    return -95;
+#endif
+  case 3:
+    name = SO_KEEPALIVE;
+    break;
+  case 4:
+    name = SO_SNDBUF;
+    break;
+  case 5:
+    name = SO_RCVBUF;
+    break;
+  default:
+    return -22;
+  }
+  return setsockopt(fd, level, name, &value, sizeof value) != 0 ? nish_net_fail() : 0;
+}
+
 /* `udpBind(host, port, flags)`: a datagram socket, non-blocking and
    close-on-exec, bound like `tcpListen`'s, with `SO_REUSEPORT` for flag 1
    and `UDP_GRO` for flag 2; any other bit is -22. */