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

//! RISC-V PLIC firmware parsing and guest register installation.

use fdt_edit::{Fdt, NodeId, Property};
use fdt_raw::RegInfo;

use super::{super::tree::FdtTree, phandle, phandle::prop_u32};
use crate::{AxVmResult, ax_err_type, machine::GuestPlicProfile};

/// Reads the host PLIC register window and firmware identity.
pub(crate) fn host_plic_profile(fdt: &Fdt) -> AxVmResult<Option<GuestPlicProfile>> {
    let Some(controller) = find_in_fdt(fdt) else {
        return Ok(None);
    };
    let view = fdt
        .view_typed(controller)
        .ok_or_else(|| ax_err_type!(InvalidData, "host PLIC node is missing"))?;
    let reg = view
        .regs()
        .into_iter()
        .next()
        .ok_or_else(|| ax_err_type!(InvalidData, "host PLIC node has no register range"))?;
    let (base, length) = checked_reg(&reg)?;
    let node = view.as_node();

    Ok(Some(GuestPlicProfile {
        node_path: fdt.path_of(controller),
        node_phandle: node
            .get_property("phandle")
            .or_else(|| node.get_property("linux,phandle"))
            .and_then(Property::get_u32),
        base,
        length,
    }))
}

pub(super) fn install_registers(tree: &mut FdtTree, profile: &GuestPlicProfile) -> AxVmResult {
    let controller = tree
        .inner()
        .get_by_path_id(&profile.node_path)
        .or_else(|| find(tree))
        .ok_or_else(|| {
            ax_err_type!(
                InvalidData,
                "guest FDT has no PLIC interrupt-controller node"
            )
        })?;
    tree.inner_mut()
        .view_typed_mut(controller)
        .ok_or_else(|| ax_err_type!(InvalidData, "guest PLIC node is missing"))?
        .set_regs(&[RegInfo::new(
            profile.base as u64,
            Some(profile.length as u64),
        )]);
    tree.set_property(controller, prop_u32("#interrupt-cells", 1))?;
    if let Some(value) = profile.node_phandle {
        phandle::install(tree, controller, value, "PLIC")?;
    }
    Ok(())
}

fn checked_reg(reg: &fdt_edit::RegFixed) -> AxVmResult<(usize, usize)> {
    let base = usize::try_from(reg.address)
        .map_err(|_| ax_err_type!(InvalidData, "host PLIC address does not fit usize"))?;
    let length = reg
        .size
        .ok_or_else(|| ax_err_type!(InvalidData, "host PLIC range has no size"))
        .and_then(|length| {
            usize::try_from(length)
                .map_err(|_| ax_err_type!(InvalidData, "host PLIC range size does not fit usize"))
        })?;
    if length == 0 {
        return Err(ax_err_type!(InvalidData, "host PLIC range is empty"));
    }
    Ok((base, length))
}

fn find(tree: &FdtTree) -> Option<NodeId> {
    find_in_fdt(tree.inner())
}

fn find_in_fdt(fdt: &Fdt) -> Option<NodeId> {
    fdt.iter_node_ids().find(|node_id| {
        fdt.node(*node_id).is_some_and(|node| {
            node.get_property("interrupt-controller").is_some()
                && node
                    .compatibles()
                    .any(|compatible| matches!(compatible, "riscv,plic0" | "sifive,plic-1.0.0"))
        })
    })
}