refactor(serial): remove generics from SerialDevice

We use `SerialDevice` with Stdin as the input source. Encode this in the
type so that we don't spill the generic all over the place.

Co-authored-by: Egor Lazarchuk <yegorlz@amazon.co.uk>
Signed-off-by: Babis Chalios <bchalios@amazon.es>

Author: bchalios

src/vmm/src/builder.rs

@@ -10,14 +10,11 @@ use std::sync::mpsc;
 use std::sync::{Arc, Mutex};
 
 use event_manager::{MutEventSubscriber, SubscriberOps};
-use libc::EFD_NONBLOCK;
 use linux_loader::cmdline::Cmdline as LoaderKernelCmdline;
 use userfaultfd::Uffd;
 use utils::time::TimestampUs;
 #[cfg(target_arch = "aarch64")]
 use vm_superio::Rtc;
-use vm_superio::Serial;
-use vmm_sys_util::eventfd::EventFd;
 
 use crate::arch::{ConfigurationError, configure_system_for_boot, load_kernel};
 #[cfg(target_arch = "aarch64")]
@@ -37,8 +34,8 @@ use crate::devices::BusDevice;
 use crate::devices::acpi::vmgenid::{VmGenId, VmGenIdError};
 #[cfg(target_arch = "aarch64")]
 use crate::devices::legacy::RTCDevice;
+use crate::devices::legacy::SerialDevice;
 use crate::devices::legacy::serial::SerialOut;
-use crate::devices::legacy::{EventFdTrigger, SerialEventsWrapper, SerialWrapper};
 use crate::devices::virtio::balloon::Balloon;
 use crate::devices::virtio::block::device::Block;
 use crate::devices::virtio::device::VirtioDevice;
