| // Copyright (c) 2017 Baidu, Inc. All Rights Reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions |
| // are met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above copyright |
| // notice, this list of conditions and the following disclaimer in |
| // the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Baidu, Inc., nor the names of its |
| // contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| use super::thread; |
| use core::fmt; |
| use core::convert; |
| use core::sync::atomic::{AtomicBool, Ordering}; |
| |
| pub struct Flag { failed: AtomicBool } |
| |
| // Note that the Ordering uses to access the `failed` field of `Flag` below is |
| // always `Relaxed`, and that's because this isn't actually protecting any data, |
| // it's just a flag whether we've panicked or not. |
| // |
| // The actual location that this matters is when a mutex is **locked** which is |
| // where we have external synchronization ensuring that we see memory |
| // reads/writes to this flag. |
| // |
| // As a result, if it matters, we should see the correct value for `failed` in |
| // all cases. |
| impl Flag { |
| pub const fn new() -> Flag { |
| Flag { failed: AtomicBool::new(false) } |
| } |
| |
| #[inline] |
| pub fn borrow(&self) -> LockResult<Guard> { |
| let ret = Guard { panicking: thread::panicking() }; |
| if self.get() { |
| Err(PoisonError::new(ret)) |
| } else { |
| Ok(ret) |
| } |
| } |
| |
| #[inline] |
| pub fn done(&self, guard: &Guard) { |
| if !guard.panicking && thread::panicking() { |
| self.failed.store(true, Ordering::Relaxed); |
| } |
| } |
| |
| #[inline] |
| pub fn get(&self) -> bool { |
| self.failed.load(Ordering::Relaxed) |
| } |
| } |
| |
| pub struct Guard { |
| panicking: bool, |
| } |
| |
| /// A type of error which can be returned whenever a lock is acquired. |
| /// |
| /// Both [`SgxMutex`]es and [`SgxRwLock`]s are poisoned whenever a thread fails while the lock |
| /// is held. The precise semantics for when a lock is poisoned is documented on |
| /// each lock, but once a lock is poisoned then all future acquisitions will |
| /// return this error. |
| pub struct PoisonError<T> { |
| guard: T, |
| } |
| |
| /// An enumeration of possible errors which can occur while calling the |
| /// [`try_lock`] method. |
| pub enum TryLockError<T> { |
| /// The lock could not be acquired because another thread failed while holding |
| /// the lock. |
| Poisoned(PoisonError<T>), |
| /// The lock could not be acquired at this time because the operation would |
| /// otherwise block. |
| WouldBlock, |
| } |
| |
| /// A type alias for the result of a lock method which can be poisoned. |
| /// |
| /// The [`Ok`] variant of this result indicates that the primitive was not |
| /// poisoned, and the `Guard` is contained within. The [`Err`] variant indicates |
| /// that the primitive was poisoned. Note that the [`Err`] variant *also* carries |
| /// the associated guard, and it can be acquired through the [`into_inner`] |
| /// method. |
| pub type LockResult<Guard> = Result<Guard, PoisonError<Guard>>; |
| |
| /// A type alias for the result of a nonblocking locking method. |
| /// |
| /// For more information, see [`LockResult`]. A `TryLockResult` doesn't |
| /// necessarily hold the associated guard in the [`Err`] type as the lock may not |
| /// have been acquired for other reasons. |
| pub type TryLockResult<Guard> = Result<Guard, TryLockError<Guard>>; |
| |
| impl<T> fmt::Debug for PoisonError<T> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| "PoisonError { inner: .. }".fmt(f) |
| } |
| } |
| |
| impl<T> fmt::Display for PoisonError<T> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| "poisoned lock: another task failed inside".fmt(f) |
| } |
| } |
| |
| impl<T> PoisonError<T> { |
| |
| /// Creates a `PoisonError`. |
| /// |
| /// This is generally created by methods like [`SgxMutex::lock`] or [`SgxRwLock::read`]. |
| /// |
| pub fn new(guard: T) -> PoisonError<T> { |
| PoisonError { guard: guard } |
| } |
| |
| /// Consumes this error indicating that a lock is poisoned, returning the |
| /// underlying guard to allow access regardless. |
| pub fn into_inner(self) -> T { self.guard } |
| |
| /// Reaches into this error indicating that a lock is poisoned, returning a |
| /// reference to the underlying guard to allow access regardless. |
| pub fn get_ref(&self) -> &T { &self.guard } |
| |
| /// Reaches into this error indicating that a lock is poisoned, returning a |
| /// mutable reference to the underlying guard to allow access regardless. |
| pub fn get_mut(&mut self) -> &mut T { &mut self.guard } |
| } |
| |
| impl<T> convert::From<PoisonError<T>> for TryLockError<T> { |
| fn from(err: PoisonError<T>) -> TryLockError<T> { |
| TryLockError::Poisoned(err) |
| } |
| } |
| |
| impl<T> fmt::Debug for TryLockError<T> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| match *self { |
| TryLockError::Poisoned(..) => "Poisoned(..)".fmt(f), |
| TryLockError::WouldBlock => "WouldBlock".fmt(f) |
| } |
| } |
| } |
| |
| impl<T> fmt::Display for TryLockError<T> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| match *self { |
| TryLockError::Poisoned(..) => "poisoned lock: another task failed inside", |
| TryLockError::WouldBlock => "try_lock failed because the operation would block" |
| }.fmt(f) |
| } |
| } |
| |
| pub fn map_result<T, U, F>(result: LockResult<T>, f: F) |
| -> LockResult<U> |
| where F: FnOnce(T) -> U { |
| match result { |
| Ok(t) => Ok(f(t)), |
| Err(PoisonError { guard }) => Err(PoisonError::new(f(guard))) |
| } |
| } |