9 files changed, 377 insertions, 8 deletions

diff --git a/CONTEXT.md b/CONTEXT.md
index aa9385b..39ce0bd 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -186,8 +186,25 @@ Single Rust crate (`x86_64-unknown-uefi` target).  Module breakdown:
   `-device ide-hd,drive=disk,bus=ide.0` puts the data disk on AHCI port
   0; the ESP gets `bus=ide.1`.  (The implicit `-drive file=fat:rw:esp`
   otherwise grabs port 0.)  Make targets (`run`, `run-gui`, `debug`)
-  attach `$(DISK_IMG)` (default `/tmp/disk.img`).  OVMF writes its
-  `NvVars` varstore file onto the first FAT volume — harmless.
+  attach `$(DISK_IMG)` (default `/tmp/disk.img`) and auto-create it when
+  missing.  OVMF writes its `NvVars` varstore file onto the first FAT
+  volume — harmless.
+
+  The whole disk workflow is scripted (no manual mkfs/mcopy):
+
+- `make disk` / `./scripts/mkdisk.sh` — create the FAT32 image with
+    `mkfs.fat -C` (the flag that actually creates the file; plain
+    `mkfs.fat` needs an existing file), label `RSDOS`, seed from
+    `seed/` via mtools; `--fresh` re-formats, `--size 128M` sizes it
+- `make inspect` — `mdir -i` listing of the image (mtools)
+- `make test-disk` / `./scripts/test-disk.sh` — full automated round
+    trip: build → deploy → ensure image → boot QEMU headless → drive
+    the shell via `sendkey` through the monitor (`ls /disk`, `mkdir`,
+    `echo >`, `cat`, `poweroff`) → fsck-clean check → `mtype` verifies
+    the written file survived poweroff
+- `./scripts/sendkeys.py` — types lines into the guest via the QEMU
+    monitor (`--sock`, US layout, named keys for punctuation; bare
+    `-`/`.`/`/` are not valid sendkey names)
 
 ## Known issues / perf notes
 
diff --git a/Makefile b/Makefile
index 7701d9d..01e265a 100644
--- a/Makefile
+++ b/Makefile
@@ -11,10 +11,10 @@ export BOOTLOADER=rsboot/rsboot.efi
 export OVMF=/usr/share/edk2/x64/OVMF.4m.fd
 export BOOT_EFI=$(ESP_DIR)/EFI/BOOT/BOOTX64.EFI
 # Attach a raw disk image as the SATA drive (disk.img -> ide.0, ESP -> ide.1).
-# Create one with: mkfs.fat -F 32 -n RSDOS disk.img && mcopy -i disk.img files ::
+# Create one with: make disk   (or: ./scripts/mkdisk.sh)
 export DISK_IMG ?= /tmp/disk.img
 
-.PHONY: all run run-gui clean image debug release fmt bootloader boot-image
+.PHONY: all run run-gui clean image debug release fmt bootloader boot-image disk disk-fresh inspect test-disk
 
 # ---- Build ---------------------------------------------------------------
 
@@ -43,7 +43,7 @@ $(INITRD): | $(ESP_DIR)
 
 # ---- QEMU runners --------------------------------------------------------
 
-run: all
+run: all disk
         qemu-system-x86_64 \
           -bios $(OVMF) \
           -drive file=$(DISK_IMG),format=raw,if=none,id=disk \
@@ -57,7 +57,7 @@ run: all
           -no-reboot \
           -display none
 
-run-gui: all
+run-gui: all disk
         qemu-system-x86_64 \
           -bios $(OVMF) \
           -drive file=$(DISK_IMG),format=raw,if=none,id=disk \
@@ -72,7 +72,7 @@ run-gui: all
           -vga std
 
 # GDB stub on :1234
-debug: all
+debug: all disk
         qemu-system-x86_64 \
           -bios $(OVMF) \
           -drive file=$(DISK_IMG),format=raw,if=none,id=disk \
@@ -92,6 +92,27 @@ debug: all
 run-image: all
         ./scripts/boot-image.sh rs-dos.img
 
