heim-virt 0.0.11

Cross-platform virtualization system detection
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

use std::marker::Unpin;
use std::path::Path;

#[cfg(any(
    target_arch = "arm",
    target_arch = "aarch64",
    target_arch = "powerpc",
    target_arch = "powerpc64"
))]
use heim_common::prelude::TryFutureExt;
use heim_common::prelude::{future, Future, FutureExt, StreamExt, TryStreamExt};
use heim_runtime::fs;

use crate::Virtualization;

#[allow(unused)]
const DEVICE_TREE_ROOT: &str = "/proc/device-tree";

#[allow(unused)]
const HYPERVISOR_COMPAT_PATH: &str = "/proc/device-tree/hypervisor/compatible";

#[allow(unused)]
fn hypervisor<T>(path: T) -> impl Future<Output = Result<Virtualization, ()>>
where
    T: AsRef<Path> + Send + Unpin + 'static,
{
    fs::read_lines(path)
        .into_stream() // TODO: Looks dumb
        .into_future()
        .map(|(try_line, _)| match try_line {
            Some(Ok(ref line)) if line == "linux,kvm" => Ok(Virtualization::Kvm),
            Some(Ok(ref line)) if line.contains("xen") => Ok(Virtualization::Xen),
            Some(Ok(..)) => Ok(Virtualization::Unknown),
            _ => Err(()),
        })
}

#[allow(unused)]
fn device_tree<T>(path: T) -> impl Future<Output = Result<Virtualization, ()>>
where
    T: AsRef<Path> + Send + Unpin + 'static,
{
    fs::read_dir(path)
        .try_filter(|entry| {
            let matched = match entry.file_name().to_str() {
                Some(file_name) if file_name.contains("fw-cfg") => true,
                _ => false,
            };
            future::ready(matched)
        })
        .into_stream()
        .into_future()
        .map(|(res, _)| match res {
            Some(..) => Ok(Virtualization::Qemu),
            None => Err(()),
        })
}

#[cfg(any(
    target_arch = "arm",
    target_arch = "aarch64",
    target_arch = "powerpc",
    target_arch = "powerpc64"
))]
pub fn detect_vm_device_tree() -> impl Future<Output = Result<Virtualization, ()>> {
    hypervisor(HYPERVISOR_COMPAT_PATH).or_else(|_| device_tree(DEVICE_TREE_ROOT))
}

#[cfg(not(any(
    target_arch = "arm",
    target_arch = "aarch64",
    target_arch = "powerpc",
    target_arch = "powerpc64"
)))]
pub fn detect_vm_device_tree() -> impl Future<Output = Result<Virtualization, ()>> {
    future::err(())
}

#[cfg(test)]
mod tests {
    use super::hypervisor;
    use crate::Virtualization;
    use std::io::Write;

    #[heim_derive::test]
    async fn test_kvm() {
        let mut f = tempfile::NamedTempFile::new().unwrap();

        f.write_all(b"linux,kvm\nsome,other,stuff").unwrap();

        let result = hypervisor(f).await;

        assert_eq!(Ok(Virtualization::Kvm), result);
    }

    #[heim_derive::test]
    async fn test_xen() {
        let mut f = tempfile::NamedTempFile::new().unwrap();

        f.write_all(b"thereis,xen").unwrap();

        let result = hypervisor(f).await;

        assert_eq!(Ok(Virtualization::Xen), result);
    }

    #[heim_derive::test]
    async fn test_unknown() {
        let mut f = tempfile::NamedTempFile::new().unwrap();

        f.write_all(b"nes-emulator").unwrap();

        let result = hypervisor(f).await;

        assert_eq!(Ok(Virtualization::Unknown), result);
    }
}