metal: handle gpu reset

Unfortunately this doesn't seem to work on amdgpu [1]. I've tested that
it works on i915.

[1] https://gitlab.freedesktop.org/drm/amd/-/issues/1749

build/egl.rs

@@ -79,6 +79,7 @@ fn write_egl_procs<W: Write>(f: &mut W) -> anyhow::Result<()> {
             "()",
             &[("target", "GLenum"), ("image", "GLeglImageOES")][..],
         ),
+        ("glGetGraphicsResetStatusKHR", "GLenum", &[][..]),
     ];
 
     writeln!(f, "use std::ptr;")?;

src/backends/metal.rs

@@ -9,7 +9,7 @@ use {
             Backend, BackendEvent, InputDevice, InputDeviceAccelProfile, InputDeviceCapability,
             InputDeviceId, InputEvent, KeyState, TransformMatrix,
         },
-        backends::metal::video::{MetalDrmDevice, PendingDrmDevice},
+        backends::metal::video::{MetalDrmDevice, MetalRenderContext, PendingDrmDevice},
         dbus::{DbusError, SignalHandler},
         libinput::{
             consts::{
@@ -44,6 +44,7 @@ use {
         cell::{Cell, RefCell},
         error::Error,
         ffi::{CStr, CString},
+        fmt::{Debug, Formatter},
         future::pending,
         mem,
         rc::Rc,
@@ -82,7 +83,7 @@ pub enum MetalError {
     NoModeForConnector,
     #[error("Could not allocate scanout buffer")]
     ScanoutBuffer(#[source] GbmError),
-    #[error("Could not create a framebuffer")]
+    #[error("addfb2 failed")]
     Framebuffer(#[source] DrmError),
     #[error("Could not import a framebuffer into EGL")]
     ImportFb(#[source] RenderError),
@@ -124,6 +125,13 @@ pub struct MetalBackend {
     drm_ids: DrmIds,
     pause_handler: Cell<Option<SignalHandler>>,
     resume_handler: Cell<Option<SignalHandler>>,
+    ctx: CloneCell<Option<Rc<MetalRenderContext>>>,
+}
+
+impl Debug for MetalBackend {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MetalBackend").finish_non_exhaustive()
+    }
 }
 
 impl MetalBackend {
@@ -250,6 +258,7 @@ pub async fn create(state: &Rc<State>) -> Result<Rc<MetalBackend>, MetalError> {
         drm_ids: Default::default(),
         pause_handler: Default::default(),
         resume_handler: Default::default(),
+        ctx: Default::default(),
     });
     metal.pause_handler.set(Some({
         let mtl = metal.clone();

src/backends/metal/monitor.rs

@@ -235,8 +235,16 @@ impl MetalBackend {
         }
     }
 
-    fn handle_drm_change(self: &Rc<Self>, _dev: UdevDevice) -> Option<()> {
+    fn handle_drm_change(self: &Rc<Self>, dev: UdevDevice) -> Option<()> {
-        // TODO: Handle monitor connections and connector hotplug
+        let dev = match self.device_holder.drm_devices.get(&dev.devnum()) {
+            Some(dev) => dev,
+            _ => return None,
+        };
+        for connector in dev.connectors.values() {
+            connector.can_present.set(true);
+            connector.has_damage.set(true);
+            connector.schedule_present();
+        }
         None
     }
 

src/backends/metal/video.rs

@@ -23,7 +23,7 @@ use {
                 DRM_CLIENT_CAP_ATOMIC, DRM_MODE_ATOMIC_ALLOW_MODESET, DRM_MODE_ATOMIC_NONBLOCK,
                 DRM_MODE_PAGE_FLIP_EVENT,
             },
-            gbm::{GbmDevice, GBM_BO_USE_RENDERING, GBM_BO_USE_SCANOUT},
+            gbm::{GbmDevice, GBM_BO_USE_LINEAR, GBM_BO_USE_RENDERING, GBM_BO_USE_SCANOUT},
             ModifiedFormat, INVALID_MODIFIER,
         },
     },
@@ -37,6 +37,7 @@ use {
     },
     uapi::c,
 };
+use crate::render::ResetStatus;
 
 pub struct PendingDrmDevice {
     pub id: DrmId,
@@ -44,6 +45,11 @@ pub struct PendingDrmDevice {
     pub devnode: CString,
 }
 
+pub struct MetalRenderContext {
+    pub dev: Rc<MetalDrmDeviceStatic>,
+    pub egl: Rc<RenderContext>,
+}
+
 #[derive(Debug)]
 pub struct MetalDrmDeviceStatic {
     pub id: DrmId,
@@ -58,7 +64,6 @@ pub struct MetalDrmDeviceStatic {
     pub min_height: u32,
     pub max_height: u32,
     pub gbm: GbmDevice,
-    pub egl: Rc<RenderContext>,
     pub async_fd: AsyncFd,
     pub handle_events: HandleEvents,
 }
@@ -86,6 +91,9 @@ pub struct MetalConnector {
     pub master: Rc<DrmMaster>,
     pub state: Rc<State>,
 
+    pub dev: Rc<MetalDrmDeviceStatic>,
+    pub backend: Rc<MetalBackend>,
+
     pub connector_id: ConnectorId,
 
     pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
@@ -162,6 +170,9 @@ impl MetalConnector {
     }
 
     pub fn present(&self) {
+        if !self.backend.check_render_context() {
+            return;
+        }
         let crtc = match self.crtc.get() {
             Some(crtc) => crtc,
             _ => return,
@@ -172,14 +183,14 @@ impl MetalConnector {
         if !crtc.active.value.get() {
             return;
         }
-        let buffers = match self.buffers.get() {
-            None => return,
-            Some(b) => b,
-        };
         let plane = match self.primary_plane.get() {
             Some(p) => p,
             _ => return,
         };
+        let buffers = match self.buffers.get() {
+            Some(b) => b,
+            _ => return,
+        };
         let buffer = &buffers[self.next_buffer.fetch_add(1) % buffers.len()];
         if let Some(node) = self.state.root.outputs.get(&self.connector_id) {
             let mut rr = self.render_result.borrow_mut();
@@ -295,7 +306,7 @@ pub struct MetalPlane {
 }
 
 fn get_connectors(
-    state: &Rc<State>,
+    backend: &Rc<MetalBackend>,
     dev: &Rc<MetalDrmDeviceStatic>,
     ids: &[DrmConnector],
 ) -> Result<
@@ -308,7 +319,7 @@ fn get_connectors(
     let mut connectors = AHashMap::new();
     let mut futures = vec![];
     for connector in ids {
-        match create_connector(state, *connector, dev) {
+        match create_connector(backend, *connector, dev) {
             Ok((con, fut)) => {
                 connectors.insert(con.id, con);
                 futures.push(fut);
@@ -320,7 +331,7 @@ fn get_connectors(
 }
 
 fn create_connector(
-    state: &Rc<State>,
+    backend: &Rc<MetalBackend>,
     connector: DrmConnector,
     dev: &Rc<MetalDrmDeviceStatic>,
 ) -> Result<(Rc<MetalConnector>, ConnectorFutures), DrmError> {
@@ -412,8 +423,10 @@ fn create_connector(
     let slf = Rc::new(MetalConnector {
         id: connector,
         master: dev.master.clone(),
-        state: state.clone(),
+        state: backend.state.clone(),
-        connector_id: state.connector_ids.next(),
+        dev: dev.clone(),
+        backend: backend.clone(),
+        connector_id: backend.state.connector_ids.next(),
         crtcs,
         mode: CloneCell::new(mode),
         refresh: Cell::new(refresh),
@@ -440,7 +453,10 @@ fn create_connector(
         render_result: RefCell::new(Default::default()),
     });
     let futures = ConnectorFutures {
-        present: state.eng.spawn2(Phase::Present, slf.clone().present_loop()),
+        present: backend
+            .state
+            .eng
+            .spawn2(Phase::Present, slf.clone().present_loop()),
     };
     Ok((slf, futures))
 }
@@ -606,6 +622,67 @@ impl<T: Copy> MutableProperty<T> {
 }
 
 impl MetalBackend {
+    fn check_render_context(&self) -> bool {
+        let ctx = match self.ctx.get() {
+            Some(ctx) => ctx,
+            None => return false,
+        };
+        let reset = match ctx.egl.reset_status() {
+            Some(r) => r,
+            None => return true,
+        };
+        log::error!("EGL context has been reset: {:?}", reset);
+        if reset != ResetStatus::Innocent {
+            fatal!("We are not innocent. Terminating.");
+        }
+        log::info!("Trying to create a new context");
+        self.state.set_render_ctx(None);
+        let mut old_buffers = vec![];
+        for dev in self.device_holder.drm_devices.lock().values() {
+            for connector in dev.connectors.values() {
+                old_buffers.push(connector.buffers.take());
+            }
+        }
+        if !self.install_render_context(&ctx.dev) {
+            return false;
+        }
+        for dev in self.device_holder.drm_devices.lock().values() {
+            if let Err(e) = self.init_drm_device(dev) {
+                log::error!("Could not re-initialize device: {}", ErrorFmt(e));
+            }
+        }
+        true
+    }
+
+    fn install_render_context(&self, dev: &Rc<MetalDrmDeviceStatic>) -> bool {
+        let ctx = match self.create_render_context(dev) {
+            Ok(ctx) => ctx,
+            Err(e) => {
+                log::error!("Could not create a render context: {}", ErrorFmt(e));
+                return false;
+            }
+        };
+        self.state.set_render_ctx(Some(&ctx.egl));
+        self.ctx.set(Some(ctx));
+        true
+    }
+
+    fn create_render_context(
+        &self,
+        dev: &Rc<MetalDrmDeviceStatic>,
+    ) -> Result<Rc<MetalRenderContext>, MetalError> {
+        let egl = match RenderContext::from_drm_device(&dev.master) {
+            Ok(r) => Rc::new(r),
+            Err(e) => return Err(MetalError::CreateRenderContex(e)),
+        };
+        let ctx = Rc::new(MetalRenderContext {
+            dev: dev.clone(),
+            egl,
+        });
+        self.ctx.set(Some(ctx.clone()));
+        Ok(ctx)
+    }
+
     pub fn create_drm_device(
         self: &Rc<Self>,
         pending: PendingDrmDevice,
@@ -650,10 +727,6 @@ impl MetalBackend {
             Ok(g) => g,
             Err(e) => return Err(MetalError::GbmDevice(e)),
         };
-        let egl = match RenderContext::from_drm_device(master) {
-            Ok(r) => Rc::new(r),
-            Err(e) => return Err(MetalError::CreateRenderContex(e)),
-        };
         let async_fd = match self.state.eng.fd(master.fd()) {
             Ok(f) => f,
             Err(e) => return Err(MetalError::CreateAsyncFd(e)),
@@ -672,14 +745,20 @@ impl MetalBackend {
             min_height: resources.min_height,
             max_height: resources.max_height,
             gbm,
-            egl: egl.clone(),
             async_fd,
             handle_events: HandleEvents {
                 handle_events: Cell::new(None),
             },
         });
 
-        let (connectors, futures) = get_connectors(&self.state, &dev, &resources.connectors)?;
+        if self.ctx.get().is_none() {
+            self.install_render_context(&dev);
+            for dev in self.device_holder.drm_devices.lock().values() {
+                let _ = self.init_drm_device(dev);
+            }
+        }
+
+        let (connectors, futures) = get_connectors(&self, &dev, &resources.connectors)?;
 
         let slf = Rc::new(MetalDrmDevice {
             dev,
@@ -730,8 +809,6 @@ impl MetalBackend {
             .spawn(self.clone().handle_drm_events(slf.clone()));
         slf.dev.handle_events.handle_events.set(Some(drm_handler));
 
-        self.state.set_render_ctx(&egl);
-
         Ok(slf)
     }
 
@@ -891,6 +968,10 @@ impl MetalBackend {
     }
 
     fn init_drm_device(&self, dev: &Rc<MetalDrmDevice>) -> Result<(), MetalError> {
+        let ctx = match self.ctx.get() {
+            Some(ctx) => ctx,
+            _ => return Ok(()),
+        };
         let mut flags = 0;
         let mut changes = dev.dev.master.change();
         if !self.can_use_current_drm_mode(dev) {
@@ -905,7 +986,7 @@ impl MetalBackend {
         }
         self.reset_planes(dev, &mut changes);
         for connector in dev.connectors.values() {
-            if let Err(e) = self.assign_connector_plane(dev, connector, &mut changes) {
+            if let Err(e) = self.assign_connector_plane(connector, &mut changes, &ctx) {
                 log::error!("Could not assign a plane: {}", ErrorFmt(e));
             }
         }
@@ -996,37 +1077,38 @@ impl MetalBackend {
 
     fn create_scanout_buffers(
         &self,
-        dev: &Rc<MetalDrmDevice>,
+        dev: &Rc<MetalDrmDeviceStatic>,
         format: &ModifiedFormat,
         width: i32,
         height: i32,
+        ctx: &MetalRenderContext,
     ) -> Result<[RenderBuffer; 2], MetalError> {
-        let create = || self.create_scanout_buffer(dev, format, width, height);
+        let create = || self.create_scanout_buffer(dev, format, width, height, ctx);
         Ok([create()?, create()?])
     }
 
     fn create_scanout_buffer(
         &self,
-        dev: &Rc<MetalDrmDevice>,
+        dev: &Rc<MetalDrmDeviceStatic>,
         format: &ModifiedFormat,
         width: i32,
         height: i32,
+        ctx: &MetalRenderContext,
     ) -> Result<RenderBuffer, MetalError> {
-        let bo = dev.dev.gbm.create_bo(
+        let mut usage = GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT;
-            width,
+        if ctx.dev.id != dev.id {
-            height,
+            usage |= GBM_BO_USE_LINEAR;
-            format,
+        };
-            GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT,
+        let bo = dev.gbm.create_bo(width, height, format, usage);
-        );
         let bo = match bo {
             Ok(b) => b,
             Err(e) => return Err(MetalError::ScanoutBuffer(e)),
         };
-        let drm_fb = match dev.dev.master.add_fb(bo.dmabuf()) {
+        let drm_fb = match dev.master.add_fb(bo.dmabuf()) {
             Ok(fb) => Rc::new(fb),
             Err(e) => return Err(MetalError::Framebuffer(e)),
         };
-        let egl_img = match dev.dev.egl.dmabuf_img(bo.dmabuf()) {
+        let egl_img = match ctx.egl.dmabuf_img(bo.dmabuf()) {
             Ok(img) => img,
             Err(e) => return Err(MetalError::ImportImage(e)),
         };
@@ -1085,9 +1167,9 @@ impl MetalBackend {
 
     fn assign_connector_plane(
         &self,
-        dev: &Rc<MetalDrmDevice>,
         connector: &Rc<MetalConnector>,
         changes: &mut Change,
+        ctx: &MetalRenderContext,
     ) -> Result<(), MetalError> {
         let crtc = match connector.crtc.get() {
             Some(c) => c,
@@ -1111,22 +1193,17 @@ impl MetalBackend {
             }
             return Err(MetalError::NoPrimaryPlaneForConnector);
         };
-        connector.buffers.set(None);
+        let format = ModifiedFormat {
-        let buffers = match connector.buffers.get() {
+            format: XRGB8888,
-            Some(b) => b,
+            modifier: INVALID_MODIFIER,
-            None => {
-                let format = ModifiedFormat {
-                    format: XRGB8888,
-                    modifier: INVALID_MODIFIER,
-                };
-                Rc::new(self.create_scanout_buffers(
-                    dev,
-                    &format,
-                    mode.hdisplay as _,
-                    mode.vdisplay as _,
-                )?)
-            }
         };
+        let buffers = Rc::new(self.create_scanout_buffers(
+            &connector.dev,
+            &format,
+            mode.hdisplay as _,
+            mode.vdisplay as _,
+            ctx,
+        )?);
         changes.change_object(primary_plane.id, |c| {
             c.change(primary_plane.fb_id, buffers[0].drm.id().0 as _);
             c.change(primary_plane.crtc_id.id, crtc.id.0 as _);

src/backends/x.rs

@@ -279,7 +279,7 @@ impl XBackend {
             .eng
             .spawn2(Phase::Present, self.clone().present_handler());
 
-        self.state.set_render_ctx(&self.ctx);
+        self.state.set_render_ctx(Some(&self.ctx));
 
         pending().await
     }

src/compositor.rs

@@ -127,6 +127,7 @@ fn start_compositor2(
         eng: engine.clone(),
         el: el.clone(),
         render_ctx: Default::default(),
+        render_ctx_version: NumCell::new(1),
         cursors: Default::default(),
         wheel,
         clients: Clients::new(),

src/ifs/wl_buffer.rs

@@ -1,3 +1,5 @@
+use std::cell::RefCell;
+use std::ops::Deref;
 use {
     crate::{
         client::{Client, ClientError},
@@ -16,6 +18,9 @@ use {
     std::{cell::Cell, rc::Rc},
     thiserror::Error,
 };
+use crate::utils::errorfmt::ErrorFmt;
+use crate::video::dmabuf::DmaBuf;
+use crate::wire::jay_screenshot::Dmabuf;
 
 pub enum WlBufferStorage {
     Shm { mem: ClientMemOffset, stride: i32 },
@@ -28,7 +33,9 @@ pub struct WlBuffer {
     pub client: Rc<Client>,
     pub rect: Rect,
     pub format: &'static Format,
-    pub storage: WlBufferStorage,
+    dmabuf: Option<DmaBuf>,
+    render_ctx_version: Cell<u32>,
+    pub storage: RefCell<Option<WlBufferStorage>>,
     pub texture: CloneCell<Option<Rc<Texture>>>,
     pub famebuffer: CloneCell<Option<Rc<Framebuffer>>>,
     width: i32,
@@ -46,6 +53,7 @@ impl WlBuffer {
         id: WlBufferId,
         client: &Rc<Client>,
         format: &'static Format,
+        dmabuf: DmaBuf,
         img: &Rc<Image>,
     ) -> Self {
         let width = img.width();
@@ -60,7 +68,9 @@ impl WlBuffer {
             height,
             texture: CloneCell::new(None),
             famebuffer: Default::default(),
-            storage: WlBufferStorage::Dmabuf(img.clone()),
+            dmabuf: Some(dmabuf),
+            render_ctx_version: Cell::new(client.state.render_ctx_version.get()),
+            storage: RefCell::new(Some(WlBufferStorage::Dmabuf(img.clone()))),
             tracker: Default::default(),
         }
     }
@@ -92,7 +102,9 @@ impl WlBuffer {
             client: client.clone(),
             rect: Rect::new_sized(0, 0, width, height).unwrap(),
             format,
-            storage: WlBufferStorage::Shm { mem, stride },
+            dmabuf: None,
+            render_ctx_version: Cell::new(client.state.render_ctx_version.get()),
+            storage: RefCell::new(Some(WlBufferStorage::Shm { mem, stride })),
             width,
             height,
             texture: CloneCell::new(None),
@@ -101,8 +113,43 @@ impl WlBuffer {
         })
     }
 
+    pub fn handle_gfx_context_change(&self) {
+        let ctx_version = self.client.state.render_ctx_version.get();
+        if self.render_ctx_version.replace(ctx_version) == ctx_version {
+            return;
+        }
+        self.texture.set(None);
+        self.famebuffer.set(None);
+        let mut storage = self.storage.borrow_mut();
+        if let Some(storage) = &mut *storage {
+            if let WlBufferStorage::Shm { .. } = storage {
+                return;
+            }
+        }
+        *storage = None;
+        let ctx = match self.client.state.render_ctx.get() {
+            Some(ctx) => ctx,
+            _ => return,
+        };
+        if let Some(dmabuf) = &self.dmabuf {
+            let image = match ctx.dmabuf_img(dmabuf) {
+                Ok(image) => image,
+                Err(e) => {
+                    log::error!("Cannot re-import wl_buffer after graphics context reset: {}", ErrorFmt(e));
+                    return;
+                }
+            };
+            *storage = Some(WlBufferStorage::Dmabuf(image));
+        }
+    }
+
     pub fn update_texture(&self) -> Result<(), WlBufferError> {
-        match &self.storage {
+        let storage = self.storage.borrow_mut();
+        let storage = match storage.deref() {
+            Some(s) => s,
+            _ => return Ok(()),
+        };
+        match storage {
             WlBufferStorage::Shm { mem, stride } => {
                 self.texture.set(None);
                 if let Some(ctx) = self.client.state.render_ctx.get() {
@@ -122,7 +169,12 @@ impl WlBuffer {
     }
 
     pub fn update_framebuffer(&self) -> Result<(), WlBufferError> {
-        match &self.storage {
+        let storage = self.storage.borrow_mut();
+        let storage = match storage.deref() {
+            Some(s) => s,
+            _ => return Ok(()),
+        };
+        match storage {
             WlBufferStorage::Shm { .. } => {
                 // nothing
             }

src/ifs/wl_drm.rs

@@ -147,7 +147,7 @@ impl WlDrm {
             }
         }
         let img = ctx.dmabuf_img(&dmabuf)?;
-        let buffer = Rc::new(WlBuffer::new_dmabuf(req.id, &self.client, format, &img));
+        let buffer = Rc::new(WlBuffer::new_dmabuf(req.id, &self.client, format, dmabuf, &img));
         track!(self.client, buffer);
         self.client.add_client_obj(&buffer)?;
         Ok(())

src/ifs/wl_output.rs

@@ -189,7 +189,7 @@ impl WlOutputGlobal {
                 continue;
             }
             let rect = capture.rect;
-            if let WlBufferStorage::Shm { mem, .. } = &wl_buffer.storage {
+            if let Some(WlBufferStorage::Shm { mem, .. }) = wl_buffer.storage.borrow_mut().deref() {
                 let res = mem.access(|mem| {
                     fb.copy_to_shm(
                         rect.x1(),

src/ifs/zwlr_screencopy_frame_v1.rs

@@ -1,3 +1,4 @@
+use std::ops::Deref;
 use {
     crate::{
         client::{Client, ClientError},
@@ -114,7 +115,7 @@ impl ZwlrScreencopyFrameV1 {
             return Err(ZwlrScreencopyFrameV1Error::InvalidBufferFormat);
         }
         buffer.update_framebuffer()?;
-        if let WlBufferStorage::Shm { stride, .. } = &buffer.storage {
+        if let Some(WlBufferStorage::Shm { stride, .. }) = buffer.storage.borrow_mut().deref() {
             if *stride != self.rect.width() * 4 {
                 return Err(ZwlrScreencopyFrameV1Error::InvalidBufferStride);
             }

src/ifs/zwp_linux_buffer_params_v1.rs

@@ -141,6 +141,7 @@ impl ZwpLinuxBufferParamsV1 {
             buffer_id,
             &self.parent.client,
             format.format,
+            dmabuf,
             &img,
         ));
         track!(self.parent.client, buffer);

src/it/test_backend.rs

@@ -167,7 +167,7 @@ impl TestBackend {
             Ok(ctx) => ctx,
             Err(e) => return Err(TestBackendError::RenderContext(e)),
         };
-        self.state.set_render_ctx(&Rc::new(ctx));
+        self.state.set_render_ctx(Some(&Rc::new(ctx)));
         Ok(())
     }
 }

src/render/egl/context.rs

@@ -3,9 +3,14 @@ use {
         egl::{
             display::EglDisplay,
             sys::{eglDestroyContext, eglMakeCurrent, EGLContext, EGLSurface, EGL_FALSE, EGL_TRUE},
+            PROCS,
         },
-        ext::GlExt,
+        ext::{DisplayExt, GlExt},
-        RenderError,
+        sys::{
+            GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB,
+            GL_UNKNOWN_CONTEXT_RESET_ARB,
+        },
+        RenderError, ResetStatus,
     },
     std::rc::Rc,
 };
@@ -31,6 +36,27 @@ impl Drop for EglContext {
 static mut CURRENT: EGLContext = EGLContext::none();
 
 impl EglContext {
+    pub fn reset_status(&self) -> Option<ResetStatus> {
+        if !self
+            .dpy
+            .exts
+            .contains(DisplayExt::EXT_CREATE_CONTEXT_ROBUSTNESS)
+        {
+            return None;
+        }
+        let status = self.with_current(|| unsafe {
+            let status = match PROCS.glGetGraphicsResetStatusKHR() {
+                0 => return Ok(None),
+                GL_GUILTY_CONTEXT_RESET_ARB => ResetStatus::Guilty,
+                GL_INNOCENT_CONTEXT_RESET_ARB => ResetStatus::Innocent,
+                GL_UNKNOWN_CONTEXT_RESET_ARB => ResetStatus::Unknown,
+                n => ResetStatus::Other(n),
+            };
+            Ok(Some(status))
+        });
+        status.unwrap_or_default()
+    }
+
     #[inline]
     pub fn with_current<T, F: FnOnce() -> Result<T, RenderError>>(
         &self,

src/render/egl/display.rs

@@ -23,7 +23,10 @@ use {
                 PROCS,
             },
             ext::{get_display_ext, get_gl_ext, DisplayExt, GlExt},
-            sys::{eglInitialize, EGL_PLATFORM_GBM_KHR},
+            sys::{
+                eglInitialize, EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT,
+                EGL_LOSE_CONTEXT_ON_RESET_EXT, EGL_PLATFORM_GBM_KHR,
+            },
             RenderError,
         },
         video::{dmabuf::DmaBuf, drm::Drm, gbm::GbmDevice, INVALID_MODIFIER},
@@ -104,7 +107,17 @@ impl EglDisplay {
     }
 
     pub fn create_context(self: &Rc<Self>) -> Result<Rc<EglContext>, RenderError> {
-        let attrib = [EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE];
+        let mut attrib = vec![EGL_CONTEXT_CLIENT_VERSION, 2];
+        if self
+            .exts
+            .contains(DisplayExt::EXT_CREATE_CONTEXT_ROBUSTNESS)
+        {
+            attrib.push(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT);
+            attrib.push(EGL_LOSE_CONTEXT_ON_RESET_EXT);
+        } else {
+            log::warn!("EGL display does not support gpu reset notifications");
+        }
+        attrib.push(EGL_NONE);
         unsafe {
             let ctx = eglCreateContext(
                 self.dpy,

src/render/egl/sys.rs

@@ -1,4 +1,4 @@
-use uapi::c;
+use {crate::render::sys::GLenum, uapi::c};
 
 pub type EGLint = i32;
 pub type EGLenum = c::c_uint;
@@ -51,6 +51,12 @@ pub const EGL_BAD_DEVICE_EXT: EGLint = 0x322B;
 pub const EGL_OPENGL_ES_API: EGLenum = 0x30A0;
 pub const EGL_PLATFORM_GBM_KHR: EGLint = 0x31D7;
 pub const EGL_CONTEXT_CLIENT_VERSION: EGLint = 0x3098;
+pub const EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT: EGLint = 0x3138;
+pub const EGL_LOSE_CONTEXT_ON_RESET_EXT: EGLint = 0x31BF;
+
+pub const GL_GUILTY_CONTEXT_RESET_ARB: GLenum = 0x8253;
+pub const GL_INNOCENT_CONTEXT_RESET_ARB: GLenum = 0x8254;
+pub const GL_UNKNOWN_CONTEXT_RESET_ARB: GLenum = 0x8255;
 
 pub const EGL_WIDTH: EGLint = 0x3057;
 pub const EGL_HEIGHT: EGLint = 0x3056;

src/render/ext.rs

@@ -76,6 +76,7 @@ bitflags::bitflags! {
         const MESA_CONFIGLESS_CONTEXT            = 1 << 4;
         const KHR_SURFACELESS_CONTEXT            = 1 << 5;
         const IMG_CONTEXT_PRIORITY               = 1 << 6;
+        const EXT_CREATE_CONTEXT_ROBUSTNESS      = 1 << 7;
     }
 }
 
@@ -103,6 +104,10 @@ pub(super) unsafe fn get_display_ext(dpy: EGLDisplay) -> DisplayExt {
             DisplayExt::KHR_SURFACELESS_CONTEXT,
         ),
         ("EGL_IMG_context_priority", DisplayExt::IMG_CONTEXT_PRIORITY),
+        (
+            "EGL_EXT_create_context_robustness",
+            DisplayExt::EXT_CREATE_CONTEXT_ROBUSTNESS,
+        ),
     ];
     match get_dpy_extensions(dpy) {
         Some(exts) => get_typed_ext(&exts, DisplayExt::empty(), &map),

src/render/renderer/context.rs

@@ -66,7 +66,19 @@ impl Debug for RenderContext {
     }
 }
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ResetStatus {
+    Guilty,
+    Innocent,
+    Unknown,
+    Other(u32),
+}
+
 impl RenderContext {
+    pub fn reset_status(&self) -> Option<ResetStatus> {
+        self.ctx.reset_status()
+    }
+
     pub fn from_drm_device(drm: &Drm) -> Result<Self, RenderError> {
         let nodes = drm.get_nodes()?;
         let node = match nodes

src/render/renderer/renderer.rs

@@ -198,7 +198,7 @@ impl Renderer<'_> {
             std::slice::from_ref(&pos.at_point(x, y)),
             &Color::from_rgba_straight(20, 20, 20, 255),
         );
-        if let Some(tex) = placeholder.texture() {
+        if let Some(tex) = placeholder.texture.get() {
             let x = x + (pos.width() - tex.width()) / 2;
             let y = y + (pos.height() - tex.height()) / 2;
             self.render_texture(&tex, x, y, &ARGB8888);

src/state.rs

@@ -29,7 +29,7 @@ use {
         theme::Theme,
         tree::{
             ContainerNode, ContainerSplit, DisplayNode, FloatNode, Node, NodeIds, NodeVisitorBase,
-            OutputNode, ToplevelNode, WorkspaceNode,
+            OutputNode, PlaceholderNode, ToplevelNode, WorkspaceNode,
         },
         utils::{
             asyncevent::AsyncEvent, clonecell::CloneCell, copyhashmap::CopyHashMap,
@@ -53,6 +53,7 @@ use {
         time::Duration,
     },
 };
+use crate::ifs::wl_surface::WlSurface;
 
 pub struct State {
     pub xkb_ctx: XkbContext,
@@ -62,6 +63,7 @@ pub struct State {
     pub eng: Rc<AsyncEngine>,
     pub el: Rc<EventLoop>,
     pub render_ctx: CloneCell<Option<Rc<RenderContext>>>,
+    pub render_ctx_version: NumCell<u32>,
     pub cursors: CloneCell<Option<Rc<ServerCursors>>>,
     pub wheel: Rc<Wheel>,
     pub clients: Clients,
@@ -175,34 +177,76 @@ pub struct OutputData {
 }
 
 impl State {
-    pub fn set_render_ctx(&self, ctx: &Rc<RenderContext>) {
+    pub fn set_render_ctx(&self, ctx: Option<&Rc<RenderContext>>) {
-        let cursors = match ServerCursors::load(ctx) {
+        self.render_ctx.set(ctx.cloned());
-            Ok(c) => Some(Rc::new(c)),
+        self.render_ctx_version.fetch_add(1);
-            Err(e) => {
-                log::error!("Could not load the cursors: {}", ErrorFmt(e));
-                None
-            }
-        };
-        self.cursors.set(cursors);
-        self.render_ctx.set(Some(ctx.clone()));
 
-        struct Walker;
+        {
-        impl NodeVisitorBase for Walker {
+            struct Walker;
-            fn visit_container(&mut self, node: &Rc<ContainerNode>) {
+            impl NodeVisitorBase for Walker {
-                // log::info!("set_render_ctx");
+                fn visit_container(&mut self, node: &Rc<ContainerNode>) {
-                node.schedule_compute_render_data();
+                    node.render_data.borrow_mut().titles.clear();
-                node.node_visit_children(self);
+                    node.node_visit_children(self);
+                }
+                fn visit_output(&mut self, node: &Rc<OutputNode>) {
+                    node.render_data.borrow_mut().titles.clear();
+                    node.render_data.borrow_mut().status.take();
+                    node.node_visit_children(self);
+                }
+                fn visit_float(&mut self, node: &Rc<FloatNode>) {
+                    node.title_texture.set(None);
+                    node.node_visit_children(self);
+                }
+                fn visit_placeholder(&mut self, node: &Rc<PlaceholderNode>) {
+                    node.texture.set(None);
+                    node.node_visit_children(self);
+                }
+                fn visit_surface(&mut self, node: &Rc<WlSurface>) {
+                    if let Some(buffer) = node.buffer.get() {
+                        buffer.handle_gfx_context_change();
+                    }
+                    node.node_visit_children(self);
+                }
             }
-            fn visit_output(&mut self, node: &Rc<OutputNode>) {
+            Walker.visit_display(&self.root);
-                node.update_render_data();
+            for client in self.clients.clients.borrow_mut().values() {
-                node.node_visit_children(self);
+                for buffer in client.data.objects.buffers.lock().values() {
-            }
+                    buffer.handle_gfx_context_change();
-            fn visit_float(&mut self, node: &Rc<FloatNode>) {
+                }
-                node.schedule_render_titles();
-                node.node_visit_children(self);
             }
         }
-        Walker.visit_display(&self.root);
+
+        if let Some(ctx) = ctx {
+            let cursors = match ServerCursors::load(ctx) {
+                Ok(c) => Some(Rc::new(c)),
+                Err(e) => {
+                    log::error!("Could not load the cursors: {}", ErrorFmt(e));
+                    None
+                }
+            };
+            self.cursors.set(cursors);
+
+            struct Walker;
+            impl NodeVisitorBase for Walker {
+                fn visit_container(&mut self, node: &Rc<ContainerNode>) {
+                    node.schedule_compute_render_data();
+                    node.node_visit_children(self);
+                }
+                fn visit_output(&mut self, node: &Rc<OutputNode>) {
+                    node.update_render_data();
+                    node.node_visit_children(self);
+                }
+                fn visit_float(&mut self, node: &Rc<FloatNode>) {
+                    node.schedule_render_titles();
+                    node.node_visit_children(self);
+                }
+                fn visit_placeholder(&mut self, node: &Rc<PlaceholderNode>) {
+                    node.update_texture();
+                    node.node_visit_children(self);
+                }
+            }
+            Walker.visit_display(&self.root);
+        }
 
         let seats = self.globals.seats.lock();
         for seat in seats.values() {

src/tree/placeholder.rs

@@ -22,7 +22,7 @@ pub struct PlaceholderNode {
     id: PlaceholderNodeId,
     toplevel: ToplevelData,
     destroyed: Cell<bool>,
-    texture: CloneCell<Option<Rc<Texture>>>,
+    pub texture: CloneCell<Option<Rc<Texture>>>,
 }
 
 impl PlaceholderNode {
@@ -39,13 +39,34 @@ impl PlaceholderNode {
         }
     }
 
-    pub fn texture(&self) -> Option<Rc<Texture>> {
-        self.texture.get()
-    }
-
     pub fn is_destroyed(&self) -> bool {
         self.destroyed.get()
     }
+
+    pub fn update_texture(&self) {
+        self.texture.set(None);
+        if let Some(ctx) = self.toplevel.state.render_ctx.get() {
+            let rect = self.toplevel.pos.get();
+            if rect.width() != 0 && rect.height() != 0 {
+                let font = format!("monospace {}", rect.width() / 10);
+                match text::render_fitting(
+                    &ctx,
+                    rect.height(),
+                    &font,
+                    "Fullscreen",
+                    Color::GREY,
+                    false,
+                ) {
+                    Ok(t) => {
+                        self.texture.set(Some(t));
+                    }
+                    Err(e) => {
+                        log::warn!("Could not render fullscreen texture: {}", ErrorFmt(e));
+                    }
+                }
+            }
+        }
+    }
 }
 
 impl Node for PlaceholderNode {
@@ -126,27 +147,7 @@ impl ToplevelNode for PlaceholderNode {
         if let Some(p) = self.toplevel.parent.get() {
             p.node_child_size_changed(self.deref(), rect.width(), rect.height());
         }
-        self.texture.set(None);
+        self.update_texture();
-        if let Some(ctx) = self.toplevel.state.render_ctx.get() {
-            if rect.width() != 0 && rect.height() != 0 {
-                let font = format!("monospace {}", rect.width() / 10);
-                match text::render_fitting(
-                    &ctx,
-                    rect.height(),
-                    &font,
-                    "Fullscreen",
-                    Color::GREY,
-                    false,
-                ) {
-                    Ok(t) => {
-                        self.texture.set(Some(t));
-                    }
-                    Err(e) => {
-                        log::warn!("Could not render fullscreen texture: {}", ErrorFmt(e));
-                    }
-                }
-            }
-        }
     }
 
     fn tl_close(self: Rc<Self>) {

src/video/drm/sys.rs

@@ -966,7 +966,7 @@ pub fn mode_addfb2(
         offsets,
         modifiers,
     };
-    log::info!("{:#?}", res);
+    // log::info!("{:#?}", res);
 
     unsafe {
         ioctl(fd, DRM_IOCTL_MODE_ADDFB2, &mut res)?;