OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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!
This commit is contained in:
bors 2013-09-17 14:05:45 -07:00
parent 9e8fb4ad61 70152ff557
commit c135cb2683
10 changed files with 1448 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/libstd/os.rs
View File

@ -196,16 +196,7 @@ pub fn env() -> ~[(~str,~str)] {
if (ch as uint == 0) {
fail!("os::env() failure getting env string from OS: %s", os::last_os_error());
}
let mut curr_ptr: uint = ch as uint;
let mut result = ~[];
while(*(curr_ptr as *libc::c_char) != 0 as libc::c_char) {
let env_pair = str::raw::from_c_str(
curr_ptr as *libc::c_char);
result.push(env_pair);
curr_ptr +=
libc::strlen(curr_ptr as *libc::c_char) as uint
+ 1;
}
let result = str::raw::from_c_multistring(ch as *libc::c_char, None);
FreeEnvironmentStringsA(ch);
result
}

679
src/libstd/rt/io/file.rs
View File

@ -8,17 +8,87 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
/*! Synchronous File I/O
This module provides a set of functions and traits for working
with regular files & directories on a filesystem.
At the top-level of the module are a set of freestanding functions,
associated with various filesystem operations. They all operate
on a `PathLike` object.
All operations in this module, including those as part of `FileStream` et al
block the task during execution. Most will raise `std::rt::io::{io_error,read_error}`
conditions in the event of failure.
Also included in this module are the `FileInfo` and `DirectoryInfo` traits. When
`use`'d alongside a value whose type implements them (A `std::path::Path` impl is
a part of this module), they expose a set of functions for operations against
a given file location, depending on whether the path already exists. Whenever
possible, the `{FileInfo, DirectoryInfo}` preserve the same semantics as their
free function counterparts.
*/
use prelude::*;
use super::support::PathLike;
use super::{Reader, Writer, Seek};
use super::{SeekSet, SeekCur, SeekEnd, SeekStyle};
use super::{SeekStyle,SeekSet, SeekCur, SeekEnd,
Open, Read, Write, Create, ReadWrite};
use rt::rtio::{RtioFileStream, IoFactory, IoFactoryObject};
use rt::io::{io_error, read_error, EndOfFile,
FileMode, FileAccess, Open, Read, Create, ReadWrite};
FileMode, FileAccess, FileStat, IoError,
PathAlreadyExists, PathDoesntExist,
MismatchedFileTypeForOperation, ignore_io_error};
use rt::local::Local;
use rt::test::*;
use option::{Some, None};
use path::Path;
use super::super::test::*;
/// Open a file for reading/writing, as indicated by `path`.
///
/// # Example
///
/// use std;
/// use std::path::Path;
/// use std::rt::io::support::PathLike;
/// use std::rt::io::file::open;
/// use std::rt::io::{FileMode, FileAccess};
///
/// let p = &Path("/some/file/path.txt");
///
/// do io_error::cond.trap(|_| {
/// // hoo-boy...
/// }).inside {
/// let stream = match open(p, Create, ReadWrite) {
/// Some(s) => s,
/// None => fail!("whoops! I'm sure this raised, anyways..");
/// }
/// // do some stuff with that stream
///
/// // the file stream will be closed at the end of this block
/// }
/// // ..
///
/// `FileMode` and `FileAccess` provide information about the permissions
/// context in which a given stream is created. More information about them
/// can be found in `std::rt::io`'s docs.
///
/// Note that, with this function, a `FileStream` is returned regardless of
/// the access-limitations indicated by `FileAccess` (e.g. calling `write` on a
/// `FileStream` opened as `ReadOnly` will raise an `io_error` condition at runtime). If you
/// desire a more-correctly-constrained interface to files, use the
/// `{open_stream, open_reader, open_writer}` methods that are a part of `FileInfo`
///
/// # Errors
///
/// This function will raise an `io_error` condition under a number of different circumstances,
/// to include but not limited to:
///
/// * Opening a file that already exists with `FileMode` of `Create` or vice versa (e.g.
/// opening a non-existant file with `FileMode` or `Open`)
/// * Attempting to open a file with a `FileAccess` that the user lacks permissions
/// for
/// * Filesystem-level errors (full disk, etc)
pub fn open<P: PathLike>(path: &P,
mode: FileMode,
access: FileAccess
@ -39,8 +109,28 @@ pub fn open<P: PathLike>(path: &P,
}
}
/// Unlink (remove) a file from the filesystem, as indicated
/// by `path`.
/// Unlink a file from the underlying filesystem.
///
/// # Example
///
/// use std;
/// use std::path::Path;
/// use std::rt::io::support::PathLike;
/// use std::rt::io::file::unlink;
///
/// let p = &Path("/some/file/path.txt");
/// unlink(p);
/// // if we made it here without failing, then the
/// // unlink operation was successful
///
/// Note that, just because an unlink call was successful, it is not
/// guaranteed that a file is immediately deleted (e.g. depending on
/// platform, other open file descriptors may prevent immediate removal)
///
/// # Errors
///
/// This function will raise an `io_error` condition if the user lacks permissions to
/// remove the file or if some other filesystem-level error occurs
pub fn unlink<P: PathLike>(path: &P) {
let unlink_result = unsafe {
let io: *mut IoFactoryObject = Local::unsafe_borrow();
@ -54,26 +144,231 @@ pub fn unlink<P: PathLike>(path: &P) {
}
}
/// Abstraction representing *positional* access to a file. In this case,
/// *positional* refers to it keeping an encounter *cursor* of where in the
/// file a subsequent `read` or `write` will begin from. Users of a `FileStream`
/// can `seek` to move the cursor to a given location *within the bounds of the
/// file* and can ask to have the `FileStream` `tell` them the location, in
/// bytes, of the cursor.
/// Create a new, empty directory at the provided path
///
/// This abstraction is roughly modeled on the access workflow as represented
/// by `open(2)`, `read(2)`, `write(2)` and friends.
/// # Example
///
/// The `open` and `unlink` static methods are provided to manage creation/removal
/// of files. All other methods operatin on an instance of `FileStream`.
/// use std;
/// use std::path::Path;
/// use std::rt::io::support::PathLike;
/// use std::rt::io::file::mkdir;
///
/// let p = &Path("/some/dir");
/// mkdir(p);
/// // If we got here, our directory exists! Horray!
///
/// # Errors
///
/// This call will raise an `io_error` condition if the user lacks permissions to make a
/// new directory at the provided path, or if the directory already exists
pub fn mkdir<P: PathLike>(path: &P) {
let mkdir_result = unsafe {
let io: *mut IoFactoryObject = Local::unsafe_borrow();
(*io).fs_mkdir(path)
};
match mkdir_result {
Ok(_) => (),
Err(ioerr) => {
io_error::cond.raise(ioerr);
}
}
}
/// Remove an existing, empty directory
///
/// # Example
///
/// use std;
/// use std::path::Path;
/// use std::rt::io::support::PathLike;
/// use std::rt::io::file::rmdir;
///
/// let p = &Path("/some/dir");
/// rmdir(p);
/// // good riddance, you mean ol' directory
///
/// # Errors
///
/// This call will raise an `io_error` condition if the user lacks permissions to remove the
/// directory at the provided path, or if the directory isn't empty
pub fn rmdir<P: PathLike>(path: &P) {
let rmdir_result = unsafe {
let io: *mut IoFactoryObject = Local::unsafe_borrow();
(*io).fs_rmdir(path)
};
match rmdir_result {
Ok(_) => (),
Err(ioerr) => {
io_error::cond.raise(ioerr);
}
}
}
/// Get information on the file, directory, etc at the provided path
///
/// Given a `rt::io::support::PathLike`, query the file system to get
/// information about a file, directory, etc.
///
/// Returns a `Some(std::rt::io::PathInfo)` on success
///
/// # Example
///
/// use std;
/// use std::path::Path;
/// use std::rt::io::support::PathLike;
/// use std::rt::io::file::stat;
///
/// let p = &Path("/some/file/path.txt");
///
/// do io_error::cond.trap(|_| {
/// // hoo-boy...
/// }).inside {
/// let info = match stat(p) {
/// Some(s) => s,
/// None => fail!("whoops! I'm sure this raised, anyways..");
/// }
/// if stat.is_file {
/// // just imagine the possibilities ...
/// }
///
/// // the file stream will be closed at the end of this block
/// }
/// // ..
///
/// # Errors
///
/// This call will raise an `io_error` condition if the user lacks the requisite
/// permissions to perform a `stat` call on the given path or if there is no
/// entry in the filesystem at the provided path.
pub fn stat<P: PathLike>(path: &P) -> Option<FileStat> {
let open_result = unsafe {
let io: *mut IoFactoryObject = Local::unsafe_borrow();
(*io).fs_stat(path)
};
match open_result {
Ok(p) => {
Some(p)
},
Err(ioerr) => {
io_error::cond.raise(ioerr);
None
}
}
}
/// Retrieve a vector containing all entries within a provided directory
///
/// # Example
///
/// use std;
/// use std::path::Path;
/// use std::rt::io::support::PathLike;
/// use std::rt::io::file::readdir;
///
/// fn visit_dirs(dir: &Path, cb: &fn(&Path)) {
/// if dir.is_dir() {
/// let contents = dir.readdir();
/// for entry in contents.iter() {
/// if entry.is_dir() { visit_dirs(entry, cb); }
/// else { cb(entry); }
/// }
/// }
/// else { fail!("nope"); }
/// }
///
/// # Errors
///
/// Will raise an `io_error` condition if the provided `path` doesn't exist,
/// the process lacks permissions to view the contents or if the `path` points
/// at a non-directory file
pub fn readdir<P: PathLike>(path: &P) -> Option<~[Path]> {
let readdir_result = unsafe {
let io: *mut IoFactoryObject = Local::unsafe_borrow();
(*io).fs_readdir(path, 0)
};
match readdir_result {
Ok(p) => {
Some(p)
},
Err(ioerr) => {
io_error::cond.raise(ioerr);
None
}
}
}
/// Constrained version of `FileStream` that only exposes read-specific operations.
///
/// Can be retreived via `FileInfo.open_reader()`.
pub struct FileReader { priv stream: FileStream }
/// a `std::rt::io::Reader` trait impl for file I/O.
impl Reader for FileReader {
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
self.stream.read(buf)
}
fn eof(&mut self) -> bool {
self.stream.eof()
}
}
/// a `std::rt::io::Seek` trait impl for file I/O.
impl Seek for FileReader {
fn tell(&self) -> u64 {
self.stream.tell()
}
fn seek(&mut self, pos: i64, style: SeekStyle) {
self.stream.seek(pos, style);
}
}
/// Constrained version of `FileStream` that only exposes write-specific operations.
///
/// Can be retreived via `FileInfo.open_writer()`.
pub struct FileWriter { priv stream: FileStream }
/// a `std::rt::io::Writer` trait impl for file I/O.
impl Writer for FileWriter {
fn write(&mut self, buf: &[u8]) {
self.stream.write(buf);
}
fn flush(&mut self) {
self.stream.flush();
}
}
/// a `std::rt::io::Seek` trait impl for file I/O.
impl Seek for FileWriter {
fn tell(&self) -> u64 {
self.stream.tell()
}
fn seek(&mut self, pos: i64, style: SeekStyle) {
self.stream.seek(pos, style);
}
}
/// Unconstrained file access type that exposes read and write operations
///
/// Can be retreived via `file::open()` and `FileInfo.open_stream()`.
///
/// # Errors
///
/// This type will raise an io_error condition if operations are attempted against
/// it for which its underlying file descriptor was not configured at creation
/// time, via the `FileAccess` parameter to `file::open()`.
///
/// For this reason, it is best to use the access-constrained wrappers that are
/// exposed via `FileInfo.open_reader()` and `FileInfo.open_writer()`.
pub struct FileStream {
fd: ~RtioFileStream,
last_nread: int,
}
impl FileStream {
}
/// a `std::rt::io::Reader` trait impl for file I/O.
impl Reader for FileStream {
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
match self.fd.read(buf) {
@ -99,6 +394,7 @@ impl Reader for FileStream {
}
}
/// a `std::rt::io::Writer` trait impl for file I/O.
impl Writer for FileStream {
fn write(&mut self, buf: &[u8]) {
match self.fd.write(buf) {
@ -119,6 +415,7 @@ impl Writer for FileStream {
}
}
/// a `std::rt::io:Seek` trait impl for file I/O.
impl Seek for FileStream {
fn tell(&self) -> u64 {
let res = self.fd.tell();
@ -145,6 +442,242 @@ impl Seek for FileStream {
}
}
/// Shared functionality between `FileInfo` and `DirectoryInfo`
pub trait FileSystemInfo {
/// Get the filesystem path that this instance points at,
/// whether it is valid or not. In this way, it can be used to
/// to specify a path of a non-existent file which it
/// later creates
fn get_path<'a>(&'a self) -> &'a Path;
/// Get information on the file, directory, etc at the provided path
///
/// Consult the `file::stat` documentation for more info.
///
/// This call preserves identical runtime/error semantics with `file::stat`
fn stat(&self) -> Option<FileStat> {
stat(self.get_path())
}
/// Boolean value indicator whether the underlying file exists on the filesystem
///
/// # Errors
///
/// Will not raise a condition
fn exists(&self) -> bool {
match ignore_io_error(|| self.stat()) {
Some(_) => true,
None => false
}
}
}
/// Represents a file, whose underlying path may or may not be valid
///
/// # Example
///
/// * Check if a file exists, reading from it if so
///
/// use std;
/// use std::path::Path;
/// use std::rt::io::file::{FileInfo, FileReader};
///
/// let f = &Path("/some/file/path.txt");
/// if f.exists() {
/// let reader = f.open_reader(Open);
/// let mut mem = [0u8, 8*64000];
/// reader.read(mem);
/// // ...
/// }
///
/// * Is the given path a file?
///
/// let f = get_file_path_from_wherever();
/// match f.is_file() {
/// true => doing_something_with_a_file(f),
/// _ => {}
/// }
pub trait FileInfo : FileSystemInfo {
/// Whether the underlying implemention (be it a file path,
/// or something else) points at a "regular file" on the FS. Will return
/// false for paths to non-existent locations or directories or
/// other non-regular files (named pipes, etc).
///
/// # Errors
///
/// Will not raise a condition
fn is_file(&self) -> bool {
match ignore_io_error(|| self.stat()) {
Some(s) => s.is_file,
None => false
}
}
/// Attempts to open a regular file for reading/writing based
/// on provided inputs
///
/// See `file::open` for more information on runtime semantics and error conditions
fn open_stream(&self, mode: FileMode, access: FileAccess) -> Option<FileStream> {
match ignore_io_error(|| self.stat()) {
Some(s) => match s.is_file {
true => open(self.get_path(), mode, access),
false => None
},
None => open(self.get_path(), mode, access)
}
}
/// Attempts to open a regular file in read-only mode, based
/// on provided inputs
///
/// See `file::open` for more information on runtime semantics and error conditions
fn open_reader(&self, mode: FileMode) -> Option<FileReader> {
match self.open_stream(mode, Read) {
Some(s) => Some(FileReader { stream: s}),
None => None
}
}
/// Attempts to open a regular file in write-only mode, based
/// on provided inputs
///
/// See `file::open` for more information on runtime semantics and error conditions
fn open_writer(&self, mode: FileMode) -> Option<FileWriter> {
match self.open_stream(mode, Write) {
Some(s) => Some(FileWriter { stream: s}),
None => None
}
}
/// Attempt to remove a file from the filesystem
///
/// See `file::unlink` for more information on runtime semantics and error conditions
fn unlink(&self) {
unlink(self.get_path());
}
}
/// `FileSystemInfo` implementation for `Path`s
impl FileSystemInfo for Path {
fn get_path<'a>(&'a self) -> &'a Path { self }
}
/// `FileInfo` implementation for `Path`s
impl FileInfo for Path { }
/// Represents a directory, whose underlying path may or may not be valid
///
/// # Example
///
/// * Check if a directory exists, `mkdir`'ing it if not
///
/// use std;
/// use std::path::Path;
/// use std::rt::io::file::{DirectoryInfo};
///
/// let dir = &Path("/some/dir");
/// if !dir.exists() {
/// dir.mkdir();
/// }
///
/// * Is the given path a directory? If so, iterate on its contents
///
/// fn visit_dirs(dir: &Path, cb: &fn(&Path)) {
/// if dir.is_dir() {
/// let contents = dir.readdir();
/// for entry in contents.iter() {
/// if entry.is_dir() { visit_dirs(entry, cb); }
/// else { cb(entry); }
/// }
/// }
/// else { fail!("nope"); }
/// }
trait DirectoryInfo : FileSystemInfo {
/// Whether the underlying implemention (be it a file path,
/// or something else) is pointing at a directory in the underlying FS.
/// Will return false for paths to non-existent locations or if the item is
/// not a directory (eg files, named pipes, links, etc)
///
/// # Errors
///
/// Will not raise a condition
fn is_dir(&self) -> bool {
match ignore_io_error(|| self.stat()) {
Some(s) => s.is_dir,
None => false
}
}
/// Create a directory at the location pointed to by the
/// type underlying the given `DirectoryInfo`.
///
/// # Errors
///
/// This method will raise a `PathAlreadyExists` kind of `io_error` condition
/// if the provided path exists
///
/// See `file::mkdir` for more information on runtime semantics and error conditions
fn mkdir(&self) {
match ignore_io_error(|| self.stat()) {
Some(_) => {
io_error::cond.raise(IoError {
kind: PathAlreadyExists,
desc: "Path already exists",
detail:
Some(fmt!("%s already exists; can't mkdir it", self.get_path().to_str()))
})
},
None => mkdir(self.get_path())
}
}
/// Remove a directory at the given location.
///
/// # Errors
///
/// This method will raise a `PathDoesntExist` kind of `io_error` condition
/// if the provided path exists. It will raise a `MismatchedFileTypeForOperation`
/// kind of `io_error` condition if the provided path points at any
/// non-directory file type
///
/// See `file::rmdir` for more information on runtime semantics and error conditions
fn rmdir(&self) {
match ignore_io_error(|| self.stat()) {
Some(s) => {
match s.is_dir {
true => rmdir(self.get_path()),
false => {
let ioerr = IoError {
kind: MismatchedFileTypeForOperation,
desc: "Cannot do rmdir() on a non-directory",
detail: Some(fmt!(
"%s is a non-directory; can't rmdir it",
self.get_path().to_str()))
};
io_error::cond.raise(ioerr);
}
}
},
None =>
io_error::cond.raise(IoError {
kind: PathDoesntExist,
desc: "Path doesn't exist",
detail: Some(fmt!("%s doesn't exist; can't rmdir it", self.get_path().to_str()))
})
}
}
// Get a collection of all entries at the given
// directory
fn readdir(&self) -> Option<~[Path]> {
readdir(self.get_path())
}
}
/// `DirectoryInfo` impl for `path::Path`
impl DirectoryInfo for Path { }
fn file_test_smoke_test_impl() {
do run_in_mt_newsched_task {
let message = "it's alright. have a good time";
@ -273,7 +806,6 @@ fn file_test_io_seek_and_tell_smoke_test() {
}
fn file_test_io_seek_and_write_impl() {
use io;
do run_in_mt_newsched_task {
use str;
let initial_msg = "food-is-yummy";
@ -294,7 +826,6 @@ fn file_test_io_seek_and_write_impl() {
}
unlink(filename);
let read_str = str::from_utf8(read_mem);
io::println(fmt!("read_str: '%?' final_msg: '%?'", read_str, final_msg));
assert!(read_str == final_msg.to_owned());
}
}
@ -343,3 +874,111 @@ fn file_test_io_seek_shakedown_impl() {
fn file_test_io_seek_shakedown() {
file_test_io_seek_shakedown_impl();
}
#[test]
fn file_test_stat_is_correct_on_is_file() {
do run_in_mt_newsched_task {
let filename = &Path("./tmp/file_stat_correct_on_is_file.txt");
{
let mut fs = open(filename, Create, ReadWrite).unwrap();
let msg = "hw";
fs.write(msg.as_bytes());
}
let stat_res = match stat(filename) {
Some(s) => s,
None => fail!("shouldn't happen")
};
assert!(stat_res.is_file);
unlink(filename);
}
}
#[test]
fn file_test_stat_is_correct_on_is_dir() {
do run_in_mt_newsched_task {
let filename = &Path("./tmp/file_stat_correct_on_is_dir");
mkdir(filename);
let stat_res = match stat(filename) {
Some(s) => s,
None => fail!("shouldn't happen")
};
assert!(stat_res.is_dir);
rmdir(filename);
}
}
#[test]
fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
do run_in_mt_newsched_task {
let dir = &Path("./tmp/fileinfo_false_on_dir");
mkdir(dir);
assert!(dir.is_file() == false);
rmdir(dir);
}
}
#[test]
fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
do run_in_mt_newsched_task {
let file = &Path("./tmp/fileinfo_check_exists_b_and_a.txt");
{
let msg = "foo".as_bytes();
let mut w = file.open_writer(Create);
w.write(msg);
}
assert!(file.exists());
file.unlink();
assert!(!file.exists());
}
}
#[test]
fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
do run_in_mt_newsched_task {
let dir = &Path("./tmp/before_and_after_dir");
assert!(!dir.exists());
dir.mkdir();
assert!(dir.exists());
assert!(dir.is_dir());
dir.rmdir();
assert!(!dir.exists());
}
}
#[test]
fn file_test_directoryinfo_readdir() {
use str;
do run_in_mt_newsched_task {
let dir = &Path("./tmp/di_readdir");
dir.mkdir();
let prefix = "foo";
for n in range(0,3) {
let f = dir.push(fmt!("%d.txt", n));
let mut w = f.open_writer(Create);
let msg_str = (prefix + n.to_str().to_owned()).to_owned();
let msg = msg_str.as_bytes();
w.write(msg);
}
match dir.readdir() {
Some(files) => {
let mut mem = [0u8, .. 4];
for f in files.iter() {
{
let n = f.filestem();
let mut r = f.open_reader(Open);
r.read(mem);
let read_str = str::from_utf8(mem);
let expected = match n {
Some(n) => prefix+n,
None => fail!("really shouldn't happen..")
};
assert!(expected == read_str);
}
f.unlink();
}
},
None => fail!("shouldn't happen")
}
dir.rmdir();
}
}

42
src/libstd/rt/io/mod.rs
View File

@ -245,6 +245,7 @@ Out of scope
use prelude::*;
use to_str::ToStr;
use str::{StrSlice, OwnedStr};
use path::Path;
// Reexports
pub use self::stdio::stdin;
@ -357,7 +358,10 @@ pub enum IoErrorKind {
Closed,
ConnectionRefused,
ConnectionReset,
BrokenPipe
BrokenPipe,
PathAlreadyExists,
PathDoesntExist,
MismatchedFileTypeForOperation
}
// FIXME: #8242 implementing manually because deriving doesn't work for some reason
@ -373,7 +377,10 @@ impl ToStr for IoErrorKind {
Closed => ~"Closed",
ConnectionRefused => ~"ConnectionRefused",
ConnectionReset => ~"ConnectionReset",
BrokenPipe => ~"BrokenPipe"
BrokenPipe => ~"BrokenPipe",
PathAlreadyExists => ~"PathAlreadyExists",
PathDoesntExist => ~"PathDoesntExist",
MismatchedFileTypeForOperation => ~"MismatchedFileTypeForOperation"
}
}
}
@ -394,6 +401,18 @@ condition! {
pub read_error: super::IoError -> ();
}
/// Helper for wrapper calls where you want to
/// ignore any io_errors that might be raised
pub fn ignore_io_error<T>(cb: &fn() -> T) -> T {
do io_error::cond.trap(|_| {
// just swallow the error.. downstream users
// who can make a decision based on a None result
// won't care
}).inside {
cb()
}
}
pub trait Reader {
/// Read bytes, up to the length of `buf` and place them in `buf`.
/// Returns the number of bytes read. The number of bytes read my
@ -596,3 +615,22 @@ pub enum FileAccess {
Write,
ReadWrite
}
pub struct FileStat {
/// A `Path` object containing information about the `PathInfo`'s location
path: Path,
/// `true` if the file pointed at by the `PathInfo` is a regular file
is_file: bool,
/// `true` if the file pointed at by the `PathInfo` is a directory
is_dir: bool,
/// The file pointed at by the `PathInfo`'s size in bytes
size: u64,
/// The file pointed at by the `PathInfo`'s creation time
created: u64,
/// The file pointed at by the `PathInfo`'s last-modification time in
/// platform-dependent msecs
modified: u64,
/// The file pointed at by the `PathInfo`'s last-accessd time (e.g. read) in
/// platform-dependent msecs
accessed: u64,
}

7
src/libstd/rt/rtio.rs
View File

@ -18,7 +18,7 @@ use rt::uv::uvio;
use path::Path;
use super::io::support::PathLike;
use super::io::{SeekStyle};
use super::io::{FileMode, FileAccess};
use super::io::{FileMode, FileAccess, FileStat};
// XXX: ~object doesn't work currently so these are some placeholder
// types to use instead
@ -74,6 +74,11 @@ pub trait IoFactory {
-> Result<~RtioFileStream, IoError>;
fn fs_unlink<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
fn get_host_addresses(&mut self, host: &str) -> Result<~[IpAddr], IoError>;
fn fs_stat<P: PathLike>(&mut self, path: &P) -> Result<FileStat, IoError>;
fn fs_mkdir<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
fn fs_rmdir<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
fn fs_readdir<P: PathLike>(&mut self, path: &P, flags: c_int) ->
Result<~[Path], IoError>;
}
pub trait RtioTcpListener : RtioSocket {

590
src/libstd/rt/uv/file.rs
View File

@ -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))
};
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)
})
});
}
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 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_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));
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)
}
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<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)
})
});
}
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
}
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 unlink_sync<P: PathLike>(loop_: &Loop, path: &P) -> Result<int, UvError> {
let result = FsRequest::unlink_common(loop_, path, None);
sync_cleanup(result)
self.sync_cleanup(result)
}
pub fn install_req_data(&self, cb: Option<FsCallback>) {
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 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 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 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();
}
}
}

