Update FUSE

redox-os · Sep 26, 2017 · 541a581 · 541a581
1 parent 070aeb5
commit 541a581
Show file tree

Hide file tree

Showing 6 changed files with 47 additions and 45 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,6 +24,6 @@ spin = { git = "https://github.com/messense/spin-rs", rev = "020f1b3f" }
 redox_syscall = "0.1"
 
 [target.'cfg(unix)'.dependencies]
-fuse = "0.2"
+fuse = "0.3"
 libc = "0.2"
 time = "0.1"
diff --git a/src/bin/mount.rs b/src/bin/mount.rs
@@ -61,9 +61,16 @@ fn main() {
                         Ok(filesystem) => {
                             println!("redoxfs: opened filesystem {}", path);
 
-                            if let Some(mountpoint) = env::args_os().nth(2) {
-                                mount(filesystem, &mountpoint, write);
-                                process::exit(0);
+                            if let Some(mountpoint) = env::args().nth(2) {
+                                match mount(filesystem, &mountpoint, write) {
+                                    Ok(()) => {
+                                        process::exit(0);
+                                    },
+                                    Err(err) => {
+                                        println!("redoxfs: failed to mount {} to {}: {}", path, mountpoint, err);
+                                        process::exit(1);
+                                    }
+                                }
                             } else {
                                 println!("redoxfs: no mount point provided");
                                 usage();

diff --git a/src/mount/fuse.rs b/src/mount/fuse.rs
@@ -1,8 +1,9 @@
 extern crate fuse;
 extern crate time;
 
-use std::path::Path;
+use std::ffi::OsStr;
 use std::os::unix::ffi::OsStrExt;
+use std::path::Path;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use disk::Disk;
@@ -54,7 +55,7 @@ fn node_attr(node: &(u64, Node)) -> FileAttr {
 }
 
 impl<D: Disk> Filesystem for Fuse<D> {
-    fn lookup(&mut self, _req: &Request, parent_block: u64, name: &Path, reply: ReplyEntry) {
+    fn lookup(&mut self, _req: &Request, parent_block: u64, name: &OsStr, reply: ReplyEntry) {
         match self.fs.find_node(name.to_str().unwrap(), parent_block) {
             Ok(node) => {
                 reply.entry(&TTL, &node_attr(&node), 0);
@@ -235,7 +236,7 @@ impl<D: Disk> Filesystem for Fuse<D> {
         }
     }
 
-    fn create(&mut self, _req: &Request, parent_block: u64, name: &Path, mode: u32, flags: u32, reply: ReplyCreate) {
+    fn create(&mut self, _req: &Request, parent_block: u64, name: &OsStr, mode: u32, flags: u32, reply: ReplyCreate) {
         let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
         match self.fs.create_node(Node::MODE_FILE | (mode as u16 & Node::MODE_PERM), name.to_str().unwrap(), parent_block, ctime.as_secs(), ctime.subsec_nanos()) {
             Ok(node) => {
@@ -248,7 +249,7 @@ impl<D: Disk> Filesystem for Fuse<D> {
         }
     }
 
-    fn mkdir(&mut self, _req: &Request, parent_block: u64, name: &Path, mode: u32, reply: ReplyEntry) {
+    fn mkdir(&mut self, _req: &Request, parent_block: u64, name: &OsStr, mode: u32, reply: ReplyEntry) {
         let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
         match self.fs.create_node(Node::MODE_DIR | (mode as u16 & Node::MODE_PERM), name.to_str().unwrap(), parent_block, ctime.as_secs(), ctime.subsec_nanos()) {
             Ok(node) => {
@@ -261,7 +262,7 @@ impl<D: Disk> Filesystem for Fuse<D> {
         }
     }
 
-    fn rmdir(&mut self, _req: &Request, parent_block: u64, name: &Path, reply: ReplyEmpty) {
+    fn rmdir(&mut self, _req: &Request, parent_block: u64, name: &OsStr, reply: ReplyEmpty) {
         match self.fs.remove_node(Node::MODE_DIR, name.to_str().unwrap(), parent_block) {
             Ok(()) => {
                 reply.ok();
@@ -272,7 +273,7 @@ impl<D: Disk> Filesystem for Fuse<D> {
         }
     }
 
-    fn unlink(&mut self, _req: &Request, parent_block: u64, name: &Path, reply: ReplyEmpty) {
+    fn unlink(&mut self, _req: &Request, parent_block: u64, name: &OsStr, reply: ReplyEmpty) {
         match self.fs.remove_node(Node::MODE_FILE, name.to_str().unwrap(), parent_block) {
             Ok(()) => {
                 reply.ok();
@@ -298,7 +299,7 @@ impl<D: Disk> Filesystem for Fuse<D> {
         }
     }
 
-    fn symlink(&mut self, _req: &Request, parent_block: u64, name: &Path, link: &Path, reply: ReplyEntry) {
+    fn symlink(&mut self, _req: &Request, parent_block: u64, name: &OsStr, link: &Path, reply: ReplyEntry) {
         let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
         match self.fs.create_node(Node::MODE_SYMLINK | 0o777, name.to_str().unwrap(), parent_block, ctime.as_secs(), ctime.subsec_nanos()) {
             Ok(node) => {

diff --git a/src/mount/mod.rs b/src/mount/mod.rs
@@ -1,3 +1,4 @@
+use std::io;
 use std::fs::File;
 use std::path::Path;
 
@@ -11,7 +12,7 @@ mod fuse;
 mod redox;
 
 #[cfg(all(unix, target_os = "macos"))]
-pub fn mount<D: Disk, P: AsRef<Path>>(filesystem: FileSystem<D>, mountpoint: &P, mut write: File) {
+pub fn mount<D: Disk, P: AsRef<Path>>(filesystem: FileSystem<D>, mountpoint: &P, mut write: File) -> io::Result<()> {
     use std::ffi::OsStr;
     use std::io::Write;
 
@@ -27,22 +28,22 @@ pub fn mount<D: Disk, P: AsRef<Path>>(filesystem: FileSystem<D>, mountpoint: &P,
         // be `root`, thus that we need to allow `root` to have access.
         OsStr::new("-o"),
         OsStr::new("defer_permissions"),
-    ]);
+    ])
 }
 
 #[cfg(all(unix, not(target_os = "macos")))]
-pub fn mount<D: Disk, P: AsRef<Path>>(filesystem: FileSystem<D>, mountpoint: &P, mut write: File) {
+pub fn mount<D: Disk, P: AsRef<Path>>(filesystem: FileSystem<D>, mountpoint: &P, mut write: File) -> io::Result<()> {
     use std::io::Write;
 
     let _ = write.write(&[0]);
     drop(write);
 
     fuse::mount(fuse::Fuse {
         fs: filesystem
-    }, mountpoint, &[]);
+    }, mountpoint, &[])
 }
 
 #[cfg(target_os = "redox")]
-pub fn mount<D: Disk, P: AsRef<Path>>(filesystem: FileSystem<D>, mountpoint: &P, write: File) {
-    redox::mount(filesystem, mountpoint, write);
+pub fn mount<D: Disk, P: AsRef<Path>>(filesystem: FileSystem<D>, mountpoint: &P, write: File) -> io::Result<()> {
+    redox::mount(filesystem, mountpoint, write)
 }
diff --git a/src/mount/redox/mod.rs b/src/mount/redox/mod.rs
@@ -2,31 +2,30 @@ extern crate spin;
 
 use syscall::{Packet, Scheme};
 use std::fs::File;
-use std::io::{Read, Write};
+use std::io::{self, Read, Write};
 use std::path::Path;
 
 use self::scheme::FileScheme;
 
 pub mod resource;
 pub mod scheme;
 
-pub fn mount<P: AsRef<Path>>(filesystem: filesystem::FileSystem, mountpoint: &P, mut write: File) {
+pub fn mount<P: AsRef<Path>>(filesystem: filesystem::FileSystem, mountpoint: &P, mut write: File) -> io::Result<()> {
     let mountpoint = mountpoint.as_ref();
-    match File::create(format!(":{}", mountpoint.display())) {
-        Ok(mut socket) => {
-            println!("redoxfs: mounted filesystem on {}:", mountpoint.display());
-
-            let _ = write.write(&[0]);
-            drop(write);
-
-            let scheme = FileScheme::new(format!("{}", mountpoint.display()), filesystem);
-            loop {
-                let mut packet = Packet::default();
-                socket.read(&mut packet).unwrap();
-                scheme.handle(&mut packet);
-                socket.write(&packet).unwrap();
-            }
-        },
-        Err(err) => println!("redoxfs: failed to create {} scheme: {}", mountpoint.display(), err)
+    let mut socket = File::create(format!(":{}", mountpoint.display()))?;
+
+    println!("redoxfs: mounted filesystem on {}:", mountpoint.display());
+
+    let _ = write.write(&[0]);
+    drop(write);
+
+    let scheme = FileScheme::new(format!("{}", mountpoint.display()), filesystem);
+    loop {
+        let mut packet = Packet::default();
+        socket.read(&mut packet).unwrap();
+        scheme.handle(&mut packet);
+        socket.write(&packet).unwrap();
     }
+
+    Ok(())
 }