fix: VRAM and memory leaks in window, session, output, and multi-GPU paths

Cargo.toml

@@ -144,4 +144,4 @@ lto = "fat"
 cosmic-protocols = { git = "https://github.com/pop-os//cosmic-protocols", branch = "main" }
 
 [patch.crates-io]
-smithay = { git = "https://github.com/smithay/smithay.git", rev = "cdc03f7" }
+smithay = { git = "https://github.com/smithay/smithay.git", rev = "347b2b3" }

src/backend/kms/device.rs

@@ -27,7 +27,7 @@ use smithay::{
             output::{DrmOutputManager, LockedDrmOutputManager},
         },
         egl::{EGLContext, EGLDevice, EGLDisplay, context::ContextPriority},
-        renderer::glow::GlowRenderer,
+        renderer::{Renderer, glow::GlowRenderer},
         session::{Session, libseat::LibSeatSession},
     },
     desktop::utils::OutputPresentationFeedback,
@@ -45,7 +45,7 @@ use smithay::{
         drm_syncobj::supports_syncobj_eventfd,
     },
 };
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 use wayland_backend::server::ClientId;
 
 use std::{
@@ -322,7 +322,7 @@ impl State {
                         .find_map(|(crtc, surface)| (surface.connector == conn).then_some(crtc))
                         .cloned()
                     {
-                        device.inner.surfaces.remove(&crtc).unwrap();
+                        device.inner.surfaces.remove(&crtc).unwrap().drop_and_join();
                     }
 
                     if !changes.added.iter().any(|(c, _)| c == &conn) {
@@ -929,6 +929,12 @@ impl LockedDevice<'_> {
                     return Err(err.into());
                 }
             }
+
+            // This renderer draws only infrequently; drop the imports it just
+            // cached so they don't pin client buffers in VRAM until its next draw.
+            if let Err(err) = renderer.invalidate_caches() {
+                debug!(?err, "Failed to invalidate main-thread renderer caches");
+            }
         }
 
         Ok(())

src/backend/kms/mod.rs

@@ -79,6 +79,7 @@ pub struct KmsState {
 
     pub syncobj_state: Option<DrmSyncobjState>,
     pub dmabuf_global: Option<DmabufGlobal>,
+    pending_renderer_cleanup: bool,
 }
 
 pub struct KmsGuard<'a> {
@@ -137,6 +138,7 @@ pub fn init_backend(
 
         syncobj_state: None,
         dmabuf_global: None,
+        pending_renderer_cleanup: false,
     });
 
     // manually add already present gpus
@@ -700,6 +702,27 @@ impl KmsState {
         Ok(node)
     }
 
+    /// Request a drain of the main-thread renderers' destruction queues on the next refresh.
+    ///
+    /// Destroying a surface or buffer drops the textures these renderers imported from it,
+    /// which only *queues* the GL deletions on their contexts; the queues are flushed by
+    /// rendering or an explicit drain. Those renderers may not draw again for a long time,
+    /// so until the drain runs the dead client's buffers stay pinned in VRAM.
+    pub fn schedule_renderer_cleanup(&mut self) {
+        self.pending_renderer_cleanup = true;
+    }
+
+    /// Drain the GL destruction queues of the main-thread renderers, if scheduled.
+    pub fn run_scheduled_renderer_cleanup(&mut self) {
+        if !self.pending_renderer_cleanup || !self.session.is_active() {
+            return;
+        }
+        self.pending_renderer_cleanup = false;
+        if let Err(err) = self.api.cleanup_texture_cache() {
+            debug!(?err, "Failed to drain main-thread renderer cleanup queue");
+        }
+    }
+
     pub fn schedule_render(&mut self, output: &Output) {
         for surface in self
             .drm_devices
@@ -1285,6 +1308,25 @@ impl KmsGuard<'_> {
             }
         }
 
+        self.invalidate_renderer_caches();
+
         Ok(())
     }
+
+    /// Drop all cached imports held by the main-thread renderers, along with the
+    /// framebuffers cached for copying between a render and a target node.
+    ///
+    /// Unlike the per-output render threads (which draw every frame), these renderers
+    /// only draw during output (re-)configuration. Between those infrequent draws their
+    /// import caches provide no benefit yet keep live clients' buffers pinned in VRAM;
+    /// the next render re-imports what it needs. Imports belonging to clients that have
+    /// already exited are released by the destruction-scheduled drain.
+    fn invalidate_renderer_caches(&mut self) {
+        if !self.session.is_active() {
+            return;
+        }
+        if let Err(err) = self.api.invalidate_caches() {
+            debug!(?err, "Failed to invalidate main-thread renderer caches");
+        }
+    }
 }

src/backend/kms/surface/mod.rs

@@ -54,7 +54,7 @@ use smithay::{
                 GlesRenderbuffer, GlesRenderer, GlesTexture, Uniform, element::TextureShaderElement,
             },
             glow::GlowRenderer,
-            multigpu::{ApiDevice, Error as MultiError, GpuManager},
+            multigpu::{Error as MultiError, GpuManager},
             sync::SyncPoint,
             utils::with_renderer_surface_state,
         },
@@ -739,6 +739,7 @@ impl SurfaceThreadState {
 
     fn node_removed(&mut self, node: DrmNode) {
         self.api.as_mut().remove_node(&node);
+        self.postprocess_textures.remove(&node);
         // force enumeration
         let _ = self.api.devices();
     }
@@ -1408,9 +1409,7 @@ impl SurfaceThreadState {
             }
         }
 
-        for device in self.api.devices_mut()? {
-            device.renderer_mut().cleanup_texture_cache()?;
-        }
+        self.api.cleanup_texture_cache()?;
 
         Ok(())
     }

src/backend/render/cursor.rs

@@ -266,6 +266,7 @@ pub struct CursorStateInner {
     cursors: HashMap<CursorIcon, Cursor>,
     current_image: Option<Image>,
     image_cache: Vec<(Image, MemoryRenderBuffer)>,
+    last_cursor_icon: Option<CursorIcon>,
 
     hidden: bool,
     idle_timer: Option<RegistrationToken>,
@@ -320,6 +321,7 @@ impl Default for CursorStateInner {
             cursors: HashMap::new(),
             current_image: None,
             image_cache: Vec::new(),
+            last_cursor_icon: None,
 
             hidden: false,
             idle_timer: None,
@@ -363,6 +365,11 @@ pub fn draw_cursor<R>(
             return;
         }
 
+        if state.last_cursor_icon != Some(current_cursor) {
+            state.image_cache.clear();
+            state.last_cursor_icon = Some(current_cursor);
+        }
+
         let integer_scale = (scale.x.max(scale.y) * buffer_scale).ceil() as u32;
         let frame = state
             .get_named_cursor(current_cursor)