+# ---- Data disk -----------------------------------------------------------
+
+# Create the FAT32 data disk if it doesn't exist.  Uses mkfs.fat -C (the
+# flag that actually creates the file) and seeds it from seed/.
+disk:
+        ./scripts/mkdisk.sh "$(DISK_IMG)"
+
+# Re-format the data disk from scratch (wipes it, then re-seeds).
+disk-fresh:
+        ./scripts/mkdisk.sh --fresh "$(DISK_IMG)"
+
+# List the data disk contents with mtools (requires mtools).
+inspect:
+        @command -v mdir >/dev/null 2>&1 || (echo "inspect needs mtools: sudo apt install mtools"; exit 1)
+        @mdir -i "$(DISK_IMG)"
+
+# Full automated round trip: build -> boot -> shell commands -> poweroff
+# -> fsck + mtools verification.
+test-disk:
+        ./scripts/test-disk.sh
+
 # ---- Full boot chain -----------------------------------------------------
 
 # Build bootloader only (rsboot submodule)
@@ -126,11 +147,18 @@ help:
         @echo "  make run            QEMU serial console (direct boot, no bootloader)"
         @echo "  make run-gui        QEMU with graphical window (GOP/PS2)"
         @echo "  make debug          QEMU + GDB stub on :1234"
+        @echo "  make disk           create the data disk if missing (default /tmp/disk.img)"
+        @echo "  make disk-fresh     re-format the data disk (wipes it)"
+        @echo "  make inspect        list data disk contents (mtools)"
+        @echo "  make test-disk      automated disk round trip (build->boot->fsck)"
         @echo "  make clean          remove build artifacts"
         @echo "  make fmt            format Rust source"
         @echo ""
         @echo "Scripts:"
         @echo "  ./scripts/boot.sh              quick direct boot (dev loop)"
+        @echo "  ./scripts/mkdisk.sh            create/re-format the data disk"
+        @echo "  ./scripts/test-disk.sh         automated disk round trip"
+        @echo "  ./scripts/sendkeys.py          type into QEMU via the monitor"
         @echo "  ./scripts/boot-image.sh        boot full chain (builds if needed)"
         @echo "  ./scripts/build-image.sh       build full chain disk image"
         @echo "  ./scripts/build-bootloader.sh  build rsboot from source"
diff --git a/rsnix/src/ahci.rs b/rsnix/src/ahci.rs
index 2efe3b4..427345d 100644
--- a/rsnix/src/ahci.rs
+++ b/rsnix/src/ahci.rs
@@ -182,7 +182,10 @@ fn start_port(abar: usize, port_idx: u32) -> Option<Disk> {
     };
     // IDENTIFY DEVICE as a sanity check + to learn the capacity.
     if issue(&d, ATA_IDENTIFY, 0, 1, false).is_err() {
-        crate::serial_println!("ahci: IDENTIFY failed on port {} (not an ATA disk?)", port_idx);
+        crate::serial_println!(
+            "ahci: IDENTIFY failed on port {} (not an ATA disk?)",
+            port_idx
+        );
         return None;
     }
     let id = unsafe { core::slice::from_raw_parts(d.buf as *const u16, 256) };
diff --git a/scripts/boot.sh b/scripts/boot.sh
index 26064f9..99fd103 100755
--- a/scripts/boot.sh
+++ b/scripts/boot.sh
@@ -95,6 +95,11 @@ echo "  gui:   $([ -n "$GUI" ] && echo yes || echo no)"
 echo "  gdb:   $([ -n "$DEBUG" ] && echo ':1234' || echo off)"
 echo ""
 
