btrfs-uapi 0.12.0

Wrappers around the btrfs userspace interface (ioctls and sysfs)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

use crate::common::{
    BackingFile, LoopbackDevice, Mount, single_mount, write_test_data,
};
use btrfs_uapi::{
    balance::{BalanceFlags, balance},
    device::{
        DeviceSpec, device_add, device_info, device_info_all, device_min_size,
        device_ready, device_remove, device_scan, device_stats,
    },
    filesystem::{filesystem_info, sync},
};
use std::ffi::CString;

/// Adding and removing a device should change the device count accordingly.
#[test]
#[ignore = "requires elevated privileges"]
fn device_add_remove() {
    let td = tempfile::tempdir().unwrap();
    let f1 = BackingFile::new(td.path(), "d1.img", 300_000_000);
    f1.mkfs();
    let lo1 = LoopbackDevice::new(f1);
    let mnt = Mount::new(lo1, td.path());

    let info_before =
        filesystem_info(mnt.fd()).expect("filesystem_info failed");
    assert_eq!(info_before.num_devices, 1);

    // Add second device.
    let f2 = BackingFile::new(td.path(), "d2.img", 300_000_000);
    let lo2 = LoopbackDevice::new(f2);
    let dev2_cpath = CString::new(lo2.path().to_str().unwrap()).unwrap();
    device_add(mnt.fd(), &dev2_cpath).expect("device_add failed");

    let info_after_add =
        filesystem_info(mnt.fd()).expect("filesystem_info after add failed");
    assert_eq!(info_after_add.num_devices, 2);

    let devs = device_info_all(mnt.fd(), &info_after_add)
        .expect("device_info_all failed");
    assert_eq!(devs.len(), 2);

    // Balance to single profile so all data is on one device, allowing removal.
    let flags =
        BalanceFlags::DATA | BalanceFlags::METADATA | BalanceFlags::SYSTEM;
    balance(mnt.fd(), flags, None, None, None).expect("balance failed");

    // Remove second device by path.
    device_remove(mnt.fd(), &DeviceSpec::Path(&dev2_cpath))
        .expect("device_remove failed");

    let info_after_remove =
        filesystem_info(mnt.fd()).expect("filesystem_info after remove failed");
    assert_eq!(info_after_remove.num_devices, 1);
}

/// device_info should return valid info and device_stats should report zero
/// errors on a healthy filesystem.
#[test]
#[ignore = "requires elevated privileges"]
fn device_info_and_stats() {
    let (_td, mnt) = single_mount();

    write_test_data(mnt.path(), "data.bin", 10_000_000);
    sync(mnt.fd()).unwrap();

    let info = device_info(mnt.fd(), 1)
        .expect("device_info failed")
        .expect("device 1 should exist");
    assert_eq!(info.devid, 1);
    assert!(info.total_bytes > 0, "total_bytes should be > 0");
    assert!(!info.path.is_empty(), "device path should not be empty");

    let stats = device_stats(mnt.fd(), 1, false).expect("device_stats failed");
    assert!(
        stats.is_clean(),
        "healthy filesystem should have zero errors: {stats:?}"
    );

    // Reset and re-read — should still be zero.
    let _reset =
        device_stats(mnt.fd(), 1, true).expect("device_stats reset failed");
    let after_reset = device_stats(mnt.fd(), 1, false)
        .expect("device_stats after reset failed");
    assert!(
        after_reset.is_clean(),
        "stats after reset should be zero: {after_reset:?}"
    );
}

/// device_scan and device_ready should succeed on a formatted loop device.
#[test]
#[ignore = "requires elevated privileges"]
fn device_scan_and_ready() {
    let td = tempfile::tempdir().unwrap();
    let f = BackingFile::new(td.path(), "disk.img", 300_000_000);
    f.mkfs();
    let lo = LoopbackDevice::new(f);

    let dev_cpath = CString::new(lo.path().to_str().unwrap()).unwrap();
    device_scan(&dev_cpath).expect("device_scan failed");
    device_ready(&dev_cpath).expect("device_ready failed");
}

