Pass scheme ID to UserInner cleaner.

src/scheme/mod.rs

@@ -223,9 +223,11 @@ impl SchemeList {
     }
 
     /// Create a new scheme.
-    pub fn insert<F>(&mut self, ns: SchemeNamespace, name: &str, scheme_fn: F) -> Result<SchemeId>
-        where F: Fn(SchemeId) -> Arc<dyn KernelScheme>
-    {
+    pub fn insert(&mut self, ns: SchemeNamespace, name: &str, scheme_fn: impl FnOnce(SchemeId) -> Arc<dyn KernelScheme>) -> Result<SchemeId> {
+        self.insert_and_pass(ns, name, |id| (scheme_fn(id), ())).map(|(id, ())| id)
+    }
+
+    pub fn insert_and_pass<T>(&mut self, ns: SchemeNamespace, name: &str, scheme_fn: impl FnOnce(SchemeId) -> (Arc<dyn KernelScheme>, T)) -> Result<(SchemeId, T)> {
         if let Some(names) = self.names.get(&ns) {
             if names.contains_key(name) {
                 return Err(Error::new(EEXIST));
@@ -249,16 +251,16 @@ impl SchemeList {
         let id = SchemeId(self.next_id);
         self.next_id += 1;
 
-        let scheme = scheme_fn(id);
+        let (new_scheme, t) = scheme_fn(id);
 
-        assert!(self.map.insert(id, scheme).is_none());
+        assert!(self.map.insert(id, new_scheme).is_none());
         if let Some(ref mut names) = self.names.get_mut(&ns) {
             assert!(names.insert(name.to_string().into_boxed_str(), id).is_none());
         } else {
             // Nonexistent namespace, posssibly null namespace
             return Err(Error::new(ENODEV));
         }
-        Ok(id)
+        Ok((id, t))
     }
 
     /// Remove a scheme

src/scheme/root.rs

@@ -85,11 +85,12 @@ impl Scheme for RootScheme {
                 let inner = {
                     let path_box = path.to_string().into_boxed_str();
                     let mut schemes = scheme::schemes_mut();
-                    let inner = Arc::new(UserInner::new(self.scheme_id, id, path_box, flags, context));
-                    schemes.insert(self.scheme_ns, path, |scheme_id| {
-                        inner.scheme_id.store(scheme_id, Ordering::SeqCst);
-                        Arc::new(UserScheme::new(Arc::downgrade(&inner)))
+
+                    let (_scheme_id, inner) = schemes.insert_and_pass(self.scheme_ns, path, |scheme_id| {
+                        let inner = Arc::new(UserInner::new(self.scheme_id, scheme_id, id, path_box, flags, context));
+                        (Arc::new(UserScheme::new(Arc::downgrade(&inner))), inner)
                     })?;
+
                     inner
                 };
 
@@ -263,9 +264,7 @@ impl Scheme for RootScheme {
         let handle = self.handles.write().remove(&file).ok_or(Error::new(EBADF))?;
         match handle {
             Handle::Scheme(inner) => {
-                let scheme_id = inner.scheme_id.load(Ordering::SeqCst);
-                let mut schemes = scheme::schemes_mut();
-                schemes.remove(scheme_id);
+                scheme::schemes_mut().remove(inner.scheme_id);
             },
             _ => ()
         }

src/scheme/user.rs

@@ -17,7 +17,7 @@ use crate::event;
 use crate::memory::Frame;
 use crate::paging::mapper::InactiveFlusher;
 use crate::paging::{PAGE_SIZE, Page, VirtualAddress};
-use crate::scheme::{AtomicSchemeId, SchemeId};
+use crate::scheme::SchemeId;
 use crate::sync::{WaitQueue, WaitMap};
 use crate::syscall::data::{Map, Packet};
 use crate::syscall::error::*;
@@ -33,7 +33,7 @@ pub struct UserInner {
     handle_id: usize,
     pub name: Box<str>,
     pub flags: usize,
-    pub scheme_id: AtomicSchemeId,
+    pub scheme_id: SchemeId,
     next_id: Mutex<u64>,
     context: Weak<RwLock<Context>>,
     todo: WaitQueue<Packet>,
@@ -50,13 +50,13 @@ pub enum Response {
 const ONE: NonZeroUsize = NonZeroUsize::new(1).unwrap();
 
 impl UserInner {
-    pub fn new(root_id: SchemeId, handle_id: usize, name: Box<str>, flags: usize, context: Weak<RwLock<Context>>) -> UserInner {
+    pub fn new(root_id: SchemeId, scheme_id: SchemeId, handle_id: usize, name: Box<str>, flags: usize, context: Weak<RwLock<Context>>) -> UserInner {
         UserInner {
             root_id,
             handle_id,
             name,
             flags,
-            scheme_id: AtomicSchemeId::default(),
+            scheme_id,
             next_id: Mutex::new(1),
             context,
             todo: WaitQueue::new(),
@@ -386,7 +386,7 @@ impl UserInner {
         if packet.id == 0 {
             // TODO: Simplify logic by using SKMSG with packet.id being ignored?
             match packet.a {
-                SYS_FEVENT => event::trigger(self.scheme_id.load(Ordering::SeqCst), packet.b, EventFlags::from_bits_truncate(packet.c)),
+                SYS_FEVENT => event::trigger(self.scheme_id, packet.b, EventFlags::from_bits_truncate(packet.c)),
                 _ => log::warn!("Unknown scheme -> kernel message {}", packet.a)
             }
         } else if Error::demux(packet.a) == Err(Error::new(ESKMSG)) {
@@ -475,14 +475,13 @@ impl UserInner {
             let context_lock = context::current()?;
             let context = context_lock.read();
             // TODO: Faster, cleaner mechanism to get descriptor
-            let scheme = self.scheme_id.load(Ordering::SeqCst);
             let mut desc_res = Err(Error::new(EBADF));
             for context_file in context.files.read().iter().flatten() {
                 let (context_scheme, context_number) = {
                     let desc = context_file.description.read();
                     (desc.scheme, desc.number)
                 };
-                if context_scheme == scheme && context_number == file {
+                if context_scheme == self.scheme_id && context_number == file {
                     desc_res = Ok(context_file.clone());
                     break;
                 }