examples/gui_vm, gtk_display: Add support for input (keyboard+touch)

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

Author: mtjhrc

examples/Cargo.lock

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 gtk_display = { path = "../krun_gtk_display" }
 krun-sys = { path = "../../krun-sys" }
+krun_input = { path = "../../src/krun_input" }
 anyhow = "1.0.98"
 clap = "4.5.39"
 clap_derive = "4.5.32"

examples/gui_vm/Cargo.toml

@@ -1,17 +1,31 @@
 use clap::Parser;
 use clap_derive::Parser;
-use gtk_display::DisplayBackendHandle;
+use gtk_display::{
+    Axis, DisplayBackendHandle, DisplayInputOptions, InputBackendHandle, TouchArea,
+    TouchScreenOptions,
+};
+
 use krun_sys::{
-    VIRGLRENDERER_RENDER_SERVER, VIRGLRENDERER_THREAD_SYNC, VIRGLRENDERER_USE_ASYNC_FENCE_CB,
-    VIRGLRENDERER_USE_EGL, VIRGLRENDERER_VENUS, krun_add_display, krun_create_ctx,
+    KRUN_DISK_FORMAT_QCOW2, KRUN_LOG_LEVEL_TRACE, KRUN_LOG_LEVEL_WARN, KRUN_LOG_STYLE_ALWAYS,
+    KRUN_LOG_TARGET_DEFAULT, VIRGLRENDERER_RENDER_SERVER, VIRGLRENDERER_THREAD_SYNC,
+    VIRGLRENDERER_USE_ASYNC_FENCE_CB, VIRGLRENDERER_USE_EGL, VIRGLRENDERER_VENUS, krun_add_disk2,
+    krun_add_display, krun_add_input_device, krun_add_input_device_fd, krun_create_ctx,
     krun_display_set_dpi, krun_display_set_physical_size, krun_display_set_refresh_rate,
-    krun_set_display_backend, krun_set_exec, krun_set_gpu_options, krun_set_log_level,
-    krun_set_root, krun_start_enter,
+    krun_init_log, krun_set_display_backend, krun_set_exec, krun_set_gpu_options2,
+    krun_set_passt_fd, krun_set_root, krun_set_root_disk_remount, krun_set_vm_config,
+    krun_start_enter,
 };
 use log::LevelFilter;
 use regex::{Captures, Regex};
 use std::ffi::{CString, c_void};
 use std::fmt::Display;
+use std::fs::{File, OpenOptions};
+use std::mem::size_of_val;
+
+use anyhow::Context;
+use std::os::fd::IntoRawFd;
+use std::os::unix::net::UnixStream;
+use std::path::PathBuf;
 use std::process::exit;
 use std::ptr::null;
 use std::str::FromStr;
@@ -32,19 +46,20 @@ struct DisplayArg {
     height: u32,
     refresh_rate: Option<u32>,
     physical_size: Option<PhysicalSize>,
+    touch: bool,
 }
 
 /// Parses a display settings string.
 /// The expected format is "WIDTHxHEIGHT[@FPS][:DPIdpi|:PHYSICAL_WIDTHxPHYSICAL_HEIGHTmm]".
 fn parse_display(display_string: &str) -> Result<DisplayArg, String> {
     static RE: LazyLock<Regex> = LazyLock::new(|| {
         Regex::new(
-            r"^(?P<width>\d+)x(?P<height>\d+)(?:@(?P<refresh_rate>\d+))?(?::(?P<dpi>\d+)dpi|:(?P<width_mm>\d+)x(?P<height_mm>\d+)mm)?$",
+            r"^(?P<width>\d+)x(?P<height>\d+)(?:@(?P<refresh_rate>\d+))?(?::(?P<dpi>\d+)dpi|:(?P<width_mm>\d+)x(?P<height_mm>\d+)mm)?(?P<touch>\+touch(screen)?)?$",
         ).unwrap()
     });
 
     let captures = RE.captures(display_string).ok_or_else(|| {
-        format!("Invalid display string '{display_string}' format. Examples of valid values:\n '1920x1080', '1920x1080@60', '1920x1080:162x91mm', '1920x1080:300dpi', '1920x1080@90:300dpi'")
+        format!("Invalid display string '{display_string}' format. Examples of valid values:\n '1920x1080', '1920x1080+touch','1920x1080@60', '1920x1080:162x91mm', '1920x1080:300dpi', '1920x1080@90:300dpi+touch'")
     })?;
 
     fn parse_group<T: FromStr>(captures: &Captures, name: &str) -> Result<Option<T>, String>
@@ -78,6 +93,7 @@ fn parse_display(display_string: &str) -> Result<DisplayArg, String> {
             (None, None, None) => None,
             _ => unreachable!("regex bug"),
         },
+        touch: captures.name("touch").is_some(),
     })
 }
 
