axvm 0.5.26

Virtual Machine resource management crate for ArceOS's hypervisor variant.
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

//! Serial-device facts derived from the resolved x86 device graph.

use std::{
    format,
    string::{String, ToString},
    vec::Vec,
};

use axdevice::*;

use super::config::X86FirmwarePlanError;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum X86SerialRegisters {
    Port { base: u16, size: u16 },
    Mmio { base: u32, size: u32 },
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct X86SerialPlan {
    pub(super) name: String,
    pub(super) namespace_path: Option<String>,
    pub(super) hid: String,
    pub(super) interface_type: u8,
    pub(super) registers: X86SerialRegisters,
    pub(super) irq: u32,
    pub(super) clock_hz: u32,
}

pub(super) fn x86_serial_plans(
    graph: &ResolvedDeviceGraph,
) -> Result<Vec<X86SerialPlan>, X86FirmwarePlanError> {
    let mut serials = crate::machine::resolved_serial_devices(graph).map_err(|error| {
        X86FirmwarePlanError::InvalidValue {
            field: "serial device graph",
            value: error.to_string(),
        }
    })?;
    serials.sort_by_key(|serial| (serial.id() != "console0", serial.id().to_string()));
    if serials
        .first()
        .is_none_or(|serial| serial.id() != "console0")
    {
        return Err(X86FirmwarePlanError::MissingDevice {
            node_id: "console0",
        });
    }
    serials
        .into_iter()
        .enumerate()
        .map(|(index, serial)| serial_plan(index, serial))
        .collect()
}

fn serial_plan(
    index: usize,
    serial: crate::machine::ResolvedSerialDevice,
) -> Result<X86SerialPlan, X86FirmwarePlanError> {
    let profile = serial.profile();
    let registers = match profile.transport {
        crate::machine::GuestSerialTransport::Port { base, length } => {
            X86SerialRegisters::Port { base, size: length }
        }
        crate::machine::GuestSerialTransport::Mmio { base, length, .. } => {
            X86SerialRegisters::Mmio {
                base: u32::try_from(base)
                    .map_err(|_| invalid_serial_value("serial MMIO base", base))?,
                size: u32::try_from(length)
                    .map_err(|_| invalid_serial_value("serial MMIO size", length))?,
            }
        }
    };
    let (generated_name, hid, interface_type) = match profile.model {
        crate::machine::GuestSerialModel::Uart16550 => {
            (format!("COM{}", index + 1), "PNP0501".into(), 0)
        }
        crate::machine::GuestSerialModel::Pl011 => (format!("URT{index}"), "ARMH0011".into(), 3),
    };
    let namespace_path = match serial.firmware_binding() {
        DeviceFirmwareBinding::AcpiDevice(path) => Some(path.clone()),
        _ => None,
    };
    let name = namespace_path
        .as_deref()
        .and_then(|path| path.rsplit(['.', '\\']).find(|part| !part.is_empty()))
        .unwrap_or(&generated_name)
        .into();
    Ok(X86SerialPlan {
        name,
        namespace_path,
        hid,
        interface_type,
        registers,
        irq: u32::try_from(profile.irq)
            .map_err(|_| invalid_serial_value("serial IRQ", profile.irq))?,
        clock_hz: profile.clock_hz,
    })
}

fn invalid_serial_value(
    field: &'static str,
    value: impl core::fmt::LowerHex,
) -> X86FirmwarePlanError {
    X86FirmwarePlanError::InvalidValue {
        field,
        value: format!("{value:#x}"),
    }
}