scsi: Add virtio daemon

This adds the virtio-specific parts that use the previously formed
interfaces and scsi emulation in order to build a daemon that offers files
from the host system as drives to the guest.

The vast majority of this work was done by Gaelan Steele as part of a
GSoC project [1][2].

[1] rust-vmm#4
[2] https://gist.github.com/Gaelan/febec4e4606e1320026a0924c3bf74d0

Co-developed-by: Erik Schilling <[email protected]>
Signed-off-by: Erik Schilling <[email protected]>
Signed-off-by: Gaelan Steele <[email protected]>

Author: Gaelan

crates/scsi/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Upcoming Release
+
+- First initial daemon implementation.

crates/scsi/src/backend.rs

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
+
+use std::{
+    fs::File,
+    path::PathBuf,
+    sync::{Arc, RwLock},
+};
+
+use crate::scsi::emulation::{
+    block_device::{BlockDevice, FileBackend, MediumRotationRate},
+    target::EmulatedTarget,
+};
+use clap::Parser;
+use log::{error, info, warn};
+use thiserror::Error as ThisError;
+use vhost::vhost_user::{self, Listener};
+use vhost_user_backend::VhostUserDaemon;
+use vm_memory::{GuestMemoryAtomic, GuestMemoryMmap};
+
+use crate::vhu_scsi::VhostUserScsiBackend;
+
+#[derive(Debug, ThisError)]
+pub enum Error {
+    #[error("More than 256 LUNs aren't currently supported")]
+    TooManyLUNs,
+    #[error("Failed creating listener: {0}")]
+    FailedCreatingListener(vhost_user::Error),
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Parser)]
+struct ScsiArgs {
+    /// Make the images read-only.
+    ///
+    /// Currently, we don't actually support writes, but sometimes we want to
+    /// pretend the disk is writable to work around issues with some tools that
+    /// use the Linux SCSI generic API.
+    #[arg(long = "read-only", short = 'r')]
+    read_only: bool,
+    /// Tell the guest this disk is non-rotational.
+    ///
+    /// Affects some heuristics in Linux around, for example, scheduling.
+    #[arg(long = "solid-state")]
+    solid_state: bool,
+    /// Location of vhost-user socket.
+    #[clap(short, long)]
+    socket_path: PathBuf,
+    /// Images against which the SCSI actions are emulated.
+    images: Vec<PathBuf>,
+}
+
+fn create_backend(args: &ScsiArgs) -> Result<VhostUserScsiBackend> {
+    let mut backend = VhostUserScsiBackend::new();
+    let mut target = EmulatedTarget::new();
+    if args.images.len() > 256 {
+        error!("");
+        // This is fairly simple to add; it's just a matter of supporting the right LUN
+        // encoding formats.
+        return Err(Error::TooManyLUNs);
+    }
+    if !args.read_only {
+        warn!("Currently, only read-only images are supported. Unless you know what you're doing, you want to pass -r");
+    }
+    for image in &args.images {
+        let mut dev = BlockDevice::new(FileBackend::new(File::open(image).expect("Opening image")));
+        dev.set_write_protected(args.read_only);
+        dev.set_solid_state(if args.solid_state {
+            MediumRotationRate::NonRotating
+        } else {
+            MediumRotationRate::Unreported
+        });
+        target.add_lun(Box::new(dev));
+    }
+    backend.add_target(Box::new(target));
+    Ok(backend)
+}
+
+fn start_backend(backend: VhostUserScsiBackend, args: ScsiArgs) -> Result<()> {
+    let backend = Arc::new(RwLock::new(backend));
+    let mut daemon = VhostUserDaemon::new(
+        "vhost-user-scsi".into(),
+        Arc::clone(&backend),
+        GuestMemoryAtomic::new(GuestMemoryMmap::new()),
+    )
+    .expect("Creating daemon");
+
+    daemon
+        .start(Listener::new(args.socket_path, true).map_err(Error::FailedCreatingListener)?)
+        .expect("Starting daemon");
+
+    match daemon.wait() {
+        Ok(()) => {
+            info!("Stopping cleanly.");
+        }
+        Err(vhost_user_backend::Error::HandleRequest(vhost_user::Error::PartialMessage)) => {
+            info!("vhost-user connection closed with partial message. If the VM is shutting down, this is expected behavior; otherwise, it might be a bug.");
+        }
+        Err(e) => {
+            warn!("Error running daemon: {:?}", e);
+        }
+    }
+    // No matter the result, we need to shut down the worker thread.
+    // unwrap will only panic if we already panicked somewhere else
+    backend
+        .read()
+        .unwrap()
+        .exit_event
+        .write(1)
+        .expect("Shutting down worker thread");
+    Ok(())
+}
+
+pub fn scsi_init() -> Result<()> {
+    env_logger::init();
+    let args = ScsiArgs::parse();
+    let backend = create_backend(&args)?;
+    start_backend(backend, args)
+}

crates/scsi/src/lib.rs

@@ -1,3 +1,10 @@
-fn main() {
-    println!("Hello world");
+// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
+
+mod backend;
+mod scsi;
+mod vhu_scsi;
+mod virtio;
+
+fn main() -> backend::Result<()> {
+    backend::scsi_init()
 }