From 079d9024be604135ca2016e2bc63e55c013bea39 Mon Sep 17 00:00:00 2001
From: Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>
Date: Tue, 9 Jan 2024 13:39:34 +0000
Subject: [PATCH] vhost-device-console: Add initial implementation

The device was tested with:
1) Upstream QEMU's vhost-user-device

    qemu-system-x86_64  \
            <normal QEMU options> \
            -machine <machine options>,memory-backend=mem0 \
            -object memory-backend-memfd,id=mem0,size=<Guest RAM size> \ # size == -m size
            -chardev socket,id=con0,path=/tmp/console.sock0 \
            -device vhost-user-device-pci,chardev=con0,virtio-id=3,num_vqs=4,config_size=12 \
            ...

2) A new QEMU vhost-user-console device which can be found in the following repo:
- https://github.com/virtualopensystems/qemu/tree/vhu-console-rfc

For more information, please check the README.md file under
staging/vhost-device-console/.

Co-authored-by: dorindabassey <53014273+dorindabassey@users.noreply.github.com>
Signed-off-by: Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>
---
 README.md                                     |    1 +
 staging/Cargo.toml                            |    1 +
 staging/coverage_config_x86_64.json           |    2 +-
 staging/vhost-device-console/CHANGELOG.md     |   15 +
 staging/vhost-device-console/Cargo.toml       |   37 +
 staging/vhost-device-console/LICENSE-APACHE   |    1 +
 .../vhost-device-console/LICENSE-BSD-3-Clause |    1 +
 staging/vhost-device-console/README.md        |  138 ++
 staging/vhost-device-console/src/backend.rs   |  313 ++++
 staging/vhost-device-console/src/console.rs   |   44 +
 staging/vhost-device-console/src/main.rs      |   69 +
 .../vhost-device-console/src/vhu_console.rs   | 1283 +++++++++++++++++
 .../src/virtio_console.rs                     |   60 +
 13 files changed, 1964 insertions(+), 1 deletion(-)
 create mode 100644 staging/vhost-device-console/CHANGELOG.md
 create mode 100644 staging/vhost-device-console/Cargo.toml
 create mode 120000 staging/vhost-device-console/LICENSE-APACHE
 create mode 120000 staging/vhost-device-console/LICENSE-BSD-3-Clause
 create mode 100644 staging/vhost-device-console/README.md
 create mode 100644 staging/vhost-device-console/src/backend.rs
 create mode 100644 staging/vhost-device-console/src/console.rs
 create mode 100644 staging/vhost-device-console/src/main.rs
 create mode 100644 staging/vhost-device-console/src/vhu_console.rs
 create mode 100644 staging/vhost-device-console/src/virtio_console.rs

