Fix OnOutOfMemoryError, MaxDirectMemorySize, access times and WatchService failures

docs/node.md

@@ -49,6 +49,8 @@ resolves to the exit code. Its options:
 - `natives`: Java `native` methods in JS, as in the browser ([browser.md](browser.md))
 - `assertions` (the flags, for example `["-ea"]`), `enablePreview`, `localeData`
 - `hostName` (what `InetAddress.getLocalHost()` reports), `maxRssMb`, `jdk`, `debug`
+- `maxDirectMemory` (`-XX:MaxDirectMemorySize`, in bytes), `onOutOfMemoryError` (`-XX:OnOutOfMemoryError` commands),
+  `vmOutputToStderr` (`-XX:+DisplayVMOutputToStderr`)
 - `fetch`: sockets stay inside the VM, and `http:` requests go to this `fetch`, as in the browser
 
 - `snapshotDir`: where boot snapshots are kept, or `null` for none (see below)

docs/support.md

@@ -29,16 +29,18 @@ java-web targets headless Java: console apps, libraries and javac.
   host's inode numbers and link counts, and the modes `open` and `mkdir` ask
   for, less the process's umask. In-memory files get synthetic inode numbers, a
   link count of 1 and default modes.
-- `-XX:OnOutOfMemoryError` runs no command, and `StackWalker`
+- `-XX:OnOutOfMemoryError` runs its commands under Node only, and `StackWalker`
   has no live locals or operands. A virtual thread that yields while it
   holds a monitor stays pinned to its carrier.
 - `ThreadMXBean` describes threads and finds deadlocks, but has no CPU times
   and no blocked or waited times (contention monitoring is off). Thread dumps
   find a frame's locked monitors from its synchronized blocks as compilers emit
   them, and list a monitor taken any other way with stack depth -1.
 - `WatchService` reports files the program itself, or another thread in the
-  same VM, creates, changes or deletes. It does not see changes made outside
-  the VM, including by child processes the program starts.
+  same VM, creates, changes or deletes. Under Node it also reports what other
+  processes do to a watched host directory, with Node's `fs.watch` (so a short-lived
+  entry can show as a delete without its create). Elsewhere it does not see
+  changes made outside the VM.
 - Not supported: GUI apps (AWT and Swing windows), `ConvolveOp`, child
   processes in the browser, and native libraries other than JS natives.
 

src/fs.ts

