[VFS] Move victoria falls to rust. (Breaks voyageurs)

Move victoria falls to rust, which allows us to remove both the denali
and victoria falls C++ code. This disk driver appears to work properly
but has highlighted some instability in the voyageus xhci implementation
which now breaks.

rust/sys/victoriafalls/src/bin/victoriafalls.rs

@@ -1,9 +1,12 @@
 #![no_std]
 #![no_main]
 
-use denali_client::{DenaliClient, DiskReader};
 use ext2::Ext2Driver;
-use mammoth::{cap::Capability, define_entry, zion::z_err_t};
+use mammoth::{define_entry, zion::z_err_t};
+use victoriafalls::{server::VictoriaFallsServerImpl, VFSServer};
+use yellowstone_yunq::RegisterEndpointRequest;
+use yunq::server::spawn_server_thread;
+use yunq::server::YunqServer;
 
 define_entry!();
 
@@ -12,13 +15,21 @@ extern "C" fn main() -> z_err_t {
     let yellowstone = yellowstone_yunq::from_init_endpoint();
 
     let denali_info = yellowstone.get_denali().unwrap();
-    let client = DenaliClient::new(Capability::take(denali_info.denali_endpoint));
 
-    let driver = Ext2Driver::new(DiskReader::new(
-        client,
-        denali_info.device_id,
-        denali_info.lba_offset,
-    ));
+    let driver = Ext2Driver::new(denali_info);
+
+    let vfs_server = VFSServer::new(VictoriaFallsServerImpl::new(driver)).unwrap();
+
+    let yellowstone = yellowstone_yunq::from_init_endpoint();
+    yellowstone
+        .register_endpoint(&RegisterEndpointRequest {
+            endpoint_name: "victoriafalls".into(),
+            endpoint_capability: vfs_server.create_client_cap().unwrap().release(),
+        })
+        .unwrap();
+
+    let server_thread = spawn_server_thread(vfs_server);
+    server_thread.join().unwrap();
 
     0
 }

rust/sys/victoriafalls/src/lib.rs

@@ -6,6 +6,7 @@ include!(concat!(env!("OUT_DIR"), "/yunq.rs"));
 
 pub mod dir;
 pub mod file;
+pub mod server;
 
 static mut VFS_CLIENT: Option<VFSClient> = None;
 

rust/sys/victoriafalls/src/server.rs

@@ -0,0 +1,75 @@
+use alloc::{string::String, vec::Vec};
+use ext2::Ext2Driver;
+use mammoth::{debug, zion::ZError};
+
+use crate::{Directory, GetDirectoryRequest, OpenFileRequest, OpenFileResponse, VFSServerHandler};
+
+pub struct VictoriaFallsServerImpl {
+    ext2_driver: Ext2Driver,
+}
+
+impl VictoriaFallsServerImpl {
+    pub fn new(ext2_driver: Ext2Driver) -> Self {
+        VictoriaFallsServerImpl { ext2_driver }
+    }
+
+    fn find_path_in_dir(&mut self, inode_num: u32, file_name: &str) -> Result<u32, ZError> {
+        let files = self.ext2_driver.read_directory(inode_num)?;
+
+        files
+            .iter()
+            .find(|fi| fi.name == file_name)
+            .map(|fi| fi.inode)
+            .ok_or(ZError::NOT_FOUND)
+    }
+}
+
+impl VFSServerHandler for VictoriaFallsServerImpl {
+    fn open_file(&mut self, req: OpenFileRequest) -> Result<OpenFileResponse, ZError> {
+        debug!("Reading {}", req.path);
+        let mut tokens = req.path.split('/');
+        if tokens.next() != Some("") {
+            debug!("Path must be absolute");
+            return Err(ZError::INVALID_ARGUMENT);
+        }
+
+        let mut inode_num = 2; // Start with root.
+
+        while let Some(path_token) = tokens.next() {
+            inode_num = self.find_path_in_dir(inode_num, path_token)?;
+        }
+
+        let inode = self.ext2_driver.get_inode(inode_num);
+        Ok(OpenFileResponse {
+            path: req.path,
+            memory: self.ext2_driver.read_file(inode_num)?.release(),
+            size: inode.size as u64,
+        })
+    }
+
+    fn get_directory(&mut self, req: GetDirectoryRequest) -> Result<Directory, ZError> {
+        debug!("Reading dir {}", req.path);
+        let mut tokens = req.path.split('/');
+        if tokens.next() != Some("") {
+            debug!("Path must be absolute");
+            return Err(ZError::INVALID_ARGUMENT);
+        }
+
+        let mut inode_num = 2; // Start with root.
+
+        while let Some(path_token) = tokens.next() {
+            inode_num = self.find_path_in_dir(inode_num, path_token)?;
+        }
+
+        let files: Vec<String> = self
+            .ext2_driver
+            .read_directory(inode_num)?
+            .into_iter()
+            .map(|fi| fi.name)
+            .collect();
+
+        Ok(Directory {
+            filenames: files.join(","),
+        })
+    }
+}