@ai-ecoverse/slicc-kernel 1.179.0 → 1.180.0

package/dist/kernel-worker.js

@@ -7451,6 +7451,82 @@ var KERNEL_SIGINFO = Object.freeze({
   status: 0
 });
 
+// src/kernel/trace.ts
+var TRACE_LIMIT = 4096;
+var TRACE_LIMIT_MAX = 65536;
+function traceLimit(value2) {
+  if (value2 === void 0) return TRACE_LIMIT;
+  if (!Number.isInteger(value2) || value2 < 1 || value2 > TRACE_LIMIT_MAX) {
+    throw Object.assign(new Error(`a trace limit is an integer from 1 to ${TRACE_LIMIT_MAX}`), {
+      code: "EINVAL"
+    });
+  }
+  return value2;
+}
+var TraceHub = class {
+  subs = /* @__PURE__ */ new Set();
+  seq = 0;
+  get idle() {
+    return this.subs.size === 0;
+  }
+  subscribe(tag, viewer, deliver, limit = TRACE_LIMIT) {
+    const sub = {
+      tag,
+      viewer: copyCred(viewer),
+      limit,
+      queue: [],
+      dropped: 0,
+      waiting: false,
+      scheduled: false,
+      deliver
+    };
+    this.subs.add(sub);
+    return {
+      ack: () => {
+        sub.waiting = false;
+        this.schedule(sub);
+      },
+      close: () => {
+        this.subs.delete(sub);
+        sub.queue = [];
+      }
+    };
+  }
+  wants(tags, cred) {
+    if (!tags?.length || this.subs.size === 0) return false;
+    for (const sub of this.subs) if (this.matches(sub, tags, cred)) return true;
+    return false;
+  }
+  publish(tags, cred, draft) {
+    if (!tags?.length) return;
+    let event;
+    for (const sub of this.subs) {
+      if (!this.matches(sub, tags, cred)) continue;
+      event ??= { ...draft, seq: ++this.seq };
+      if (sub.queue.length >= sub.limit) sub.dropped++;
+      else sub.queue.push(event);
+      this.schedule(sub);
+    }
+  }
+  matches(sub, tags, cred) {
+    return tags.includes(sub.tag) && maySee(sub.viewer, cred);
+  }
+  schedule(sub) {
+    if (sub.scheduled || sub.waiting) return;
+    if (sub.queue.length === 0 && sub.dropped === 0) return;
+    sub.scheduled = true;
+    queueMicrotask(() => {
+      sub.scheduled = false;
+      if (!this.subs.has(sub)) return;
+      const batch = { events: sub.queue, dropped: sub.dropped };
+      sub.queue = [];
+      sub.dropped = 0;
+      sub.waiting = true;
+      sub.deliver(batch);
+    });
+  }
+};
+
 // src/body-idle.ts
 var BODY_IDLE_MS = 5 * 60 * 1e3;
 
