matrix-rust-sdk

public

Star0

Fork 0

Watch0

41 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `c72dc01ad0dd`

tarball

atagen <boss@atagen.co>2026-10-26 10:11 UTC

3 files changed+21-17

event-cache: never await a room while holding the room caches lock

The redecryptor read every room's events while holding the global by_room read lock. One room held up there (a full history load from IndexedDB) kept the lock, and since tokio queues new readers behind a waiting room creation, every room access stalled. That fits room opens timing out right after a recovery hands over the backup key, which sets the redecryptor going. It now clones the room handles out first.

Modified file: crates/matrix-sdk/src/event_cache/caches/mod.rs−10 deletions@@ -146,16 +146,6 @@ impl Caches {
     pub async fn prepare_to_reset(&mut self) -> Result<ResetCaches<'_>> {
         ResetCaches::new(self).await
     }
-
-    /// Get all events from all the event caches manged by this [`Cacches`].
-    ///
-    /// Events can be duplicated if present in different event caches.
-    #[cfg(feature = "e2e-encryption")]
-    pub async fn all_events(&self) -> Result<impl Iterator<Item = Event>> {
-        let events_from_room = self.room.events().await?;
-
-        Ok(events_from_room.into_iter())
-    }
 }
 
 /// Type holding exclusive locks over all event caches managed by a

Modified file: crates/matrix-sdk/src/event_cache/caches/room/history.rs+1−1

@@ -253,7 +253,7 @@ impl RoomEventCache {

253253 mut cancellation: watch::Receiver<bool>,

254254 ) -> Result<RecentHistoryOutcome> {

255255 let (anchor, retained) = {

256- let mut state = self.inner.state.write().await?;

256+ let state = self.inner.state.write().await?;

257257 let retained: HashSet<_> = state

258258 .room_linked_chunk()

259259 .events()

Modified file: crates/matrix-sdk/src/event_cache/redecryptor.rs+20 additions−6 deletions@@ -281,14 +281,28 @@ impl EventCache {
         Ok(events.into_iter().filter_map(filter_timeline_event_to_utd).collect())
     }
 
+    /// The rooms the event cache holds, taken out of `by_room` before any of them is awaited.
+    ///
+    /// A slow room (a full history load from IndexedDB) would otherwise keep the global lock, and
+    /// tokio queues new readers behind a waiting room creation, so every room access stalls.
+    async fn rooms_in_memory(&self) -> Vec<(OwnedRoomId, crate::event_cache::RoomEventCache)> {
+        self.inner
+            .by_room
+            .read()
+            .await
+            .iter()
+            .map(|(room_id, caches)| (room_id.clone(), caches.room.clone()))
+            .collect()
+    }
+
     /// Retrieve a set of events that we weren't able to decrypt from the memory
     /// of the event cache.
     async fn get_utds_from_memory(&self) -> BTreeMap<OwnedRoomId, Vec<EventIdAndUtd>> {
         let mut utds = BTreeMap::new();
 
-        for (room_id, caches) in self.inner.by_room.read().await.iter() {
-            let room_utds: Vec<_> = caches
-                .all_events()
+        for (room_id, room) in self.rooms_in_memory().await {
+            let room_utds: Vec<_> = room
+                .events()
                 .await
                 .into_iter()
                 .flatten()
@@ -324,9 +338,9 @@ impl EventCache {
     ) -> BTreeMap<OwnedRoomId, Vec<EventIdAndEvent>> {
         let mut decrypted_events = BTreeMap::new();
 
-        for (room_id, caches) in self.inner.by_room.read().await.iter() {
-            let room_utds: Vec<_> = caches
-                .all_events()
+        for (room_id, room) in self.rooms_in_memory().await {
+            let room_utds: Vec<_> = room
+                .events()
                 .await
                 .into_iter()
                 .flatten()

matrix-rust-sdk

Commit c72dc01ad0dd

Commit `c72dc01ad0dd`