ntfs-mac-core 0.1.4

Core library for ntfs-mac: subprocess wrappers around ntfs-3g, diskutil, hdiutil, mkntfs, ntfsfix.
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

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 kodephp contributors

//! NTFS repair. `ntfsfix -d` unmounts the volume, clears the dirty
//! flag and runs a light chkdsk-like pass. `fsck_ntfs` is a heavier
//! alternative.

use std::time::Duration;

use serde::{Deserialize, Serialize};

use crate::Volume;
use crate::error::{Error, Result};
use crate::runner::{RunOptions, run_expect_success};

/// Which fix tool to use.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum FixTool {
    /// Fast: `ntfsfix -d /dev/diskN`.
    #[default]
    Ntfsfix,
    /// Slower, more thorough: `fsck_ntfs /dev/diskN`.
    FsckNtfs,
}

/// Options for `fix`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FixOptions {
    pub tool: FixTool,
    /// Pass the `-d` (drop dirty flag) to ntfsfix.
    #[serde(default = "default_true")]
    pub drop_dirty_flag: bool,
}

impl Default for FixOptions {
    fn default() -> Self {
        Self {
            tool: FixTool::Ntfsfix,
            drop_dirty_flag: true,
        }
    }
}

fn default_true() -> bool {
    true
}

/// Run a repair pass on `vol`.
pub fn fix(vol: &Volume) -> Result<()> {
    fix_with_opts(vol, &FixOptions::default())
}

/// Run a repair pass with explicit options.
pub fn fix_with_opts(vol: &Volume, opts: &FixOptions) -> Result<()> {
    if vol.mounted {
        return Err(Error::InvalidArgument(format!(
            "volume `{}` is mounted at `{}`; unmount before running fix",
            vol.device_identifier,
            vol.mount_point.as_deref().unwrap_or("<unknown>")
        )));
    }
    let dev_path = format!("/dev/{}", vol.device_identifier);
    match opts.tool {
        FixTool::Ntfsfix => {
            let mut args: Vec<String> = Vec::new();
            if opts.drop_dirty_flag {
                args.push("-d".into());
            }
            args.push(dev_path);
            let refs: Vec<&str> = args.iter().map(String::as_str).collect();
            run_expect_success(
                "ntfsfix",
                &refs,
                &RunOptions {
                    timeout: Some(Duration::from_secs(1800)),
                    ..Default::default()
                },
            )?;
        }
        FixTool::FsckNtfs => {
            run_expect_success(
                "fsck_ntfs",
                &[dev_path.as_str()],
                &RunOptions {
                    timeout: Some(Duration::from_secs(3600)),
                    ..Default::default()
                },
            )?;
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn fix_refuses_mounted_volume() {
        let vol = Volume {
            device_identifier: "disk2s2".into(),
            volume_name: "X".into(),
            media_type: "com.microsoft.ntfs".into(),
            uuid: None,
            size_bytes: 0,
            mounted: true,
            mount_point: Some("/Volumes/X".into()),
            parent_disk: None,
            size_pretty: "0 B".into(),
            location: "external".into(),
            contents: None,
        };
        let r = fix(&vol);
        assert!(matches!(r, Err(Error::InvalidArgument(_))));
    }

    #[test]
    fn fix_tool_defaults_to_ntfsfix() {
        let opts = FixOptions::default();
        assert_eq!(opts.tool, FixTool::Ntfsfix);
        assert!(opts.drop_dirty_flag);
    }
}