Re-introduce a token invalidation mechanism

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+#### Additions
+
+- `Token` and `RegistrationToken` are now invalidated when the event source they represent is removed from the event loop.
+
 #### Bugfixes
 
 - Fix an issue, where id-reuse could execute a PostAction on a newly registered event source

src/io.rs

@@ -19,9 +19,8 @@ use futures_io::{AsyncRead, AsyncWrite, IoSlice, IoSliceMut};
 
 use crate::loop_logic::EventIterator;
 use crate::{
-    loop_logic::{LoopInner, MAX_SOURCES_MASK},
-    sources::EventDispatcher,
-    Interest, Mode, Poll, PostAction, Readiness, Token, TokenFactory,
+    loop_logic::LoopInner, sources::EventDispatcher, Interest, Mode, Poll, PostAction, Readiness,
+    Token, TokenFactory,
 };
 use crate::{AdditionalLifecycleEventsSet, RegistrationToken};
 
@@ -62,8 +61,13 @@ impl<'l, F: AsFd> Async<'l, F> {
             interest: Interest::EMPTY,
             last_readiness: Readiness::EMPTY,
         }));
-        let key = inner.sources.borrow_mut().insert(Some(dispatcher.clone()));
-        dispatcher.borrow_mut().token = Some(Token { key });
+
+        {
+            let mut sources = inner.sources.borrow_mut();
+            let slot = sources.vacant_entry();
+            slot.source = Some(dispatcher.clone());
+            dispatcher.borrow_mut().token = Some(Token { inner: slot.token });
+        }
 
         // SAFETY: We are sure to deregister on drop.
         unsafe {
@@ -198,17 +202,13 @@ impl<'l, Data> IoLoopInner for LoopInner<'l, Data> {
     }
 
     fn kill(&self, dispatcher: &RefCell<IoDispatcher>) {
-        let key = dispatcher
+        let token = dispatcher
             .borrow()
             .token
-            .expect("No token for IO dispatcher")
-            .key
-            & MAX_SOURCES_MASK;
-        let _source = self
-            .sources
-            .borrow_mut()
-            .try_remove(key)
-            .expect("Attempting to remove a non-existent source?!");
+            .expect("No token for IO dispatcher");
+        if let Ok(slot) = self.sources.borrow_mut().get_mut(token.inner) {
+            slot.source = None;
+        }
     }
 }
 

src/lib.rs

@@ -156,6 +156,8 @@ pub mod error;
 pub use error::{Error, InsertError, Result};
 
 pub mod io;
+mod list;
 mod loop_logic;
 mod macros;
 mod sources;
+mod token;

src/list.rs

@@ -0,0 +1,71 @@
+use std::rc::Rc;
+
+use crate::sources::EventDispatcher;
+use crate::token::TokenInner;
+
+pub(crate) struct SourceEntry<'l, Data> {
+    pub(crate) token: TokenInner,
+    pub(crate) source: Option<Rc<dyn EventDispatcher<Data> + 'l>>,
+}
+
+pub(crate) struct SourceList<'l, Data> {
+    sources: Vec<SourceEntry<'l, Data>>,
+}
+
+impl<'l, Data> SourceList<'l, Data> {
+    pub(crate) fn new() -> Self {
+        SourceList {
+            sources: Vec::new(),
+        }
+    }
+
+    pub(crate) fn vacant_entry(&mut self) -> &mut SourceEntry<'l, Data> {
+        let opt_id = self.sources.iter().position(|slot| slot.source.is_none());
+        match opt_id {
+            Some(id) => {
+                // we are reusing a slot
+                let slot = &mut self.sources[id];
+                // increment the slot version
+                slot.token = slot.token.increment_version();
+                slot
+            }
+            None => {
+                // we are inserting a new slot
+                let next_id = self.sources.len();
+                self.sources.push(SourceEntry {
+                    token: TokenInner::new(self.sources.len())
+                        .expect("Trying to insert too many sources in an event loop."),
+                    source: None,
+                });
+                &mut self.sources[next_id]
+            }
+        }
+    }
+
+    pub(crate) fn get(&self, token: TokenInner) -> crate::Result<&SourceEntry<'l, Data>> {
+        let entry = self
+            .sources
+            .get(token.get_id())
+            .ok_or(crate::Error::InvalidToken)?;
+        if entry.token.same_source_as(token) {
+            Ok(entry)
+        } else {
+            Err(crate::Error::InvalidToken)
+        }
+    }
+
+    pub(crate) fn get_mut(
+        &mut self,
+        token: TokenInner,
+    ) -> crate::Result<&mut SourceEntry<'l, Data>> {
+        let entry = self
+            .sources
+            .get_mut(token.get_id())
+            .ok_or(crate::Error::InvalidToken)?;
+        if entry.token.same_source_as(token) {
+            Ok(entry)
+        } else {
+            Err(crate::Error::InvalidToken)
+        }
+    }
+}