@@ -86,41 +102,103 @@ struct Args {
     #[arg(long)]
     root_dir: Option<CString>,
 
+    // Set disk to mount after boot
+    #[arg(long)]
+    remount_disk: Option<CString>,
+
     executable: Option<CString>,
     argv: Vec<CString>,
     // Display specifications in the format WIDTHxHEIGHT[@FPS][:DPIdpi|:PHYSICAL_WIDTHxPHYSICAL_HEIGHTmm]
     #[clap(long, value_parser = parse_display)]
     display: Vec<DisplayArg>,
+
+    /// Attach a virtual keyboard input device
+    #[arg(long)]
+    keyboard_input: bool,
+
+    /// Pipe (or file) where to write log (with terminal color formatting)
+    #[arg(long)]
+    color_log: Option<PathBuf>,
+
+    /// Passthrough an input device (e.g. /dev/input/event0)
+    #[arg(long)]
+    input: Vec<PathBuf>,
 }
 
-fn krun_thread(args: &Args, display_backend_handle: DisplayBackendHandle) -> anyhow::Result<()> {
+fn krun_thread(
+    args: &Args,
+    display_backend_handle: DisplayBackendHandle,
+    input_device_handles: Vec<InputBackendHandle>,
+) -> anyhow::Result<()> {
     unsafe {
-        krun_call!(krun_set_log_level(3))?;
+        if let Some(path) = &args.color_log {
+            krun_call!(krun_init_log(
+                OpenOptions::new()
+                    .write(true)
+                    .open(path)
+                    .context("Failed to open log output")?
+                    .into_raw_fd(),
+                KRUN_LOG_LEVEL_TRACE,
+                KRUN_LOG_STYLE_ALWAYS,
+                0
+            ))?;
+        } else {
+            krun_call!(krun_init_log(
+                KRUN_LOG_TARGET_DEFAULT,
+                KRUN_LOG_LEVEL_WARN,
+                0,
+                0,
+            ))?;
+        }
+
         let ctx = krun_call_u32!(krun_create_ctx())?;
 
-        krun_call!(krun_set_gpu_options(
+        krun_call!(krun_set_vm_config(ctx, 4, 4096))?;
+
+        krun_call!(krun_set_passt_fd(
+            ctx,
+            UnixStream::connect("/tmp/passt_1.socket")
+                .unwrap()
+                .into_raw_fd()
+        ))?;
+        krun_call!(krun_set_gpu_options2(
             ctx,
             VIRGLRENDERER_USE_EGL
                 | VIRGLRENDERER_VENUS
                 | VIRGLRENDERER_RENDER_SERVER
                 | VIRGLRENDERER_THREAD_SYNC
-                | VIRGLRENDERER_USE_ASYNC_FENCE_CB
+                | VIRGLRENDERER_USE_ASYNC_FENCE_CB,
+            4096
         ))?;
 
-        if let Some(root_dir) = &args.root_dir {
-            krun_call!(krun_set_root(ctx, root_dir.as_ptr()))?;
-            // Executable variable should be set if we have root_dir, this is verified by clap
-            let executable = args.executable.as_ref().unwrap().as_ptr();
-            let argv: Vec<_> = args.argv.iter().map(|a| a.as_ptr()).collect();
-            let argv_ptr = if argv.is_empty() {
+        if let Some(remount_disk) = &args.remount_disk {
+            krun_call!(krun_add_disk2(
+                ctx,
+                c"/dev/vda".as_ptr(),
+                remount_disk.as_ptr(),
+                KRUN_DISK_FORMAT_QCOW2,
+                false
+            ))?;
+            krun_call!(krun_set_root_disk_remount(
+                ctx,
+                c"/dev/vda".as_ptr(),
+                c"btrfs".as_ptr(),
                 null()
-            } else {
-                argv.as_ptr()
-            };
-            let envp = [null()];
-            krun_call!(krun_set_exec(ctx, executable, argv_ptr, envp.as_ptr()))?;
+            ))?;
+        } else if let Some(root_dir) = &args.root_dir {
+            krun_call!(krun_set_root(ctx, root_dir.as_ptr()))?;
         }
 
+        let executable = args.executable.as_ref().unwrap().as_ptr();
+        let argv: Vec<_> = args.argv.iter().map(|a| a.as_ptr()).collect();
+        let argv_ptr = if argv.is_empty() {
+            null()
+        } else {
+            argv.as_ptr()
+        };
+        let envp = [null()];
+        krun_call!(krun_set_exec(ctx, executable, argv_ptr, envp.as_ptr()))?;
+
         for display in &args.display {
             let display_id = krun_call_u32!(krun_add_display(ctx, display.width, display.height))?;
             if let Some(refresh_rate) = display.refresh_rate {
@@ -144,21 +222,74 @@ fn krun_thread(args: &Args, display_backend_handle: DisplayBackendHandle) -> any
             &raw const display_backend as *const c_void,
             size_of_val(&display_backend),
         ))?;
+
+        for input in &args.input {
+            let fd = File::open(input)
+                .context("Failed to open input device: {input}")?
+                .into_raw_fd();
+            krun_call!(krun_add_input_device_fd(ctx, fd))
+                .context("Failed to attach input device")?;
+        }
+
+        // Configure all input devices
+        for handle in &input_device_handles {
+            let config_backend = handle.get_config();
+            let event_provider_backend = handle.get_events();
+
+            krun_call!(krun_add_input_device(
+                ctx,
+                &raw const config_backend as *const c_void,
+                size_of_val(&config_backend),
+                &raw const event_provider_backend as *const c_void,
+                size_of_val(&event_provider_backend),
+            ))?;
+        }
+
         krun_call!(krun_start_enter(ctx))?;
     };
     Ok(())
 }
 
 fn main() -> anyhow::Result<()> {
-    env_logger::builder().filter_level(LevelFilter::Info).init();
+    env_logger::builder()
+        .filter_level(LevelFilter::Debug)
+        .init();
     let args = Args::parse();
 
-    let (display_backend, display_worker) =
-        gtk_display::crate_display("libkrun examples/gui_vm".to_string());
+    let mut per_display_inputs = vec![vec![]; args.display.len()];
+    for (idx, display) in args.display.iter().enumerate() {
+        if display.touch {
+            per_display_inputs[idx].push(DisplayInputOptions::TouchScreen(TouchScreenOptions {
+                // There is no specific reason for these axis sizes, just picked what my
+                // physical hardware had
+                area: TouchArea {
+                    x: Axis {
+                        max: 13764,
+                        res: 40,
+                        ..Default::default()
+                    },
+                    y: Axis {
+                        max: 7740,
+                        res: 40,
+                        ..Default::default()
+                    },
+                },
+                emit_mt: true,
+                emit_non_mt: false,
+                triggered_by_mouse: true,
+            }));
+        }
+    }
+
+    let (display_backend, input_backends, display_worker) = gtk_display::init(
+        "libkrun examples/gui_vm".to_string(),
+        args.keyboard_input,
+        per_display_inputs,
+    )?;
 
     thread::scope(|s| {
         s.spawn(|| {
-            if let Err(e) = krun_thread(&args, display_backend) {
+            if let Err(e) = krun_thread(&args, display_backend, input_backends) {
                 eprintln!("{e}");
                 exit(1);
             }

examples/gui_vm/src/main.rs

@@ -6,9 +6,9 @@ edition = "2024"
 
 [dependencies]
 utils = { path = "../../src/utils" } # Our version of rust vmm-sys-util
-crossbeam-channel = "0.5.15"
 gtk = { version = "0.10", package = "gtk4", features = ["v4_16"] }
 krun_display = { path = "../../src/krun_display" }
+krun_input = { path = "../../src/krun_input" }
 anyhow = "1.0.98"
 log = "0.4.27"
 libc = "0.2.174"

examples/krun_gtk_display/Cargo.toml

@@ -1,18 +1,17 @@
-use crossbeam_channel::{Receiver, Sender, TrySendError, bounded};
 use gtk::{gdk::MemoryFormat, glib::Bytes};
 use krun_display::{
     DisplayBackendBasicFramebuffer, DisplayBackendError, DisplayBackendNew, MAX_DISPLAYS, Rect,
     ResourceFormat,
 };
-use log::error;
 use std::mem;
+use std::sync::mpsc::{Receiver, SyncSender, sync_channel};
 use utils::pollable_channel::PollableChannelSender;
 
 // We try to push the maximum amount of data to the GTK thread. Currently, we want the display thread
 // deal with dropping the frames if they are coming too quickly to render. If we set this to a lower
 // number could slow down the libkrun thread, by making it wait for the display thread when calling
 // DisplayBackendBasicFramebuffer::alloc_frame.
-const MAX_DISPLAY_BUFFERS: usize = 4;
+const MAX_DISPLAY_BUFFERS: usize = 32;
 const _: () = {
     if MAX_DISPLAY_BUFFERS < 2 {
         panic!("At least 2 buffers are required")
@@ -74,7 +73,7 @@ impl DisplayBackendBasicFramebuffer for GtkDisplayBackend {
         if let Some(ref mut scanout) = self.scanouts[scanout_id as usize] {
             scanout.required_buffer_size = required_buffer_size;
         } else {
-            let (buffer_tx, buffer_rx) = bounded(MAX_DISPLAY_BUFFERS);
+            let (buffer_tx, buffer_rx) = sync_channel(MAX_DISPLAY_BUFFERS);
 
             for _ in 0..MAX_DISPLAY_BUFFERS {
                 // We initialize the buffers as empty in case we don't end up using them, the buffers
@@ -171,7 +170,7 @@ fn resource_format_into_gdk(format: ResourceFormat) -> MemoryFormat {
 }
 
 struct Scanout {
-    buffer_tx: Sender<Vec<u8>>,
+    buffer_tx: SyncSender<Vec<u8>>,
     buffer_rx: Receiver<Vec<u8>>,
     required_buffer_size: usize,
     current_buffer: Vec<u8>,
@@ -187,7 +186,7 @@ impl Scanout {
 }
 
 struct BufferReturner {
-    return_tx: Sender<Vec<u8>>,
+    return_tx: SyncSender<Vec<u8>>,
     buf: Vec<u8>,
 }
 
@@ -199,14 +198,11 @@ impl AsRef<[u8]> for BufferReturner {
 
 impl Drop for BufferReturner {
     fn drop(&mut self) {
-        match self.return_tx.try_send(mem::take(&mut self.buf)) {
+        match self.return_tx.send(mem::take(&mut self.buf)) {
             Ok(_) => (),
             // We can just drop the buffer if the other party doesn't exist anymore.
-            Err(TrySendError::Disconnected(_)) => (),
-            Err(TrySendError::Full(_)) => {
-                error!(
-                    "Either the channel is too small or we have more than MAX_DISPLAY_BUFFERS buffers!?"
-                );
+            Err(_) => {
+                // If send fails, it's because the receiver is gone, so just drop the buffer
             }
         }
     }