From: Devrandom Date: Mon, 19 Jul 2021 14:13:00 +0000 (+0200) Subject: Implement dummy Mutex, Condvar and RwLock X-Git-Tag: v0.0.100~24^2~1 X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=rust-lightning;a=commitdiff_plain;h=a0a3a6b204395a63647a7914f35077b117315b1d Implement dummy Mutex, Condvar and RwLock --- diff --git a/lightning/Cargo.toml b/lightning/Cargo.toml index 7172ee07..32c0d0af 100644 --- a/lightning/Cargo.toml +++ b/lightning/Cargo.toml @@ -25,7 +25,11 @@ max_level_debug = [] # This is unsafe to use in production because it may result in the counterparty publishing taking our funds. unsafe_revoked_tx_signing = [] unstable = [] + no_std = ["hashbrown"] +std = [] + +default = ["std"] [dependencies] bitcoin = "0.26" diff --git a/lightning/src/lib.rs b/lightning/src/lib.rs index 10880635..14445710 100644 --- a/lightning/src/lib.rs +++ b/lightning/src/lib.rs @@ -54,6 +54,10 @@ mod prelude { pub use self::hashbrown::{HashMap, HashSet, hash_map}; } +#[cfg(feature = "std")] mod sync { pub use ::std::sync::{Arc, Mutex, Condvar, MutexGuard, RwLock, RwLockReadGuard}; } + +#[cfg(not(feature = "std"))] +mod sync; diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs index 5065b9ae..0d5ffb03 100644 --- a/lightning/src/ln/channel.rs +++ b/lightning/src/ln/channel.rs @@ -44,9 +44,8 @@ use util::scid_utils::scid_from_parts; use prelude::*; use core::{cmp,mem,fmt}; use core::ops::Deref; -#[cfg(any(test, feature = "fuzztarget"))] +#[cfg(any(test, feature = "fuzztarget", debug_assertions))] use sync::Mutex; -use sync; use bitcoin::hashes::hex::ToHex; use bitcoin::blockdata::opcodes::all::OP_PUSHBYTES_0; @@ -375,10 +374,10 @@ pub(super) struct Channel { #[cfg(debug_assertions)] /// Max to_local and to_remote outputs in a locally-generated commitment transaction - holder_max_commitment_tx_output: sync::Mutex<(u64, u64)>, + holder_max_commitment_tx_output: Mutex<(u64, u64)>, #[cfg(debug_assertions)] /// Max to_local and to_remote outputs in a remote-generated commitment transaction - counterparty_max_commitment_tx_output: sync::Mutex<(u64, u64)>, + counterparty_max_commitment_tx_output: Mutex<(u64, u64)>, last_sent_closing_fee: Option<(u32, u64, Signature)>, // (feerate, fee, holder_sig) @@ -596,9 +595,9 @@ impl Channel { monitor_pending_failures: Vec::new(), #[cfg(debug_assertions)] - holder_max_commitment_tx_output: sync::Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)), + holder_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)), #[cfg(debug_assertions)] - counterparty_max_commitment_tx_output: sync::Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)), + counterparty_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)), last_sent_closing_fee: None, @@ -837,9 +836,9 @@ impl Channel { monitor_pending_failures: Vec::new(), #[cfg(debug_assertions)] - holder_max_commitment_tx_output: sync::Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)), + holder_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)), #[cfg(debug_assertions)] - counterparty_max_commitment_tx_output: sync::Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)), + counterparty_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)), last_sent_closing_fee: None, @@ -4944,9 +4943,9 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<&'a K> for Channel feerate_per_kw, #[cfg(debug_assertions)] - holder_max_commitment_tx_output: sync::Mutex::new((0, 0)), + holder_max_commitment_tx_output: Mutex::new((0, 0)), #[cfg(debug_assertions)] - counterparty_max_commitment_tx_output: sync::Mutex::new((0, 0)), + counterparty_max_commitment_tx_output: Mutex::new((0, 0)), last_sent_closing_fee, diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs index ad9ce5df..22a7982b 100644 --- a/lightning/src/ln/channelmanager.rs +++ b/lightning/src/ln/channelmanager.rs @@ -4959,6 +4959,7 @@ mod tests { use ln::features::InitFeatures; use ln::msgs::ChannelMessageHandler; + #[cfg(feature = "std")] #[test] fn test_wait_timeout() { let persistence_notifier = Arc::new(PersistenceNotifier::new()); diff --git a/lightning/src/sync.rs b/lightning/src/sync.rs new file mode 100644 index 00000000..bde54703 --- /dev/null +++ b/lightning/src/sync.rs @@ -0,0 +1,115 @@ +pub use ::alloc::sync::Arc; +use core::ops::{Deref, DerefMut}; +use core::time::Duration; +use core::cell::{RefCell, Ref, RefMut}; + +pub type LockResult = Result; + +pub struct Condvar {} + +impl Condvar { + pub fn new() -> Condvar { + Condvar { } + } + + pub fn wait<'a, T>(&'a self, guard: MutexGuard<'a, T>) -> LockResult> { + Ok(guard) + } + + #[allow(unused)] + pub fn wait_timeout<'a, T>(&'a self, guard: MutexGuard<'a, T>, _dur: Duration) -> LockResult<(MutexGuard<'a, T>, ())> { + Ok((guard, ())) + } + + pub fn notify_all(&self) {} +} + +pub struct Mutex { + inner: RefCell +} + +#[must_use = "if unused the Mutex will immediately unlock"] +pub struct MutexGuard<'a, T: ?Sized + 'a> { + lock: RefMut<'a, T>, +} + +impl Deref for MutexGuard<'_, T> { + type Target = T; + + fn deref(&self) -> &T { + &self.lock.deref() + } +} + +impl DerefMut for MutexGuard<'_, T> { + fn deref_mut(&mut self) -> &mut T { + self.lock.deref_mut() + } +} + +impl Mutex { + pub fn new(inner: T) -> Mutex { + Mutex { inner: RefCell::new(inner) } + } + + pub fn lock<'a>(&'a self) -> LockResult> { + Ok(MutexGuard { lock: self.inner.borrow_mut() }) + } + + pub fn try_lock<'a>(&'a self) -> LockResult> { + Ok(MutexGuard { lock: self.inner.borrow_mut() }) + } +} + +pub struct RwLock { + inner: RefCell +} + +pub struct RwLockReadGuard<'a, T: ?Sized + 'a> { + lock: Ref<'a, T>, +} + +pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> { + lock: RefMut<'a, T>, +} + +impl Deref for RwLockReadGuard<'_, T> { + type Target = T; + + fn deref(&self) -> &T { + &self.lock.deref() + } +} + +impl Deref for RwLockWriteGuard<'_, T> { + type Target = T; + + fn deref(&self) -> &T { + &self.lock.deref() + } +} + +impl DerefMut for RwLockWriteGuard<'_, T> { + fn deref_mut(&mut self) -> &mut T { + self.lock.deref_mut() + } +} + +impl RwLock { + pub fn new(inner: T) -> RwLock { + RwLock { inner: RefCell::new(inner) } + } + + pub fn read<'a>(&'a self) -> LockResult> { + Ok(RwLockReadGuard { lock: self.inner.borrow() }) + } + + pub fn write<'a>(&'a self) -> LockResult> { + Ok(RwLockWriteGuard { lock: self.inner.borrow_mut() }) + } + + pub fn try_write<'a>(&'a self) -> LockResult> { + // There is no try, grasshopper - only used for tests and expected to fail + Err(()) + } +}