You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@asyncband.apache.org by ti...@apache.org on 2026/09/04 07:34:45 UTC
(asyncband) 01/01: fix: clarify mutex third-party licensing
This is an automated email from the ASF dual-hosted git repository.
tisonkun pushed a commit to branch codex/clarify-mutex-rwlock-licensing
in repository https://gitbox.apache.org/repos/asf/asyncband.git
commit fc195179c42af8efacd57fdafdd29c57115a4e80
Author: tison <wa...@gmail.com>
AuthorDate: Fri Sep 4 15:34:11 2026 +0800
fix: clarify mutex third-party licensing
---
LICENSE | 23 +++-
asyncband/src/mutex/mod.rs | 276 ++++++++++++++++--------------------------
asyncband/src/pool/bounded.rs | 2 +-
licenserc.toml | 1 -
4 files changed, 126 insertions(+), 176 deletions(-)
diff --git a/LICENSE b/LICENSE
index 2229678..8a2b25c 100644
--- a/LICENSE
+++ b/LICENSE
@@ -217,6 +217,20 @@ Portions of asyncband/src/mutex/mod.rs are derived from Tokio 1.41.0:
https://github.com/tokio-rs/tokio/blob/01e04daaa162ce6122bb894fdda0b6803dd32093/tokio/src/sync/mutex.rs
+Asyncband's Mutex core predates the incorporation of Tokio's owned and mapped
+guard APIs. It is built on Asyncband's own fair semaphore, has no closed state
+or acquisition error, returns Option from nonblocking acquisition, and provides
+a single const constructor without runtime-specific tracing or blocking entry
+points. Asyncband substantially changed the incorporated guard implementation.
+Projected guards use NonNull pointers and explicit invariance, borrowed and
+owned projected guards can be mapped repeatedly, and guard destruction releases
+permits through Asyncband's semaphore lifecycle.
+
+The standard ASF source header on asyncband/src/mutex/mod.rs applies to the
+independent Mutex core and the substantial modifications contributed to Apache
+Asyncband. It does not replace the Tokio copyright notice or MIT License
+applicable to the incorporated portions.
+
Portions of the following files are derived from Tokio 1.42.0. Each local path
is followed by its upstream source path or paths:
@@ -245,8 +259,13 @@ The exact Tokio 1.42.0 revision is:
https://github.com/tokio-rs/tokio/tree/bb9d57017e100985f86d8ca41ac105ee9140423e/tokio/src/sync
-Asyncband's RwLock accepts any NonZeroUsize as max_readers instead of Tokio's
-restricted range.
+Asyncband adapted RwLock to its own semaphore and guard model. Acquisition has
+no semaphore-close error, nonblocking methods return Option, and max_readers is
+any NonZeroUsize instead of Tokio's restricted range. Mapped read guards use
+separate borrowed and owned types rather than changing a type parameter on the
+original read guard. All mapped guards use filter_map naming, and mutable mapped
+guards carry explicit invariance. The local guard types release and downgrade
+permits through Asyncband's usize-based semaphore implementation.
Portions of the following files originated from Tokio 1.47.0's OnceCell. Each
local path is followed by its upstream source path:
diff --git a/asyncband/src/mutex/mod.rs b/asyncband/src/mutex/mod.rs
index b0986ad..bd5d193 100644
--- a/asyncband/src/mutex/mod.rs
+++ b/asyncband/src/mutex/mod.rs
@@ -1,19 +1,39 @@
-// This file contains code derived from Tokio 1.41.0.
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Portions of the owned and mapped guard APIs originated from Tokio 1.41.0's Mutex implementation.
// Copyright (c) Tokio Contributors
-// The derived code remains licensed under the MIT License.
-// The incorporated code has been modified for use in Apache Asyncband.
+// The Tokio-derived portions remain licensed under the MIT License.
+// Asyncband independently built the mutex on its own semaphore and substantially changed the
+// incorporated guard implementation: the try-lock error type and semaphore closure are absent,
+// projected guards use NonNull pointers with explicit invariance, and projected guards can be
+// mapped repeatedly in both borrowed and owned forms.
// Upstream source:
// https://github.com/tokio-rs/tokio/blob/01e04daaa162ce6122bb894fdda0b6803dd32093/tokio/src/sync/mutex.rs
-//! An async mutex for protecting shared data.
+//! Mutual exclusion that yields the current task while waiting.
//!
-//! Unlike a standard mutex, this implementation is designed to work with async/await,
-//! ensuring tasks yield properly when the lock is contended. This makes it suitable
-//! for protecting shared resources in async code.
+//! A successful lock operation returns a guard that provides exclusive access to the protected
+//! value and releases the lock when dropped. The guard may be held across `.await` points. When
+//! that is unnecessary, a synchronous mutex is usually cheaper.
//!
-//! This mutex will block tasks waiting for the lock to become available. The
-//! mutex can be created via [`new`] and the protected data can be accessed
-//! via the async [`lock`] method.
+//! Waiters are served through Asyncband's fair semaphore queue. Cancelling a pending lock
+//! operation removes that waiter from the queue; a later attempt joins at the back. A panic while
+//! holding a guard releases the lock without poisoning it.
//!
//! # Examples
//!
@@ -24,29 +44,24 @@
//!
//! use asyncband::mutex::Mutex;
//!
-//! let mutex = Arc::new(Mutex::new(0));
-//! let mut handles = vec![];
+//! let counter = Arc::new(Mutex::new(0));
+//! let mut tasks = Vec::new();
//!
-//! for i in 0..3 {
-//! let mutex = mutex.clone();
-//! handles.push(tokio::spawn(async move {
-//! let mut lock = mutex.lock().await;
-//! *lock += i;
+//! for _ in 0..3 {
+//! let counter = counter.clone();
+//! tasks.push(tokio::spawn(async move {
+//! *counter.lock().await += 1;
//! }));
//! }
//!
-//! for handle in handles {
-//! handle.await.unwrap();
+//! for task in tasks {
+//! task.await.unwrap();
//! }
//!
-//! let final_value = mutex.lock().await;
-//! assert_eq!(*final_value, 3); // 0 + 1 + 2
+//! assert_eq!(*counter.lock().await, 3);
//!
-//! # }
+//! # }
//! ```
-//!
-//! [`new`]: Mutex::new
-//! [`lock`]: Mutex::lock
use std::cell::UnsafeCell;
use std::fmt;
@@ -59,7 +74,7 @@ use std::sync::Arc;
use crate::internal::semaphore;
-/// An async mutex for protecting shared data.
+/// An asynchronous mutex backed by Asyncband's fair semaphore.
///
/// See the [module level documentation](self) for more.
pub struct Mutex<T: ?Sized> {
@@ -96,7 +111,7 @@ impl<T: ?Sized + fmt::Debug> fmt::Debug for Mutex<T> {
}
impl<T> Mutex<T> {
- /// Creates a new mutex in an unlocked state ready for use.
+ /// Wraps `t` in an unlocked mutex.
///
/// # Examples
///
@@ -111,7 +126,7 @@ impl<T> Mutex<T> {
Self { s, c }
}
- /// Consumes the mutex, returning the underlying data.
+ /// Unwraps the protected value.
///
/// # Examples
///
@@ -128,17 +143,12 @@ impl<T> Mutex<T> {
}
impl<T: ?Sized> Mutex<T> {
- /// Locks this mutex, causing the current task to yield until the lock has been acquired. When
- /// the lock has been acquired, function returns a [`MutexGuard`].
- ///
- /// This method is async and will yield the current task if the mutex is currently held by
- /// another task. When the mutex becomes available, the task will be woken up and given the
- /// lock.
+ /// Waits for exclusive access and returns a borrowed guard.
///
/// # Cancel safety
///
- /// This method uses a queue to fairly distribute locks in the order they were requested.
- /// Cancelling a call to `lock` makes you lose your place in the queue.
+ /// Waiters enter the mutex's fair queue. Dropping this future before it completes removes the
+ /// waiter, so retrying starts again at the back of the queue.
///
/// # Examples
///
@@ -158,8 +168,7 @@ impl<T: ?Sized> Mutex<T> {
MutexGuard { lock: self }
}
- /// Attempts to acquire the lock, and returns `None` if the lock is currently held somewhere
- /// else.
+ /// Acquires the mutex without waiting, or returns `None` when it is already held.
///
/// # Examples
///
@@ -180,22 +189,15 @@ impl<T: ?Sized> Mutex<T> {
}
}
- /// Locks this mutex, causing the current task to yield until the lock has been acquired. When
- /// the lock has been acquired, this returns an [`OwnedMutexGuard`].
+ /// Waits for exclusive access and returns a guard that owns this [`Arc`].
///
- /// This method is async and will yield the current task if the mutex is currently held by
- /// another task. When the mutex becomes available, the task will be woken up and given the
- /// lock.
- ///
- /// This method is identical to [`Mutex::lock`], except that the returned guard references the
- /// `Mutex` with an [`Arc`] rather than by borrowing it. Therefore, the `Mutex` must be
- /// wrapped in an `Arc` to call this method, and the guard will live for the `'static` lifetime,
- /// as it keeps the `Mutex` alive by holding an `Arc`.
+ /// The owned guard keeps the mutex alive instead of borrowing it, which allows the guard to be
+ /// moved wherever a `'static` value is required.
///
/// # Cancel safety
///
- /// This method uses a queue to fairly distribute locks in the order they were requested.
- /// Cancelling a call to `lock_owned` makes you lose your place in the queue.
+ /// Waiters enter the mutex's fair queue. Dropping this future before it completes removes the
+ /// waiter, so retrying starts again at the back of the queue.
///
/// # Examples
///
@@ -217,13 +219,9 @@ impl<T: ?Sized> Mutex<T> {
OwnedMutexGuard { lock: self }
}
- /// Attempts to acquire the lock, and returns `None` if the lock is currently held somewhere
- /// else.
+ /// Acquires the mutex without waiting and returns a guard that owns this [`Arc`].
///
- /// This method is identical to [`Mutex::try_lock`], except that the returned guard references
- /// the `Mutex` with an [`Arc`] rather than by borrowing it. Therefore, the `Mutex` must be
- /// wrapped in an `Arc` to call this method, and the guard will live for the `'static` lifetime,
- /// as it keeps the `Mutex` alive by holding an `Arc`.
+ /// Returns `None` when another guard currently holds the mutex.
///
/// # Examples
///
@@ -246,10 +244,10 @@ impl<T: ?Sized> Mutex<T> {
}
}
- /// Returns a mutable reference to the underlying data.
+ /// Borrows the protected value mutably without locking.
///
- /// Since this call borrows the `Mutex` mutably, no actual locking needs to take place: the
- /// mutable borrow statically guarantees no locks exist.
+ /// The exclusive borrow of the mutex already prevents any guard from existing at the same
+ /// time.
///
/// # Examples
///
@@ -265,14 +263,10 @@ impl<T: ?Sized> Mutex<T> {
}
}
-/// RAII structure used to release the exclusive lock on a mutex when dropped.
-///
-/// This structure is created by the [`lock`] and [`try_lock`] methods on [`Mutex`].
+/// A borrowed proof of exclusive access to a [`Mutex`].
///
-/// [`lock`]: Mutex::lock
-/// [`try_lock`]: Mutex::try_lock
-///
-/// See the [module level documentation](self) for more.
+/// [`Mutex::lock`] and [`Mutex::try_lock`] create this guard. It dereferences to the protected
+/// value and returns its single semaphore permit when dropped.
///
/// # Variance
///
@@ -290,7 +284,7 @@ impl<T: ?Sized> Mutex<T> {
/// guard
/// }
/// ```
-#[must_use = "if unused the Mutex will immediately unlock"]
+#[must_use = "dropping the guard releases the mutex immediately"]
pub struct MutexGuard<'a, T: ?Sized> {
lock: &'a Mutex<T>,
}
@@ -334,12 +328,10 @@ impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
}
impl<'a, T: ?Sized> MutexGuard<'a, T> {
- /// Makes a new [`MappedMutexGuard`] for a component of the locked data.
+ /// Projects this guard to a mutable component of the protected value.
///
- /// This operation cannot fail as the `MutexGuard` passed in already locked the mutex.
- ///
- /// This is an associated function that needs to be used as `MutexGuard::map(...)`. A method
- /// would interfere with methods of the same name on the contents of the locked data.
+ /// The returned guard owns the same lock permit and releases it when dropped. Call this as
+ /// `MutexGuard::map(...)` so a method named `map` on `T` remains accessible through deref.
///
/// # Examples
///
@@ -391,14 +383,10 @@ impl<'a, T: ?Sized> MutexGuard<'a, T> {
}
}
- /// Attempts to make a new [`MappedMutexGuard`] for a component of the locked data. The
- /// original guard is returned if the closure returns `None`.
- ///
- /// This operation cannot fail as the `MutexGuard` passed in already locked the mutex.
+ /// Attempts to project this guard to a mutable component of the protected value.
///
- /// This is an associated function that needs to be used as `MutexGuard::filter_map(...)`.
- ///
- /// A method would interfere with methods of the same name on the contents of the locked data.
+ /// The original guard is returned when `f` returns `None`. Call this as
+ /// `MutexGuard::filter_map(...)` so a method with the same name on `T` remains accessible.
///
/// # Examples
///
@@ -456,20 +444,11 @@ impl<'a, T: ?Sized> MutexGuard<'a, T> {
}
}
-/// An owned handle to a held `Mutex`.
-///
-/// This guard is only available from a [`Mutex`] that is wrapped in an [`Arc`]. It is identical to
-/// [`MutexGuard`], except that rather than borrowing the `Mutex`, it clones the `Arc`, incrementing
-/// the reference count. This means that unlike `MutexGuard`, it will have the `'static` lifetime.
-///
-/// As long as you have this guard, you have exclusive access to the underlying `T`. The guard
-/// internally keeps a reference-counted pointer to the original `Mutex`, so even if the lock goes
-/// away, the guard remains valid.
-///
-/// The lock is automatically released whenever the guard is dropped, at which point `lock` will
-/// succeed yet again.
+/// A proof of exclusive access that owns an [`Arc`] containing its [`Mutex`].
///
-/// See the [module level documentation](self) for more.
+/// [`Mutex::lock_owned`] and [`Mutex::try_lock_owned`] create this guard. Owning the `Arc` lets the
+/// guard outlive the reference used to acquire it; dropping the guard releases the lock permit and
+/// its share of the `Arc`.
///
/// # Variance
///
@@ -487,7 +466,7 @@ impl<'a, T: ?Sized> MutexGuard<'a, T> {
/// guard
/// }
/// ```
-#[must_use = "if unused the Mutex will immediately unlock"]
+#[must_use = "dropping the guard releases the mutex immediately"]
pub struct OwnedMutexGuard<T: ?Sized> {
lock: Arc<Mutex<T>>,
}
@@ -531,12 +510,10 @@ impl<T: ?Sized> DerefMut for OwnedMutexGuard<T> {
}
impl<T: ?Sized> OwnedMutexGuard<T> {
- /// Makes a new [`OwnedMappedMutexGuard`] for a component of the locked data.
- ///
- /// This operation cannot fail as the `OwnedMutexGuard` passed in already locked the mutex.
+ /// Projects this guard to a mutable component of the protected value.
///
- /// This is an associated function that needs to be used as `OwnedMutexGuard::map(...)`. A
- /// method would interfere with methods of the same name on the contents of the locked data.
+ /// The returned guard retains the same `Arc` and lock permit. Call this as
+ /// `OwnedMutexGuard::map(...)` so a method named `map` on `T` remains accessible through deref.
///
/// # Examples
///
@@ -584,14 +561,10 @@ impl<T: ?Sized> OwnedMutexGuard<T> {
}
}
- /// Attempts to make a new [`OwnedMappedMutexGuard`] for a component of the locked data. The
- /// original guard is returned if the closure returns `None`.
- ///
- /// This operation cannot fail as the `OwnedMutexGuard` passed in already locked the mutex.
- ///
- /// This is an associated function that needs to be used as `OwnedMutexGuard::filter_map(...)`.
+ /// Attempts to project this guard to a mutable component of the protected value.
///
- /// A method would interfere with methods of the same name on the contents of the locked data.
+ /// The original guard is returned when `f` returns `None`. Call this as
+ /// `OwnedMutexGuard::filter_map(...)` so a method with the same name on `T` remains accessible.
///
/// # Examples
///
@@ -638,25 +611,11 @@ impl<T: ?Sized> OwnedMutexGuard<T> {
}
}
-/// RAII structure used to release the exclusive lock on a mutex when dropped, for a mapped
-/// component of the locked data.
+/// A borrowed mutex guard projected to a mutable component of the protected value.
///
-/// This structure is created by the [`map`] and [`filter_map`] methods on [`MutexGuard`]. It allows
-/// you to hold a lock on a subfield of the protected data, enabling more fine-grained access
-/// control while maintaining the same locking semantics.
-///
-/// As long as you have this guard, you have exclusive access to the underlying `T`. The guard
-/// internally keeps a reference to the original mutex's semaphore, so the original lock is
-/// maintained until this guard is dropped.
-///
-/// `MappedMutexGuard` implements [`Send`] and [`Sync`]
-/// when the underlying data type supports these traits, allowing it to be used across task
-/// boundaries and shared between threads safely.
-///
-/// See the [module level documentation](self) for more.
-///
-/// [`map`]: MutexGuard::map
-/// [`filter_map`]: MutexGuard::filter_map
+/// [`MutexGuard::map`] and [`MutexGuard::filter_map`] create this guard. It retains the original
+/// semaphore permit while exposing only the projected component, and releases that permit when
+/// dropped.
///
/// # Examples
///
@@ -711,7 +670,7 @@ impl<T: ?Sized> OwnedMutexGuard<T> {
/// guard
/// }
/// ```
-#[must_use = "if unused the Mutex will immediately unlock"]
+#[must_use = "dropping the guard releases the mutex immediately"]
pub struct MappedMutexGuard<'a, T: ?Sized> {
/// Non-null pointer to the mapped data
d: NonNull<T>,
@@ -766,12 +725,11 @@ impl<T: ?Sized> DerefMut for MappedMutexGuard<'_, T> {
}
impl<'a, T: ?Sized> MappedMutexGuard<'a, T> {
- /// Makes a new [`MappedMutexGuard`] for a component of the locked data.
- ///
- /// This operation cannot fail as the `MappedMutexGuard` passed in already locked the mutex.
+ /// Projects an already mapped guard to a deeper mutable component.
///
- /// This is an associated function that needs to be used as `MappedMutexGuard::map(...)`. A
- /// method would interfere with methods of the same name on the contents of the locked data.
+ /// The returned guard retains the same lock permit. Call this as
+ /// `MappedMutexGuard::map(...)` so a method named `map` on `T` remains accessible through
+ /// deref.
///
/// # Examples
///
@@ -828,14 +786,11 @@ impl<'a, T: ?Sized> MappedMutexGuard<'a, T> {
}
}
- /// Attempts to make a new [`MappedMutexGuard`] for a component of the locked data. The
- /// original guard is returned if the closure returns `None`.
+ /// Attempts to project an already mapped guard to a deeper mutable component.
///
- /// This operation cannot fail as the `MappedMutexGuard` passed in already locked the mutex.
- ///
- /// This is an associated function that needs to be used as `MappedMutexGuard::filter_map(...)`.
- /// A method would interfere with methods of the same name on the contents of the locked
- /// data.
+ /// The original mapped guard is returned when `f` returns `None`. Call this as
+ /// `MappedMutexGuard::filter_map(...)` so a method with the same name on `T` remains
+ /// accessible.
///
/// # Examples
///
@@ -890,28 +845,11 @@ impl<'a, T: ?Sized> MappedMutexGuard<'a, T> {
}
}
-/// An owned handle to a held `Mutex` for a mapped component of the locked data.
-///
-/// This guard is only available from a [`Mutex`] that is wrapped in an [`Arc`]. It is similar to
-/// [`MappedMutexGuard`], except that rather than borrowing the `Mutex`, it clones the `Arc`,
-/// incrementing the reference count. This means that unlike `MappedMutexGuard`, it will have
-/// the `'static` lifetime.
+/// An owned mutex guard projected to a mutable component of the protected value.
///
-/// This structure is created by the [`map`] and [`filter_map`] methods on [`OwnedMutexGuard`].
-/// It allows you to hold a lock on a subfield of the protected data, enabling more fine-grained
-/// access control while maintaining the same locking semantics.
-///
-/// As long as you have this guard, you have exclusive access to the underlying `U`. The guard
-/// internally keeps a reference-counted pointer to the original `Mutex`, so even if the lock goes
-/// away, the guard remains valid.
-///
-/// The lock is automatically released whenever the guard is dropped, at which point `lock` will
-/// succeed yet again.
-///
-/// See the [module level documentation](self) for more.
-///
-/// [`map`]: OwnedMutexGuard::map
-/// [`filter_map`]: OwnedMutexGuard::filter_map
+/// [`OwnedMutexGuard::map`] and [`OwnedMutexGuard::filter_map`] create this guard. It keeps the
+/// original mutex alive through an `Arc`, retains its lock permit, and exposes only the projected
+/// component until dropped.
///
/// # Examples
///
@@ -952,7 +890,7 @@ impl<'a, T: ?Sized> MappedMutexGuard<'a, T> {
/// guard
/// }
/// ```
-#[must_use = "if unused the Mutex will immediately unlock"]
+#[must_use = "dropping the guard releases the mutex immediately"]
pub struct OwnedMappedMutexGuard<T: ?Sized, U: ?Sized> {
// This Arc acts as an ownership certificate, ensuring the Mutex remains valid
// and the lock is not released
@@ -1013,13 +951,11 @@ impl<T: ?Sized, U: ?Sized> DerefMut for OwnedMappedMutexGuard<T, U> {
}
impl<T: ?Sized, U: ?Sized> OwnedMappedMutexGuard<T, U> {
- /// Makes a new [`OwnedMappedMutexGuard`] for a component of the locked data.
- ///
- /// This operation cannot fail as the `OwnedMappedMutexGuard` passed in already locked the
- /// mutex.
+ /// Projects an owned mapped guard to a deeper mutable component.
///
- /// This is an associated function that needs to be used as `OwnedMappedMutexGuard::map(...)`. A
- /// method would interfere with methods of the same name on the contents of the locked data.
+ /// The returned guard retains the same `Arc` and lock permit. Call this as
+ /// `OwnedMappedMutexGuard::map(...)` so a method named `map` on `U` remains accessible through
+ /// deref.
///
/// # Examples
///
@@ -1073,15 +1009,11 @@ impl<T: ?Sized, U: ?Sized> OwnedMappedMutexGuard<T, U> {
}
}
- /// Attempts to make a new [`OwnedMappedMutexGuard`] for a component of the locked data. The
- /// original guard is returned if the closure returns `None`.
- ///
- /// This operation cannot fail as the `OwnedMappedMutexGuard` passed in already locked the
- /// mutex.
+ /// Attempts to project an owned mapped guard to a deeper mutable component.
///
- /// This is an associated function that needs to be used as
- /// `OwnedMappedMutexGuard::filter_map(...)`. A method would interfere with methods of the same
- /// name on the contents of the locked data.
+ /// The original mapped guard is returned when `f` returns `None`. Call this as
+ /// `OwnedMappedMutexGuard::filter_map(...)` so a method with the same name on `U` remains
+ /// accessible through deref.
///
/// # Examples
///
diff --git a/asyncband/src/pool/bounded.rs b/asyncband/src/pool/bounded.rs
index 6c3009a..4ac17c6 100644
--- a/asyncband/src/pool/bounded.rs
+++ b/asyncband/src/pool/bounded.rs
@@ -207,7 +207,7 @@ impl<M: ManageObject> Pool<M> {
/// checked-out objects. Existing idle objects count toward the target, and the pool's
/// maximum size is never exceeded. Targets above the maximum size are treated as the maximum.
/// Concurrent calls and checkouts can change the observed idle count while this method is
- /// running, so the target is best effort rather than a postcondition.
+ /// running, so the target is the best effort rather than a postcondition.
///
/// Returns the number of objects created. If [`ManageObject::create`] fails, objects created by
/// this call before the failure remain in the pool and the error is returned.
diff --git a/licenserc.toml b/licenserc.toml
index f004664..eec57c5 100644
--- a/licenserc.toml
+++ b/licenserc.toml
@@ -24,7 +24,6 @@ builtin = "Apache-2.0-ASF"
excludes = [
"asyncband/src/blocking/executor.rs",
"asyncband/src/blocking/parker.rs",
- "asyncband/src/mutex/mod.rs",
"asyncband/src/pool/bounded.rs",
"asyncband/src/pool/common.rs",
"asyncband/src/pool/mod.rs",
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@asyncband.apache.org
For additional commands, e-mail: commits-help@asyncband.apache.org