@ai-ecoverse/slicc-kernel 1.102.0 → 1.102.2

package/dist/node.js

@@ -7490,6 +7490,11 @@ function devRemoval(path, cred) {
   if (cred && cred.euid !== 0) return "EACCES";
   return path === "/dev" ? "EBUSY" : "EPERM";
 }
+function devCreation(path, cred) {
+  if (path === "/proc" || path.startsWith("/proc/")) return "EROFS";
+  if (path === "/dev" || !inDevTree(path)) return void 0;
+  return cred && cred.euid !== 0 ? "EACCES" : "EPERM";
+}
 
 // src/fs/fresh-modules.ts
 var MAGIC = [0, 97, 115, 109];
@@ -10245,12 +10250,29 @@ async function guardAndResolve(entry, path, req) {
   };
 }
 var REMOVALS = /* @__PURE__ */ new Set(["unlink", "rmdir", "rm"]);
+var CREATIONS = /* @__PURE__ */ new Set(["write", "mkdir", "symlink", "create"]);
+var NAMING = /* @__PURE__ */ new Set(["link", "rename"]);
+async function newDevName(entry, path, req) {
+  const named = NAMING.has(req.op);
+  if (!named && !CREATIONS.has(req.op)) return void 0;
+  const target = named ? entry.fs.resolvePath(entry.cwd, req.arg2 ?? "") : path;
+  const refused2 = devCreation(target, entry.cred?.());
+  if (!refused2) return void 0;
+  const there = await entry.fs.lstat(target).then(
+    () => true,
+    () => false
+  );
+  if (there) return void 0;
+  return { ok: false, errno: refused2, message: `${target}: no new names in /dev or /proc` };
+}
 async function dispatchOne(entry, req) {
   const { fs, cwd } = entry;
   try {
     const path = fs.resolvePath(cwd, req.path);
     const device = REMOVALS.has(req.op) ? devRemoval(path, entry.cred?.()) : void 0;
     if (device) return { ok: false, errno: device, message: `${path}: a device entry stays` };
+    const made2 = await newDevName(entry, path, req);
+    if (made2) return made2;
     const held = await byHandle(entry, path, req);
     if (held) return held;
     if (req.op === "access") return await accessOp(entry, path, req);
@@ -11107,7 +11129,7 @@ var PATH_OPS = new Set(SYNC_FS_OPS);
 var EARLY_WHOLE_FILE = 64 * 1024;
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.102.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.102.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
@@ -11621,6 +11643,41 @@ var EventFd = class _EventFd {
   }
 };
 
+// src/kernel/timer.ts
+var TIMER_MAX_MS = 2147483647;
+function timerAt(deadline, fire) {
+  let timer;
+  const arm = () => {
+    const left = deadline - performance.now();
+    if (left > 0) {
+      timer = setTimeout(arm, Math.min(left, TIMER_MAX_MS));
+      return;
+    }
+    timer = void 0;
+    fire();
+  };
+  timer = setTimeout(arm, Math.min(Math.max(0, deadline - performance.now()), TIMER_MAX_MS));
+  return () => clearTimeout(timer);
+}
+function timerAfter(ms, fire) {
+  return timerAt(performance.now() + ms, fire);
+}
+function repeating(first, every, fire) {
+  let next2 = performance.now() + first;
+  let cancel = () => {
+  };
+  const tick = () => {
+    fire();
+    if (every <= 0) return;
+    next2 += every;
+    const now = performance.now();
+    if (next2 <= now) next2 += (Math.floor((now - next2) / every) + 1) * every;
+    cancel = timerAt(next2, tick);
+  };
+  cancel = timerAt(next2, tick);
+  return () => cancel();
+}
+
 // src/kernel/epoll.ts
 var EPOLL = {
   IN: 1,
@@ -11672,11 +11729,11 @@ function lookup(fds, fd) {
 }
 function pause(ms, signal) {
   return new Promise((resolve2) => {
-    const timer = setTimeout(resolve2, ms);
+    const cancel = timerAfter(ms, resolve2);
     signal.addEventListener(
       "abort",
       () => {
-        clearTimeout(timer);
+        cancel();
         resolve2();
       },
       { once: true }
@@ -11742,17 +11799,14 @@ var EpollFile = class _EpollFile {
       const round = new AbortController();
       const woken = this.changes.wait(AbortSignal.any([round.signal, signal]));
       woken.catch(() => void 0);
-      let timer;
-      const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [
-        new Promise(
-          (resolve2) => timer = setTimeout(resolve2, deadline - performance.now())
-        )
-      ];
+      let cancel = () => {
+      };
+      const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve2) => cancel = timerAt(deadline, resolve2))];
       try {
         await Promise.race([woken, ...expiry]);
       } finally {
         round.abort();
-        clearTimeout(timer);
+        cancel();
       }
     }
   }
@@ -12097,9 +12151,10 @@ var AsyncOps = class {
   }
   sleep(timeoutMs, signal) {
     return new Promise((resolve2, reject) => {
-      let timer;
+      let cancel = () => {
+      };
       const cleanup = () => {
-        clearTimeout(timer);
+        cancel();
         this.waiters.delete(wake);
         signal.removeEventListener("abort", abort);
       };
@@ -12114,10 +12169,10 @@ var AsyncOps = class {
       this.waiters.add(wake);
       signal.addEventListener("abort", abort, { once: true });
       if (timeoutMs !== void 0) {
-        timer = setTimeout(() => {
+        cancel = timerAfter(timeoutMs, () => {
           cleanup();
           resolve2(false);
-        }, timeoutMs);
+        });
       }
     });
   }
@@ -14168,14 +14223,14 @@ async function runChild(req, deps) {
     return frame2(outcome2, new Uint8Array(0), new Uint8Array(0));
   }
   if (failure !== void 0) kill();
-  const timer = req.timeoutMs !== void 0 && req.timeoutMs > 0 ? setTimeout(() => stop("ETIMEDOUT"), req.timeoutMs) : void 0;
+  const cancel = req.timeoutMs !== void 0 && req.timeoutMs > 0 ? timerAfter(req.timeoutMs, () => stop("ETIMEDOUT")) : void 0;
   let status;
   try {
     status = await reaped(deps, pid);
     const open = controls.filter((c) => c.opened);
     await Promise.race([Promise.all(open.map((c) => c.eof)), decided.promise]);
   } finally {
-    clearTimeout(timer);
+    cancel?.();
     for (const control of controls) control.shut = true;
   }
   const out = deps.children.captured(pid, 1);
@@ -14231,27 +14286,23 @@ async function waitReady(fds, read, write, deadline, interrupted3) {
       const file = fds.get(fd).file;
       return file.changed === void 0 ? [] : [file.changed(round.signal).catch(() => void 0)];
     });
-    let timer;
-    const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [
-      new Promise(
-        (resolve2) => timer = setTimeout(resolve2, deadline - performance.now())
-      )
-    ];
+    let cancel = () => {
+    };
+    const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve2) => cancel = timerAt(deadline, resolve2))];
     try {
       await Promise.race([...changes, ...expiry, interrupted3]);
     } finally {
       round.abort();
-      clearTimeout(timer);
+      cancel();
     }
   }
 }
 
 // src/kernel/sem.ts
 var SEM_VALUE_MAX = 2147483647;
