console: Flatten PortDescription enum into struct

Make PortDescription a struct instead of an enum with variants. This will allow
for more flexibility when describing behavior of console ports.

Signed-off-by: Matej Hrica <[email protected]>

Author: mtjhrc

src/devices/src/virtio/console/device.rs

@@ -102,10 +102,7 @@ pub struct Console {
 impl Console {
     pub fn new(ports: Vec<PortDescription>) -> super::Result<Console> {
         assert!(!ports.is_empty(), "Expected at least 1 port");
-        assert!(
-            matches!(ports[0], PortDescription::Console { .. }),
-            "First port must be a console"
-        );
+        assert!(ports[0].represents_console, "First port must be a console");
 
         let num_queues = num_queues(ports.len());
         let queues = vec![VirtQueue::new(QUEUE_SIZE); num_queues];

src/devices/src/virtio/console/port.rs

@@ -12,19 +12,49 @@ use crate::virtio::console::process_rx::process_rx;
 use crate::virtio::console::process_tx::process_tx;
 use crate::virtio::{InterruptTransport, Queue};
 
-pub enum PortDescription {
-    Console {
+pub struct PortDescription {
+    pub name: Cow<'static, str>,
+    pub represents_console: bool,
+    pub input: Option<Box<dyn PortInput + Send>>,
+    pub output: Option<Box<dyn PortOutput + Send>>,
+}
+
+impl PortDescription {
+    pub fn console(
         input: Option<Box<dyn PortInput + Send>>,
         output: Option<Box<dyn PortOutput + Send>>,
-    },
-    InputPipe {
-        name: Cow<'static, str>,
-        input: Box<dyn PortInput + Send>,
-    },
-    OutputPipe {
-        name: Cow<'static, str>,
+    ) -> Self {
+        Self {
+            name: "".into(),
+            represents_console: true,
+            input,
+            output,
+        }
+    }
+
+    pub fn output_pipe(
+        name: impl Into<Cow<'static, str>>,
         output: Box<dyn PortOutput + Send>,
-    },
+    ) -> Self {
+        Self {
+            name: name.into(),
+            represents_console: false,
+            input: None,
+            output: Some(output),
+        }
+    }
+
+    pub fn input_pipe(
+        name: impl Into<Cow<'static, str>>,
+        input: Box<dyn PortInput + Send>,
+    ) -> Self {
+        Self {
+            name: name.into(),
+            represents_console: false,
+            input: Some(input),
+            output: None,
+        }
+    }
 }
 
 enum PortState {
@@ -49,31 +79,15 @@ pub(crate) struct Port {
 
 impl Port {
     pub(crate) fn new(port_id: u32, description: PortDescription) -> Self {
-        match description {
-            PortDescription::Console { input, output } => Self {
-                port_id,
-                name: "".into(),
-                represents_console: true,
-                state: PortState::Inactive,
-                input: input.map(|input| Arc::new(Mutex::new(input))),
-                output: output.map(|output| Arc::new(Mutex::new(output))),
-            },
-            PortDescription::InputPipe { name, input } => Self {
-                port_id,
-                name,
-                represents_console: false,
-                state: PortState::Inactive,
-                input: Some(Arc::new(Mutex::new(input))),
-                output: None,
-            },
-            PortDescription::OutputPipe { name, output } => Self {
-                port_id,
-                name,
-                represents_console: false,
-                state: PortState::Inactive,
-                input: None,
-                output: Some(Arc::new(Mutex::new(output))),
-            },
+        Self {
+            port_id,
+            name: description.name,
+            represents_console: description.represents_console,
+            state: PortState::Inactive,
+            input: description.input.map(|input| Arc::new(Mutex::new(input))),
+            output: description
+                .output
+                .map(|output| Arc::new(Mutex::new(output))),
         }
     }
 

src/vmm/src/builder.rs

@@ -1883,10 +1883,10 @@ fn attach_console_devices(
 
     let ports = if console_output_path.is_some() {
         let file = File::create(console_output_path.unwrap()).map_err(OpenConsoleFile)?;
-        vec![PortDescription::Console {
-            input: Some(port_io::input_empty().unwrap()),
-            output: Some(port_io::output_file(file).unwrap()),
-        }]
+        vec![PortDescription::console(
+            Some(port_io::input_empty().unwrap()),
+            Some(port_io::output_file(file).unwrap()),
+        )]
     } else {
         let (input_fd, output_fd, err_fd) = match cfg {
             Some(c) => (c.input_fd, c.output_fd, c.err_fd),
@@ -1928,10 +1928,7 @@ fn attach_console_devices(
             Some(port_io::output_to_log_as_err())
         };
 
-        let mut ports = vec![PortDescription::Console {
-            input: console_input,
-            output: console_output,
-        }];
+        let mut ports = vec![PortDescription::console(console_input, console_output)];
 
         let console_err = if stderr_is_terminal {
             Some(port_io::stderr().unwrap())
@@ -1941,30 +1938,18 @@ fn attach_console_devices(
             None
         };
 
-        ports.push(PortDescription::Console {
-            input: None,
-            output: console_err,
-        });
+        ports.push(PortDescription::console(None, console_err));
 
         if !stdin_is_terminal && input_fd == STDIN_FILENO {
-            ports.push(PortDescription::InputPipe {
-                name: "krun-stdin".into(),
-                input: port_io::stdin().unwrap(),
-            })
+            ports.push(PortDescription::input_pipe("krun-stdin", port_io::stdin().unwrap()));
         }
 
         if !stdout_is_terminal && output_fd == STDOUT_FILENO {
-            ports.push(PortDescription::OutputPipe {
-                name: "krun-stdout".into(),
-                output: port_io::stdout().unwrap(),
-            })
+            ports.push(PortDescription::output_pipe("krun-stdout", port_io::stdout().unwrap()));
         };
 
         if !stderr_is_terminal && err_fd == STDERR_FILENO {
-            ports.push(PortDescription::OutputPipe {
-                name: "krun-stderr".into(),
-                output: port_io::stderr().unwrap(),
-            });
+            ports.push(PortDescription::output_pipe("krun-stderr", port_io::stderr().unwrap()));
         }
 
         ports