fix: launcher, socket, process and system failures from the OpenJDK sweep

AGENTS.md

@@ -55,6 +55,8 @@ Node, which is how the tests run.
   `src/net-node.ts` host sockets, DNS and interfaces for Node
 - `src/node.ts` Node entry, over `build/jdk` or, built as `dist/node.js`, the
   packaged image (`src/image.ts`); `scripts/build-jdk.sh` builds `build/jdk`
+- `src/bootpath.ts` class files on the `-Xbootclasspath/a` and `--patch-module` paths;
+  `src/posixtz.ts` POSIX `TZ` rules such as `MEZ-1MESZ,M3.5.0,M10.5.0/3`
 - `src/http-proxy.ts` the browser's virtual HTTP proxy (`fetch`); `scripts/tls/` the
   `javaweb.tls` pass-through TLS provider it relies on for `https:`
 

docs/node.md

@@ -18,6 +18,7 @@ npx @project516/java-web [options] -jar app.jar [args]
 | `-ea`, `-da`, `-esa` and the rest | assertions, as with `java` |
 | `--enable-preview` | preview features |
 | `--add-exports`, `--add-opens`, `--add-reads`, `--add-modules`, `--module-path`, `-p` | module options, as with `java` |
+| `-m`, `--module module[/class]` | run a main class from a module on the module path |
 | `--locale-data` | locales other than English (see [support.md](support.md#locales)) |
 | `-Xmx` | the maximum heap reported by `Runtime.maxMemory()` (at most 1g, rounded up to 2 MB steps, below 2m an error). Under Node, java-web checks measured heap use periodically during allocation and throws `OutOfMemoryError: Java heap space` when live use stays over the cap after collection. Without an exposed garbage collector, it checks after estimated allocations exceed the cap. Pages set the cap with `maxHeap` ([browser.md](browser.md)). |
 | `--max-rss MB` | exit when resident memory passes this (default 2048) |
@@ -26,6 +27,9 @@ npx @project516/java-web [options] -jar app.jar [args]
 
 Other `-X` and HotSpot-only options are ignored.
 
+`kill -QUIT` on a running command prints every thread's stack to stderr, as
+HotSpot does, and the program goes on. `JW_DUMP_STACKS=10` does it every 10 seconds.
+
 ## From JS
 
 ```js
@@ -43,7 +47,7 @@ const code = await runNode({
 The package ships TypeScript declarations (`dist/node.d.ts`). `runNode`
 resolves to the exit code. Its options:
 
-- `classpath`, `mainClass` or `jar`, `args`, `props` (system properties)
+- `classpath`, `mainClass`, `mainModule` (`module/class`, with `jdk.module.path` in `props`) or `jar`, `args`, `props` (system properties)
 - `stdout`, `stderr` (byte callbacks; default the process's), `input` (fixed stdin bytes)
 - `env` (what `System.getenv()` returns; default the host's environment)
 - `natives`: Java `native` methods in JS, as in the browser ([browser.md](browser.md))

docs/support.md

@@ -128,3 +128,8 @@ Locales other than English need `cheerpjInit({ localeData: true })`, or
 - IPv4 only. Not supported: IPv6, asynchronous channels
   (`AsynchronousSocketChannel`), SCTP, ICMP (`isReachable` is true for the
   host's own addresses only) and inherited channels.
+- `jdk.net` is in the image. Its socket options (TCP keep-alive time, interval
+  and probes, quick ack, don't fragment) keep their values on the socket and do
+  not reach a host socket. Peer credentials are this process's user and group
+  when the peer is in the same VM, and -1 for both when it is a host socket. TCP urgent data (`sendUrgentData`,
+  `MSG_OOB`) is not supported: Node cannot send or read it.

scripts/build-jdk.sh

@@ -4,7 +4,7 @@ set -euo pipefail
 
 cd "$(dirname "$0")/.."
 out=build/jdk
-modules=${JDK_MODULES:-java.se,jdk.compiler,jdk.httpserver,jdk.jartool,jdk.security.jgss,jdk.unsupported,jdk.zipfs,jdk.localedata,jdk.management,jdk.internal.md,javaweb.tls}
+modules=${JDK_MODULES:-java.se,jdk.compiler,jdk.httpserver,jdk.jartool,jdk.security.jgss,jdk.unsupported,jdk.zipfs,jdk.localedata,jdk.management,jdk.net,jdk.nio.mapmode,jdk.internal.md,javaweb.tls}
 
 # Builds from one pinned JDK release so every machine makes the same image.
 # Renovate bumps the release.
@@ -125,6 +125,20 @@ mkdir -p "$out/lib/fonts"
 cp "$font_home/ttf/DejaVuSans.ttf" "$out/lib/fonts/"
 cp "$font_home/LICENSE" "$out/legal/java.desktop/dejavu-fonts.txt"
 
+# Programs look for bin/java under java.home. ProcessBuilder starts the VM's
+# own java for this path; run from a host shell, it starts the java-web command,
+# or the checkout the image was built in.
+mkdir -p "$out/bin"
+cat > "$out/bin/java" <<'SH'
+#!/bin/sh
+command -v java-web >/dev/null 2>&1 && exec java-web "$@"
+root=$(cd "$(dirname "$(readlink -f "$0")")/../../.." && pwd)
+[ -f "$root/src/node.ts" ] && exec node "$root/src/node.ts" "$@"
+echo "java: the java-web command is not on PATH" >&2
+exit 127
+SH
+chmod 755 "$out/bin/java"
+
 # a digest of the whole image, which boot snapshots are made for
 (cd "$out" && node -e '
 const { createHash } = require("node:crypto");

src/bootpath.ts

@@ -0,0 +1,70 @@
+// Class files on the -Xbootclasspath/a path: directories and jars on the host.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { inflateRawSync } from "node:zlib";
+
+type Jar = { buf: Buffer; entries: Map<string, { method: number; size: number; at: number }> };
+
+function readJar(file: string): Jar | null {
+  let buf: Buffer;
+  try { buf = fs.readFileSync(file); } catch { return null; }
+  // a jar that cannot be read has no classes, as a malformed one on HotSpot's path
+  try {
+    let end = buf.length - 22;
+    while (end >= 0 && buf.readUInt32LE(end) !== 0x06054b50) end--;
+    if (end < 0) return null;
+    const entries = new Map<string, { method: number; size: number; at: number }>();
+    let p = buf.readUInt32LE(end + 16);
+    for (let n = buf.readUInt16LE(end + 10); n > 0 && buf.readUInt32LE(p) === 0x02014b50; n--) {
+      const nameLen = buf.readUInt16LE(p + 28);
+      entries.set(buf.toString("utf8", p + 46, p + 46 + nameLen), { method: buf.readUInt16LE(p + 10), size: buf.readUInt32LE(p + 20), at: buf.readUInt32LE(p + 42) });
+      p += 46 + nameLen + buf.readUInt16LE(p + 30) + buf.readUInt16LE(p + 32);
+    }
+    return { buf, entries };
+  } catch {
+    return null;
+  }
+}
+
+function fromJar(jar: Jar, name: string): Uint8Array | null {
+  const e = jar.entries.get(name);
+  if (!e) return null;
+  try {
+    const start = e.at + 30 + jar.buf.readUInt16LE(e.at + 26) + jar.buf.readUInt16LE(e.at + 28);
+    const data = jar.buf.subarray(start, start + e.size);
+    return e.method === 0 ? data : e.method === 8 ? inflateRawSync(data) : null;
+  } catch {
+    return null;
+  }
+}
+
+// entries is the colon-separated -Xbootclasspath/a value
+export function bootClassPath(entries: string | undefined): ((name: string) => { bytes: Uint8Array; location: string } | null) | undefined {
+  if (!entries) return undefined;
+  const list = entries.split(":").filter(Boolean).map((e) => ({ entry: path.resolve(e), jar: undefined as Jar | null | undefined }));
+  return (name) => {
+    for (const e of list) {
+      if (e.jar === undefined) e.jar = fs.statSync(e.entry, { throwIfNoEntry: false })?.isDirectory() ? null : readJar(e.entry);
+      if (e.jar) {
+        const bytes = fromJar(e.jar, `${name}.class`);
+        if (bytes) return { bytes, location: e.entry };
+      } else if (e.jar === null) {
+        try { return { bytes: fs.readFileSync(path.join(e.entry, `${name}.class`)), location: e.entry }; } catch { /* not here */ }
+      }
+    }
+    return null;
+  };
+}
+
+// --patch-module module=path:path, as the jdk.module.patch.N properties hold it
+export function bootPatches(props: Record<string, string> | undefined): ((module: string, name: string) => Uint8Array | null) | undefined {
+  const paths = new Map<string, string[]>();
+  for (const [k, v] of Object.entries(props ?? {})) {
+    const eq = v.indexOf("=");
+    if (/^jdk\.module\.patch\.\d+$/.test(k) && eq > 0) paths.set(v.slice(0, eq), [...(paths.get(v.slice(0, eq)) ?? []), v.slice(eq + 1)]);
+  }
+  if (paths.size === 0) return undefined;
+  const finders = new Map([...paths].map(([module, list]) => [module, bootClassPath(list.join(":"))!]));
+  return (module, name) => finders.get(module)?.(name)?.bytes ?? null;
+}

src/indy.ts

@@ -140,6 +140,16 @@ function* defineHidden(vm: JVM, t: JThread, caller: JClass, w: ClassWriter): Nat
 
 // ---- LambdaMetafactory -----------------------------------------------------
 
+// -Djdk.invoke.LambdaMetafactory.dumpProxyClassFiles: the JDK's own dumper writes the class
+function* dumpLambda(vm: JVM, t: JThread, c: JClass, bytes: Uint8Array): NativeGen {
+  const factory = vm.loadBootOrFail("java/lang/invoke/InnerClassLambdaMetafactory");
+  if (factory.state !== INITIALIZED) yield* vm.initGen(t, factory);
+  const array = vm.newArray(vm.primClass("B"), bytes.length);
+  (array.a as Int8Array).set(new Int8Array(bytes.buffer, bytes.byteOffset, bytes.length));
+  yield t.callVirtual(vm.getStatic(factory, "lambdaProxyClassFileDumper"), "dumpClass", "(Ljava/lang/String;Ljava/lang/Class;[B)V",
+    vm.str(c.cf!.name), vm.mirror(c), array);
+}
+
 function* spinLambda(vm: JVM, t: JThread, caller: JClass, name: string, factoryDesc: string, args: BsmArg[], alt: boolean): NativeGen {
   const sam = args[0], impl = args[1], inst = args[2];
   if (sam.kind !== "mt" || impl.kind !== "mh" || inst.kind !== "mt") return null;
@@ -223,6 +233,7 @@ function* spinLambda(vm: JVM, t: JThread, caller: JClass, name: string, factoryD
     m.ret(samRet);
   }
   const c: JClass = yield* defineHidden(vm, t, caller, w);
+  if (vm.props.has("jdk.invoke.LambdaMetafactory.dumpProxyClassFiles")) yield* dumpLambda(vm, t, c, w.toBytes());
   // HotSpot's lambda classes have neither; its call sites build the instance
   const factoryMethod = c.methodMap.get("get$Lambda" + factoryDesc)!;
   c.vmMembers = new Set([factoryMethod, ...c.fields.filter((f) => f.name === "INSTANCE")]);

src/interp.ts

@@ -17,7 +17,9 @@ const MAX_FRAMES = 6000;
 // be constructed and handled; the limit drops back once the stack unwinds.
 function checkStack(t: JThread) {
   if (t.frames.length < t.stackLimit) return;
-  if (t.stackLimit >= 2 * MAX_FRAMES) throw new Error("stack overflow while handling a stack overflow");
+  // Overflows inside handlers of overflows have no headroom left to build an
+  // error with its constructor, so a bare one is thrown.
+  if (t.stackLimit >= 2 * MAX_FRAMES) throw new JavaThrow(t.vm.newObject(t.vm.loadBootOrFail("java/lang/StackOverflowError")));
   t.stackLimit = t.frames.length + 1500;
   throw new PendingThrow("java/lang/StackOverflowError");
 }

src/jvm.ts

@@ -65,6 +65,12 @@ export interface JvmOptions {
   assertions?: Assertions;
   // run class files that use this release's preview features
   enablePreview?: boolean;
+  // class bytes from --patch-module for a boot loader module, which win over the image's
+  bootPatch?: (module: string, name: string) => Uint8Array | null;
+  // class bytes on the -Xbootclasspath/a path, and the path entry that holds them
+  bootClassPath?: (name: string) => { bytes: Uint8Array; location: string } | null;
+  // os.version; the kernel release where there is one
+  osVersion?: string;
   // sockets and name lookup; defaults to loopback sockets inside the VM
   net?: NetBackend;
   // what InetAddress.getLocalHost() reports
@@ -97,16 +103,16 @@ export interface JvmOptions {
 const RESUMED = Object.freeze({ kind: "resume" }) as unknown as Request;
 
 // LauncherHelper launch modes
-export const LM_CLASS = 1, LM_JAR = 2;
+export const LM_CLASS = 1, LM_JAR = 2, LM_MODULE = 3;
 
 const intrinsicClasses = new Set(Object.keys(intrinsics).map((k) => k.slice(0, k.indexOf("."))));
 
 // Rejects run and startLibrary when a snapshot could not be restored. The
 // snapshot is dropped, so a new VM with the same options boots.
 export class SnapshotError extends Error {}
 
-// properties under which boot reads application files, which a key does not cover
-const BOOT_READS_APP = /^(java\.system\.class\.loader|jdk\.module\.(path|upgrade\.path|patch\.\d+))$/;
+// properties under which the VM reads application files that a snapshot key does not cover
+const BOOT_READS_APP = /^(java\.system\.class\.loader|jdk\.boot\.class\.path\.append|jdk\.module\.(path|upgrade\.path|patch\.\d+))$/;
 
 const YIELD = (() => {
   if (typeof setImmediate === "function") return (fn: () => void) => setImmediate(fn);
@@ -131,6 +137,10 @@ export class JVM {
   private readonly image: JImage | null;
   // package -> module, for boot classes
   readonly bootPackages = new Map<string, string>();
+  // packages of modules defined at run time for the boot loader, such as a Proxy's dynamic module
+  readonly bootModulePackages = new Map<string, JObject>();
+  // packages of classes loaded from -Xbootclasspath/a, with the path entry they came from
+  readonly bootAppendPackages = new Map<string, string>();
   // Module objects defined to the boot loader, by name
   readonly bootModules = new Map<string, JObject>();
   bootUnnamedModule: JObject | null = null;
@@ -197,10 +207,12 @@ export class JVM {
     // Locale data is left out as --limit-modules would leave it, unless asked
     // for, or named by --add-modules (by name or as ALL-SYSTEM). A limit given
     // by the caller keeps it only if it names it, since no module requires it.
+    // With a module path it stays in: a limit would hide the modules the main
+    // module requires.
     const addmods = [...this.props].filter(([k]) => k.startsWith("jdk.module.addmods.")).flatMap(([, v]) => v.split(","));
     const limit = this.props.get("jdk.module.limitmods");
     const noLocales = this.image !== null && (limit !== undefined ? !limit.split(",").includes("jdk.localedata")
-      : !opts.localeData && !addmods.some((m) => m === "ALL-SYSTEM" || m === "jdk.localedata"));
+      : !opts.localeData && !this.props.has("jdk.module.path") && !addmods.some((m) => m === "ALL-SYSTEM" || m === "jdk.localedata"));
     const present = new Map<string, boolean>();
     for (const line of new TextDecoder().decode(index).split("\n")) {
       const sp = line.indexOf(" ");
@@ -250,8 +262,19 @@ export class JVM {
     }
     const i = name.lastIndexOf("/");
     const module = this.bootPackages.get(i < 0 ? "" : name.slice(0, i));
-    if (!module) return null;
-    const bytes = this.image ? this.image.read(module, `${name}.class`) : this.fs.read(`${this.opts.javaHome}/modules/${module}/${name}.class`);
+    // once the boot layer is defined, a module left out of it (--limit-modules) has no classes
+    if (module && this.bootModules.has("java.base") && !this.bootModules.has(module)) return null;
+    let bytes: Uint8Array | null | undefined;
+    if (module) {
+      bytes = this.opts.bootPatch?.(module, name) ?? (this.image ? this.image.read(module, `${name}.class`) : this.fs.read(`${this.opts.javaHome}/modules/${module}/${name}.class`));
+    }
+    else {
+      const found = this.opts.bootClassPath?.(name);
+      if (found) {
+        bytes = found.bytes;
+        this.bootAppendPackages.set(i < 0 ? "" : name.slice(0, i), found.location);
+      }
+    }
     if (!bytes) return null;
     const cf = parseClass(bytes);
     const superclass = cf.superName ? this.loadBootOrFail(cf.superName) : null;
@@ -715,7 +738,7 @@ export class JVM {
       const mod = this.bootPackages.get(c.packageName);
       // a module not defined yet: defineModule0 sets it later, as HotSpot does
       if (mod) return this.bootModules.get(mod) ?? null;
-      return this.bootUnnamedModule;
+      return this.bootModulePackages.get(c.packageName) ?? this.bootUnnamedModule;
     }
     const named = this.loaderData(c.loader).modules.get(c.packageName);
     if (named) return named;
@@ -880,6 +903,16 @@ export class JVM {
     this.throwNew(t, "java/lang/InternalError", e instanceof Error ? e.message : String(e));
   }
 
+  // Every live thread's Java stack, for kill -QUIT on a stuck program
+  dumpAllStacks() {
+    console.error(`Full thread dump ${this.props.get("java.vm.name") ?? "java-web"}:`);
+    for (const t of this.threads) {
+      if (t.state === TERMINATED) continue;
+      console.error(`\n"${t.name}" ${t.state === RUNNABLE ? "runnable" : "waiting"}`);
+      this.dumpStack(t);
+    }
+  }
+
   dumpStack(t: JThread) {
     for (let i = t.frames.length - 1; i >= 0; i--) {
       const f = t.frames[i];
@@ -1167,6 +1200,10 @@ export class JVM {
       failed(e instanceof Error ? e : new Error(String(e)));
       return;
     }
+    if (this.exitCode !== null) {
+      failed(new Error(`VM exited during startup with ${this.exitCode}`));
+      return;
+    }
     if (this.opts.warmSnapshot && this.libraryStarting && this.snapshots) {
       this.warmTraceActive = this.fs.beginWarmTrace();
       this.warmTraceClasses = this.classCount;
@@ -1260,8 +1297,12 @@ export class JVM {
         "java/lang/invoke/MemberName", "java/lang/invoke/MethodHandleNatives",
       ]) yield* init(n);
       this.debug("initPhase2");
-      const rc = yield t.call(boot("java/lang/System").methodMap.get("initPhase2(ZZ)I")!, 1, 1);
-      if (rc !== 0) throw new Error(`initPhase2 failed: ${rc}`);
+      // HotSpot prints a failed boot layer to stdout, without a stack trace, and exits
+      const rc = yield t.call(boot("java/lang/System").methodMap.get("initPhase2(ZZ)I")!, 0, 0);
+      if (rc !== 0) {
+        this.halt(1);
+        return;
+      }
       this.debug("initPhase3");
       yield t.call(boot("java/lang/System").methodMap.get("initPhase3()V")!);
       this.debug("vm started in", Date.now() - this.startTime, "ms");
@@ -1355,6 +1396,7 @@ export class JVM {
     if (!restored) {
       if (cmd !== undefined) this.props.set("sun.java.command", "");
       yield* this.bootGen(t);
+      if (this.exitCode !== null) return;
       // a snapshot is only a cache: failing to make or keep one never fails the run
       if (snaps) {
         try {
@@ -1382,6 +1424,7 @@ export class JVM {
   private *mainGen(t: JThread, mode: number, what: string, args: string[], restored: boolean): NativeGen {
     const boot = (n: string) => this.loadBootOrFail(n);
     yield* this.startGen(t, restored);
+    if (this.exitCode !== null) return;
     let code = 0;
     try {
       const helper = boot("sun/launcher/LauncherHelper");

src/natives/loader.ts

@@ -25,7 +25,10 @@ function defineModule(t: JThread, m: JObject, version: JObject | null, location:
   const loader = vm.getField(m, "java/lang/Module", "loader") as JObject | null;
   const pkgs = (pns.a as JObject[]).map((p) => vm.jsString(p).replace(/\./g, "/"));
   if (loader === null) {
-    if (name) vm.bootModules.set(name, m);
+    if (name) {
+      vm.bootModules.set(name, m);
+      for (const p of pkgs) if (!vm.bootPackages.has(p)) vm.bootModulePackages.set(p, m);
+    }
     const set = new Set(pkgs);
     for (const c of [...vm.boot.values(), ...vm.prims.values()]) {
       let e = c;