diff --git a/README.md b/README.md
index f3fb8cd..221d7d8 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,7 @@ Here is the list of device backends in **staging**:
 
 - [Video](https://github.com/rust-vmm/vhost-device/blob/main/staging/vhost-device-video/README.md)
 - [Can](https://github.com/rust-vmm/vhost-device/blob/main/staging/vhost-device-can/README.md)
+- [Console](https://github.com/rust-vmm/vhost-device/blob/main/staging/vhost-device-console/README.md)
 
 <!--
 Template:
diff --git a/staging/Cargo.toml b/staging/Cargo.toml
index c622b67..88d4168 100644
--- a/staging/Cargo.toml
+++ b/staging/Cargo.toml
@@ -3,4 +3,5 @@ resolver = "2"
 members = [
   "vhost-device-video",
   "vhost-device-can",
+  "vhost-device-console",
 ]
diff --git a/staging/coverage_config_x86_64.json b/staging/coverage_config_x86_64.json
index 7bc710f..386cf33 100644
--- a/staging/coverage_config_x86_64.json
+++ b/staging/coverage_config_x86_64.json
@@ -1,5 +1,5 @@
 {
-  "coverage_score": 63.00,
+  "coverage_score": 60.50,
   "exclude_path": "",
   "crate_features": ""
 }
diff --git a/staging/vhost-device-console/CHANGELOG.md b/staging/vhost-device-console/CHANGELOG.md
new file mode 100644
index 0000000..6c84888
--- /dev/null
+++ b/staging/vhost-device-console/CHANGELOG.md
@@ -0,0 +1,15 @@
+# Changelog
+## Unreleased
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Deprecated
+
+## v0.1.0
+
+First release
+
diff --git a/staging/vhost-device-console/Cargo.toml b/staging/vhost-device-console/Cargo.toml
new file mode 100644
index 0000000..aa52036
--- /dev/null
+++ b/staging/vhost-device-console/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "vhost-device-console"
+version = "0.1.0"
+authors = ["Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>"]
+description = "vhost console backend device"
+repository = "https://github.com/rust-vmm/vhost-device"
+readme = "README.md"
+keywords = ["console", "vhost", "virt", "backend"]
+license = "Apache-2.0 OR BSD-3-Clause"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+xen = ["vm-memory/xen", "vhost/xen", "vhost-user-backend/xen"]
+
+[dependencies]
+console = "0.15.7"
+crossterm = "0.27.0"
+nix = "0.26.4"
+queues = "1.0.2"
+clap = { version = "4.4",  features = ["derive"] }
+env_logger = "0.10"
+epoll = "4.3"
+log = "0.4"
+thiserror = "1.0"
+vhost = { version = "0.11", features = ["vhost-user-backend"] }
+vhost-user-backend = "0.15"
+virtio-bindings = "0.2.2"
+virtio-queue = "0.12"
+vm-memory = "0.14.1"
+vmm-sys-util = "0.12"
+
+[dev-dependencies]
+assert_matches = "1.5"
+virtio-queue = { version = "0.12", features = ["test-utils"] }
+vm-memory = { version = "0.14.1", features = ["backend-mmap", "backend-atomic"] }
diff --git a/staging/vhost-device-console/LICENSE-APACHE b/staging/vhost-device-console/LICENSE-APACHE
new file mode 120000
index 0000000..1cd601d
--- /dev/null
+++ b/staging/vhost-device-console/LICENSE-APACHE
@@ -0,0 +1 @@
+../../LICENSE-APACHE
\ No newline at end of file
diff --git a/staging/vhost-device-console/LICENSE-BSD-3-Clause b/staging/vhost-device-console/LICENSE-BSD-3-Clause
new file mode 120000
index 0000000..a60f1af
--- /dev/null
+++ b/staging/vhost-device-console/LICENSE-BSD-3-Clause
@@ -0,0 +1 @@
+../../LICENSE-BSD-3-Clause
\ No newline at end of file
diff --git a/staging/vhost-device-console/README.md b/staging/vhost-device-console/README.md
new file mode 100644
index 0000000..c9eba8a
--- /dev/null
+++ b/staging/vhost-device-console/README.md
@@ -0,0 +1,138 @@
+# vhost-device-console - Console emulation backend daemon
+
+## Description
+
+This program is a vhost-user backend that emulates a VirtIO Console device.
+The device's binary takes as parameters a socket path, a socket number which
+is the number of connections, commonly used across all vhost-devices to
+communicate with the vhost-user frontend devices, and the backend type
+"nested" or "network".
+
+The "nested" backend allows input/output to the guest console through the
+current terminal.
+
+The "network" backend creates a local TCP port (specified on vhost-device-console
+arguments) and allows input/output to the guest console via that socket.
+
+This program is tested with QEMU's `vhost-user-device-pci` device.
+Examples' section below.
+
+## Staging Device
+This device will be in `staging` until we complete the following steps:
+- [ ] Increase test coverage
+- [ ] Support VIRTIO_CONSOLE_F_SIZE feature (optional)
+- [ ] Support VIRTIO_CONSOLE_F_EMERG_WRITE feature (optional)
+
+## Synopsis
+```text
+vhost-device-console --socket-path=<SOCKET_PATH>
+```
+
+## Options
+
+.. program:: vhost-device-console
+
+.. option:: -h, --help
+
+  Print help.
+
+.. option:: -s, --socket-path=PATH
+
+  Location of vhost-user Unix domain sockets, this path will be suffixed with
+  0,1,2..socket_count-1.
+
+.. option:: -p, --tcp-port=PORT_NUMBER
+
+ The localhost's port to be used for each guest, this part will be increased with
+ 0,1,2..socket_count-1.
+
+-- option:: -b, --backend=nested|network
+
+  The backend type vhost-device-console to be used. The current implementation
+  supports two types of backends: "nested", "network" (described above).
+  Note: The nested backend is selected by default and can be used only when
+        socket_count equals 1.
+
+## Limitations
+
+This device is still work-in-progress (WIP). The current version has been tested
+with VIRTIO_CONSOLE_F_MULTIPORT, but only for one console (`max_nr_ports = 1`).
+Also it does not yet support the VIRTIO_CONSOLE_F_EMERG_WRITE and
+VIRTIO_CONSOLE_F_SIZE features.
+
+## Features
+
+The current device gives access to multiple QEMU guest by providing a login prompt
+either by connecting to a localhost server port (network backend) or by creating an
+nested command prompt in the current terminal (nested backend). This prompt appears
+as soon as the guest is fully booted and gives the ability to user run command as a
+in regular terminal.
+
+## Examples
+
+### Dependencies
+For testing the device the required dependencies are:
+- Linux:
+    - Set `CONFIG_VIRTIO_CONSOLE=y`
+- QEMU (optional):
+    - A new vhost-user-console device has been implemented in the following repo:
+      - https://github.com/virtualopensystems/qemu/tree/vhu-console-rfc
+
+
+### Test the device
+
+The daemon should be started first:
+```shell
+host# vhost-device-console --socket-path=/tmp/console.sock --socket-count=1 \
+                           --tcp-port=12345 --backend=network
+```
+>Note: In case the backend is "nested" there is no need to provide
+       "--socket-count" and "--tcp-port" parameters.
+
+The QEMU invocation needs to create a chardev socket the device can
+use to communicate as well as share the guests memory over a memfd.
+
+There are two option for running QEMU with vhost-device-console:
+
+1) Using `vhost-user-console-pci`:
+```text
+host# qemu-system                                               \
+    <normal QEMU options>                                       \
+    -machine <machine options>,memory-backend=mem0              \
+    -object memory-backend-memfd,id=mem0,size=<Guest RAM size>  \ # size == -m size
+    -chardev socket,path=/tmp/console.sock0,id=con              \
+    -device vhost-user-console-pci,chardev=con0,id=console      \
+    ...
+```
+
+> Note: For testing this scenario the reader needs to clone the QEMU version from the following repo
+>       which implements `vhost-user-console` device.
+> - https://github.com/virtualopensystems/qemu/tree/vhu-console-rfc
+
+2) Using `vhost-user-device-pci`:
+```text
+host# qemu-system                                                                   \
+    <normal QEMU options>                                                           \
+    -machine <machine options>,memory-backend=mem0                                  \
+    -object memory-backend-memfd,id=mem0,size=<Guest RAM size>                      \ # size == -m size
+    -chardev socket,id=con0,path=/tmp/console.sock0                                 \
+    -device vhost-user-device-pci,chardev=con0,virtio-id=3,num_vqs=4,config_size=12 \
+    ...
+```
+
+Eventually, the user can connect to the console by running:
+```test
+host# stty -icanon -echo && nc localhost 12345 && stty echo
+```
+
+>Note: `stty -icanon -echo` is used to force the tty layer to disable buffering and send / receive each character individually. After closing the connection please run `stty echo` so character are printed back on the local terminal console.
+
+>Note: In case the backend is "nested" a nested terminal will be shown into
+       vhost-device-console terminal space.
+
+## License
+
+This project is licensed under either of
+
+- [Apache License](http://www.apache.org/licenses/LICENSE-2.0), Version 2.0
+- [BSD-3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
diff --git a/staging/vhost-device-console/src/backend.rs b/staging/vhost-device-console/src/backend.rs
new file mode 100644
index 0000000..62d6745
--- /dev/null
+++ b/staging/vhost-device-console/src/backend.rs
@@ -0,0 +1,313 @@
+// VIRTIO CONSOLE Emulation via vhost-user
+//
+// Copyright 2023-2024 VIRTUAL OPEN SYSTEMS SAS. All Rights Reserved.
+//          Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>
+//
+// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
+
+use log::{error, info, warn};
+use std::any::Any;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::{Arc, RwLock};
+use std::thread::Builder;
+
+use thiserror::Error as ThisError;
+use vhost_user_backend::VhostUserDaemon;
+use vm_memory::{GuestMemoryAtomic, GuestMemoryMmap};
+
+use crate::console::{BackendType, ConsoleController};
+use crate::vhu_console::VhostUserConsoleBackend;
+
+pub(crate) type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, ThisError)]
+/// Errors related to low level Console helpers
+pub(crate) enum Error {
+    #[error("Invalid socket count: {0}")]
+    SocketCountInvalid(usize),
+    #[error("Could not create console backend: {0}")]
+    CouldNotCreateBackend(crate::vhu_console::Error),
+    #[error("Could not create daemon: {0}")]
+    CouldNotCreateDaemon(vhost_user_backend::Error),
+    #[error("Fatal error: {0}")]
+    ServeFailed(vhost_user_backend::Error),
+    #[error("Thread `{0}` panicked")]
+    ThreadPanic(String, Box<dyn Any + Send>),
+    #[error("Error using multiple sockets with Nested backend")]
+    WrongBackendSocket,
+}
+
+#[derive(PartialEq, Debug)]
+pub struct VuConsoleConfig {
+    pub(crate) socket_path: PathBuf,
+    pub(crate) backend: BackendType,
+    pub(crate) tcp_port: String,
+    pub(crate) socket_count: u32,
+}
+
+impl VuConsoleConfig {
+    pub fn generate_socket_paths(&self) -> Vec<PathBuf> {
+        let socket_file_name = self
+            .socket_path
+            .file_name()
+            .expect("socket_path has no filename.");
+        let socket_file_parent = self
+            .socket_path
+            .parent()
+            .expect("socket_path has no parent directory.");
+
+        let make_socket_path = |i: u32| -> PathBuf {
+            let mut file_name = socket_file_name.to_os_string();
+            file_name.push(std::ffi::OsStr::new(&i.to_string()));
+            socket_file_parent.join(&file_name)
+        };
+
+        (0..self.socket_count).map(make_socket_path).collect()
+    }
+
+    pub fn generate_tcp_addrs(&self) -> Vec<String> {
+        let tcp_port_base = self.tcp_port.clone();
+
+        let make_tcp_port = |i: u32| -> String {
+            let port_num: u32 = tcp_port_base.clone().parse().unwrap();
+            "127.0.0.1:".to_owned() + &(port_num + i).to_string()
+        };
+
+        (0..self.socket_count).map(make_tcp_port).collect()
+    }
+}
+
+// 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<()> {
+    loop {
+        let controller = ConsoleController::new(backend);
+        let arc_controller = Arc::new(RwLock::new(controller));
+        let vu_console_backend = Arc::new(RwLock::new(
+            VhostUserConsoleBackend::new(arc_controller).map_err(Error::CouldNotCreateBackend)?,
+        ));
+
+        let mut daemon = VhostUserDaemon::new(
+            String::from("vhost-device-console-backend"),
+            vu_console_backend.clone(),
+            GuestMemoryAtomic::new(GuestMemoryMmap::new()),
+        )
+        .map_err(Error::CouldNotCreateDaemon)?;
+
+        let vring_workers = daemon.get_epoll_handlers();
+        vu_console_backend
+            .read()
+            .unwrap()
+            .set_vring_worker(&vring_workers[0]);
+
+        // Start the corresponding console thread
+        let read_handle = if backend == BackendType::Nested {
+            VhostUserConsoleBackend::start_console_thread(&vu_console_backend)
+        } else {
+            VhostUserConsoleBackend::start_tcp_console_thread(&vu_console_backend, tcp_addr.clone())
+        };
+
+        daemon.serve(&socket).map_err(Error::ServeFailed)?;
+
+        // Kill console input thread
+        vu_console_backend.read().unwrap().kill_console_thread();
+
+        // Wait for read thread to exit
+        match read_handle.join() {
+            Ok(_) => info!("The read thread returned successfully"),
+            Err(e) => warn!("The read thread returned the error: {:?}", e),
+        }
+    }
+}
+
+pub fn start_backend(config: VuConsoleConfig) -> Result<()> {
+    let mut handles = HashMap::new();
+    let (senders, receiver) = std::sync::mpsc::channel();
+    let tcp_addrs = config.generate_tcp_addrs();
+    let backend = config.backend;
+
+    for (thread_id, (socket, tcp_addr)) in config
+        .generate_socket_paths()
+        .into_iter()
+        .zip(tcp_addrs.iter())
+        .enumerate()
+    {
+        let tcp_addr = tcp_addr.clone();
+        info!("thread_id: {}, socket: {:?}", thread_id, socket);
+
+        let name = format!("vhu-console-{}", tcp_addr);
+        let sender = senders.clone();
+        let handle = Builder::new()
+            .name(name.clone())
+            .spawn(move || {
+                let result = std::panic::catch_unwind(move || {
+                    start_backend_server(socket, tcp_addr.to_string(), backend)
+                });
+
+                // Notify the main thread that we are done.
+                sender.send(thread_id).unwrap();
+
+                result.map_err(|e| Error::ThreadPanic(name, e))?
+            })
+            .unwrap();
+        handles.insert(thread_id, handle);
+    }
+
+    while !handles.is_empty() {
+        let thread_id = receiver.recv().unwrap();
+        handles
+            .remove(&thread_id)
+            .unwrap()
+            .join()
+            .map_err(std::panic::resume_unwind)
+            .unwrap()?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ConsoleArgs;
+    use assert_matches::assert_matches;
+
+    #[test]
+    fn test_console_valid_configuration_nested() {
+        let args = ConsoleArgs {
+            socket_path: String::from("/tmp/vhost.sock").into(),
+            backend: BackendType::Nested,
+            tcp_port: String::from("12345"),
+            socket_count: 1,
+        };
+
+        assert!(VuConsoleConfig::try_from(args).is_ok());
+    }
+
+    #[test]
+    fn test_console_invalid_configuration_nested_1() {
+        let args = ConsoleArgs {
+            socket_path: String::from("/tmp/vhost.sock").into(),
+            backend: BackendType::Nested,
+            tcp_port: String::from("12345"),
+            socket_count: 0,
+        };
+
+        assert_matches!(
+            VuConsoleConfig::try_from(args),
+            Err(Error::SocketCountInvalid(0))
+        );
+    }
+
+    #[test]
+    fn test_console_invalid_configuration_nested_2() {
+        let args = ConsoleArgs {
+            socket_path: String::from("/tmp/vhost.sock").into(),
+            backend: BackendType::Nested,
+            tcp_port: String::from("12345"),
+            socket_count: 2,
+        };
+
+        assert_matches!(
+            VuConsoleConfig::try_from(args),
+            Err(Error::WrongBackendSocket)
+        );
+    }
+
+    #[test]
+    fn test_console_valid_configuration_network_1() {
+        let args = ConsoleArgs {
+            socket_path: String::from("/tmp/vhost.sock").into(),
+            backend: BackendType::Network,
+            tcp_port: String::from("12345"),
+            socket_count: 1,
+        };
+
+        assert!(VuConsoleConfig::try_from(args).is_ok());
+    }
+
+    #[test]
+    fn test_console_valid_configuration_network_2() {
+        let args = ConsoleArgs {
+            socket_path: String::from("/tmp/vhost.sock").into(),
+            backend: BackendType::Network,
+            tcp_port: String::from("12345"),
+            socket_count: 2,
+        };
+
+        assert!(VuConsoleConfig::try_from(args).is_ok());
+    }
+
+    fn test_backend_start_and_stop(args: ConsoleArgs) {
+        let config = VuConsoleConfig::try_from(args).expect("Wrong config");
+
+        let tcp_addrs = config.generate_tcp_addrs();
+        let backend = config.backend;
+
+        for (_socket, tcp_addr) in config
+            .generate_socket_paths()
+            .into_iter()
+            .zip(tcp_addrs.iter())
+        {
+            let controller = ConsoleController::new(backend);
+            let arc_controller = Arc::new(RwLock::new(controller));
+            let vu_console_backend = Arc::new(RwLock::new(
+                VhostUserConsoleBackend::new(arc_controller)
+                    .map_err(Error::CouldNotCreateBackend)
+                    .expect("Fail create vhuconsole backend"),
+            ));
+
+            let mut _daemon = VhostUserDaemon::new(
+                String::from("vhost-device-console-backend"),
+                vu_console_backend.clone(),
+                GuestMemoryAtomic::new(GuestMemoryMmap::new()),
+            )
+            .map_err(Error::CouldNotCreateDaemon)
+            .expect("Failed create daemon");
+
+            // Start the corresponinding console thread
+            let read_handle = if backend == BackendType::Nested {
+                VhostUserConsoleBackend::start_console_thread(&vu_console_backend)
+            } else {
+                VhostUserConsoleBackend::start_tcp_console_thread(
+                    &vu_console_backend,
+                    tcp_addr.clone(),
+                )
+            };
+
+            // Kill console input thread
+            vu_console_backend.read().unwrap().kill_console_thread();
+
+            // Wait for read thread to exit
+            assert_matches!(read_handle.join(), Ok(_));
+        }
+    }
+    #[test]
+    fn test_start_net_backend_success() {
+        let args = ConsoleArgs {
+            socket_path: String::from("/tmp/vhost.sock").into(),
+            backend: BackendType::Network,
+            tcp_port: String::from("12345"),
+            socket_count: 1,
+        };
+
+        test_backend_start_and_stop(args);
+    }
+
+    #[test]
+    fn test_start_nested_backend_success() {
+        let args = ConsoleArgs {
+            socket_path: String::from("/tmp/vhost.sock").into(),
+            backend: BackendType::Nested,
+            tcp_port: String::from("12345"),
+            socket_count: 1,
+        };
+
+        test_backend_start_and_stop(args);
+    }
+}
diff --git a/staging/vhost-device-console/src/console.rs b/staging/vhost-device-console/src/console.rs
new file mode 100644
index 0000000..079fe0c
--- /dev/null
+++ b/staging/vhost-device-console/src/console.rs
@@ -0,0 +1,44 @@
+// Console backend device
+//
+// Copyright 2023-2024 VIRTUAL OPEN SYSTEMS SAS. All Rights Reserved.
+//          Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>
+//
+// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
+
+use crate::virtio_console::VirtioConsoleConfig;
+use clap::ValueEnum;
+use log::trace;
+
+#[derive(ValueEnum, Clone, Copy, Default, Debug, Eq, PartialEq)]
+pub enum BackendType {
+    #[default]
+    Nested,
+    Network,
+}
+
+#[derive(Debug)]
+pub(crate) struct ConsoleController {
+    config: VirtioConsoleConfig,
+    pub backend: BackendType,
+    pub exit: bool,
+}
+
+impl ConsoleController {
+    pub(crate) fn new(backend: BackendType) -> ConsoleController {
+        ConsoleController {
+            config: VirtioConsoleConfig {
+                cols: 20.into(),
+                rows: 20.into(),
+                max_nr_ports: 1.into(),
+                emerg_wr: 64.into(),
+            },
+            backend,
+            exit: false,
+        }
+    }
+
+    pub(crate) fn config(&self) -> &VirtioConsoleConfig {
+        trace!("Get config\n");
+        &self.config
+    }
+}
diff --git a/staging/vhost-device-console/src/main.rs b/staging/vhost-device-console/src/main.rs
new file mode 100644
index 0000000..216a01e
--- /dev/null
+++ b/staging/vhost-device-console/src/main.rs
@@ -0,0 +1,69 @@
+// VIRTIO CONSOLE Emulation via vhost-user
+//
+// Copyright 2023-2024 VIRTUAL OPEN SYSTEMS SAS. All Rights Reserved.
+//          Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>
+//
+// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
+
+mod backend;
+mod console;
+mod vhu_console;
+mod virtio_console;
+use crate::console::BackendType;
+use clap::Parser;
+use log::error;
+use std::path::PathBuf;
+use std::process::exit;
+
+pub(crate) type Result<T> = std::result::Result<T, Error>;
+use crate::backend::{start_backend, Error, VuConsoleConfig};
+
+#[derive(Parser, Debug)]
+#[clap(author, version, about, long_about = None)]
+struct ConsoleArgs {
+    /// Location of vhost-user Unix domain socket. This is suffixed by 0,1,2..socket_count-1.
+    #[clap(short = 's', long, value_name = "SOCKET")]
+    socket_path: PathBuf,
+
+    /// Number of guests (sockets) to connect to.
+    #[clap(short = 'c', long, default_value_t = 1)]
+    socket_count: u32,
+
+    /// Console backend (Network, Nested) to be used.
+    #[clap(short = 'b', long, value_enum, default_value = "nested")]
+    backend: BackendType,
+
+    /// Initial tcp port to be used with "network" backend. If socket_count is N then
+    /// the following tcp ports will be created: tcp_port, tcp_port + 1, ..., tcp_port + (N - 1).
+    #[clap(short = 'p', long, value_name = "PORT", default_value = "12345")]
+    tcp_port: String,
+}
+
+impl TryFrom<ConsoleArgs> for VuConsoleConfig {
+    type Error = Error;
+
+    fn try_from(args: ConsoleArgs) -> Result<Self> {
+        if args.socket_count == 0 {
+            return Err(Error::SocketCountInvalid(0));
+        }
+
+        if (args.backend == BackendType::Nested) && (args.socket_count != 1) {
+            return Err(Error::WrongBackendSocket);
+        }
+
+        Ok(VuConsoleConfig {
+            socket_path: args.socket_path,
+            backend: args.backend,
+            tcp_port: args.tcp_port,
+            socket_count: args.socket_count,
+        })
+    }
+}
+
+fn main() {
+    env_logger::init();
+    if let Err(e) = VuConsoleConfig::try_from(ConsoleArgs::parse()).and_then(start_backend) {
+        error!("{e}");
+        exit(1);
+    }
+}
diff --git a/staging/vhost-device-console/src/vhu_console.rs b/staging/vhost-device-console/src/vhu_console.rs
new file mode 100644
index 0000000..d5cca74
--- /dev/null
+++ b/staging/vhost-device-console/src/vhu_console.rs
@@ -0,0 +1,1283 @@
+// vhost device console
+//
+// Copyright 2023-2024 VIRTUAL OPEN SYSTEMS SAS. All Rights Reserved.
+//          Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>
+//
+// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
+
+use crate::console::{BackendType, ConsoleController};
+use crate::virtio_console::{
+    VirtioConsoleControl, VIRTIO_CONSOLE_CONSOLE_PORT, VIRTIO_CONSOLE_DEVICE_READY,
+    VIRTIO_CONSOLE_F_MULTIPORT, VIRTIO_CONSOLE_PORT_ADD, VIRTIO_CONSOLE_PORT_NAME,
+    VIRTIO_CONSOLE_PORT_OPEN, VIRTIO_CONSOLE_PORT_READY,
+};
+use console::Key;
+use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
+use log::{error, trace};
+use nix::sys::select::{select, FdSet};
+use std::os::fd::AsRawFd;
+use std::slice::from_raw_parts;
+use std::sync::{Arc, RwLock};
+use std::thread::JoinHandle;
+use std::{
+    convert,
+    io::{self, Result as IoResult},
+};
+use thiserror::Error as ThisError;
+use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures};
+use vhost_user_backend::VringEpollHandler;
+use vhost_user_backend::{VhostUserBackendMut, VringRwLock, VringT};
+use virtio_bindings::bindings::virtio_config::{VIRTIO_F_NOTIFY_ON_EMPTY, VIRTIO_F_VERSION_1};
+use virtio_bindings::bindings::virtio_ring::{
+    VIRTIO_RING_F_EVENT_IDX, VIRTIO_RING_F_INDIRECT_DESC,
+};
+use virtio_queue::{DescriptorChain, QueueOwnedT};
+use vm_memory::{
+    ByteValued, GuestAddressSpace, GuestMemoryAtomic, GuestMemoryLoadGuard, GuestMemoryMmap,
+};
+use vmm_sys_util::epoll::EventSet;
+use vmm_sys_util::eventfd::{EventFd, EFD_NONBLOCK};
+
+use console::Term;
+use queues::{IsQueue, Queue};
+use std::io::Read;
+use std::io::Write;
+use std::net::TcpListener;
+use std::thread::spawn;
+
+/// Virtio configuration
+const QUEUE_SIZE: usize = 128;
+const NUM_QUEUES: usize = 4;
+
+/// Queue events
+const RX_QUEUE: u16 = 0;
+const TX_QUEUE: u16 = 1;
+const CTRL_RX_QUEUE: u16 = 2;
+const CTRL_TX_QUEUE: u16 = 3;
+
+/// The two following events are used to help the vhu_console
+/// backend trigger events to itself. For example:
+/// a) BACKEND_RX_EFD is being triggered when the backend
+///    has new data to send to the RX queue.
+/// b) BACKEND_CTRL_RX_EFD event is used when the backend
+///    needs to write to the RX control queue.
+const BACKEND_RX_EFD: u16 = (NUM_QUEUES + 1) as u16;
+const BACKEND_CTRL_RX_EFD: u16 = (NUM_QUEUES + 2) as u16;
+
+/// Port name - Need to be updated when MULTIPORT feature
+///             is supported for more than one devices.
+const PORT_NAME: &[u8] = b"org.test.foo!";
+
+type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Copy, Clone, Debug, PartialEq, ThisError)]
+pub(crate) enum Error {
+    #[error("Failed to handle unknown event")]
+    HandleEventUnknown,
+    #[error("Descriptor not found")]
+    DescriptorNotFound,
+    #[error("Failed to send notification")]
+    NotificationFailed,
+    #[error("Descriptor read failed")]
+    DescriptorReadFailed,
+    #[error("Descriptor write failed")]
+    DescriptorWriteFailed,
+    #[error("Add used element in vring {0} failed")]
+    AddUsedElemFailed(u16),
+    #[error("Failed to create new EventFd")]
+    EventFdFailed,
+    #[error("Failed to add control message in the internal queue")]
+    RxCtrlQueueAddFailed,
+}
+
+impl convert::From<Error> for io::Error {
+    fn from(e: Error) -> Self {
+        io::Error::new(io::ErrorKind::Other, e)
+    }
+}
+
+// SAFETY: The layout of the structure is fixed and can be initialized by
+// reading its content from byte array.
+unsafe impl ByteValued for VirtioConsoleControl {}
+
+pub(crate) struct VhostUserConsoleBackend {
+    controller: Arc<RwLock<ConsoleController>>,
+    acked_features: u64,
+    event_idx: bool,
+    rx_ctrl_fifo: Queue<VirtioConsoleControl>,
+    rx_data_fifo: Queue<String>,
+    pub(crate) ready: bool,
+    pub(crate) ready_to_write: bool,
+    pub(crate) output_queue: Queue<String>,
+    pub(crate) rx_event: EventFd,
+    pub(crate) rx_ctrl_event: EventFd,
+    pub(crate) exit_event: EventFd,
+    mem: Option<GuestMemoryAtomic<GuestMemoryMmap>>,
+}
+
+type ConsoleDescriptorChain = DescriptorChain<GuestMemoryLoadGuard<GuestMemoryMmap<()>>>;
+
+impl VhostUserConsoleBackend {
+    pub(crate) fn new(controller: Arc<RwLock<ConsoleController>>) -> Result<Self> {
+        Ok(VhostUserConsoleBackend {
+            controller,
+            event_idx: false,
+            rx_ctrl_fifo: Queue::new(),
+            rx_data_fifo: Queue::new(),
+            acked_features: 0x0,
+            ready: false,
+            ready_to_write: false,
+            output_queue: Queue::new(),
+            rx_event: EventFd::new(EFD_NONBLOCK).map_err(|_| Error::EventFdFailed)?,
+            rx_ctrl_event: EventFd::new(EFD_NONBLOCK).map_err(|_| Error::EventFdFailed)?,
+            exit_event: EventFd::new(EFD_NONBLOCK).map_err(|_| Error::EventFdFailed)?,
+            mem: None,
+        })
+    }
+
+    fn print_console_frame(&self, control_msg: VirtioConsoleControl) {
+        trace!("id 0x{:x}", control_msg.id.to_native());
+        trace!("event 0x{:x}", control_msg.event.to_native());
+        trace!("value 0x{:x}", control_msg.value.to_native());
+    }
+
+    fn process_rx_requests(
+        &mut self,
+        requests: Vec<ConsoleDescriptorChain>,
+        vring: &VringRwLock,
+    ) -> Result<bool> {
+        if requests.is_empty() {
+            return Ok(true);
+        }
+
+        for desc_chain in requests {
+            let atomic_mem = self.mem.as_ref().unwrap().memory();
+            let mut writer = desc_chain
+                .clone()
+                .writer(&atomic_mem)
+                .map_err(|_| Error::DescriptorWriteFailed)?;
+
+            let response: String = match self.rx_data_fifo.remove() {
+                Ok(item) => item,
+                _ => {
+                    return Ok(false);
+                }
+            };
+
+            for b in response.bytes() {
+                writer
+                    .write_obj::<u8>(b)
+                    .map_err(|_| Error::DescriptorWriteFailed)?;
+            }
+
+            vring
+                .add_used(desc_chain.head_index(), writer.bytes_written() as u32)
+                .map_err(|_| Error::AddUsedElemFailed(RX_QUEUE))?;
+        }
+
+        Ok(true)
+    }
+
+    fn process_tx_requests(
+        &mut self,
+        requests: Vec<ConsoleDescriptorChain>,
+        vring: &VringRwLock,
+    ) -> Result<bool> {
+        if requests.is_empty() {
+            return Ok(true);
+        }
+
+        for desc_chain in requests {
+            let atomic_mem = self.mem.as_ref().unwrap().memory();
+            let mut reader = desc_chain
+                .clone()
+                .reader(&atomic_mem)
+                .map_err(|_| Error::DescriptorReadFailed)?;
+
+            let mut tx_data: Vec<u8> = Vec::new();
+            let data_len = reader.available_bytes();
+            for _i in 0..data_len {
+                let data_byte = reader
+                    .read_obj::<u8>()
+                    .map_err(|_| Error::DescriptorReadFailed)?;
+                tx_data.push(data_byte);
+            }
+
+            let my_string = String::from_utf8(tx_data).unwrap();
+            if self.controller.read().unwrap().backend == BackendType::Nested {
+                print!("{}", my_string);
+                io::stdout().flush().unwrap();
+            } else {
+                self.output_queue
+                    .add(my_string)
+                    .expect("Failed to add element in the output queue");
+                //.map_err(|_| Error::RxCtrlQueueAddFailed)?;
+            }
+
+            vring
+                .add_used(desc_chain.head_index(), reader.bytes_read() as u32)
+                .map_err(|_| Error::AddUsedElemFailed(TX_QUEUE))?;
+        }
+
+        Ok(true)
+    }
+
+    fn process_ctrl_rx_requests(
+        &mut self,
+        requests: Vec<ConsoleDescriptorChain>,
+        vring: &VringRwLock,
+    ) -> Result<bool> {
+        let mut used_flag = false;
+
+        if requests.is_empty() {
+            return Ok(true);
+        }
+
+        for desc_chain in requests {
+            let atomic_mem = self.mem.as_ref().unwrap().memory();
+            let mut writer = desc_chain
+                .clone()
+                .writer(&atomic_mem)
+                .map_err(|_| Error::DescriptorWriteFailed)?;
+
+            let ctrl_msg: VirtioConsoleControl = match self.rx_ctrl_fifo.remove() {
+                Ok(item) => {
+                    used_flag = true;
+                    item
+                }
+                _ => {
+                    return Ok(used_flag);
+                }
+            };
+
+            self.print_console_frame(ctrl_msg);
+
+            let mut buffer: Vec<u8> = Vec::new();
+            buffer.extend_from_slice(&ctrl_msg.to_le_bytes());
+
+            if ctrl_msg.event.to_native() == VIRTIO_CONSOLE_PORT_NAME {
+                buffer.extend_from_slice(PORT_NAME);
+            };
+
+            writer
+                .write(buffer.as_slice())
+                .map_err(|_| Error::DescriptorWriteFailed)?;
+
+            vring
+                .add_used(desc_chain.head_index(), writer.bytes_written() as u32)
+                .map_err(|_| Error::AddUsedElemFailed(CTRL_RX_QUEUE))?;
+        }
+
+        Ok(true)
+    }
+
+    fn handle_control_msg(&mut self, ctrl_msg: VirtioConsoleControl) -> Result<()> {
+        let mut ctrl_msg_reply = VirtioConsoleControl {
+            id: 0.into(),
+            event: 0.into(),
+            value: 1.into(),
+        };
+        match ctrl_msg.event.to_native() {
+            VIRTIO_CONSOLE_DEVICE_READY => {
+                trace!("VIRTIO_CONSOLE_DEVICE_READY");
+
+                if ctrl_msg.value != 1 {
+                    trace!("Guest failure in adding device");
+                    return Ok(());
+                }
+
+                self.ready = true;
+                ctrl_msg_reply.event = VIRTIO_CONSOLE_PORT_ADD.into();
+                self.rx_ctrl_fifo
+                    .add(ctrl_msg_reply)
+                    .map_err(|_| Error::RxCtrlQueueAddFailed)?;
+            }
+            VIRTIO_CONSOLE_PORT_READY => {
+                trace!("VIRTIO_CONSOLE_PORT_READY");
+
+                if ctrl_msg.value != 1 {
+                    trace!("Guest failure in adding port for device");
+                    return Ok(());
+                }
+
+                ctrl_msg_reply.event = VIRTIO_CONSOLE_CONSOLE_PORT.into();
+                self.rx_ctrl_fifo
+                    .add(ctrl_msg_reply)
+                    .map_err(|_| Error::RxCtrlQueueAddFailed)?;
+
+                ctrl_msg_reply.event = VIRTIO_CONSOLE_PORT_NAME.into();
+                self.rx_ctrl_fifo
+                    .add(ctrl_msg_reply)
+                    .map_err(|_| Error::RxCtrlQueueAddFailed)?;
+
+                ctrl_msg_reply.event = VIRTIO_CONSOLE_PORT_OPEN.into();
+                self.rx_ctrl_fifo
+                    .add(ctrl_msg_reply)
+                    .map_err(|_| Error::RxCtrlQueueAddFailed)?;
+            }
+            VIRTIO_CONSOLE_PORT_OPEN => {
+                trace!("VIRTIO_CONSOLE_PORT_OPEN");
+            }
+            _ => {
+                trace!("Uknown control event");
+                return Err(Error::HandleEventUnknown);
+            }
+        };
+        Ok(())
+    }
+
+    fn process_ctrl_tx_requests(
+        &mut self,
+        requests: Vec<ConsoleDescriptorChain>,
+        vring: &VringRwLock,
+    ) -> Result<bool> {
+        if requests.is_empty() {
+            return Ok(true);
+        }
+
+        for desc_chain in requests {
+            let atomic_mem = self.mem.as_ref().unwrap().memory();
+            let mut reader = desc_chain
+                .clone()
+                .reader(&atomic_mem)
+                .map_err(|_| Error::DescriptorReadFailed)?;
+
+            let request = reader
+                .read_obj::<VirtioConsoleControl>()
+                .map_err(|_| Error::DescriptorReadFailed)?;
+
+            // Print the receive console frame
+            self.print_console_frame(request);
+
+            // Process the received control frame
+            self.handle_control_msg(request)?;
+
+            // trigger a kick to the CTRL_RT_QUEUE
+            self.rx_ctrl_event.write(1).unwrap();
+
+            vring
+                .add_used(desc_chain.head_index(), reader.bytes_read() as u32)
+                .map_err(|_| Error::AddUsedElemFailed(CTRL_TX_QUEUE))?;
+        }
+
+        Ok(true)
+    }
+
+    /// Process the messages in the vring and dispatch replies
+    fn process_rx_queue(&mut self, vring: &VringRwLock) -> Result<()> {
+        let requests: Vec<_> = vring
+            .get_mut()
+            .get_queue_mut()
+            .iter(self.mem.as_ref().unwrap().memory())
+            .map_err(|_| Error::DescriptorNotFound)?
+            .collect();
+
+        if self.process_rx_requests(requests, vring)? {
+            // Send notification once all the requests are processed
+            vring
+                .signal_used_queue()
+                .map_err(|_| Error::NotificationFailed)?;
+        }
+        Ok(())
+    }
+
+    /// Process the messages in the vring and dispatch replies
+    fn process_tx_queue(&mut self, vring: &VringRwLock) -> Result<()> {
+        let requests: Vec<_> = vring
+            .get_mut()
+            .get_queue_mut()
+            .iter(self.mem.as_ref().unwrap().memory())
+            .map_err(|_| Error::DescriptorNotFound)?
+            .collect();
+
+        if self.process_tx_requests(requests, vring)? {
+            // Send notification once all the requests are processed
+            vring
+                .signal_used_queue()
+                .map_err(|_| Error::NotificationFailed)?;
+        }
+        Ok(())
+    }
+
+    /// Process the messages in the vring and dispatch replies
+    fn process_ctrl_rx_queue(&mut self, vring: &VringRwLock) -> Result<()> {
+        let requests: Vec<_> = vring
+            .get_mut()
+            .get_queue_mut()
+            .iter(self.mem.as_ref().unwrap().memory())
+            .map_err(|_| Error::DescriptorNotFound)?
+            .collect();
+
+        if self.process_ctrl_rx_requests(requests, vring)? {
+            // Send notification once all the requests are processed
+            vring
+                .signal_used_queue()
+                .map_err(|_| Error::NotificationFailed)?;
+        }
+        Ok(())
+    }
+
+    /// Process the messages in the vring and dispatch replies
+    fn process_ctrl_tx_queue(&mut self, vring: &VringRwLock) -> Result<()> {
+        let requests: Vec<_> = vring
+            .get_mut()
+            .get_queue_mut()
+            .iter(self.mem.as_ref().unwrap().memory())
+            .map_err(|_| Error::DescriptorNotFound)?
+            .collect();
+
+        if self.process_ctrl_tx_requests(requests, vring)? {
+            // Send notification once all the requests are processed
+            vring
+                .signal_used_queue()
+                .map_err(|_| Error::NotificationFailed)?;
+        }
+        Ok(())
+    }
+
+    /// Set self's VringWorker.
+    pub(crate) fn set_vring_worker(
+        &self,
+        vring_worker: &Arc<VringEpollHandler<Arc<RwLock<VhostUserConsoleBackend>>>>,
+    ) {
+        let rx_event_fd = self.rx_event.as_raw_fd();
+        vring_worker
+            .register_listener(rx_event_fd, EventSet::IN, u64::from(BACKEND_RX_EFD))
+            .unwrap();
+
+        let rx_ctrl_event_fd = self.rx_ctrl_event.as_raw_fd();
+        vring_worker
+            .register_listener(
+                rx_ctrl_event_fd,
+                EventSet::IN,
+                u64::from(BACKEND_CTRL_RX_EFD),
+            )
+            .unwrap();
+    }
+
+    pub(crate) fn start_tcp_console_thread(
+        vhu_console: &Arc<RwLock<VhostUserConsoleBackend>>,
+        tcplisener_str: String,
+    ) -> JoinHandle<Result<()>> {
+        let vhu_console = Arc::clone(vhu_console);
+        spawn(move || {
+            loop {
+                let ready = vhu_console.read().unwrap().ready_to_write;
+                let exit = vhu_console.read().unwrap().controller.read().unwrap().exit;
+
+                if exit {
+                    trace!("Thread exits!");
+                    break;
+                } else if ready {
+                    let listener = match TcpListener::bind(tcplisener_str.clone()) {
+                        Ok(listener) => listener,
+                        Err(e) => {
+                            eprintln!("Failed to bind to {}: {}", tcplisener_str, e);
+                            return Ok(());
+                        }
+                    };
+                    listener.set_nonblocking(true).expect("Non-blocking error");
+
+                    println!("Server listening on address: {}", tcplisener_str.clone());
+                    for stream in listener.incoming() {
+                        match stream {
+                            Ok(mut stream) => {
+                                trace!("New connection");
+                                stream.set_nonblocking(true).expect("Non-blocking error");
+
+                                let mut buffer = [0; 1024];
+                                loop {
+                                    let exit =
+                                        vhu_console.read().unwrap().controller.read().unwrap().exit;
+                                    if exit {
+                                        trace!("Thread exits!");
+                                        return Ok(());
+                                    }
+                                    // Write to the stream
+                                    if vhu_console.read().unwrap().output_queue.size() > 0 {
+                                        let byte_stream = vhu_console
+                                            .write()
+                                            .unwrap()
+                                            .output_queue
+                                            .remove()
+                                            .expect("Error removing element from output queue")
+                                            .into_bytes();
+                                        if let Err(e) = stream.write_all(&byte_stream) {
+                                            eprintln!("Error writing to stream: {}", e);
+                                        }
+                                    }
+                                    match stream.read(&mut buffer) {
+                                        Ok(bytes_read) => {
+                                            if bytes_read == 0 {
+                                                println!("Close connection");
+                                                break;
+                                            }
+                                            trace!(
+                                                "Received: {}",
+                                                String::from_utf8_lossy(&buffer[..bytes_read])
+                                            );
+                                            let input_buffer =
+                                                String::from_utf8_lossy(&buffer[..bytes_read])
+                                                    .to_string();
+                                            vhu_console
+                                                .write()
+                                                .unwrap()
+                                                .rx_data_fifo
+                                                .add(input_buffer)
+                                                .unwrap();
+                                            vhu_console.write().unwrap().rx_event.write(1).unwrap();
+                                        }
+                                        Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                                            continue;
+                                        }
+                                        Err(ref e)
+                                            if e.kind() == io::ErrorKind::BrokenPipe
+                                                || e.kind() == io::ErrorKind::ConnectionReset =>
+                                        {
+                                            trace!("Stream has been closed.");
+                                            break;
+                                        }
+                                        Err(e) => {
+                                            eprintln!("Error reading from socket: {}", e);
+                                        }
+                                    }
+                                }
+                            }
+                            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                                let exit =
+                                    vhu_console.read().unwrap().controller.read().unwrap().exit;
+                                if exit {
+                                    trace!("Thread exits!");
+                                    return Ok(());
+                                }
+                                continue;
+                            }
+                            Err(e) => {
+                                eprintln!("Error accepting connection: {}", e);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            Ok(())
+        })
+    }
+
+    /// Start console thread.
+    pub(crate) fn start_console_thread(
+        vhu_console: &Arc<RwLock<VhostUserConsoleBackend>>,
+    ) -> JoinHandle<Result<()>> {
+        let vhu_console = Arc::clone(vhu_console);
+
+        let exit_eventfd = vhu_console.read().unwrap().exit_event.as_raw_fd();
+        // Spawn a new thread to handle input.
+        spawn(move || {
+            let term = Term::stdout();
+            let mut fdset = FdSet::new();
+            fdset.insert(term.as_raw_fd());
+            fdset.insert(exit_eventfd);
+            let max_fd = fdset.highest().expect("Failed to read fdset!") + 1;
+
+            loop {
+                let ready = vhu_console.read().unwrap().ready_to_write;
+                let exit = vhu_console.read().unwrap().controller.read().unwrap().exit;
+
+                if exit {
+                    trace!("Exit!");
+                    break;
+                } else if ready {
+                    let mut fdset_clone = fdset;
+                    enable_raw_mode().expect("Raw mode error");
+
+                    match select(Some(max_fd), Some(&mut fdset_clone), None, None, None) {
+                        Ok(_num_fds) => {
+                            let exit = vhu_console.read().unwrap().controller.read().unwrap().exit;
+                            if (fdset_clone.contains(exit_eventfd)) && exit {
+                                trace!("Exit!");
+                                break;
+                            }
+
+                            if fdset_clone.contains(term.as_raw_fd()) {
+                                if let Some(character) = match term.read_key().unwrap() {
+                                    Key::Char(character) => Some(character),
+                                    Key::Enter => Some('\n'),
+                                    Key::Tab => Some('\t'),
+                                    Key::Backspace => Some('\u{8}'),
+                                    _ => None,
+                                } {
+                                    // Pass the data to vhu_console and trigger an EventFd
+                                    let input_buffer = character.to_string();
+                                    vhu_console
+                                        .write()
+                                        .unwrap()
+                                        .rx_data_fifo
+                                        .add(input_buffer)
+                                        .unwrap();
+                                    vhu_console.write().unwrap().rx_event.write(1).unwrap();
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            eprintln!("Error in select: {}", e);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            disable_raw_mode().expect("Raw mode error");
+            Ok(())
+        })
+    }
+    pub fn kill_console_thread(&self) {
+        trace!("Kill thread");
+        self.controller.write().unwrap().exit = true;
+        self.exit_event.write(1).unwrap();
+    }
+}
+
+/// VhostUserBackendMut trait methods
+impl VhostUserBackendMut for VhostUserConsoleBackend {
+    type Vring = VringRwLock;
+    type Bitmap = ();
+
+    fn num_queues(&self) -> usize {
+        NUM_QUEUES
+    }
+
+    fn max_queue_size(&self) -> usize {
+        QUEUE_SIZE
+    }
+
+    fn features(&self) -> u64 {
+        1 << VIRTIO_F_VERSION_1
+            | 1 << VIRTIO_F_NOTIFY_ON_EMPTY
+            | 1 << VIRTIO_RING_F_EVENT_IDX
+            | 1 << VIRTIO_RING_F_INDIRECT_DESC
+            | 1 << VIRTIO_CONSOLE_F_MULTIPORT
+            | VhostUserVirtioFeatures::PROTOCOL_FEATURES.bits()
+    }
+
+    fn acked_features(&mut self, features: u64) {
+        self.acked_features = features;
+    }
+
+    fn protocol_features(&self) -> VhostUserProtocolFeatures {
+        VhostUserProtocolFeatures::MQ
+            | VhostUserProtocolFeatures::CONFIG
+            | VhostUserProtocolFeatures::REPLY_ACK
+    }
+
+    fn get_config(&self, offset: u32, size: u32) -> Vec<u8> {
+        // SAFETY: The layout of the structure is fixed and can be initialized by
+        // reading its content from byte array.
+        unsafe {
+            from_raw_parts(
+                self.controller
+                    .write()
+                    .unwrap()
+                    .config()
+                    .as_slice()
+                    .as_ptr()
+                    .offset(offset as isize) as *const _ as *const _,
+                size as usize,
+            )
+            .to_vec()
+        }
+    }
+
+    fn set_event_idx(&mut self, enabled: bool) {
+        self.event_idx = enabled;
+    }
+
+    fn update_memory(&mut self, mem: GuestMemoryAtomic<GuestMemoryMmap>) -> IoResult<()> {
+        self.mem = Some(mem);
+        Ok(())
+    }
+
+    fn handle_event(
+        &mut self,
+        device_event: u16,
+        _evset: EventSet,
+        vrings: &[VringRwLock],
+        _thread_id: usize,
+    ) -> IoResult<()> {
+        if device_event == RX_QUEUE {
+            // Check if there are any available data
+            if self.rx_data_fifo.size() == 0 {
+                return Ok(());
+            }
+        };
+
+        if device_event == CTRL_RX_QUEUE {
+            // Check if there are any available data and the device is ready
+            if (!self.ready) || (self.rx_ctrl_fifo.size() == 0) {
+                return Ok(());
+            }
+        };
+
+        let vring = if device_event == BACKEND_RX_EFD {
+            &vrings[RX_QUEUE as usize]
+        } else if device_event == BACKEND_CTRL_RX_EFD {
+            &vrings[CTRL_RX_QUEUE as usize]
+        } else {
+            &vrings[device_event as usize]
+        };
+
+        if self.event_idx {
+            loop {
+                vring.disable_notification().unwrap();
+                match device_event {
+                    RX_QUEUE => self.process_rx_queue(vring),
+                    TX_QUEUE => {
+                        self.ready_to_write = true;
+                        self.process_tx_queue(vring)
+                    }
+                    CTRL_RX_QUEUE => self.process_ctrl_rx_queue(vring),
+                    CTRL_TX_QUEUE => self.process_ctrl_tx_queue(vring),
+                    BACKEND_RX_EFD => {
+                        let _ = self.rx_event.read();
+                        self.process_rx_queue(vring)
+                    }
+                    BACKEND_CTRL_RX_EFD => {
+                        let _ = self.rx_ctrl_event.read();
+                        self.process_ctrl_rx_queue(vring)
+                    }
+                    _ => Err(Error::HandleEventUnknown),
+                }?;
+                if !vring.enable_notification().unwrap() {
+                    break;
+                }
+            }
+        } else {
+            match device_event {
+                RX_QUEUE => self.process_rx_queue(vring),
+                TX_QUEUE => {
+                    self.ready_to_write = true;
+                    self.process_tx_queue(vring)
+                }
+                CTRL_RX_QUEUE => self.process_ctrl_rx_queue(vring),
+                CTRL_TX_QUEUE => self.process_ctrl_tx_queue(vring),
+                BACKEND_RX_EFD => {
+                    let _ = self.rx_event.read();
+                    self.process_rx_queue(vring)
+                }
+                BACKEND_CTRL_RX_EFD => {
+                    let _ = self.rx_ctrl_event.read();
+                    self.process_ctrl_rx_queue(vring)
+                }
+                _ => Err(Error::HandleEventUnknown),
+            }?;
+        }
+        Ok(())
+    }
+
+    fn exit_event(&self, _thread_index: usize) -> Option<EventFd> {
+        self.exit_event.try_clone().ok()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use virtio_bindings::virtio_ring::{VRING_DESC_F_NEXT, VRING_DESC_F_WRITE};
+    use virtio_queue::{mock::MockSplitQueue, Descriptor, Queue};
+    use vm_memory::{Bytes, GuestAddress, GuestMemoryAtomic, GuestMemoryMmap};
+
+    #[test]
+    fn test_vhost_user_console_backend_creation() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let vhost_user_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        assert_eq!(vhost_user_console_backend.acked_features, 0);
+        assert!(!vhost_user_console_backend.event_idx);
+        assert!(!vhost_user_console_backend.ready);
+        assert!(!vhost_user_console_backend.ready_to_write);
+    }
+
+    #[test]
+    fn test_virtio_console_empty_handle_request() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let mut vu_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        // Artificial memory
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap(),
+        );
+
+        // Update memory
+        vu_console_backend.update_memory(mem.clone()).unwrap();
+
+        // Artificial Vring
+        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()];
+
+        vu_console_backend
+            .handle_event(RX_QUEUE, EventSet::IN, &list_vrings, 0)
+            .unwrap();
+
+        vu_console_backend
+            .handle_event(TX_QUEUE, EventSet::IN, &list_vrings, 0)
+            .unwrap();
+
+        vu_console_backend
+            .handle_event(CTRL_RX_QUEUE, EventSet::IN, &list_vrings, 0)
+            .unwrap();
+
+        vu_console_backend
+            .handle_event(CTRL_TX_QUEUE, EventSet::IN, &list_vrings, 0)
+            .unwrap();
+
+        vu_console_backend
+            .handle_event(BACKEND_RX_EFD, EventSet::IN, &list_vrings, 0)
+            .unwrap();
+
+        vu_console_backend
+            .handle_event(BACKEND_CTRL_RX_EFD, EventSet::IN, &list_vrings, 0)
+            .unwrap();
+    }
+
+    #[test]
+    fn test_virtio_console_empty_requests() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let mut vu_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        // Artificial memory
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap(),
+        );
+
+        // Artificial Vring
+        let vring = VringRwLock::new(mem.clone(), 0x1000).unwrap();
+
+        // Empty descriptor chain should be ignored
+        assert!(vu_console_backend
+            .process_rx_requests(Vec::<ConsoleDescriptorChain>::new(), &vring)
+            .is_ok());
+        assert!(vu_console_backend
+            .process_tx_requests(Vec::<ConsoleDescriptorChain>::new(), &vring)
+            .is_ok());
+        assert!(vu_console_backend
+            .process_ctrl_rx_requests(Vec::<ConsoleDescriptorChain>::new(), &vring)
+            .is_ok());
+        assert!(vu_console_backend
+            .process_ctrl_tx_requests(Vec::<ConsoleDescriptorChain>::new(), &vring)
+            .is_ok());
+    }
+
+    fn build_desc_chain(
+        mem: &GuestMemoryMmap,
+        count: u16,
+        flags: Vec<u16>,
+        len: u32,
+    ) -> ConsoleDescriptorChain {
+        let vq = MockSplitQueue::new(mem, 16);
+        let mut desc_vec = Vec::new();
+
+        //Create a descriptor chain with @count descriptors.
+        for i in 0..count {
+            let desc_flags = if i < count - 1 {
+                flags[i as usize] | VRING_DESC_F_NEXT as u16
+            } else {
+                flags[i as usize] & !VRING_DESC_F_NEXT as u16
+            };
+
+            let desc = Descriptor::new((0x100 * (i + 1)) as u64, len, desc_flags, i + 1);
+            desc_vec.push(desc);
+        }
+
+        vq.add_desc_chains(&desc_vec, 0).unwrap();
+
+        // Create descriptor chain from pre-filled memory
+        vq.create_queue::<Queue>()
+            .unwrap()
+            .iter(GuestMemoryAtomic::new(mem.clone()).memory())
+            .unwrap()
+            .next()
+            .unwrap()
+    }
+
+    #[test]
+    fn test_virtio_console_ctrl_rx_request() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let mut vu_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        // Artificial memory
+        let mem = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap();
+
+        // Test 1: Empty queue
+        let mem1 = GuestMemoryAtomic::new(mem.clone());
+        let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
+        assert!(vu_console_backend
+            .process_ctrl_rx_requests(vec![], &vring)
+            .unwrap());
+
+        // Test 2: Found no rx elements
+        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
+            .process_ctrl_rx_requests(vec![desc_chain], &vring)
+            .unwrap());
+
+        // Test 3: empty queue
+        let desc_chain = build_desc_chain(&mem, 1, vec![VRING_DESC_F_WRITE as u16], 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
+            .process_ctrl_rx_requests(vec![desc_chain.clone()], &vring)
+            .unwrap());
+
+        // Test 4: the written desc reply
+        let ctrl_msg = VirtioConsoleControl {
+            id: 0.into(),
+            event: VIRTIO_CONSOLE_PORT_ADD.into(),
+            value: 1.into(),
+        };
+        let _ = vu_console_backend.rx_ctrl_fifo.add(ctrl_msg);
+
+        assert!(vu_console_backend
+            .process_ctrl_rx_requests(vec![desc_chain.clone()], &vring)
+            .unwrap());
+
+        let ctrl_msg_reply = desc_chain
+            .memory()
+            .read_obj::<VirtioConsoleControl>(vm_memory::GuestAddress(0x100_u64))
+            .map_err(|_| Error::DescriptorReadFailed)
+            .unwrap();
+
+        assert_eq!(ctrl_msg.id, ctrl_msg_reply.id);
+        assert_eq!(ctrl_msg.event, ctrl_msg_reply.event);
+        assert_eq!(ctrl_msg.value, ctrl_msg_reply.value);
+
+        // 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 vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
+        vu_console_backend.update_memory(mem1).unwrap();
+
+        let ctrl_msg = VirtioConsoleControl {
+            id: 0.into(),
+            event: VIRTIO_CONSOLE_PORT_NAME.into(),
+            value: 1.into(),
+        };
+        let _ = vu_console_backend.rx_ctrl_fifo.add(ctrl_msg);
+
+        assert!(vu_console_backend
+            .process_ctrl_rx_requests(vec![desc_chain.clone()], &vring)
+            .unwrap());
+    }
+
+    #[test]
+    fn test_virtio_console_ctrl_tx_request() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let mut vu_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        // Artificial memory
+        let mem = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap();
+
+        // Test 1: Empty queue
+        let mem1 = GuestMemoryAtomic::new(mem.clone());
+        let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
+        assert!(vu_console_backend
+            .process_ctrl_tx_requests(vec![], &vring)
+            .unwrap());
+
+        // Test 2: Found no descriptors
+        let desc_chain = build_desc_chain(&mem, 1, vec![VRING_DESC_F_WRITE as u16], 0x200);
+        let mem1 = GuestMemoryAtomic::new(mem.clone());
+        let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
+        vu_console_backend.update_memory(mem1).unwrap();
+
+        assert_eq!(
+            vu_console_backend
+                .process_ctrl_tx_requests(vec![desc_chain], &vring)
+                .unwrap_err(),
+            Error::DescriptorReadFailed
+        );
+
+        // Test 3: Smaller descriptor len than a console ctrl message
+        let desc_chain = build_desc_chain(&mem, 1, vec![0], 0x2);
+        let mem1 = GuestMemoryAtomic::new(mem.clone());
+        let vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
+        vu_console_backend.update_memory(mem1).unwrap();
+        assert_eq!(
+            vu_console_backend
+                .process_ctrl_tx_requests(vec![desc_chain.clone()], &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 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)
+            .unwrap());
+    }
+
+    #[test]
+    fn test_virtio_console_handle_control_msg() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let mut vu_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        // Artificial memory & update device's memory
+        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();
+
+        // Test 1: Empty queue
+        let ctrl_msg_1 = VirtioConsoleControl {
+            id: 0.into(),
+            event: VIRTIO_CONSOLE_DEVICE_READY.into(),
+            value: 1.into(),
+        };
+
+        let ctrl_msg_2 = VirtioConsoleControl {
+            id: 0.into(),
+            event: VIRTIO_CONSOLE_PORT_READY.into(),
+            value: 1.into(),
+        };
+
+        let ctrl_msg_3 = VirtioConsoleControl {
+            id: 0.into(),
+            event: VIRTIO_CONSOLE_PORT_OPEN.into(),
+            value: 1.into(),
+        };
+
+        let ctrl_msg_err = VirtioConsoleControl {
+            id: 0.into(),
+            event: 4.into(),
+            value: 1.into(),
+        };
+
+        assert!(vu_console_backend.handle_control_msg(ctrl_msg_3).is_ok());
+
+        assert_eq!(
+            vu_console_backend
+                .handle_control_msg(ctrl_msg_err)
+                .unwrap_err(),
+            Error::HandleEventUnknown
+        );
+
+        assert!(vu_console_backend.handle_control_msg(ctrl_msg_1).is_ok());
+
+        // Update memory
+        let mem_1 = GuestMemoryAtomic::new(mem.clone());
+        vu_console_backend.update_memory(mem_1.clone()).unwrap();
+
+        assert!(vu_console_backend.handle_control_msg(ctrl_msg_2).is_ok());
+    }
+
+    #[test]
+    fn test_virtio_console_tx_request() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let mut vu_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        // Artificial memory
+        let mem = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap();
+
+        // Test 1: Empty queue
+        let mem1 = GuestMemoryAtomic::new(mem.clone());
+        let vring = VringRwLock::new(mem1, 0x1000).unwrap();
+        assert!(vu_console_backend
+            .process_tx_requests(vec![], &vring)
+            .is_ok());
+
+        // 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
+            .process_tx_requests(vec![desc_chain], &vring)
+            .is_ok());
+
+        // Test 3: Fill message to the buffer
+        let desc_chain = build_desc_chain(&mem, 1, vec![0], 0x200);
+        let desc_addr = desc_chain.clone().collect::<Vec<_>>()[0].addr();
+
+        // Build the Vec with the desired string
+        let mut buffer: Vec<u8> = Vec::new();
+        let string_bytes = "Hello!".as_bytes();
+        buffer.extend_from_slice(string_bytes);
+
+        // Write a new buffer into the desc_chain
+        desc_chain.memory().write_slice(&buffer, desc_addr).unwrap();
+
+        // Verify that it is written
+        let mut read_buffer: Vec<u8> = vec![0; 0x200];
+        desc_chain
+            .memory()
+            .read_slice(&mut read_buffer, desc_addr)
+            .expect("Failed to read");
+        let read_buffer: Vec<u8> = read_buffer.iter().take(buffer.len()).copied().collect();
+
+        assert_eq!(
+            String::from_utf8(read_buffer).unwrap(),
+            String::from_utf8(buffer).unwrap()
+        );
+
+        assert!(vu_console_backend
+            .process_tx_requests(vec![desc_chain], &vring)
+            .is_ok());
+    }
+
+    #[test]
+    fn test_virtio_console_tx_request_network() {
+        let console_controller =
+            Arc::new(RwLock::new(ConsoleController::new(BackendType::Network)));
+        let mut vu_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        // Artificial memory
+        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 vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
+
+        // Test: Fill message to the buffer
+        vu_console_backend.update_memory(mem1).unwrap();
+        let desc_addr = desc_chain.clone().collect::<Vec<_>>()[0].addr();
+
+        // Build the Vec with the desired string
+        let mut buffer: Vec<u8> = Vec::new();
+        let string_bytes = "Hello!".as_bytes();
+        buffer.extend_from_slice(string_bytes);
+
+        // Write a new buffer into the desc_chain
+        desc_chain.memory().write_slice(&buffer, desc_addr).unwrap();
+
+        // Verify that it is written
+        let mut read_buffer: Vec<u8> = vec![0; 0x200];
+        desc_chain
+            .memory()
+            .read_slice(&mut read_buffer, desc_addr)
+            .expect("Failed to read");
+        let read_buffer: Vec<u8> = read_buffer.iter().take(buffer.len()).copied().collect();
+
+        assert_eq!(
+            String::from_utf8(read_buffer).unwrap(),
+            String::from_utf8(buffer).unwrap()
+        );
+
+        assert!(vu_console_backend
+            .process_tx_requests(vec![desc_chain], &vring)
+            .is_ok());
+    }
+
+    #[test]
+    fn test_virtio_console_rx_request() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let mut vu_console_backend = VhostUserConsoleBackend::new(console_controller)
+            .expect("Failed create vhuconsole backend");
+
+        // Artificial memory
+        let mem = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap();
+
+        // Test 1: Empty queue
+        let mem1 = GuestMemoryAtomic::new(mem.clone());
+        let vring = VringRwLock::new(mem1, 0x1000).unwrap();
+        assert!(vu_console_backend
+            .process_rx_requests(vec![], &vring)
+            .is_ok());
+
+        // 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
+            .process_rx_requests(vec![desc_chain], &vring)
+            .unwrap());
+
+        // Test 3: Fill message to the buffer. The descriptor should be write-only
+        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();
+
+        let input_buffer = "Hello!".to_string();
+        let _ = vu_console_backend.rx_data_fifo.add(input_buffer.clone());
+        assert_eq!(
+            vu_console_backend
+                .process_rx_requests(vec![desc_chain], &vring)
+                .unwrap_err(),
+            Error::DescriptorWriteFailed
+        );
+
+        // 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 vring = VringRwLock::new(mem1.clone(), 0x1000).unwrap();
+        vu_console_backend.update_memory(mem1).unwrap();
+
+        let input_buffer = "Hello!".to_string();
+        let _ = vu_console_backend.rx_data_fifo.add(input_buffer.clone());
+        assert!(vu_console_backend
+            .process_rx_requests(vec![desc_chain.clone()], &vring)
+            .unwrap());
+
+        // Test 5: Verify written data
+        let desc_addr = GuestAddress(0x100);
+        let mut read_buffer: Vec<u8> = vec![0; 0x100];
+        desc_chain
+            .memory()
+            .read_slice(&mut read_buffer, desc_addr)
+            .expect("Failed to read");
+
+        let read_buffer: Vec<u8> = read_buffer
+            .iter()
+            .take(input_buffer.len())
+            .copied()
+            .collect();
+
+        assert_eq!(String::from_utf8(read_buffer).unwrap(), input_buffer);
+    }
+
+    #[test]
+    fn test_virtio_console_start_tcp_console_thread() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let vu_console_backend = Arc::new(RwLock::new(
+            VhostUserConsoleBackend::new(console_controller)
+                .expect("Failed create vhuconsole backend"),
+        ));
+        let tcp_addr = "127.0.0.1:12345".to_string();
+
+        let read_handle = VhostUserConsoleBackend::start_tcp_console_thread(
+            &vu_console_backend,
+            tcp_addr.clone(),
+        );
+        vu_console_backend.read().unwrap().kill_console_thread();
+        assert!(read_handle.join().is_ok());
+    }
+
+    #[test]
+    fn test_virtio_console_start_nested_console_thread() {
+        let console_controller = Arc::new(RwLock::new(ConsoleController::new(BackendType::Nested)));
+        let vu_console_backend = Arc::new(RwLock::new(
+            VhostUserConsoleBackend::new(console_controller)
+                .expect("Failed create vhuconsole backend"),
+        ));
+
+        let read_handle = VhostUserConsoleBackend::start_console_thread(&vu_console_backend);
+
+        vu_console_backend.read().unwrap().kill_console_thread();
+        assert!(read_handle.join().is_ok());
+    }
+}
diff --git a/staging/vhost-device-console/src/virtio_console.rs b/staging/vhost-device-console/src/virtio_console.rs
new file mode 100644
index 0000000..323473f
--- /dev/null
+++ b/staging/vhost-device-console/src/virtio_console.rs
@@ -0,0 +1,60 @@
+// Console virtio bindings
+//
+// Copyright 2023-2024 VIRTUAL OPEN SYSTEMS SAS. All Rights Reserved.
+//          Timos Ampelikiotis <t.ampelikiotis@virtualopensystems.com>
+//
+// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
+
+use vm_memory::{ByteValued, Le16, Le32};
+
+/// Feature bit numbers
+#[allow(dead_code)]
+pub const VIRTIO_CONSOLE_F_SIZE: u16 = 0;
+pub const VIRTIO_CONSOLE_F_MULTIPORT: u16 = 1;
+#[allow(dead_code)]
+pub const VIRTIO_CONSOLE_F_EMERG_WRITE: u16 = 2;
+
+/// Console virtio control messages
+pub const VIRTIO_CONSOLE_DEVICE_READY: u16 = 0;
+pub const VIRTIO_CONSOLE_PORT_ADD: u16 = 1;
+#[allow(dead_code)]
+pub const VIRTIO_CONSOLE_PORT_REMOVE: u16 = 2;
+pub const VIRTIO_CONSOLE_PORT_READY: u16 = 3;
+pub const VIRTIO_CONSOLE_CONSOLE_PORT: u16 = 4;
+#[allow(dead_code)]
+pub const VIRTIO_CONSOLE_RESIZE: u16 = 5;
+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)]
+#[repr(C)]
+pub(crate) struct VirtioConsoleConfig {
+    pub cols: Le16,
+    pub rows: Le16,
+    pub max_nr_ports: Le32,
+    pub emerg_wr: Le32,
+}
+
+// SAFETY: The layout of the structure is fixed and can be initialized by
+// reading its content from byte array.
+unsafe impl ByteValued for VirtioConsoleConfig {}
+
+#[derive(Copy, Clone, Debug, Default, PartialEq)]
+#[repr(C)]
+pub(crate) struct VirtioConsoleControl {
+    pub id: Le32,
+    pub event: Le16,
+    pub value: Le16,
+}
+
+impl VirtioConsoleControl {
+    pub fn to_le_bytes(self) -> Vec<u8> {
+        let mut buffer = Vec::new();
+
+        buffer.extend_from_slice(&self.id.to_native().to_le_bytes());
+        buffer.extend_from_slice(&self.event.to_native().to_le_bytes());
+        buffer.extend_from_slice(&self.value.to_native().to_le_bytes());
+        buffer
+    }
+}