metal: add lease infrastructure

src/backend.rs

@@ -15,7 +15,7 @@ use {
         fmt::{Debug, Display, Formatter},
         rc::Rc,
     },
-    uapi::c,
+    uapi::{c, OwnedFd},
 };
 
 linear_ids!(ConnectorIds, ConnectorId);
@@ -103,6 +103,8 @@ pub enum ConnectorEvent {
     Disconnected,
     Removed,
     ModeChanged(Mode),
+    Unavailable,
+    Available,
 }
 
 pub trait HardwareCursor: Debug {
@@ -286,4 +288,20 @@ pub trait BackendDrmDevice {
     fn version(&self) -> Result<DrmVersion, DrmError>;
     fn set_direct_scanout_enabled(&self, enabled: bool);
     fn is_render_device(&self) -> bool;
+    fn create_lease(
+        self: Rc<Self>,
+        lessee: Rc<dyn BackendDrmLessee>,
+        connector_ids: &[ConnectorId],
+    ) {
+        let _ = lessee;
+        let _ = connector_ids;
+    }
+}
+
+pub trait BackendDrmLease {
+    fn fd(&self) -> &Rc<OwnedFd>;
+}
+
+pub trait BackendDrmLessee {
+    fn created(&self, lease: Rc<dyn BackendDrmLease>);
 }

src/backends/metal/monitor.rs

@@ -1,13 +1,15 @@
 use {
     crate::{
-        backend::BackendEvent,
+        backend::{BackendEvent, ConnectorEvent},
         backends::metal::{
-            video::{MetalDrmDeviceData, PendingDrmDevice},
+            video::{FrontState, MetalDrmDeviceData, PendingDrmDevice},
             MetalBackend, MetalDevice, MetalError, MetalInputDevice,
         },
         dbus::{DbusError, TRUE},
         udev::UdevDevice,
-        utils::{bitflags::BitflagsExt, errorfmt::ErrorFmt, nonblock::set_nonblock},
+        utils::{
+            bitflags::BitflagsExt, cell_ext::CellExt, errorfmt::ErrorFmt, nonblock::set_nonblock,
+        },
         video::drm::DrmMaster,
         wire_dbus::org::freedesktop::login1::session::{
             PauseDevice, ResumeDevice, TakeDeviceReply,
@@ -89,6 +91,18 @@ impl MetalBackend {
 
     fn handle_drm_device_resume(self: &Rc<Self>, dev: &Rc<MetalDrmDeviceData>, _fd: Rc<OwnedFd>) {
         log::info!("Device resumed: {}", dev.dev.devnode.to_bytes().as_bstr());
+        dev.dev.paused.set(false);
+        self.break_leases(dev);
+        for c in dev.connectors.lock().values() {
+            match c.frontend_state.get() {
+                FrontState::Removed | FrontState::Disconnected | FrontState::Connected { .. } => {}
+                FrontState::Unavailable => {
+                    if c.lease.is_none() {
+                        c.send_event(ConnectorEvent::Available);
+                    }
+                }
+            }
+        }
         if let Err(e) = self.resume_drm_device(dev) {
             log::error!("Could not resume drm device: {}", ErrorFmt(e));
         }
@@ -149,6 +163,21 @@ impl MetalBackend {
     }
 
     fn handle_drm_device_paused(self: &Rc<Self>, dev: &Rc<MetalDrmDeviceData>) {
+        dev.dev.paused.set(true);
+        for c in dev.connectors.lock().values() {
+            match c.frontend_state.get() {
+                FrontState::Removed
+                | FrontState::Disconnected
+                | FrontState::Unavailable
+                | FrontState::Connected { non_desktop: false } => {}
+                FrontState::Connected { non_desktop: true } => {
+                    c.send_event(ConnectorEvent::Unavailable);
+                }
+            }
+        }
+        for (lease_id, lease) in dev.dev.leases.lock().drain() {
+            dev.dev.leases_to_break.set(lease_id, lease);
+        }
         log::info!("Device paused: {}", dev.dev.devnode.to_bytes().as_bstr());
     }
 

src/backends/metal/video.rs

@@ -2,8 +2,9 @@ use {
     crate::{
         async_engine::{Phase, SpawnedFuture},
         backend::{
-            BackendDrmDevice, BackendEvent, Connector, ConnectorEvent, ConnectorId,
+            BackendDrmDevice, BackendDrmLease, BackendDrmLessee, BackendEvent, Connector,
-            ConnectorKernelId, DrmDeviceId, HardwareCursor, Mode, MonitorInfo,
+            ConnectorEvent, ConnectorId, ConnectorKernelId, DrmDeviceId, HardwareCursor, Mode,
+            MonitorInfo,
         },
         backends::metal::{MetalBackend, MetalError},
         drm_feedback::DrmFeedback,
@@ -20,7 +21,7 @@ use {
         tree::OutputNode,
         udev::UdevDevice,
         utils::{
-            asyncevent::AsyncEvent, bitflags::BitflagsExt, clonecell::CloneCell,
+            asyncevent::AsyncEvent, bitflags::BitflagsExt, cell_ext::CellExt, clonecell::CloneCell,
             copyhashmap::CopyHashMap, debug_fn::debug_fn, errorfmt::ErrorFmt, numcell::NumCell,
             on_change::OnChange, opaque_cell::OpaqueCell, oserror::OsError,
             transform_ext::TransformExt,
@@ -29,10 +30,10 @@ use {
             dmabuf::DmaBufId,
             drm::{
                 drm_mode_modeinfo, Change, ConnectorStatus, ConnectorType, DrmBlob, DrmConnector,
-                DrmCrtc, DrmEncoder, DrmError, DrmEvent, DrmFramebuffer, DrmMaster, DrmModeInfo,
+                DrmCrtc, DrmEncoder, DrmError, DrmEvent, DrmFramebuffer, DrmLease, DrmMaster,
-                DrmObject, DrmPlane, DrmProperty, DrmPropertyDefinition, DrmPropertyType,
+                DrmModeInfo, DrmObject, DrmPlane, DrmProperty, DrmPropertyDefinition,
-                DrmVersion, PropBlob, DRM_CLIENT_CAP_ATOMIC, DRM_MODE_ATOMIC_ALLOW_MODESET,
+                DrmPropertyType, DrmVersion, PropBlob, DRM_CLIENT_CAP_ATOMIC,
-                DRM_MODE_ATOMIC_NONBLOCK, DRM_MODE_PAGE_FLIP_EVENT,
+                DRM_MODE_ATOMIC_ALLOW_MODESET, DRM_MODE_ATOMIC_NONBLOCK, DRM_MODE_PAGE_FLIP_EVENT,
             },
             gbm::{GbmDevice, GBM_BO_USE_LINEAR, GBM_BO_USE_RENDERING, GBM_BO_USE_SCANOUT},
             Modifier, INVALID_MODIFIER,
@@ -42,17 +43,22 @@ use {
     arrayvec::ArrayVec,
     bstr::{BString, ByteSlice},
     indexmap::{indexset, IndexSet},
+    isnt::std_1::collections::IsntHashMap2Ext,
     jay_config::video::GfxApi,
     std::{
         any::Any,
         cell::{Cell, RefCell},
+        collections::hash_map::Entry,
         ffi::CString,
         fmt::{Debug, Formatter},
         mem,
         ops::DerefMut,
         rc::{Rc, Weak},
     },
-    uapi::c::{self, dev_t},
+    uapi::{
+        c::{self, dev_t},
+        OwnedFd,
+    },
 };
 
 pub struct PendingDrmDevice {
@@ -88,6 +94,10 @@ pub struct MetalDrmDevice {
     pub on_change: OnChange<crate::backend::DrmEvent>,
     pub direct_scanout_enabled: Cell<Option<bool>>,
     pub is_nvidia: bool,
+    pub lease_ids: MetalLeaseIds,
+    pub leases: CopyHashMap<MetalLeaseId, MetalLeaseData>,
+    pub leases_to_break: CopyHashMap<MetalLeaseId, MetalLeaseData>,
+    pub paused: Cell<bool>,
 }
 
 impl Debug for MetalDrmDevice {
@@ -145,6 +155,120 @@ impl BackendDrmDevice for MetalDrmDevice {
     fn is_render_device(&self) -> bool {
         Some(self.id) == self.backend.ctx.get().map(|c| c.dev_id)
     }
+
+    fn create_lease(
+        self: Rc<Self>,
+        lessee: Rc<dyn BackendDrmLessee>,
+        connector_ids: &[ConnectorId],
+    ) {
+        let Some(data) = self.backend.device_holder.drm_devices.get(&self.devnum) else {
+            log::error!("Tried to create a lease for a DRM device that no longer exists");
+            return;
+        };
+        let mut connectors = vec![];
+        let mut crtcs = AHashMap::new();
+        let mut planes = AHashMap::new();
+        let mut ids = vec![];
+        for id in connector_ids {
+            let Some(connector) = data
+                .connectors
+                .lock()
+                .values()
+                .find(|c| c.connector_id == *id)
+                .cloned()
+            else {
+                log::error!("Tried to lease connector {id} but no such connector exists");
+                return;
+            };
+            let fe_state = connector.frontend_state.get();
+            match fe_state {
+                FrontState::Connected { non_desktop: true } => {}
+                FrontState::Connected { non_desktop: false }
+                | FrontState::Removed
+                | FrontState::Disconnected
+                | FrontState::Unavailable => {
+                    log::error!(
+                        "Tried to lease connector {id} but it is in an invalid state: {fe_state:?}"
+                    );
+                    return;
+                }
+            }
+            if let Some(lease_id) = connector.lease.get() {
+                match data.dev.leases_to_break.lock().entry(lease_id) {
+                    Entry::Occupied(oe) => {
+                        if oe.get().try_revoke() {
+                            oe.remove();
+                        }
+                    }
+                    _ => {
+                        log::error!("Connector is logically available for leasing, has a lease ID, and has no entry in leases_to_break");
+                    }
+                }
+            }
+            if connector.lease.is_some() {
+                log::error!("Tried to lease connector {id} but it is already leased");
+                return;
+            }
+            let dd = &*connector.display.borrow();
+            let crtc = dd.crtcs.values().find(|c| {
+                c.connector.is_none() && c.lease.is_none() && crtcs.not_contains_key(&c.id)
+            });
+            let Some(crtc) = crtc else {
+                log::error!("Tried to lease connector {id} but it has no matching unused CRTC");
+                return;
+            };
+            let plane = crtc.possible_planes.values().find(|p| {
+                !p.assigned.get()
+                    && p.lease.is_none()
+                    && planes.not_contains_key(&p.id)
+                    && p.ty == PlaneType::Primary
+            });
+            let Some(plane) = plane else {
+                log::error!("Tried to lease connector {id} but it has no matching unused plane");
+                return;
+            };
+            connectors.push(connector.clone());
+            crtcs.insert(crtc.id, crtc.clone());
+            planes.insert(plane.id, plane.clone());
+            ids.push(connector.id.0);
+            ids.push(crtc.id.0);
+            ids.push(plane.id.0);
+        }
+        let drm_lease = match self.master.lease(&ids) {
+            Ok(l) => l,
+            Err(e) => {
+                log::error!("Could not create lease: {}", ErrorFmt(e));
+                return;
+            }
+        };
+        let lease_id = self.lease_ids.next();
+        for c in &connectors {
+            c.lease.set(Some(lease_id));
+            c.send_event(ConnectorEvent::Unavailable);
+        }
+        for c in crtcs.values() {
+            c.lease.set(Some(lease_id));
+        }
+        for p in planes.values() {
+            p.lease.set(Some(lease_id));
+        }
+        let fd = drm_lease.lessee_fd().clone();
+        let lease_data = MetalLeaseData {
+            lease: drm_lease,
+            _lessee: lessee.clone(),
+            connectors,
+            crtcs: crtcs.values().cloned().collect(),
+            planes: planes.values().cloned().collect(),
+            revoked: Cell::new(false),
+        };
+        self.leases.set(lease_id, lease_data);
+        let lease = Rc::new(MetalLease {
+            dev: self.clone(),
+            id: lease_id,
+            fd,
+        });
+        lessee.created(lease);
+    }
 }
 
 pub struct HandleEvents {
@@ -196,6 +320,81 @@ impl ConnectorDisplayData {
     }
 }
 
+linear_ids!(MetalLeaseIds, MetalLeaseId, u64);
+
+pub struct MetalLeaseData {
+    lease: DrmLease,
+    _lessee: Rc<dyn BackendDrmLessee>,
+    connectors: Vec<Rc<MetalConnector>>,
+    crtcs: Vec<Rc<MetalCrtc>>,
+    planes: Vec<Rc<MetalPlane>>,
+    revoked: Cell<bool>,
+}
+
+impl MetalLeaseData {
+    fn try_revoke(&self) -> bool {
+        if self.revoked.get() {
+            return true;
+        }
+        let res = self.lease.try_revoke();
+        if res {
+            self.revoked.set(res);
+            for c in &self.connectors {
+                c.lease.take();
+            }
+            for c in &self.crtcs {
+                c.lease.take();
+            }
+            for p in &self.planes {
+                p.lease.take();
+            }
+        }
+        res
+    }
+}
+
+pub struct MetalLease {
+    dev: Rc<MetalDrmDevice>,
+    id: MetalLeaseId,
+    fd: Rc<OwnedFd>,
+}
+
+impl Drop for MetalLease {
+    fn drop(&mut self) {
+        if let Some(lease) = self.dev.leases.remove(&self.id) {
+            if !self.dev.paused.get() {
+                for c in &lease.connectors {
+                    match c.frontend_state.get() {
+                        FrontState::Removed
+                        | FrontState::Disconnected
+                        | FrontState::Connected { .. } => {}
+                        FrontState::Unavailable => {
+                            c.send_event(ConnectorEvent::Available);
+                        }
+                    }
+                }
+            }
+            if !lease.try_revoke() {
+                self.dev.leases_to_break.set(self.id, lease);
+            }
+        }
+    }
+}
+
+impl BackendDrmLease for MetalLease {
+    fn fd(&self) -> &Rc<OwnedFd> {
+        &self.fd
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FrontState {
+    Removed,
+    Disconnected,
+    Connected { non_desktop: bool },
+    Unavailable,
+}
+
 pub struct MetalConnector {
     pub id: DrmConnector,
     pub master: Rc<DrmMaster>,
@@ -212,13 +411,15 @@ pub struct MetalConnector {
     pub enabled: Cell<bool>,
     pub non_desktop_override: Cell<Option<bool>>,
 
+    pub lease: Cell<Option<MetalLeaseId>>,
+
     pub can_present: Cell<bool>,
     pub has_damage: Cell<bool>,
     pub cursor_changed: Cell<bool>,
 
     pub display: RefCell<ConnectorDisplayData>,
 
-    pub connect_sent: Cell<bool>,
+    pub frontend_state: Cell<FrontState>,
 
     pub primary_plane: CloneCell<Option<Rc<MetalPlane>>>,
     pub cursor_plane: CloneCell<Option<Rc<MetalPlane>>>,
@@ -387,8 +588,12 @@ impl MetalConnector {
     }
 
     fn send_hardware_cursor(self: &Rc<Self>) {
-        if !self.connect_sent.get() {
+        match self.frontend_state.get() {
-            return;
+            FrontState::Removed
+            | FrontState::Disconnected
+            | FrontState::Unavailable
+            | FrontState::Connected { non_desktop: true } => return,
+            FrontState::Connected { non_desktop: false } => {}
         }
         let generation = self.cursor_generation.fetch_add(1) + 1;
         let hc = match self.cursor_buffers.get() {
@@ -852,6 +1057,78 @@ impl MetalConnector {
             }
         }
     }
+
+    pub fn send_event(&self, event: ConnectorEvent) {
+        let state = self.frontend_state.get();
+        match &event {
+            ConnectorEvent::Connected(ty) => match state {
+                FrontState::Disconnected => {
+                    let non_desktop = ty.non_desktop;
+                    self.on_change.send_event(event);
+                    self.frontend_state
+                        .set(FrontState::Connected { non_desktop });
+                }
+                FrontState::Removed | FrontState::Connected { .. } | FrontState::Unavailable => {
+                    log::error!("Tried to send connected event in invalid state: {state:?}");
+                }
+            },
+            ConnectorEvent::HardwareCursor(_) | ConnectorEvent::ModeChanged(_) => match state {
+                FrontState::Connected { non_desktop: false } => {
+                    self.on_change.send_event(event);
+                }
+                FrontState::Connected { non_desktop: true }
+                | FrontState::Removed
+                | FrontState::Disconnected
+                | FrontState::Unavailable => {
+                    let name = match &event {
+                        ConnectorEvent::HardwareCursor(_) => "hardware cursor",
+                        _ => "mode change",
+                    };
+                    log::error!("Tried to send {name} event in invalid state: {state:?}");
+                }
+            },
+            ConnectorEvent::Disconnected => match state {
+                FrontState::Connected { .. } | FrontState::Unavailable => {
+                    self.on_change.send_event(event);
+                    self.frontend_state.set(FrontState::Disconnected);
+                }
+                FrontState::Removed | FrontState::Disconnected => {
+                    log::error!("Tried to send disconnected event in invalid state: {state:?}");
+                }
+            },
+            ConnectorEvent::Removed => match state {
+                FrontState::Disconnected => {
+                    self.on_change.send_event(event);
+                    self.frontend_state.set(FrontState::Removed);
+                }
+                FrontState::Removed | FrontState::Connected { .. } | FrontState::Unavailable => {
+                    log::error!("Tried to send removed event in invalid state: {state:?}");
+                }
+            },
+            ConnectorEvent::Unavailable => match state {
+                FrontState::Connected { non_desktop: true } => {
+                    self.on_change.send_event(event);
+                    self.frontend_state.set(FrontState::Unavailable);
+                }
+                FrontState::Connected { non_desktop: false }
+                | FrontState::Removed
+                | FrontState::Disconnected
+                | FrontState::Unavailable => {
+                    log::error!("Tried to send unavailable event in invalid state: {state:?}");
+                }
+            },
+            ConnectorEvent::Available => match state {
+                FrontState::Unavailable => {
+                    self.on_change.send_event(event);
+                    self.frontend_state
+                        .set(FrontState::Connected { non_desktop: true });
+                }
+                FrontState::Connected { .. } | FrontState::Removed | FrontState::Disconnected => {
+                    log::error!("Tried to send available event in invalid state: {state:?}");
+                }
+            },
+        }
+    }
 }
 
 impl Connector for MetalConnector {
@@ -908,10 +1185,14 @@ impl Connector for MetalConnector {
     }
 
     fn set_mode(&self, be_mode: Mode) {
-        let mut dd = self.display.borrow_mut();
+        match self.frontend_state.get() {
-        if dd.non_desktop_effective {
+            FrontState::Connected { non_desktop: false } => {}
-            return;
+            FrontState::Connected { non_desktop: true }
+            | FrontState::Removed
+            | FrontState::Disconnected
+            | FrontState::Unavailable => return,
         }
+        let mut dd = self.display.borrow_mut();
         let Some(mode) = dd.modes.iter().find(|m| m.to_backend() == be_mode) else {
             log::warn!("Connector does not support mode {:?}", be_mode);
             return;
@@ -932,8 +1213,7 @@ impl Connector for MetalConnector {
         dd.mode = Some(mode.clone());
         drop(dd);
         let Err(e) = self.backend.handle_drm_change_(&dev, true) else {
-            self.on_change
+            self.send_event(ConnectorEvent::ModeChanged(be_mode));
-                .send_event(ConnectorEvent::ModeChanged(be_mode));
             return;
         };
         log::warn!("Could not change mode: {}", ErrorFmt(&e));
@@ -973,6 +1253,8 @@ pub struct MetalCrtc {
     pub idx: usize,
     pub master: Rc<DrmMaster>,
 
+    pub lease: Cell<Option<MetalLeaseId>>,
+
     pub possible_planes: AHashMap<DrmPlane, Rc<MetalPlane>>,
 
     pub connector: CloneCell<Option<Rc<MetalConnector>>>,
@@ -1018,6 +1300,7 @@ pub struct MetalPlane {
     pub possible_crtcs: u32,
     pub formats: AHashMap<u32, PlaneFormat>,
 
+    pub lease: Cell<Option<MetalLeaseId>>,
     pub assigned: Cell<bool>,
 
     pub mode_w: Cell<i32>,
@@ -1085,6 +1368,7 @@ fn create_connector(
         next_buffer: Default::default(),
         enabled: Cell::new(true),
         non_desktop_override: Default::default(),
+        lease: Cell::new(None),
         can_present: Cell::new(true),
         has_damage: Cell::new(true),
         primary_plane: Default::default(),
@@ -1099,7 +1383,7 @@ fn create_connector(
         cursor_enabled: Cell::new(false),
         cursor_buffers: Default::default(),
         display: RefCell::new(display),
-        connect_sent: Cell::new(false),
+        frontend_state: Cell::new(FrontState::Disconnected),
         cursor_changed: Cell::new(false),
         cursor_front_buffer: Default::default(),
         cursor_swap_buffer: Cell::new(false),
@@ -1266,6 +1550,7 @@ fn create_crtc(
         id: crtc,
         idx,
         master: master.clone(),
+        lease: Cell::new(None),
         possible_planes,
         connector: Default::default(),
         active: props.get("ACTIVE")?.map(|v| v == 1),
@@ -1350,6 +1635,7 @@ fn create_plane(plane: DrmPlane, master: &Rc<DrmMaster>) -> Result<MetalPlane, D
         assigned: Cell::new(false),
         mode_w: Cell::new(0),
         mode_h: Cell::new(0),
+        lease: Cell::new(None),
     })
 }
 
@@ -1503,10 +1789,20 @@ impl MetalBackend {
         for c in removed_connectors {
             dev.futures.remove(&c);
             if let Some(c) = dev.connectors.remove(&c) {
-                if c.connect_sent.get() {
+                if let Some(lease_id) = c.lease.get() {
-                    c.on_change.send_event(ConnectorEvent::Disconnected);
+                    if let Some(lease) = dev.dev.leases.remove(&lease_id) {
+                        if !lease.try_revoke() {
+                            dev.dev.leases_to_break.set(lease_id, lease);
+                        }
+                    }
                 }
-                c.on_change.send_event(ConnectorEvent::Removed);
+                match c.frontend_state.get() {
+                    FrontState::Removed | FrontState::Disconnected => {}
+                    FrontState::Connected { .. } | FrontState::Unavailable => {
+                        c.send_event(ConnectorEvent::Disconnected);
+                    }
+                }
+                c.send_event(ConnectorEvent::Removed);
             }
         }
         let mut preserve = Preserve::default();
@@ -1531,16 +1827,38 @@ impl MetalBackend {
                 }
             }
             mem::swap(old.deref_mut(), &mut dd);
-            if c.connect_sent.get() {
+            match c.frontend_state.get() {
-                if !c.enabled.get()
+                FrontState::Removed | FrontState::Disconnected => {}
-                    || old.connection != ConnectorStatus::Connected
+                FrontState::Connected { .. } | FrontState::Unavailable => {
-                    || !old.is_same_monitor(&dd)
+                    let mut disconnect = false;
-                    || c.primary_plane.is_none() != old.non_desktop_effective
+                    // Disconnect if the connector has been disabled.
-                {
+                    disconnect |= !c.enabled.get();
-                    c.on_change.send_event(ConnectorEvent::Disconnected);
+                    // If the connector is connected and switched between being a non-desktop
-                    c.connect_sent.set(false);
+                    // and desktop device, break leases and disconnect.
-                } else if preserve_any {
+                    disconnect |= old.connection == ConnectorStatus::Connected
-                    preserve.connectors.insert(c.id);
+                        && (c.primary_plane.is_none() != old.non_desktop_effective);
+                    if c.lease.is_none() {
+                        // If the connector is leased, we have to be careful because DRM is
+                        // fickle with sending intermittent disconnected states while the
+                        // client performs his setup. Otherwise apply the following rules.
+
+                        // Disconnect if the connector is no longer connected.
+                        disconnect |= old.connection != ConnectorStatus::Connected;
+                        // Disconnect if the connected monitor changed.
+                        disconnect |= !old.is_same_monitor(&dd);
+                    }
+                    if disconnect {
+                        if let Some(lease_id) = c.lease.get() {
+                            if let Some(lease) = dev.dev.leases.remove(&lease_id) {
+                                if !lease.try_revoke() {
+                                    dev.dev.leases_to_break.set(lease_id, lease);
+                                }
+                            }
+                        }
+                        c.send_event(ConnectorEvent::Disconnected);
+                    } else if preserve_any {
+                        preserve.connectors.insert(c.id);
+                    }
                 }
             }
         }
@@ -1572,6 +1890,12 @@ impl MetalBackend {
     }
 
     fn send_connected(&self, connector: &Rc<MetalConnector>, dd: &ConnectorDisplayData) {
+        match connector.frontend_state.get() {
+            FrontState::Removed | FrontState::Connected { .. } | FrontState::Unavailable => {
+                return;
+            }
+            FrontState::Disconnected => {}
+        }
         let mut prev_mode = None;
         let mut modes = vec![];
         for mode in dd.modes.iter().map(|m| m.to_backend()) {
@@ -1579,19 +1903,16 @@ impl MetalBackend {
                 modes.push(mode);
             }
         }
-        connector
+        connector.send_event(ConnectorEvent::Connected(MonitorInfo {
-            .on_change
+            modes,
-            .send_event(ConnectorEvent::Connected(MonitorInfo {
+            manufacturer: dd.monitor_manufacturer.clone(),
-                modes,
+            product: dd.monitor_name.clone(),
-                manufacturer: dd.monitor_manufacturer.clone(),
+            serial_number: dd.monitor_serial_number.clone(),
-                product: dd.monitor_name.clone(),
+            initial_mode: dd.mode.clone().unwrap().to_backend(),
-                serial_number: dd.monitor_serial_number.clone(),
+            width_mm: dd.mm_width as _,
-                initial_mode: dd.mode.clone().unwrap().to_backend(),
+            height_mm: dd.mm_height as _,
-                width_mm: dd.mm_width as _,
+            non_desktop: dd.non_desktop_effective,
-                height_mm: dd.mm_height as _,
+        }));
-                non_desktop: dd.non_desktop_effective,
-            }));
-        connector.connect_sent.set(true);
         connector.send_hardware_cursor();
     }
 
@@ -1696,6 +2017,10 @@ impl MetalBackend {
             on_change: Default::default(),
             direct_scanout_enabled: Default::default(),
             is_nvidia,
+            lease_ids: Default::default(),
+            leases: Default::default(),
+            leases_to_break: Default::default(),
+            paused: Cell::new(false),
         });
 
         let (connectors, futures) = get_connectors(self, &dev, &resources.connectors)?;
@@ -2053,11 +2378,19 @@ impl MetalBackend {
         }
     }
 
+    pub fn break_leases(&self, dev: &Rc<MetalDrmDeviceData>) {
+        dev.dev
+            .leases_to_break
+            .lock()
+            .retain(|_, lease| !lease.try_revoke());
+    }
+
     fn init_drm_device(
         &self,
         dev: &Rc<MetalDrmDeviceData>,
         preserve: &mut Preserve,
     ) -> Result<(), MetalError> {
+        self.break_leases(dev);
         let ctx = match self.ctx.get() {
             Some(ctx) => ctx,
             _ => return Ok(()),
@@ -2342,7 +2675,7 @@ impl MetalBackend {
         }
         let crtc = 'crtc: {
             for crtc in dd.crtcs.values() {
-                if crtc.connector.is_none() {
+                if crtc.connector.is_none() && crtc.lease.is_none() {
                     break 'crtc crtc.clone();
                 }
             }
@@ -2390,7 +2723,8 @@ impl MetalBackend {
         };
         let (primary_plane, primary_modifiers) = 'primary_plane: {
             for plane in crtc.possible_planes.values() {
-                if plane.ty == PlaneType::Primary && !plane.assigned.get() {
+                if plane.ty == PlaneType::Primary && !plane.assigned.get() && plane.lease.is_none()
+                {
                     if let Some(format) = plane.formats.get(&XRGB8888.drm) {
                         break 'primary_plane (plane.clone(), &format.modifiers);
                     }
@@ -2412,6 +2746,7 @@ impl MetalBackend {
         for plane in crtc.possible_planes.values() {
             if plane.ty == PlaneType::Cursor
                 && !plane.assigned.get()
+                && plane.lease.is_none()
                 && plane.formats.contains_key(&ARGB8888.drm)
             {
                 if let Some(format) = plane.formats.get(&ARGB8888.drm) {
@@ -2485,11 +2820,13 @@ impl MetalBackend {
 
     fn start_connector(&self, connector: &Rc<MetalConnector>, log_mode: bool) {
         let dd = connector.display.borrow_mut();
-        if !connector.connect_sent.get() {
+        self.send_connected(connector, &dd);
-            self.send_connected(connector, &dd);
+        match connector.frontend_state.get() {
-        }
+            FrontState::Connected { non_desktop: false } => {}
-        if connector.primary_plane.is_none() {
+            FrontState::Connected { non_desktop: true }
-            return;
+            | FrontState::Removed
+            | FrontState::Disconnected
+            | FrontState::Unavailable => return,
         }
         if log_mode {
             log::info!(

src/tasks/connector.rs

@@ -317,7 +317,8 @@ impl ConnectorHandler {
             while let Some(event) = self.data.connector.event() {
                 match event {
                     ConnectorEvent::Disconnected => break 'outer,
-                    ConnectorEvent::HardwareCursor(None) => {}
+                    ConnectorEvent::Available => {}
+                    ConnectorEvent::Unavailable => {}
                     ev => unreachable!("received unexpected event {:?}", ev),
                 }
             }

src/video/drm.rs

@@ -21,7 +21,7 @@ use {
     bstr::{BString, ByteSlice},
     indexmap::IndexSet,
     std::{
-        cell::RefCell,
+        cell::{Cell, RefCell},
         ffi::CString,
         fmt::{Debug, Display, Formatter},
         mem::{self, MaybeUninit},
@@ -40,8 +40,8 @@ use crate::{
     video::{
         dmabuf::DmaBuf,
         drm::sys::{
-            drm_format_modifier, drm_format_modifier_blob, get_version, DRM_CAP_CURSOR_HEIGHT,
+            drm_format_modifier, drm_format_modifier_blob, get_version, revoke_lease,
-            DRM_CAP_CURSOR_WIDTH, FORMAT_BLOB_CURRENT,
+            DRM_CAP_CURSOR_HEIGHT, DRM_CAP_CURSOR_WIDTH, FORMAT_BLOB_CURRENT,
         },
         Modifier, INVALID_MODIFIER,
     },
@@ -137,6 +137,8 @@ pub enum DrmError {
     Merge(#[source] OsError),
     #[error("Could not import a sync file into a sync obj")]
     ImportSyncFile(#[source] OsError),
+    #[error("Could not create a lease")]
+    CreateLease(#[source] OsError),
 }
 
 fn render_node_name(fd: c::c_int) -> Result<Ustring, DrmError> {
@@ -242,6 +244,36 @@ impl Deref for DrmMaster {
     }
 }
 
+pub struct DrmLease {
+    drm_fd: Rc<OwnedFd>,
+    lessee_id: u32,
+    lessee_fd: Rc<OwnedFd>,
+    revoked: Cell<bool>,
+}
+
+impl DrmLease {
+    pub fn lessee_fd(&self) -> &Rc<OwnedFd> {
+        &self.lessee_fd
+    }
+
+    pub fn try_revoke(&self) -> bool {
+        if self.revoked.get() {
+            return true;
+        }
+        match revoke_lease(self.drm_fd.raw(), self.lessee_id) {
+            Ok(_) => {
+                log::info!("Revoked lease {}/{}", self.drm_fd.raw(), self.lessee_id);
+                self.revoked.set(true);
+                true
+            }
+            Err(e) => {
+                log::error!("Could not revoke lease: {}", ErrorFmt(e));
+                false
+            }
+        }
+    }
+}
+
 impl DrmMaster {
     pub fn new(ring: &Rc<IoUring>, fd: Rc<OwnedFd>) -> Self {
         Self {
@@ -516,6 +548,18 @@ impl DrmMaster {
         }
         Ok(self.events.pop())
     }
+
+    pub fn lease(&self, objs: &[u32]) -> Result<DrmLease, DrmError> {
+        let (fd, lessee_id) =
+            create_lease(self.raw(), objs, c::O_CLOEXEC as _).map_err(DrmError::CreateLease)?;
+        log::info!("Created lease {}/{}", self.fd.raw(), lessee_id);
+        Ok(DrmLease {
+            drm_fd: self.fd.clone(),
+            lessee_id,
+            lessee_fd: Rc::new(fd),
+            revoked: Cell::new(false),
+        })
+    }
 }
 
 pub enum DrmEvent {

src/video/drm/sys.rs

@@ -70,6 +70,21 @@ pub fn create_lease(fd: c::c_int, objects: &[u32], flags: u32) -> Result<(OwnedF
     Ok((OwnedFd::new(create.fd as _), create.lessee_id))
 }
 
+const DRM_IOCTL_MODE_REVOKE_LEASE: u64 = drm_iowr::<drm_mode_revoke_lease>(0xc9);
+
+#[repr(C)]
+struct drm_mode_revoke_lease {
+    lessee_id: u32,
+}
+
+pub fn revoke_lease(fd: c::c_int, lessee_id: u32) -> Result<(), OsError> {
+    let mut revoke = drm_mode_revoke_lease { lessee_id };
+    unsafe {
+        ioctl(fd, DRM_IOCTL_MODE_REVOKE_LEASE, &mut revoke)?;
+    }
+    Ok(())
+}
+
 pub fn get_node_type_from_fd(fd: c::c_int) -> Result<NodeType, OsError> {
     let (_, _, min) = drm_stat(fd)?;
     get_minor_type(min)