pxcloud/vhost-device
5
0
Fork 0
mirror of https://github.com/rust-vmm/vhost-device.git synced 2025-12-26 06:32:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

console: add crate-level clippy lints

Browse Source 
Signed-off-by: Manos Pitsidianakis <manos.pitsidianakis@linaro.org>
This commit is contained in:
Manos Pitsidianakis 2024-11-11 06:45:49 +02:00 committed by Manos Pitsidianakis
parent 8a2a11d877
commit ad30537ab0
5 changed files with 126 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
vhost-device-console/src/backend.rs
View File

@ -23,11 +23,11 @@ use crate::{
vhu_console::VhostUserConsoleBackend,
};
pub(crate) type Result<T> = std::result::Result<T, Error>;
pub type Result<T> = std::result::Result<T, Error>;
#[derive(Debug, ThisError)]
/// Errors related to low level Console helpers
pub(crate) enum Error {
pub enum Error {
#[error("Invalid socket count: {0}")]
SocketCountInvalid(usize),
#[error("Could not create console backend: {0}")]
@ -44,12 +44,12 @@ pub(crate) enum Error {
WrongBackendSocket,
}
#[derive(PartialEq, Debug)]
#[derive(PartialEq, Eq, Debug)]
pub struct VuConsoleConfig {
pub(crate) socket_path: PathBuf,
pub(crate) backend: BackendType,
pub(crate) tcp_port: String,
pub(crate) socket_count: u32,
pub socket_path: PathBuf,
pub backend: BackendType,
pub tcp_port: String,
pub socket_count: u32,
}
impl VuConsoleConfig {
@ -86,11 +86,7 @@ impl VuConsoleConfig {
/// This is the public API through which an external program starts the
/// vhost-device-console backend server.
pub(crate) fn start_backend_server(
socket: PathBuf,
tcp_addr: String,
backend: BackendType,
) -> Result<()> {
pub fn start_backend_server(socket: PathBuf, tcp_addr: String, backend: BackendType) -> Result<()> {
loop {
let controller = ConsoleController::new(backend);
let arc_controller = Arc::new(RwLock::new(controller));
@ -188,7 +184,7 @@ mod tests {
socket_count: 1,
};
assert!(VuConsoleConfig::try_from(args).is_ok());
VuConsoleConfig::try_from(args).unwrap();
}
#[test]
@ -230,7 +226,7 @@ mod tests {
socket_count: 1,
};
assert!(VuConsoleConfig::try_from(args).is_ok());
VuConsoleConfig::try_from(args).unwrap();
}
#[test]
@ -242,7 +238,7 @@ mod tests {
socket_count: 2,
};
assert!(VuConsoleConfig::try_from(args).is_ok());
VuConsoleConfig::try_from(args).unwrap();
}
fn test_backend_start_and_stop(args: ConsoleArgs) -> Result<()> {

10
vhost-device-console/src/console.rs
View File

@ -18,14 +18,14 @@ pub enum BackendType {
}
#[derive(Debug)]
pub(crate) struct ConsoleController {
pub struct ConsoleController {
config: VirtioConsoleConfig,
pub backend: BackendType,
}
impl ConsoleController {
pub(crate) fn new(backend: BackendType) -> ConsoleController {
ConsoleController {
pub fn new(backend: BackendType) -> Self {
Self {
config: VirtioConsoleConfig {
cols: 20.into(),
rows: 20.into(),
@ -36,8 +36,8 @@ impl ConsoleController {
}
}
pub(crate) fn config(&self) -> &VirtioConsoleConfig {
trace!("Get config\n");
pub fn config(&self) -> &VirtioConsoleConfig {
trace!("Get config");
&self.config
}
}

44
vhost-device-console/src/main.rs
View File

@ -4,6 +4,31 @@
// Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>
//
// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
#![deny(
clippy::undocumented_unsafe_blocks,
/* groups */
clippy::correctness,
clippy::suspicious,
clippy::complexity,
clippy::perf,
clippy::style,
clippy::nursery,
//* restriction */
clippy::dbg_macro,
clippy::rc_buffer,
clippy::as_underscore,
clippy::assertions_on_result_states,
//* pedantic */
clippy::cast_lossless,
clippy::cast_possible_wrap,
clippy::ptr_as_ptr,
clippy::bool_to_int_with_if,
clippy::borrow_as_ptr,
clippy::case_sensitive_file_extension_comparisons,
clippy::cast_lossless,
clippy::cast_ptr_alignment,
clippy::naive_bytecount
)]
mod backend;
mod console;
@ -16,7 +41,7 @@ use log::error;
use crate::console::BackendType;
pub(crate) type Result<T> = std::result::Result<T, Error>;
pub type Result<T> = std::result::Result<T, Error>;
use crate::backend::{start_backend, Error, VuConsoleConfig};
#[derive(Parser, Debug)]
@ -54,11 +79,18 @@ impl TryFrom<ConsoleArgs> for VuConsoleConfig {
return Err(Error::WrongBackendSocket);
}
Ok(VuConsoleConfig {
socket_path: args.socket_path,
backend: args.backend,
tcp_port: args.tcp_port,
socket_count: args.socket_count,
let ConsoleArgs {
socket_path,
backend,
tcp_port,
socket_count,
} = args;
Ok(Self {
socket_path,
backend,
tcp_port,
socket_count,
})
}
}

135
vhost-device-console/src/vhu_console.rs
View File

@ -43,8 +43,8 @@ use crate::{
type Result<T> = std::result::Result<T, Error>;
#[derive(Copy, Clone, Debug, PartialEq, ThisError)]
pub(crate) enum Error {
#[derive(Copy, Clone, Debug, PartialEq, Eq, ThisError)]
pub enum Error {
#[error("Failed to handle unknown event: {0}")]
HandleEventUnknown(u16),
#[error("Descriptor not found")]
@ -71,7 +71,7 @@ pub(crate) enum Error {
impl From<Error> for io::Error {
fn from(err: Error) -> Self {
io::Error::new(io::ErrorKind::Other, err)
Self::new(io::ErrorKind::Other, err)
}
}
@ -123,7 +123,7 @@ impl<T: Read + Write> ReadWrite for T {}
// reading its content from byte array.
unsafe impl ByteValued for VirtioConsoleControl {}
pub(crate) struct VhostUserConsoleBackend {
pub struct VhostUserConsoleBackend {
controller: Arc<RwLock<ConsoleController>>,
acked_features: u64,
event_idx: bool,
@ -131,15 +131,15 @@ pub(crate) struct VhostUserConsoleBackend {
rx_data_fifo: Queue<u8>,
epoll_fd: i32,
stream_fd: Option<i32>,
pub(crate) ready: bool,
pub(crate) ready_to_write: bool,
pub(crate) output_queue: Queue<String>,
pub(crate) stdin: Option<Box<dyn Read + Send + Sync>>,
pub(crate) listener: Option<TcpListener>,
pub(crate) stream: Option<Box<dyn ReadWrite + Send + Sync>>,
pub(crate) rx_event: EventFd,
pub(crate) rx_ctrl_event: EventFd,
pub(crate) exit_event: EventFd,
pub ready: bool,
pub ready_to_write: bool,
pub output_queue: Queue<String>,
pub stdin: Option<Box<dyn Read + Send + Sync>>,
pub listener: Option<TcpListener>,
pub stream: Option<Box<dyn ReadWrite + Send + Sync>>,
pub rx_event: EventFd,
pub rx_ctrl_event: EventFd,
pub exit_event: EventFd,
mem: Option<GuestMemoryAtomic<GuestMemoryMmap>>,
}
@ -150,9 +150,9 @@ impl VhostUserConsoleBackend {
pub const QUEUE_SIZE: usize = 128;
pub const NUM_QUEUES: u16 = 4;
pub(crate) fn new(controller: Arc<RwLock<ConsoleController>>) -> Result<Self> {
Ok(VhostUserConsoleBackend {
controller: controller.clone(),
pub fn new(controller: Arc<RwLock<ConsoleController>>) -> Result<Self> {
Ok(Self {
controller,
event_idx: false,
rx_ctrl_fifo: Queue::new(),
rx_data_fifo: Queue::new(),
@ -184,7 +184,7 @@ impl VhostUserConsoleBackend {
Self::epoll_register(self.epoll_fd.as_raw_fd(), stdin_fd, epoll::Events::EPOLLIN)
.map_err(|_| Error::EpollAdd)?;
} else {
let listener = TcpListener::bind(tcpaddr_str.clone()).expect("asdasd");
let listener = TcpListener::bind(tcpaddr_str).expect("asdasd");
self.listener = Some(listener);
}
Ok(())
@ -495,10 +495,7 @@ impl VhostUserConsoleBackend {
}
/// Set self's VringWorker.
pub(crate) fn set_vring_worker(
&self,
vring_worker: Arc<VringEpollHandler<Arc<RwLock<VhostUserConsoleBackend>>>>,
) {
pub fn set_vring_worker(&self, vring_worker: Arc<VringEpollHandler<Arc<RwLock<Self>>>>) {
let rx_event_fd = self.rx_event.as_raw_fd();
vring_worker
.register_listener(
@ -724,6 +721,12 @@ impl VhostUserBackendMut for VhostUserConsoleBackend {
}
fn get_config(&self, offset: u32, size: u32) -> Vec<u8> {
debug_assert_eq!(
std::mem::size_of::<*const u8>(),
8,
"If we start supporting non-64-bit pointers, remove the following clippy lint."
);
#[allow(clippy::cast_possible_wrap)]
// SAFETY: The layout of the structure is fixed and can be initialized by
// reading its content from byte array.
unsafe {
@ -734,7 +737,7 @@ impl VhostUserBackendMut for VhostUserConsoleBackend {
.config()
.as_slice()
.as_ptr()
.offset(offset as isize) as *const _ as *const _,
.offset(offset as isize),
size as usize,
)
.to_vec()
@ -888,7 +891,7 @@ mod tests {
let vring = VringRwLock::new(mem, 0x1000).unwrap();
vring.set_queue_info(0x100, 0x200, 0x300).unwrap();
vring.set_queue_ready(true);
let list_vrings = [vring.clone(), vring.clone(), vring.clone(), vring.clone()];
let list_vrings = [vring.clone(), vring.clone(), vring.clone(), vring];
vu_console_backend
.handle_event(QueueEvents::RX_QUEUE, EventSet::IN, &list_vrings, 0)
@ -930,21 +933,21 @@ mod tests {
GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap(),
);
let vring = VringRwLock::new(mem.clone(), 0x1000).unwrap();
let vring = VringRwLock::new(mem, 0x1000).unwrap();
// Empty descriptor chain should be ignored
assert!(vu_console_backend
vu_console_backend
.process_rx_requests(Vec::<ConsoleDescriptorChain>::new(), &vring)
.is_ok());
assert!(vu_console_backend
.unwrap();
vu_console_backend
.process_tx_requests(Vec::<ConsoleDescriptorChain>::new(), &vring)
.is_ok());
assert!(vu_console_backend
.unwrap();
vu_console_backend
.process_ctrl_rx_requests(Vec::<ConsoleDescriptorChain>::new(), &vring)
.is_ok());
assert!(vu_console_backend
.unwrap();
vu_console_backend
.process_ctrl_tx_requests(Vec::<ConsoleDescriptorChain>::new(), &vring)
.is_ok());
.unwrap();
}
fn build_desc_chain(
@ -964,7 +967,7 @@ mod tests {
flags[i as usize] & !VRING_DESC_F_NEXT as u16
};
let desc = Descriptor::new((0x100 * (i + 1)) as u64, len, desc_flags, i + 1);
let desc = Descriptor::new(u64::from(0x100 * (i + 1)), len, desc_flags, i + 1);
desc_vec.push(desc);
}
@ -989,7 +992,7 @@ mod tests {
// Test 1: Empty queue
let mem1 = GuestMemoryAtomic::new(mem.clone());
let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
let vring = VringRwLock::new(mem1, 0x1000).unwrap();
assert!(vu_console_backend
.process_ctrl_rx_requests(vec![], &vring)
.unwrap());
@ -1037,7 +1040,7 @@ mod tests {
// Test 5: if message is VIRTIO_CONSOLE_PORT_NAME
let desc_chain = build_desc_chain(&mem, 1, vec![VRING_DESC_F_WRITE as u16], 0x200);
let mem1 = GuestMemoryAtomic::new(mem.clone());
let mem1 = GuestMemoryAtomic::new(mem);
let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
vu_console_backend.update_memory(mem1).unwrap();
@ -1049,7 +1052,7 @@ mod tests {
let _ = vu_console_backend.rx_ctrl_fifo.add(ctrl_msg);
assert!(vu_console_backend
.process_ctrl_rx_requests(vec![desc_chain.clone()], &vring)
.process_ctrl_rx_requests(vec![desc_chain], &vring)
.unwrap());
}
@ -1063,7 +1066,7 @@ mod tests {
// Test 1: Empty queue
let mem1 = GuestMemoryAtomic::new(mem.clone());
let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
let vring = VringRwLock::new(mem1, 0x1000).unwrap();
assert!(vu_console_backend
.process_ctrl_tx_requests(vec![], &vring)
.unwrap());
@ -1088,18 +1091,18 @@ mod tests {
vu_console_backend.update_memory(mem1).unwrap();
assert_eq!(
vu_console_backend
.process_ctrl_tx_requests(vec![desc_chain.clone()], &vring)
.process_ctrl_tx_requests(vec![desc_chain], &vring)
.unwrap_err(),
Error::DescriptorReadFailed
);
// Test 4: Complete function successfully -- VIRTIO_CONSOLE_PORT_READY message
let desc_chain = build_desc_chain(&mem, 1, vec![0], 0x8);
let mem1 = GuestMemoryAtomic::new(mem.clone());
let mem1 = GuestMemoryAtomic::new(mem);
let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
vu_console_backend.update_memory(mem1).unwrap();
assert!(vu_console_backend
.process_ctrl_tx_requests(vec![desc_chain.clone()], &vring)
.process_ctrl_tx_requests(vec![desc_chain], &vring)
.unwrap());
}
@ -1111,7 +1114,7 @@ mod tests {
let mem = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap();
let mem_1 = GuestMemoryAtomic::new(mem.clone());
vu_console_backend.update_memory(mem_1.clone()).unwrap();
vu_console_backend.update_memory(mem_1).unwrap();
// Test 1: Empty queue
let ctrl_msg_1 = VirtioConsoleControl {
@ -1138,7 +1141,7 @@ mod tests {
value: 1.into(),
};
assert!(vu_console_backend.handle_control_msg(ctrl_msg_3).is_ok());
vu_console_backend.handle_control_msg(ctrl_msg_3).unwrap();
assert_eq!(
vu_console_backend
@ -1147,13 +1150,13 @@ mod tests {
Error::HandleEventUnknown(4)
);
assert!(vu_console_backend.handle_control_msg(ctrl_msg_1).is_ok());
vu_console_backend.handle_control_msg(ctrl_msg_1).unwrap();
// Update memory
let mem_1 = GuestMemoryAtomic::new(mem.clone());
vu_console_backend.update_memory(mem_1.clone()).unwrap();
let mem_1 = GuestMemoryAtomic::new(mem);
vu_console_backend.update_memory(mem_1).unwrap();
assert!(vu_console_backend.handle_control_msg(ctrl_msg_2).is_ok());
vu_console_backend.handle_control_msg(ctrl_msg_2).unwrap();
}
#[test]
@ -1167,18 +1170,18 @@ mod tests {
// Test 1: Empty queue
let mem1 = GuestMemoryAtomic::new(mem.clone());
let vring = VringRwLock::new(mem1, 0x1000).unwrap();
assert!(vu_console_backend
vu_console_backend
.process_tx_requests(vec![], &vring)
.is_ok());
.unwrap();
// Test 2: Empty buffer
let desc_chain = build_desc_chain(&mem, 1, vec![0], 0x200);
let mem1 = GuestMemoryAtomic::new(mem.clone());
let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
vu_console_backend.update_memory(mem1).unwrap();
assert!(vu_console_backend
vu_console_backend
.process_tx_requests(vec![desc_chain], &vring)
.is_ok());
.unwrap();
// Test 3: Fill message to the buffer
let desc_chain = build_desc_chain(&mem, 1, vec![0], 0x200);
@ -1186,7 +1189,7 @@ mod tests {
// Build the Vec with the desired string
let mut buffer: Vec<u8> = Vec::new();
let string_bytes = "Hello!".as_bytes();
let string_bytes = b"Hello!";
buffer.extend_from_slice(string_bytes);
// Write a new buffer into the desc_chain
@ -1205,9 +1208,9 @@ mod tests {
String::from_utf8(buffer).unwrap()
);
assert!(vu_console_backend
vu_console_backend
.process_tx_requests(vec![desc_chain], &vring)
.is_ok());
.unwrap();
}
#[test]
@ -1219,7 +1222,7 @@ mod tests {
let mem = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap();
let desc_chain = build_desc_chain(&mem, 1, vec![0], 0x200);
let mem1 = GuestMemoryAtomic::new(mem.clone());
let mem1 = GuestMemoryAtomic::new(mem);
let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
// Test: Fill message to the buffer
@ -1228,7 +1231,7 @@ mod tests {
// Build the Vec with the desired string
let mut buffer: Vec<u8> = Vec::new();
let string_bytes = "Hello!".as_bytes();
let string_bytes = b"Hello!";
buffer.extend_from_slice(string_bytes);
// Write a new buffer into the desc_chain
@ -1247,9 +1250,9 @@ mod tests {
String::from_utf8(buffer).unwrap()
);
assert!(vu_console_backend
vu_console_backend
.process_tx_requests(vec![desc_chain], &vring)
.is_ok());
.unwrap();
}
#[test]
@ -1263,9 +1266,9 @@ mod tests {
// Test 1: Empty queue
let mem1 = GuestMemoryAtomic::new(mem.clone());
let vring = VringRwLock::new(mem1, 0x1000).unwrap();
assert!(vu_console_backend
vu_console_backend
.process_rx_requests(vec![], &vring)
.is_ok());
.unwrap();
// Test 2: Empty buffer
let desc_chain = build_desc_chain(&mem, 1, vec![0], 0x200);
@ -1296,7 +1299,7 @@ mod tests {
// Test 4: Fill message to the buffer. Everything should work!
let desc_chain = build_desc_chain(&mem, 1, vec![VRING_DESC_F_WRITE as u16], 0x200);
let mem1 = GuestMemoryAtomic::new(mem.clone());
let mem1 = GuestMemoryAtomic::new(mem);
let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
vu_console_backend.update_memory(mem1).unwrap();
@ -1343,14 +1346,13 @@ mod tests {
vu_console_backend.stdin = Some(Box::new(cursor));
vu_console_backend.ready_to_write = true;
assert!(vu_console_backend
vu_console_backend
.handle_event(QueueEvents::KEY_EFD, EventSet::IN, &[vring], 0)
.is_ok());
.unwrap();
let received_byte = vu_console_backend.rx_data_fifo.peek();
// verify that the character has been received and is the one we sent
assert!(received_byte.clone().is_ok());
assert_eq!(received_byte.unwrap(), input_data[0]);
}
@ -1373,14 +1375,13 @@ mod tests {
vu_console_backend.stream = Some(Box::new(cursor));
vu_console_backend.ready_to_write = true;
assert!(vu_console_backend
vu_console_backend
.handle_event(QueueEvents::KEY_EFD, EventSet::IN, &[vring], 0)
.is_ok());
.unwrap();
let received_byte = vu_console_backend.rx_data_fifo.peek();
// verify that the character has been received and is the one we sent
assert!(received_byte.clone().is_ok());
assert_eq!(received_byte.unwrap(), input_data[0]);
}
@ -1393,7 +1394,7 @@ mod tests {
let mem = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap();
let mem = GuestMemoryAtomic::new(mem);
vu_console_backend.update_memory(mem.clone()).unwrap();
vu_console_backend.update_memory(mem).unwrap();
// Test 1: Call the actual read function
let cursor = Cursor::new(Vec::new());

8
vhost-device-console/src/virtio_console.rs
View File

@ -27,9 +27,9 @@ pub const VIRTIO_CONSOLE_PORT_OPEN: u16 = 6;
pub const VIRTIO_CONSOLE_PORT_NAME: u16 = 7;
/// Virtio Console Config
#[derive(Copy, Clone, Debug, Default, PartialEq)]
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
#[repr(C)]
pub(crate) struct VirtioConsoleConfig {
pub struct VirtioConsoleConfig {
pub cols: Le16,
pub rows: Le16,
pub max_nr_ports: Le32,
@ -40,9 +40,9 @@ pub(crate) struct VirtioConsoleConfig {
// reading its content from byte array.
unsafe impl ByteValued for VirtioConsoleConfig {}
#[derive(Copy, Clone, Debug, Default, PartialEq)]
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
#[repr(C)]
pub(crate) struct VirtioConsoleControl {
pub struct VirtioConsoleControl {
pub id: Le32,
pub event: Le16,
pub value: Le16,