auto merge of #9235 : olsonjeffery/rust/newrt_file_io_1, r=thestinger

A quick rundown:

- added `file::{readdir, stat, mkdir, rmdir}`
- Added access-constrained versions of `FileStream`; `FileReader` and `FileWriter` respectively
- big rework in `uv::file` .. most actions are by-val-self methods on `FsRequest`; `FileDescriptor` has gone the way of the dinosaurs
- playing nice w/ homing IO (I just copied ecr's work, hehe), etc
- added `FileInfo` trait, with an impl for `Path`
  - wrapper for file-specific actions, with the file path always implied by self's value
  - has the means to create `FileReader` & `FileWriter` (this isn't exposed in the top-level free function API)
  - has "safe" wrappers for `stat()` that won't throw in the event of non-existence/error (in this case, I mean `is_file` and `exists`)
  - actions should fail if done on non-regular-files, as appropriate
- added `DirectoryInfo` trait, with an impl for `Path`
  - pretty much ditto above, but for directories
  - added `readdir` (!!) to iterate over entries in a dir as a `~[Path]` (this was *brutal* to get working)

...<del>and lots of other stuff</del>not really. Do your worst!

3 files changed, 632 insertions, 198 deletions

diff --git a/src/libstd/rt/uv/file.rs b/src/libstd/rt/uv/file.rs
index e87e2d4b1e4..ada558036cf 100644
--- a/src/libstd/rt/uv/file.rs
+++ b/src/libstd/rt/uv/file.rs
@@ -17,6 +17,7 @@ use rt::uv::uvll;
 use rt::uv::uvll::*;
 use super::super::io::support::PathLike;
 use cast::transmute;
+use libc;
 use libc::{c_int};
 use option::{None, Some, Option};
 
@@ -24,77 +25,230 @@ pub struct FsRequest(*uvll::uv_fs_t);
 impl Request for FsRequest;
 
 pub struct RequestData {
-    complete_cb: Option<FsCallback>,
-    raw_fd: Option<c_int>
+    complete_cb: Option<FsCallback>
 }
 
 impl FsRequest {
-    pub fn new(cb: Option<FsCallback>) -> FsRequest {
+    pub fn new() -> FsRequest {
         let fs_req = unsafe { malloc_req(UV_FS) };
         assert!(fs_req.is_not_null());
         let fs_req: FsRequest = NativeHandle::from_native_handle(fs_req);
-        fs_req.install_req_data(cb);
         fs_req
     }
 
-    fn open_common<P: PathLike>(loop_: &Loop, path: &P, flags: int, mode: int,
-               cb: Option<FsCallback>) -> int {
-        let complete_cb_ptr = match cb {
-            Some(_) => compl_cb as *u8,
-            None => 0 as *u8
+    pub fn open<P: PathLike>(self, loop_: &Loop, path: &P, flags: int, mode: int,
+               cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
         };
-        let is_sync = cb.is_none();
-        let req = FsRequest::new(cb);
-        let result = path.path_as_str(|p| {
+        path.path_as_str(|p| {
             p.to_c_str().with_ref(|p| unsafe {
             uvll::fs_open(loop_.native_handle(),
-                          req.native_handle(), p, flags, mode, complete_cb_ptr) as int
+                          self.native_handle(), p, flags, mode, complete_cb_ptr)
             })
         });
-        if is_sync { req.cleanup_and_delete(); }
-        result
     }
-    pub fn open<P: PathLike>(loop_: &Loop, path: &P, flags: int, mode: int,
-               cb: FsCallback) {
-        FsRequest::open_common(loop_, path, flags, mode, Some(cb));
+
+    pub fn open_sync<P: PathLike>(self, loop_: &Loop, path: &P,
+                                  flags: int, mode: int) -> Result<c_int, UvError> {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(None)
+        };
+        let result = path.path_as_str(|p| {
+            p.to_c_str().with_ref(|p| unsafe {
+            uvll::fs_open(loop_.native_handle(),
+                    self.native_handle(), p, flags, mode, complete_cb_ptr)
+            })
+        });
+        self.sync_cleanup(result)
     }
 
-    pub fn open_sync<P: PathLike>(loop_: &Loop, path: &P, flags: int, mode: int)
-          -> Result<int, UvError> {
-        let result = FsRequest::open_common(loop_, path, flags, mode, None);
-        sync_cleanup(result)
+    pub fn unlink<P: PathLike>(self, loop_: &Loop, path: &P, cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
+        };
+        path.path_as_str(|p| {
+            p.to_c_str().with_ref(|p| unsafe {
+                uvll::fs_unlink(loop_.native_handle(),
+                              self.native_handle(), p, complete_cb_ptr)
+            })
+        });
     }
 
-    fn unlink_common<P: PathLike>(loop_: &Loop, path: &P, cb: Option<FsCallback>) -> int {
-        let complete_cb_ptr = match cb {
-            Some(_) => compl_cb as *u8,
-            None => 0 as *u8
+    pub fn unlink_sync<P: PathLike>(self, loop_: &Loop, path: &P)
+      -> Result<c_int, UvError> {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(None)
         };
-        let is_sync = cb.is_none();
-        let req = FsRequest::new(cb);
         let result = path.path_as_str(|p| {
             p.to_c_str().with_ref(|p| unsafe {
                 uvll::fs_unlink(loop_.native_handle(),
-                              req.native_handle(), p, complete_cb_ptr) as int
+                              self.native_handle(), p, complete_cb_ptr)
             })
         });
-        if is_sync { req.cleanup_and_delete(); }
-        result
+        self.sync_cleanup(result)
+    }
+
+    pub fn stat<P: PathLike>(self, loop_: &Loop, path: &P, cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
+        };
+        path.path_as_str(|p| {
+            p.to_c_str().with_ref(|p| unsafe {
+                uvll::fs_stat(loop_.native_handle(),
+                              self.native_handle(), p, complete_cb_ptr)
+            })
+        });
+    }
+
+    pub fn write(self, loop_: &Loop, fd: c_int, buf: Buf, offset: i64, cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
+        };
+        let base_ptr = buf.base as *c_void;
+        let len = buf.len as uint;
+        unsafe {
+            uvll::fs_write(loop_.native_handle(), self.native_handle(),
+                           fd, base_ptr,
+                           len, offset, complete_cb_ptr)
+        };
     }
-    pub fn unlink<P: PathLike>(loop_: &Loop, path: &P, cb: FsCallback) {
-        let result = FsRequest::unlink_common(loop_, path, Some(cb));
-        sync_cleanup(result);
+    pub fn write_sync(self, loop_: &Loop, fd: c_int, buf: Buf, offset: i64)
+          -> Result<c_int, UvError> {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(None)
+        };
+        let base_ptr = buf.base as *c_void;
+        let len = buf.len as uint;
+        let result = unsafe {
+            uvll::fs_write(loop_.native_handle(), self.native_handle(),
+                           fd, base_ptr,
+                           len, offset, complete_cb_ptr)
+        };
+        self.sync_cleanup(result)
+    }
+
+    pub fn read(self, loop_: &Loop, fd: c_int, buf: Buf, offset: i64, cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
+        };
+        let buf_ptr = buf.base as *c_void;
+        let len = buf.len as uint;
+        unsafe {
+            uvll::fs_read(loop_.native_handle(), self.native_handle(),
+                           fd, buf_ptr,
+                           len, offset, complete_cb_ptr)
+        };
     }
-    pub fn unlink_sync<P: PathLike>(loop_: &Loop, path: &P) -> Result<int, UvError> {
-        let result = FsRequest::unlink_common(loop_, path, None);
-        sync_cleanup(result)
+    pub fn read_sync(self, loop_: &Loop, fd: c_int, buf: Buf, offset: i64)
+          -> Result<c_int, UvError> {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(None)
+        };
+        let buf_ptr = buf.base as *c_void;
+        let len = buf.len as uint;
+        let result = unsafe {
+            uvll::fs_read(loop_.native_handle(), self.native_handle(),
+                           fd, buf_ptr,
+                           len, offset, complete_cb_ptr)
+        };
+        self.sync_cleanup(result)
     }
 
-    pub fn install_req_data(&self, cb: Option<FsCallback>) {
+    pub fn close(self, loop_: &Loop, fd: c_int, cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
+        };
+        unsafe {
+            uvll::fs_close(loop_.native_handle(), self.native_handle(),
+                           fd, complete_cb_ptr)
+        };
+    }
+    pub fn close_sync(self, loop_: &Loop, fd: c_int) -> Result<c_int, UvError> {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(None)
+        };
+        let result = unsafe {
+            uvll::fs_close(loop_.native_handle(), self.native_handle(),
+                           fd, complete_cb_ptr)
+        };
+        self.sync_cleanup(result)
+    }
+
+    pub fn mkdir<P: PathLike>(self, loop_: &Loop, path: &P, mode: int, cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
+        };
+        path.path_as_str(|p| {
+            p.to_c_str().with_ref(|p| unsafe {
+            uvll::fs_mkdir(loop_.native_handle(),
+                          self.native_handle(), p, mode, complete_cb_ptr)
+            })
+        });
+    }
+
+    pub fn rmdir<P: PathLike>(self, loop_: &Loop, path: &P, cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
+        };
+        path.path_as_str(|p| {
+            p.to_c_str().with_ref(|p| unsafe {
+            uvll::fs_rmdir(loop_.native_handle(),
+                          self.native_handle(), p, complete_cb_ptr)
+            })
+        });
+    }
+
+    pub fn readdir<P: PathLike>(self, loop_: &Loop, path: &P,
+                                flags: c_int, cb: FsCallback) {
+        let complete_cb_ptr = {
+            let mut me = self;
+            me.req_boilerplate(Some(cb))
+        };
+        path.path_as_str(|p| {
+            p.to_c_str().with_ref(|p| unsafe {
+            uvll::fs_readdir(loop_.native_handle(),
+                          self.native_handle(), p, flags, complete_cb_ptr)
+            })
+        });
+    }
+
+    // accessors/utility funcs
+    fn sync_cleanup(self, result: c_int)
+          -> Result<c_int, UvError> {
+        self.cleanup_and_delete();
+        match status_to_maybe_uv_error(result as i32) {
+            Some(err) => Err(err),
+            None => Ok(result)
+        }
+    }
+    fn req_boilerplate(&mut self, cb: Option<FsCallback>) -> *u8 {
+        let result = match cb {
+            Some(_) => {
+                compl_cb as *u8
+            },
+            None => 0 as *u8
+        };
+        self.install_req_data(cb);
+        result
+    }
+    pub fn install_req_data(&mut self, cb: Option<FsCallback>) {
         let fs_req = (self.native_handle()) as *uvll::uv_write_t;
         let data = ~RequestData {
-            complete_cb: cb,
-            raw_fd: None
+            complete_cb: cb
         };
         unsafe {
             let data = transmute::<~RequestData, *c_void>(data);
@@ -106,7 +260,7 @@ impl FsRequest {
         unsafe {
             let data = uvll::get_data_for_req((self.native_handle()));
             let data = transmute::<&*c_void, &mut ~RequestData>(&data);
-            return &mut **data;
+            &mut **data
         }
     }
 
@@ -120,6 +274,42 @@ impl FsRequest {
         unsafe { Loop{handle:uvll::get_loop_from_fs_req(self.native_handle())} }
     }
 
+    pub fn get_stat(&self) -> uv_stat_t {
+        let stat = uv_stat_t::new();
+        unsafe { uvll::populate_stat(self.native_handle(), &stat); }
+        stat
+    }
+
+    pub fn get_ptr(&self) -> *libc::c_void {
+        unsafe {
+            uvll::get_ptr_from_fs_req(self.native_handle())
+        }
+    }
+
+    pub fn get_paths(&mut self) -> ~[~str] {
+        use str;
+        let ptr = self.get_ptr();
+        match self.get_result() {
+            n if (n <= 0) => {
+                ~[]
+            },
+            n => {
+                let n_len = n as uint;
+                // we pass in the len that uv tells us is there
+                // for the entries and we don't continue past that..
+                // it appears that sometimes the multistring isn't
+                // correctly delimited and we stray into garbage memory?
+                // in any case, passing Some(n_len) fixes it and ensures
+                // good results
+                let raw_path_strs = unsafe {
+                    str::raw::from_c_multistring(ptr as *libc::c_char, Some(n_len)) };
+                let raw_len = raw_path_strs.len();
+                assert_eq!(raw_len, n_len);
+                raw_path_strs
+            }
+        }
+    }
+
     fn cleanup_and_delete(self) {
         unsafe {
             let data = uvll::get_data_for_req(self.native_handle());
@@ -148,97 +338,6 @@ fn sync_cleanup(result: int)
     }
 }
 
-pub struct FileDescriptor(c_int);
-
-impl FileDescriptor {
-    fn new(fd: c_int) -> FileDescriptor {
-        FileDescriptor(fd)
-    }
-
-
-    pub fn from_open_req(req: &mut FsRequest) -> FileDescriptor {
-        FileDescriptor::new(req.get_result())
-    }
-
-    // as per bnoordhuis in #libuv: offset >= 0 uses prwrite instead of write
-    fn write_common(&mut self, loop_: &Loop, buf: Buf, offset: i64, cb: Option<FsCallback>)
-          -> int {
-        let complete_cb_ptr = match cb {
-            Some(_) => compl_cb as *u8,
-            None => 0 as *u8
-        };
-        let is_sync = cb.is_none();
-        let mut req = FsRequest::new(cb);
-        let base_ptr = buf.base as *c_void;
-        let len = buf.len as uint;
-        req.get_req_data().raw_fd = Some(self.native_handle());
-        let result = unsafe {
-            uvll::fs_write(loop_.native_handle(), req.native_handle(),
-                           self.native_handle(), base_ptr,
-                           len, offset, complete_cb_ptr) as int
-        };
-        if is_sync { req.cleanup_and_delete(); }
-        result
-    }
-    pub fn write(&mut self, loop_: &Loop, buf: Buf, offset: i64, cb: FsCallback) {
-        self.write_common(loop_, buf, offset, Some(cb));
-    }
-    pub fn write_sync(&mut self, loop_: &Loop, buf: Buf, offset: i64)
-          -> Result<int, UvError> {
-        let result = self.write_common(loop_, buf, offset, None);
-        sync_cleanup(result)
-    }
-
-    fn read_common(&mut self, loop_: &Loop, buf: Buf,
-                   offset: i64, cb: Option<FsCallback>)
-          -> int {
-        let complete_cb_ptr = match cb {
-            Some(_) => compl_cb as *u8,
-            None => 0 as *u8
-        };
-        let is_sync = cb.is_none();
-        let mut req = FsRequest::new(cb);
-        req.get_req_data().raw_fd = Some(self.native_handle());
-        let buf_ptr = buf.base as *c_void;
-        let result = unsafe {
-            uvll::fs_read(loop_.native_handle(), req.native_handle(),
-                           self.native_handle(), buf_ptr,
-                           buf.len as uint, offset, complete_cb_ptr) as int
-        };
-        if is_sync { req.cleanup_and_delete(); }
-        result
-    }
-    pub fn read(&mut self, loop_: &Loop, buf: Buf, offset: i64, cb: FsCallback) {
-        self.read_common(loop_, buf, offset, Some(cb));
-    }
-    pub fn read_sync(&mut self, loop_: &Loop, buf: Buf, offset: i64)
-          -> Result<int, UvError> {
-        let result = self.read_common(loop_, buf, offset, None);
-        sync_cleanup(result)
-    }
-
-    fn close_common(self, loop_: &Loop, cb: Option<FsCallback>) -> int {
-        let complete_cb_ptr = match cb {
-            Some(_) => compl_cb as *u8,
-            None => 0 as *u8
-        };
-        let is_sync = cb.is_none();
-        let req = FsRequest::new(cb);
-        let result = unsafe {
-            uvll::fs_close(loop_.native_handle(), req.native_handle(),
-                           self.native_handle(), complete_cb_ptr) as int
-        };
-        if is_sync { req.cleanup_and_delete(); }
-        result
-    }
-    pub fn close(self, loop_: &Loop, cb: FsCallback) {
-        self.close_common(loop_, Some(cb));
-    }
-    pub fn close_sync(self, loop_: &Loop) -> Result<int, UvError> {
-        let result = self.close_common(loop_, None);
-        sync_cleanup(result)
-    }
-}
 extern fn compl_cb(req: *uv_fs_t) {
     let mut req: FsRequest = NativeHandle::from_native_handle(req);
     // pull the user cb out of the req data
@@ -261,15 +360,7 @@ extern fn compl_cb(req: *uv_fs_t) {
     req.cleanup_and_delete();
 }
 
-impl NativeHandle<c_int> for FileDescriptor {
-    fn from_native_handle(handle: c_int) -> FileDescriptor {
-        FileDescriptor(handle)
-    }
-    fn native_handle(&self) -> c_int {
-        match self { &FileDescriptor(ptr) => ptr }
-    }
-}
-
+#[cfg(test)]
 mod test {
     use super::*;
     //use rt::test::*;
@@ -279,11 +370,11 @@ mod test {
     use unstable::run_in_bare_thread;
     use path::Path;
     use rt::uv::{Loop, Buf, slice_to_uv_buf};
-    use libc::{O_CREAT, O_RDWR, O_RDONLY,
-               S_IWUSR, S_IRUSR}; //NOTE: need defs for S_**GRP|S_**OTH in libc:: ...
-               //S_IRGRP, S_IROTH};
+    use libc::{c_int, O_CREAT, O_RDWR, O_RDONLY,
+               S_IWUSR, S_IRUSR};
 
-    fn file_test_full_simple_impl() {
+    #[test]
+    fn file_test_full_simple() {
         do run_in_bare_thread {
             let mut loop_ = Loop::new();
             let create_flags = O_RDWR | O_CREAT;
@@ -302,25 +393,27 @@ mod test {
             let read_buf = slice_to_uv_buf(read_mem);
             let read_buf_ptr: *Buf = &read_buf;
             let p = Path(path_str);
-            do FsRequest::open(&loop_, &p, create_flags as int, mode as int)
+            let open_req = FsRequest::new();
+            do open_req.open(&loop_, &p, create_flags as int, mode as int)
             |req, uverr| {
                 assert!(uverr.is_none());
-                let mut fd = FileDescriptor::from_open_req(req);
-                let raw_fd = fd.native_handle();
+                let fd = req.get_result();
                 let buf = unsafe { *write_buf_ptr };
-                do fd.write(&req.get_loop(), buf, -1) |req, uverr| {
-                    let fd = FileDescriptor(raw_fd);
-                    do fd.close(&req.get_loop()) |req, _| {
-                        let loop_ = req.get_loop();
+                let write_req = FsRequest::new();
+                do write_req.write(&req.get_loop(), fd, buf, -1) |req, uverr| {
+                    let close_req = FsRequest::new();
+                    do close_req.close(&req.get_loop(), fd) |req, _| {
                         assert!(uverr.is_none());
-                        do FsRequest::open(&loop_, &Path(path_str), read_flags as int,0)
+                        let loop_ = req.get_loop();
+                        let open_req = FsRequest::new();
+                        do open_req.open(&loop_, &Path(path_str), read_flags as int,0)
                             |req, uverr| {
                             assert!(uverr.is_none());
                             let loop_ = req.get_loop();
-                            let mut fd = FileDescriptor::from_open_req(req);
-                            let raw_fd = fd.native_handle();
+                            let fd = req.get_result();
                             let read_buf = unsafe { *read_buf_ptr };
-                            do fd.read(&loop_, read_buf, 0) |req, uverr| {
+                            let read_req = FsRequest::new();
+                            do read_req.read(&loop_, fd, read_buf, 0) |req, uverr| {
                                 assert!(uverr.is_none());
                                 let loop_ = req.get_loop();
                                 // we know nread >=0 because uverr is none..
@@ -334,15 +427,17 @@ mod test {
                                                 read_buf.base, nread))
                                     };
                                     assert!(read_str == ~"hello");
-                                    do FileDescriptor(raw_fd).close(&loop_) |req,uverr| {
+                                    let close_req = FsRequest::new();
+                                    do close_req.close(&loop_, fd) |req,uverr| {
                                         assert!(uverr.is_none());
                                         let loop_ = &req.get_loop();
-                                        do FsRequest::unlink(loop_, &Path(path_str))
+                                        let unlink_req = FsRequest::new();
+                                        do unlink_req.unlink(loop_, &Path(path_str))
                                         |_,uverr| {
                                             assert!(uverr.is_none());
                                         };
                                     };
-                                }
+                                };
                             };
                         };
                     };
@@ -352,7 +447,9 @@ mod test {
             loop_.close();
         }
     }
-    fn file_test_full_simple_impl_sync() {
+
+    #[test]
+    fn file_test_full_simple_sync() {
         do run_in_bare_thread {
             // setup
             let mut loop_ = Loop::new();
@@ -368,26 +465,31 @@ mod test {
             let write_val = "hello".as_bytes().to_owned();
             let write_buf = slice_to_uv_buf(write_val);
             // open/create
-            let result = FsRequest::open_sync(&loop_, &Path(path_str),
+            let open_req = FsRequest::new();
+            let result = open_req.open_sync(&loop_, &Path(path_str),
                                                    create_flags as int, mode as int);
             assert!(result.is_ok());
-            let mut fd = FileDescriptor(result.unwrap() as i32);
+            let fd = result.unwrap();
             // write
-            let result = fd.write_sync(&loop_, write_buf, -1);
+            let write_req = FsRequest::new();
+            let result = write_req.write_sync(&loop_, fd, write_buf, -1);
             assert!(result.is_ok());
             // close
-            let result = fd.close_sync(&loop_);
+            let close_req = FsRequest::new();
+            let result = close_req.close_sync(&loop_, fd);
             assert!(result.is_ok());
             // re-open
-            let result = FsRequest::open_sync(&loop_, &Path(path_str),
+            let open_req = FsRequest::new();
+            let result = open_req.open_sync(&loop_, &Path(path_str),
                                                    read_flags as int,0);
             assert!(result.is_ok());
             let len = 1028;
-            let mut fd = FileDescriptor(result.unwrap() as i32);
+            let fd = result.unwrap();
             // read
             let read_mem: ~[u8] = vec::from_elem(len, 0u8);
             let buf = slice_to_uv_buf(read_mem);
-            let result = fd.read_sync(&loop_, buf, 0);
+            let read_req = FsRequest::new();
+            let result = read_req.read_sync(&loop_, fd, buf, 0);
             assert!(result.is_ok());
             let nread = result.unwrap();
             // nread == 0 would be EOF.. we know it's >= zero because otherwise
@@ -397,31 +499,23 @@ mod test {
                     read_mem.slice(0, nread as uint));
                 assert!(read_str == ~"hello");
                 // close
-                let result = fd.close_sync(&loop_);
+                let close_req = FsRequest::new();
+                let result = close_req.close_sync(&loop_, fd);
                 assert!(result.is_ok());
                 // unlink
-                let result = FsRequest::unlink_sync(&loop_, &Path(path_str));
+                let unlink_req = FsRequest::new();
+                let result = unlink_req.unlink_sync(&loop_, &Path(path_str));
                 assert!(result.is_ok());
             } else { fail!("nread was 0.. wudn't expectin' that."); }
             loop_.close();
         }
     }
 
-    #[test]
-    fn file_test_full_simple() {
-        file_test_full_simple_impl();
-    }
-
-    #[test]
-    fn file_test_full_simple_sync() {
-        file_test_full_simple_impl_sync();
-    }
-
     fn naive_print(loop_: &Loop, input: &str) {
-        let mut stdout = FileDescriptor(STDOUT_FILENO);
         let write_val = input.as_bytes();
         let write_buf = slice_to_uv_buf(write_val);
-        stdout.write_sync(loop_, write_buf, -1);
+        let write_req = FsRequest::new();
+        write_req.write_sync(loop_, STDOUT_FILENO, write_buf, -1);
     }
 
     #[test]
@@ -433,4 +527,130 @@ mod test {
             loop_.close();
         };
     }
+    #[test]
+    fn file_test_stat_simple() {
+        do run_in_bare_thread {
+            let mut loop_ = Loop::new();
+            let path = "./tmp/file_test_stat_simple.txt";
+            let create_flags = O_RDWR |
+                O_CREAT;
+            let mode = S_IWUSR |
+                S_IRUSR;
+            let write_val = "hello".as_bytes().to_owned();
+            let write_buf  = slice_to_uv_buf(write_val);
+            let write_buf_ptr: *Buf = &write_buf;
+            let open_req = FsRequest::new();
+            do open_req.open(&loop_, &path, create_flags as int, mode as int)
+            |req, uverr| {
+                assert!(uverr.is_none());
+                let fd = req.get_result();
+                let buf = unsafe { *write_buf_ptr };
+                let write_req = FsRequest::new();
+                do write_req.write(&req.get_loop(), fd, buf, 0) |req, uverr| {
+                    assert!(uverr.is_none());
+                    let loop_ = req.get_loop();
+                    let stat_req = FsRequest::new();
+                    do stat_req.stat(&loop_, &path) |req, uverr| {
+                        assert!(uverr.is_none());
+                        let loop_ = req.get_loop();
+                        let stat = req.get_stat();
+                        let sz: uint = stat.st_size as uint;
+                        assert!(sz > 0);
+                        let close_req = FsRequest::new();
+                        do close_req.close(&loop_, fd) |req, uverr| {
+                            assert!(uverr.is_none());
+                            let loop_ = req.get_loop();
+                            let unlink_req = FsRequest::new();
+                            do unlink_req.unlink(&loop_, &path) |req,uverr| {
+                                assert!(uverr.is_none());
+                                let loop_ = req.get_loop();
+                                let stat_req = FsRequest::new();
+                                do stat_req.stat(&loop_, &path) |_, uverr| {
+                                    // should cause an error because the
+                                    // file doesn't exist anymore
+                                    assert!(uverr.is_some());
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            loop_.run();
+            loop_.close();
+        }
+    }
+
+    #[test]
+    fn file_test_mk_rm_dir() {
+        do run_in_bare_thread {
+            let mut loop_ = Loop::new();
+            let path = "./tmp/mk_rm_dir";
+            let mode = S_IWUSR |
+                S_IRUSR;
+            let mkdir_req = FsRequest::new();
+            do mkdir_req.mkdir(&loop_, &path, mode as int) |req,uverr| {
+                assert!(uverr.is_none());
+                let loop_ = req.get_loop();
+                let stat_req = FsRequest::new();
+                do stat_req.stat(&loop_, &path) |req, uverr| {
+                    assert!(uverr.is_none());
+                    let loop_ = req.get_loop();
+                    let stat = req.get_stat();
+                    naive_print(&loop_, fmt!("%?", stat));
+                    assert!(stat.is_dir());
+                    let rmdir_req = FsRequest::new();
+                    do rmdir_req.rmdir(&loop_, &path) |req,uverr| {
+                        assert!(uverr.is_none());
+                        let loop_ = req.get_loop();
+                        let stat_req = FsRequest::new();
+                        do stat_req.stat(&loop_, &path) |req, uverr| {
+                            assert!(uverr.is_some());
+                        }
+                    }
+                }
+            }
+            loop_.run();
+            loop_.close();
+        }
+    }
+    #[test]
+    fn file_test_mkdir_chokes_on_double_create() {
+        do run_in_bare_thread {
+            let mut loop_ = Loop::new();
+            let path = "./tmp/double_create_dir";
+            let mode = S_IWUSR |
+                S_IRUSR;
+            let mkdir_req = FsRequest::new();
+            do mkdir_req.mkdir(&loop_, &path, mode as int) |req,uverr| {
+                assert!(uverr.is_none());
+                let loop_ = req.get_loop();
+                let mkdir_req = FsRequest::new();
+                do mkdir_req.mkdir(&loop_, &path, mode as int) |req,uverr| {
+                    assert!(uverr.is_some());
+                    let loop_ = req.get_loop();
+                    let stat = req.get_stat();
+                    let rmdir_req = FsRequest::new();
+                    do rmdir_req.rmdir(&loop_, &path) |req,uverr| {
+                        assert!(uverr.is_none());
+                        let loop_ = req.get_loop();
+                    }
+                }
+            }
+            loop_.run();
+            loop_.close();
+        }
+    }
+    #[test]
+    fn file_test_rmdir_chokes_on_nonexistant_path() {
+        do run_in_bare_thread {
+            let mut loop_ = Loop::new();
+            let path = "./tmp/never_existed_dir";
+            let rmdir_req = FsRequest::new();
+            do rmdir_req.rmdir(&loop_, &path) |req,uverr| {
+                assert!(uverr.is_some());
+            }
+            loop_.run();
+            loop_.close();
+        }
+    }
 }
diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index 8c827430f25..76dcf6daae6 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -32,11 +32,13 @@ use rt::uv::idle::IdleWatcher;
 use rt::uv::net::{UvIpv4SocketAddr, UvIpv6SocketAddr, accum_sockaddrs};
 use rt::uv::addrinfo::GetAddrInfoRequest;
 use unstable::sync::Exclusive;
+use path::Path;
 use super::super::io::support::PathLike;
 use libc::{lseek, off_t, O_CREAT, O_APPEND, O_TRUNC, O_RDWR, O_RDONLY, O_WRONLY,
-          S_IRUSR, S_IWUSR};
+          S_IRUSR, S_IWUSR, S_IRWXU};
 use rt::io::{FileMode, FileAccess, OpenOrCreate, Open, Create,
-            CreateOrTruncate, Append, Truncate, Read, Write, ReadWrite};
+             CreateOrTruncate, Append, Truncate, Read, Write, ReadWrite,
+             FileStat};
 use task;
 
 #[cfg(test)] use container::Container;
@@ -407,6 +409,36 @@ impl UvIoFactory {
     }
 }
 
+/// Helper for a variety of simple uv_fs_* functions that
+/// have no ret val
+fn uv_fs_helper<P: PathLike>(loop_: &mut Loop, path: &P,
+                             cb: ~fn(&mut FsRequest, &mut Loop, &P,
+                                     ~fn(&FsRequest, Option<UvError>)))
+        -> Result<(), IoError> {
+    let result_cell = Cell::new_empty();
+    let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
+    let path_cell = Cell::new(path);
+    do task::unkillable { // FIXME(#8674)
+        let scheduler: ~Scheduler = Local::take();
+        let mut new_req = FsRequest::new();
+        do scheduler.deschedule_running_task_and_then |_, task| {
+            let task_cell = Cell::new(task);
+            let path = path_cell.take();
+            do cb(&mut new_req, loop_, path) |_, err| {
+                let res = match err {
+                    None => Ok(()),
+                    Some(err) => Err(uv_error_to_io_error(err))
+                };
+                unsafe { (*result_cell_ptr).put_back(res); }
+                let scheduler: ~Scheduler = Local::take();
+                scheduler.resume_blocked_task_immediately(task_cell.take());
+            };
+        }
+    }
+    assert!(!result_cell.is_empty());
+    return result_cell.take();
+}
+
 impl IoFactory for UvIoFactory {
     // Connect to an address and return a new stream
     // NB: This blocks the task waiting on the connection.
@@ -512,7 +544,6 @@ impl IoFactory for UvIoFactory {
 
     fn fs_from_raw_fd(&mut self, fd: c_int, close_on_drop: bool) -> ~RtioFileStream {
         let loop_ = Loop {handle: self.uv_loop().native_handle()};
-        let fd = file::FileDescriptor(fd);
         let home = get_handle_to_current_scheduler!();
         ~UvFileStream::new(loop_, fd, close_on_drop, home) as ~RtioFileStream
     }
@@ -543,15 +574,16 @@ impl IoFactory for UvIoFactory {
         let path_cell = Cell::new(path);
         do task::unkillable { // FIXME(#8674)
             let scheduler: ~Scheduler = Local::take();
+            let open_req = file::FsRequest::new();
             do scheduler.deschedule_running_task_and_then |_, task| {
                 let task_cell = Cell::new(task);
                 let path = path_cell.take();
-                do file::FsRequest::open(self.uv_loop(), path, flags as int, create_mode as int)
+                do open_req.open(self.uv_loop(), path, flags as int, create_mode as int)
                       |req,err| {
                     if err.is_none() {
                         let loop_ = Loop {handle: req.get_loop().native_handle()};
                         let home = get_handle_to_current_scheduler!();
-                        let fd = file::FileDescriptor(req.get_result());
+                        let fd = req.get_result() as c_int;
                         let fs = ~UvFileStream::new(
                             loop_, fd, true, home) as ~RtioFileStream;
                         let res = Ok(fs);
@@ -566,31 +598,56 @@ impl IoFactory for UvIoFactory {
                     }
                 };
             };
-        }
+        };
         assert!(!result_cell.is_empty());
         return result_cell.take();
     }
 
     fn fs_unlink<P: PathLike>(&mut self, path: &P) -> Result<(), IoError> {
+        do uv_fs_helper(self.uv_loop(), path) |unlink_req, l, p, cb| {
+            do unlink_req.unlink(l, p) |req, err| {
+                cb(req, err)
+            };
+        }
+    }
+    fn fs_stat<P: PathLike>(&mut self, path: &P) -> Result<FileStat, IoError> {
+        use str::StrSlice;
         let result_cell = Cell::new_empty();
-        let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
+        let result_cell_ptr: *Cell<Result<FileStat,
+                                           IoError>> = &result_cell;
         let path_cell = Cell::new(path);
         do task::unkillable { // FIXME(#8674)
             let scheduler: ~Scheduler = Local::take();
+            let stat_req = file::FsRequest::new();
             do scheduler.deschedule_running_task_and_then |_, task| {
                 let task_cell = Cell::new(task);
                 let path = path_cell.take();
-                do file::FsRequest::unlink(self.uv_loop(), path) |_, err| {
+                let path_str = path.path_as_str(|p| p.to_owned());
+                do stat_req.stat(self.uv_loop(), path)
+                      |req,err| {
                     let res = match err {
-                        None => Ok(()),
-                        Some(err) => Err(uv_error_to_io_error(err))
+                        None => {
+                            let stat = req.get_stat();
+                            Ok(FileStat {
+                                path: Path(path_str),
+                                is_file: stat.is_file(),
+                                is_dir: stat.is_dir(),
+                                size: stat.st_size,
+                                created: stat.st_ctim.tv_sec as u64,
+                                modified: stat.st_mtim.tv_sec as u64,
+                                accessed: stat.st_atim.tv_sec as u64
+                            })
+                        },
+                        Some(e) => {
+                            Err(uv_error_to_io_error(e))
+                        }
                     };
                     unsafe { (*result_cell_ptr).put_back(res); }
                     let scheduler: ~Scheduler = Local::take();
                     scheduler.resume_blocked_task_immediately(task_cell.take());
                 };
             };
-        }
+        };
         assert!(!result_cell.is_empty());
         return result_cell.take();
     }
@@ -625,6 +682,59 @@ impl IoFactory for UvIoFactory {
         assert!(!result_cell.is_empty());
         return result_cell.take();
     }
+    fn fs_mkdir<P: PathLike>(&mut self, path: &P) -> Result<(), IoError> {
+        let mode = S_IRWXU as int;
+        do uv_fs_helper(self.uv_loop(), path) |mkdir_req, l, p, cb| {
+            do mkdir_req.mkdir(l, p, mode as int) |req, err| {
+                cb(req, err)
+            };
+        }
+    }
+    fn fs_rmdir<P: PathLike>(&mut self, path: &P) -> Result<(), IoError> {
+        do uv_fs_helper(self.uv_loop(), path) |rmdir_req, l, p, cb| {
+            do rmdir_req.rmdir(l, p) |req, err| {
+                cb(req, err)
+            };
+        }
+    }
+    fn fs_readdir<P: PathLike>(&mut self, path: &P, flags: c_int) ->
+        Result<~[Path], IoError> {
+        use str::StrSlice;
+        let result_cell = Cell::new_empty();
+        let result_cell_ptr: *Cell<Result<~[Path],
+                                           IoError>> = &result_cell;
+        let path_cell = Cell::new(path);
+        do task::unkillable { // FIXME(#8674)
+            let scheduler: ~Scheduler = Local::take();
+            let stat_req = file::FsRequest::new();
+            do scheduler.deschedule_running_task_and_then |_, task| {
+                let task_cell = Cell::new(task);
+                let path = path_cell.take();
+                let path_str = path.path_as_str(|p| p.to_owned());
+                do stat_req.readdir(self.uv_loop(), path, flags)
+                      |req,err| {
+                    let res = match err {
+                        None => {
+                            let rel_paths = req.get_paths();
+                            let mut paths = ~[];
+                            for r in rel_paths.iter() {
+                                paths.push(Path(path_str+"/"+*r));
+                            }
+                            Ok(paths)
+                        },
+                        Some(e) => {
+                            Err(uv_error_to_io_error(e))
+                        }
+                    };
+                    unsafe { (*result_cell_ptr).put_back(res); }
+                    let scheduler: ~Scheduler = Local::take();
+                    scheduler.resume_blocked_task_immediately(task_cell.take());
+                };
+            };
+        };
+        assert!(!result_cell.is_empty());
+        return result_cell.take();
+    }
 }
 
 pub struct UvTcpListener {
@@ -1163,7 +1273,7 @@ impl RtioTimer for UvTimer {
 
 pub struct UvFileStream {
     loop_: Loop,
-    fd: file::FileDescriptor,
+    fd: c_int,
     close_on_drop: bool,
     home: SchedHandle
 }
@@ -1173,7 +1283,7 @@ impl HomingIO for UvFileStream {
 }
 
 impl UvFileStream {
-    fn new(loop_: Loop, fd: file::FileDescriptor, close_on_drop: bool,
+    fn new(loop_: Loop, fd: c_int, close_on_drop: bool,
            home: SchedHandle) -> UvFileStream {
         UvFileStream {
             loop_: loop_,
@@ -1190,7 +1300,8 @@ impl UvFileStream {
             do scheduler.deschedule_running_task_and_then |_, task| {
                 let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
                 let task_cell = Cell::new(task);
-                do self_.fd.read(&self_.loop_, buf, offset) |req, uverr| {
+                let read_req = file::FsRequest::new();
+                do read_req.read(&self_.loop_, self_.fd, buf, offset) |req, uverr| {
                     let res = match uverr  {
                         None => Ok(req.get_result() as int),
                         Some(err) => Err(uv_error_to_io_error(err))
@@ -1211,7 +1322,8 @@ impl UvFileStream {
             do scheduler.deschedule_running_task_and_then |_, task| {
                 let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
                 let task_cell = Cell::new(task);
-                do self_.fd.write(&self_.loop_, buf, offset) |_, uverr| {
+                let write_req = file::FsRequest::new();
+                do write_req.write(&self_.loop_, self_.fd, buf, offset) |_, uverr| {
                     let res = match uverr  {
                         None => Ok(()),
                         Some(err) => Err(uv_error_to_io_error(err))
@@ -1228,7 +1340,7 @@ impl UvFileStream {
         Result<u64, IoError>{
         #[fixed_stack_segment]; #[inline(never)];
         unsafe {
-            match lseek((*self.fd), pos as off_t, whence) {
+            match lseek(self.fd, pos as off_t, whence) {
                 -1 => {
                     Err(IoError {
                         kind: OtherIoError,
@@ -1249,7 +1361,8 @@ impl Drop for UvFileStream {
             do self_.home_for_io_with_sched |self_, scheduler| {
                 do scheduler.deschedule_running_task_and_then |_, task| {
                     let task_cell = Cell::new(task);
-                    do self_.fd.close(&self.loop_) |_,_| {
+                    let close_req = file::FsRequest::new();
+                    do close_req.close(&self.loop_, self_.fd) |_,_| {
                         let scheduler: ~Scheduler = Local::take();
                         scheduler.resume_blocked_task_immediately(task_cell.take());
                     };
diff --git a/src/libstd/rt/uv/uvll.rs b/src/libstd/rt/uv/uvll.rs
index 8f3cef4d238..42102a52e2e 100644
--- a/src/libstd/rt/uv/uvll.rs
+++ b/src/libstd/rt/uv/uvll.rs
@@ -96,6 +96,59 @@ pub type uv_fs_t = c_void;
 pub type uv_udp_send_t = c_void;
 pub type uv_getaddrinfo_t = c_void;
 
+pub struct uv_timespec_t {
+    tv_sec: libc::c_long,
+    tv_nsec: libc::c_long
+}
+
+pub struct uv_stat_t {
+    st_dev: libc::uint64_t,
+    st_mode: libc::uint64_t,
+    st_nlink: libc::uint64_t,
+    st_uid: libc::uint64_t,
+    st_gid: libc::uint64_t,
+    st_rdev: libc::uint64_t,
+    st_ino: libc::uint64_t,
+    st_size: libc::uint64_t,
+    st_blksize: libc::uint64_t,
+    st_blocks: libc::uint64_t,
+    st_flags: libc::uint64_t,
+    st_gen: libc::uint64_t,
+    st_atim: uv_timespec_t,
+    st_mtim: uv_timespec_t,
+    st_ctim: uv_timespec_t,
+    st_birthtim: uv_timespec_t
+}
+
+impl uv_stat_t {
+    pub fn new() -> uv_stat_t {
+        uv_stat_t {
+            st_dev: 0,
+            st_mode: 0,
+            st_nlink: 0,
+            st_uid: 0,
+            st_gid: 0,
+            st_rdev: 0,
+            st_ino: 0,
+            st_size: 0,
+            st_blksize: 0,
+            st_blocks: 0,
+            st_flags: 0,
+            st_gen: 0,
+            st_atim: uv_timespec_t { tv_sec: 0, tv_nsec: 0 },
+            st_mtim: uv_timespec_t { tv_sec: 0, tv_nsec: 0 },
+            st_ctim: uv_timespec_t { tv_sec: 0, tv_nsec: 0 },
+            st_birthtim: uv_timespec_t { tv_sec: 0, tv_nsec: 0 }
+        }
+    }
+    pub fn is_file(&self) -> bool {
+        ((self.st_mode) & libc::S_IFMT as libc::uint64_t) == libc::S_IFREG as libc::uint64_t
+    }
+    pub fn is_dir(&self) -> bool {
+        ((self.st_mode) & libc::S_IFMT as libc::uint64_t) == libc::S_IFDIR as libc::uint64_t
+    }
+}
+
 #[cfg(stage0)]
 pub type uv_idle_cb = *u8;
 #[cfg(stage0)]
@@ -736,6 +789,39 @@ pub unsafe fn fs_close(loop_ptr: *uv_loop_t, req: *uv_fs_t, fd: c_int,
 
     rust_uv_fs_close(loop_ptr, req, fd, cb)
 }
+pub unsafe fn fs_stat(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char, cb: *u8) -> c_int {
+    #[fixed_stack_segment]; #[inline(never)];
+
+    rust_uv_fs_stat(loop_ptr, req, path, cb)
+}
+pub unsafe fn fs_fstat(loop_ptr: *uv_loop_t, req: *uv_fs_t, fd: c_int, cb: *u8) -> c_int {
+    #[fixed_stack_segment]; #[inline(never)];
+
+    rust_uv_fs_fstat(loop_ptr, req, fd, cb)
+}
+pub unsafe fn fs_mkdir(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char, mode: int,
+                cb: *u8) -> c_int {
+    #[fixed_stack_segment]; #[inline(never)];
+
+    rust_uv_fs_mkdir(loop_ptr, req, path, mode as c_int, cb)
+}
+pub unsafe fn fs_rmdir(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+                cb: *u8) -> c_int {
+    #[fixed_stack_segment]; #[inline(never)];
+
+    rust_uv_fs_rmdir(loop_ptr, req, path, cb)
+}
+pub unsafe fn fs_readdir(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+                flags: c_int, cb: *u8) -> c_int {
+    #[fixed_stack_segment]; #[inline(never)];
+
+    rust_uv_fs_readdir(loop_ptr, req, path, flags, cb)
+}
+pub unsafe fn populate_stat(req_in: *uv_fs_t, stat_out: *uv_stat_t) {
+    #[fixed_stack_segment]; #[inline(never)];
+
+    rust_uv_populate_uv_stat(req_in, stat_out)
+}
 pub unsafe fn fs_req_cleanup(req: *uv_fs_t) {
     #[fixed_stack_segment]; #[inline(never)];
 
@@ -748,6 +834,11 @@ pub unsafe fn get_result_from_fs_req(req: *uv_fs_t) -> c_int {
 
     rust_uv_get_result_from_fs_req(req)
 }
+pub unsafe fn get_ptr_from_fs_req(req: *uv_fs_t) -> *libc::c_void {
+    #[fixed_stack_segment]; #[inline(never)];
+
+    rust_uv_get_ptr_from_fs_req(req)
+}
 pub unsafe fn get_loop_from_fs_req(req: *uv_fs_t) -> *uv_loop_t {
     #[fixed_stack_segment]; #[inline(never)];
 
@@ -928,8 +1019,18 @@ extern {
                        buf: *c_void, len: c_uint, offset: i64, cb: *u8) -> c_int;
     fn rust_uv_fs_close(loop_ptr: *c_void, req: *uv_fs_t, fd: c_int,
                         cb: *u8) -> c_int;
+    fn rust_uv_fs_stat(loop_ptr: *c_void, req: *uv_fs_t, path: *c_char, cb: *u8) -> c_int;
+    fn rust_uv_fs_fstat(loop_ptr: *c_void, req: *uv_fs_t, fd: c_int, cb: *u8) -> c_int;
+    fn rust_uv_fs_mkdir(loop_ptr: *c_void, req: *uv_fs_t, path: *c_char,
+                        mode: c_int, cb: *u8) -> c_int;
+    fn rust_uv_fs_rmdir(loop_ptr: *c_void, req: *uv_fs_t, path: *c_char,
+                        cb: *u8) -> c_int;
+    fn rust_uv_fs_readdir(loop_ptr: *c_void, req: *uv_fs_t, path: *c_char,
+                        flags: c_int, cb: *u8) -> c_int;
     fn rust_uv_fs_req_cleanup(req: *uv_fs_t);
+    fn rust_uv_populate_uv_stat(req_in: *uv_fs_t, stat_out: *uv_stat_t);
     fn rust_uv_get_result_from_fs_req(req: *uv_fs_t) -> c_int;
+    fn rust_uv_get_ptr_from_fs_req(req: *uv_fs_t) -> *libc::c_void;
     fn rust_uv_get_loop_from_fs_req(req: *uv_fs_t) -> *uv_loop_t;
     fn rust_uv_get_loop_from_getaddrinfo_req(req: *uv_fs_t) -> *uv_loop_t;