arcbox-virtio 0.6.3

VirtIO device implementations for ArcBox
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

//! # arcbox-virtio
//!
//! `VirtIO` device implementations for `ArcBox`.
//!
//! This crate provides `VirtIO` device emulation including:
//!
//! - [`blk`]: Block device (virtio-blk)
//! - [`net`]: Network device (virtio-net)
//! - [`console`]: Console device (virtio-console)
//! - [`fs`]: Filesystem device (virtio-fs)
//! - [`vsock`]: Socket device (virtio-vsock)
//!
//! ## `VirtIO` Queue
//!
//! All devices use the standard `VirtIO` queue (virtqueue) mechanism for
//! communication with the guest. The [`queue`] module provides the core
//! queue implementation.
//!
//! ## Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────┐
//! │            arcbox-virtio                │
//! │  ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐│
//! │  │ blk │ │ net │ │cons │ │ fs  │ │vsock││
//! │  └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘│
//! │     └───────┴───────┴───────┴───────┘   │
//! │                   │                     │
//! │              VirtQueue                  │
//! └─────────────────────────────────────────┘
//! ```

#![allow(clippy::ptr_as_ptr)]
#![allow(clippy::borrow_as_ptr)]
#![allow(clippy::unnecessary_cast)]
#![allow(clippy::cognitive_complexity)]
#![allow(clippy::map_unwrap_or)]
#![allow(clippy::useless_vec)]
#![allow(clippy::unnecessary_wraps)]
#![allow(clippy::redundant_clone)]
#![allow(clippy::unnecessary_map_or)]
#![allow(clippy::missing_fields_in_debug)]
#![allow(clippy::needless_lifetimes)]
#![allow(clippy::needless_collect)]
#![allow(mismatched_lifetime_syntaxes)]

/// Back-compat re-export of `arcbox-virtio-blk`.
pub mod blk {
    pub use arcbox_virtio_blk::*;
}

/// Back-compat re-export of `arcbox-virtio-console`.
pub mod console {
    pub use arcbox_virtio_console::*;
}

/// Back-compat re-export of `arcbox-virtio-fs`.
pub mod fs {
    pub use arcbox_virtio_fs::*;
}

/// Back-compat re-export of `arcbox-virtio-net`.
pub mod net {
    pub use arcbox_virtio_net::*;
}

/// Back-compat re-export of `arcbox-virtio-rng`.
pub mod rng {
    pub use arcbox_virtio_rng::*;
}

/// Back-compat re-export of `arcbox-virtio-vsock`.
pub mod vsock {
    pub use arcbox_virtio_vsock::*;
}

/// Back-compat re-export of `arcbox-virtio-balloon`.
pub mod balloon {
    pub use arcbox_virtio_balloon::*;
}

/// Back-compat re-export of the vsock connection manager. The actual
/// `RxOps` / `VsockConnectionManager` / `VsockConnection` definitions
/// live in `arcbox-virtio-vsock::manager` after the per-device split.
pub mod vsock_manager {
    pub use arcbox_virtio_vsock::manager::*;
}

// Back-compat re-export of the `queue` module (moved to
// `arcbox-virtio-core`). Existing `arcbox_virtio::queue::VirtQueue`
// paths keep working.
pub use arcbox_virtio_core::queue;

// Re-export the foundational types from arcbox-virtio-core so existing
// `arcbox_virtio::{VirtioDevice, DeviceCtx, ...}` imports keep working
// without changes. The types' actual definitions live in
// `arcbox-virtio-core` so per-device crates (rng, console, blk, ...)
// can depend on the smaller foundation crate without pulling in every
// device implementation.
pub use arcbox_virtio_core::{
    ChainIter, DescChain, DeviceCtx, DeviceStatus, GuestMemWriter, QueueConfig, Result, SplitQueue,
    VirtioDevice, VirtioDeviceId, VirtioError, VirtqDesc, virtio_bindings,
};
pub use queue::{AvailRing, Descriptor, UsedRing, VirtQueue};

// Back-compat re-export of the foundational `error` and `guest_mem`
// modules — code that did `arcbox_virtio::error::VirtioError` or
// `arcbox_virtio::guest_mem::GuestMemWriter` keeps compiling.
pub use arcbox_virtio_core::error;
pub use arcbox_virtio_core::guest_mem;