libbtrfs 0.0.30

Rust library for working with the btrfs filesystem
Documentation 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

#![allow(unused_macros)]

macro_rules! copy_bytes_to_slice {
    ($bytes:expr, $dst:expr) => {
        if $bytes.len() > $dst.len() {
            true // too long return true
        } else {
            let _: &[u8] = $bytes;
            let src: *const u8 = $bytes.as_ptr().cast();
            let dst: *mut u8 = $dst.as_mut_ptr().cast();
            let len: usize = $bytes.len();
            unsafe {
                ::std::ptr::copy_nonoverlapping(src, dst, len);
            }
            false // success return false
        }
    };
}

macro_rules! error {
    ( $kind:ident ) => {
        Err(::std::io::Error::from(::std::io::ErrorKind::$kind))
    };
}

// for implmeting iterator next trait
macro_rules! try_or_some_err {
    ($expr:expr $(,)?) => {
        match $expr {
            ::std::result::Result::Ok(val) => val,
            ::std::result::Result::Err(err) => {
                return Some(::std::result::Result::Err(::std::convert::From::from(err)));
            }
        }
    };
}

macro_rules! syscall {
    ($name:ident($( $args:expr ),* $(,)?)) => {
        {
            #[cfg(not(feature = "use-syscalls"))]
            match ::libc::$name($( $args ),*) {
                -1 => Err(::std::io::Error::last_os_error()),
                res => Ok(res)
            }

            #[cfg(feature = "use-syscalls")]
            match __use_syscalls!($name($( $args ),*)) {
                Err(e) => Err(::std::io::Error::from_raw_os_error(e.into_raw())),
                Ok(res) => Ok(res as ::libc::c_int),
            }
        }
    };

    (unsafe { $name:ident( $( $args:expr ),*  $(,)?) }) => {
        unsafe { syscall!($name($( $args ),*)) }
    };
}

// syscall signature definitions to match libc
#[cfg(feature = "use-syscalls")]
macro_rules! __use_syscalls {
    (fstat ($fd:expr, $statbuf:expr)) => {
        ::syscalls::syscall!(
            ::syscalls::Sysno::fstat,
            $fd as ::libc::c_int,
            $statbuf as *mut ::libc::stat
        )
    };

    (fstatfs ($fd:expr, $buf:expr)) => {
        ::syscalls::syscall!(
            ::syscalls::Sysno::fstatfs,
            $fd as ::libc::c_int,
            $buf as *mut ::libc::statfs
        )
    };

    (ioctl ($fd:expr, $op:expr, $argp:expr)) => {
        ::syscalls::syscall!(
            ::syscalls::Sysno::ioctl,
            $fd as ::libc::c_int,
            $op as ::libc::Ioctl,
            $argp as *mut _
        )
    };

    (open ($path:expr, $flags:expr)) => {
        ::syscalls::syscall!(
            ::syscalls::Sysno::open,
            $path as *const ::libc::c_char,
            $flags as ::libc::c_int
        )
    };
    (open ($path:expr, $flags:expr, $mode:expr)) => {
        ::syscalls::syscall!(
            ::syscalls::Sysno::open,
            $path as *const ::libc::c_char,
            $flags as ::libc::c_int,
            $mode as ::libc::mode_t
        )
    };

    (openat ($dirfd:expr, $path:expr, $flags:expr)) => {
        ::syscalls::syscall!(
            ::syscalls::Sysno::openat,
            $dirfd as ::libc::c_int,
            $path as *const ::libc::c_char,
            $flags as ::libc::c_int
        )
    };
    (openat ($dirfd:expr, $path:expr, $flags:expr, $mode:expr)) => {
        ::syscalls::syscall!(
            ::syscalls::Sysno::openat,
            $dirfd as ::libc::c_int,
            $path as *const ::libc::c_char,
            $flags as ::libc::c_int,
            $mode as ::libc::mode_t
        )
    };

    (statfs ($path:expr, $buf:expr)) => {
        ::syscalls::syscall!(
            ::syscalls::Sysno::statfs,
            $path as *const ::libc::c_char,
            $buf as *mut ::libc::statfs
        )
    };
}