devices, libkrun: Introduce krun_add_input_device_fd

Introduce krun_add_input_device_fd, allowing the user to pass a file descriptor to
a /dev/input/event* device, which will be become available in the guest.

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

Author: mtjhrc

include/libkrun.h

@@ -631,6 +631,19 @@ int32_t krun_set_display_backend(uint32_t ctx_id, const void *display_backend, s
 int krun_add_input_device(uint32_t ctx_id, const void *config_backend, size_t config_backend_size,
                             const void *events_backend, size_t events_backend_size);
 
+/**
+ * Creates a passthrough input device from a host /dev/input/* file descriptor.
+ * The device configuration will be automatically queried from the host device using ioctls.
+ * 
+ * Arguments:
+ *  "ctx_id"  - The krun context
+ *  "input_fd" - File descriptor to a /dev/input/* device on the host
+ *
+ * Returns:
+ *  Zero on success or a negative error code otherwise.
+ */
+int krun_add_input_device_fd(uint32_t ctx_id, int input_fd);
+
 /**
  * Enables or disables a virtio-snd device.
  *

src/devices/src/virtio/input/mod.rs

@@ -1,4 +1,5 @@
 mod device;
+pub mod passthrough;
 mod worker;
 
 pub use self::defs::uapi::VIRTIO_ID_INPUT as TYPE_INPUT;

src/devices/src/virtio/input/passthrough.rs

@@ -0,0 +1,211 @@
+use krun_input::{
+    InputAbsInfo, InputBackendError, InputDeviceIds, InputEvent, InputEventsImpl, InputQueryConfig,
+    ObjectNew,
+};
+use nix::fcntl::{fcntl, OFlag, F_GETFL, F_SETFL};
+use nix::{errno::Errno, ioctl_read, ioctl_read_buf, unistd};
+use std::mem;
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd};
+
+/// Internal passthrough input backend that forwards host /dev/input/* devices
+pub struct PassthroughInputBackend {
+    fd: BorrowedFd<'static>,
+}
+
+impl InputQueryConfig for PassthroughInputBackend {
+    fn query_serial_name(&self, serial_buf: &mut [u8]) -> Result<u8, InputBackendError> {
+        match unsafe { eviocguniq(self.fd.as_raw_fd(), serial_buf) } {
+            Ok(len) => Ok(len as u8),
+            Err(e) => {
+                error!("Failed to get device serial (eviocguniq): {e}");
+                Err(InputBackendError::InternalError)
+            }
+        }
+    }
+
+    fn query_device_name(&self, name_buf: &mut [u8]) -> Result<u8, InputBackendError> {
+        match unsafe { eviocgname(self.fd.as_raw_fd(), name_buf) } {
+            Ok(len) => Ok(len as u8),
+            Err(e) => {
+                error!("Failed to get device name (eviocgname): {e}");
+                Err(InputBackendError::InternalError)
+            }
+        }
+    }
+
+    fn query_device_ids(&self, ids: &mut InputDeviceIds) -> Result<(), InputBackendError> {
+        match unsafe { eviocgid(self.fd.as_raw_fd(), ids) } {
+            Ok(_) => Ok(()),
+            Err(e) => {
+                error!("Failed to get device information ids (eviocgid): {e}");
+                Err(InputBackendError::InternalError)
+            }
+        }
+    }
+
+    fn query_event_capabilities(
+        &self,
+        event_type: u8,
+        bitmap_buf: &mut [u8],
+    ) -> Result<u8, InputBackendError> {
+        match unsafe { eviocgbit(self.fd.as_raw_fd(), event_type, bitmap_buf) } {
+            Ok(n) => {
+                let len = find_length(&bitmap_buf[..n as usize]) as u8;
+                debug!(
+                    "eviocgbit: {event_type}, got {n} bytes (from n): {:#?}",
+                    &bitmap_buf[..n as usize]
+                );
+                Ok(len)
+            }
+            Err(e) => {
+                error!("Failed to get device event capabilities (eviocgbit): {e}");
+                Err(InputBackendError::InternalError)
+            }
+        }
+    }
+
+    fn query_abs_info(
+        &self,
+        abs_axis: u8,
+        abs_info: &mut InputAbsInfo,
+    ) -> Result<(), InputBackendError> {
+        let mut linux_abs_info = LinuxAbsInfo::default();
+        match unsafe { eviocgabs(self.fd.as_raw_fd(), abs_axis, &mut linux_abs_info) } {
+            Ok(_) => {
+                *abs_info = InputAbsInfo {
+                    min: linux_abs_info.minimum,
+                    max: linux_abs_info.maximum,
+                    fuzz: linux_abs_info.fuzz,
+                    flat: linux_abs_info.flat,
+                    res: linux_abs_info.resolution,
+                };
+                Ok(())
+            }
+            Err(e) => {
+                error!("Failed to get device abs_info (eviocgabs): {e}");
+                Err(InputBackendError::InternalError)
+            }
+        }
+    }
+
+    fn query_properties(&self, properties: &mut [u8]) -> Result<u8, InputBackendError> {
+        match unsafe { eviocgprop(self.fd.as_raw_fd(), properties) } {
+            Ok(len) => Ok(len as u8),
+            Err(e) => {
+                error!("Failed to query device properties (eviocgprop): {e}");
+                Err(InputBackendError::InternalError)
+            }
+        }
+    }
+}
+
+impl ObjectNew<BorrowedFd<'static>> for PassthroughInputBackend {
+    fn new(userdata: Option<&BorrowedFd<'static>>) -> Self {
+        let fd = userdata
+            .copied()
+            .expect("Missing argument for PassthroughInputBackend::new");
+
+        make_non_blocking(&fd)
+            .expect("Cannot make device fd non-blocking (Invalid file descriptor?)");
+        Self { fd }
+    }
+}
+
+impl InputEventsImpl for PassthroughInputBackend {
+    fn get_read_notify_fd(&self) -> Result<BorrowedFd<'_>, InputBackendError> {
+        Ok(self.fd)
+    }
+
+    fn next_event(&mut self) -> Result<Option<InputEvent>, InputBackendError> {
+        let mut linux_event = unsafe { std::mem::zeroed::<LinuxInputEvent>() };
+        let event_slice = unsafe {
+            std::slice::from_raw_parts_mut(
+                &mut linux_event as *mut _ as *mut u8,
+                size_of::<LinuxInputEvent>(),
+            )
+        };
+
+        match unistd::read(self.fd, event_slice) {
+            Ok(bytes_read) if bytes_read == size_of::<LinuxInputEvent>() => {
+                trace!("Forwarding input: {linux_event:?}");
+                Ok(Some(InputEvent {
+                    type_: linux_event.type_,
+                    code: linux_event.code,
+                    value: linux_event.value,
+                }))
+            }
+            Ok(_bytes_read) => {
+                error!("Partial read from /dev/input was unexpected, not implemented!");
+                Err(InputBackendError::InternalError)
+            }
+            Err(Errno::EAGAIN) => Ok(None),
+            Err(e) => {
+                error!("Failed to read event from input device: {e}");
+                Err(InputBackendError::InternalError)
+            }
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+struct LinuxInputEvent {
+    time: libc::timeval,
+    type_: u16,
+    code: u16,
+    value: u32,
+}
+
+#[repr(C)]
+#[derive(Debug, Default)]
+struct LinuxAbsInfo {
+    value: u32,
+    minimum: u32,
+    maximum: u32,
+    fuzz: u32,
+    flat: u32,
+    resolution: u32,
+}
+
+ioctl_read!(eviocgid, b'E', 0x02, InputDeviceIds); // Kernel uapi struct is the same as virtio
+ioctl_read_buf!(eviocgname, b'E', 0x06, u8);
+ioctl_read_buf!(eviocguniq, b'E', 0x08, u8);
+ioctl_read_buf!(eviocgprop, b'E', 0x09, u8);
+
+unsafe fn eviocgbit(fd: RawFd, evt: u8, buf: &mut [u8]) -> Result<u32, Errno> {
+    let ioctl_num = nix::request_code_read!(b'E', 0x20 + evt, buf.len());
+
+    let n = libc::ioctl(fd, ioctl_num as _, buf.as_mut_ptr());
+    if n < 0 {
+        return Err(Errno::last());
+    }
+    Ok(n as u32)
+}
+
+unsafe fn eviocgabs(fd: RawFd, axis: u8, abs_info: &mut LinuxAbsInfo) -> Result<u32, Errno> {
+    let ioctl_num = nix::request_code_read!(b'E', 0x40 + axis, size_of::<LinuxAbsInfo>());
+
+    let n = libc::ioctl(fd, ioctl_num as _, abs_info as *mut _);
+    if n < 0 {
+        return Err(Errno::last());
+    }
+    Ok(mem::size_of::<InputAbsInfo>() as u32)
+}
+
+fn make_non_blocking(fd: &impl AsFd) -> Result<(), nix::Error> {
+    let flags = fcntl(fd, F_GETFL)?;
+    fcntl(
+        fd,
+        F_SETFL(OFlag::from_bits_retain(flags) | OFlag::O_NONBLOCK),
+    )?;
+
+    Ok(())
+}
+
+fn find_length(bytes: &[u8]) -> usize {
+    bytes
+        .iter()
+        .rposition(|b| *b != 0)
+        .map(|idx| idx + 1)
+        .unwrap_or(0)
+}

src/libkrun/src/lib.rs

@@ -32,6 +32,8 @@ use std::ffi::{c_void, CStr};
 use std::fs::File;
 #[cfg(target_os = "linux")]
 use std::os::fd::AsRawFd;
+#[cfg(feature = "input")]
+use std::os::fd::BorrowedFd;
 use std::os::fd::{FromRawFd, RawFd};
 use std::path::PathBuf;
 use std::slice;
@@ -1412,6 +1414,36 @@ pub extern "C" fn krun_add_input_device(
     -libc::ENOTSUP
 }
 
+#[cfg(feature = "input")]
+#[allow(clippy::missing_safety_doc)]
+#[no_mangle]
+pub extern "C" fn krun_add_input_device_fd(ctx_id: u32, input_fd: i32) -> i32 {
+    use devices::virtio::input::passthrough::PassthroughInputBackend;
+    use krun_input::{IntoInputConfig, IntoInputEvents};
+
+    if input_fd < 0 {
+        return -libc::EINVAL;
+    }
+    // TODO: currently we let the fd (and it's Box allocation) live forever, we should eventually fix
+    //       this
+    let input_fd = unsafe {
+        // SAFETY: The user provided fd should be valid. Its lifetime is 'static because it will
+        //         exist until libkrun _exits the process
+        BorrowedFd::borrow_raw(input_fd)
+    };
+    let borrowed_fd: &'static BorrowedFd<'static> = Box::leak(Box::new(input_fd));
+
+    let config_backend = PassthroughInputBackend::into_input_config(Some(borrowed_fd));
+    let events_backend = PassthroughInputBackend::into_input_events(Some(borrowed_fd));
+
+    with_cfg(ctx_id, |cfg| {
+        cfg.vmr
+            .input_backends
+            .push((config_backend, events_backend));
+        KRUN_SUCCESS
+    })
+}
+
 #[cfg(feature = "input")]
 #[allow(clippy::missing_safety_doc)]
 #[no_mangle]
@@ -1447,6 +1479,13 @@ pub unsafe extern "C" fn krun_add_input_device(
     })
 }
 
+#[cfg(not(feature = "input"))]
+#[allow(clippy::missing_safety_doc)]
+#[no_mangle]
+pub unsafe extern "C" fn krun_add_input_device_fd(_ctx_id: u32, _input_fd: i32) -> i32 {
+    -libc::ENOTSUP
+}
+
 #[cfg(feature = "gpu")]
 #[allow(clippy::missing_safety_doc)]
 #[no_mangle]