microsandbox-filesystem 0.4.5

Filesystem backends and guest filesystem support for microsandbox.
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

use std::sync::atomic::Ordering;

use super::*;

#[test]
fn test_build_default() {
    let fs = MemFs::builder().build().unwrap();
    fs.init(FsOptions::empty()).unwrap();
    let (st, _) = fs
        .getattr(MemFsTestSandbox::ctx(), ROOT_INODE, None)
        .unwrap();
    assert_eq!(
        st.st_mode as u32 & libc::S_IFMT as u32,
        libc::S_IFDIR as u32
    );
}

#[test]
fn test_build_with_capacity() {
    let fs = MemFs::builder().capacity(1024 * 1024).build().unwrap();
    assert_eq!(fs.cfg.capacity, Some(1024 * 1024));
}

#[test]
fn test_build_with_max_inodes() {
    let fs = MemFs::builder().max_inodes(500).build().unwrap();
    assert_eq!(fs.cfg.max_inodes, Some(500));
}

#[test]
fn test_build_with_cache_policy_never() {
    let fs = MemFs::builder()
        .cache_policy(CachePolicy::Never)
        .build()
        .unwrap();
    assert_eq!(fs.cfg.cache_policy, CachePolicy::Never);
}

#[test]
fn test_build_with_cache_policy_auto() {
    let fs = MemFs::builder()
        .cache_policy(CachePolicy::Auto)
        .build()
        .unwrap();
    assert_eq!(fs.cfg.cache_policy, CachePolicy::Auto);
}

#[test]
fn test_build_with_cache_policy_always() {
    let fs = MemFs::builder()
        .cache_policy(CachePolicy::Always)
        .build()
        .unwrap();
    assert_eq!(fs.cfg.cache_policy, CachePolicy::Always);
}

#[test]
fn test_init_negotiates_features() {
    let fs = MemFs::builder().build().unwrap();
    let caps = FsOptions::ASYNC_READ | FsOptions::BIG_WRITES | FsOptions::HANDLE_KILLPRIV_V2;
    let opts = fs.init(caps).unwrap();
    assert!(opts.contains(FsOptions::ASYNC_READ));
    assert!(opts.contains(FsOptions::BIG_WRITES));
    assert!(opts.contains(FsOptions::HANDLE_KILLPRIV_V2));
}

#[test]
fn test_init_writeback() {
    let fs = MemFs::builder().writeback(true).build().unwrap();
    let opts = fs.init(FsOptions::WRITEBACK_CACHE).unwrap();
    assert!(opts.contains(FsOptions::WRITEBACK_CACHE));
    assert!(fs.writeback.load(Ordering::Relaxed));
}

#[test]
fn test_init_no_writeback() {
    let fs = MemFs::builder().writeback(false).build().unwrap();
    let opts = fs.init(FsOptions::WRITEBACK_CACHE).unwrap();
    assert!(!opts.contains(FsOptions::WRITEBACK_CACHE));
    assert!(!fs.writeback.load(Ordering::Relaxed));
}

#[test]
fn test_root_exists_after_init() {
    let sb = MemFsTestSandbox::new();
    let (st, _) = sb
        .fs
        .getattr(MemFsTestSandbox::ctx(), ROOT_INODE, None)
        .unwrap();
    let mode = st.st_mode as u32;
    assert_eq!(mode & libc::S_IFMT as u32, libc::S_IFDIR as u32);
    assert_eq!(mode & 0o777, 0o755);
    assert_eq!(st.st_uid, 0);
    assert_eq!(st.st_gid, 0);
}

#[test]
fn test_root_nlink() {
    let sb = MemFsTestSandbox::new();
    let (st, _) = sb
        .fs
        .getattr(MemFsTestSandbox::ctx(), ROOT_INODE, None)
        .unwrap();
    #[cfg(target_os = "linux")]
    assert_eq!(st.st_nlink, 2);
    #[cfg(target_os = "macos")]
    assert_eq!(st.st_nlink, 2);
}