@@ -158,7 +155,7 @@ fn create_vmm_and_vcpus(
         set_stdout_nonblocking();
 
         // Serial device setup.
-        let serial_device = setup_serial_device(event_manager, std::io::stdin(), io::stdout())?;
+        let serial_device = setup_serial_device(event_manager)?;
 
         // x86_64 uses the i8042 reset event as the Vmm exit event.
         let reset_evt = vcpus_exit_evt.try_clone().map_err(VmmError::EventFd)?;
@@ -532,22 +529,11 @@ pub fn build_microvm_from_snapshot(
 /// Sets up the serial device.
 pub fn setup_serial_device(
     event_manager: &mut EventManager,
-    input: std::io::Stdin,
-    out: std::io::Stdout,
 ) -> Result<Arc<Mutex<BusDevice>>, VmmError> {
-    let interrupt_evt = EventFdTrigger::new(EventFd::new(EFD_NONBLOCK).map_err(VmmError::EventFd)?);
-    let kick_stdin_read_evt =
-        EventFdTrigger::new(EventFd::new(EFD_NONBLOCK).map_err(VmmError::EventFd)?);
-    let serial = Arc::new(Mutex::new(BusDevice::Serial(SerialWrapper {
-        serial: Serial::with_events(
-            interrupt_evt,
-            SerialEventsWrapper {
-                buffer_ready_event_fd: Some(kick_stdin_read_evt),
-            },
-            SerialOut::Stdout(out),
-        ),
-        input: Some(input),
-    })));
+    let serial = Arc::new(Mutex::new(BusDevice::Serial(
+        SerialDevice::new(Some(std::io::stdin()), SerialOut::Stdout(std::io::stdout()))
+            .map_err(VmmError::EventFd)?,
+    )));
     event_manager.add_subscriber(serial.clone());
     Ok(serial)
 }
@@ -569,7 +555,7 @@ fn attach_legacy_devices_aarch64(
     if cmdline_contains_console {
         // Make stdout non-blocking.
         set_stdout_nonblocking();
-        let serial = setup_serial_device(event_manager, std::io::stdin(), std::io::stdout())?;
+        let serial = setup_serial_device(event_manager)?;
         vmm.mmio_device_manager
             .register_mmio_serial(vmm.vm.fd(), &mut vmm.resource_allocator, serial, None)
             .map_err(VmmError::RegisterMMIODevice)?;
@@ -749,11 +735,15 @@ pub(crate) fn set_stdout_nonblocking() {
 pub(crate) mod tests {
 
     use linux_loader::cmdline::Cmdline;
+    #[cfg(target_arch = "x86_64")]
+    use vmm_sys_util::eventfd::EventFd;
     use vmm_sys_util::tempfile::TempFile;
 
     use super::*;
     use crate::arch::DeviceType;
     use crate::device_manager::resources::ResourceAllocator;
+    #[cfg(target_arch = "x86_64")]
+    use crate::devices::legacy::serial::SerialOut;
     use crate::devices::virtio::block::CacheType;
     use crate::devices::virtio::rng::device::ENTROPY_DEV_ID;
     use crate::devices::virtio::vsock::{TYPE_VSOCK, VSOCK_DEV_ID};
@@ -830,16 +820,9 @@ pub(crate) mod tests {
         let acpi_device_manager = ACPIDeviceManager::new();
         #[cfg(target_arch = "x86_64")]
         let pio_device_manager = PortIODeviceManager::new(
-            Arc::new(Mutex::new(BusDevice::Serial(SerialWrapper {
-                serial: Serial::with_events(
-                    EventFdTrigger::new(EventFd::new(EFD_NONBLOCK).unwrap()),
-                    SerialEventsWrapper {
-                        buffer_ready_event_fd: None,
-                    },
-                    SerialOut::Sink(std::io::sink()),
-                ),
-                input: None,
-            }))),
+            Arc::new(Mutex::new(BusDevice::Serial(
+                SerialDevice::new(None, SerialOut::Sink(std::io::sink())).unwrap(),
+            ))),
             EventFd::new(libc::EFD_NONBLOCK).unwrap(),
         )
         .unwrap();

src/vmm/src/device_manager/persist.rs

@@ -421,11 +421,8 @@ impl<'a> Persist<'a> for MMIODeviceManager {
         {
             for state in &state.legacy_devices {
                 if state.type_ == DeviceType::Serial {
-                    let serial = crate::builder::setup_serial_device(
-                        constructor_args.event_manager,
-                        std::io::stdin(),
-                        std::io::stdout(),
-                    )?;
+                    let serial =
+                        crate::builder::setup_serial_device(constructor_args.event_manager)?;
 
                     constructor_args
                         .resource_allocator

src/vmm/src/devices/bus.rs

@@ -65,7 +65,7 @@ pub enum BusDevice {
     RTCDevice(RTCDevice),
     BootTimer(BootTimer),
     MmioTransport(MmioTransport),
-    Serial(SerialDevice<std::io::Stdin>),
+    Serial(SerialDevice),
     #[cfg(test)]
     Dummy(DummyDevice),
     #[cfg(test)]
@@ -127,7 +127,7 @@ impl BusDevice {
             _ => None,
         }
     }
-    pub fn serial_ref(&self) -> Option<&SerialDevice<std::io::Stdin>> {
+    pub fn serial_ref(&self) -> Option<&SerialDevice> {
         match self {
             Self::Serial(x) => Some(x),
             _ => None,
@@ -159,7 +159,7 @@ impl BusDevice {
             _ => None,
         }
     }
-    pub fn serial_mut(&mut self) -> Option<&mut SerialDevice<std::io::Stdin>> {
+    pub fn serial_mut(&mut self) -> Option<&mut SerialDevice> {
         match self {
             Self::Serial(x) => Some(x),
             _ => None,

src/vmm/src/devices/legacy/serial.rs

@@ -7,16 +7,17 @@
 
 //! Implements a wrapper over an UART serial device.
 use std::fmt::Debug;
-use std::io;
-use std::io::{Read, Write};
+use std::io::{self, Read, Stdin, Write};
 use std::os::unix::io::{AsRawFd, RawFd};
 
 use event_manager::{EventOps, Events, MutEventSubscriber};
+use libc::EFD_NONBLOCK;
 use log::{error, warn};
 use serde::Serialize;
 use vm_superio::serial::{Error as SerialError, SerialEvents};
 use vm_superio::{Serial, Trigger};
 use vmm_sys_util::epoll::EventSet;
+use vmm_sys_util::eventfd::EventFd;
 
 use crate::devices::legacy::EventFdTrigger;
 use crate::logger::{IncMetric, SharedIncMetric};
@@ -220,7 +221,27 @@ impl<I: Read + AsRawFd + Send + Debug> SerialWrapper<EventFdTrigger, SerialEvent
 }
 
 /// Type for representing a serial device.
-pub type SerialDevice<I> = SerialWrapper<EventFdTrigger, SerialEventsWrapper, I>;
+pub type SerialDevice = SerialWrapper<EventFdTrigger, SerialEventsWrapper, Stdin>;
+
+impl SerialDevice {
+    pub fn new(serial_in: Option<Stdin>, serial_out: SerialOut) -> Result<Self, std::io::Error> {
+        let interrupt_evt = EventFdTrigger::new(EventFd::new(EFD_NONBLOCK)?);
+        let buffer_read_event_fd = EventFdTrigger::new(EventFd::new(EFD_NONBLOCK)?);
+
+        let serial = Serial::with_events(
+            interrupt_evt,
+            SerialEventsWrapper {
+                buffer_ready_event_fd: Some(buffer_read_event_fd),
+            },
+            serial_out,
+        );
+
+        Ok(SerialDevice {
+            serial,
+            input: serial_in,
+        })
+    }
+}
 
 impl<I: Read + AsRawFd + Send + Debug> MutEventSubscriber
     for SerialWrapper<EventFdTrigger, SerialEventsWrapper, I>