@@ -8130,7 +8206,7 @@ var UserDb = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 14];
+var PROTOCOL = [1, 15];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -8297,9 +8373,21 @@ async function runAs(l, self, requested) {
 function clientCred(self) {
   return self ? credOf(self) : copyCred(ROOT);
 }
+var MAX_SPAWN_TAGS = 8;
+function spawnTags(value2) {
+  if (!Array.isArray(value2)) {
+    tagOption(value2);
+    return value2 === void 0 ? [] : [value2];
+  }
+  if (value2.length > MAX_SPAWN_TAGS) {
+    throw new TypeError(`a spawn adds at most ${MAX_SPAWN_TAGS} tags`);
+  }
+  for (const each of value2) tagOption(each ?? 0);
+  return value2;
+}
 async function runTagged(l, self, options, tag, session = -1) {
-  tagOption(options.tag);
-  const tags = withTag(withTag(void 0, tag), options.tag);
+  let tags = withTag(void 0, tag);
+  for (const added of spawnTags(options.tag)) tags = withTag(tags, added);
   return {
     user: await runAs(l, self, options.user),
     tag,
@@ -8430,6 +8518,34 @@ async function watchOp(l, req, watches, send2, g) {
   watches.set(req.id, unwatch);
   return { result: req.id };
 }
+function traceRegistry(send2) {
+  const traces = /* @__PURE__ */ new Map();
+  return {
+    answer(l, self, req) {
+      if (req.op === "untrace") {
+        traces.get(req.trace)?.close();
+        return { result: traces.delete(req.trace) };
+      }
+      if (typeof req.tag !== "string" || req.tag === "") {
+        throw fsError("EINVAL", "trace: a tag is a non-empty string");
+      }
+      const limit = traceLimit(req.limit);
+      const id2 = req.id;
+      const deliver = ({ events, dropped: dropped2 }) => send2({ trace: id2, events, ...dropped2 > 0 ? { dropped: dropped2 } : {} });
+      traces.set(id2, l.traces.subscribe(req.tag, credOf(self), deliver, limit));
+      return { result: id2 };
+    },
+    ack(data) {
+      if (typeof data.traceAck !== "number") return false;
+      traces.get(data.traceAck)?.ack();
+      return true;
+    },
+    close() {
+      for (const trace of traces.values()) trace.close();
+      traces.clear();
+    }
+  };
+}
 var TRAITS_WATCH = -1;
 function traitsWatch(launcher, transport, send2) {
   return launcher.onTraits(() => send2({ traits: transport.traits }));
@@ -8456,6 +8572,21 @@ function requestBinding(send2, port) {
     close: () => unbind?.()
   };
 }
+function answered(pending, req, reply, detach) {
+  pending.then(
+    ({ result, signal, transfer }) => {
+      reply(req.id, { result, ...signal ? { signal } : {} }, transfer);
+      if (req.op === "detach") detach(req.kill === true);
+    },
+    (err) => {
+      const code = err?.code;
+      reply(req.id, {
+        error: err instanceof Error ? err.message : String(err),
+        ...typeof code === "string" ? { code } : {}
+      });
+    }
+  );
+}
 function serveClient(port, host) {
   let state = "new";
   let self;
@@ -8471,6 +8602,7 @@ function serveClient(port, host) {
   };
   const reply = (id2, body, transfer) => send2({ id: id2, ...body }, transfer);
   const hosts = hostRegistries(send2, ended.promise, port);
+  const traces = traceRegistry(send2);
   function detach(kill = false, bye = "the slicc-kernel detached this client") {
     if (state === "closed") return;
     send2({ bye });
@@ -8478,6 +8610,7 @@ function serveClient(port, host) {
     net?.close();
     for (const unwatch of watches.values()) unwatch();
     watches.clear();
+    traces.close();
     hosts.close();
     for (const session of terminals.values()) session.close();
     terminals.clear();
@@ -8585,6 +8718,9 @@ function serveClient(port, host) {
       case "serve-facade":
       case "unserve-facade":
         return { result: hosts.answer(l, req) };
+      case "trace":
+      case "untrace":
+        return traces.answer(l, self, req);
       case "detach":
         return { result: true };
       default:
@@ -8608,20 +8744,9 @@ function serveClient(port, host) {
       net?.answer(data);
       return;
     }
+    if (traces.ack(data)) return;
     const req = data;
-    handle(req).then(
-      ({ result, signal, transfer }) => {
-        reply(req.id, { result, ...signal ? { signal } : {} }, transfer);
-        if (req.op === "detach") detach(req.kill === true);
-      },
-      (err) => {
-        const code = err?.code;
-        reply(req.id, {
-          error: err instanceof Error ? err.message : String(err),
-          ...typeof code === "string" ? { code } : {}
-        });
-      }
-    );
+    answered(handle(req), req, reply, detach);
   });
   port.addEventListener("close", () => detach());
   port.start?.();
@@ -8779,7 +8904,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.179.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.180.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
@@ -30069,6 +30194,9 @@ var JobTable = class {
   idOf(pid) {
     return this.members.get(pid)?.shownAs ?? pid;
   }
+  execParentOf(pid) {
+    return this.members.get(pid)?.execParent;
+  }
   byId(id2) {
     for (const member of this.members.values()) if (member.shownAs === id2) return member;
     return this.member(id2);
@@ -35283,10 +35411,12 @@ var Launcher = class {
       });
       const fit = await (handle.ready ?? true);
       if (fit) {
+        this.traceAdmitted(handle.pid, true);
         await fds.closeAll();
         return handle;
       }
       await handle.exited;
+      this.traceAdmitted(handle.pid, false);
       await this.memories.refused().catch(async (err) => {
         await fds.closeAll();
         throw err;
@@ -35417,10 +35547,12 @@ var Launcher = class {
     if (req.group === "lead") this.jobs.lead(pid);
     if (req.group === "session") this.jobs.setsid(pid);
     this.described.set(pid, describe(req, terminal?.name ?? null));
+    this.traceStarted(pid, req);
     handle.onState(
       (state) => state === "stopped" ? this.stopped.add(pid) : this.stopped.delete(pid)
     );
-    void handle.exited.then(() => {
+    void handle.exited.then((status) => {
+      this.traceEnded(pid, handle, status);
       this.cwds.release(this.cwdSlots.get(pid));
       this.cwdSlots.delete(pid);
       this.cwdPaths.delete(pid);
@@ -35535,6 +35667,71 @@ var Launcher = class {
   imageTimes = /* @__PURE__ */ new Map();
   childTimes = /* @__PURE__ */ new Map();
   stopped = /* @__PURE__ */ new Set();
+  traces = new TraceHub();
+  traceHeld = /* @__PURE__ */ new Map();
+  replacedImages = /* @__PURE__ */ new Set();
+  traceStarted(pid, req) {
+    const replaces = req.exec ? req.ppid : void 0;
+    if (req.quietOom) this.traceHeld.set(pid, { replaces, events: [] });
+    else if (replaces !== void 0) this.replacedImages.add(replaces);
+    this.traceEmit(pid, () => {
+      const { pid: shown2, ppid } = this.identityOf(pid);
+      const described2 = this.described.get(pid);
+      const { argv, started, tty: _tty, exeId: _exeId, ...exe } = described2;
+      return {
+        type: req.fork ? "fork" : "exec",
+        pid: shown2,
+        ppid,
+        pgid: this.jobs.pgidOf(pid),
+        argv: [...argv],
+        ...exe,
+        uid: this.credOf(pid).euid,
+        at: started,
+        ...req.exec ? { replaced: true } : {}
+      };
+    });
+  }
+  traceEnded(pid, handle, status) {
+    if (this.replacedImages.delete(pid)) return;
+    this.traceEmit(pid, () => ({
+      type: "exit",
+      pid: this.jobs.idOf(pid),
+      status,
+      ...signalField(handle.termsig()),
+      ...this.chainTimes(pid),
+      at: Date.now()
+    }));
+  }
+  traceEmit(pid, build) {
+    if (this.traces.idle) return;
+    const tags = this.tagsOf(pid);
+    const cred = this.credOf(pid);
+    if (!this.traces.wants(tags, cred)) return;
+    const held = this.traceHeld.get(pid);
+    if (held) held.events.push({ tags, cred: copyCred(cred), draft: build() });
+    else this.traces.publish(tags, cred, build());
+  }
+  traceAdmitted(pid, fit) {
+    const held = this.traceHeld.get(pid);
+    if (!held) return;
+    this.traceHeld.delete(pid);
+    if (!fit) return;
+    if (held.replaces !== void 0) this.replacedImages.add(held.replaces);
+    for (const { tags, cred, draft } of held.events) this.traces.publish(tags, cred, draft);
+  }
+  chainTimes(pid) {
+    let utime = 0;
+    let stime = 0;
+    let timed2 = false;
+    for (let at = pid; at !== void 0; at = this.jobs.execParentOf(at)) {
+      const t = this.timesAt(at);
+      if (!t) continue;
+      timed2 = true;
+      utime += t.utime;
+      stime += t.stime;
+    }
+    return timed2 ? { utime, stime } : {};
+  }
   stateOf(pid) {
     if (!this.processes.has(pid)) return "Z";
     return this.stopped.has(pid) ? "T" : "S";
@@ -37061,7 +37258,7 @@ function sudoApprovals(port) {
     }
   };
 }
-function answered(data, remote, uplink, approvals) {
+function answered2(data, remote, uplink, approvals) {
   if (data.sudoAnswer) approvals.answer(data.sudoAnswer);
   else if (data.net !== void 0) remote?.receive(data);
   else if (typeof data.uplink === "string") uplink?.receive(data);
@@ -37346,7 +37543,7 @@ function serveKernel(port, deps) {
     const grant = event.data.hostfsGrant;
     if (grant) return granted2(grant);
     if (allowed(event.data)) return;
-    if (answered(event.data, remote, uplink, approvals)) return;
+    if (answered2(event.data, remote, uplink, approvals)) return;
     const req = event.data;
     handle(req).then(
       (result) => reply(req.id, { result }, transferOf2(req, result)),