3 files changed, 250 insertions, 35 deletions

diff --git a/rsnix/src/ahci.rs b/rsnix/src/ahci.rs
index 9a49431..9ed803d 100644
--- a/rsnix/src/ahci.rs
+++ b/rsnix/src/ahci.rs
@@ -52,17 +52,28 @@ const ATA_WRITE_DMA_EXT: u8 = 0x35;
 /// One attached disk: register map + DMA structures.
 #[derive(Clone, Copy)]
 struct Disk {
-    port: usize,  // port register base = ABAR + 0x100
-    clb: usize,   // command list, 1024 B (32 × 32 B), 256 B aligned
-    ct: usize,    // command table, 256 B, 128 B aligned
-    buf: usize,   // 4 KiB DMA data buffer (page aligned)
-    sectors: u64, // total sectors (LBA48 from IDENTIFY)
+    port: usize,   // port register base = ABAR + 0x100
+    port_idx: u32, // implemented-port index this disk lives on (rescan bookkeeping)
+    clb: usize,    // command list, 1024 B (32 × 32 B), 256 B aligned
+    ct: usize,     // command table, 256 B, 128 B aligned
+    buf: usize,    // 4 KiB DMA data buffer (page aligned)
+    sectors: u64,  // total sectors (LBA48 from IDENTIFY)
 }
 
 static mut DISKS: [Option<Disk>; MAX_DISKS] = [None; MAX_DISKS];
 static mut DISK_COUNT: usize = 0;
 static mut ACTIVE: usize = 0;
 
+// Controller state kept for runtime rescan: ABAR + the implemented-port
+// bitmap, plus the last-known device presence (PxSSTS.DET == 3) per port.
+// `poll_dirty` compares live DET against this, so a hotplug is noticed
+// with a handful of MMIO reads; the full re-scan only runs on a change.
+const MAX_PORTS: usize = 32;
+static mut ABAR: usize = 0;
+static mut NP: u32 = 0;
+static mut IMPL_PORTS: u32 = 0;
+static mut PORT_UP: [bool; MAX_PORTS] = [false; MAX_PORTS];
+
 fn reg(a: usize) -> u32 {
     unsafe { core::ptr::read_volatile(a as *const u32) }
 }
