Browse Source

Rewrite linux mapper to use epoll instead of threads and blocking IO

master
Travis Burtrum 2 months ago
parent
commit
d785d341cb
6 changed files with 215 additions and 177 deletions
  1. +13
    -0
      Cargo.lock
  2. +1
    -0
      Cargo.toml
  3. +13
    -24
      src/error.rs
  4. +1
    -5
      src/keymapper.rs
  5. +99
    -13
      src/linux/device/input_device.rs
  6. +88
    -135
      src/linux/mod.rs

+ 13
- 0
Cargo.lock View File

@ -1,5 +1,7 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3
[[package]]
name = "bitflags"
version = "1.2.1"
@ -18,6 +20,16 @@ version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
[[package]]
name = "epoll"
version = "4.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20df693c700404f7e19d4d6fae6b15215d2913c27955d2b9d6f2c0f537511cd0"
dependencies = [
"bitflags",
"libc",
]
[[package]]
name = "getopts"
version = "0.2.21"
@ -94,6 +106,7 @@ dependencies = [
name = "rusty-keys"
version = "0.0.3"
dependencies = [
"epoll",
"getopts",
"inotify",
"lazy_static",


+ 1
- 0
Cargo.toml View File

@ -32,4 +32,5 @@ lazy_static = "1.4.0"
[target.'cfg(target_os="linux")'.dependencies]
libc = "0.2.72"
nix = "0.17.0"
epoll = "4.3.1"
inotify = { version = "0.8.3", default-features = false, features = [] }

+ 13
- 24
src/error.rs View File

@ -3,15 +3,9 @@ use std::error;
use std::ffi;
use std::io;
#[cfg(target_os = "linux")]
use std::sync::mpsc;
#[cfg(target_os = "linux")]
use nix;
#[cfg(target_os = "linux")]
use libc;
/// UInput error.
#[derive(Debug)]
pub enum Error {
@ -23,15 +17,16 @@ pub enum Error {
Nul(ffi::NulError),
Io(io::Error),
Toml(toml::de::Error),
#[cfg(target_os = "linux")]
Send(mpsc::SendError<libc::input_event>),
/// The uinput file could not be found.
NotFound,
NotAKeyboard,
/// error reading input_event
ShortRead,
/// epoll already added
EpollAlreadyAdded,
}
impl From<ffi::NulError> for Error {
@ -53,13 +48,6 @@ impl From<io::Error> for Error {
}
}
#[cfg(target_os = "linux")]
impl From<mpsc::SendError<libc::input_event>> for Error {
fn from(value: mpsc::SendError<libc::input_event>) -> Self {
Error::Send(value)
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match self {
@ -69,13 +57,14 @@ impl fmt::Display for Error {
&Error::Nul(ref err) => err.fmt(f),
&Error::Io(ref err) => err.fmt(f),
#[cfg(target_os = "linux")]
&Error::Send(ref err) => err.fmt(f),
&Error::NotFound => f.write_str("Device not found."),
&Error::Toml(ref err) => err.fmt(f),
&Error::NotAKeyboard => f.write_str("This device file is not a keyboard"),
&Error::ShortRead => f.write_str("Error while reading from device file."),
&Error::EpollAlreadyAdded => f.write_str("epoll already added, delete first"),
}
}
}


+ 1
- 5
src/keymapper.rs View File

@ -470,9 +470,5 @@ fn parse_cfg<P: AsRef<Path>>(path: P) -> Result<KeymapConfig> {
let mut f = File::open(path)?;
let mut input = String::new();
f.read_to_string(&mut input)?;
//toml::from_str(&input)?
match toml::from_str(&input) {
Ok(toml) => Ok(toml),
Err(_) => Err(Error::NotFound) // todo: something better
}
toml::from_str(&input).map_err(|e| Error::Toml(e))
}

+ 99
- 13
src/linux/device/input_device.rs View File

@ -2,54 +2,140 @@ use std::mem;
use std::fs::File;
use std::io::Read;
use std::os::unix::io::AsRawFd;
use std::os::unix::prelude::RawFd;
use libc::{input_event, c_int};
use nix::ioctl_write_ptr;
use nix::{ioctl_write_ptr, ioctl_read_buf};
use epoll::ControlOptions::{EPOLL_CTL_ADD, EPOLL_CTL_DEL};
use nix::fcntl::{OFlag, fcntl, FcntlArg};
use crate::{Error,Result};
use crate::linux::{EV_KEY, KEY_MAX, NAME, KEY_W, KEY_A, KEY_S, KEY_D};
ioctl_write_ptr!(eviocgrab, b'E', 0x90, c_int);
ioctl_read_buf!(eviocgname, b'E', 0x06, u8);
ioctl_read_buf!(eviocgbit, b'E', 0x20, u8);
ioctl_read_buf!(eviocgbit_ev_key, b'E', 0x20 + EV_KEY, u8);
const SIZE_OF_INPUT_EVENT: usize = mem::size_of::<input_event>();
pub struct InputDevice {
device_file: File,
buf: [u8; SIZE_OF_INPUT_EVENT],
grabbed: bool,
epoll_fd: Option<RawFd>,
}
impl InputDevice {
pub fn open(device_file: &str) -> Result<Self> {
let device_file = File::open(device_file)?;
pub fn open<P: AsRef<std::path::Path>>(path: P) -> Result<Self> {
Ok(InputDevice {
device_file: device_file,
buf: [0u8; SIZE_OF_INPUT_EVENT],
device_file: File::open(path)?,
grabbed: false,
epoll_fd: None,
})
}
pub fn new_input_event_buf() -> [u8; SIZE_OF_INPUT_EVENT] {
[0u8; SIZE_OF_INPUT_EVENT]
}
pub fn read_event(&mut self) -> Result<input_event> {
let num_bytes = self.device_file.read(&mut self.buf)?;
pub fn read_event(&mut self, buf: &mut [u8; SIZE_OF_INPUT_EVENT]) -> Result<input_event> {
let num_bytes = self.device_file.read(buf)?;
if num_bytes != SIZE_OF_INPUT_EVENT {
return Err(Error::ShortRead);
}
let event: input_event = unsafe { mem::transmute(self.buf) };
let event: input_event = unsafe { mem::transmute(*buf) };
Ok(event)
}
pub fn grab(&mut self) -> Result<()> {
pub fn valid_keyboard_device(self) -> Result<Self> {
use std::os::unix::fs::FileTypeExt;
// must be a character device
if !self.device_file.metadata()?.file_type().is_char_device() {
return Err(Error::NotAKeyboard);
}
let raw_fd = self.device_file.as_raw_fd();
// does it support EV_KEY
let mut evbit = [0u8; 8];
unsafe {
eviocgbit(raw_fd, &mut evbit)?;
};
let evbit = u64::from_ne_bytes(evbit);
if (evbit & (1 << EV_KEY)) == 0 {
return Err(Error::NotAKeyboard);
}
// does it support all keys WASD ? (yes this is fairly random but probably good enough, could make configuration probably)
let mut key_bits = [0u8; (KEY_MAX as usize / 8) + 1];
unsafe {
eviocgbit_ev_key(raw_fd, &mut key_bits)?;
};
let key_unsupported = |key : c_int| (key_bits[key as usize / 8] & (1 << (key % 8))) == 0;
if key_unsupported(KEY_W) || key_unsupported(KEY_A) || key_unsupported(KEY_S) || key_unsupported(KEY_D) {
return Err(Error::NotAKeyboard);
}
// is it another running copy of rusty-keys ?
let mut name = [0u8; NAME.len()];
unsafe {
eviocgname(raw_fd, &mut name)?
};
if NAME.as_bytes() == &name {
return Err(Error::NotAKeyboard);
}
return Ok(self);
}
pub fn grab(mut self) -> Result<Self> {
unsafe {
eviocgrab(self.device_file.as_raw_fd(), 1 as *const c_int)?;
}
Ok(())
self.grabbed = true;
Ok(self)
}
pub fn release(&mut self) -> Result<()> {
unsafe {
eviocgrab(self.device_file.as_raw_fd(), 0 as *const c_int)?;
if self.grabbed {
unsafe {
eviocgrab(self.device_file.as_raw_fd(), 0 as *const c_int)?;
}
self.grabbed = false;
}
Ok(())
}
pub fn epoll_add(mut self, epoll_fd: RawFd, data: u64) -> Result<Self> {
if None != self.epoll_fd {
return Err(Error::EpollAlreadyAdded);
}
let raw_fd = self.device_file.as_raw_fd();
let flags = unsafe {
// https://github.com/nix-rust/nix/issues/1102
OFlag::from_bits_unchecked(fcntl(raw_fd, FcntlArg::F_GETFL)?)
};
fcntl(raw_fd, FcntlArg::F_SETFL(flags | OFlag::O_NONBLOCK))?;
let epoll_event = epoll::Event::new(epoll::Events::EPOLLIN | epoll::Events::EPOLLET, data);
epoll::ctl(epoll_fd, EPOLL_CTL_ADD, raw_fd, epoll_event)?;
self.epoll_fd = Some(epoll_fd);
Ok(self)
}
pub fn epoll_del(&mut self) -> Result<&mut Self> {
if let Some(epoll_fd) = self.epoll_fd {
let empty_event = epoll::Event::new(epoll::Events::empty(), 0);
epoll::ctl(epoll_fd, EPOLL_CTL_DEL, self.device_file.as_raw_fd(), empty_event)?;
self.epoll_fd = None;
}
Ok(self)
}
}
impl Drop for InputDevice {
fn drop(&mut self) {
// todo: only release if grabbed
self.release().ok(); // ignore any errors here, what could we do anyhow?
self.epoll_del().ok();
}
}

+ 88
- 135
src/linux/mod.rs View File

@ -19,9 +19,7 @@ pub fn open<P: AsRef<Path>>(path: P) -> Result<device::Builder> {
use libc::input_event;
use std::process::exit;
use std::{env, thread};
use std::sync::mpsc;
use std::sync::mpsc::Sender;
use std::env;
const INPUT_FOLDER: &str = "/dev/input/";
@ -32,7 +30,6 @@ const UP: i32 = 0;
use getopts::Options;
use inotify::{
EventMask,
Inotify,
WatchMask,
};
@ -101,8 +98,6 @@ impl Keyboard<u16, input_event> for Device {
}
}
#[derive(Debug)]
struct Config {
device_files: Vec<String>,
@ -132,76 +127,107 @@ pub fn main_res() -> Result<()> {
let mut key_map = LinuxKeyMaps::from_cfg(&key_map, &config.config_file);
//println!("keymaps: {:?}", keymaps);
let mut input_event_buf = InputDevice::new_input_event_buf();
if config.device_files.len() == 1 {
// shortcut, don't bother with threads
let mut input_device = InputDevice::open(&config.device_files[0])?;
input_device.grab()?;
// shortcut, don't bother with epoll
let mut input_device = InputDevice::open(&config.device_files[0])?.grab()?;
loop {
let event = input_device.read_event()?;
let event = input_device.read_event(&mut input_event_buf)?;
send_event(&mut key_map, event, &device)?
}
} else {
// start up some intra thread communication
let (tx, rx) = mpsc::channel();
if config.device_files.len() > 0 {
// we only want to operate on device files sent in then quit
for device_file in config.device_files.iter() {
let device_file = device_file.clone();
let tx = tx.clone();
thread::spawn(move || {
let ret = spawn_map_thread(tx, &device_file);
if let Err(e) = ret {
println!("mapping for {} ended due to error: {}", device_file, e);
}
});
}
} else {
let tx = tx.clone();
thread::spawn(move || {
// we want to wait forever starting new threads for any new keyboard devices
let mut inotify = Inotify::init().expect("Failed to initialize inotify");
let epoll_fd = epoll::create(true)?;
const INOTIFY_DATA: u64 = u64::max_value();
inotify.add_watch(INPUT_FOLDER, WatchMask::CREATE).expect("Failed to add inotify watch");
let (device_files, mut inotify) = if config.device_files.len() > 0 {
// we operate on exactly the devices sent in and never watch for new devices
(config.device_files.iter().map(|device_file| InputDevice::open(&device_file).expect("device_file does not exist!")).collect(), None)
} else {
use std::os::unix::io::AsRawFd;
// we want to wait forever starting new threads for any new keyboard devices
// there is a slight race condition here, if a keyboard is plugged in between the time we
// enumerate the devices and set up the inotify watch, we'll miss it, doing it the other way
// can bring duplicates though, todo: think about this...
let device_files = get_keyboard_devices();
let mut inotify = Inotify::init()?;
inotify.add_watch(INPUT_FOLDER, WatchMask::CREATE)?;
let epoll_event = epoll::Event::new(epoll::Events::EPOLLIN | epoll::Events::EPOLLET, INOTIFY_DATA);
epoll::ctl(epoll_fd, epoll::ControlOptions::EPOLL_CTL_ADD, inotify.as_raw_fd(), epoll_event)?;
(device_files, Some(inotify))
};
let mut input_devices = Vec::with_capacity(device_files.len());
for (idx, device_file) in device_files.into_iter().enumerate() {
input_devices.push(Some(device_file.grab()?.epoll_add(epoll_fd, idx as u64)?));
}
let device_files = get_keyboard_device_filenames();
println!("Detected devices: {:?}", device_files);
for device_file in device_files.iter() {
inotify_spawn_thread(&tx, device_file);
}
let mut epoll_buf = [epoll::Event::new(epoll::Events::empty(), 0); 4];
let mut inotify_buf = [0u8; 256];
let mut buffer = [0u8; 4096];
loop {
let events = inotify.read_events_blocking(&mut buffer);
if let Ok(events) = events {
for event in events {
if !event.mask.contains(EventMask::ISDIR) {
if let Some(device_file) = event.name.and_then(|name|name.to_str()) {
// check if this is an eligible keyboard device
let mut path = std::path::PathBuf::new();
path.push(INPUT_FOLDER);
path.push(device_file);
if valid_keyboard_device(path) {
println!("starting mapping thread for: {}", device_file);
inotify_spawn_thread(&tx, device_file.clone());
loop {
let num_events = epoll::wait(epoll_fd, -1, &mut epoll_buf)?;
for event in &epoll_buf[0..num_events] {
let idx = event.data as usize;
if let Some(Some(input_device)) = &mut input_devices.get_mut(idx) {
loop {
match input_device.read_event(&mut input_event_buf) {
Ok(event) => {
//println!("input event: {:?}", event);
send_event(&mut key_map, event, &device)?
}
Err(err) => {
if let Error::Io(ref err) = err {
if err.kind() == std::io::ErrorKind::WouldBlock {
// go back to epoll event loop
break;
}
}
// otherwise it's some other error, don't read anything from this again
println!("input err: {:?}", err);
// remove it from input_devices and drop it
let _ = std::mem::replace(&mut input_devices[idx], None);
if inotify.is_none() {
// if we aren't watching with inotify, and the last device is removed (Vec only has None's in it), exit the program
if input_devices.iter().all(|id| id.is_none()) {
println!("last device went away, exiting...");
return Ok(());
}
}
break;
}
}
}
} else if event.data == INOTIFY_DATA {
if let Some(inotify) = &mut inotify {
for event in inotify.read_events(&mut inotify_buf)? {
if let Some(device_file) = event.name.and_then(|name| name.to_str()) {
// check if this is an eligible keyboard device
let mut path = std::path::PathBuf::new();
path.push(INPUT_FOLDER);
path.push(device_file);
if let Ok(input_device) = InputDevice::open(path).and_then(|id|id.valid_keyboard_device()) {
println!("starting mapping for new keyboard: {}", device_file);
let idx = input_devices.iter().position(|id| id.is_none()).unwrap_or(input_devices.len());
let input_device = input_device.grab()?.epoll_add(epoll_fd, idx as u64)?;
if idx == input_devices.len() {
input_devices.push(Some(input_device));
} else {
// simply replacing None here
let _ = std::mem::replace(&mut input_devices[idx], Some(input_device));
}
}
}
}
}
}
});
}
drop(tx); // drop our last one, so when the threads finish, everything stops
// process all events
for event in rx {
send_event(&mut key_map, event, &device)?
}
}
}
Ok(())
}
fn send_event(key_map: &mut LinuxKeyMaps, mut event: input_event, device: &Device) -> Result<()> {
@ -213,28 +239,6 @@ fn send_event(key_map: &mut LinuxKeyMaps, mut event: input_event, device: &Devic
Ok(())
}
fn inotify_spawn_thread(tx: &Sender<input_event>, device_file: &str) {
let mut filename = INPUT_FOLDER.to_string();
filename.push_str(&device_file);
let tx = tx.clone();
thread::spawn(move || {
let ret = spawn_map_thread(tx, &filename);
if let Err(e) = ret {
println!("mapping for {} ended due to error: {}", filename, e);
}
});
}
fn spawn_map_thread(tx: Sender<input_event>, device_file: &str) -> Result<()> {
let mut input_device = InputDevice::open(device_file)?;
input_device.grab()?;
loop {
let event = input_device.read_event()?;
tx.send(event)?
}
}
fn parse_args() -> Config {
fn print_usage(program: &str, opts: Options) {
let brief = format!("Usage: {} [options] [device_files...]", program);
@ -269,64 +273,13 @@ fn parse_args() -> Config {
Config::new(matches.free, config_file)
}
nix::ioctl_read_buf!(eviocgname, b'E', 0x06, u8);
nix::ioctl_read_buf!(eviocgbit, b'E', 0x20, u8);
nix::ioctl_read_buf!(eviocgbit_ev_key, b'E', 0x20 + EV_KEY, u8);
fn valid_keyboard_device_res<P: AsRef<Path>>(path: P) -> Result<bool> {
use std::fs::File;
use std::os::unix::fs::FileTypeExt;
use std::os::unix::io::AsRawFd;
let device_file = File::open(path)?;
// must be a character device
if !device_file.metadata()?.file_type().is_char_device() {
return Ok(false);
}
// does it support EV_KEY
let mut evbit = [0u8; 8];
unsafe {
eviocgbit(device_file.as_raw_fd(), &mut evbit)?;
};
let evbit = u64::from_ne_bytes(evbit);
if (evbit & (1 << EV_KEY)) == 0 {
return Ok(false);
}
// does it support KEY_A ? todo: check other keys ?
let mut key_bits = [0u8; (KEY_MAX as usize / 8) + 1];
unsafe {
eviocgbit_ev_key(device_file.as_raw_fd(), &mut key_bits)?;
};
if (key_bits[KEY_A as usize / 8] & (1 << (KEY_A % 8))) == 0 {
return Ok(false);
}
// is it another running copy of rusty-keys ?
let mut name = [0u8; NAME.len()];
unsafe {
eviocgname(device_file.as_raw_fd(), &mut name)?
};
if NAME.as_bytes() == &name {
return Ok(false);
}
return Ok(true);
}
fn valid_keyboard_device<P: AsRef<Path>>(path: P) -> bool {
valid_keyboard_device_res(path).unwrap_or(false)
}
fn get_keyboard_device_filenames() -> Vec<String> {
fn get_keyboard_devices() -> Vec<InputDevice> {
let mut res = Vec::new();
if let Ok(entries) = std::fs::read_dir(INPUT_FOLDER) {
for entry in entries {
if let Ok(entry) = entry {
if valid_keyboard_device(entry.path()) {
// these unwrap()'s should not be able to fail if valid_keyboard_device() returns true
res.push(entry.path().file_name().unwrap().to_str().unwrap().to_owned());
if let Ok(input_device) = InputDevice::open(entry.path()).and_then(|id|id.valid_keyboard_device()) {
res.push(input_device);
}
}
}


Loading…
Cancel
Save