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

use crate::common::{
    BackingFile, LoopbackDevice, Mount, single_mount, write_test_data,
};
use btrfs_uapi::{
    filesystem::sync,
    scrub::{scrub_cancel, scrub_start},
};
use nix::errno::Errno;
use std::{fs::File, os::unix::io::AsFd};

/// A scrub on a healthy filesystem with data should complete with bytes
/// scrubbed and zero errors.
#[test]
#[ignore = "requires elevated privileges"]
fn scrub_healthy() {
    let (_td, mnt) = single_mount();

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

    let progress = scrub_start(mnt.fd(), 1, false).expect("scrub_start failed");

    assert!(
        progress.data_bytes_scrubbed > 0,
        "should have scrubbed some data bytes: {progress:?}",
    );
    assert!(
        progress.is_clean(),
        "healthy filesystem should have zero errors: {progress:?}"
    );
}

/// A readonly scrub should complete without errors and not modify data.
#[test]
#[ignore = "requires elevated privileges"]
fn scrub_readonly() {
    let (_td, mnt) = single_mount();

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

    let progress =
        scrub_start(mnt.fd(), 1, true).expect("scrub_start readonly failed");

    assert!(
        progress.data_bytes_scrubbed > 0,
        "readonly scrub should still scrub data: {progress:?}",
    );
    assert!(
        progress.is_clean(),
        "readonly scrub should have zero errors: {progress:?}"
    );

    // Data should still be intact.
    crate::common::verify_test_data(mnt.path(), "data.bin", 10_000_000);
}

/// Cancelling a running scrub should succeed.
#[test]
#[ignore = "requires elevated privileges"]
fn scrub_cancel_test() {
    let td = tempfile::tempdir().unwrap();
    let f = BackingFile::new(td.path(), "disk.img", 512_000_000);
    f.mkfs();
    let lo = LoopbackDevice::new(f);
    let mnt = Mount::new(lo, td.path());

    // Write enough data so the scrub takes a moment.
    write_test_data(mnt.path(), "data.bin", 200_000_000);
    sync(mnt.fd()).unwrap();

    // Start scrub in a background thread (scrub_start blocks).
    let mount_path = mnt.path().to_path_buf();
    let scrub_thread = std::thread::spawn(move || {
        let file =
            File::open(&mount_path).expect("open mount in thread failed");
        scrub_start(file.as_fd(), 1, false)
    });

    std::thread::sleep(std::time::Duration::from_millis(100));

    // Cancel — may return ENOTCONN if scrub already finished.
    match scrub_cancel(mnt.fd()) {
        Ok(()) => {}
        Err(Errno::ENOTCONN) => {}
        Err(e) => panic!("unexpected error from scrub_cancel: {e}"),
    }

    // The scrub thread should complete (either finished or cancelled).
    let result = scrub_thread.join().expect("scrub thread panicked");
    match result {
        Ok(progress) => {
            // Scrub completed (possibly partially).
            assert!(
                progress.bytes_scrubbed() > 0,
                "should have scrubbed something"
            );
        }
        Err(Errno::ECANCELED) => { /* expected */ }
        Err(e) => panic!("scrub returned unexpected error: {e}"),
    }
}