1#![expect(missing_docs)]
10#![forbid(unsafe_code)]
11
12use mesh::MeshPayload;
13use vm_resource::Resource;
14use vm_resource::ResourceId;
15use vm_resource::kind::PciDeviceHandleKind;
16use vm_resource::kind::VirtioDeviceHandle;
17
18#[derive(MeshPayload)]
20pub struct VirtioPciDeviceHandle(pub Resource<VirtioDeviceHandle>);
21
22impl ResourceId<PciDeviceHandleKind> for VirtioPciDeviceHandle {
23 const ID: &'static str = "virtio";
24}
25
26pub mod p9 {
27 use mesh::MeshPayload;
28 use vm_resource::ResourceId;
29 use vm_resource::kind::VirtioDeviceHandle;
30
31 #[derive(MeshPayload)]
32 pub struct VirtioPlan9Handle {
33 pub tag: String,
34 pub root_path: String,
35 pub debug: bool,
36 }
37
38 impl ResourceId<VirtioDeviceHandle> for VirtioPlan9Handle {
39 const ID: &'static str = "virtio-9p";
40 }
41}
42
43pub mod fs {
44 use mesh::MeshPayload;
45 use vm_resource::ResourceId;
46 use vm_resource::kind::VirtioDeviceHandle;
47
48 #[derive(MeshPayload)]
49 pub struct VirtioFsHandle {
50 pub tag: String,
51 pub fs: VirtioFsBackend,
52 }
53
54 #[derive(MeshPayload)]
55 pub enum VirtioFsBackend {
56 HostFs {
57 root_path: String,
58 mount_options: String,
59 },
60 SectionFs {
61 root_path: String,
62 },
63 }
64
65 impl ResourceId<VirtioDeviceHandle> for VirtioFsHandle {
66 const ID: &'static str = "virtiofs";
67 }
68}
69
70pub mod pmem {
71 use mesh::MeshPayload;
72 use vm_resource::ResourceId;
73 use vm_resource::kind::VirtioDeviceHandle;
74
75 #[derive(MeshPayload)]
76 pub struct VirtioPmemHandle {
77 pub path: String,
78 }
79
80 impl ResourceId<VirtioDeviceHandle> for VirtioPmemHandle {
81 const ID: &'static str = "virtio-pmem";
82 }
83}
84
85pub mod rng {
86 use mesh::MeshPayload;
87 use vm_resource::ResourceId;
88 use vm_resource::kind::VirtioDeviceHandle;
89
90 #[derive(MeshPayload)]
91 pub struct VirtioRngHandle;
92
93 impl ResourceId<VirtioDeviceHandle> for VirtioRngHandle {
94 const ID: &'static str = "virtio-rng";
95 }
96}
97
98pub mod blk {
99 use mesh::MeshPayload;
100 use vm_resource::Resource;
101 use vm_resource::ResourceId;
102 use vm_resource::kind::DiskHandleKind;
103 use vm_resource::kind::VirtioDeviceHandle;
104
105 #[derive(MeshPayload)]
106 pub struct VirtioBlkHandle {
107 pub disk: Resource<DiskHandleKind>,
108 pub read_only: bool,
109 }
110
111 impl ResourceId<VirtioDeviceHandle> for VirtioBlkHandle {
112 const ID: &'static str = "virtio-blk";
113 }
114}
115
116pub mod net {
117 use mesh::MeshPayload;
118 use net_backend_resources::mac_address::MacAddress;
119 use vm_resource::Resource;
120 use vm_resource::ResourceId;
121 use vm_resource::kind::NetEndpointHandleKind;
122 use vm_resource::kind::VirtioDeviceHandle;
123
124 #[derive(MeshPayload)]
125 pub struct VirtioNetHandle {
126 pub max_queues: Option<u16>,
127 pub mac_address: MacAddress,
128 pub endpoint: Resource<NetEndpointHandleKind>,
129 }
130
131 impl ResourceId<VirtioDeviceHandle> for VirtioNetHandle {
132 const ID: &'static str = "virtio-net";
133 }
134}
135
136pub mod console {
137 use mesh::MeshPayload;
138 use vm_resource::Resource;
139 use vm_resource::ResourceId;
140 use vm_resource::kind::SerialBackendHandle;
141 use vm_resource::kind::VirtioDeviceHandle;
142
143 #[derive(MeshPayload)]
144 pub struct VirtioConsoleHandle {
145 pub backend: Resource<SerialBackendHandle>,
146 }
147
148 impl ResourceId<VirtioDeviceHandle> for VirtioConsoleHandle {
149 const ID: &'static str = "virtio-console";
150 }
151}