revert unsafe impl linked_list::Link for TimerShared

Author: wathenjiang

tokio/src/runtime/time/entry.rs

@@ -415,16 +415,16 @@ impl TimerShared {
 }
 
 unsafe impl linked_list::Link for TimerShared {
-    type Handle = NonNull<TimerShared>;
+    type Handle = TimerHandle;
 
     type Target = TimerShared;
 
     fn as_raw(handle: &Self::Handle) -> NonNull<Self::Target> {
-        *handle
+        handle.inner
     }
 
     unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle {
-        ptr
+        TimerHandle { inner: ptr }
     }
 
     unsafe fn pointers(
@@ -593,10 +593,6 @@ impl TimerHandle {
     pub(super) unsafe fn fire(self, completed_state: TimerResult) -> Option<Waker> {
         self.inner.as_ref().state.fire(completed_state)
     }
-
-    pub(super) fn inner(&self) -> NonNull<TimerShared> {
-        self.inner
-    }
 }
 
 impl Drop for TimerEntry {

tokio/src/runtime/time/mod.rs

@@ -325,16 +325,17 @@ impl Handle {
             // pinned in memory and is not dropped until the guarded list is dropped.
             let guard = TimerShared::new(id);
             pin!(guard);
+            let guard_handle = guard.as_ref().get_ref().handle();
 
             // * This list will be still guarded by the lock of the Wheel with the specefied id.
             //   `EntryWaitersList` wrapper makes sure we hold the lock to modify it.
             // * This wrapper will empty the list on drop. It is critical for safety
             //   that we will not leave any list entry with a pointer to the local
             //   guard node after this function returns / panics.
-            let mut list = lock.get_waiters_list(&expiration, guard.as_ref(), id, self);
+            // Safety: The `TimerShared` inside this `TimerHandle` is pinned in the memory.
+            let mut list = unsafe { lock.get_waiters_list(&expiration, guard_handle, id, self) };
 
             while let Some(entry) = list.pop_back_locked(&mut lock) {
-                let entry = unsafe { entry.as_ref().handle() };
                 let deadline = expiration.deadline;
                 // Try to expire the entry; this is cheap (doesn't synchronize) if
                 // the timer is not expired, and updates cached_when.

tokio/src/runtime/time/wheel/level.rs

@@ -121,7 +121,7 @@ impl Level {
     pub(crate) unsafe fn add_entry(&mut self, item: TimerHandle) {
         let slot = slot_for(item.true_when(), self.level);
 
-        self.slot[slot].push_front(item.inner());
+        self.slot[slot].push_front(item);
 
         self.occupied |= occupied_bit(slot);
     }

tokio/src/runtime/time/wheel/mod.rs

@@ -6,7 +6,6 @@ mod level;
 pub(crate) use self::level::Expiration;
 use self::level::Level;
 
-use std::pin::Pin;
 use std::{array, ptr::NonNull};
 
 use super::entry::MAX_SAFE_MILLIS_DURATION;
@@ -37,12 +36,11 @@ impl<'a> Drop for EntryWaitersList<'a> {
 impl<'a> EntryWaitersList<'a> {
     fn new(
         unguarded_list: LinkedList<TimerShared, <TimerShared as linked_list::Link>::Target>,
-        guard: Pin<&'a TimerShared>,
+        guard_handle: TimerHandle,
         wheel_id: u32,
         handle: &'a Handle,
     ) -> Self {
-        let guard_ptr = NonNull::from(guard.get_ref());
-        let list = unguarded_list.into_guarded(guard_ptr);
+        let list = unguarded_list.into_guarded(guard_handle);
         Self {
             list,
             is_empty: false,
@@ -53,7 +51,7 @@ impl<'a> EntryWaitersList<'a> {
 
     /// Removes the last element from the guarded list. Modifying this list
     /// requires an exclusive access to the Wheel with the specified `wheel_id`.
-    pub(super) fn pop_back_locked(&mut self, _wheel: &mut Wheel) -> Option<NonNull<TimerShared>> {
+    pub(super) fn pop_back_locked(&mut self, _wheel: &mut Wheel) -> Option<TimerHandle> {
         let result = self.list.pop_back();
         if result.is_none() {
             // Save information about emptiness to avoid waiting for lock
@@ -263,10 +261,11 @@ impl Wheel {
     }
 
     /// Obtains the guarded list of entries that need processing for the given expiration.
-    pub(super) fn get_waiters_list<'a>(
+    /// Safety: The `TimerShared` inside `guard_handle` must be pinned in the memory.
+    pub(super) unsafe fn get_waiters_list<'a>(
         &mut self,
         expiration: &Expiration,
-        guard: Pin<&'a TimerShared>,
+        guard_handle: TimerHandle,
         wheel_id: u32,
         handle: &'a Handle,
     ) -> EntryWaitersList<'a> {
@@ -281,7 +280,7 @@ impl Wheel {
         // back into the same position; we must make sure we don't then process
         // those entries again or we'll end up in an infinite loop.
         let unguarded_list = self.levels[expiration.level].take_slot(expiration.slot);
-        EntryWaitersList::new(unguarded_list, guard, wheel_id, handle)
+        EntryWaitersList::new(unguarded_list, guard_handle, wheel_id, handle)
     }
 
     pub(super) fn occupied_bit_maintain(&mut self, expiration: &Expiration) {