@@ -173,6 +184,7 @@ fn start_port(abar: usize, port_idx: u32) -> Option<Disk> {
 
     let mut d = Disk {
         port,
+        port_idx,
         clb,
         ct,
         buf,
@@ -238,16 +250,24 @@ pub fn init() -> bool {
 
     // Scan implemented ports (CAP.NP + 1 of them, filtered by PI).
     let cap = reg(abar as usize + CAP);
-    let np = ((cap & 0x1F) + 1).min(32);
+    let np = ((cap & 0x1F) + 1).min(MAX_PORTS as u32);
     let pi = reg(abar as usize + PI);
+    unsafe {
+        ABAR = abar as usize;
+        NP = np;
+        IMPL_PORTS = pi;
+    }
     for port_idx in 0..np {
         if (pi >> port_idx) & 1 == 0 {
             continue;
         }
+        let det = reg(abar as usize + PORT_BASE + port_idx as usize * PORT_STRIDE + P_SSTS) & 0xF;
+        unsafe { PORT_UP[port_idx as usize] = det == 3; }
         if let Some(d) = start_port(abar as usize, port_idx) {
-            unsafe {
-                DISKS[DISK_COUNT] = Some(d);
-                DISK_COUNT += 1;
+            // The device answered IDENTIFY — it's definitely present.
+            unsafe { PORT_UP[port_idx as usize] = true; }
+            if !place_disk(d) {
+                crate::serial_println!("ahci: port {} up but disk table full", port_idx);
             }
         }
     }
@@ -257,16 +277,103 @@ pub fn init() -> bool {
     unsafe { DISK_COUNT > 0 }
 }
 
-/// Number of disks found at boot.
+/// Record a started disk in the table, reusing a tombstoned (None) slot so
+/// indices stay stable across plug/unplug cycles.  Returns false if full.
+fn place_disk(d: Disk) -> bool {
+    unsafe {
+        for i in 0..MAX_DISKS {
+            if DISKS[i].is_none() {
+                DISKS[i] = Some(d);
+                DISK_COUNT = DISK_COUNT.max(i + 1);
+                return true;
+            }
+        }
+    }
+    false
+}
+
+/// Number of disk slots in use (high-water mark; tombstones included).
 pub fn disk_count() -> usize {
     unsafe { DISK_COUNT }
 }
 
+/// Cheap runtime hotplug probe: true if any implemented port's device
+/// presence (PxSSTS.DET == 3) differs from the last known state.  A few
+/// MMIO reads — safe to call on every shell prompt.
+pub fn poll_dirty() -> bool {
+    let abar = unsafe { ABAR };
+    if abar == 0 {
+        return false;
+    }
+    let (np, pi) = (unsafe { NP }, unsafe { IMPL_PORTS });
+    for port_idx in 0..np {
+        if (pi >> port_idx) & 1 == 0 {
+            continue;
+        }
+        let det = reg(abar + PORT_BASE + port_idx as usize * PORT_STRIDE + P_SSTS) & 0xF;
+        if (det == 3) != unsafe { PORT_UP[port_idx as usize] } {
+            return true;
+        }
+    }
+    false
+}
+
+/// Re-scan the controller's ports for arrivals/removals.  Starts ports
+/// that now have a link, tombstones (None) the slots of ports whose device
+/// vanished, and refreshes the poll state.  Slot indices never shift, so
+/// the filesystem's disk handles stay valid.  Returns (added, removed).
+pub fn rescan() -> (usize, usize) {
+    let abar = unsafe { ABAR };
+    if abar == 0 {
+        return (0, 0);
+    }
+    let (np, pi) = (unsafe { NP }, unsafe { IMPL_PORTS });
+    let mut added = 0usize;
+    let mut removed = 0usize;
+    for port_idx in 0..np {
+        if (pi >> port_idx) & 1 == 0 {
+            continue;
+        }
+        let port = abar + PORT_BASE + port_idx as usize * PORT_STRIDE;
+        let det = reg(port + P_SSTS) & 0xF;
+        let up = det == 3;
+        let slot = disks()
+            .iter()
+            .position(|d| d.is_some_and(|d| d.port_idx == port_idx));
+        let up_prev = unsafe { PORT_UP[port_idx as usize] };
+        unsafe { PORT_UP[port_idx as usize] = up; }
+        if up == up_prev {
+            continue;
+        }
+        if up {
+            // Arrival: full bring-up on this port.
+            if let Some(d) = start_port(abar, port_idx) {
+                if place_disk(d) {
+                    added += 1;
+                } else {
+                    crate::serial_println!("ahci: port {} up but disk table full", port_idx);
+                }
+            }
+        } else if let Some(i) = slot {
+            // Removal: tombstone the slot; indices stay stable.
+            unsafe { DISKS[i] = None; }
+            crate::serial_println!("ahci: port {} down — device removed", port_idx);
+            removed += 1;
+        }
+    }
+    (added, removed)
+}
+
+/// Is the disk at index `idx` still attached?  (False for tombstones.)
+pub fn is_up(idx: usize) -> bool {
+    disks().get(idx).is_some_and(|d| d.is_some())
+}
+
 /// Make `idx` the disk the sector API reads/writes.  Returns false if the
-/// index is out of range.
+/// index is out of range or its slot is a tombstone.
 pub fn select(idx: usize) -> bool {
     unsafe {
-        if idx < DISK_COUNT {
+        if idx < DISK_COUNT && DISKS[idx].is_some() {
             ACTIVE = idx;
             true
         } else {
diff --git a/rsnix/src/fat.rs b/rsnix/src/fat.rs
index 335a160..ef75aa9 100644
--- a/rsnix/src/fat.rs
+++ b/rsnix/src/fat.rs
@@ -36,6 +36,7 @@ pub struct Entry {
 struct Volume {
     disk: usize, // AHCI disk index this volume was mounted from
     uid: String, // unique mount name: "LABEL-XXXXXXXX"
+    mounted: bool, // still backed by a present disk (false = tombstoned)
     sectors_per_cluster: u8,
     reserved: u16,
     fat_size: u32, // sectors per FAT
@@ -65,6 +66,69 @@ pub fn volume_count() -> usize {
     vols().len()
 }
 
+/// Is volume `vol` currently mounted (its disk present and FAT cached)?
+pub fn is_mounted(vol: usize) -> bool {
+    vols().get(vol).map(|v| v.mounted).unwrap_or(false)
+}
+
+/// Re-scan after a disk arrival/removal: unmount volumes whose disk left,
+/// mount every disk that has no mounted volume (which also re-tries
+/// mounts that failed at boot).  Volume slots are tombstoned, never
+/// removed, so VFS disk handles keep their indices.  Returns
+/// (mounted, unmounted).
+pub fn rescan() -> (usize, usize) {
+    let disks = crate::ahci::disk_count();
+    let mut mounted = 0usize;
+    let mut unmounted = 0usize;
+    // Unmount volumes whose disk is gone.
+    for i in 0..vols().len() {
+        if vols()[i].mounted && !crate::ahci::is_up(vols()[i].disk) {
+            vols()[i].mounted = false;
+            crate::serial_println!("fat: unmounted \"{}\"", vols()[i].uid);
+            unmounted += 1;
+        }
+    }
+    // Mount every disk that has no mounted volume.
+    for d in 0..disks {
+        if !crate::ahci::select(d) {
+            continue;
+        }
+        if vols().iter().any(|v| v.mounted && v.disk == d) {
+            continue;
+        }
+        if let Some(volume) = try_mount(d) {
+            let uid = volume.uid.clone();
+            let vol = match vols().iter().position(|v| !v.mounted && v.disk == d) {
+                // Reuse the disk's own tombstoned slot (indices stay stable).
+                Some(slot) => {
+                    vols()[slot] = volume;
+                    slot
+                }
+                None => {
+                    vols().push(volume);
+                    vols().len() - 1
+                }
+            };
+            if select_vol(vol).is_ok() {
+                fsinfo_recount();
+            }
+            let count = list_dir(vol, root_cluster(vol))
+                .map(|es| es.len())
+                .unwrap_or(0);
+            crate::serial_println!(
+                "fat: mounted \"{}\" at /disk/{} ({} clusters, {} B/cluster, root: {} entries)",
+                uid,
+                uid,
+                v().cluster_count,
+                cluster_size(),
+                count
+            );
+            mounted += 1;
+        }
+    }
+    (mounted, unmounted)
+}
+
 /// Unique mount name of volume `vol` ("RSDOS-5BD1E55F").
 pub fn uid(vol: usize) -> &'static str {
     vols().get(vol).map(|v| v.uid.as_str()).unwrap_or("")
@@ -1099,11 +1163,12 @@ fn try_mount(d: usize) -> Option<Volume> {
     if label.is_empty() {
         label = String::from("DISK");
     }
-    // Deduplicate against already-mounted volumes (e.g. cloned images).
+    // Deduplicate against already-MOUNTED volumes (e.g. cloned images).
+    // Tombstoned slots are skipped so a re-plugged disk keeps its name.
     let mut uid = alloc::format!("{}-{:08X}", label, serial);
     let mut n = 2u32;
     loop {
-        let taken = vols().iter().any(|v| v.uid == uid);
+        let taken = vols().iter().any(|v| v.mounted && v.uid == uid);
         if !taken {
             break;
         }
@@ -1113,6 +1178,7 @@ fn try_mount(d: usize) -> Option<Volume> {
     Some(Volume {
         disk: d,
         uid,
+        mounted: true,
         sectors_per_cluster: spc,
         reserved,
         fat_size,
diff --git a/rsnix/src/fs.rs b/rsnix/src/fs.rs
index 063560a..b560bfa 100644
--- a/rsnix/src/fs.rs
+++ b/rsnix/src/fs.rs
@@ -183,33 +183,75 @@ pub fn init() -> (usize, usize) {
     );
 
     // Mount every FAT32 volume under /disk/<UID>/ (UID = label-serial).
-    let disks = crate::fat::volume_count();
-    if disks > 0 {
-        let disk_dir = add("disk", Some(root), FileType::Dir, NodeData::Dir(Vec::new()));
-        for vol in 0..disks {
-            let uid = String::from(crate::fat::uid(vol));
-            let root_cl = crate::fat::root_cluster(vol);
-            add(
-                &uid,
-                Some(disk_dir),
-                FileType::Dir,
-                NodeData::Disk(DiskInfo {
-                    vol,
-                    parent: root_cl,
-                    name: String::new(),
-                    is_dir: true,
-                    size: 0,
-                    cluster: root_cl,
-                }),
-            );
-        }
-    }
+    // `rescan_disks()` also keeps this table current after hotplug events.
+    let _ = rescan_disks();
 
     let dirs = nodes().iter().filter(|n| n.kind == FileType::Dir).count();
     let files = nodes().len() - dirs;
     (dirs, files)
 }
 
+/// (Re)sync the /disk mount table with the FAT volumes: create the /disk
+/// dir lazily, ensure a mount node for every mounted volume (refreshing
+/// its backing info), and tombstone nodes whose volume was unmounted.
+/// Returns (added, removed) node ops.
+pub fn rescan_disks() -> (usize, usize) {
+    let mut added = 0usize;
+    let mut removed = 0usize;
+    let disk_dir = match lookup(0, "disk") {
+        Some(h) => h,
+        None => add("disk", Some(0), FileType::Dir, NodeData::Dir(Vec::new())),
+    };
+    for vol in 0..crate::fat::volume_count() {
+        if !crate::fat::is_mounted(vol) {
+            continue;
+        }
+        let uid = String::from(crate::fat::uid(vol));
+        let root_cl = crate::fat::root_cluster(vol);
+        match lookup(disk_dir, &uid) {
+            Some(h) => {
+                // Refresh the backing info in case the volume's slot moved.
+                if let NodeData::Disk(i) = &mut nodes()[h].data {
+                    i.vol = vol;
+                    i.parent = root_cl;
+                    i.cluster = root_cl;
+                }
+                nodes()[h].removed = false;
+            }
+            None => {
+                add(
+                    &uid,
+                    Some(disk_dir),
+                    FileType::Dir,
+                    NodeData::Disk(DiskInfo {
+                        vol,
+                        parent: root_cl,
+                        name: String::new(),
+                        is_dir: true,
+                        size: 0,
+                        cluster: root_cl,
+                    }),
+                );
+                added += 1;
+            }
+        }
+    }
+    if let NodeData::Dir(v) = &nodes()[disk_dir].data {
+        for &c in v.clone().iter() {
+            if nodes()[c].removed {
+                continue;
+            }
+            if let NodeData::Disk(i) = &nodes()[c].data
+                && !crate::fat::is_mounted(i.vol)
+            {
+                nodes()[c].removed = true;
+                removed += 1;
+            }
+        }
+    }
+    (added, removed)
+}
+
 fn lookup(dir: usize, name: &str) -> Option<usize> {
     let children = match &nodes()[dir].data {
         NodeData::Dir(v) => v.clone(),