Remove internal mutex

Author: simolus3

Cargo.lock

@@ -21,7 +21,6 @@ serde_json = { version = "1.0", default-features = false, features = ["alloc", "
 serde = { version = "1.0", default-features = false, features = ["alloc", "derive", "rc"] }
 streaming-iterator = { version = "0.1.9", default-features = false, features = ["alloc"] }
 const_format = "0.2.34"
-lock_api = { version = "0.4.12", default-features = false }
 futures-lite = { version = "2.6.0", default-features = false, features = ["alloc"] }
 rustc-hash = { version = "2.1", default-features = false }
 

crates/core/Cargo.toml

@@ -199,7 +199,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
 
     fn deserialize_newtype_struct<V>(
         self,
-        name: &'static str,
+        _name: &'static str,
         visitor: V,
     ) -> Result<V::Value, Self::Error>
     where

crates/core/src/bson/de.rs

@@ -11,7 +11,6 @@ use core::ffi::{c_char, c_int};
 
 use sqlite::ResultCode;
 use sqlite_nostd as sqlite;
-use util::SQLITE3_API;
 
 mod bson;
 mod checkpoint;
@@ -43,11 +42,6 @@ pub extern "C" fn sqlite3_powersync_init(
     api: *mut sqlite::api_routines,
 ) -> c_int {
     sqlite::EXTENSION_INIT2(api);
-    unsafe {
-        // SAFETY: This field is only assigned once, when the library is loaded.
-        SQLITE3_API = api
-    };
-
     let result = init_extension(db);
 
     return if let Err(code) = result {

crates/core/src/lib.rs

@@ -120,7 +120,7 @@ pub fn register(db: *mut sqlite::sqlite3) -> Result<(), ResultCode> {
         argv: *mut *mut sqlite::value,
     ) -> () {
         let result = (|| -> Result<(), SQLiteError> {
-            let controller = unsafe { ctx.user_data().cast::<SqlController>().as_ref() }
+            let controller = unsafe { ctx.user_data().cast::<SqlController>().as_mut() }
                 .ok_or_else(|| SQLiteError::from(ResultCode::INTERNAL))?;
 
             let args = sqlite::args!(argc, argv);

crates/core/src/sync/interface.rs

@@ -14,12 +14,7 @@ use alloc::{
 };
 use futures_lite::FutureExt;
 
-use crate::{
-    bson,
-    error::SQLiteError,
-    kv::client_id,
-    util::{sqlite3_mutex, Mutex},
-};
+use crate::{bson, error::SQLiteError, kv::client_id};
 use sqlite_nostd::{self as sqlite, ResultCode};
 
 use super::{
@@ -40,42 +35,35 @@ use super::{
 pub struct SyncClient {
     db: *mut sqlite::sqlite3,
     /// The current [ClientState] (essentially an optional [StreamingSyncIteration]).
-    ///
-    /// This is guarded behind a mutex so that we can mutate the state without forcing callers to
-    /// obtain a mutable reference to the [SyncClient] itself. It doesn't mean much in practice
-    /// because it's impossible to run two `powersync_control` calls on the same database connection
-    /// concurrently.
-    state: Mutex<ClientState>,
+    state: ClientState,
 }
 
 impl SyncClient {
     pub fn new(db: *mut sqlite::sqlite3) -> Self {
         Self {
             db,
-            state: sqlite3_mutex(ClientState::Idle),
+            state: ClientState::Idle,
         }
     }
 
     pub fn push_event<'a>(
-        &self,
+        &mut self,
         event: SyncControlRequest<'a>,
     ) -> Result<Vec<Instruction>, SQLiteError> {
-        let mut state = self.state.lock();
-
         match event {
             SyncControlRequest::StartSyncStream { parameters } => {
-                state.tear_down()?;
+                self.state.tear_down()?;
 
                 let mut handle = SyncIterationHandle::new(self.db, parameters)?;
                 let instructions = handle.initialize()?;
-                *state = ClientState::IterationActive(handle);
+                self.state = ClientState::IterationActive(handle);
 
                 Ok(instructions)
             }
             SyncControlRequest::SyncEvent(sync_event) => {
                 let mut active = ActiveEvent::new(sync_event);
 
-                let ClientState::IterationActive(handle) = &mut *state else {
+                let ClientState::IterationActive(handle) = &mut self.state else {
                     return Err(SQLiteError(
                         ResultCode::MISUSE,
                         Some("No iteration is active".to_string()),
@@ -84,19 +72,19 @@ impl SyncClient {
 
                 match handle.run(&mut active) {
                     Err(e) => {
-                        *state = ClientState::Idle;
+                        self.state = ClientState::Idle;
                         return Err(e);
                     }
                     Ok(done) => {
                         if done {
-                            *state = ClientState::Idle;
+                            self.state = ClientState::Idle;
                         }
                     }
                 };
 
                 Ok(active.instructions)
             }
-            SyncControlRequest::StopSyncStream => state.tear_down(),
+            SyncControlRequest::StopSyncStream => self.state.tear_down(),
         }
     }
 }

crates/core/src/sync/streaming_sync.rs

@@ -5,14 +5,9 @@ use core::ptr::{self, null_mut};
 use alloc::format;
 use alloc::string::String;
 
-use lock_api::{GuardSend, Mutex as MutexApi, RawMutex};
-use serde::de::Visitor;
-use sqlite_nostd::bindings::SQLITE_MUTEX_FAST;
-use sqlite_nostd::{api_routines, Connection, Context};
-
-use crate::error::SQLiteError;
+#[cfg(not(feature = "getrandom"))]
 use crate::sqlite;
-use crate::sqlite::bindings::sqlite3_mutex;
+use serde::de::Visitor;
 
 use uuid::Uuid;
 
@@ -94,103 +89,6 @@ where
     deserializer.deserialize_option(ValueVisitor)
 }
 
-pub struct SqliteMutex {
-    ptr: *mut sqlite3_mutex,
-}
-
-// We always invoke mutex APIs through the api routines, even when we link the rest of SQLite
-// statically.
-// The reason is that it's possible to omit the mutex code (in which case we don't want to link
-// undefined symbols).
-pub(crate) static mut SQLITE3_API: *mut api_routines = ptr::null_mut();
-
-impl SqliteMutex {
-    pub fn new() -> Self {
-        let native_alloc = unsafe {
-            // SAFETY: SQLITE3_API is only set once when the library is loaded by SQLite.
-            (*SQLITE3_API).mutex_alloc
-        };
-
-        Self {
-            ptr: match native_alloc {
-                None => null_mut(),
-                Some(mutex_alloc) => unsafe {
-                    // SAFETY: We're allowed to call sqlite3_mutex_alloc with this bitmask:
-                    // https://sqlite.org/c3ref/mutex_alloc.html
-                    mutex_alloc(SQLITE_MUTEX_FAST as i32)
-                },
-            },
-        }
-    }
-}
-
-unsafe impl RawMutex for SqliteMutex {
-    const INIT: Self = SqliteMutex { ptr: null_mut() };
-
-    type GuardMarker = GuardSend;
-
-    fn lock(&self) {
-        if self.ptr.is_null() {
-            // Disable mutex code
-        } else {
-            unsafe {
-                // SAFETY: When we get here, we were able to allocate a mutex (so mutex methods
-                // must be present).
-                (*SQLITE3_API).mutex_enter.unwrap_unchecked()(self.ptr)
-            }
-        }
-    }
-
-    fn try_lock(&self) -> bool {
-        if self.ptr.is_null() {
-            // Disable mutex code
-            true
-        } else {
-            let res = unsafe {
-                // SAFETY: When we get here, we were able to allocate a mutex (so mutex methods
-                // must be present).
-                (*SQLITE3_API).mutex_try.unwrap_unchecked()(self.ptr)
-            };
-            res == 0
-        }
-    }
-
-    unsafe fn unlock(&self) {
-        if self.ptr.is_null() {
-            // Disable mutex code
-        } else {
-            unsafe {
-                // SAFETY: When we get here, we were able to allocate a mutex (so mutex methods
-                // must be present). Also, this method is only allowed to be called after a caller
-                // has locked the mutex before.
-                (*SQLITE3_API).mutex_leave.unwrap_unchecked()(self.ptr)
-            }
-        }
-    }
-}
-
-impl Drop for SqliteMutex {
-    fn drop(&mut self) {
-        if !self.ptr.is_null() {
-            unsafe {
-                // SAFETY: The pointer points to a valid mutex we own. This means that we have been
-                // able to allocate a mutex, so mutex methods must be present.
-                (*SQLITE3_API).mutex_free.unwrap_unchecked()(self.ptr)
-            };
-        }
-    }
-}
-
-pub type Mutex<T> = MutexApi<SqliteMutex, T>;
-
-/// Creates a [Mutex] implementation using `sqlite3_mutex_enter` and `sqlite3_mutex_free`.
-///
-/// When SQLite has been compiled without mutexes, the returned mutex doesn't do anything.
-pub fn sqlite3_mutex<T>(value: T) -> Mutex<T> {
-    let raw = SqliteMutex::new();
-    MutexApi::from_raw(raw, value)
-}
-
 // Use getrandom crate to generate UUID.
 // This is not available in all WASM builds - use the default in those cases.
 #[cfg(feature = "getrandom")]