-var SEM_NAMES_MAX = 4096;
-var SEM_HANDLES_MAX = 256;
+var SEM_NAMES_MAX = 65536;
+var SEM_HANDLES_MAX = 65536;
 var NAME_MAX = 251;
-var TIMER_MAX_MS = 2147483647;
 var SEM_OPS = [
   "sem-open",
   "sem-close",
@@ -14288,11 +14339,12 @@ var Semaphore = class {
     if (signal.aborted) return Promise.reject(new KernelError("EINTR"));
     return new Promise((resolve2, reject) => {
       const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : performance.now() + timeoutMs;
-      let timer;
+      let cancel = () => {
+      };
       const leave = () => {
         const at = this.waiters.indexOf(waiter);
         if (at >= 0) this.waiters.splice(at, 1);
-        clearTimeout(timer);
+        cancel();
         signal.removeEventListener("abort", abort);
       };
       const waiter = {
@@ -14306,18 +14358,13 @@ var Semaphore = class {
         reject(new KernelError("EINTR"));
       };
       const expire = () => {
-        const left = deadline - performance.now();
-        if (left > 0) {
-          timer = setTimeout(expire, Math.min(left, TIMER_MAX_MS));
-          return;
-        }
         leave();
         resolve2(false);
       };
       this.waiters.push(waiter);
       signal.addEventListener("abort", abort, { once: true });
       if (deadline !== Number.POSITIVE_INFINITY) {
-        timer = setTimeout(expire, Math.min(timeoutMs, TIMER_MAX_MS));
+        cancel = timerAt(deadline, expire);
       }
     });
   }
@@ -14352,6 +14399,10 @@ var SemTable = class {
 var SemHandles = class _SemHandles {
   byHandle = /* @__PURE__ */ new Map();
   next = 1;
+  limit;
+  constructor(limit = SEM_HANDLES_MAX) {
+    this.limit = limit;
+  }
   add(sem) {
     for (const [handle2, entry] of this.byHandle) {
       if (entry.sem === sem) {
@@ -14359,7 +14410,7 @@ var SemHandles = class _SemHandles {
         return handle2;
       }
     }
-    if (this.byHandle.size >= SEM_HANDLES_MAX) throw new KernelError("EMFILE");
+    if (this.byHandle.size >= this.limit) throw new KernelError("EMFILE");
     const handle = this.next++;
     this.byHandle.set(handle, { sem, opens: 1 });
     return handle;
@@ -14375,7 +14426,7 @@ var SemHandles = class _SemHandles {
     if (--entry.opens === 0) this.byHandle.delete(handle);
   }
   fork() {
-    const child = new _SemHandles();
+    const child = new _SemHandles(this.limit);
     child.next = this.next;
     for (const [handle, entry] of this.byHandle) child.byHandle.set(handle, { ...entry });
     return child;
@@ -16662,17 +16713,12 @@ var WasmProcess = class {
     (req, cancelled) => this.syscall(req, cancelled),
     () => this.options.onAsync?.()
   );
-  alarmEvery;
   setAlarm(sig, first, every, timer) {
     if (!isSignal(sig)) throw new KernelError("EINVAL");
     this.clearAlarm();
     if (first <= 0) return;
     const fire = timer === void 0 ? () => this.options.raise?.(sig) : () => this.timerExpired(timer);
-    this.alarm = setTimeout(() => {
-      this.alarm = void 0;
-      fire();
-      if (every > 0) this.alarmEvery = setInterval(fire, every);
-    }, first);
+    this.alarm = repeating(first, every, fire);
   }
   timerExpired(which) {
     this.options.onTimer?.(which);
@@ -16681,10 +16727,8 @@ var WasmProcess = class {
     blocked2.abort();
   }
   clearAlarm() {
-    clearTimeout(this.alarm);
-    clearInterval(this.alarmEvery);
+    this.alarm?.();
     this.alarm = void 0;
-    this.alarmEvery = void 0;
   }
   async exit() {
     if (this.exited) return;