fat: mount every FAT32 volume under /disk/<UID>/, fix multi-entry LFN

- fat.rs: VOL: Option<Volume> → VOLS: Vec<Volume>; try_mount() returns
  a Volume per disk and init() mounts every valid FAT32 volume found.
  Volume UID = sanitized uppercase label + 8-hex volume serial
  (e.g. RSDOS-5BD1E55F): unique per format, stable across reboots,
  human-recognizable, machine-parseable (^[A-Z0-9_]+-[0-9A-F]{8}$);
  cloned volumes get a -N suffix.  Public ops take a vol index and
  select it (select_vol also picks the backing AHCI disk), matching
  the ahci::select pattern
- fs.rs: /disk is now a plain directory whose children are one Disk
  node per mounted volume, named by UID; DiskInfo carries vol
- LFN fix: entries are stored last-first on disk — both the writer
  (head-entry first) and reader (append in disk order) were reversed
  and cancelled out for ≤13-char names; multi-entry names (>13 chars)
  read back mangled (e.g. 'from-kernel.txt' as 'xt').  Writer now
  places seq=1 closest to the SFN and seq=N|0x40 first; reader places
  chunks by sequence number and trims at the first NUL.  Verified with
  a 25-char filename round trip: kernel ls/cat correct, mtools shows
  the full LFN, fsck clean on both volumes
- test-disk.sh: test file renamed to disk-test-.txt (>13 chars,
  exercises multi-entry LFN); UID discovered from the boot log; QEMU
  stdio redirected to a log file + EXIT trap so an orphaned QEMU can
  never hang a piped caller (it previously did, 400s)

1 files changed, 142 insertions, 59 deletions