/// Removing a device by its devid should work.
#[test]
#[ignore = "requires elevated privileges"]
fn device_remove_by_devid() {
    let td = tempfile::tempdir().unwrap();
    let f1 = BackingFile::new(td.path(), "d1.img", 300_000_000);
    f1.mkfs();
    let lo1 = LoopbackDevice::new(f1);
    let mnt = Mount::new(lo1, td.path());

    let f2 = BackingFile::new(td.path(), "d2.img", 300_000_000);
    let lo2 = LoopbackDevice::new(f2);
    let dev2_cpath = CString::new(lo2.path().to_str().unwrap()).unwrap();
    device_add(mnt.fd(), &dev2_cpath).expect("device_add failed");

    // Balance so data is on device 1, then remove device 2 by ID.
    let flags =
        BalanceFlags::DATA | BalanceFlags::METADATA | BalanceFlags::SYSTEM;
    balance(mnt.fd(), flags, None, None, None).expect("balance failed");

    let info = filesystem_info(mnt.fd()).expect("filesystem_info failed");
    let devs =
        device_info_all(mnt.fd(), &info).expect("device_info_all failed");
    let dev2 = devs
        .iter()
        .find(|d| d.devid != 1)
        .expect("should have a second device");

    device_remove(mnt.fd(), &DeviceSpec::Id(dev2.devid))
        .expect("device_remove by id failed");

    let info_after =
        filesystem_info(mnt.fd()).expect("filesystem_info after remove failed");
    assert_eq!(info_after.num_devices, 1);
}

/// device_min_size should return a sensible value and increase after writing data.
#[test]
#[ignore = "requires elevated privileges"]
fn dev_extent_min_size_single() {
    let td = tempfile::tempdir().unwrap();
    let f = BackingFile::new(td.path(), "disk.img", 500_000_000);
    f.mkfs();
    let lo = LoopbackDevice::new(f);
    let mnt = Mount::new(lo, td.path());

    write_test_data(mnt.path(), "data1.bin", 100_000_000);
    sync(mnt.fd()).unwrap();

    let min1 = device_min_size(mnt.fd(), 1).expect("device_min_size failed");
    assert!(min1 > 0, "device_min_size should be > 0");
    assert!(
        min1 <= 500_000_000,
        "device_min_size should be <= device size"
    );

    write_test_data(mnt.path(), "data2.bin", 200_000_000);
    sync(mnt.fd()).unwrap();

    let min2 = device_min_size(mnt.fd(), 1)
        .expect("device_min_size after more data failed");
    assert!(
        min2 >= min1,
        "device_min_size should not decrease after writing more data: before={min1}, after={min2}",
    );
}

/// device_min_size on both devices of a two-device filesystem should return
/// sensible values.
#[test]
#[ignore = "requires elevated privileges"]
fn dev_extent_min_size_multi() {
    let td = tempfile::tempdir().unwrap();
    let f1 = BackingFile::new(td.path(), "d1.img", 300_000_000);
    f1.mkfs();
    let lo1 = LoopbackDevice::new(f1);
    let mnt = Mount::new(lo1, td.path());

    let f2 = BackingFile::new(td.path(), "d2.img", 400_000_000);
    let lo2 = LoopbackDevice::new(f2);
    let dev2_cpath = CString::new(lo2.path().to_str().unwrap()).unwrap();
    device_add(mnt.fd(), &dev2_cpath).expect("device_add failed");

    write_test_data(mnt.path(), "data.bin", 50_000_000);
    sync(mnt.fd()).unwrap();

    let min1 =
        device_min_size(mnt.fd(), 1).expect("device_min_size dev 1 failed");
    let min2 =
        device_min_size(mnt.fd(), 2).expect("device_min_size dev 2 failed");

    assert!(min1 > 0, "device_min_size for dev 1 should be > 0");
    assert!(min2 > 0, "device_min_size for dev 2 should be > 0");
    assert!(
        min1 <= 300_000_000,
        "device_min_size for dev 1 should be <= its size: {min1}",
    );
    assert!(
        min2 <= 400_000_000,
        "device_min_size for dev 2 should be <= its size: {min2}",
    );
}