Better virtual file system, keyboard through MMIO&VirtIO

crates/bffs/src/dir.rs

@@ -1,11 +1,11 @@
 use crate::{
+    Fat32FileSystem, ReadSeek, ReadWriteSeek,
     entry::{DirEntry, DirectoryIterator},
     error::Error,
     file::{File, RawFile},
-    io::{self, IoBase, Read, Seek, Write},
     path::Path,
-    Fat32FileSystem, ReadSeek, ReadWriteSeek,
 };
+use io::{self, IoBase, Read, Seek, Write};
 
 pub struct Dir<'a, T> {
     raw: RawFile<'a, T>,
@@ -13,24 +13,24 @@ pub struct Dir<'a, T> {
 }
 
 impl<'a, T: IoBase> IoBase for Dir<'a, T> {
-    type Error = T::Error;
+    type Error = Error<T::Error>;
 }
 impl<'a, T: ReadSeek> Seek for Dir<'a, T> {
-    fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, Error<Self::Error>> {
+    fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, Self::Error> {
         self.raw.seek(pos)
     }
 }
 impl<'a, T: ReadSeek> Read for Dir<'a, T> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error<Self::Error>> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         self.raw.read(buf)
     }
 }
 impl<'a, T: ReadWriteSeek> Write for Dir<'a, T> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Error<Self::Error>> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         self.raw.write(buf)
     }
 
-    fn flush(&mut self) -> Result<(), Error<Self::Error>> {
+    fn flush(&mut self) -> Result<(), Self::Error> {
         self.raw.flush()
     }
 }
@@ -44,25 +44,28 @@ impl<'a, T> Dir<'a, T> {
     }
 }
 impl<'a, T: ReadSeek> Dir<'a, T> {
-    pub fn open_entry<P: AsRef<Path>>(
-        &self,
-        path: P,
-    ) -> Result<DirEntry<'a, T>, Error<T::Error>> {
+    pub fn open_entry<P: AsRef<Path>>(&self, path: P) -> Result<DirEntry<'a, T>, Error<T::Error>> {
         if path.as_ref().is_absolute() {
             return self.fs.open_entry(path);
         }
+        let (start, entryname) = path.as_ref().split_path();
         for file in self.iter() {
             let f = file?;
-            if f.name_is(path.as_ref().as_str()) {
-                return Ok(f);
+            if f.name_is(start) {
+                if let Some(entry_name) = entryname {
+                    if f.is_dir() {
+                        return f.to_dir().open_entry(entry_name);
+                    } else {
+                        return Err(Error::NotFound);
+                    }
+                } else {
+                    return Ok(f);
+                }
             }
         }
         Err(Error::NotFound)
     }
-    pub fn open_file<P: AsRef<Path>>(
-        &self,
-        path: P,
-    ) -> Result<File<'a, T>, Error<T::Error>> {
+    pub fn open_file<P: AsRef<Path>>(&self, path: P) -> Result<File<'a, T>, Error<T::Error>> {
         if path.as_ref().is_absolute() {
             return self.fs.open_file(path);
         }