Don't use mutex routines if unavailable

Author: simolus3

crates/core/src/lib.rs

@@ -11,6 +11,7 @@ use core::ffi::{c_char, c_int};
 
 use sqlite::ResultCode;
 use sqlite_nostd as sqlite;
+use util::SQLITE3_API;
 
 mod bson;
 mod checkpoint;
@@ -43,6 +44,7 @@ pub extern "C" fn sqlite3_powersync_init(
     api: *mut sqlite::api_routines,
 ) -> c_int {
     sqlite::EXTENSION_INIT2(api);
+    unsafe { SQLITE3_API = api };
 
     let result = init_extension(db);
 

crates/core/src/sync/streaming_sync.rs

@@ -237,7 +237,7 @@ impl StreamingSyncIteration {
                                         .into(),
                                 });
 
-                                self.handle_checkpoint_applied(&checkpoint, event)?;
+                                self.handle_checkpoint_applied(event)?;
                             }
                             _ => {
                                 event.instructions.push(Instruction::LogLine {
@@ -331,7 +331,7 @@ impl StreamingSyncIteration {
                                 severity: LogSeverity::DEBUG,
                                 line: "Validated and applied checkpoint".into(),
                             });
-                            self.handle_checkpoint_applied(target, event)?;
+                            self.handle_checkpoint_applied(event)?;
                         }
                     }
                 }
@@ -438,16 +438,12 @@ impl StreamingSyncIteration {
         Ok(local_bucket_names)
     }
 
-    fn handle_checkpoint_applied(
-        &mut self,
-        target: &OwnedCheckpoint,
-        event: &mut ActiveEvent,
-    ) -> Result<(), ResultCode> {
+    fn handle_checkpoint_applied(&mut self, event: &mut ActiveEvent) -> Result<(), ResultCode> {
         event.instructions.push(Instruction::DidCompleteSync {});
 
         let now = self.adapter.now()?;
         self.status.update(
-            |status| status.applied_checkpoint(target, now),
+            |status| status.applied_checkpoint(now),
             &mut event.instructions,
         );
 

crates/core/src/sync/sync_status.rs

@@ -69,7 +69,7 @@ impl DownloadSyncStatus {
         self.debug_assert_priority_status_is_sorted();
     }
 
-    pub fn applied_checkpoint(&mut self, applied: &OwnedCheckpoint, now: Timestamp) {
+    pub fn applied_checkpoint(&mut self, now: Timestamp) {
         self.downloading = None;
         self.priority_status.clear();
 

crates/core/src/util.rs

@@ -1,20 +1,16 @@
 extern crate alloc;
 
-use core::ptr::null_mut;
+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::{
-    sqlite3_mutex_alloc, sqlite3_mutex_enter, sqlite3_mutex_free, sqlite3_mutex_leave,
-    sqlite3_mutex_try, Connection, Context,
-};
+use sqlite_nostd::{api_routines, Connection, Context};
 
 use crate::error::SQLiteError;
-#[cfg(feature = "getrandom")]
 use crate::sqlite;
 use crate::sqlite::bindings::sqlite3_mutex;
 
@@ -118,10 +114,21 @@ 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 { (*SQLITE3_API).mutex_alloc };
+
         Self {
-            ptr: sqlite3_mutex_alloc(SQLITE_MUTEX_FAST as i32),
+            ptr: match native_alloc {
+                None => null_mut(),
+                Some(mutex_alloc) => unsafe { mutex_alloc(SQLITE_MUTEX_FAST as i32) },
+            },
         }
     }
 }
@@ -132,21 +139,37 @@ unsafe impl RawMutex for SqliteMutex {
     type GuardMarker = GuardSend;
 
     fn lock(&self) {
-        sqlite3_mutex_enter(self.ptr);
+        if self.ptr.is_null() {
+            // Disable mutex code
+        } else {
+            unsafe { (*SQLITE3_API).mutex_enter.unwrap_unchecked()(self.ptr) }
+        }
     }
 
     fn try_lock(&self) -> bool {
-        sqlite3_mutex_try(self.ptr) == 0
+        if self.ptr.is_null() {
+            // Disable mutex code
+            true
+        } else {
+            let res = unsafe { (*SQLITE3_API).mutex_try.unwrap_unchecked()(self.ptr) };
+            res == 0
+        }
     }
 
     unsafe fn unlock(&self) {
-        sqlite3_mutex_leave(self.ptr);
+        if self.ptr.is_null() {
+            // Disable mutex code
+        } else {
+            unsafe { (*SQLITE3_API).mutex_leave.unwrap_unchecked()(self.ptr) }
+        }
     }
 }
 
 impl Drop for SqliteMutex {
     fn drop(&mut self) {
-        sqlite3_mutex_free(self.ptr);
+        if !self.ptr.is_null() {
+            unsafe { (*SQLITE3_API).mutex_free.unwrap_unchecked()(self.ptr) };
+        }
     }
 }
 

crates/shell/build.rs

@@ -1,3 +1,4 @@
+
 fn main() {
     let mut cfg = cc::Build::new();
 
@@ -7,7 +8,7 @@ fn main() {
     cfg.include("../sqlite/sqlite");
 
     // General SQLite options
-    cfg.define("SQLITE_THREADSAFE", Some("1"));
+    cfg.define("SQLITE_THREADSAFE", Some("0"));
     cfg.define("SQLITE_ENABLE_BYTECODE_VTAB", Some("1"));
 
     // Call core_init() in main.rs