diff --git a/rsnix/src/fat.rs b/rsnix/src/fat.rs
index 616a08f..c486dfe 100644
--- a/rsnix/src/fat.rs
+++ b/rsnix/src/fat.rs
@@ -34,6 +34,8 @@ pub struct Entry {
 }
 
 struct Volume {
+    disk: usize,          // AHCI disk index this volume was mounted from
+    uid: String,          // unique mount name: "LABEL-XXXXXXXX"
     sectors_per_cluster: u8,
     reserved: u16,
     fat_count: u8,
@@ -45,14 +47,34 @@ struct Volume {
     fat: Vec<u8>,        // FAT 1 cached in RAM
 }
 
-static mut VOL: Option<Volume> = None;
+static mut VOLS: Vec<Volume> = Vec::new();
+static mut ACTIVE_VOL: usize = 0;
 
-pub fn is_mounted() -> bool {
-    unsafe { VOL.is_some() }
+pub fn volume_count() -> usize {
+    unsafe { VOLS.len() }
 }
 
-pub fn root_cluster() -> u32 {
-    unsafe { VOL.as_ref() }.map(|v| v.root_cluster).unwrap_or(0)
+/// Unique mount name of volume `vol` ("RSDOS-5BD1E55F").
+pub fn uid(vol: usize) -> &'static str {
+    unsafe { VOLS.get(vol) }.map(|v| v.uid.as_str()).unwrap_or("")
+}
+
+pub fn root_cluster(vol: usize) -> u32 {
+    unsafe { VOLS.get(vol) }.map(|v| v.root_cluster).unwrap_or(0)
+}
+
+/// Point all FAT operations at volume `vol`; also selects the backing
+/// AHCI disk.  Called by every public entry point (single-threaded
+/// kernel, so a process-wide "current volume" is fine).
+fn select_vol(vol: usize) -> Result<(), ()> {
+    let disk = unsafe { VOLS.get(vol) }.map(|v| v.disk).ok_or(())?;
+    unsafe {
+        ACTIVE_VOL = vol;
+    }
+    if !crate::ahci::select(disk) {
+        return Err(());
+    }
+    Ok(())
 }
 
 // --- sector I/O -----------------------------------------------------------
@@ -71,7 +93,7 @@ fn write_sector(lba: u64, data: &[u8; SECTOR]) -> Result<(), ()> {
 // --- cluster math ----------------------------------------------------------
 
 fn v() -> &'static mut Volume {
-    unsafe { VOL.as_mut() }.unwrap()
+    unsafe { VOLS.get_mut(ACTIVE_VOL) }.unwrap()
 }
 
 fn spc() -> usize {
@@ -336,7 +358,19 @@ fn scan_dir(dir_cluster: u32) -> Result<Vec<DirItem>, ()> {
                 _ => {
                     let attr = e[11];
                     if attr == 0x0F {
-                        // LFN entry: 13 UTF-16 chars (bytes 1-10, 14-25, 28-31).
+                        // LFN entry: 13 UTF-16 chars (bytes 1-10, 14-25,
+                        // 28-31).  Entries are stored last-first on disk;
+                        // place each chunk by its sequence number so
+                        // multi-entry names reassemble in the right order.
+                        let seq = (e[0] & 0x1F) as usize;
+                        if seq == 0 || seq > 20 {
+                            continue;
+                        }
+                        let need = seq * 13;
+                        if lfn.len() < need {
+                            lfn.resize(need, 0);
+                        }
+                        let base = (seq - 1) * 13;
                         for k in 0..13 {
                             let pos = if k < 5 {
                                 1 + k * 2
@@ -347,11 +381,9 @@ fn scan_dir(dir_cluster: u32) -> Result<Vec<DirItem>, ()> {
                             };
                             let ch = u16::from_le_bytes([e[pos], e[pos + 1]]);
                             if ch == 0x0000 {
-                                break;
-                            }
-                            if ch != 0xFFFF {
-                                lfn.push(ch);
+                                break; // end of the name; rest is 0xFFFF padding
                             }
+                            lfn[base + k] = ch;
                         }
                         lfn_sum = e[13];
                     } else {
@@ -359,7 +391,8 @@ fn scan_dir(dir_cluster: u32) -> Result<Vec<DirItem>, ()> {
                         let mut sfn = [0u8; 11];
                         sfn.copy_from_slice(&e[0..11]);
                         let name = if !lfn.is_empty() && lfn_checksum(&sfn) == lfn_sum {
-                            utf16_to_string(&lfn)
+                            let end = lfn.iter().position(|&c| c == 0).unwrap_or(lfn.len());
+                            utf16_to_string(&lfn[..end])
                         } else {
                             sfn_decode(e)
                         };
@@ -387,7 +420,8 @@ fn scan_dir(dir_cluster: u32) -> Result<Vec<DirItem>, ()> {
 }
 
 /// Public listing: no `.` / `..`.
-pub fn list_dir(dir_cluster: u32) -> Result<Vec<Entry>, ()> {
+pub fn list_dir(vol: usize, dir_cluster: u32) -> Result<Vec<Entry>, ()> {
+    select_vol(vol)?;
     Ok(scan_dir(dir_cluster)?
         .into_iter()
         .filter(|i| i.name != "." && i.name != "..")
@@ -412,7 +446,8 @@ fn find_item(parent_dir_cluster: u32, name: &str) -> Result<DirItem, ()> {
 }
 
 /// Find an entry by name (case-insensitive).
-pub fn find(parent_dir_cluster: u32, name: &str) -> Result<Entry, ()> {
+pub fn find(vol: usize, parent_dir_cluster: u32, name: &str) -> Result<Entry, ()> {
+    select_vol(vol)?;
     find_item(parent_dir_cluster, name).map(|i| Entry {
         name: i.name,
         is_dir: i.attr & 0x10 != 0,
@@ -424,15 +459,17 @@ pub fn find(parent_dir_cluster: u32, name: &str) -> Result<Entry, ()> {
 // --- file data --------------------------------------------------------------
 
 pub fn read_file(
+    vol: usize,
     parent_dir_cluster: u32,
     name: &str,
     buf: &mut [u8],
     pos: u64,
 ) -> Result<usize, ()> {
+    select_vol(vol)?;
     if buf.is_empty() {
         return Ok(0);
     }
-    let it = find(parent_dir_cluster, name)?;
+    let it = find(vol, parent_dir_cluster, name)?;
     if it.is_dir || it.cluster == 0 {
         return Err(());
     }
@@ -467,7 +504,8 @@ pub fn read_file(
     Ok(out)
 }
 
-pub fn write_file(parent_dir_cluster: u32, name: &str, buf: &[u8], pos: u64) -> Result<usize, ()> {
+pub fn write_file(vol: usize, parent_dir_cluster: u32, name: &str, buf: &[u8], pos: u64) -> Result<usize, ()> {
+    select_vol(vol)?;
     if buf.is_empty() {
         return Ok(0);
     }
@@ -529,7 +567,8 @@ pub fn write_file(parent_dir_cluster: u32, name: &str, buf: &[u8], pos: u64) ->
     Ok(buf.len())
 }
 
-pub fn set_len(parent_dir_cluster: u32, name: &str, len: u64) -> Result<(), ()> {
+pub fn set_len(vol: usize, parent_dir_cluster: u32, name: &str, len: u64) -> Result<(), ()> {
+    select_vol(vol)?;
     let it = find_item(parent_dir_cluster, name)?;
     if it.attr & 0x10 != 0 {
         return Err(());
@@ -721,8 +760,11 @@ fn add_dir_entry(parent: u32, name: &str, is_dir: bool, cluster: u32) -> Result<
         if run >= needed {
             if groups > 0 {
                 for g in 0..groups {
-                    let seq = (groups - g) as u8 | if g == groups - 1 { 0x40 } else { 0 };
-                    let e = &mut buf[(start + g) * 32..(start + g) * 32 + 32];
+                    // LFN entries are stored last-first on disk: the tail
+                    // chunk (highest seq, LAST flag) goes first, and the
+                    // head chunk (seq 1) lands immediately before the SFN.
+                    let seq = (g + 1) as u8 | if g == groups - 1 { 0x40 } else { 0 };
+                    let e = &mut buf[(start + groups - 1 - g) * 32..(start + groups - 1 - g) * 32 + 32];
                     e.fill(0);
                     e[0] = seq;
                     e[11] = 0x0F;
@@ -769,8 +811,9 @@ fn add_dir_entry(parent: u32, name: &str, is_dir: bool, cluster: u32) -> Result<
     }
 }
 
-pub fn create(parent_dir_cluster: u32, name: &str, is_dir: bool) -> Result<(), ()> {
-    if find(parent_dir_cluster, name).is_ok() {
+pub fn create(vol: usize, parent_dir_cluster: u32, name: &str, is_dir: bool) -> Result<(), ()> {
+    select_vol(vol)?;
+    if find(vol, parent_dir_cluster, name).is_ok() {
         return Err(());
     }
     let cluster = if is_dir {
@@ -807,11 +850,12 @@ pub fn create(parent_dir_cluster: u32, name: &str, is_dir: bool) -> Result<(), (
     add_dir_entry(parent_dir_cluster, name, is_dir, cluster)
 }
 
-pub fn remove(parent_dir_cluster: u32, name: &str) -> Result<(), ()> {
+pub fn remove(vol: usize, parent_dir_cluster: u32, name: &str) -> Result<(), ()> {
+    select_vol(vol)?;
     let it = find_item(parent_dir_cluster, name)?;
     if it.attr & 0x10 != 0 {
         // Only empty directories may be removed.
-        let kids = list_dir(it.cluster)?;
+        let kids = list_dir(vol, it.cluster)?;
         if !kids.is_empty() {
             return Err(());
         }
@@ -847,35 +891,59 @@ pub fn init() -> bool {
         crate::serial_println!("fat: no disk");
         return false;
     }
+    let mut mounted = false;
     for d in 0..disks {
         if !crate::ahci::select(d) {
             continue;
         }
-        if try_mount() {
-            return true;
+        match try_mount(d) {
+            Some(volume) => {
+                let uid = volume.uid.clone();
+                let vol = unsafe {
+                    VOLS.push(volume);
+                    VOLS.len() - 1
+                };
+                // Re-sync the FSInfo free-cluster count (may be stale
+                // from earlier sessions).
+                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 = true;
+            }
+            None => crate::serial_println!("fat: no FAT32 volume on disk {}", d),
         }
-        crate::serial_println!("fat: no FAT32 volume on disk {}", d);
     }
-    false
+    mounted
 }
 
 /// Parse the BPB of the selected disk, cache the FAT and validate the
-/// volume.
-fn try_mount() -> bool {
+/// volume.  Returns the ready-to-mount volume or None.
+fn try_mount(d: usize) -> Option<Volume> {
     let mut bpb = [0u8; SECTOR];
     if read_sector(0, &mut bpb).is_err() {
         crate::serial_println!("fat: no disk");
-        return false;
+        return None;
     }
     let bytes_per_sector = u16::from_le_bytes([bpb[11], bpb[12]]);
     if bytes_per_sector != 512 {
         crate::serial_println!("fat: unsupported sector size {}", bytes_per_sector);
-        return false;
+        return None;
     }
     let spc = bpb[13];
     if spc == 0 || spc & (spc - 1) != 0 {
         crate::serial_println!("fat: bad sectors/cluster {}", spc);
-        return false;
+        return None;
     }
     let reserved = u16::from_le_bytes([bpb[14], bpb[15]]);
     let fat_count = bpb[16];
@@ -891,12 +959,12 @@ fn try_mount() -> bool {
     let fsinfo_sec = u16::from_le_bytes([bpb[48], bpb[49]]) as u32;
     if fat_size == 0 || root_cluster < 2 || reserved == 0 || fat_count == 0 {
         crate::serial_println!("fat: not FAT32 (root={} fat={})", root_cluster, fat_size);
-        return false;
+        return None;
     }
     let first_data = reserved as u32 + fat_count as u32 * fat_size;
     if first_data >= total {
         crate::serial_println!("fat: bad geometry");
-        return false;
+        return None;
     }
     let cluster_count = (total - first_data) / spc as u32;
 
@@ -909,7 +977,7 @@ fn try_mount() -> bool {
         let n = ((fat.len() - done) / SECTOR).min(8) as u32;
         if ahci::read_sectors(lba, n).is_err() {
             crate::serial_println!("fat: FAT read failed at lba {}", lba);
-            return false;
+            return None;
         }
         unsafe {
             core::ptr::copy(ahci::buf(), fat.as_mut_ptr().add(done), n as usize * SECTOR);
@@ -926,30 +994,45 @@ fn try_mount() -> bool {
             e0 & 0xFF,
             e1 & EOC_MASK
         );
-        return false;
+        return None;
     }
-    unsafe {
-        VOL = Some(Volume {
-            sectors_per_cluster: spc,
-            reserved,
-            fat_count,
-            fat_size,
-            root_cluster,
-            first_data,
-            cluster_count,
-            fsinfo: (fsinfo_sec != 0 && fsinfo_sec < total).then_some(fsinfo_sec),
-            fat,
-        });
-    }
-    // Re-sync the FSInfo free-cluster count (may be stale from earlier
-    // sessions that predate FSInfo maintenance).
-    fsinfo_recount();
-    let count = list_dir(root_cluster).map(|v| v.len()).unwrap_or(0);
-    crate::serial_println!(
-        "fat: FAT32 mounted — {} clusters ({} bytes each), root: {} entries",
+    // Volume identity: sanitized label + volume serial → "RSDOS-5BD1E55F".
+    // Unique per format, stable across reboots, human-recognizable, and
+    // machine-parseable (^[A-Z0-9_]+-[0-9A-F]{8}$).
+    let serial = u32::from_le_bytes([bpb[67], bpb[68], bpb[69], bpb[70]]);
+    let mut label = String::new();
+    for &c in &bpb[71..82] {
+        if c == 0 || c == b' ' {
+            continue; // strip padding/NULs
+        }
+        let ch = (c as char).to_ascii_uppercase();
+        label.push(if ch.is_ascii_alphanumeric() { ch } else { '_' });
+    }
+    if label.is_empty() {
+        label = String::from("DISK");
+    }
+    // Deduplicate against already-mounted volumes (e.g. cloned images).
+    let mut uid = alloc::format!("{}-{:08X}", label, serial);
+    let mut n = 2u32;
+    loop {
+        let taken = unsafe { VOLS.iter() }.any(|v| v.uid == uid);
+        if !taken {
+            break;
+        }
+        uid = alloc::format!("{}-{:08X}-{}", label, serial, n);
+        n += 1;
+    }
+    Some(Volume {
+        disk: d,
+        uid,
+        sectors_per_cluster: spc,
+        reserved,
+        fat_count,
+        fat_size,
+        root_cluster,
+        first_data,
         cluster_count,
-        cluster_size(),
-        count
-    );
-    true
+        fsinfo: (fsinfo_sec != 0 && fsinfo_sec < total).then_some(fsinfo_sec),
+        fat,
+    })
 }