Add a little shell example.

You can walk around a disk image and do directory listings. I had to make some more things 'Debug' so I could print the filesystem state. Also our handling of ".." was not right so I fixed that.

Author: thejpster

examples/linux/mod.rs

@@ -74,6 +74,7 @@ impl BlockDevice for LinuxBlockDevice {
     }
 }
 
+#[derive(Debug)]
 pub struct Clock;
 
 impl TimeSource for Clock {

examples/shell.rs

@@ -0,0 +1,151 @@
+//! A simple shell demo for embedded-sdmmc
+//!
+//! Presents a basic command prompt which implements some basic MS-DOS style shell commands.
+
+use std::io::prelude::*;
+
+use embedded_sdmmc::{Directory, Error, Volume, VolumeIdx, VolumeManager};
+
+use crate::linux::{Clock, LinuxBlockDevice};
+
+mod linux;
+
+struct State {
+    directory: Directory,
+    volume: Volume,
+}
+
+fn main() -> Result<(), Error<std::io::Error>> {
+    env_logger::init();
+    let mut args = std::env::args().skip(1);
+    let filename = args.next().unwrap_or_else(|| "/dev/mmcblk0".into());
+    let print_blocks = args.find(|x| x == "-v").map(|_| true).unwrap_or(false);
+    println!("Opening '{filename}'...");
+    let lbd = LinuxBlockDevice::new(filename, print_blocks).map_err(Error::DeviceError)?;
+    let mut volume_mgr: VolumeManager<LinuxBlockDevice, Clock, 8, 8, 4> =
+        VolumeManager::new_with_limits(lbd, Clock, 100);
+    let stdin = std::io::stdin();
+    let mut volumes: [Option<State>; 4] = [None, None, None, None];
+
+    let mut current_volume = None;
+    for volume_no in 0..4 {
+        match volume_mgr.open_volume(VolumeIdx(volume_no)) {
+            Ok(volume) => {
+                println!("Volume # {}: found", volume_no,);
+                match volume_mgr.open_root_dir(volume) {
+                    Ok(root_dir) => {
+                        volumes[volume_no] = Some(State {
+                            directory: root_dir,
+                            volume,
+                        });
+                        if current_volume.is_none() {
+                            current_volume = Some(volume_no);
+                        }
+                    }
+                    Err(e) => {
+                        println!("Failed to open root directory: {e:?}");
+                        volume_mgr.close_volume(volume).expect("close volume");
+                    }
+                }
+            }
+            Err(e) => {
+                println!("Failed to open volume {volume_no}: {e:?}");
+            }
+        }
+    }
+
+    let Some(mut current_volume) = current_volume else {
+        println!("No volumes found in file. Sorry.");
+        return Ok(());
+    };
+
+    loop {
+        print!("{}:> ", current_volume);
+        std::io::stdout().flush().unwrap();
+        let mut line = String::new();
+        stdin.read_line(&mut line)?;
+        let line = line.trim();
+        log::info!("Got command: {line:?}");
+        if line == "quit" {
+            break;
+        } else if line == "help" {
+            println!("Commands:");
+            println!("\thelp                -> this help text");
+            println!("\t<volume>:           -> change volume/partition");
+            println!("\tdir                 -> do a directory listing");
+            println!("\tquit                -> exits the program");
+        } else if line == "0:" {
+            current_volume = 0;
+        } else if line == "1:" {
+            current_volume = 1;
+        } else if line == "2:" {
+            current_volume = 2;
+        } else if line == "3:" {
+            current_volume = 3;
+        } else if line == "stat" {
+            println!("Status:\n{volume_mgr:#?}");
+        } else if line == "dir" {
+            let Some(s) = &volumes[current_volume] else {
+                println!("That volume isn't available");
+                continue;
+            };
+            let r = volume_mgr.iterate_dir(s.directory, |entry| {
+                println!(
+                    "{:12} {:9} {} {}",
+                    entry.name,
+                    entry.size,
+                    entry.mtime,
+                    if entry.attributes.is_directory() {
+                        "<DIR>"
+                    } else {
+                        ""
+                    }
+                );
+            });
+            handle("iterating directory", r);
+        } else if let Some(arg) = line.strip_prefix("cd ") {
+            let Some(s) = &mut volumes[current_volume] else {
+                println!("This volume isn't available");
+                continue;
+            };
+            match volume_mgr.open_dir(s.directory, arg) {
+                Ok(d) => {
+                    let r = volume_mgr.close_dir(s.directory);
+                    handle("closing old directory", r);
+                    s.directory = d;
+                }
+                Err(e) => {
+                    handle("changing directory", Err(e));
+                }
+            }
+        } else {
+            println!("Unknown command {line:?} - try 'help' for help");
+        }
+    }
+
+    for (idx, s) in volumes.into_iter().enumerate() {
+        if let Some(state) = s {
+            println!("Unmounting {idx}...");
+            let r = volume_mgr.close_dir(state.directory);
+            handle("closing directory", r);
+            let r = volume_mgr.close_volume(state.volume);
+            handle("closing volume", r);
+            println!("Unmounted {idx}!");
+        }
+    }
+
+    println!("Bye!");
+    Ok(())
+}
+
+fn handle(operation: &str, r: Result<(), Error<std::io::Error>>) {
+    if let Err(e) = r {
+        println!("Error {operation}: {e:?}");
+    }
+}
+
+// ****************************************************************************
+//
+// End Of File
+//
+// ****************************************************************************

src/fat/ondiskdirentry.rs

@@ -148,17 +148,26 @@ impl<'a> OnDiskDirEntry<'a> {
         entry_block: BlockIdx,
         entry_offset: u32,
     ) -> DirEntry {
+        let attributes = Attributes::create_from_fat(self.raw_attr());
         let mut result = DirEntry {
             name: ShortFileName {
                 contents: [0u8; 11],
             },
             mtime: Timestamp::from_fat(self.write_date(), self.write_time()),
             ctime: Timestamp::from_fat(self.create_date(), self.create_time()),
-            attributes: Attributes::create_from_fat(self.raw_attr()),
-            cluster: if fat_type == FatType::Fat32 {
-                self.first_cluster_fat32()
-            } else {
-                self.first_cluster_fat16()
+            attributes,
+            cluster: {
+                let cluster = if fat_type == FatType::Fat32 {
+                    self.first_cluster_fat32()
+                } else {
+                    self.first_cluster_fat16()
+                };
+                if cluster == ClusterId::EMPTY && attributes.is_directory() {
+                    // FAT16/FAT32 uses a cluster ID of `0` in the ".." entry to mean 'root directory'
+                    ClusterId::ROOT_DIR
+                } else {
+                    cluster
+                }
             },
             size: self.file_size(),
             entry_block,

src/filesystem/filename.rs

@@ -85,6 +85,12 @@ impl ShortFileName {
         let mut sfn = ShortFileName {
             contents: [b' '; Self::FILENAME_MAX_LEN],
         };
+
+        // Special case `..`, which means "parent directory".
+        if name == ".." {
+            return Ok(ShortFileName::parent_dir());
+        }
+
         let mut idx = 0;
         let mut seen_dot = false;
         for ch in name.bytes() {

src/filesystem/search_id.rs

@@ -12,6 +12,7 @@ pub struct SearchId(pub(crate) u32);
 /// Well, it will wrap after `2**32` IDs. But most systems won't open that many
 /// files, and if they do, they are unlikely to hold one file open and then
 /// open/close `2**32 - 1` others.
+#[derive(Debug)]
 pub struct SearchIdGenerator {
     next_id: Wrapping<u32>,
 }

src/volume_mgr.rs

@@ -20,6 +20,7 @@ use heapless::Vec;
 
 /// A `VolumeManager` wraps a block device and gives access to the FAT-formatted
 /// volumes within it.
+#[derive(Debug)]
 pub struct VolumeManager<
     D,
     T,
@@ -242,6 +243,8 @@ where
             }
         };
 
+        debug!("Found dir entry: {:?}", dir_entry);
+
         if !dir_entry.attributes.is_directory() {
             return Err(Error::OpenedFileAsDir);
         }
@@ -482,7 +485,7 @@ where
 
         // Check if it's open already
         if let Some(dir_entry) = &dir_entry {
-            if self.file_is_open(volume_info.volume_id, &dir_entry) {
+            if self.file_is_open(volume_info.volume_id, dir_entry) {
                 return Err(Error::FileAlreadyOpen);
             }
         }