Allow multiple processes to share IRQs.

I haven't been able to receive xhc interrupt anyway.

src/scheme/irq.rs

 use core::{mem, str};
-use core::sync::atomic::Ordering;
-use spin::Mutex;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use spin::{Mutex, RwLock};
+
+use alloc::collections::BTreeMap;
 
 use crate::event;
 use crate::interrupt::irq::acknowledge;
@@ -12,22 +14,42 @@ use crate::syscall::scheme::Scheme;
 pub static IRQ_SCHEME_ID: AtomicSchemeId = AtomicSchemeId::default();
 
 /// IRQ queues
-static ACKS: Mutex<[usize; 16]> = Mutex::new([0; 16]);
 static COUNTS: Mutex<[usize; 16]> = Mutex::new([0; 16]);
+static HANDLES: RwLock<Option<BTreeMap<usize, Handle>>> = RwLock::new(None);
 
 /// Add to the input queue
 #[no_mangle]
 pub extern fn irq_trigger(irq: u8) {
     COUNTS.lock()[irq as usize] += 1;
-    event::trigger(IRQ_SCHEME_ID.load(Ordering::SeqCst), irq as usize, EVENT_READ);
+
+    let guard = HANDLES.read();
+    if let Some(handles) = guard.as_ref() {
+        for (fd, _) in handles.iter().filter(|(_, handle)| handle.irq == irq) {
+            event::trigger(IRQ_SCHEME_ID.load(Ordering::SeqCst), *fd, EVENT_READ);
+        }
+    } else {
+        println!("Calling IRQ without triggering");
+    }
 }
 
-pub struct IrqScheme;
+struct Handle {
+    ack: AtomicUsize,
+    irq: u8,
+}
+
+pub struct IrqScheme {
+    next_fd: AtomicUsize,
+}
 
 impl IrqScheme {
     pub fn new(scheme_id: SchemeId) -> IrqScheme {
         IRQ_SCHEME_ID.store(scheme_id, Ordering::SeqCst);
-        IrqScheme
+
+        *HANDLES.write() = Some(BTreeMap::new());
+
+        IrqScheme {
+            next_fd: AtomicUsize::new(0),
+        }
     }
 }
 
@@ -39,7 +61,9 @@ impl Scheme for IrqScheme {
             let id = path_str.parse::<usize>().or(Err(Error::new(ENOENT)))?;
 
             if id < COUNTS.lock().len() {
-                Ok(id)
+                let fd = self.next_fd.fetch_add(1, Ordering::Relaxed);
+                HANDLES.write().as_mut().unwrap().insert(fd, Handle { ack: AtomicUsize::new(0), irq: id as u8 });
+                Ok(fd)
             } else {
                 Err(Error::new(ENOENT))
             }
@@ -51,9 +75,11 @@ impl Scheme for IrqScheme {
     fn read(&self, file: usize, buffer: &mut [u8]) -> Result<usize> {
         // Ensures that the length of the buffer is larger than the size of a usize
         if buffer.len() >= mem::size_of::<usize>() {
-            let ack = ACKS.lock()[file];
-            let current = COUNTS.lock()[file];
-            if ack != current {
+            let handles_guard = HANDLES.read();
+            let handle = &handles_guard.as_ref().unwrap().get(&file).ok_or(Error::new(EBADF))?;
+
+            let current = COUNTS.lock()[handle.irq as usize];
+            if handle.ack.load(Ordering::SeqCst) != current {
                 // Safe if the length of the buffer is larger than the size of a usize
                 assert!(buffer.len() >= mem::size_of::<usize>());
                 unsafe { *(buffer.as_mut_ptr() as *mut usize) = current; }
@@ -69,11 +95,16 @@ impl Scheme for IrqScheme {
     fn write(&self, file: usize, buffer: &[u8]) -> Result<usize> {
         if buffer.len() >= mem::size_of::<usize>() {
             assert!(buffer.len() >= mem::size_of::<usize>());
+
+            let handles_guard = HANDLES.read();
+            let handle = &handles_guard.as_ref().unwrap().get(&file).ok_or(Error::new(EBADF))?;
+
             let ack = unsafe { *(buffer.as_ptr() as *const usize) };
-            let current = COUNTS.lock()[file];
+            let current = COUNTS.lock()[handle.irq as usize];
+
             if ack == current {
-                ACKS.lock()[file] = ack;
-                unsafe { acknowledge(file); }
+                handle.ack.store(ack, Ordering::SeqCst);
+                unsafe { acknowledge(handle.irq as usize); }
                 Ok(mem::size_of::<usize>())
             } else {
                 Ok(0)