diff --git a/src/backend.rs b/src/backend.rs index 406d3ab6..fbe976d6 100644 --- a/src/backend.rs +++ b/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; fn set_direct_scanout_enabled(&self, enabled: bool); fn is_render_device(&self) -> bool; + fn create_lease( + self: Rc, + lessee: Rc, + connector_ids: &[ConnectorId], + ) { + let _ = lessee; + let _ = connector_ids; + } +} + +pub trait BackendDrmLease { + fn fd(&self) -> &Rc; +} + +pub trait BackendDrmLessee { + fn created(&self, lease: Rc); } diff --git a/src/backends/metal/monitor.rs b/src/backends/metal/monitor.rs index 425c5a11..acfa51e8 100644 --- a/src/backends/metal/monitor.rs +++ b/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, dev: &Rc, _fd: Rc) { 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, dev: &Rc) { + 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()); } diff --git a/src/backends/metal/video.rs b/src/backends/metal/video.rs index 6b7637c7..1f156dbd 100644 --- a/src/backends/metal/video.rs +++ b/src/backends/metal/video.rs @@ -2,8 +2,9 @@ use { crate::{ async_engine::{Phase, SpawnedFuture}, backend::{ - BackendDrmDevice, BackendEvent, Connector, ConnectorEvent, ConnectorId, - ConnectorKernelId, DrmDeviceId, HardwareCursor, Mode, MonitorInfo, + BackendDrmDevice, BackendDrmLease, BackendDrmLessee, BackendEvent, Connector, + 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, - DrmObject, DrmPlane, DrmProperty, DrmPropertyDefinition, DrmPropertyType, - DrmVersion, PropBlob, DRM_CLIENT_CAP_ATOMIC, DRM_MODE_ATOMIC_ALLOW_MODESET, - DRM_MODE_ATOMIC_NONBLOCK, DRM_MODE_PAGE_FLIP_EVENT, + DrmCrtc, DrmEncoder, DrmError, DrmEvent, DrmFramebuffer, DrmLease, DrmMaster, + DrmModeInfo, DrmObject, DrmPlane, DrmProperty, DrmPropertyDefinition, + DrmPropertyType, DrmVersion, PropBlob, DRM_CLIENT_CAP_ATOMIC, + 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, pub direct_scanout_enabled: Cell>, pub is_nvidia: bool, + pub lease_ids: MetalLeaseIds, + pub leases: CopyHashMap, + pub leases_to_break: CopyHashMap, + pub paused: Cell, } 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, + lessee: Rc, + 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, + connectors: Vec>, + crtcs: Vec>, + planes: Vec>, + revoked: Cell, +} + +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, + id: MetalLeaseId, + fd: Rc, +} + +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 { + &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, @@ -212,13 +411,15 @@ pub struct MetalConnector { pub enabled: Cell, pub non_desktop_override: Cell>, + pub lease: Cell>, + pub can_present: Cell, pub has_damage: Cell, pub cursor_changed: Cell, pub display: RefCell, - pub connect_sent: Cell, + pub frontend_state: Cell, pub primary_plane: CloneCell>>, pub cursor_plane: CloneCell>>, @@ -387,8 +588,12 @@ impl MetalConnector { } fn send_hardware_cursor(self: &Rc) { - if !self.connect_sent.get() { - return; + match self.frontend_state.get() { + 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(); - if dd.non_desktop_effective { - return; + match self.frontend_state.get() { + FrontState::Connected { non_desktop: false } => {} + 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 - .send_event(ConnectorEvent::ModeChanged(be_mode)); + self.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, + pub lease: Cell>, + pub possible_planes: AHashMap>, pub connector: CloneCell>>, @@ -1018,6 +1300,7 @@ pub struct MetalPlane { pub possible_crtcs: u32, pub formats: AHashMap, + pub lease: Cell>, pub assigned: Cell, pub mode_w: Cell, @@ -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) -> Result {} + 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() { - if !c.enabled.get() - || old.connection != ConnectorStatus::Connected - || !old.is_same_monitor(&dd) - || c.primary_plane.is_none() != old.non_desktop_effective - { - c.on_change.send_event(ConnectorEvent::Disconnected); - c.connect_sent.set(false); - } else if preserve_any { - preserve.connectors.insert(c.id); + match c.frontend_state.get() { + FrontState::Removed | FrontState::Disconnected => {} + FrontState::Connected { .. } | FrontState::Unavailable => { + let mut disconnect = false; + // Disconnect if the connector has been disabled. + disconnect |= !c.enabled.get(); + // If the connector is connected and switched between being a non-desktop + // and desktop device, break leases and disconnect. + disconnect |= old.connection == ConnectorStatus::Connected + && (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, 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 - .on_change - .send_event(ConnectorEvent::Connected(MonitorInfo { - modes, - manufacturer: dd.monitor_manufacturer.clone(), - product: dd.monitor_name.clone(), - serial_number: dd.monitor_serial_number.clone(), - initial_mode: dd.mode.clone().unwrap().to_backend(), - width_mm: dd.mm_width as _, - height_mm: dd.mm_height as _, - non_desktop: dd.non_desktop_effective, - })); - connector.connect_sent.set(true); + connector.send_event(ConnectorEvent::Connected(MonitorInfo { + modes, + manufacturer: dd.monitor_manufacturer.clone(), + product: dd.monitor_name.clone(), + serial_number: dd.monitor_serial_number.clone(), + initial_mode: dd.mode.clone().unwrap().to_backend(), + width_mm: dd.mm_width as _, + height_mm: dd.mm_height as _, + non_desktop: dd.non_desktop_effective, + })); 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) { + dev.dev + .leases_to_break + .lock() + .retain(|_, lease| !lease.try_revoke()); + } + fn init_drm_device( &self, dev: &Rc, 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, log_mode: bool) { let dd = connector.display.borrow_mut(); - if !connector.connect_sent.get() { - self.send_connected(connector, &dd); - } - if connector.primary_plane.is_none() { - return; + self.send_connected(connector, &dd); + match connector.frontend_state.get() { + FrontState::Connected { non_desktop: false } => {} + FrontState::Connected { non_desktop: true } + | FrontState::Removed + | FrontState::Disconnected + | FrontState::Unavailable => return, } if log_mode { log::info!( diff --git a/src/tasks/connector.rs b/src/tasks/connector.rs index 67f87ade..c5fb2382 100644 --- a/src/tasks/connector.rs +++ b/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), } } diff --git a/src/video/drm.rs b/src/video/drm.rs index 78e57536..051181ba 100644 --- a/src/video/drm.rs +++ b/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_CAP_CURSOR_WIDTH, FORMAT_BLOB_CURRENT, + drm_format_modifier, drm_format_modifier_blob, get_version, revoke_lease, + 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 { @@ -242,6 +244,36 @@ impl Deref for DrmMaster { } } +pub struct DrmLease { + drm_fd: Rc, + lessee_id: u32, + lessee_fd: Rc, + revoked: Cell, +} + +impl DrmLease { + pub fn lessee_fd(&self) -> &Rc { + &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, fd: Rc) -> Self { Self { @@ -516,6 +548,18 @@ impl DrmMaster { } Ok(self.events.pop()) } + + pub fn lease(&self, objs: &[u32]) -> Result { + 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 { diff --git a/src/video/drm/sys.rs b/src/video/drm/sys.rs index 195c1029..8ad7f5e3 100644 --- a/src/video/drm/sys.rs +++ b/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::(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 { let (_, _, min) = drm_stat(fd)?; get_minor_type(min)