mkdir support

Author: kahing

src/catfs/dir.rs

@@ -1,5 +1,7 @@
 extern crate libc;
 
+use std::fs;
+use std::io;
 use std::path::Path;
 
 use catfs::error;
@@ -71,4 +73,17 @@ impl Handle {
             }
         }
     }
+
+    pub fn mkdir(path: &AsRef<Path>, mode: u32) -> io::Result<()> {
+        rlibc::mkdir(path, mode)
+    }
+
+    pub fn rmdir(src_path: &AsRef<Path>, cache_path: &AsRef<Path>) -> io::Result<()> {
+        if let Err(e) = fs::remove_dir(cache_path) {
+            if !error::is_enoent(&e) {
+                return Err(e);
+            }
+        }
+        return fs::remove_dir(src_path);
+    }
 }

src/catfs/file.rs

@@ -130,15 +130,6 @@ impl Handle {
         return fs::remove_file(src_path);
     }
 
-    pub fn rmdir(src_path: &AsRef<Path>, cache_path: &AsRef<Path>) -> io::Result<()> {
-        if let Err(e) = fs::remove_dir(cache_path) {
-            if !error::is_enoent(&e) {
-                return Err(e);
-            }
-        }
-        return fs::remove_dir(src_path);
-    }
-
     fn is_pristine(cache_path: &AsRef<Path>) -> error::Result<bool> {
         if let Some(v) = xattr::get(cache_path, "user.catfs.pristine")? {
             return Ok(v == PRISTINE);

src/catfs/inode.rs

@@ -205,8 +205,25 @@ impl<'a> Inode<'a> {
         );
     }
 
+    pub fn mkdir(&self, name: &OsStr, mode: u32) -> error::Result<(Inode<'a>)> {
+        let path = self.get_child_name(name);
+        let src_path = self.to_src_path().join(name);
+        dir::Handle::mkdir(&src_path, mode)?;
+
+        let attr = Inode::lookup_path(&src_path)?;
+        let inode = Inode::new(
+            self.src_dir,
+            self.cache_dir,
+            name.to_os_string(),
+            path,
+            attr,
+        );
+
+        return Ok(inode);
+    }
+
     pub fn rmdir(&self, name: &OsStr) -> io::Result<()> {
-        return file::Handle::rmdir(
+        return dir::Handle::rmdir(
             &self.to_src_path().join(name),
             &self.to_cache_path().join(name),
         );

src/catfs/mod.rs

@@ -534,4 +534,30 @@ impl<'a> Filesystem for CatFS<'a> {
             self.remove_path(&parent_inode.get_path().join(name));
         }
     }
+
+    fn mkdir(&mut self, _req: &Request, parent: u64, name: &OsStr, mode: u32, reply: ReplyEntry) {
+        let parent_inode: Arc<Mutex<Inode<'a>>>;
+        {
+            let store = self.store.lock().unwrap();
+            parent_inode = store.get(parent);
+        }
+
+        let parent_inode = parent_inode.lock().unwrap();
+        match parent_inode.mkdir(name, mode) {
+            Ok(inode) => {
+                reply.entry(&self.ttl, inode.get_attr(), 0);
+                debug!("<-- mkdir {:?}/{:?}", parent_inode.get_path(), name);
+                self.insert_inode(inode);
+            }
+            Err(e) => {
+                debug!(
+                    "<-- !mkdir {:?}/{:?} = {}",
+                    parent_inode.get_path(),
+                    name,
+                    e
+                );
+                reply.error(e.raw_os_error().unwrap());
+            }
+        }
+    }
 }

src/catfs/rlibc.rs

@@ -122,6 +122,16 @@ pub fn readdir(dir: *mut libc::DIR) -> io::Result<Option<Dirent>> {
     }
 }
 
+pub fn mkdir(path: &AsRef<Path>, mode: u32) -> io::Result<()> {
+    let s = to_cstring(path);
+    let res = unsafe { libc::mkdir(s.as_ptr(), mode) };
+    if res < 0 {
+        return Err(io::Error::last_os_error());
+    } else {
+        return Ok(());
+    }
+}
+
 pub struct File {
     fd: libc::c_int,
 }

tests/integration_tests.rs

@@ -248,6 +248,11 @@ unit_tests!{
         diff(&f.get_from(), &f.mnt);
     }
 
+    fn mkdir(f: &CatFSTests) {
+        let foo = f.mnt.join("foo");
+        fs::create_dir(&foo).unwrap();
+    }
+
     fn rmdir(f: &CatFSTests) {
         let dir2 = f.mnt.join("dir2");
         fs::remove_dir(&dir2).unwrap();