btrfs-cli 0.12.0

User-space command-line tool for inspecting and managing Btrfs filesystems
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

use crate::{
    RunContext, Runnable,
    util::{open_path, parse_qgroupid},
};
use anyhow::{Context, Result, bail};
use btrfs_uapi::quota::qgroupid_level;
use clap::Parser;
use nix::errno::Errno;
use std::{os::unix::io::AsFd, path::PathBuf};

/// Assign a qgroup as the child of another qgroup
#[derive(Parser, Debug)]
pub struct QgroupAssignCommand {
    /// Source qgroup id (e.g. "0/5")
    pub src: String,
    /// Destination qgroup id (e.g. "1/0")
    pub dst: String,
    /// Path to a mounted btrfs filesystem
    pub path: PathBuf,
    /// Schedule a quota rescan if needed (default)
    #[clap(long, conflicts_with = "no_rescan")]
    pub rescan: bool,
    /// Do not schedule a quota rescan
    #[clap(long)]
    pub no_rescan: bool,
}

impl Runnable for QgroupAssignCommand {
    fn run(&self, _ctx: &RunContext) -> Result<()> {
        let src = parse_qgroupid(&self.src)?;
        let dst = parse_qgroupid(&self.dst)?;

        if qgroupid_level(src) >= qgroupid_level(dst) {
            bail!(
                "source qgroup '{}' must be at a lower level than destination qgroup '{}'",
                self.src,
                self.dst
            );
        }

        let file = open_path(&self.path)?;
        let fd = file.as_fd();

        let needs_rescan = match btrfs_uapi::quota::qgroup_assign(fd, src, dst)
        {
            Ok(needs_rescan) => needs_rescan,
            Err(Errno::ENOTCONN) => {
                bail!("quota not enabled on '{}'", self.path.display())
            }
            Err(e) => {
                return Err(e).with_context(|| {
                    format!(
                        "failed to assign qgroup '{}' to '{}' on '{}'",
                        self.src,
                        self.dst,
                        self.path.display()
                    )
                });
            }
        };

        // Default behaviour (neither flag given) is to rescan.
        let do_rescan = !self.no_rescan;

        if needs_rescan {
            if do_rescan {
                btrfs_uapi::quota::quota_rescan(fd).with_context(|| {
                    format!(
                        "failed to schedule quota rescan on '{}'",
                        self.path.display()
                    )
                })?;
                println!("Quota data changed, rescan scheduled");
            } else {
                eprintln!(
                    "WARNING: quotas may be inconsistent, rescan needed on '{}'",
                    self.path.display()
                );
            }
        }

        Ok(())
    }
}