From fa58651b70fcd8d52c9730dafe090641cb38c681 Mon Sep 17 00:00:00 2001 From: Jeremy Soller Date: Sun, 19 Apr 2020 21:40:12 -0600 Subject: [PATCH] Add serio scheme, based on debug scheme, for supporting ps2 devices --- src/scheme/mod.rs | 5 ++ src/scheme/serio.rs | 166 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 171 insertions(+) create mode 100644 src/scheme/serio.rs diff --git a/src/scheme/mod.rs b/src/scheme/mod.rs index 5f92107..d337a08 100644 --- a/src/scheme/mod.rs +++ b/src/scheme/mod.rs @@ -28,6 +28,7 @@ use self::memory::MemoryScheme; use self::pipe::PipeScheme; use self::proc::ProcScheme; use self::root::RootScheme; +use self::serio::SerioScheme; use self::sys::SysScheme; use self::time::TimeScheme; @@ -66,6 +67,9 @@ pub mod proc; /// `:` - allows the creation of userspace schemes, tightly dependent on `user` pub mod root; +/// `serio:` - provides access to ps/2 devices +pub mod serio; + /// `sys:` - system information, such as the context list and scheme list pub mod sys; @@ -150,6 +154,7 @@ impl SchemeList { self.insert(ns, Box::new(*b"initfs"), |_| Arc::new(InitFsScheme::new())).unwrap(); self.insert(ns, Box::new(*b"irq"), |scheme_id| Arc::new(IrqScheme::new(scheme_id))).unwrap(); self.insert(ns, Box::new(*b"proc"), |scheme_id| Arc::new(ProcScheme::new(scheme_id))).unwrap(); + self.insert(ns, Box::new(*b"serio"), |scheme_id| Arc::new(SerioScheme::new(scheme_id))).unwrap(); #[cfg(feature = "live")] { self.insert(ns, Box::new(*b"disk/live"), |_| Arc::new(self::live::DiskScheme::new())).unwrap(); diff --git a/src/scheme/serio.rs b/src/scheme/serio.rs new file mode 100644 index 0000000..f3c5735 --- /dev/null +++ b/src/scheme/serio.rs @@ -0,0 +1,166 @@ +//! PS/2 unfortunately requires a kernel driver to prevent race conditions due +//! to how status is utilized +use core::str; +use core::sync::atomic::{AtomicUsize, Ordering}; +use spin::{Once, RwLock, RwLockReadGuard, RwLockWriteGuard}; + +use crate::arch::debug::Writer; +use crate::event; +use crate::scheme::*; +use crate::sync::WaitQueue; +use crate::syscall::flag::{EventFlags, EVENT_READ, F_GETFL, F_SETFL, O_ACCMODE, O_NONBLOCK}; +use crate::syscall::scheme::Scheme; + +static SCHEME_ID: AtomicSchemeId = AtomicSchemeId::default(); + +static NEXT_ID: AtomicUsize = AtomicUsize::new(0); + +/// Input queue +static INPUT: [Once>; 2] = [Once::new(), Once::new()]; + +/// Initialize input queue, called if needed +fn init_input() -> WaitQueue { + WaitQueue::new() +} + +#[derive(Clone, Copy)] +struct Handle { + index: usize, + flags: usize, +} + +static HANDLES: Once>> = Once::new(); + +fn init_handles() -> RwLock> { + RwLock::new(BTreeMap::new()) +} + +fn handles() -> RwLockReadGuard<'static, BTreeMap> { + HANDLES.call_once(init_handles).read() +} + +fn handles_mut() -> RwLockWriteGuard<'static, BTreeMap> { + HANDLES.call_once(init_handles).write() +} + +/// Add to the input queue +pub fn serio_input(index: usize, data: u8) { + INPUT[index].call_once(init_input).send(data); + for (id, _handle) in handles().iter() { + event::trigger(SCHEME_ID.load(Ordering::SeqCst), *id, EVENT_READ); + } +} + +pub struct SerioScheme; + +impl SerioScheme { + pub fn new(scheme_id: SchemeId) -> Self { + SCHEME_ID.store(scheme_id, Ordering::SeqCst); + Self + } +} + +impl Scheme for SerioScheme { + fn open(&self, path: &[u8], flags: usize, uid: u32, _gid: u32) -> Result { + if uid != 0 { + return Err(Error::new(EPERM)); + } + + let index = str::from_utf8(path) + .map_err(|err| Error::new(ENOENT))? + .parse::() + .map_err(|err| Error::new(ENOENT))?; + if index >= INPUT.len() { + return Err(Error::new(ENOENT)); + } + + let id = NEXT_ID.fetch_add(1, Ordering::SeqCst); + handles_mut().insert(id, Handle { + index, + flags: flags & ! O_ACCMODE + }); + + Ok(id) + } + + /// Read the file `number` into the `buffer` + /// + /// Returns the number of bytes read + fn read(&self, id: usize, buf: &mut [u8]) -> Result { + let handle = { + let handles = handles(); + *handles.get(&id).ok_or(Error::new(EBADF))? + }; + + INPUT[handle.index].call_once(init_input) + .receive_into(buf, handle.flags & O_NONBLOCK != O_NONBLOCK, "SerioScheme::read") + .ok_or(Error::new(EINTR)) + } + + fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Result { + let mut handles = handles_mut(); + if let Some(handle) = handles.get_mut(&id) { + match cmd { + F_GETFL => Ok(handle.flags), + F_SETFL => { + handle.flags = arg & ! O_ACCMODE; + Ok(0) + }, + _ => Err(Error::new(EINVAL)) + } + } else { + Err(Error::new(EBADF)) + } + } + + fn fevent(&self, id: usize, _flags: EventFlags) -> Result { + let _handle = { + let handles = handles(); + *handles.get(&id).ok_or(Error::new(EBADF))? + }; + + Ok(EventFlags::empty()) + } + + fn fpath(&self, id: usize, buf: &mut [u8]) -> Result { + let handle = { + let handles = handles(); + *handles.get(&id).ok_or(Error::new(EBADF))? + }; + + let mut i = 0; + let scheme_path = b"serio:"; + while i < buf.len() && i < scheme_path.len() { + buf[i] = scheme_path[i]; + i += 1; + } + + let file_path = format!("{}", handle.index).into_bytes(); + let mut j = 0; + while i < buf.len() && j < file_path.len() { + buf[i] = file_path[j]; + j += 1; + } + + Ok(i) + } + + fn fsync(&self, id: usize) -> Result { + let _handle = { + let handles = handles(); + *handles.get(&id).ok_or(Error::new(EBADF))? + }; + + Ok(0) + } + + /// Close the file `number` + fn close(&self, id: usize) -> Result { + let _handle = { + let mut handles = handles_mut(); + handles.remove(&id).ok_or(Error::new(EBADF))? + }; + + Ok(0) + } +}