Implement dummy Mutex, Condvar and RwLock

Author: devrandom

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"

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;

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<Signer: Sign> {
 
 	#[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<Signer: Sign> Channel<Signer> {
 			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<Signer: Sign> Channel<Signer> {
 			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<Signer>
 			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,
 

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());

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<Guard> = Result<Guard, ()>;
+
+pub struct Condvar {}
+
+impl Condvar {
+	pub fn new() -> Condvar {
+		Condvar { }
+	}
+
+	pub fn wait<'a, T>(&'a self, guard: MutexGuard<'a, T>) -> LockResult<MutexGuard<'a, T>> {
+		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<T: ?Sized> {
+	inner: RefCell<T>
+}
+
+#[must_use = "if unused the Mutex will immediately unlock"]
+pub struct MutexGuard<'a, T: ?Sized + 'a> {
+	lock: RefMut<'a, T>,
+}
+
+impl<T: ?Sized> Deref for MutexGuard<'_, T> {
+	type Target = T;
+
+	fn deref(&self) -> &T {
+		&self.lock.deref()
+	}
+}
+
+impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
+	fn deref_mut(&mut self) -> &mut T {
+		self.lock.deref_mut()
+	}
+}
+
+impl<T> Mutex<T> {
+	pub fn new(inner: T) -> Mutex<T> {
+		Mutex { inner: RefCell::new(inner) }
+	}
+
+	pub fn lock<'a>(&'a self) -> LockResult<MutexGuard<'a, T>> {
+		Ok(MutexGuard { lock: self.inner.borrow_mut() })
+	}
+
+	pub fn try_lock<'a>(&'a self) -> LockResult<MutexGuard<'a, T>> {
+		Ok(MutexGuard { lock: self.inner.borrow_mut() })
+	}
+}
+
+pub struct RwLock<T: ?Sized> {
+	inner: RefCell<T>
+}
+
+pub struct RwLockReadGuard<'a, T: ?Sized + 'a> {
+	lock: Ref<'a, T>,
+}
+
+pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> {
+	lock: RefMut<'a, T>,
+}
+
+impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
+	type Target = T;
+
+	fn deref(&self) -> &T {
+		&self.lock.deref()
+	}
+}
+
+impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
+	type Target = T;
+
+	fn deref(&self) -> &T {
+		&self.lock.deref()
+	}
+}
+
+impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
+	fn deref_mut(&mut self) -> &mut T {
+		self.lock.deref_mut()
+	}
+}
+
+impl<T> RwLock<T> {
+	pub fn new(inner: T) -> RwLock<T> {
+		RwLock { inner: RefCell::new(inner) }
+	}
+
+	pub fn read<'a>(&'a self) -> LockResult<RwLockReadGuard<'a, T>> {
+		Ok(RwLockReadGuard { lock: self.inner.borrow() })
+	}
+
+	pub fn write<'a>(&'a self) -> LockResult<RwLockWriteGuard<'a, T>> {
+		Ok(RwLockWriteGuard { lock: self.inner.borrow_mut() })
+	}
+
+	pub fn try_write<'a>(&'a self) -> LockResult<RwLockWriteGuard<'a, T>> {
+		// There is no try, grasshopper - only used for tests and expected to fail
+		Err(())
+	}
+}