btrfs-uapi 0.13.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

use crate::common::{single_mount, write_test_data};
use btrfs_uapi::{
    fiemap::file_extents,
    filesystem::sync,
    subvolume::{snapshot_create, subvolume_create},
};
use std::{ffi::CStr, fs::File, os::unix::io::AsFd, process::Command};

/// file_extents on a regular file should report non-zero total bytes and zero
/// shared bytes when no snapshots or reflinks exist.
#[test]
#[ignore = "requires elevated privileges"]
fn fiemap_basic() {
    let (_td, mnt) = single_mount();

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

    let file = File::open(mnt.path().join("data.bin")).expect("open failed");
    let info = file_extents(file.as_fd()).expect("file_extents failed");

    assert!(info.total_bytes > 0, "total_bytes should be > 0: {info:?}");
    assert_eq!(
        info.shared_bytes, 0,
        "shared_bytes should be 0 without snapshots: {info:?}"
    );
}

/// After snapshotting a subvolume, file_extents should report shared bytes for
/// files that exist in both the original and the snapshot.
#[test]
#[ignore = "requires elevated privileges"]
fn fiemap_shared_after_snapshot() {
    let (_td, mnt) = single_mount();

    // Create a subvolume and write data into it.
    let subvol_name = CStr::from_bytes_with_nul(b"origin\0").unwrap();
    subvolume_create(mnt.fd(), subvol_name, &[])
        .expect("subvolume_create failed");

    write_test_data(&mnt.path().join("origin"), "data.bin", 5_000_000);
    sync(mnt.fd()).unwrap();

    // Snapshot the subvolume.
    let snap_name = CStr::from_bytes_with_nul(b"snap\0").unwrap();
    let origin_dir =
        File::open(mnt.path().join("origin")).expect("open origin failed");
    snapshot_create(mnt.fd(), origin_dir.as_fd(), snap_name, false, &[])
        .expect("snapshot_create failed");
    sync(mnt.fd()).unwrap();

    // The file in the original subvolume should now have shared extents.
    let file = File::open(mnt.path().join("origin").join("data.bin"))
        .expect("open data failed");
    let info = file_extents(file.as_fd()).expect("file_extents failed");

    assert!(info.total_bytes > 0, "total_bytes should be > 0: {info:?}");
    assert!(
        info.shared_bytes > 0,
        "shared_bytes should be > 0 after snapshot: {info:?}",
    );
}

/// After reflinking a file, file_extents should report shared bytes.
#[test]
#[ignore = "requires elevated privileges"]
fn fiemap_shared_after_reflink() {
    let (_td, mnt) = single_mount();

    write_test_data(mnt.path(), "original.bin", 5_000_000);
    sync(mnt.fd()).unwrap();

    // cp --reflink creates a CoW copy that shares all extents.
    let original = mnt.path().join("original.bin");
    let reflinked = mnt.path().join("reflinked.bin");
    let output = Command::new("cp")
        .args(["--reflink=always"])
        .arg(&original)
        .arg(&reflinked)
        .output()
        .expect("failed to run cp");
    assert!(
        output.status.success(),
        "cp --reflink failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );

    sync(mnt.fd()).unwrap();

    let file = File::open(&original).expect("open original failed");
    let info = file_extents(file.as_fd()).expect("file_extents failed");

    assert!(info.total_bytes > 0, "total_bytes should be > 0: {info:?}");
    assert!(
        info.shared_bytes > 0,
        "shared_bytes should be > 0 after reflink: {info:?}",
    );
}