Add irq manager for drivers

Author: Jiajie Chen

kernel/src/drivers/irq.rs

@@ -0,0 +1,65 @@
+use super::Driver;
+use alloc::collections::btree_map::Entry;
+use alloc::collections::BTreeMap;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+
+struct IrqManager {
+    // drivers that only respond to specific irq
+    mapping: BTreeMap<u32, Vec<Arc<Driver>>>,
+    // drivers that respond to all irqs
+    all: Vec<Arc<Driver>>,
+}
+
+impl IrqManager {
+    pub fn new() -> IrqManager {
+        IrqManager {
+            mapping: BTreeMap::new(),
+            all: Vec::new(),
+        }
+    }
+
+    pub fn register_irq(&mut self, irq: u32, driver: Arc<Driver>) {
+        match self.mapping.entry(irq) {
+            Entry::Occupied(mut e) => {
+                e.get_mut().push(driver);
+            }
+            Entry::Vacant(e) => {
+                let mut v = Vec::new();
+                v.push(driver);
+                e.insert(v);
+            }
+        }
+    }
+
+    pub fn register_all(&mut self, driver: Arc<Driver>) {
+        self.all.push(driver);
+    }
+
+    pub fn deregister_irq(&mut self, irq: u32, driver: Arc<Driver>) {
+        if let Some(e) = self.mapping.get_mut(&irq) {
+            e.retain(|d| !Arc::ptr_eq(&d, &driver));
+        }
+    }
+
+    pub fn deregister_all(&mut self, driver: Arc<Driver>) {
+        self.all.retain(|d| !Arc::ptr_eq(&d, &driver));
+    }
+
+    pub fn handle_interrupt(&self, irq: u32) -> bool {
+        if let Some(e) = self.mapping.get(&irq) {
+            for dri in e.iter() {
+                if dri.try_handle_interrupt(Some(irq)) {
+                    return true;
+                }
+            }
+        }
+
+        for dri in self.all.iter() {
+            if dri.try_handle_interrupt(Some(irq)) {
+                return true;
+            }
+        }
+        false
+    }
+}

kernel/src/drivers/mod.rs

@@ -18,6 +18,7 @@ mod device_tree;
 mod gpu;
 #[allow(dead_code)]
 mod input;
+pub mod irq;
 #[allow(dead_code)]
 pub mod net;
 mod provider;

kernel/src/syscall/fs.rs

@@ -338,7 +338,7 @@ impl Syscall<'_> {
     ) -> SysResult {
         // TODO: check permissions based on uid/gid
         let proc = self.process();
-        let path = unsafe { check_and_clone_cstr(path)? };
+        let path = check_and_clone_cstr(path)?;
         let flags = AtFlags::from_bits_truncate(flags);
         if !proc.pid.is_init() {
             // we trust pid 0 process
@@ -419,7 +419,7 @@ impl Syscall<'_> {
         len: usize,
     ) -> SysResult {
         let proc = self.process();
-        let path = unsafe { check_and_clone_cstr(path)? };
+        let path = check_and_clone_cstr(path)?;
         let slice = unsafe { self.vm().check_write_array(base, len)? };
         info!(
             "readlinkat: dirfd: {}, path: {:?}, base: {:?}, len: {}",
@@ -465,7 +465,7 @@ impl Syscall<'_> {
 
     pub fn sys_truncate(&mut self, path: *const u8, len: usize) -> SysResult {
         let proc = self.process();
-        let path = unsafe { check_and_clone_cstr(path)? };
+        let path = check_and_clone_cstr(path)?;
         info!("truncate: path: {:?}, len: {}", path, len);
         proc.lookup_inode(&path)?.resize(len)?;
         Ok(0)
@@ -678,7 +678,7 @@ impl Syscall<'_> {
 
     pub fn sys_unlinkat(&mut self, dirfd: usize, path: *const u8, flags: usize) -> SysResult {
         let proc = self.process();
-        let path = unsafe { check_and_clone_cstr(path)? };
+        let path = check_and_clone_cstr(path)?;
         let flags = AtFlags::from_bits_truncate(flags);
         info!(
             "unlinkat: dirfd: {}, path: {:?}, flags: {:?}",