libasync/smoltcp/mod: prevent duplicated wakers

libasync/src/smoltcp/mod.rs

@@ -30,7 +30,7 @@ impl Sockets {
         let sockets = RefCell::new(SocketSet::new(sockets_storage));
 
         let wakers = RefCell::new(Vec::new());
-        
+
         let instance = Sockets {
             sockets,
             wakers,
@@ -57,7 +57,7 @@ impl Sockets {
     pub(crate) fn instance() -> &'static Self {
         unsafe { SOCKETS.as_ref().expect("Sockets") }
     }
-    
+
     fn poll<'b, 'c, 'e, D: for<'d> Device<'d>>(
         &self,
         iface: &mut EthernetInterface<'b, 'c, 'e, D>,
@@ -81,7 +81,14 @@ impl Sockets {
     /// TODO: this was called through eg. TcpStream, another poll()
     /// might want to send packets before sleeping for an interrupt.
     pub(crate) fn register_waker(waker: Waker) {
-        Self::instance().wakers.borrow_mut()
+        let mut wakers = Self::instance().wakers.borrow_mut();
-            .push(waker);
+        for (i, w) in wakers.iter().enumerate() {
+            if w.will_wake(&waker) {
+                let last = wakers.len() - 1;
+                wakers.swap(i, last);
+                return;
+            }
+        }
+        wakers.push(waker);
     }
 }

libcortex_a9/src/mutex.rs

@@ -3,7 +3,7 @@ use core::sync::atomic::{AtomicU32, Ordering};
 use core::cell::UnsafeCell;
 use super::{
     spin_lock_yield, notify_spin_lock,
-    asm::{dmb, enter_critical, exit_critical}
+    asm::{enter_critical, exit_critical}
 };
 
 const LOCKED: u32 = 1;
@@ -32,30 +32,27 @@ impl<T> Mutex<T> {
     /// Lock the Mutex, blocks when already locked
     pub fn lock(&self) -> MutexGuard<T> {
         let mut irq = unsafe { enter_critical() };
-        while self.locked.compare_and_swap(UNLOCKED, LOCKED, Ordering::Acquire) != UNLOCKED {
+        while self.locked.compare_and_swap(UNLOCKED, LOCKED, Ordering::AcqRel) != UNLOCKED {
             unsafe {
                 exit_critical(irq);
                 spin_lock_yield();
                 irq = enter_critical();
             }
         }
-        dmb();
         MutexGuard { mutex: self, irq }
     }
 
     pub fn try_lock(&self) -> Option<MutexGuard<T>> {
         let irq = unsafe { enter_critical() };
-        if self.locked.compare_and_swap(UNLOCKED, LOCKED, Ordering::Acquire) != UNLOCKED {
+        if self.locked.compare_and_swap(UNLOCKED, LOCKED, Ordering::AcqRel) != UNLOCKED {
             unsafe { exit_critical(irq) };
             None
         } else {
-            dmb();
             Some(MutexGuard { mutex: self, irq })
         }
     }
 
     fn unlock(&self) {
-        dmb();
         self.locked.store(UNLOCKED, Ordering::Release);
 
         notify_spin_lock();