Add dispatch task, plus a bunch more updates

This commit was originally a sequence of trial-and-error commits that
are a bit of a mess. Rather than include them, or trying to turn them
retroactively into a separate commit for each of the below, I'm just
squashing them into here.  The changes in a nutshell:

There are now tests that can run under src/test.  So far it just checks
that the hello world filesystem works.

I no longer start an OS thread for each FS operation.  There is one
thread for the C API, which passes all commands back to a "dispatch
task" running on the default scheduler, which in turn starts a new task
on the default scheduler for each command.

I don't try to turn byte strings I get from FUSE into utf-8.  I still
use std::path in the public API, and therefore could run into some
problems due to rust-lang/rust#7225 but that will be addressed here when
the underlying problem in std::path is taken care of.

The public API now consists of a FuseMount object whose existence is
tied to the mounting of a filesystem via FUSE.

There is a Makefile whose main purpose is to allow you to quickly run
the tests.  Once "rustpkg test" works, it may not be needed anymore.

Author: MicahChalmer

.gitignore

@@ -2,3 +2,4 @@ build/
 lib/
 bin/
 .rust
+.vagrant

Makefile

@@ -0,0 +1,12 @@
+.PHONY: install test
+
+install: bin/hello_fs
+
+test: bin/test
+	env RUST_LOG=test=4,rust_fuse=4 ./bin/test
+
+bin/hello_fs: $(shell git ls-files src/rust_fuse src/examples '*.rs')
+	rm .rust/*.json; rustpkg install examples/hello_fs
+
+bin/test: bin/hello_fs $(shell git ls-files src/test '*.rs')
+	rustc --test --out-dir bin src/test/test.rs

README.md

@@ -20,6 +20,7 @@ The modules:
   * `rust_fuse::ffi` - The actual C headers, translated to rust extern fns.  Not meant for direct use.
   * `rust_fuse::lowlevel` - This is a "thin" rust wrapper over the FUSE low level C API.  The goals:
     * Eliminate the need for a user of this library to use unsafe code.  That means converting all raw pointers to vectors, borrowed pointers, etc as appropriate.
+    * Pass only meaningful data to a user of this library.  The C API has many places where it will pass you a big struct, then tell you in its documentation that only certain fields are meaningful.  We change the data structures in those cases so that you the filesystem implementor gets only real information, not random garbage.
     * Use rust's task system to:
       * Run each filesystem request in its own task to allow them to run in parallel.
       * Guarantee that each "request" call receives an appropriate reply, without having to track it yourself.

src/examples/hello_fs/main.rs

@@ -0,0 +1,151 @@
+extern mod rust_fuse;
+
+use std::libc::{
+    S_IFDIR,
+    S_IFREG,
+    ENOENT,
+    EACCES,
+    O_RDONLY,
+    stat,
+    off_t,
+    size_t,
+    mode_t,
+    c_int
+};
+
+use std::cmp::{min, max};
+use rust_fuse::lowlevel::*;
+use std::os;
+use rust_fuse::stat::stat::arch::default_stat;
+use std::c_str::CString;
+use std::io::stderr;
+use std::default::Default;
+
+static HELLO_STR:&'static str = "Hello rusty world!\n";
+static HELLO_FILE_NAME:&'static str = "hello_from_rust";
+static INO_ROOT_DIR:fuse_ino_t = 1;
+static INO_HELLO_FILE:fuse_ino_t = 2;
+fn root_dir_stat() -> stat {
+    stat{
+        // 493: octal 755.  Rust lacks octal literals
+        st_mode: (S_IFDIR | 493) as mode_t,
+        st_nlink: 2,
+        .. default_stat()
+    }
+}
+fn hello_file_stat() -> stat {
+    stat{
+        // 292: octal 0444
+        st_mode: (S_IFREG | 292) as mode_t,
+        st_nlink: 1,
+        st_size: HELLO_STR.len() as off_t,
+        .. default_stat()
+    }
+}
+
+fn cstr_as_bytes_no_term<'a>(cs:&'a CString) -> &'a[u8] {
+    let ab = cs.as_bytes();
+    ab.slice_to(max(ab.len()-1,0))
+}
+
+fn main() {
+    if os::args().len() < 2 {
+        stderr().write_line("Must specify mount point");
+        os::set_exit_status(1);
+        return;
+    }
+    let ops = ~FuseLowLevelOps{
+
+        getattr: Some::<~fn(fuse_ino_t) -> ErrnoResult<AttrReply>>(
+            |ino: fuse_ino_t| {
+                let hello_stat = match(ino) {
+                    INO_ROOT_DIR => Some(root_dir_stat()),
+                    INO_HELLO_FILE => Some(hello_file_stat()),
+                    _ => None
+                };
+                match hello_stat {
+                    Some(st) => Ok(AttrReply{ attr: st,
+                                              attr_timeout: 1.0 }),
+                    None => Err(ENOENT)
+                }
+            }),
+
+        lookup: Some::<~fn(parent: fuse_ino_t, name: &CString)
+                             -> ErrnoResult<EntryReply>>(
+            |parent: fuse_ino_t, name:&CString| {
+                if parent != INO_ROOT_DIR || 
+                    cstr_as_bytes_no_term(name)
+                    != HELLO_FILE_NAME.as_bytes() {
+                    Err(ENOENT) 
+                } else { Ok(Struct_fuse_entry_param {
+                            ino: INO_HELLO_FILE,
+                            generation: 0,
+                            attr: hello_file_stat(),
+                            attr_timeout: 1.0,
+                            entry_timeout: 1.0
+                        })
+                }
+            }),
+
+        readdir: Some::<~fn(ino: fuse_ino_t, size: size_t, off: off_t,
+                              fh: u64) -> ErrnoResult<ReaddirReply>>(
+            |ino:fuse_ino_t, _size: size_t, off: off_t, _fh: u64| {
+                if ino != INO_ROOT_DIR {
+                    Err(ENOENT)
+                } else {
+                    let mut entries = ~[
+                        DirEntry{ino: INO_ROOT_DIR,
+                                 name: ".".to_c_str(), 
+                                 mode: root_dir_stat().st_mode,
+                                 next_offset: 1},
+                        DirEntry{ino: INO_ROOT_DIR,
+                                 name: "..".to_c_str(),
+                                 mode: root_dir_stat().st_mode,
+                                 next_offset: 2}, 
+                        DirEntry{ 
+                            ino: INO_HELLO_FILE, 
+                            name: HELLO_FILE_NAME.to_c_str(), 
+                            mode: hello_file_stat().st_mode, 
+                            next_offset: 3},
+                        ];
+                    let num_entries = entries.len();
+                    let start = min(num_entries, off as uint);
+                    entries.reverse();
+                    entries.truncate(num_entries - start);
+                    entries.reverse();
+                    Ok(DirEntries(entries))
+                }
+            }),
+
+        open: Some::<~fn(ino: fuse_ino_t, flags: c_int)
+                           -> ErrnoResult<OpenReply>>(
+            |ino: fuse_ino_t, flags: c_int| {
+                if ino != INO_HELLO_FILE {
+                    Err(ENOENT)
+                } else if flags & 3 != O_RDONLY {
+                    Err(EACCES)
+                } else {
+                    Ok(OpenReply{direct_io: false, keep_cache: false,
+                                 fh: 0})
+                }
+            }),
+
+        read: Some::<~fn(ino: fuse_ino_t, size: size_t, off: off_t,
+                           fh: u64) -> ErrnoResult<ReadReply>>(
+            |ino: fuse_ino_t, size: size_t, off: off_t, _fh: u64| {
+                if ino != INO_HELLO_FILE {
+                    Err(ENOENT)
+                } else {
+                    let slice_to_read = HELLO_STR.as_bytes().slice(
+                        off as uint, min(HELLO_STR.len(),size as uint));
+                    Ok(DataBuffer(slice_to_read.into_owned()))
+                }
+            }),
+
+        ..Default::default()
+    };
+    
+    let args_u8 = os::args().map(|s| s.as_bytes().into_owned());
+    FuseMount::new(~FuseMountOptions{args: args_u8, 
+                                     ..Default::default()}, ops).finish();
+}

src/hello_fs/main.rs

@@ -4,7 +4,7 @@ automatically generated by rust-bindgen, with some manual changes needed:
  *  * use a bindgen'd statvfs and statfs
  *  * add Struct_iovec
  *  * add stub Struct_flock
- *  * add derived Zero impl for Struct_fuse_file_info
+ *  * add derived Default impl for Struct_fuse_file_info
  *  * wrap the type of the function pointers in Option to allow them to be null
 */
 
@@ -47,7 +47,7 @@ pub struct Struct_fuse_args {
 }
 pub type fuse_opt_proc_t = *u8;
 
-#[deriving(Zero)]
+#[deriving(Default)]
 pub struct Struct_fuse_file_info {
     flags: c_int,
     fh_old: c_ulong,
@@ -118,7 +118,6 @@ pub struct Struct_fuse_forget_data {
     ino: uint64_t,
     nlookup: uint64_t,
 }
-#[packed]
 pub struct Struct_fuse_lowlevel_ops {
     init: Option<extern "C" fn(userdata:*mut c_void, 
                                _conn:*Struct_fuse_conn_info)>,

src/rust_fuse/ffi.rs

@@ -4,3 +4,4 @@
 
 pub mod lowlevel;
 pub mod ffi;
+pub mod stat;