@@ -16,8 +16,13 @@ export interface Stat {
   // the modification time in nanoseconds, when it was set with more precision
   // than mtime keeps
   mtimeNs?: bigint;
+  // the access time, when the backend keeps one (mtime otherwise), and in nanoseconds
+  atime?: number;
+  atimeNs?: bigint;
   // permission and special bits, when the backend can report them
   mode?: number;
+  // a socket, FIFO or device on the host, which cannot be opened here
+  special?: boolean;
   // a character device; it streams and is never read whole
   device?: boolean;
   // lstat of a symbolic link: the length of its target, which is also its size
@@ -60,8 +65,8 @@ export interface Backend {
   rename?(from: string, to: string): boolean;
   // the file system holding path: block size and block counts, as statvfs gives them
   space?(path: string): Space | null;
-  // sets the modification time, in milliseconds since the epoch
-  setMtime?(path: string, ms: number, noFollow?: boolean): boolean;
+  // sets the modification time, and the access time when given, in milliseconds since the epoch
+  setMtime?(path: string, ms: number, noFollow?: boolean, atimeMs?: number): boolean;
   // whether the host refuses to write the file, or to create it when it is missing
   denied?(path: string): boolean;
   // sets the permission bits to f(current bits)
@@ -76,6 +81,10 @@ export interface Backend {
   link?(existing: string, path: string): string | undefined;
   // the path with every link resolved, where the missing tail stays as written
   realpath?(path: string): string | null;
+  // reports changes others make to a directory's entries (name "" is the directory itself); returns what stops it
+  watch?(path: string, onEvent: (name: string, event: "create" | "modify" | "delete") => void): (() => void) | null;
+  // changes whenever the entry's content or times do, or is "" when it is missing
+  signature?(path: string): string;
 }
 
 export interface WarmTrace {
@@ -104,7 +113,7 @@ export function normalize(path: string): string {
 
 export class VFS {
   // path -> the time a VM set, and the mtime the backend reported right after
-  private setTimes = new Map<string, { ms: number; ns: bigint }>();
+  private setTimes = new Map<string, { ms: number; ns: bigint; atime?: { ms: number; ns: bigint } }>();
   private mounts: { prefix: string; backend: Backend }[] = [];
   private hidden: string[] = [];
   private warmTrace: WarmTrace | null = null;
@@ -229,6 +238,51 @@ export class VFS {
   private changedNormalized(path: string, event: "create" | "modify" | "delete") {
     for (const watcher of this.watchers) watcher(path, event);
     this.warmChanged?.add(path);
+    if (this.hostWatches.size === 0) return;
+    const watch = this.hostWatches.get(parentOf(path));
+    if (watch) watch.own.set(path.slice(path.lastIndexOf("/") + 1), this.signature(path));
+  }
+
+  // Host directories being watched: the entries as the VM last left them, so
+  // that only changes others make reach watchers a second time.
+  private hostWatches = new Map<string, { stop: () => void; refs: number; own: Map<string, string> }>();
+
+  private signature(path: string): string {
+    const r = this.resolve(path);
+    return (r && r[0].signature?.(r[1])) ?? "";
+  }
+
+  // Starts reporting what others do to a directory on a host backend, as
+  // inotify does; the VM's own changes already reach watchers. Returns what stops it.
+  watchDirectory(path: string): () => void {
+    const dir = normalize(path);
+    let watch = this.hostWatches.get(dir);
+    if (!watch) {
+      const r = this.resolve(dir);
+      const stop = r?.[0].watch?.(r[1], (name, event) => this.hostChanged(dir, name, event));
+      if (!stop) return () => {};
+      watch = { stop, refs: 0, own: new Map() };
+      this.hostWatches.set(dir, watch);
+    }
+    const w = watch;
+    w.refs++;
+    let done = false;
+    return () => {
+      if (done) return;
+      done = true;
+      if (--w.refs === 0) {
+        w.stop();
+        if (this.hostWatches.get(dir) === w) this.hostWatches.delete(dir);
+      }
+    };
+  }
+
+  private hostChanged(dir: string, name: string, event: "create" | "modify" | "delete") {
+    const watch = this.hostWatches.get(dir);
+    if (!watch) return;
+    const path = name === "" ? dir : (dir === "/" ? "" : dir) + "/" + name;
+    if (name !== "" && watch.own.get(name) === this.signature(path)) return;
+    for (const watcher of this.watchers) watcher(path, event);
   }
 
   resolvePath(path: string): string {
@@ -289,7 +343,10 @@ export class VFS {
     const s = r ? r[0].stat(r[1]) : null;
     if (s) {
       const set = this.setTimes.get(n);
-      if (set?.ms === s.mtime) return { ...s, mtimeNs: set.ns };
+      if (set?.ms === s.mtime) {
+        const atime = set.atime && set.atime.ms === s.atime ? { atimeNs: set.atime.ns } : {};
+        return { ...s, mtimeNs: set.ns, ...atime };
+      }
       if (set) this.setTimes.delete(n);
       return s;
     }
@@ -474,16 +531,18 @@ export class VFS {
   // ns, when given, is the exact time asked for. Hosts keep times as floating
   // point seconds or milliseconds, which lose nanoseconds, so stat reports ns
   // for as long as the file keeps the time this set.
-  setMtime(path: string, ms: number, ns?: bigint, noFollow = false): boolean {
+  setMtime(path: string, ms: number, ns?: bigint, noFollow = false, atime?: { ms: number; ns: bigint }): boolean {
     const r = this.resolve(path);
-    if (!r || !r[0].writable || !r[0].setMtime?.(r[1], ms, noFollow)) return false;
+    if (!r || !r[0].writable || !r[0].setMtime?.(r[1], ms, noFollow, atime?.ms)) return false;
     this.changed(path, "modify");
     if (noFollow) return true;
     const n = normalize(path);
     const st = ns === undefined ? null : r[0].stat(r[1]);
     // only a time the host kept, give or take its rounding; a host can clamp it
-    if (st && Math.abs(st.mtime - ms) < 1) this.setTimes.set(n, { ms: st.mtime, ns: ns! });
-    else this.setTimes.delete(n);
+    if (st && Math.abs(st.mtime - ms) < 1) {
+      const kept = atime && st.atime !== undefined && Math.abs(st.atime - atime.ms) < 1;
+      this.setTimes.set(n, { ms: st.mtime, ns: ns!, ...(kept ? { atime: { ms: st.atime!, ns: atime.ns } } : {}) });
+    } else this.setTimes.delete(n);
     return true;
   }
 

src/jvm.ts

@@ -57,6 +57,8 @@ export interface JvmOptions {
   loadNativeLibrary?: (path: string) => Promise<void>;
   // told when Java closes a file it wrote
   fileClosed?: (path: string) => void;
+  // runs before the first OutOfMemoryError the VM throws is created
+  onOutOfMemory?: (message: string | null) => void;
   // log VM internals to the host console
   debug?: boolean;
   assertions?: Assertions;
@@ -837,6 +839,7 @@ export class JVM {
 
   *newThrowable(t: JThread, name: string, msg: string | null, cause: JObject | null = null,
     ctor?: { desc: string; args: any[] }): NativeGen {
+    if (name === "java/lang/OutOfMemoryError") this.reportOutOfMemory(msg);
     const c = this.loadBootOrFail(name);
     if (c.state !== INITIALIZED) yield* this.initGen(t, c);
     const o = this.newObject(c);
@@ -852,6 +855,13 @@ export class JVM {
     return o;
   }
 
+  private oomReported = false;
+  private reportOutOfMemory(msg: string | null) {
+    if (this.oomReported || !this.opts.onOutOfMemory) return;
+    this.oomReported = true;
+    this.opts.onOutOfMemory(msg);
+  }
+
   // native: the native method throwing it, shown in its stack trace
   throwNew(t: JThread, name: string, msg: string | null, ctor?: { desc: string; args: any[] }, native: JMethod | null = null) {
     const vm = this;

src/natives/io.ts

@@ -412,9 +412,9 @@ export function syncPath(t: JThread, abs: string) {
 }
 
 // Pending writes go out first, so closing the file later does not change the time again.
-export function setMtime(t: JThread, abs: string, ms: number, ns?: bigint, noFollow = false): boolean {
+export function setMtime(t: JThread, abs: string, ms: number, ns?: bigint, noFollow = false, atime?: { ms: number; ns: bigint }): boolean {
   syncPath(t, abs);
-  return t.vm.fs.setMtime(abs, ms, ns, noFollow);
+  return t.vm.fs.setMtime(abs, ms, ns, noFollow, atime);
 }
 
 // write(2) on a descriptor opened read-only fails with EBADF.

src/natives/nio.ts

@@ -10,12 +10,12 @@ import { closeFd, DirectoryFile, newFd, fileInode, fileOf, flush, flushOrThrow,
 import type { OpenFile } from "./io.ts";
 import type { Natives } from "./util.ts";
 
-export const EPERM = 1, ENOENT = 2, EINTR = 4, EIO = 5, EBADF = 9, ENOMEM = 12, EACCES = 13,
+export const EPERM = 1, ENOENT = 2, EINTR = 4, EIO = 5, ENXIO = 6, EBADF = 9, ENOMEM = 12, EACCES = 13,
   EEXIST = 17, EXDEV = 18, ENOTDIR = 20, EISDIR = 21, EINVAL = 22, ENOSPC = 28, EROFS = 30,
   ENOTEMPTY = 39, ENOSYS = 38, ENAMETOOLONG = 36, ELOOP = 40, ENOTSUP = 95, ESTALE = 116, EDQUOT = 122;
 
 const MESSAGES: Record<number, string> = {
-  [EPERM]: "Operation not permitted", [EINTR]: "Interrupted system call", [EIO]: "Input/output error",
+  [EPERM]: "Operation not permitted", [ENXIO]: "No such device or address", [EINTR]: "Interrupted system call", [EIO]: "Input/output error",
   [ENOMEM]: "Cannot allocate memory", [ENOSPC]: "No space left on device",
   [ELOOP]: "Too many levels of symbolic links", [ENOTSUP]: "Operation not supported", [ESTALE]: "Stale file handle",
   [ENAMETOOLONG]: "File name too long", [EDQUOT]: "Disk quota exceeded",
@@ -103,10 +103,12 @@ function renameAbs(t: JThread, from: string, to: string) {
 }
 
 function openAbs(t: JThread, abs: string, flags: number, mode: number): number {
+  // before any stat that follows the link, which would touch its access time
+  if (flags & O_NOFOLLOW && !(flags & O_CREAT && flags & O_EXCL) && t.vm.fs.lstat(abs)?.link !== undefined) unixError(ELOOP);
   const st = t.vm.fs.stat(abs);
   if ((flags & O_CREAT) && (flags & O_EXCL) && (st || t.vm.fs.lstat(abs))) unixError(EEXIST);
+  if (st?.special) unixError(ENXIO);
   if (!st && !(flags & O_CREAT)) unixError(ENOENT);
-  if (flags & O_NOFOLLOW && t.vm.fs.lstat(abs)?.link !== undefined) unixError(ELOOP);
   if (flags & O_DIRECTORY && st && !st.dir) unixError(ENOTDIR);
   const write = (flags & O_ACCMODE) !== 0;
   if (st?.dir && write) unixError(EISDIR);
@@ -162,25 +164,30 @@ function fillAttrs(t: JThread, attrs: JObject, p: string, follow = true): number
   return 0;
 }
 
+// seconds and nanoseconds of a time kept as milliseconds, or exactly as nanoseconds
+function splitTime(ms: number, ns?: bigint): [bigint, bigint] {
+  if (ns === undefined) return [BigInt(Math.floor(ms / 1000)), BigInt(Math.floor((ms % 1000) * 1e6))];
+  const sec = ns / 1_000_000_000n, nsec = ns % 1_000_000_000n;
+  // before 1970: whole seconds round down, nanoseconds stay positive
+  return nsec < 0n ? [sec - 1n, nsec + 1_000_000_000n] : [sec, nsec];
+}
+
 function fillStat(t: JThread, attrs: JObject, st: Stat, writable: boolean, ino: number, size = st.size, nlink = 1) {
   const vm = t.vm, A = "sun/nio/fs/UnixFileAttributes";
   const mode = st.device ? S_IFCHR | 0o666 : (st.link !== undefined ? S_IFLNK : st.dir ? S_IFDIR : S_IFREG) | (st.mode ?? (st.dir ? (writable ? 0o755 : 0o555) : (writable ? 0o644 : 0o444)));
-  let sec = BigInt(Math.floor(st.mtime / 1000)), nsec = BigInt(Math.floor((st.mtime % 1000) * 1e6));
-  if (st.mtimeNs !== undefined) {
-    sec = st.mtimeNs / 1_000_000_000n;
-    nsec = st.mtimeNs % 1_000_000_000n;
-    // before 1970: whole seconds round down, nanoseconds stay positive
-    if (nsec < 0n) [sec, nsec] = [sec - 1n, nsec + 1_000_000_000n];
-  }
+  const [sec, nsec] = splitTime(st.mtime, st.mtimeNs);
   vm.setField(attrs, A, "st_mode", mode);
   vm.setField(attrs, A, "st_ino", BigInt(ino));
   vm.setField(attrs, A, "st_dev", 1n);
   vm.setField(attrs, A, "st_nlink", nlink);
   vm.setField(attrs, A, "st_uid", 1000);
   vm.setField(attrs, A, "st_gid", 1000);
   vm.setField(attrs, A, "st_size", BigInt(size));
-  for (const k of ["st_atime_sec", "st_mtime_sec", "st_ctime_sec"]) vm.setField(attrs, A, k, sec);
-  for (const k of ["st_atime_nsec", "st_mtime_nsec", "st_ctime_nsec"]) vm.setField(attrs, A, k, nsec);
+  for (const k of ["st_mtime_sec", "st_ctime_sec"]) vm.setField(attrs, A, k, sec);
+  for (const k of ["st_mtime_nsec", "st_ctime_nsec"]) vm.setField(attrs, A, k, nsec);
+  const [asec, ansec] = splitTime(st.atime ?? st.mtime, st.atimeNs);
+  vm.setField(attrs, A, "st_atime_sec", asec);
+  vm.setField(attrs, A, "st_atime_nsec", ansec);
 }
 
 // open mount table handles: whether the one entry has been read
@@ -310,15 +317,15 @@ export const natives: Natives = {
   [`${N}chown0(JII)V`]: () => undefined,
   [`${N}lchown0(JII)V`]: () => undefined,
   [`${N}fchown0(III)V`]: () => undefined,
-  // times in nanoseconds; only the modification time is kept
-  [`${N}utimensat0(IJJJI)V`]: (t, [dfd, p, , mtime, flags]) => {
+  // times in nanoseconds; in-memory files keep only the modification time
+  [`${N}utimensat0(IJJJI)V`]: (t, [dfd, p, atime, mtime, flags]) => {
     const abs = pathAt(t, dfd, p);
     if (!t.vm.fs.lstat(abs)) unixError(ENOENT);
-    if (!setMtime(t, abs, Number(mtime) / 1e6, BigInt(mtime), (flags & AT_SYMLINK_NOFOLLOW) !== 0)) unixError(EROFS);
+    if (!setMtime(t, abs, Number(mtime) / 1e6, BigInt(mtime), (flags & AT_SYMLINK_NOFOLLOW) !== 0, { ms: Number(atime) / 1e6, ns: BigInt(atime) })) unixError(EROFS);
   },
-  [`${N}futimens0(IJJ)V`]: (t, [fd, , mtime]) => {
+  [`${N}futimens0(IJJ)V`]: (t, [fd, atime, mtime]) => {
     const f = fileOf(t, fd);
-    if (!setMtime(t, f.path, Number(mtime) / 1e6, BigInt(mtime))) unixError(EROFS);
+    if (!setMtime(t, f.path, Number(mtime) / 1e6, BigInt(mtime), false, { ms: Number(atime) / 1e6, ns: BigInt(atime) })) unixError(EROFS);
   },
   [`${N}opendir0(J)J`]: (t, [p]) => {
     const abs = path(t, p);