apfs 0.2.4

Read-only APFS (Apple File System) parser
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

use criterion::{Criterion, criterion_group, criterion_main};
use std::io::BufReader;

fn open_appfs() -> Option<BufReader<std::fs::File>> {
    let path = std::path::Path::new("../tests/appfs.raw");
    if !path.exists() {
        return None;
    }
    let file = std::fs::File::open(path).ok()?;
    Some(BufReader::new(file))
}

fn bench_open(c: &mut Criterion) {
    if open_appfs().is_none() {
        eprintln!("Skipping benchmarks - appfs.raw not found");
        return;
    }

    c.bench_function("apfs_open", |b| {
        b.iter(|| {
            let reader = open_appfs().unwrap();
            let _vol = apfs::ApfsVolume::open(reader).unwrap();
        })
    });
}

fn bench_list_root(c: &mut Criterion) {
    let reader = match open_appfs() {
        Some(r) => r,
        None => return,
    };

    let mut vol = apfs::ApfsVolume::open(reader).unwrap();

    c.bench_function("apfs_list_root", |b| {
        b.iter(|| {
            let _entries = vol.list_directory("/").unwrap();
        })
    });
}

fn bench_walk_all(c: &mut Criterion) {
    if open_appfs().is_none() {
        return;
    }

    c.bench_function("apfs_walk_all", |b| {
        b.iter(|| {
            let reader = open_appfs().unwrap();
            let mut vol = apfs::ApfsVolume::open(reader).unwrap();
            let _entries = vol.walk().unwrap();
        })
    });
}

fn bench_stat(c: &mut Criterion) {
    let reader = match open_appfs() {
        Some(r) => r,
        None => return,
    };

    let mut vol = apfs::ApfsVolume::open(reader).unwrap();

    // Find a file path to stat
    let walk = vol.walk().unwrap();
    let file_path = walk
        .iter()
        .find(|e| e.entry.kind == apfs::EntryKind::File && e.entry.size > 0)
        .map(|e| e.path.clone());

    if let Some(path) = file_path {
        c.bench_function("apfs_stat", |b| {
            b.iter(|| {
                let _stat = vol.stat(&path).unwrap();
            })
        });
    }
}

fn bench_read_small_file(c: &mut Criterion) {
    let reader = match open_appfs() {
        Some(r) => r,
        None => return,
    };

    let mut vol = apfs::ApfsVolume::open(reader).unwrap();

    // Find a small file to read
    let walk = vol.walk().unwrap();
    let file_path = walk
        .iter()
        .find(|e| {
            e.entry.kind == apfs::EntryKind::File && e.entry.size > 0 && e.entry.size < 100_000
        })
        .map(|e| e.path.clone());

    if let Some(path) = file_path {
        c.bench_function("apfs_read_small_file", |b| {
            b.iter(|| {
                let _data = vol.read_file(&path).unwrap();
            })
        });
    }
}

criterion_group!(
    benches,
    bench_open,
    bench_list_root,
    bench_walk_all,
    bench_stat,
    bench_read_small_file
);
criterion_main!(benches);