axvm 0.6.0

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Configured constructor for Axvisor IVC channel metadata.

use std::sync::Arc;

use axdevice::*;
use axdevice_base::{InterruptControllerId, InterruptSharing, InterruptTrigger};
use axvmconfig::VirtualDeviceRequest;

use crate::{
    ConfiguredDeviceError, ConfiguredModelRegistration, DeviceInstantiationContext,
    FixedDeviceBindings, runtime::ivc,
};

const REGISTERS_SLOT: &str = "registers";
const NOTIFY_IRQ_SLOT: &str = "notify";
pub(crate) const IVC_CHANNEL_SHARED_RANGE_SIZE: u64 = 0x1_0000;

pub(crate) const IVC_REGISTRATIONS: &[ConfiguredModelRegistration] =
    &[ConfiguredModelRegistration {
        model: "ivc-channel",
        create: create_ivc_channel,
        default_fixed_resources: None,
    }];

fn request_error(
    request: &VirtualDeviceRequest,
    detail: impl Into<String>,
) -> ConfiguredDeviceError {
    ConfiguredDeviceError::Instantiation {
        device: request.id.clone(),
        model: request.model.clone(),
        detail: detail.into(),
    }
}

fn static_slot(name: &'static str) -> DeviceManagerResult<ResourceSlot> {
    ResourceSlot::new(name)
}

#[derive(Clone, Copy, Debug, Default, serde::Deserialize)]
#[serde(deny_unknown_fields)]
struct IvcChannelOptions {}

fn create_ivc_channel(
    id: DeviceNodeId,
    request: &VirtualDeviceRequest,
    context: &DeviceInstantiationContext,
) -> Result<DeviceNodeSpec, ConfiguredDeviceError> {
    request
        .deserialize_options::<IvcChannelOptions>()
        .map_err(|error| ConfiguredDeviceError::InvalidOptions {
            device: request.id.clone(),
            model: request.model.clone(),
            detail: error.to_string(),
        })?;
    let controller = context.default_wired_controller().ok_or_else(|| {
        request_error(
            request,
            "IVC notify requires a default wired interrupt domain",
        )
    })?;
    let dependency = context
        .default_wired_controller_node()
        .ok_or_else(|| {
            request_error(
                request,
                "default wired interrupt domain is missing its device-graph node",
            )
        })?
        .clone();
    Ok(DeviceNodeSpec::virtual_device(
        id,
        Arc::new(IvcChannelModel {
            controller,
            fixed: context.fixed_bindings().clone(),
        }),
    )
    .with_dependency(dependency))
}

struct IvcChannelModel {
    controller: InterruptControllerId,
    fixed: FixedDeviceBindings,
}

impl DeviceModel for IvcChannelModel {
    fn requirements(&self) -> DeviceManagerResult<DeviceRequirements> {
        let register_slot = static_slot(REGISTERS_SLOT)?;
        let irq_slot = static_slot(NOTIFY_IRQ_SLOT)?;
        let mmio_request = self
            .fixed
            .mmio(&register_slot)
            .map_or(ResourceRequest::Auto, |(base, _)| {
                ResourceRequest::Fixed(base)
            });
        let fixed_irq = self.fixed.wired(&irq_slot);
        DeviceRequirements::new()
            .with_mmio(
                register_slot,
                IVC_CHANNEL_SHARED_RANGE_SIZE,
                0x1000,
                mmio_request,
            )?
            .with_wired_irq(
                irq_slot,
                fixed_irq.map_or(self.controller, |binding| binding.controller),
                fixed_irq.map_or(InterruptTrigger::EdgeTriggered, |binding| binding.trigger),
                fixed_irq.map_or(InterruptSharing::Exclusive, |binding| binding.sharing),
                fixed_irq.map_or(ResourceRequest::Auto, |binding| {
                    ResourceRequest::Fixed(binding.input)
                }),
            )
    }

    fn firmware(&self) -> DeviceFirmwareSpec {
        DeviceFirmwareSpec::new("ivc-channel")
            .with_compatible("axvisor,ivc-channel")
            .with_register(ResourceSlot::new(REGISTERS_SLOT).expect("static IVC slot is valid"))
            .with_interrupt(ResourceSlot::new(NOTIFY_IRQ_SLOT).expect("static IVC slot is valid"))
            .with_u32_property("axvisor,ivc-version", 1)
    }

    fn build(&self, context: &mut DeviceBuildContext<'_>) -> DeviceManagerResult<DeviceBundle> {
        let (base, length) = context.mmio(REGISTERS_SLOT)?;
        let notify_irq = context.irq(NOTIFY_IRQ_SLOT)?;
        let bundle = DeviceBundle::new()
            .with_service::<ivc::IvcApertureAllocatorKey>(
                ivc::IvcAperturePool::new(
                    usize::try_from(base).map_err(|_| DeviceManagerError::InvalidConfig {
                        operation: "create IVC channel",
                        detail: "base GPA does not fit usize".into(),
                    })?,
                    usize::try_from(length).map_err(|_| DeviceManagerError::InvalidConfig {
                        operation: "create IVC channel",
                        detail: "length does not fit usize".into(),
                    })?,
                )?
                .into_service(),
            )?
            .with_service::<ivc::IvcNotifyEndpointKey>(Arc::new(
                ivc::WiredIvcNotifyEndpoint::new(notify_irq),
            ))?;
        Ok(bundle)
    }
}