+if [ ! -f "$DISK_IMG" ]; then
+        echo "  (creating missing disk image: $DISK_IMG)"
+        "$SCRIPT_DIR/mkdisk.sh" "$DISK_IMG"
+fi
+
 if [ -f "$DISK_IMG" ]; then
         DISK_ARGS=(
                 -drive "file=$DISK_IMG,format=raw,if=none,id=disk"
diff --git a/scripts/mkdisk.sh b/scripts/mkdisk.sh
new file mode 100755
index 0000000..f9a8c09
--- /dev/null
+++ b/scripts/mkdisk.sh
@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+#
+# scripts/mkdisk.sh — create (or re-create) the FAT32 data disk that the
+# kernel mounts at /disk.
+#
+# Usage:
+#   ./scripts/mkdisk.sh                 # create /tmp/disk.img (64M) if missing
+#   ./scripts/mkdisk.sh --fresh         # re-format (wipes the image!)
+#   ./scripts/mkdisk.sh --size 128M     # different size (default 64M)
+#   ./scripts/mkdisk.sh /path/img       # custom image path
+#   ./scripts/mkdisk.sh --no-seed       # skip the seed/ directory
+#
+# The image is created with `mkfs.fat -C`, which is the option that
+# actually creates the file — plain `mkfs.fat` only writes into an
+# existing one.  Files from seed/ (if present) are copied in with mtools.
+#
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+IMG="/tmp/disk.img"
+SIZE="64M"
+FRESH=0
+SEED_DIR="$PROJECT_DIR/seed"
+
+while [ $# -gt 0 ]; do
+        case "$1" in
+        --fresh) FRESH=1 ;;
+        --size)
+                shift
+                SIZE="$1"
+                ;;
+        --no-seed) SEED_DIR="" ;;
+        --help | -h)
+                head -20 "$0" | grep "^#" | sed 's/^# \?//'
+                exit 0
+                ;;
+        *)
+                IMG="$1"
+                ;;
+        esac
+        shift
+done
+
+if [ -f "$IMG" ] && [ "$FRESH" -eq 0 ]; then
+        echo "mkdisk: $IMG already exists (use --fresh to re-format)"
+        exit 0
+fi
+
+if ! command -v mkfs.fat >/dev/null 2>&1; then
+        echo "mkdisk: mkfs.fat not found — install dosfstools (sudo apt install dosfstools)" >&2
+        exit 1
+fi
+
+# mkfs.fat sizes are 1024-byte blocks; accept M/G/K suffixes too.
+case "$SIZE" in
+*G) SIZE_BLOCKS=$(( ${SIZE%G} * 1024 * 1024 )) ;;
+*M) SIZE_BLOCKS=$(( ${SIZE%M} * 1024 )) ;;
+*K) SIZE_BLOCKS=$(( ${SIZE%K} )) ;;
+*)      SIZE_BLOCKS="$SIZE" ;;
+esac
+if [ -z "$SIZE_BLOCKS" ] || [ "$SIZE_BLOCKS" -le 0 ] 2>/dev/null; then
+        echo "mkdisk: bad size '$SIZE' (use e.g. 64M or 65536)" >&2
+        exit 1
+fi
+
+echo "mkdisk: creating $IMG ($SIZE FAT32, label RSDOS)"
+rm -f "$IMG"
+mkfs.fat -C -F 32 -n RSDOS "$IMG" "$SIZE_BLOCKS"
+
+if [ -n "$SEED_DIR" ] && [ -d "$SEED_DIR" ]; then
+        if ! command -v mcopy >/dev/null 2>&1; then
+                echo "mkdisk: warning: mcopy not found — skipping seed files (install mtools)" >&2
+        else
+                echo "mkdisk: seeding from $SEED_DIR/"
+                for f in "$SEED_DIR"/*; do
+                        [ -f "$f" ] || continue
+                        mcopy -i "$IMG" "$f" "::/$(basename "$f")"
+                        echo "  -> $(basename "$f")"
+                done
+        fi
+fi
+
+echo "mkdisk: done — boot with: make run   (or: ./scripts/boot.sh)"
diff --git a/scripts/sendkeys.py b/scripts/sendkeys.py
new file mode 100755
index 0000000..5d1692c
--- /dev/null
+++ b/scripts/sendkeys.py
@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Type lines into a QEMU guest via the monitor's `sendkey` command.
+
+Each positional argument is one line: it is typed character by character
+(US layout) followed by Enter.  Use it to drive the rs-dos shell from a
+test script without a display.
+
+Usage:
+    sendkeys.py "ls /disk" "echo hi > /disk/a.txt" "poweroff"
+    sendkeys.py --sock /tmp/qmon.sock "date"
+
+Environment: QMON_SOCK (default: /tmp/qmon.sock)
+"""
+import os
+import socket
+import sys
+import time
+
+SOCK = os.environ.get("QMON_SOCK", "/tmp/qmon.sock")
+
+# Unshifted punctuation needs QEMU's *named* keys — bare '-'/'.'/'/' are
+# not valid sendkey names (and '-' is the modifier separator).
+BASE = {
+    "-": "minus", "=": "equal", "[": "bracketleft", "]": "bracketright",
+    "\\": "backslash", ";": "semicolon", "'": "apostrophe",
+    ",": "comma", ".": "dot", "/": "slash", "`": "grave",
+}
+
+# Characters that need a shift key on US layout, and the key QEMU's
+# `sendkey` understands for them.
+SHIFT = {
+    "~": "grave", "!": "1", "@": "2", "#": "3", "$": "4", "%": "5",
+    "^": "6", "&": "7", "*": "8", "(": "9", ")": "0",
+    "_": "minus", "+": "equal", "{": "bracketleft", "}": "bracketright",
+    "|": "backslash", ":": "semicolon", '"': "apostrophe",
+    "<": "comma", ">": "dot", "?": "slash",
+}
+
+ALNUM = set("abcdefghijklmnopqrstuvwxyz0123456789")
+
+
+def connect(path, timeout=60):
+    """Connect to the monitor socket, retrying until QEMU is up."""
+    deadline = time.time() + timeout
+    while True:
+        try:
+            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            s.connect(path)
+            return s
+        except OSError:
+            if time.time() > deadline:
+                raise
+            time.sleep(0.2)
+
+
+def sendkey(sock, keys):
+    sock.sendall(("sendkey %s\n" % keys).encode())
+
+
+def type_line(sock, line):
+    for ch in line:
+        if ch == " ":
+            sendkey(sock, "spc")
+        elif ch in BASE:
+            sendkey(sock, BASE[ch])
+        elif ch in SHIFT:
+            sendkey(sock, "shift-" + SHIFT[ch])
+        elif ch.isupper():
+            sendkey(sock, "shift-" + ch.lower())
+        elif ch in ALNUM:
+            sendkey(sock, ch)
+        else:
+            sys.stderr.write("warning: no sendkey mapping for %r\n" % ch)
+            continue
+        time.sleep(0.05)
+    sendkey(sock, "ret")
+    time.sleep(0.7)
+
+
+def main():
+    args = [a for a in sys.argv[1:] if a != "--sock"]
+    sock_path = SOCK
+    if "--sock" in sys.argv:
+        i = sys.argv.index("--sock")
+        sock_path = sys.argv[i + 1]
+        args = sys.argv[i + 2:]
+    if not args:
+        sys.stderr.write(__doc__ or "")
+        return 1
+    sock = connect(sock_path)
+    # Let the monitor drain any startup banner before typing.
+    time.sleep(0.5)
+    for line in args:
+        try:
+            type_line(sock, line)
+        except OSError:
+            # Guest powered off (last line was usually "poweroff").
+            break
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/test-disk.sh b/scripts/test-disk.sh
new file mode 100755
index 0000000..f7be7c6
--- /dev/null
+++ b/scripts/test-disk.sh
@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+#
+# scripts/test-disk.sh — full automated data-disk round trip.
+#
+# Builds the kernel, ensures the FAT32 image exists (with --fresh it is
+# re-formatted and re-seeded), boots QEMU headless, drives the shell via
+# the monitor, then verifies the results with mtools and fsck.
+#
+# Usage:
+#   ./scripts/test-disk.sh            # reuse existing image
+#   ./scripts/test-disk.sh --fresh    # re-format the image first
+#
+# Environment:
+#   DISK_IMG  data disk path (default: /tmp/disk.img)
+#   OVMF      firmware (default: /usr/share/edk2/x64/OVMF.4m.fd)
+#   QEMU      qemu binary (default: qemu-system-x86_64)
+#
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+cd "$PROJECT_DIR"
+
+FRESH=0
+[ "${1:-}" = "--fresh" ] && FRESH=1
+
+OVMF="${OVMF:-/usr/share/edk2/x64/OVMF.4m.fd}"
+QEMU="${QEMU:-qemu-system-x86_64}"
+IMG="${DISK_IMG:-/tmp/disk.img}"
+ESP_DIR="$PROJECT_DIR/esp"
+QPID=/tmp/rsdos-test-qpid
+SOCK=/tmp/rsdos-test-qmon.sock
+LOG=/tmp/rsdos-test-serial.log
+STAMP="$(date +%s)"
+
+fail() {
+        echo "FAIL: $1"
+        [ -f "$LOG" ] && tail -20 "$LOG"
+        exit 1
+}
+
+# wait_log FILE PATTERN TIMEOUT-SECONDS — poll a file for a regex.
+wait_log() {
+        local i=0
+        while [ "$i" -lt $(( ${3:-60} * 10 )) ]; do
+                grep -q "$2" "$1" 2>/dev/null && return 0
+                sleep 0.1
+                i=$((i + 1))
+        done
+        return 1
+}
+
+# wait_qemu_exit TIMEOUT-SECONDS — poll until the pid is gone.
+wait_qemu_exit() {
+        local i=0
+        while [ "$i" -lt $(( ${1:-30} * 10 )) ]; do
+                kill -0 "$(cat "$QPID" 2>/dev/null)" 2>/dev/null || return 0
+                sleep 0.1
+                i=$((i + 1))
+        done
+        return 1
+}
+
+echo "==> 1/6 build kernel (debug)"
+cargo build --package rsdos --target x86_64-unknown-uefi
+
+echo "==> 2/6 deploy to ESP + ensure disk image"
+mkdir -p "$ESP_DIR/EFI/BOOT"
+cp target/x86_64-unknown-uefi/debug/rsdos.efi "$ESP_DIR/EFI/BOOT/BOOTX64.EFI"
+"$SCRIPT_DIR/mkdisk.sh" $([ "$FRESH" -eq 1 ] && echo --fresh) "$IMG"
+
+echo "==> 3/6 boot QEMU (headless)"
+kill "$(cat "$QPID" 2>/dev/null)" 2>/dev/null || true
+sleep 1
+rm -f "$SOCK" "$LOG"
+"$QEMU" -bios "$OVMF" \
+        -drive file="$IMG",format=raw,if=none,id=disk \
+        -device ide-hd,drive=disk,bus=ide.0 \
+        -drive file=fat:rw:"$ESP_DIR",format=raw,if=none,id=esp \
+        -device ide-hd,drive=esp,bus=ide.1 \
+        -serial file:"$LOG" \
+        -monitor unix:"$SOCK",server,nowait \
+        -m 256M -machine q35 -cpu qemu64 -no-reboot -display none &
+echo $! > "$QPID"
+
+wait_log "$LOG" "boot: entering shell" 90 || fail "kernel never reached the shell"
+sleep 1
+
+echo "==> 4/6 drive the shell (ls / mkdir / echo > / cat / poweroff)"
+python3 "$SCRIPT_DIR/sendkeys.py" --sock "$SOCK" \
+        "ls /disk" \
+        "mkdir /disk/sub" \
+        "echo disk-test-$STAMP > /disk/sub/hello.txt" \
+        "cat /disk/sub/hello.txt" \
+        "poweroff"
+
+echo "==> 5/6 wait for shutdown"
+wait_qemu_exit 30 || fail "QEMU did not exit after poweroff"
+
+echo "==> 6/6 verify"
+grep -a "disk-test-$STAMP" "$LOG" >/dev/null || fail "cat output missing from serial log"
+if ! fsck.fat -n "$IMG" >/tmp/rsdos-fsck.out 2>&1; then
+        fail "fsck.fat reports problems: $(cat /tmp/rsdos-fsck.out | tail -3)"
+fi
+MT="$(mtype -i "$IMG" "::/sub/hello.txt" 2>/dev/null || true)"
+[ "$MT" = "disk-test-$STAMP" ] || fail "mtype mismatch: got '$MT'"
+
+echo ""
+echo "PASS — disk round trip OK (fsck clean, file survived poweroff)"
+echo "  image:      $IMG"
+echo "  written:    /disk/sub/hello.txt = \"disk-test-$STAMP\""
diff --git a/seed/lines.txt b/seed/lines.txt
new file mode 100644
index 0000000..719197f
--- /dev/null
+++ b/seed/lines.txt
@@ -0,0 +1,6 @@
+the quick brown fox jumps over the lazy dog
+the quick brown fox jumps over the lazy dog
+the quick brown fox jumps over the lazy dog
+line 4: a slightly longer line to exercise multi-cluster reads
+line 5: rs-dos persistence test — power off and back on
+line 6: hello from the disk
diff --git a/seed/motd.txt b/seed/motd.txt
new file mode 100644
index 0000000..ac960fa
--- /dev/null
+++ b/seed/motd.txt
@@ -0,0 +1,11 @@
+Welcome to rs-dos!
+
+This file lives on the FAT32 data disk (the one mounted at /disk).
+The kernel mounts the first valid FAT32 volume it finds — create or
+re-seed this image with:
+
+    make disk            # create if missing (default /tmp/disk.img)
+    make disk-fresh      # re-format + re-seed from seed/
+
+Everything written from the shell survives reboots: it's a real disk,
+not RAM.