@ai-ecoverse/slicc-kernel 1.113.0 → 1.114.0

package/dist/kernel-worker.js

@@ -4962,6 +4962,14 @@ var SIGNAL_BY_NAME = {
   SIGSTOP: SIG.STOP,
   SIGCONT: SIG.CONT
 };
+var SI = { USER: 0, QUEUE: -1, TIMER: -2, TKILL: -6, KERNEL: 128 };
+var CLD = { EXITED: 1, KILLED: 2, DUMPED: 3, STOPPED: 5, CONTINUED: 6 };
+var KERNEL_SIGINFO = Object.freeze({
+  code: SI.KERNEL,
+  pid: 0,
+  uid: 0,
+  status: 0
+});
 
 // src/body-idle.ts
 var BODY_IDLE_MS = 5 * 60 * 1e3;
@@ -6213,7 +6221,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.113.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.114.0" : "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
@@ -9089,8 +9097,16 @@ var ChildTable = class {
     void handle.exited.then((code) => {
       child.code = code;
       this.watchers.delete(handle.pid);
+      const termsig = handle.termsig?.();
       if (!this.kept.delete(handle.pid) && this.autoReap?.()) this.reap(handle.pid, code);
-      this.onChildState?.();
+      const uid = handle.uid?.();
+      this.onChildState?.({
+        pid: handle.pid,
+        state: "exited",
+        status: termsig ?? code,
+        termsig,
+        uid
+      });
     });
     handle.onState?.((state, sig) => {
       child.stopReport = state === "stopped" ? sig : void 0;
@@ -9100,7 +9116,7 @@ var ChildTable = class {
       const waiters = this.stateChanged;
       this.stateChanged = [];
       for (const wake of waiters) wake();
-      this.onChildState?.();
+      this.onChildState?.({ pid: handle.pid, state, status: sig, uid: handle.uid?.() });
     });
     this.children.set(handle.pid, child);
     return handle.pid;
@@ -17170,6 +17186,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "sig-mask",
   "sig-inherited",
   "sig-waiting",
+  "sig-info",
   "sig-pause",
   ...SOCKET_OPS,
   ...EPOLL_OPS,
@@ -17251,7 +17268,7 @@ var WasmProcess = class {
     this.children = new ChildTable(fds, options.spawner, options.forker);
     this.nodes = options.nodes ?? new VfsNodes(options.fs);
     if (!options.nodes) options.openFiles?.add(this.nodes);
-    this.children.onChildState = () => this.signal(SIG.CHLD);
+    this.children.onChildState = (child) => this.signal(SIG.CHLD, child && this.childInfo(child));
     this.children.autoReap = () => this.reapsChildren();
     this.seedDl(options.dl);
     this.children.onReap = (pid2) => {
@@ -17268,10 +17285,43 @@ var WasmProcess = class {
   inheritable(fork = false) {
     return ((fork ? 0 : this.ignored) | this.inherited) & ~this.caught;
   }
-  signal(sig) {
+  sigInfos = /* @__PURE__ */ new Map();
+  signal(sig, info) {
+    const pending = ((this.options.pendingBits?.() ?? 0) & sigbit(sig)) !== 0;
+    const outcome = this.signalOutcome(sig, info);
+    if (outcome === "deliver" && !(pending && this.sigInfos.has(`0:${sig}`))) {
+      this.sigInfos.set(`0:${sig}`, info ?? KERNEL_SIGINFO);
+    }
+    return outcome;
+  }
+  async threadKill(tid, sig) {
+    const info = await this.threadSender(sig);
+    if (this.options.threadKill?.(tid, sig)) this.sigInfos.set(`${tid}:${sig}`, info);
+    else this.options.raise?.(sig, info);
+  }
+  async threadSender(sig) {
+    const pid = (await this.options.identity?.())?.pid ?? this.pid;
+    const code = sig === SIG.PIPE ? SI.USER : SI.TKILL;
+    return { code, pid, uid: this.cred.ruid, status: 0 };
+  }
+  childInfo(child) {
+    const code = child.state === "stopped" ? CLD.STOPPED : child.state === "continued" ? CLD.CONTINUED : child.termsig ? CLD.KILLED : CLD.EXITED;
+    return { code, pid: child.pid, uid: child.uid ?? this.cred.ruid, status: child.status };
+  }
+  takeSigInfo(sig, tid) {
+    for (const key of [`${tid}:${sig}`, `0:${sig}`]) {
+      const info = this.sigInfos.get(key);
+      if (info) {
+        this.sigInfos.delete(key);
+        return info;
+      }
+    }
+    return null;
+  }
+  signalOutcome(sig, info) {
     if (this.execChild !== void 0) {
       if (sig === SIG.CONT) this.cont();
-      void Promise.resolve(this.options.kill?.(this.execChild, sig)).catch(() => void 0);
+      void Promise.resolve(this.options.kill?.(this.execChild, sig, info)).catch(() => void 0);
       if (sig !== SIG.KILL) return "forward";
       if (!this.options.writesBack?.(this.execChild)) return "terminate";
       this.wake?.();
@@ -18332,8 +18382,10 @@ var WasmProcess = class {
       case "sig-pause":
         return this.pause(cancelled);
       case "thread-kill":
-        if (!this.options.threadKill?.(req.tid, req.sig)) this.options.raise?.(req.sig);
+        await this.threadKill(req.tid, req.sig);
         return { ok: true, kind: "void" };
+      case "sig-info":
+        return { ok: true, kind: "json", json: this.takeSigInfo(req.sig, req.tid ?? 0) };
       case "proc-captured":
         return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
       case "proc-sudo":
@@ -18812,7 +18864,7 @@ function spawnWasmProcess(opts) {
       opts,
       header3,
       {
-        raise: (sig) => signal(sig),
+        raise: (sig, info) => signal(sig, info),
         threadKill: (tid, sig) => killThread(threadSignals.get(tid), process.signalMasks().caught, sig),
         unblockedThread: (sig) => unblockedThread(threadSignals, sig),
         ...opts.program.abi === "js" ? {
@@ -18934,8 +18986,9 @@ function spawnWasmProcess(opts) {
     if (opts.program.abi !== "wasi" || done4) finish(code, sig);
     else dying.start(code, sig, header3, process, () => finish(code, sig));
   };
-  const signal = (sig) => {
-    if (process.signal(sig) === "terminate") terminate(sig === SIG.KILL ? 137 : 128 + sig, sig);
+  const signal = (sig, info) => {
+    if (process.signal(sig, info) === "terminate")
+      terminate(sig === SIG.KILL ? 137 : 128 + sig, sig);
   };
   const kill = (code = 137) => finish(code, code > 128 && code < 160 ? code - 128 : void 0);
   return {
@@ -19105,14 +19158,14 @@ var JobTable = class {
     this.foreground.set(tty, member.pgid);
     return true;
   }
-  killGroup(pgid, sig, may = () => true) {
+  killGroup(pgid, sig, may = () => true, info) {
     const group = [...this.members.values()].filter((m) => m.pgid === pgid);
     const targets = group.filter((m) => may(m.pid));
     if (targets.length === 0 && group.length > 0) throw new KernelError("EPERM");
     const pids = new Set(targets.map((m) => m.pid));
     if (sig !== 0) {
       for (const m of targets)
-        if (m.execParent === void 0 || !pids.has(m.execParent)) m.signal(sig);
+        if (m.execParent === void 0 || !pids.has(m.execParent)) m.signal(sig, info);
     }
     return targets.length > 0;
   }
@@ -22383,7 +22436,8 @@ function childHandle(handle) {
     pid: handle.pid,
     exited: handle.exited,
     termsig: handle.termsig,
-    onState: (listener) => handle.onState(listener)
+    onState: (listener) => handle.onState(listener),
+    uid: () => handle.cred?.().ruid
   };
 }
 function concat7(chunks) {
@@ -23421,7 +23475,7 @@ var Launcher = class {
       onError: req.report,
       spawner: this.spawner(pid, req.report),
       forker: this.forker(pid, req),
-      kill: (target, sig) => this.kill(target, sig, this.credOf(pid), pid),
+      kill: (target, sig, info) => this.kill(target, sig, this.credOf(pid), pid, info),
       writesBack: (target) => this.processes.get(target)?.writesBack() === true,
       processes: () => ({
         boot: this.boot,
@@ -23456,7 +23510,7 @@ var Launcher = class {
     this.creds.set(pid, () => handle.cred?.() ?? copyCred(cred));
     this.marks(pid, req);
     if (req.ppid !== void 0 && this.controlsJobs(req.ppid)) this.settling.started(pid, req.ppid);
-    this.jobs.add(pid, req.ppid, (sig) => handle.signal(sig), terminal);
+    this.jobs.add(pid, req.ppid, (sig, info) => handle.signal(sig, info), terminal);
     if (req.exec && req.ppid !== void 0) this.jobs.exec(req.ppid, pid, true);
     if (req.pgid !== void 0) this.jobs.join(pid, req.pgid);
     if (req.group === "lead") this.jobs.lead(pid);
@@ -23837,21 +23891,26 @@ var Launcher = class {
   ignoredBy(pid, fork = false) {
     return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }
-  kill(pid, sig, sender, from) {
+  kill(pid, sig, sender, from, forwarded) {
+    const info = forwarded ?? this.senderInfo(sender, from);
     const session = from === void 0 ? void 0 : this.jobs.sidOf(from);
     const may = (target) => !sender || maySignal(sender, this.credOf(target)) || sig === SIG.CONT && session !== void 0 && this.jobs.sidOf(target) === session || from !== void 0 && this.imageOf(from) === this.imageOf(target) || from !== void 0 && this.granted.get(this.jobs.shown(target)) === from || from !== void 0 && this.granted.get(this.jobs.pgidOf(target) ?? 0) === from;
     if (pid === -1) {
       const sender2 = from === void 0 ? void 0 : this.imageOf(from);
-      return this.killAll(sig, (member) => this.imageOf(member) !== sender2, may);
+      return this.killAll(sig, (member) => this.imageOf(member) !== sender2, may, info);
     }
-    if (pid < 0) return this.jobs.killGroup(-pid, sig, (member) => may(this.imageOf(member)));
+    if (pid < 0) return this.jobs.killGroup(-pid, sig, (member) => may(this.imageOf(member)), info);
     const handle = this.processes.get(pid);
     if (!handle) return false;
     if (!may(this.imageOf(pid))) throw fsError("EPERM", `pid ${pid}`);
-    if (sig !== 0) handle.signal(sig);
+    if (sig !== 0) handle.signal(sig, info);
     return true;
   }
-  killAll(sig, other, may) {
+  senderInfo(sender, from) {
+    if (from === void 0) return void 0;
+    return { code: SI.USER, pid: this.jobs.shown(from), uid: sender?.ruid ?? 0, status: 0 };
+  }
+  killAll(sig, other, may, info) {
     const candidates = [...this.processes].filter(([pid]) => pid !== 1 && other(pid));
     const targets = candidates.filter(([pid]) => may(this.imageOf(pid)));
     if (targets.length === 0 && candidates.length > 0) throw fsError("EPERM", "kill -1");
@@ -23859,7 +23918,7 @@ var Launcher = class {
     const parents = new Map(this.jobs.list().map((m) => [m.pid, m.execParent]));
     for (const [pid, handle] of targets) {
       const parent = parents.get(pid);
-      if (sig !== 0 && (parent === void 0 || !pids.has(parent))) handle.signal(sig);
+      if (sig !== 0 && (parent === void 0 || !pids.has(parent))) handle.signal(sig, info);
     }
     return targets.length > 0;
   }