1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
//! libmount //! //! This library has two major goals: //! //! 1. Add type-safe interface for mount() system call //! 2. Add very good explanation of what's wrong when the call fails //! //! So we have two error types: //! //! 1. `OSError` holds mount info and errno //! 2. `Error` is returned by `OSError::explain()` //! //! The first one is returned by `bare_mount()` the second by `mount()`, and //! using latter is preffered for most situations. Unless performance is //! too critical (i.e. you are doing thousands of *failing* mounts per second). //! On the success path there is no overhead. //! extern crate libc; extern crate nix; #[macro_use] extern crate quick_error; mod util; mod error; mod explain; mod bind; mod overlay; mod tmpfs; mod modify; mod remount; mod mountinfo; use std::io; use explain::Explainable; use remount::RemountError; pub use bind::BindMount; pub use overlay::Overlay; pub use tmpfs::Tmpfs; pub use modify::Move; pub use remount::Remount; quick_error! { #[derive(Debug)] enum MountError { Io(err: io::Error) { cause(err) from() } Remount(err: RemountError) { cause(err) from() } } } /// The raw os error /// /// This is a wrapper around `io::Error` providing `explain()` method /// /// Note: you need to explain as fast as possible, because during explain /// library makes some probes for different things in filesystem, and if /// anything changes it may give incorrect results. /// /// You should always `explain()` the errors, unless you are trying lots of /// mounts for bruteforcing or other similar thing and you are concerned of /// performance. Usually library does `stat()` and similar things which are /// much faster than mount anyway. Also explaining is zero-cost in the success /// path. /// #[derive(Debug)] pub struct OSError(MountError, Box<Explainable>); impl OSError { fn from_io(err: io::Error, explain: Box<Explainable>) -> OSError { OSError(MountError::Io(err), explain) } fn from_remount(err: RemountError, explain: Box<Explainable>) -> OSError { OSError(MountError::Remount(err), explain) } } /// The error holder which contains as much information about why failure /// happens as the library implementors could gain /// /// This type only provides `Display` for now, but some programmatic interface /// is expected in future. #[derive(Debug)] pub struct Error(Box<Explainable>, io::Error, String);