@@ -20,6 +20,8 @@ export interface Backend {
   readRange?(path: string, off: number, len: number): Uint8Array | null;
   list(path: string): string[] | null;
   write?(path: string, data: Uint8Array): boolean;
+  // the errno code (such as "ENOSPC") of the last write that failed
+  writeError?: string;
   mkdir?(path: string): boolean;
   remove?(path: string): boolean;
   rename?(from: string, to: string): boolean;
@@ -139,6 +141,10 @@ export class VFS {
     return !!r && r[0].writable && !!r[0].write?.(r[1], data);
   }
 
+  writeError(path: string): string | undefined {
+    return this.resolve(path)?.[0].writeError;
+  }
+
   mkdir(path: string): boolean {
     const r = this.resolve(path);
     return !!r && r[0].writable && !!r[0].mkdir?.(r[1]);
 
@@ -190,7 +190,8 @@ export function fileOf(t: JThread, fd: number): OpenFile {
   return f;
 }
 
-export function flush(t: JThread, f: OpenFile) {
+// Writes the file's buffered bytes; false if the host refused them.
+export function flush(t: JThread, f: OpenFile): boolean {
   if (f.dirty && f.writable && f.path) {
     const data = f.data.slice(0, f.size);
     let ok = t.vm.fs.write(f.path, data);
@@ -201,7 +202,25 @@ export function flush(t: JThread, f: OpenFile) {
       t.vm.fs.chmod(f.path, () => mode);
     }
     if (ok) f.dirty = false;
+    return ok;
   }
+  return true;
+}
+
+const ERRNO: Record<string, string> = {
+  ENOSPC: "No space left on device", EFBIG: "File too large", EDQUOT: "Disk quota exceeded",
+  EACCES: "Permission denied", EPERM: "Operation not permitted", EROFS: "Read-only file system",
+  ENOENT: "No such file or directory",
+};
+
+// Where Java learns of a write that failed: HotSpot reports it from write(),
+// java-web, which buffers, from the flush, sync or close that writes it out.
+export function flushOrThrow(t: JThread, f: OpenFile) {
+  if (!flush(t, f)) throw writeFailed(t, f.path);
+}
+
+function writeFailed(t: JThread, path: string): PendingThrow {
+  return new PendingThrow("java/io/IOException", ERRNO[t.vm.fs.writeError(path) ?? ""] ?? "Input/output error");
 }
 
 export function newFd(t: JThread): number {
@@ -213,9 +232,11 @@ export function closeFd(t: JThread, fd: number) {
   const tab = table(t);
   const f = tab.files.get(fd);
   if (f) {
-    flush(t, f);
+    const ok = flush(t, f);
     tab.files.delete(fd);
     if (f.writable && f.path) t.vm.opts.fileClosed?.(f.path);
+    // the descriptor is closed either way, as with close(2)
+    if (!ok) throw writeFailed(t, f.path);
   }
 }
 
@@ -308,7 +329,7 @@ export const natives: Natives = {
   "java/io/FileDescriptor.sync0()V": (t, [fdObj]) => {
     const fd = t.vm.getField(fdObj, "java/io/FileDescriptor", "fd");
     const f = table(t).files.get(fd);
-    if (f) flush(t, f);
+    if (f) flushOrThrow(t, f);
   },
   "java/io/FileDescriptor.close0()V": (t, [fdObj]) => {
     const fd = t.vm.getField(fdObj, "java/io/FileDescriptor", "fd");
 
@@ -5,7 +5,7 @@ import type { JObject } from "../runtime.ts";
 import { preCloseSock } from "../sockets.ts";
 import { sockRead, sockReadv, sockWrite, sockWritev } from "./sockets.ts";
 import { JThread, PendingThrow } from "../thread.ts";
-import { closeFd, endsInDot, fileOf, flush, openFile, removePath, renamePath, resolvePath, setMtime, syncPath } from "./io.ts";
+import { closeFd, endsInDot, fileOf, flush, flushOrThrow, openFile, removePath, renamePath, resolvePath, setMtime, syncPath } from "./io.ts";
 import type { OpenFile } from "./io.ts";
 import type { Natives } from "./util.ts";
 
@@ -338,8 +338,7 @@ Object.assign(natives, {
   [`${UFD}writev0(Ljava/io/FileDescriptor;JI)J`]: (t: JThread, [fd, addr, n]: any[]) =>
     sockWritev(t, fd, addr, n) ?? vector(t, addr, n, (base, len) => writeAt(t, fd, base, len, null)),
   [`${UFD}force0(Ljava/io/FileDescriptor;Z)I`]: (t: JThread, [fd]: any[]) => {
-    const f = chanFile(t, fd);
-    flush(t, f);
+    flushOrThrow(t, chanFile(t, fd));
     return 0;
   },
   [`${UFD}seek0(Ljava/io/FileDescriptor;J)J`]: (t: JThread, [fd, off]: any[]) => {
 
@@ -68,11 +68,13 @@ export class NodeBackend implements Backend {
     if (!this.writable) this.lists.set(p, names);
     return names;
   }
+  writeError?: string;
   write(p: string, data: Uint8Array) {
     try {
       fs.writeFileSync(this.host(p), data);
       return true;
-    } catch {
+    } catch (e) {
+      this.writeError = (e as NodeJS.ErrnoException).code;
       return false;
     }
   }
 
@@ -0,0 +1,37 @@
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+
+// Writes past the file size limit (ulimit -f), so the host refuses them. HotSpot
+// reports that from write(); java-web, which buffers, from close, sync or force.
+public class Full {
+  public static void main(String[] args) throws Exception {
+    Path p = Path.of(args[0]);
+    try {
+      try (var out = new FileOutputStream(p.toFile())) {
+        out.write(new byte[8192]);
+      }
+      System.out.println("closed");
+    } catch (IOException e) {
+      System.out.println("close: " + e.getMessage());
+    }
+    try (var out = new FileOutputStream(p.toFile())) {
+      out.write(new byte[8192]);
+      out.getFD().sync();
+      System.out.println("synced");
+    } catch (IOException e) {
+      System.out.println("sync: " + e.getMessage());
+    }
+    try (var ch = FileChannel.open(p, StandardOpenOption.WRITE)) {
+      ByteBuffer b = ByteBuffer.allocate(8192);
+      while (b.hasRemaining()) ch.write(b);
+      ch.force(true);
+      System.out.println("forced");
+    } catch (IOException e) {
+      System.out.println("force: " + e.getMessage());
+    }
+  }
+}
@@ -76,6 +76,22 @@ test("-Xmx caps an allocation under the command", () => {
   assert.match(max.stdout, /^max 18874368$/m);
 });
 
+// ulimit -f makes the host refuse writes past 4 KB; SIGXFSZ ignored, they fail with EFBIG
+test("writes the host refuses", { skip: process.platform !== "linux" }, () => {
+  const classes = join(root, "build", "test-full");
+  execFileSync(hotspot("javac"), ["-d", classes, join(root, "test", "full", "Full.java")]);
+  const dir = mkdtempSync(join(tmpdir(), "java-web-full-"));
+  const limited = (cmd: string, args: string[]) =>
+    spawnSync("bash", ["-c", 'trap "" XFSZ; ulimit -f 4; exec "$@"', "bash", cmd, ...args, "-cp", classes, "Full", join(dir, "out.bin")], { encoding: "utf8" });
+  try {
+    const ref = limited(hotspot("java"), []);
+    const got = limited(process.execPath, [join(root, "src", "node.ts")]);
+    assert.deepEqual({ stdout: got.stdout, code: got.status }, { stdout: ref.stdout, code: ref.status });
+  } finally {
+    rmSync(dir, { recursive: true });
+  }
+});
+
 test("stdout closed by its reader", async () => {
   const classes = join(root, "build", "test-pipe");
   execFileSync(hotspot("javac"), ["-d", classes, join(root, "test", "pipe", "Pipe.java")]);
Original file line number	Diff line number	Diff line change
`@@ -68,11 +68,13 @@ export class NodeBackend implements Backend {`
`68`	`68`	`if (!this.writable) this.lists.set(p, names);`
`69`	`69`	`return names;`
`70`	`70`	`}`
	`71`	`+ writeError?: string;`
`71`	`72`	`write(p: string, data: Uint8Array) {`
`72`	`73`	`try {`
`73`	`74`	`fs.writeFileSync(this.host(p), data);`
`74`	`75`	`return true;`
`75`		`- } catch {`
	`76`	`+ } catch (e) {`
	`77`	`+ this.writeError = (e as NodeJS.ErrnoException).code;`
`76`	`78`	`return false;`
`77`	`79`	`}`
`78`	`80`	`}`