@ai-ecoverse/slicc-kernel 1.116.1 → 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.
 

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.1" : "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