147
src/libstd/rt/uv/uvio.rs
View File

@ -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());
};

101
src/libstd/rt/uv/uvll.rs
View File

@ -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;

48
src/libstd/str.rs
View File

@ -938,6 +938,7 @@ static TAG_CONT_U8: u8 = 128u8;
/// Unsafe operations
pub mod raw {
use option::{Option, Some};
use cast;
use libc;
use ptr;
@ -1091,6 +1092,34 @@ pub mod raw {
vec::raw::set_len(as_owned_vec(s), new_len)
}
/// Parses a C "multistring", eg windows env values or
/// the req->ptr result in a uv_fs_readdir() call.
/// Optionally, a `count` can be passed in, limiting the
/// parsing to only being done `count`-times.
#[inline]
pub unsafe fn from_c_multistring(buf: *libc::c_char, count: Option<uint>) -> ~[~str] {
#[fixed_stack_segment]; #[inline(never)];
let mut curr_ptr: uint = buf as uint;
let mut result = ~[];
let mut ctr = 0;
let (limited_count, limit) = match count {
Some(limit) => (true, limit),
None => (false, 0)
};
while(*(curr_ptr as *libc::c_char) != 0 as libc::c_char
&& ((limited_count && ctr < limit) || !limited_count)) {
let env_pair = from_c_str(
curr_ptr as *libc::c_char);
result.push(env_pair);
curr_ptr +=
libc::strlen(curr_ptr as *libc::c_char) as uint
+ 1;
ctr += 1;
}
result
}
/// Sets the length of a string
///
/// This will explicitly set the size of the string, without actually
@ -1106,6 +1135,25 @@ pub mod raw {
}
}
#[test]
fn test_str_multistring_parsing() {
use option::None;
unsafe {
let input = bytes!("zero", "\x00", "one", "\x00", "\x00");
let ptr = vec::raw::to_ptr(input);
let mut result = from_c_multistring(ptr as *libc::c_char, None);
assert!(result.len() == 2);
let mut ctr = 0;
for x in result.iter() {
match ctr {
0 => assert_eq!(x, &~"zero"),
1 => assert_eq!(x, &~"one"),
_ => fail!("shouldn't happen!")
}
ctr += 1;
}
}
}
}
/*

51
src/rt/rust_uv.cpp
View File

@ -542,6 +542,10 @@ extern "C" int
rust_uv_get_result_from_fs_req(uv_fs_t* req) {
return req->result;
}
extern "C" void*
rust_uv_get_ptr_from_fs_req(uv_fs_t* req) {
return req->ptr;
}
extern "C" uv_loop_t*
rust_uv_get_loop_from_fs_req(uv_fs_t* req) {
return req->loop;
@ -551,3 +555,50 @@ extern "C" uv_loop_t*
rust_uv_get_loop_from_getaddrinfo_req(uv_getaddrinfo_t* req) {
return req->loop;
}
extern "C" int
rust_uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
return uv_fs_stat(loop, req, path, cb);
}
extern "C" int
rust_uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
return uv_fs_fstat(loop, req, file, cb);
}
extern "C" void
rust_uv_populate_uv_stat(uv_fs_t* req_in, uv_stat_t* stat_out) {
stat_out->st_dev = req_in->statbuf.st_dev;
stat_out->st_mode = req_in->statbuf.st_mode;
stat_out->st_nlink = req_in->statbuf.st_nlink;
stat_out->st_uid = req_in->statbuf.st_uid;
stat_out->st_gid = req_in->statbuf.st_gid;
stat_out->st_rdev = req_in->statbuf.st_rdev;
stat_out->st_ino = req_in->statbuf.st_ino;
stat_out->st_size = req_in->statbuf.st_size;
stat_out->st_blksize = req_in->statbuf.st_blksize;
stat_out->st_blocks = req_in->statbuf.st_blocks;
stat_out->st_flags = req_in->statbuf.st_flags;
stat_out->st_gen = req_in->statbuf.st_gen;
stat_out->st_atim.tv_sec = req_in->statbuf.st_atim.tv_sec;
stat_out->st_atim.tv_nsec = req_in->statbuf.st_atim.tv_nsec;
stat_out->st_mtim.tv_sec = req_in->statbuf.st_mtim.tv_sec;
stat_out->st_mtim.tv_nsec = req_in->statbuf.st_mtim.tv_nsec;
stat_out->st_ctim.tv_sec = req_in->statbuf.st_ctim.tv_sec;
stat_out->st_ctim.tv_nsec = req_in->statbuf.st_ctim.tv_nsec;
stat_out->st_birthtim.tv_sec = req_in->statbuf.st_birthtim.tv_sec;
stat_out->st_birthtim.tv_nsec = req_in->statbuf.st_birthtim.tv_nsec;
}
extern "C" int
rust_uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb) {
return uv_fs_mkdir(loop, req, path, mode, cb);
}
extern "C" int
rust_uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
return uv_fs_rmdir(loop, req, path, cb);
}
extern "C" int
rust_uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, uv_fs_cb cb) {
return uv_fs_readdir(loop, req, path, flags, cb);
}

7
src/rt/rustrt.def.in
View File

@ -113,8 +113,15 @@ rust_uv_fs_write
rust_uv_fs_read
rust_uv_fs_close
rust_uv_get_result_from_fs_req
rust_uv_get_ptr_from_fs_req
rust_uv_get_loop_from_fs_req
rust_uv_fs_stat
rust_uv_fs_fstat
rust_uv_fs_req_cleanup
rust_uv_populate_uv_stat
rust_uv_fs_mkdir
rust_uv_fs_rmdir
rust_uv_fs_readdir
rust_dbg_lock_create
rust_dbg_lock_destroy
rust_dbg_lock_lock