microsandbox-filesystem 0.3.13

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
109
110
111
112

use super::*;
use crate::agentd::AGENTD_BYTES;

#[test]
fn test_init_krun_lookup() {
    let sb = MemFsTestSandbox::new();
    let entry = sb.lookup_root("init.krun").unwrap();
    assert_eq!(entry.inode, INIT_INODE);
    let mode = entry.attr.st_mode as u32;
    assert_eq!(mode & libc::S_IFMT as u32, libc::S_IFREG as u32);
    assert_eq!(mode & 0o777, 0o755);
    assert_eq!(entry.attr.st_size, AGENTD_BYTES.len() as i64);
}

#[test]
fn test_init_krun_open_and_read() {
    let sb = MemFsTestSandbox::new();
    let (handle, opts) = sb
        .fs
        .open(
            MemFsTestSandbox::ctx(),
            INIT_INODE,
            false,
            libc::O_RDONLY as u32,
        )
        .unwrap();
    assert_eq!(handle, Some(0)); // INIT_HANDLE = 0
    assert_eq!(opts, OpenOptions::KEEP_CACHE);

    let data = sb
        .fuse_read(INIT_INODE, 0, AGENTD_BYTES.len() as u32, 0)
        .unwrap();
    assert_eq!(data.len(), AGENTD_BYTES.len());
    assert_eq!(&data[..], AGENTD_BYTES);
}

#[test]
fn test_init_krun_partial_read() {
    let sb = MemFsTestSandbox::new();
    let offset = 100u64;
    let size = 64u32;
    let data = sb.fuse_read(INIT_INODE, 0, size, offset).unwrap();
    assert_eq!(data.len(), size as usize);
    assert_eq!(
        &data[..],
        &AGENTD_BYTES[offset as usize..offset as usize + size as usize]
    );
}

#[test]
fn test_init_krun_write_fails() {
    let sb = MemFsTestSandbox::new();
    let mut reader = MockZeroCopyReader::new(vec![0u8; 10]);
    let result = sb.fs.write(
        MemFsTestSandbox::ctx(),
        INIT_INODE,
        0, // INIT_HANDLE
        &mut reader,
        10,
        0,
        None,
        false,
        false,
        0,
    );
    MemFsTestSandbox::assert_errno(result, LINUX_EACCES);
}

#[test]
fn test_init_krun_unlink_fails() {
    let sb = MemFsTestSandbox::new();
    let result = sb.fs.unlink(
        MemFsTestSandbox::ctx(),
        ROOT_INODE,
        &MemFsTestSandbox::cstr("init.krun"),
    );
    MemFsTestSandbox::assert_errno(result, LINUX_EACCES);
}

#[test]
fn test_init_krun_setattr_fails() {
    let sb = MemFsTestSandbox::new();
    let attr: stat64 = unsafe { std::mem::zeroed() };
    let result = sb.fs.setattr(
        MemFsTestSandbox::ctx(),
        INIT_INODE,
        attr,
        None,
        SetattrValid::MODE,
    );
    MemFsTestSandbox::assert_errno(result, LINUX_EACCES);
}

#[test]
fn test_init_krun_getattr() {
    let sb = MemFsTestSandbox::new();
    let (st, _) = sb
        .fs
        .getattr(MemFsTestSandbox::ctx(), INIT_INODE, None)
        .unwrap();
    assert_eq!(st.st_ino, INIT_INODE);
    assert_eq!(st.st_uid, 0);
    assert_eq!(st.st_gid, 0);
    assert_eq!(st.st_size, AGENTD_BYTES.len() as i64);
    let mode = st.st_mode as u32;
    assert_eq!(mode & libc::S_IFMT as u32, libc::S_IFREG as u32);
    assert_eq!(mode & 0o777, 0o755);
    #[cfg(target_os = "linux")]
    assert_eq!(st.st_nlink, 1);
    #[cfg(target_os = "macos")]
    assert_eq!(st.st_nlink, 1);
}