diff --git a/.github/workflows/browser-demos-ci.yml b/.github/workflows/browser-demos-ci.yml index 87b54cccc..432401f78 100644 --- a/.github/workflows/browser-demos-ci.yml +++ b/.github/workflows/browser-demos-ci.yml @@ -57,10 +57,10 @@ jobs: working-directory: apps/browser-demos run: npx playwright install --with-deps chromium firefox webkit - - name: Run cross-origin isolation smoke tests + - name: Run browser smoke tests working-directory: apps/browser-demos run: | - npx playwright test test/coi.spec.ts \ + npx playwright test test/coi.spec.ts test/wasm-trap-signal.spec.ts \ --project=chromium \ --project=firefox \ --project=webkit diff --git a/apps/browser-demos/playwright.config.ts b/apps/browser-demos/playwright.config.ts index 1c0e52765..ae9d2aff8 100644 --- a/apps/browser-demos/playwright.config.ts +++ b/apps/browser-demos/playwright.config.ts @@ -26,12 +26,16 @@ export default defineConfig({ }, { name: "firefox", - testMatch: "coi.spec.ts", + testMatch: ["coi.spec.ts", "wasm-trap-signal.spec.ts"], use: { browserName: "firefox" }, }, { name: "webkit", - testMatch: ["coi.spec.ts", "kandelo-webkit-smoke.spec.ts"], + testMatch: [ + "coi.spec.ts", + "kandelo-webkit-smoke.spec.ts", + "wasm-trap-signal.spec.ts", + ], use: { browserName: "webkit" }, }, ], diff --git a/apps/browser-demos/public/trap-signal-test.html b/apps/browser-demos/public/trap-signal-test.html new file mode 100644 index 000000000..32586fdc1 --- /dev/null +++ b/apps/browser-demos/public/trap-signal-test.html @@ -0,0 +1,2 @@ + +Wasm trap signal test diff --git a/apps/browser-demos/test/wasm-trap-signal.spec.ts b/apps/browser-demos/test/wasm-trap-signal.spec.ts new file mode 100644 index 000000000..cd9043583 --- /dev/null +++ b/apps/browser-demos/test/wasm-trap-signal.spec.ts @@ -0,0 +1,157 @@ +import { expect, test } from "@playwright/test"; +import { dirname, resolve } from "node:path"; +import { fileURLToPath } from "node:url"; +import { SIGFPE, SIGILL, SIGSEGV } from "../../../host/src/trap-signals"; + +const __dirname = dirname(fileURLToPath(import.meta.url)); +const trapSignalsModulePath = resolve( + __dirname, + "../../../host/src/trap-signals.ts", +); + +// Browser engines do not all isolate synthetic Wasm traps well enough for a +// stable E2E test. The host tests exercise real traps; this suite verifies that +// the classifier Kandelo ships to browsers maps representative engine messages. +const TRAP_MESSAGE_CASES = [ + { + name: "v8 memory-oob", + message: "RuntimeError: memory access out of bounds", + expectedSignum: SIGSEGV, + expectedSignalName: "SIGSEGV", + }, + { + name: "jsc memory-oob", + message: "RuntimeError: Out of bounds memory access", + expectedSignum: SIGSEGV, + expectedSignalName: "SIGSEGV", + }, + { + name: "spidermonkey generic bounds", + message: "RuntimeError: index out of bounds", + expectedSignum: SIGSEGV, + expectedSignalName: "SIGSEGV", + }, + { + name: "table index bounds", + message: "RuntimeError: table index is out of bounds", + expectedSignum: SIGSEGV, + expectedSignalName: "SIGSEGV", + }, + { + name: "call_indirect bounds", + message: "RuntimeError: Out of bounds call_indirect", + expectedSignum: SIGSEGV, + expectedSignalName: "SIGSEGV", + }, + { + name: "divide by zero", + message: "RuntimeError: divide by zero", + expectedSignum: SIGFPE, + expectedSignalName: "SIGFPE", + }, + { + name: "integer divide by zero", + message: "RuntimeError: integer divide by zero", + expectedSignum: SIGFPE, + expectedSignalName: "SIGFPE", + }, + { + name: "integer overflow", + message: "RuntimeError: integer overflow", + expectedSignum: SIGFPE, + expectedSignalName: "SIGFPE", + }, + { + name: "unreachable", + message: "RuntimeError: unreachable", + expectedSignum: SIGILL, + expectedSignalName: "SIGILL", + }, + { + name: "unreachable executed", + message: "RuntimeError: unreachable executed", + expectedSignum: SIGILL, + expectedSignalName: "SIGILL", + }, + { + name: "indirect type mismatch", + message: "RuntimeError: indirect call type mismatch", + expectedSignum: SIGILL, + expectedSignalName: "SIGILL", + }, + { + name: "null indirect function", + message: "RuntimeError: null function or function signature mismatch", + expectedSignum: SIGILL, + expectedSignalName: "SIGILL", + }, + { + name: "call_indirect signature mismatch", + message: "RuntimeError: call_indirect to a signature that does not match", + expectedSignum: SIGILL, + expectedSignalName: "SIGILL", + }, + { + name: "call_indirect null table entry", + message: "RuntimeError: call_indirect to a null table entry", + expectedSignum: SIGILL, + expectedSignalName: "SIGILL", + }, + { + name: "stack overflow", + message: "RangeError: Maximum call stack size exceeded", + expectedSignum: SIGSEGV, + expectedSignalName: "SIGSEGV", + }, + { + name: "stack exhausted", + message: "RuntimeError: call stack exhausted", + expectedSignum: SIGSEGV, + expectedSignalName: "SIGSEGV", + }, + { + name: "loader compile error", + message: "CompileError: WebAssembly.compile(): expected magic word", + expectedSignum: null, + expectedSignalName: null, + }, + { + name: "ABI mismatch", + message: "ABI version mismatch: program=1 kernel=2", + expectedSignum: null, + expectedSignalName: null, + }, +] as const; + +for (const trapCase of TRAP_MESSAGE_CASES) { + test(`@trap-signal classifies ${trapCase.name} in the browser`, async ({ + page, + baseURL, + browserName, + }) => { + expect(baseURL).toBeTruthy(); + const moduleUrl = new URL(`/@fs/${trapSignalsModulePath}`, baseURL).href; + + await page.goto(new URL("/trap-signal-test.html", baseURL).href); + const classification = await page.evaluate( + async ({ moduleUrl, message }) => { + const trapSignals = await import(/* @vite-ignore */ moduleUrl); + return trapSignals.classifyWasmCrashSignal(message) as { + signum: number; + signalName: string; + } | null; + }, + { moduleUrl, message: trapCase.message }, + ); + + if (trapCase.expectedSignum === null) { + expect(classification, `${browserName} ${trapCase.name}`).toBeNull(); + return; + } + + expect(classification, `${browserName} ${trapCase.name}`).toMatchObject({ + signum: trapCase.expectedSignum, + signalName: trapCase.expectedSignalName, + }); + }); +} diff --git a/examples/divzero_trap_test.c b/examples/divzero_trap_test.c new file mode 100644 index 000000000..36f85c967 --- /dev/null +++ b/examples/divzero_trap_test.c @@ -0,0 +1,15 @@ +/* + * Deliberately trigger a Wasm integer divide-by-zero trap. + */ +#include + +int main(void) +{ + fprintf(stderr, "before-divzero\n"); + fflush(stderr); + volatile int numerator = 1; + volatile int denominator = 0; + volatile int value = numerator / denominator; + fprintf(stderr, "after-divzero-SHOULD-NEVER-REACH:%d\n", value); + return 1; +} diff --git a/examples/oob_trap_test.c b/examples/oob_trap_test.c new file mode 100644 index 000000000..253917d6b --- /dev/null +++ b/examples/oob_trap_test.c @@ -0,0 +1,16 @@ +/* + * Deliberately dereference an address outside the configured wasm32 + * linear-memory maximum so the engine raises a memory OOB trap. + */ +#include +#include + +int main(void) +{ + fprintf(stderr, "before-oob\n"); + fflush(stderr); + volatile uint32_t *p = (volatile uint32_t *)(uintptr_t)0x7fffffffU; + volatile uint32_t value = *p; + fprintf(stderr, "after-oob-SHOULD-NEVER-REACH:%u\n", value); + return 1; +} diff --git a/examples/run-example.ts b/examples/run-example.ts index 1fec9a85d..5f44badec 100644 --- a/examples/run-example.ts +++ b/examples/run-example.ts @@ -59,6 +59,7 @@ const nanoWasm = tryResolveBinary("programs/nano.wasm"); const tclshWasm = tryResolveBinary("programs/tcl.wasm"); const testfixtureWasm = tryResolveBinary("programs/sqlite/testfixture.wasm"); const mysqltestWasm = tryResolveBinary("programs/mariadb/mysqltest.wasm"); +const echoWasm = tryResolveBinary("programs/echo.wasm") ?? resolve(repoRoot, "examples/echo.wasm"); // GNU coreutils multi-call binary supports all of these as argv[0] const coreutilsNames = [ @@ -73,9 +74,9 @@ const coreutilsNames = [ // Values may be null when a program isn't fetched/built locally. // Consumers filter out null entries before use. const builtinPrograms: Record = { - "echo": resolve(repoRoot, "examples/echo.wasm"), - "/bin/echo": resolve(repoRoot, "examples/echo.wasm"), - "/usr/bin/echo": resolve(repoRoot, "examples/echo.wasm"), + "echo": echoWasm, + "/bin/echo": echoWasm, + "/usr/bin/echo": echoWasm, "sh": dashWasm, "/bin/sh": dashWasm, "dash": dashWasm, @@ -257,12 +258,6 @@ function resolveProgram(path: string): ArrayBuffer | null { if (mapped) { return loadBytes(mapped); } - // execlp() searches the inherited host/dev-shell PATH. In CI that can - // resolve tools like gencat to /nix/store/.../bin/gencat; never load that - // host ELF as a guest program. - if (path.endsWith("/gencat")) { - return loadBytes(resolve(repoRoot, "examples/gencat.wasm")); - } const kernelCwd = process.env.KERNEL_CWD || process.cwd(); const candidates = [ path, @@ -280,6 +275,14 @@ function resolveProgram(path: string): ArrayBuffer | null { return null; } +function guestEnv(): string[] { + const kernelPath = process.env.KERNEL_PATH ?? "/usr/local/bin:/usr/bin:/bin"; + const inherited = Object.entries(process.env) + .filter(([k, v]) => v !== undefined && k !== "PATH") + .map(([k, v]) => `${k}=${v}`); + return [...inherited, `PATH=${kernelPath}`]; +} + async function main() { const name = process.argv[2]; if (!name) { @@ -340,9 +343,7 @@ async function main() { const timeoutMs = parseInt(process.env.TIMEOUT || "30000", 10); const exitPromise = host.spawn(loadBytes(programPath), processArgv, { env: [ - ...Object.entries(process.env) - .filter(([, v]) => v !== undefined) - .map(([k, v]) => `${k}=${v}`), + ...guestEnv(), ...gitEnv, ], cwd: process.env.KERNEL_CWD || process.cwd(), diff --git a/examples/wasm_trap_test.c b/examples/wasm_trap_test.c index 0ae0f9b33..bfc5966cc 100644 --- a/examples/wasm_trap_test.c +++ b/examples/wasm_trap_test.c @@ -13,8 +13,8 @@ * promise never resolves and tests time out. * * With the fix, this program terminates promptly and `spawn()` - * resolves. Expected exit code is 0 because worker-main treats - * `unreachable` as the normal `_Exit` exit pattern. + * resolves. An arbitrary user-space `unreachable` is classified as + * SIGILL; only the known kernel_exit path is treated as normal exit. */ #include diff --git a/host/src/browser-kernel-worker-entry.ts b/host/src/browser-kernel-worker-entry.ts index 41d81dc73..6ba172d35 100644 --- a/host/src/browser-kernel-worker-entry.ts +++ b/host/src/browser-kernel-worker-entry.ts @@ -64,6 +64,7 @@ import { CentralizedKernelWorker } from "./kernel-worker"; import type { ForkFromThreadContext, ResolvedSpawnProgram, + SpawnProgramResolution, } from "./kernel-worker"; import type { KernelPointer } from "./kernel"; import { BrowserWorkerAdapter } from "./worker-adapter-browser"; @@ -78,8 +79,14 @@ import { import type { MountConfig } from "./vfs/types"; import { TlsNetworkBackend } from "./networking/tls-network-backend"; import { patchWasmForThread } from "./worker-main"; -import { detectPtrWidth, extractHeapBase } from "./constants"; +import { detectPtrWidth, extractHeapBase, isWasmModuleBytes } from "./constants"; import { ThreadExitCoordinator } from "./thread-exit-coordinator"; +import { + classifiedSignalOrFallback, + classifiedTrapExitStatus, + signalExitStatus, + SIGSEGV, +} from "./trap-signals"; import type { CentralizedWorkerInitMessage, CentralizedThreadInitMessage, @@ -110,6 +117,7 @@ let io: VirtualPlatformIO; let maxPages: number = DEFAULT_MAX_PAGES; let defaultThreadSlots: number = DEFAULT_PROCESS_THREAD_SLOTS; let defaultEnv: string[] = []; +const ENOEXEC = 8; // Process tracking interface ProcessInfo { @@ -159,14 +167,17 @@ async function resolveExecutableForLaunch( path: string, argv: string[], depth = 0, -): Promise { +): Promise { if (depth > MAX_SHEBANG_DEPTH) return null; await memfs.ensureMaterialized(path); const bytes = readFileFromFs(path); if (!bytes) return null; const shebang = parseShebang(bytes); - if (!shebang) return { programBytes: bytes, argv }; + if (!shebang) { + if (!isWasmModuleBytes(bytes)) return { errno: ENOEXEC }; + return { programBytes: bytes, argv }; + } const scriptArgv = [ shebang.interpreter, @@ -639,6 +650,11 @@ async function handleSpawn(msg: Extract) return; } + if (!isWasmModuleBytes(programBytes)) { + respondError(msg.requestId, "ENOEXEC: program is not a WebAssembly module"); + return; + } + // Pid: if the caller pre-picked one, honor it (legacy spawn() callers // still do); otherwise the worker is the source of truth and allocates. const pid = msg.pid ?? kernelWorker.allocatePid(); @@ -737,7 +753,7 @@ function installProcessWorkerListeners( pid: number, ): void { let exited = false; - const finalize = (status: number, source: string) => { + const finalize = (status: number, source: string, crashSignum?: number) => { if (exited) return; exited = true; if (processes.get(pid)?.worker !== worker) return; // already replaced (e.g. by exec) @@ -747,19 +763,20 @@ function installProcessWorkerListeners( } else { console.warn(message); } - handleExit(pid, status); + handleExit(pid, status, crashSignum); }; - // Status conventions match the Node host (PR #410): - // 139 = 128 + SIGSEGV (11) — uncaught wasm trap, worker died without - // a SYS_exit_group. Matches a Linux child killed by SIGSEGV. - // -1 — worker-main caught an instantiation/init error and posted - // {type:"error"}. Same convention as Node-side handleSpawn. + // Status conventions match the Node host: + // 128+signal — classified Wasm trap, or generic SIGSEGV when a worker + // dies without a trap reason. Matches Linux signal-death status. + // -1 — worker-main caught an unclassified instantiation/init error + // and posted {type:"error"}. // m.status — worker-main posted {type:"exit"}, normal exit path. worker.on("error", (err: Error) => { if (intentionallyTerminated.has(worker as object)) return; console.error(`[kernel-worker] Worker error pid=${pid}:`, err.message); - finalize(128 + 11, "worker.onerror"); + const signum = classifiedSignalOrFallback(err); + finalize(signalExitStatus(signum), "worker.onerror", signum); }); worker.on("exit", (code: number) => { // BrowserWorkerHandle synthesizes an "exit" event when the underlying @@ -773,7 +790,7 @@ function installProcessWorkerListeners( // finalized via the "error" handler above, so this is a no-op there. // If "exit" fires without a prior "error" (worker died via some path // we don't yet model), still treat it as a crash. - finalize(128 + 11, "worker exit event"); + finalize(signalExitStatus(SIGSEGV), "worker exit event", SIGSEGV); }); worker.on("message", (msg: unknown) => { const m = msg as { type?: string; message?: string; pid?: number; status?: number }; @@ -789,7 +806,8 @@ function installProcessWorkerListeners( `[process-worker] ${m.message ?? "unknown error"}\n`, ); post({ type: "stderr", pid, data: errBytes }); - finalize(-1, "worker-main error message"); + const signum = classifiedSignalOrFallback(m.message); + finalize(classifiedTrapExitStatus(m.message) ?? -1, "worker-main error message", signum); } else if (m.type === "exit") { finalize(m.status ?? 0, "worker-main exit message"); } @@ -881,6 +899,7 @@ async function handleExec( ): Promise { const resolved = await resolveExecutableForLaunch(path, argv); if (!resolved) return -2; // ENOENT + if ("errno" in resolved) return -resolved.errno; const { programBytes: bytes, argv: launchArgv } = resolved; // Program found — run kernel exec setup @@ -996,7 +1015,7 @@ async function handleExec( async function handlePosixSpawnResolve( path: string, argv: string[], -): Promise { +): Promise { return resolveExecutableForLaunch(path, argv); } @@ -1189,11 +1208,19 @@ function handleThreadExit(pid: number, channelOffset: number): boolean { return threadExits.requestExit(pid, channelOffset); } -function handleExit(pid: number, exitStatus: number): void { - void finishProcessExit(pid, exitStatus); +function signalFromExitStatus(exitStatus: number): number | null { + return exitStatus >= 128 ? (exitStatus - 128) & 0x7f : null; } -async function finishProcessExit(pid: number, exitStatus: number): Promise { +function handleExit(pid: number, exitStatus: number, crashSignum?: number): void { + void finishProcessExit(pid, exitStatus, crashSignum); +} + +async function finishProcessExit( + pid: number, + exitStatus: number, + crashSignum: number = signalFromExitStatus(exitStatus) ?? SIGSEGV, +): Promise { if (processTeardowns.has(pid)) return; const info = processes.get(pid); @@ -1207,7 +1234,7 @@ async function finishProcessExit(pid: number, exitStatus: number): Promise threadedProcessPids.delete(pid); const teardown = (async () => { - // Synthesize a SIGSEGV-style reap *before* `deactivateProcess` in + // Synthesize a signal-style reap *before* `deactivateProcess` in // case the worker died without sending SYS_EXIT_GROUP (uncaught // wasm trap -> onerror, worker-main `{type:"error"}` -> finalize(-1), // externally terminated Worker -> "exit" event). Without this, a @@ -1216,7 +1243,7 @@ async function finishProcessExit(pid: number, exitStatus: number): Promise // `hostReaped`: when the kernel already processed a clean // SYS_EXIT_GROUP for this pid, this is a no-op. Mirrors // `finalizeProcessWorker` in host/src/node-kernel-worker-entry.ts. - try { kernelWorker.notifyHostProcessCrashed(pid); } catch { /* best-effort */ } + try { kernelWorker.notifyHostProcessCrashed(pid, crashSignum); } catch { /* best-effort */ } // Check if this is a "top-level" process or a fork child // For now, always deactivate — the main thread tracks exit promises kernelWorker.deactivateProcess(pid); diff --git a/host/src/constants.ts b/host/src/constants.ts index 8359c18de..b0188ca70 100644 --- a/host/src/constants.ts +++ b/host/src/constants.ts @@ -20,6 +20,20 @@ export const DEFAULT_MAX_PAGES = PROCESS_MEMORY_DEFAULT_MAX_PAGES; export const PAGES_PER_THREAD = PROCESS_MEMORY_PAGES_PER_THREAD_SLOT; export const PAGES_PER_THREAD_SLOT = PROCESS_MEMORY_PAGES_PER_THREAD_SLOT; +/** Return true when bytes start with a WebAssembly module header. */ +export function isWasmModuleBytes(programBytes: ArrayBuffer): boolean { + const src = new Uint8Array(programBytes); + return src.length >= 8 && + src[0] === 0x00 && + src[1] === 0x61 && + src[2] === 0x73 && + src[3] === 0x6d && + src[4] === 0x01 && + src[5] === 0x00 && + src[6] === 0x00 && + src[7] === 0x00; +} + /** * Read an unsigned LEB128 starting at `off`. * Returns [value, bytesConsumed]. diff --git a/host/src/kernel-worker.ts b/host/src/kernel-worker.ts index 29e883fff..a8dfcbcb7 100644 --- a/host/src/kernel-worker.ts +++ b/host/src/kernel-worker.ts @@ -505,7 +505,19 @@ export interface ResolvedSpawnProgram { argv: string[]; } -export type SpawnProgramResolution = ArrayBuffer | ResolvedSpawnProgram; +export interface SpawnResolveError { + errno: number; +} + +export type SpawnProgramResolution = ArrayBuffer | ResolvedSpawnProgram | SpawnResolveError; + +function isSpawnResolveError( + resolution: SpawnProgramResolution, +): resolution is SpawnResolveError { + return !(resolution instanceof ArrayBuffer) && + "errno" in resolution && + typeof resolution.errno === "number"; +} /** Callbacks for fork/exec/exit handling. */ export interface CentralizedKernelCallbacks { @@ -548,7 +560,8 @@ export interface CentralizedKernelCallbacks { /** * Pre-flight resolution step for SYS_SPAWN. Returns the program bytes * for `path` (or `{ programBytes, argv }` when resolution rewrites argv, - * e.g. a shebang script), or `null` for ENOENT. **Must NOT have side effects** — + * e.g. a shebang script), `{ errno }` for a located but unlaunchable + * program, or `null` for ENOENT. **Must NOT have side effects** — * `handleSpawn` calls this BEFORE `kernel_spawn_process` so that file * actions never run on a doomed PATH-iteration. POSIX requires * file_actions to run "exactly once," and `posix_spawnp`'s PATH-walk @@ -5761,6 +5774,10 @@ export class CentralizedKernelWorker { this.completeChannel(channel, SYS_SPAWN, origArgs, undefined, -1, 2); // ENOENT return; } + if (isSpawnResolveError(resolved)) { + this.completeChannel(channel, SYS_SPAWN, origArgs, undefined, -1, resolved.errno >>> 0); + return; + } const programBytes = resolved instanceof ArrayBuffer ? resolved : resolved.programBytes; const launchArgv = resolved instanceof ArrayBuffer ? argv : resolved.argv; this.handleSpawnAfterResolve( diff --git a/host/src/node-kernel-host.ts b/host/src/node-kernel-host.ts index 00b7ad66f..d79d7c58d 100644 --- a/host/src/node-kernel-host.ts +++ b/host/src/node-kernel-host.ts @@ -12,7 +12,7 @@ * const exitCode = await host.spawn(programBytes, ["hello"], { env: [...] }); * await host.destroy(); */ -import { readFileSync, existsSync } from "node:fs"; +import { readFileSync, existsSync, statSync } from "node:fs"; import { join, dirname } from "node:path"; import { fileURLToPath } from "node:url"; import { pathToFileURL } from "node:url"; @@ -553,10 +553,10 @@ function spawnKernelWorkerThread(): NodeThreadWorker { const distJs = entryTs.replace(/\/src\/([^/]+)\.ts$/, "/dist/$1.js"); // Check for compiled .js version first (much faster startup) - if (existsSync(distJs)) { + if (compiledEntryIsCurrent(entryTs, distJs)) { return new NodeThreadWorker(distJs); } - if (existsSync(entryJs)) { + if (compiledEntryIsCurrent(entryTs, entryJs)) { return new NodeThreadWorker(entryJs); } @@ -572,3 +572,9 @@ function spawnKernelWorkerThread(): NodeThreadWorker { ].join("\n"); return new NodeThreadWorker(bootstrap, { eval: true }); } + +function compiledEntryIsCurrent(sourcePath: string, compiledPath: string): boolean { + if (!existsSync(compiledPath)) return false; + if (!existsSync(sourcePath)) return true; + return statSync(compiledPath).mtimeMs >= statSync(sourcePath).mtimeMs; +} diff --git a/host/src/node-kernel-worker-entry.ts b/host/src/node-kernel-worker-entry.ts index aafd081f5..431e833e6 100644 --- a/host/src/node-kernel-worker-entry.ts +++ b/host/src/node-kernel-worker-entry.ts @@ -19,7 +19,11 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import { fileURLToPath } from "node:url"; import { CentralizedKernelWorker } from "./kernel-worker"; -import type { ForkFromThreadContext, ResolvedSpawnProgram } from "./kernel-worker"; +import type { + ForkFromThreadContext, + ResolvedSpawnProgram, + SpawnProgramResolution, +} from "./kernel-worker"; import { NodePlatformIO } from "./platform/node"; import { VirtualPlatformIO, @@ -37,8 +41,14 @@ import { NodeWorkerAdapter } from "./worker-adapter"; import { ThreadPageAllocator } from "./thread-allocator"; import { patchWasmForThread } from "./worker-main"; import { ThreadExitCoordinator } from "./thread-exit-coordinator"; -import { detectPtrWidth, extractHeapBase } from "./constants"; +import { detectPtrWidth, extractHeapBase, isWasmModuleBytes } from "./constants"; import { CH_TOTAL_SIZE, DEFAULT_MAX_PAGES, PAGES_PER_THREAD, WASM_PAGE_SIZE } from "./constants"; +import { + classifiedSignalOrFallback, + classifiedTrapExitStatus, + signalExitStatus, + SIGSEGV, +} from "./trap-signals"; import { computeProcessMemoryLayout, createProcessMemory, @@ -79,6 +89,7 @@ let rootfsMemfs: MemoryFileSystem | null = null; /** Per-boot scratch directory; cleaned up on `destroy`. Only set when the * worker constructs a `VirtualPlatformIO` from the default mount spec. */ let sessionDir: string | null = null; +const ENOEXEC = 8; // Process tracking interface ProcessInfo { @@ -107,9 +118,9 @@ const intentionallyTerminated = new WeakSet(); * the host's spawn promise would hang waiting for an exit notification * that never comes. This listener detects that case — when the worker we * registered here is *still* the one bound to `pid` in `processes` and we - * didn't terminate it ourselves — and synthesizes a crash exit so the - * host learns the process is gone. Encoded as 128+SIGSEGV (139) by - * convention for "killed by signal 11". + * didn't terminate it ourselves — and synthesizes a SIGSEGV crash exit + * so the host learns the process is gone. There is no reliable trap + * reason on this path, so it keeps the generic 128+SIGSEGV convention. */ function installCrashSafetyNet( worker: ReturnType, @@ -123,7 +134,7 @@ function installCrashSafetyNet( `[process-worker] pid=${pid} crashed (worker exit code=${code}, no SYS_exit_group from wasm)\n`, ); post({ type: "stderr", pid, data: errBytes }); - void finalizeProcessWorker(pid, worker, 128 + 11 /* SIGSEGV */); + void finalizeProcessWorker(pid, worker, signalExitStatus(SIGSEGV), SIGSEGV); }); } @@ -170,6 +181,10 @@ function reportProcessExit(pid: number, status: number): void { post({ type: "exit", pid, status }); } +function signalFromExitStatus(exitStatus: number): number | null { + return exitStatus >= 128 ? (exitStatus - 128) & 0x7f : null; +} + // PTY index per-PID const ptyByPid = new Map(); @@ -198,17 +213,18 @@ async function finalizeProcessWorker( pid: number, worker: ReturnType, exitStatus: number, + crashSignum: number = signalFromExitStatus(exitStatus) ?? SIGSEGV, ): Promise { const cur = processes.get(pid); if (cur && cur.worker === worker) { - // Synthesize a SIGSEGV-style reap *before* `deactivateProcess` in + // Synthesize a signal-style reap *before* `deactivateProcess` in // case the worker died without sending SYS_EXIT_GROUP (uncaught // wasm trap, instantiation failure → `{type:"error"}` path). // Without this, a concurrent waitpid in the parent blocks until // destroy because the kernel never marked the child as a zombie. // Idempotent via `hostReaped`: when the kernel already processed // a clean SYS_EXIT_GROUP for this pid, this is a no-op. - try { kernelWorker.notifyHostProcessCrashed(pid); } catch { /* best-effort */ } + try { kernelWorker.notifyHostProcessCrashed(pid, crashSignum); } catch { /* best-effort */ } try { kernelWorker.deactivateProcess(pid); } catch { /* best-effort */ } processes.delete(pid); threadModuleCache.delete(pid); @@ -219,6 +235,48 @@ async function finalizeProcessWorker( reportProcessExit(pid, exitStatus); } +function processWorkerErrorDisposition(reason: string | undefined): { + exitStatus: number; + signum: number; +} { + return { + exitStatus: classifiedTrapExitStatus(reason) ?? -1, + signum: classifiedSignalOrFallback(reason), + }; +} + +function unexpectedWorkerCrashDisposition(reason: unknown): { + exitStatus: number; + signum: number; +} { + const signum = classifiedSignalOrFallback(reason); + return { exitStatus: signalExitStatus(signum), signum }; +} + +function finalizeProcessWorkerError( + pid: number, + worker: ReturnType, + message: string | undefined, +): void { + const errBytes = new TextEncoder().encode(`[process-worker] ${message ?? "unknown error"}\n`); + post({ type: "stderr", pid, data: errBytes }); + const { exitStatus, signum } = processWorkerErrorDisposition(message); + void finalizeProcessWorker(pid, worker, exitStatus, signum); +} + +function finalizeUnexpectedWorkerError( + pid: number, + worker: ReturnType, + label: string, + err: unknown, +): void { + const message = err instanceof Error ? (err.message ?? String(err)) : String(err); + const errBytes = new TextEncoder().encode(`[kernel-worker] pid=${pid}: ${label}: ${message}\n`); + post({ type: "stderr", pid, data: errBytes }); + const { exitStatus, signum } = unexpectedWorkerCrashDisposition(err); + void finalizeProcessWorker(pid, worker, exitStatus, signum); +} + function post(msg: KernelToMainMessage) { port.postMessage(msg); } @@ -411,13 +469,16 @@ async function resolveExecutableForLaunch( path: string, argv: string[], depth = 0, -): Promise { +): Promise { if (depth > MAX_SHEBANG_DEPTH) return null; const bytes = await resolveExec(path); if (!bytes) return null; const shebang = parseShebang(bytes); - if (!shebang) return { programBytes: bytes, argv }; + if (!shebang) { + if (!isWasmModuleBytes(bytes)) return { errno: ENOEXEC }; + return { programBytes: bytes, argv }; + } const scriptArgv = [ shebang.interpreter, @@ -540,20 +601,6 @@ async function handleInit(msg: InitMessage) { post({ type: "ready" }); } -// Init-time failure path. centralizedWorkerMain catches its own throws and -// posts {type:"error"} — without surfacing those, spawn() hangs on exitResolvers. -function failProcess(pid: number, reason: string) { - const text = `[kernel-worker] pid=${pid}: ${reason}\n`; - post({ type: "stderr", pid, data: new TextEncoder().encode(text) }); - try { kernelWorker.deactivateProcess(pid); } catch {} - const info = processes.get(pid); - info?.worker.terminate().catch(() => {}); - processes.delete(pid); - threadModuleCache.delete(pid); - ptyByPid.delete(pid); - reportProcessExit(pid, -1); -} - // --- Spawn --- function handleSpawn(msg: SpawnMessage) { @@ -564,6 +611,11 @@ function handleSpawn(msg: SpawnMessage) { } const pid = nextSpawnPid++; + if (!isWasmModuleBytes(msg.programBytes)) { + respondError(msg.requestId, "ENOEXEC: program is not a WebAssembly module"); + return; + } + const ptrWidth = detectPtrWidth(msg.programBytes); const { memory, @@ -633,11 +685,7 @@ function handleSpawn(msg: SpawnMessage) { threadAllocator, }); - worker.on("error", (err: Error) => failProcess(pid, `worker error: ${err.message ?? err}`)); - worker.on("message", (m: unknown) => { - const wmsg = m as WorkerToHostMessage; - if (wmsg.type === "error") failProcess(pid, wmsg.message); - }); + worker.on("error", (err: Error) => finalizeUnexpectedWorkerError(pid, worker, "worker error", err)); // Process-worker top-level catch in worker-main posts {type:"error"} // for instantiation failures (ABI mismatch, link errors). Without @@ -647,9 +695,7 @@ function handleSpawn(msg: SpawnMessage) { worker.on("message", (raw: unknown) => { const m = raw as { type: string; pid?: number; message?: string; status?: number }; if (m.type === "error" && m.pid === pid) { - const errBytes = new TextEncoder().encode(`[process-worker] ${m.message ?? "unknown error"}\n`); - post({ type: "stderr", pid, data: errBytes }); - void finalizeProcessWorker(pid, worker, -1); + finalizeProcessWorkerError(pid, worker, m.message); } else if (m.type === "exit" && m.pid === pid) { // worker-main posts {type:"exit"} when _start returns or hits an // "unreachable" trap (the latter is treated as normal _Exit). If @@ -737,18 +783,12 @@ async function handleFork( threadAllocator: threadAllocatorForLayout(childLayout, ptrWidth, childPid), }); - childWorker.on("error", (err: Error) => failProcess(childPid, `worker error: ${err.message ?? err}`)); - childWorker.on("message", (m: unknown) => { - const wmsg = m as WorkerToHostMessage; - if (wmsg.type === "error") failProcess(childPid, wmsg.message); - }); + childWorker.on("error", (err: Error) => finalizeUnexpectedWorkerError(childPid, childWorker, "worker error", err)); childWorker.on("message", (raw: unknown) => { const m = raw as { type: string; pid?: number; message?: string; status?: number }; if (m.type === "error" && m.pid === childPid) { - const errBytes = new TextEncoder().encode(`[process-worker] ${m.message ?? "unknown error"}\n`); - post({ type: "stderr", pid: childPid, data: errBytes }); - void finalizeProcessWorker(childPid, childWorker, -1); + finalizeProcessWorkerError(childPid, childWorker, m.message); } else if (m.type === "exit" && m.pid === childPid) { void finalizeProcessWorker(childPid, childWorker, m.status ?? 0); } @@ -767,6 +807,7 @@ async function handleExec( ): Promise { const resolved = await resolveExecutableForLaunch(path, argv); if (!resolved) return -2; // ENOENT + if ("errno" in resolved) return -resolved.errno; const { programBytes, argv: launchArgv } = resolved; const newPtrWidth = detectPtrWidth(programBytes); @@ -827,11 +868,7 @@ async function handleExec( threadAllocator: newThreadAllocator, }); - newWorker.on("error", (err: Error) => failProcess(pid, `exec worker error: ${err.message ?? err}`)); - newWorker.on("message", (m: unknown) => { - const wmsg = m as WorkerToHostMessage; - if (wmsg.type === "error") failProcess(pid, wmsg.message); - }); + newWorker.on("error", (err: Error) => finalizeUnexpectedWorkerError(pid, newWorker, "exec worker error", err)); // Forward worker-main top-level errors (instantiation failures, // uncaught wasm traps) so the host learns the process died — same @@ -839,9 +876,7 @@ async function handleExec( newWorker.on("message", (raw: unknown) => { const m = raw as { type: string; pid?: number; message?: string; status?: number }; if (m.type === "error" && m.pid === pid) { - const errBytes = new TextEncoder().encode(`[process-worker] ${m.message ?? "unknown error"}\n`); - post({ type: "stderr", pid, data: errBytes }); - void finalizeProcessWorker(pid, newWorker, -1); + finalizeProcessWorkerError(pid, newWorker, m.message); } else if (m.type === "exit" && m.pid === pid) { void finalizeProcessWorker(pid, newWorker, m.status ?? 0); } @@ -881,7 +916,7 @@ async function handleExec( async function handlePosixSpawnResolve( path: string, argv: string[], -): Promise { +): Promise { return resolveExecutableForLaunch(path, argv); } @@ -942,18 +977,12 @@ async function handlePosixSpawn( threadAllocator, }); - newWorker.on("error", (err: Error) => failProcess(childPid, `spawn worker error: ${err.message ?? err}`)); - newWorker.on("message", (m: unknown) => { - const wmsg = m as WorkerToHostMessage; - if (wmsg.type === "error") failProcess(childPid, wmsg.message); - }); + newWorker.on("error", (err: Error) => finalizeUnexpectedWorkerError(childPid, newWorker, "spawn worker error", err)); newWorker.on("message", (raw: unknown) => { const m = raw as { type: string; pid?: number; message?: string; status?: number }; if (m.type === "error" && m.pid === childPid) { - const errBytes = new TextEncoder().encode(`[process-worker] ${m.message ?? "unknown error"}\n`); - post({ type: "stderr", pid: childPid, data: errBytes }); - void finalizeProcessWorker(childPid, newWorker, -1); + finalizeProcessWorkerError(childPid, newWorker, m.message); } else if (m.type === "exit" && m.pid === childPid) { void finalizeProcessWorker(childPid, newWorker, m.status ?? 0); } diff --git a/host/src/trap-signals.ts b/host/src/trap-signals.ts new file mode 100644 index 000000000..eb5a204c3 --- /dev/null +++ b/host/src/trap-signals.ts @@ -0,0 +1,138 @@ +export const SIGILL = 4; +export const SIGFPE = 8; +export const SIGSEGV = 11; + +export type WasmCrashCategory = + | "memory" + | "bounds" + | "stack" + | "arithmetic" + | "illegal-instruction"; + +export interface WasmCrashSignalClassification { + category: WasmCrashCategory; + signum: number; + signalName: "SIGILL" | "SIGFPE" | "SIGSEGV"; + matched: string; +} + +interface TrapPattern { + category: WasmCrashCategory; + signum: number; + signalName: WasmCrashSignalClassification["signalName"]; + patterns: RegExp[]; +} + +const TRAP_PATTERNS: TrapPattern[] = [ + { + category: "arithmetic", + signum: SIGFPE, + signalName: "SIGFPE", + patterns: [ + /divide by zero/i, + /division by zero/i, + /remainder by zero/i, + /integer overflow/i, + /integer divide by zero/i, + ], + }, + { + category: "memory", + signum: SIGSEGV, + signalName: "SIGSEGV", + patterns: [ + /memory access out of bounds/i, + /out of bounds memory access/i, + /out-of-bounds memory/i, + /index out of bounds.*memory/i, + /memory out of bounds/i, + ], + }, + { + category: "bounds", + signum: SIGSEGV, + signalName: "SIGSEGV", + patterns: [ + /RuntimeError:[^\n]*\bindex out of bounds\b/i, + /table index (?:is )?out of bounds/i, + /table index (?:is )?outside/i, + /out of bounds call_indirect/i, + /indirect call.*out of bounds/i, + ], + }, + { + category: "illegal-instruction", + signum: SIGILL, + signalName: "SIGILL", + patterns: [ + /\bunreachable\b/i, + /call_indirect.*null/i, + /call_indirect.*type mismatch/i, + /call_indirect.*signature.*does not match/i, + /indirect call.*null/i, + /indirect call.*type mismatch/i, + /function signature mismatch/i, + /signature mismatch/i, + /signature.*does not match/i, + /type mismatch/i, + /null function/i, + /undefined element/i, + /uninitialized element/i, + ], + }, + { + category: "stack", + signum: SIGSEGV, + signalName: "SIGSEGV", + patterns: [ + /maximum call stack/i, + /call stack size exceeded/i, + /call stack exhausted/i, + /stack overflow/i, + /stack exhausted/i, + ], + }, +]; + +function crashText(reason: unknown): string { + if (reason instanceof Error) { + return reason.stack ? `${reason.message}\n${reason.stack}` : reason.message; + } + return String(reason ?? ""); +} + +export function classifyWasmCrashSignal(reason: unknown): WasmCrashSignalClassification | null { + const text = crashText(reason); + if (!text) return null; + + for (const group of TRAP_PATTERNS) { + for (const pattern of group.patterns) { + const match = pattern.exec(text); + if (!match) continue; + return { + category: group.category, + signum: group.signum, + signalName: group.signalName, + matched: match[0], + }; + } + } + + return null; +} + +export function signalExitStatus(signum: number): number { + return 128 + signum; +} + +export function classifiedSignalOrFallback( + reason: unknown, + fallback: number = SIGSEGV, +): number { + return classifyWasmCrashSignal(reason)?.signum ?? fallback; +} + +export function classifiedTrapExitStatus(reason: unknown): number | null { + const classification = classifyWasmCrashSignal(reason); + return classification ? signalExitStatus(classification.signum) : null; +} diff --git a/host/test/centralized-spawn.test.ts b/host/test/centralized-spawn.test.ts index 44eba32da..ee078c5b9 100644 --- a/host/test/centralized-spawn.test.ts +++ b/host/test/centralized-spawn.test.ts @@ -10,6 +10,8 @@ */ import { describe, expect, it } from "vitest"; +import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; import { join, dirname } from "node:path"; import { fileURLToPath } from "node:url"; import { runCentralizedProgram } from "./centralized-test-helper"; @@ -33,6 +35,7 @@ describe("non-forking posix_spawn", () => { execPrograms: new Map([ ["/usr/bin/hello", helloWasm], ]), + useDefaultRootfs: false, timeout: 30_000, captureForkCount: true, }); @@ -59,6 +62,7 @@ describe("non-forking posix_spawn", () => { ["/usr/bin/hello", helloWasm], ["/usr/bin/spawn-pause", spawnPauseWasm], ]), + useDefaultRootfs: false, timeout: 60_000, captureForkCount: true, }); @@ -71,4 +75,29 @@ describe("non-forking posix_spawn", () => { // GUARDRAIL: three posix_spawn calls and zero fork bumps. expect(result.forkCount).toBe(0n); }); + + it("reports ENOEXEC for non-Wasm spawn targets before launching a worker", async () => { + const tempDir = mkdtempSync(join(tmpdir(), "kandelo-enoexec-")); + const nativeLikeBinary = join(tempDir, "not-wasm"); + try { + writeFileSync(nativeLikeBinary, Buffer.from([0x7f, 0x45, 0x4c, 0x46, 0, 0, 0, 0])); + + const result = await runCentralizedProgram({ + programPath: spawnSmokeWasm, + argv: ["spawn-smoke", "/usr/bin/not-wasm"], + execPrograms: new Map([ + ["/usr/bin/not-wasm", nativeLikeBinary], + ]), + useDefaultRootfs: false, + timeout: 30_000, + }); + + expect(result.exitCode).toBe(1); + expect(result.stderr).toContain("Exec format error"); + expect(result.stderr).not.toContain("Centralized worker failed"); + expect(result.stderr).not.toContain("WebAssembly.compile()"); + } finally { + rmSync(tempDir, { recursive: true, force: true }); + } + }); }); diff --git a/host/test/centralized-test-helper.ts b/host/test/centralized-test-helper.ts index 47cf7936d..ac371ef9f 100644 --- a/host/test/centralized-test-helper.ts +++ b/host/test/centralized-test-helper.ts @@ -136,6 +136,8 @@ export interface RunProgramOptions { * only (NodeKernelHost.getForkCount); main-thread mode falls back to * reading from the kernel instance directly. */ captureForkCount?: boolean; + /** Use the canonical rootfs image in worker-thread mode. Defaults to true. */ + useDefaultRootfs?: boolean; } export interface RunProgramResult { @@ -202,7 +204,7 @@ async function runInWorkerThread(options: RunProgramOptions): Promise { stdout += new TextDecoder().decode(data); diff --git a/host/test/global-setup.ts b/host/test/global-setup.ts index 617576f82..1b65de356 100644 --- a/host/test/global-setup.ts +++ b/host/test/global-setup.ts @@ -25,7 +25,14 @@ const TEST_PROGRAMS = [ "getaddrinfo_test.c", "sysv_ipc_test.c", "wasm_trap_test.c", + "oob_trap_test.c", + "divzero_trap_test.c", "abort_test.c", + "echo.c", + "hello.c", + "spawn-smoke.c", + "spawn-coverage.c", + "spawn-pause.c", "mount_probe_test.c", "getpwent_smoke.c", "thread-exit-group.c", diff --git a/host/test/trap-signals.test.ts b/host/test/trap-signals.test.ts new file mode 100644 index 000000000..c78a1a3ba --- /dev/null +++ b/host/test/trap-signals.test.ts @@ -0,0 +1,109 @@ +import { describe, expect, it } from "vitest"; +import { + classifiedSignalOrFallback, + classifiedTrapExitStatus, + classifyWasmCrashSignal, + signalExitStatus, + SIGFPE, + SIGILL, + SIGSEGV, +} from "../src/trap-signals"; + +describe("Wasm trap signal classification", () => { + it("maps memory and stack traps to SIGSEGV", () => { + expect(classifyWasmCrashSignal("RuntimeError: memory access out of bounds")).toMatchObject({ + category: "memory", + signum: SIGSEGV, + signalName: "SIGSEGV", + }); + expect(classifyWasmCrashSignal("RuntimeError: Out of bounds memory access")).toMatchObject({ + category: "memory", + signum: SIGSEGV, + }); + expect(classifyWasmCrashSignal("RangeError: Maximum call stack size exceeded")).toMatchObject({ + category: "stack", + signum: SIGSEGV, + }); + expect(classifyWasmCrashSignal("RuntimeError: call stack exhausted")).toMatchObject({ + category: "stack", + signum: SIGSEGV, + }); + }); + + it("maps generic Wasm bounds traps to SIGSEGV", () => { + for (const message of [ + "RuntimeError: index out of bounds", + "RuntimeError: table index is out of bounds", + "RuntimeError: Out of bounds call_indirect", + ]) { + expect(classifyWasmCrashSignal(message), message).toMatchObject({ + category: "bounds", + signum: SIGSEGV, + signalName: "SIGSEGV", + }); + } + }); + + it("maps arithmetic traps to SIGFPE", () => { + for (const message of [ + "RuntimeError: divide by zero", + "RuntimeError: integer divide by zero", + "RuntimeError: integer overflow", + "RuntimeError: remainder by zero", + ]) { + expect(classifyWasmCrashSignal(message), message).toMatchObject({ + category: "arithmetic", + signum: SIGFPE, + signalName: "SIGFPE", + }); + } + }); + + it("maps illegal control-flow traps to SIGILL", () => { + for (const message of [ + "RuntimeError: unreachable", + "RuntimeError: unreachable executed", + "RuntimeError: indirect call type mismatch", + "RuntimeError: null function or function signature mismatch", + "RuntimeError: call_indirect to a signature that does not match", + "RuntimeError: call_indirect to a null table entry", + ]) { + expect(classifyWasmCrashSignal(message), message).toMatchObject({ + category: "illegal-instruction", + signum: SIGILL, + signalName: "SIGILL", + }); + } + }); + + it("does not classify loader and ABI errors as Wasm trap causes", () => { + for (const message of [ + "CompileError: WebAssembly.compile(): expected magic word", + "LinkError: WebAssembly.instantiate(): Import #0 module=\"env\" error", + "ABI version mismatch: program=1 kernel=2", + ]) { + expect(classifyWasmCrashSignal(message), message).toBeNull(); + expect(classifiedTrapExitStatus(message), message).toBeNull(); + } + }); + + it("keeps call_indirect bounds traps separate from null indirect calls", () => { + const classification = classifyWasmCrashSignal("RuntimeError: Out of bounds call_indirect"); + expect(classification).toMatchObject({ + category: "bounds", + signum: SIGSEGV, + }); + expect(classifyWasmCrashSignal("RuntimeError: call_indirect to a null table entry")).toMatchObject({ + category: "illegal-instruction", + signum: SIGILL, + }); + }); + + it("returns POSIX-style signal exit statuses for classified traps", () => { + expect(signalExitStatus(SIGILL)).toBe(132); + expect(signalExitStatus(SIGFPE)).toBe(136); + expect(signalExitStatus(SIGSEGV)).toBe(139); + expect(classifiedTrapExitStatus("RuntimeError: divide by zero")).toBe(136); + expect(classifiedSignalOrFallback("not a wasm trap")).toBe(SIGSEGV); + }); +}); diff --git a/host/test/wasm-trap.test.ts b/host/test/wasm-trap.test.ts index 0ceb748a1..f48a0a346 100644 --- a/host/test/wasm-trap.test.ts +++ b/host/test/wasm-trap.test.ts @@ -9,7 +9,12 @@ * - `wasm_trap_test`: `__builtin_trap()` from main(). Worker-main * reports the unhandled `unreachable` * RuntimeError as a process failure; the host - * must still resolve spawn() promptly. + * maps it to SIGILL and resolves promptly. + * + * - `oob_trap_test`: Out-of-bounds linear-memory access maps to + * SIGSEGV. + * + * - `divzero_trap_test`: Integer divide-by-zero maps to SIGFPE. * * - `abort_test`: abort(). musl's abort() raises SIGABRT and * then loops on `for(;;) a_crash()` as a @@ -24,18 +29,25 @@ import { join, dirname } from "node:path"; import { fileURLToPath } from "node:url"; import { existsSync } from "node:fs"; import { runCentralizedProgram } from "./centralized-test-helper"; +import { signalExitStatus, SIGFPE, SIGILL, SIGSEGV } from "../src/trap-signals"; const __dirname = dirname(fileURLToPath(import.meta.url)); const wasmTrapBin = join(__dirname, "../../examples/wasm_trap_test.wasm"); +const oobTrapBin = join(__dirname, "../../examples/oob_trap_test.wasm"); +const divzeroTrapBin = join(__dirname, "../../examples/divzero_trap_test.wasm"); const abortBin = join(__dirname, "../../examples/abort_test.wasm"); -const programsBuilt = existsSync(wasmTrapBin) && existsSync(abortBin); +const programsBuilt = existsSync(wasmTrapBin) && + existsSync(oobTrapBin) && + existsSync(divzeroTrapBin) && + existsSync(abortBin); describe.skipIf(!programsBuilt)("wasm trap → host exit (regression)", () => { it("__builtin_trap() in user code: spawn() resolves promptly, no hang", async () => { const t0 = Date.now(); const { exitCode, stderr } = await runCentralizedProgram({ programPath: wasmTrapBin, + useDefaultRootfs: false, timeout: 5000, }); const elapsed = Date.now() - t0; @@ -44,7 +56,41 @@ describe.skipIf(!programsBuilt)("wasm trap → host exit (regression)", () => { expect(stderr).not.toContain("SHOULD-NEVER-REACH"); // Arbitrary `unreachable` traps are no longer masked as successful exits; // only the known kernel_exit path is interpreted as normal termination. - expect(exitCode).toBe(-1); + expect(exitCode).toBe(signalExitStatus(SIGILL)); + expect(stderr).toContain("RuntimeError"); + expect(stderr).toContain("unreachable"); + expect(elapsed).toBeLessThan(3000); + }, 8_000); + + it("out-of-bounds memory trap resolves as SIGSEGV", async () => { + const t0 = Date.now(); + const { exitCode, stderr } = await runCentralizedProgram({ + programPath: oobTrapBin, + useDefaultRootfs: false, + timeout: 5000, + }); + const elapsed = Date.now() - t0; + + expect(stderr).toContain("before-oob"); + expect(stderr).not.toContain("SHOULD-NEVER-REACH"); + expect(exitCode).toBe(signalExitStatus(SIGSEGV)); + expect(stderr).toContain("RuntimeError"); + expect(elapsed).toBeLessThan(3000); + }, 8_000); + + it("integer divide-by-zero trap resolves as SIGFPE", async () => { + const t0 = Date.now(); + const { exitCode, stderr } = await runCentralizedProgram({ + programPath: divzeroTrapBin, + useDefaultRootfs: false, + timeout: 5000, + }); + const elapsed = Date.now() - t0; + + expect(stderr).toContain("before-divzero"); + expect(stderr).not.toContain("SHOULD-NEVER-REACH"); + expect(exitCode).toBe(signalExitStatus(SIGFPE)); + expect(stderr).toContain("RuntimeError"); expect(elapsed).toBeLessThan(3000); }, 8_000); @@ -52,18 +98,19 @@ describe.skipIf(!programsBuilt)("wasm trap → host exit (regression)", () => { const t0 = Date.now(); const { exitCode, stderr } = await runCentralizedProgram({ programPath: abortBin, + useDefaultRootfs: false, timeout: 5000, }); const elapsed = Date.now() - t0; expect(stderr).toContain("before-abort"); expect(stderr).not.toContain("SHOULD-NEVER-REACH"); - // exitCode could legitimately be 0 (a_crash unreachable trap → - // worker-main's `_Exit` interpretation) or 134 (128+SIGABRT, when - // raise(SIGABRT) terminates via the kernel's default action). + // exitCode could legitimately be 132 (abort backstop's unreachable + // trap) or 134 (128+SIGABRT, when raise(SIGABRT) terminates via the + // kernel's default action). // Both are valid "process terminated" outcomes; the regression // we're guarding against is HANGING. - expect([0, 134]).toContain(exitCode); + expect([signalExitStatus(SIGILL), 134]).toContain(exitCode); expect(elapsed).toBeLessThan(3000); }, 8_000); }); diff --git a/scripts/ci-run-test-suite.sh b/scripts/ci-run-test-suite.sh index 6dc42e022..1298cbd38 100755 --- a/scripts/ci-run-test-suite.sh +++ b/scripts/ci-run-test-suite.sh @@ -42,8 +42,13 @@ case "$suite" in ( cd apps/browser-demos PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm ci --no-audit --no-fund - npx playwright install chromium - npx playwright test --grep-invert "@slow" --project=chromium + if [ "$(uname -s)" = "Linux" ]; then + PATH="/usr/bin:/bin:$PATH" npx playwright install --with-deps chromium firefox + else + npx playwright install chromium firefox + fi + npx playwright test --grep-invert "@slow|@trap-signal" --project=chromium + npx playwright test wasm-trap-signal.spec.ts --project=chromium --project=firefox ) ;; libc) diff --git a/scripts/run-libc-tests.sh b/scripts/run-libc-tests.sh index 1745962af..c33e2011e 100755 --- a/scripts/run-libc-tests.sh +++ b/scripts/run-libc-tests.sh @@ -241,6 +241,21 @@ build_math-relaxed() { instrument_wasm "$wasm" } +build_example_program() { + local name="$1" + local src="$REPO_ROOT/examples/${name}.c" + local wasm="$REPO_ROOT/examples/${name}.wasm" + + [ -f "$src" ] || return 0 + if [ -f "$wasm" ] && [ "$wasm" -nt "$src" ]; then + return 0 + fi + + "$CC" "${CFLAGS[@]}" \ + "$src" "${LINK_FLAGS[@]}" \ + -o "$wasm" 2>/tmp/libc-test-build-err.txt +} + # ── Run a single test ─────────────────────────────────────── run_test() { @@ -372,6 +387,12 @@ if [ ! -f "$KERNEL_WASM" ]; then echo "Error: kernel wasm not found. Run build.sh first." >&2 exit 1 fi +if ! build_example_program echo; then + err=$(head -5 /tmp/libc-test-build-err.txt 2>/dev/null || echo "(no error output)") + echo "Error: failed to build examples/echo.wasm" >&2 + echo "$err" | head -3 | sed 's/^/ /' >&2 + exit 1 +fi PASS=0 FAIL=0