@ai-ecoverse/slicc-kernel 1.116.0 → 1.116.2

package/README.md

@@ -589,6 +589,7 @@ Directories are renamed with `FileSystemHandle.move()` where available, else by
 - **The node's identity, not its name, picks the FIFO:** an open FIFO keeps working after an `unlink` or a `rename`, and a new `mkfifo` at the same name is another FIFO. `/proc/<pid>/fd/N` names the FIFO's path, also in children that inherit the end.
 - **One kernel per storage root:** the table of open FIFOs is per kernel, so two tabs (two kernels on one origin) opening the same FIFO don't connect, as with record locks ([#675](https://github.com/ai-ecoverse/slicc-kernel/issues/675)).
 - GNU make 4.4's `-jN` uses a FIFO jobserver this way (`--jobserver-auth=fifo:PATH`), so sub-makes join it by path.
+- **Below an open** ([#908](https://github.com/ai-ecoverse/slicc-kernel/issues/908)): a FIFO or socket node is never read or written as a plain file. A JS program's `ctx.fs.readFile`/`writeFile` and the kernel API's `readFile`/`writeFile` (and the positioned reads, writes and truncates under them) fail with `ENXIO` on either, because they read or write a whole file rather than open one. Emscripten and WASI programs' opens of a FIFO go through the kernel's FIFO open as above, and a WASI program's open of a socket node is `ENXIO`, as on Linux.
 
 `mmap` of a regular file works on every file system, for Emscripten programs built with `mmap` (whose glue exports `emscripten_builtin_memalign`) as well as for WASIX ones: the kernel reads the mapped range into fresh memory of the process, as Emscripten's MEMFS does. A `MAP_PRIVATE` mapping may be written, and its changes stay in the process. A writable `MAP_SHARED` mapping of such a file is `ENODEV`; a file in the process's own in-memory file system (MEMFS, as under `/dev`) keeps Emscripten's own mapping, which writes back. A read-only `MAP_SHARED` mapping is a copy taken at `mmap`, so later changes to the file do not show in it.
 
@@ -802,7 +803,7 @@ The kernel runs scheduled jobs itself, with no daemon process: a cron service st
 - **`crontab`** is a command of the kernel itself, in `/usr/bin` (a package's `crontab` never wins over it), with Vixie's options: `crontab -l` prints the caller's table, `crontab -r` removes it, `crontab <file>` and `crontab -` (standard input) install one, and `crontab -e` copies the table to `/tmp`, runs `$VISUAL` (or `$EDITOR`) on the copy through `/bin/bash -c '<editor> "$1"'`, and installs it if it changed and the editor exited with 0. If the edit doesn't parse, the copy is kept and its path is printed. `-u <user>` works on another user's table and needs an effective uid of 0 (`sudo crontab -u cone -l`). An install is checked first: a table with a line that doesn't parse is refused with every error (`"-":<line>: <message>`), and the old one stays. The table becomes the user's `0600` file in the spool, written to a dotfile of a random name and renamed, so the service, which skips dotfiles, never reads half a table. The command only reads the file it is given and passes it on (`ctx.crontab`, see [JS programs](#js-programs)). The kernel decides whose table it is from the caller's real uid, so a user reaches only their own table, and `/etc/crontab` stays root's to edit.
 - **Format:** Vixie's. Five fields (minute, hour, day of month, month, weekday) with lists, ranges, steps and the names `jan`–`dec` and `sun`–`sat` (7 is Sunday too), or one of `@yearly`/`@annually`, `@monthly`, `@weekly`, `@daily`/`@midnight`, `@hourly` and `@reboot`. As in cronie, when the day of month or the weekday starts with `*`, a day must match both fields; when both are restricted, it may match either. `/etc/crontab` has a user field after the schedule; a user's table doesn't. `NAME=value` lines set the environment for the jobs after them, `#` lines are comments, and `# name: <id>` on the line above a job gives it a stable id (letters, digits, `_`, `.`, `-`), which names its log. Without one, the id is a hash of the table, the user, the schedule and the command. `%` is not special. Times are the kernel's local time.
 - **Environment:** only what a login of that user gets, and nothing from the page or the embedder's `env`. That is `HOME`, `USER`, `LOGNAME`, `PATH`, `PNPM_HOME`, `NPM_CONFIG_PREFIX`, the kernel's network settings (`http_proxy`, `SSL_CERT_FILE`, …), `SHELL`, `PWD`, the table's `NAME=value` lines, and `SLICC_CRON=1`, `SLICC_CRON_JOB=<id>`, `SLICC_CRON_DUE=<ISO time of the due run>` and `SLICC_CRON_MISSED=<runs folded into this one>`. An `agent send` from a job therefore knows it was scheduled.
-- **Missed runs:** when the kernel wasn't running (a closed tab) or time jumped forward, every due run since the last one is folded into **one** run, with `SLICC_CRON_MISSED` saying how many more were due (counted up to 100 000). The next run is then computed from now. A clock set back more than two minutes runs nothing until the next due time after the new time.
+- **Missed runs:** when the kernel wasn't running (a closed tab) or time jumped forward, every due run since the last one is folded into **one** run, with `SLICC_CRON_MISSED` saying how many more were due (counted up to 100 000) and `SLICC_CRON_DUE` naming the latest due time, even past the count's cap ([#843](https://github.com/ai-ecoverse/slicc-kernel/issues/843)). The next run is then computed from now. A clock set back more than two minutes runs nothing until the next due time after the new time.
 - **At most once:** the service writes each due run to `/var/spool/cron/stamp` before it starts the job. A kernel that ends mid-job (a reload, a crash) never runs that due again; a stamp that can't be read counts every job as run just now.
 - **`@reboot`** runs once per kernel boot, when that kernel first fires jobs.
 - **Overlap:** a job's runs don't wait for each other, so a slow job can still be running when it is due again. At most 16 jobs of one user run at once; a run past that is skipped, with a line in the job's log and in `/var/log/cron/cron.err`.

package/dist/kernel-worker.js

@@ -1699,13 +1699,20 @@ var OpfsFs = class {
     if (handle.kind === "directory") throw fsError("EISDIR", path);
     return handle;
   }
+  async refuseNode(path, empty) {
+    if (!empty) return;
+    const [entry] = await this.meta.get([(await this.locate(path, true)).path]);
+    if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
+  }
   async readFileBuffer(path) {
     const handle = await this.existing(path);
-    return this.retrying(
+    const bytes = await this.retrying(
       path,
       async () => new Uint8Array(await (await handle.getFile()).arrayBuffer()),
       false
     );
+    await this.refuseNode(path, bytes.length === 0);
+    return bytes;
   }
   async readVersioned(path, cached = false) {
     const handle = await this.existing(path);
@@ -1715,6 +1722,7 @@ var OpfsFs = class {
         const stamp = await this.stamp(path, cached);
         const file = await handle.getFile();
         const bytes = new Uint8Array(await file.arrayBuffer());
+        await this.refuseNode(path, bytes.length === 0);
         return { bytes, version: `${file.lastModified}:${file.size}:${stamp}` };
       },
       false
@@ -1736,7 +1744,11 @@ var OpfsFs = class {
     const handle = await this.existing(path);
     return this.retrying(
       path,
-      async () => new Uint8Array(await (await handle.getFile()).slice(offset, offset + length2).arrayBuffer()),
+      async () => {
+        const file = await handle.getFile();
+        await this.refuseNode(path, file.size === 0);
+        return new Uint8Array(await file.slice(offset, offset + length2).arrayBuffer());
+      },
       false
     );
   }
@@ -1752,6 +1764,7 @@ var OpfsFs = class {
   }
   async truncate(path, size) {
     const handle = await this.existing(path, true);
+    await this.refuseNode(path, (await handle.getFile()).size === 0);
     const resolve2 = this.ranged || this.remote?.watched();
     const target = resolve2 || this.counted.length > 0 ? (await this.locate(path, true)).path : path;
     await this.counting(target);
@@ -1804,6 +1817,10 @@ var OpfsFs = class {
   }
   async fileFor(path) {
     const [target, existed] = await this.writeTarget(path);
+    if (existed) {
+      const [entry] = await this.meta.get([target]);
+      if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
+    }
     const [dir, name2] = await this.parent(target);
     try {
       const handle = await this.inDir(
@@ -6241,7 +6258,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.116.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.116.2" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -6889,7 +6906,25 @@ function missedFires(schedule, from, until, utc = false, cap = MISSED_CAP) {
     count2++;
   }
   const next3 = nextFire(schedule, last, utc);
-  return { count: count2, last, more: next3 !== null && next3 <= until };
+  if (next3 === null || next3 > until) return { count: count2, last, more: false };
+  return { count: count2, last: latestFire(schedule, last, until, utc), more: true };
+}
+function latestFire(schedule, from, until, utc = false) {
+  let found = from;
+  for (let span = 6e4; ; span *= 2) {
+    const start2 = Math.max(from, until - span);
+    const first = nextFire(schedule, start2, utc);
+    if (first !== null && first <= until) {
+      found = first;
+      break;
+    }
+    if (start2 === from) return from;
+  }
+  for (let at = nextFire(schedule, found, utc); at !== null && at <= until; ) {
+    found = at;
+    at = nextFire(schedule, at, utc);
+  }
+  return found;
 }
 
 // src/cron/table.ts