autocommit 2022-03-11 18:15:21 CET

src/backends/metal.rs

@@ -1,22 +1,27 @@
 mod input;
 mod monitor;
+mod video;
 
 use crate::async_engine::AsyncFd;
+use crate::backend::{Backend, InputDevice, InputDeviceId, InputEvent};
 use crate::dbus::DbusError;
+use crate::drm::drm::DrmError;
+use crate::drm::gbm::GbmError;
 use crate::libinput::device::RegisteredDevice;
 use crate::libinput::{LibInput, LibInputAdapter, LibInputError};
 use crate::logind::{LogindError, Session};
+use crate::metal::video::{MetalDrmDevice, PendingDrmDevice};
 use crate::udev::{UdevError, UdevMonitor};
 use crate::utils::copyhashmap::CopyHashMap;
-use crate::{CloneCell, State, Udev};
+use crate::utils::oserror::OsError;
+use crate::utils::syncqueue::SyncQueue;
+use crate::{CloneCell, RenderError, State, Udev};
 use std::cell::{Cell, RefCell};
 use std::ffi::{CStr, CString};
 use std::future::pending;
 use std::rc::Rc;
 use thiserror::Error;
 use uapi::{c, OwnedFd};
-use crate::backend::{Backend, InputDevice, InputDeviceId, InputEvent};
-use crate::utils::syncqueue::SyncQueue;
 
 #[derive(Debug, Error)]
 pub enum MetalError {
@@ -36,6 +41,34 @@ pub enum MetalError {
     Dup(#[source] crate::utils::oserror::OsError),
     #[error("Metal backend terminated unexpectedly")]
     UnexpectedTermination,
+    #[error("Could not create GBM device")]
+    GbmDevice(#[source] GbmError),
+    #[error("Could not create a render context")]
+    CreateRenderContex(#[source] RenderError),
+    #[error("Cannot initialize connector because no CRTC is available")]
+    NoCrtcForConnector,
+    #[error("Cannot initialize connector because no primary plane is available")]
+    NoPrimaryPlaneForConnector,
+    #[error("Cannot initialize connector because no mode is available")]
+    NoModeForConnector,
+    #[error("Could not allocate scanout buffer")]
+    ScanoutBuffer(#[source] GbmError),
+    #[error("Could not create a framebuffer")]
+    Framebuffer(#[source] DrmError),
+    #[error("Could not import a framebuffer into EGL")]
+    ImportFb(#[source] RenderError),
+    #[error("Could not configure connector chain")]
+    Configure(#[source] DrmError),
+    #[error("Could not enable atomic modesetting")]
+    AtomicModesetting(#[source] OsError),
+    #[error("Could not inspect a plane")]
+    CreatePlane(#[source] DrmError),
+    #[error("Could not inspect a crtc")]
+    CreateCrtc(#[source] DrmError),
+    #[error("Could not inspect an encoder")]
+    CreateEncoder(#[source] DrmError),
+    #[error(transparent)]
+    DrmError(#[from] DrmError),
 }
 
 pub async fn run(state: Rc<State>) -> MetalError {
@@ -45,6 +78,8 @@ pub async fn run(state: Rc<State>) -> MetalError {
     }
 }
 
+linear_ids!(DrmIds, DrmId);
+
 struct MetalBackend {
     state: Rc<State>,
     udev: Rc<Udev>,
@@ -54,11 +89,10 @@ struct MetalBackend {
     libinput_fd: AsyncFd,
     device_holder: Rc<DeviceHolder>,
     session: Session,
+    drm_ids: DrmIds,
 }
 
-impl Backend for MetalBackend {
-
-}
+impl Backend for MetalBackend {}
 
 async fn run_(state: Rc<State>) -> Result<(), MetalError> {
     let socket = match state.dbus.system() {
@@ -73,12 +107,15 @@ async fn run_(state: Rc<State>) -> Result<(), MetalError> {
         return Err(MetalError::TakeControl(e));
     }
     let device_holder = Rc::new(DeviceHolder {
+        devices: Default::default(),
         input_devices: Default::default(),
-        input_devices_: Default::default(),
+        drm_devices: Default::default(),
+        pending_drm_devices: Default::default(),
     });
     let udev = Rc::new(Udev::new()?);
     let monitor = Rc::new(udev.create_monitor()?);
     monitor.add_match_subsystem_devtype(Some("input"), None)?;
+    monitor.add_match_subsystem_devtype(Some("drm"), None)?;
     monitor.enable_receiving()?;
     let libinput = Rc::new(LibInput::new(device_holder.clone())?);
     let monitor_fd = match uapi::fcntl_dupfd_cloexec(monitor.fd(), 0) {
@@ -98,7 +135,22 @@ async fn run_(state: Rc<State>) -> Result<(), MetalError> {
         libinput_fd,
         device_holder,
         session,
+        drm_ids: Default::default(),
     });
+    let _pause_handler = {
+        let mtl = metal.clone();
+        metal
+            .session
+            .on_pause(move |p| mtl.handle_device_pause(p))
+            .unwrap()
+    };
+    let _resume_handler = {
+        let mtl = metal.clone();
+        metal
+            .session
+            .on_resume(move |p| mtl.handle_device_resume(p))
+            .unwrap()
+    };
     let _monitor = state.eng.spawn(metal.clone().monitor_devices());
     let _events = state.eng.spawn(metal.clone().handle_libinput_events());
     if let Err(e) = metal.enumerate_devices() {
@@ -107,7 +159,7 @@ async fn run_(state: Rc<State>) -> Result<(), MetalError> {
     pending().await
 }
 
-struct MetalDevice {
+struct MetalInputDevice {
     slot: usize,
     id: InputDeviceId,
     devnum: c::dev_t,
@@ -120,9 +172,17 @@ struct MetalDevice {
     cb: CloneCell<Option<Rc<dyn Fn()>>>,
 }
 
+#[derive(Clone)]
+enum MetalDevice {
+    Input(Rc<MetalInputDevice>),
+    Drm(Rc<MetalDrmDevice>),
+}
+
 struct DeviceHolder {
-    input_devices: CopyHashMap<c::dev_t, Rc<MetalDevice>>,
-    input_devices_: RefCell<Vec<Option<Rc<MetalDevice>>>>,
+    devices: CopyHashMap<c::dev_t, MetalDevice>,
+    input_devices: RefCell<Vec<Option<Rc<MetalInputDevice>>>>,
+    drm_devices: CopyHashMap<c::dev_t, Rc<MetalDrmDevice>>,
+    pending_drm_devices: CopyHashMap<c::dev_t, PendingDrmDevice>,
 }
 
 impl LibInputAdapter for DeviceHolder {
@@ -131,8 +191,8 @@ impl LibInputAdapter for DeviceHolder {
             Ok(s) => s,
             Err(e) => return Err(LibInputError::Stat(e.into())),
         };
-        match self.input_devices.get(&stat.st_rdev) {
-            Some(d) => match d.fd.get() {
+        match self.devices.get(&stat.st_rdev) {
+            Some(MetalDevice::Input(d)) => match d.fd.get() {
                 Some(fd) => match uapi::fcntl_dupfd_cloexec(fd.raw(), 0) {
                     Ok(fd) => Ok(fd),
                     Err(e) => Err(LibInputError::DupFd(e.into())),
@@ -144,7 +204,7 @@ impl LibInputAdapter for DeviceHolder {
     }
 }
 
-impl InputDevice for MetalDevice {
+impl InputDevice for MetalInputDevice {
     fn id(&self) -> InputDeviceId {
         self.id
     }
@@ -166,7 +226,7 @@ impl InputDevice for MetalDevice {
     }
 }
 
-impl MetalDevice {
+impl MetalInputDevice {
     fn event(&self, event: InputEvent) {
         self.events.push(event);
         if let Some(cb) = self.cb.get() {

src/backends/metal/input.rs

@@ -1,35 +1,38 @@
 use crate::async_engine::FdStatus;
+use crate::backend::{InputEvent, KeyState};
+use crate::libinput::consts::LIBINPUT_KEY_STATE_PRESSED;
 use crate::libinput::event::LibInputEvent;
 use crate::metal::MetalBackend;
 use crate::ErrorFmt;
 use std::rc::Rc;
-use crate::backend::{InputEvent, KeyState};
-use crate::libinput::consts::LIBINPUT_KEY_STATE_PRESSED;
 
 macro_rules! unpack {
-    ($slf:expr, $ev:expr) => {
+    ($slf:expr, $ev:expr) => {{
+        let slot = match $ev.device().slot() {
+            Some(s) => s,
+            _ => return,
+        };
+        let data = match $slf
+            .device_holder
+            .input_devices
+            .borrow_mut()
+            .get(slot)
+            .cloned()
+            .and_then(|v| v)
         {
-            let slot = match $ev.device().slot() {
-                Some(s) => s,
-                _ => return,
-            };
-            let data = match $slf.device_holder.input_devices_.borrow_mut().get(slot).cloned().and_then(|v| v) {
-                Some(d) => d,
-                _ => return,
-            };
-            data
-        }
-    };
-    ($slf:expr, $ev:expr, $conv:ident) => {
-        {
-            let event = match $ev.$conv() {
-                Some(e) => e,
-                _ => return,
-            };
-            let data = unpack!($slf, $ev);
-            (event, data)
-        }
-    };
+            Some(d) => d,
+            _ => return,
+        };
+        data
+    }};
+    ($slf:expr, $ev:expr, $conv:ident) => {{
+        let event = match $ev.$conv() {
+            Some(e) => e,
+            _ => return,
+        };
+        let data = unpack!($slf, $ev);
+        (event, data)
+    }};
 }
 
 impl MetalBackend {
@@ -65,7 +68,7 @@ impl MetalBackend {
 
         match event.ty() {
             c::LIBINPUT_EVENT_DEVICE_ADDED => self.handle_device_added(event),
-            c::LIBINPUT_EVENT_DEVICE_REMOVED => self.handle_device_removed(event),
+            c::LIBINPUT_EVENT_DEVICE_REMOVED => self.handle_li_device_removed(event),
             c::LIBINPUT_EVENT_KEYBOARD_KEY => self.handle_keyboard_key(event),
             c::LIBINPUT_EVENT_POINTER_MOTION => self.handle_pointer_motion(event),
             _ => {}
@@ -76,10 +79,9 @@ impl MetalBackend {
         // let dev = unpack!(self, event);
     }
 
-    fn handle_device_removed(self: &Rc<Self>, event: LibInputEvent) {
+    fn handle_li_device_removed(self: &Rc<Self>, event: LibInputEvent) {
         let dev = unpack!(self, event);
-        self.device_holder.input_devices.remove(&dev.devnum);
-        self.device_holder.input_devices_.borrow_mut()[dev.slot] = None;
+        dev.inputdev.set(None);
         event.device().unset_slot();
     }
 

src/backends/metal/monitor.rs

@@ -1,11 +1,29 @@
-use std::cell::Cell;
 use crate::async_engine::FdStatus;
+use crate::backend::BackendEvent;
 use crate::dbus::TRUE;
-use crate::metal::{MetalBackend, MetalDevice, MetalError};
+use crate::drm::drm::DrmMaster;
+use crate::metal::video::PendingDrmDevice;
+use crate::metal::{MetalBackend, MetalDevice, MetalDrmDevice, MetalError, MetalInputDevice};
+use crate::org::freedesktop::login1::session::{PauseDevice, ResumeDevice};
 use crate::udev::UdevDevice;
 use crate::ErrorFmt;
+use bstr::ByteSlice;
+use std::cell::Cell;
 use std::rc::Rc;
-use crate::backend::BackendEvent;
+use uapi::{c, OwnedFd};
+
+const DRM: &[u8] = b"drm";
+const INPUT: &[u8] = b"input";
+const EVENT: &[u8] = b"event";
+
+const CARD: &[u8] = b"card";
+
+fn is_primary_node(n: &[u8]) -> bool {
+    match n.strip_prefix(CARD) {
+        Some(r) => r.iter().copied().all(|c| matches!(c, b'0'..=b'9')),
+        _ => false,
+    }
+}
 
 impl MetalBackend {
     pub async fn monitor_devices(self: Rc<Self>) {
@@ -25,58 +43,215 @@ impl MetalBackend {
                 _ => {}
             }
             while let Some(dev) = self.monitor.receive_device() {
-                log::info!("x {:?}", dev.devnode());
+                let action = match dev.action() {
+                    Some(c) => c,
+                    _ => continue,
+                };
+                match action.to_bytes() {
+                    b"add" => self.handle_device_add(dev),
+                    b"change" => self.handle_device_change(dev),
+                    _ => None,
+                };
             }
         }
         log::error!("Monitor task exited. Future hotplug events will be ignored.");
     }
 
+    pub fn handle_device_pause(self: &Rc<Self>, pause: PauseDevice) {
+        if pause.ty == "pause" {
+            self.session.device_paused(pause.major, pause.minor);
+        }
+        let dev = uapi::makedev(pause.major as _, pause.minor as _);
+        if pause.ty == "gone" {
+            self.handle_device_removed(dev);
+        } else {
+            self.handle_device_paused(dev);
+        }
+    }
+
+    pub fn handle_device_resume(self: &Rc<Self>, resume: ResumeDevice) {
+        let dev = uapi::makedev(resume.major as _, resume.minor as _);
+        let dev = match self.device_holder.devices.get(&dev) {
+            Some(d) => d,
+            _ => return,
+        };
+        match dev {
+            MetalDevice::Input(id) => self.handle_input_device_resume(&id, resume.fd),
+            MetalDevice::Drm(dd) => self.handle_drm_device_resume(&dd, resume.fd),
+        }
+    }
+
+    fn handle_drm_device_resume(self: &Rc<Self>, dev: &Rc<MetalDrmDevice>, fd: Rc<OwnedFd>) {
+        log::info!("Device resumed: {}", dev.dev.devnode.to_bytes().as_bstr());
+    }
+
+    fn handle_input_device_resume(self: &Rc<Self>, dev: &Rc<MetalInputDevice>, fd: Rc<OwnedFd>) {
+        log::info!("Device resumed: {}", dev.devnode.to_bytes().as_bstr());
+        dev.fd.set(Some(fd));
+        let inputdev = match self.libinput.open(dev.devnode.as_c_str()) {
+            Ok(d) => d,
+            Err(_) => return,
+        };
+        inputdev.device().set_slot(dev.slot);
+        dev.inputdev.set(Some(inputdev));
+    }
+
+    fn handle_device_removed(self: &Rc<Self>, dev: c::dev_t) {
+        let dev = match self.device_holder.devices.remove(&dev) {
+            Some(d) => d,
+            _ => return,
+        };
+        match dev {
+            MetalDevice::Input(id) => self.handle_input_device_removed(&id),
+            MetalDevice::Drm(dd) => self.handle_drm_device_removed(&dd),
+        }
+    }
+
+    fn handle_drm_device_removed(self: &Rc<Self>, dev: &Rc<MetalDrmDevice>) {
+        log::info!("Device removed: {}", dev.dev.devnode.to_bytes().as_bstr());
+    }
+
+    fn handle_input_device_removed(self: &Rc<Self>, dev: &Rc<MetalInputDevice>) {
+        log::info!("Device removed: {}", dev.devnode.to_bytes().as_bstr());
+        self.device_holder.input_devices.borrow_mut()[dev.slot] = None;
+        dev.fd.set(None);
+        if let Some(rd) = dev.inputdev.take() {
+            rd.device().unset_slot();
+        }
+        dev.removed.set(true);
+        if let Some(cb) = dev.cb.take() {
+            cb();
+        }
+    }
+
+    fn handle_device_paused(self: &Rc<Self>, dev: c::dev_t) {
+        let dev = match self.device_holder.devices.get(&dev) {
+            Some(d) => d,
+            _ => return,
+        };
+        match dev {
+            MetalDevice::Input(id) => self.handle_input_device_paused(&id),
+            MetalDevice::Drm(dd) => self.handle_drm_device_paused(&dd),
+        }
+    }
+
+    fn handle_drm_device_paused(self: &Rc<Self>, dev: &Rc<MetalDrmDevice>) {
+        log::info!("Device paused: {}", dev.dev.devnode.to_bytes().as_bstr());
+    }
+
+    fn handle_input_device_paused(self: &Rc<Self>, dev: &Rc<MetalInputDevice>) {
+        log::info!("Device paused: {}", dev.devnode.to_bytes().as_bstr());
+        if let Some(rd) = dev.inputdev.take() {
+            rd.device().unset_slot();
+        }
+    }
+
+    fn handle_device_add(self: &Rc<Self>, dev: UdevDevice) -> Option<()> {
+        let ss = dev.subsystem()?;
+        match ss.to_bytes() {
+            INPUT => self.handle_input_device_add(dev),
+            DRM => self.handle_drm_add(dev),
+            _ => None,
+        }
+    }
+
+    fn handle_input_device_add(self: &Rc<Self>, dev: UdevDevice) -> Option<()> {
+        let sysname = dev.sysname()?;
+        if sysname.to_bytes().starts_with(EVENT) {
+            self.add_input_device(&dev);
+        }
+        None
+    }
+
+    fn handle_drm_add(self: &Rc<Self>, dev: UdevDevice) -> Option<()> {
+        let sysname = dev.sysname()?;
+        if !is_primary_node(sysname.to_bytes()) {
+            return None;
+        }
+        let devnum = dev.devnum();
+        let devnode = dev.devnode()?;
+        let id = self.drm_ids.next();
+        log::info!("Device added: {}", devnode.to_bytes().as_bstr());
+        let dev = PendingDrmDevice {
+            id,
+            devnum,
+            devnode: devnode.to_owned(),
+        };
+        self.device_holder.pending_drm_devices.set(devnum, dev);
+        let slf = self.clone();
+        self.session.get_device(devnum, move |res| {
+            let dev = match slf.device_holder.pending_drm_devices.remove(&devnum) {
+                Some(d) if d.id == id => d,
+                _ => return,
+            };
+            let res = match res {
+                Ok(r) => r,
+                Err(e) => {
+                    log::error!("Could not take control of drm device: {}", ErrorFmt(e));
+                    return;
+                }
+            };
+            if res.inactive == TRUE {
+                return;
+            }
+            let master = Rc::new(DrmMaster::new(res.fd.clone()));
+            let dev = match slf.creat_drm_device(dev, &master) {
+                Ok(d) => Rc::new(d),
+                Err(e) => {
+                    log::error!("Could not initialize drm device: {}", ErrorFmt(e));
+                    return;
+                }
+            };
+            slf.init_drm_device(&dev);
+            slf.device_holder
+                .drm_devices
+                .set(dev.dev.devnum, dev.clone());
+            slf.device_holder
+                .devices
+                .set(dev.dev.devnum, MetalDevice::Drm(dev.clone()));
+        });
+        None
+    }
+
+    fn handle_device_change(self: &Rc<Self>, dev: UdevDevice) -> Option<()> {
+        let ss = dev.subsystem()?;
+        log::info!("Device changed: {}", dev.devnode()?.to_bytes().as_bstr());
+        match ss.to_bytes() {
+            DRM => self.handle_drm_change(dev),
+            _ => None,
+        }
+    }
+
+    fn handle_drm_change(self: &Rc<Self>, dev: UdevDevice) -> Option<()> {
+        None
+    }
+
     pub fn enumerate_devices(self: &Rc<Self>) -> Result<(), MetalError> {
         let mut enumerate = self.udev.create_enumerate()?;
-        enumerate.add_match_subsystem("input")?;
+        enumerate.add_match_subsystem(INPUT)?;
+        enumerate.add_match_subsystem(DRM)?;
         enumerate.scan_devices()?;
         let mut entry_opt = enumerate.get_list_entry()?;
         while let Some(entry) = entry_opt.take() {
-            'inner: {
-                let device = match self.udev.create_device_from_syspath(entry.name()) {
-                    Ok(d) => d,
-                    _ => break 'inner,
-                };
-                let sysname = match device.sysname() {
-                    Ok(s) => s,
-                    _ => break 'inner,
-                };
-                if sysname.to_bytes().starts_with(b"event") {
-                    self.add_input_device(&device);
-                }
+            if let Ok(dev) = self.udev.create_device_from_syspath(entry.name()) {
+                self.handle_device_add(dev);
             }
             entry_opt = entry.next();
         }
         Ok(())
     }
 
-    fn add_input_device(self: &Rc<Self>, dev: &UdevDevice) {
+    fn add_input_device(self: &Rc<Self>, dev: &UdevDevice) -> Option<()> {
         if !dev.is_initialized() {
-            return;
+            return None;
         }
         let slf = self.clone();
         let device_id = self.state.input_device_ids.next();
         let devnum = dev.devnum();
-        let devnode = match dev.devnode() {
-            Ok(n) => n,
-            Err(e) => {
-                log::error!("Could not retrieve devnode of udev device: {}", ErrorFmt(e));
-                return;
-            }
-        };
-        let sysname = match dev.sysname() {
-            Ok(n) => n,
-            Err(e) => {
-                log::error!("Could not retrieve sysname of udev device: {}", ErrorFmt(e));
-                return;
-            }
-        };
-        let mut slots = self.device_holder.input_devices_.borrow_mut();
+        let devnode = dev.devnode()?;
+        let sysname = dev.sysname()?;
+        log::info!("Device added: {}", devnode.to_bytes().as_bstr());
+        let mut slots = self.device_holder.input_devices.borrow_mut();
         let slot = 'slot: {
             for (i, s) in slots.iter().enumerate() {
                 if s.is_none() {
@@ -86,7 +261,7 @@ impl MetalBackend {
             slots.push(None);
             slots.len() - 1
         };
-        let dev = Rc::new(MetalDevice {
+        let dev = Rc::new(MetalInputDevice {
             slot,
             id: device_id,
             devnum,
@@ -99,12 +274,14 @@ impl MetalBackend {
             cb: Default::default(),
         });
         slots[slot] = Some(dev.clone());
-        self.device_holder.input_devices.set(devnum, dev);
+        self.device_holder
+            .devices
+            .set(devnum, MetalDevice::Input(dev));
         self.session.get_device(devnum, move |res| {
-            let id = &slf.device_holder.input_devices;
-            let mut slots = slf.device_holder.input_devices_.borrow_mut();
+            let id = &slf.device_holder.devices;
+            let mut slots = slf.device_holder.input_devices.borrow_mut();
             let dev = 'dev: {
-                if let Some(dev) = id.get(&devnum) {
+                if let Some(dev) = slots[slot].clone() {
                     if dev.id == device_id {
                         break 'dev dev;
                     }
@@ -126,15 +303,14 @@ impl MetalBackend {
             dev.fd.set(Some(res.fd.clone()));
             let inputdev = match slf.libinput.open(dev.devnode.as_c_str()) {
                 Ok(d) => d,
-                Err(_) => {
-                    slots[dev.slot] = None;
-                    id.remove(&devnum);
-                    return;
-                }
+                Err(_) => return,
             };
             inputdev.device().set_slot(slot);
             dev.inputdev.set(Some(inputdev));
-            slf.state.backend_events.push(BackendEvent::NewInputDevice(dev.clone()));
+            slf.state
+                .backend_events
+                .push(BackendEvent::NewInputDevice(dev.clone()));
         });
+        None
     }
 }

src/backends/metal/video.rs

@@ -0,0 +1,615 @@
+use crate::backend::{BackendEvent, Output, OutputId};
+use crate::drm::drm::{
+    ConnectorStatus, ConnectorType, DrmBlob, DrmConnector, DrmCrtc, DrmEncoder, DrmError, DrmFb,
+    DrmFramebuffer, DrmMaster, DrmModeInfo, DrmObject, DrmPlane, DrmProperty,
+    DrmPropertyDefinition, DrmPropertyType, PropBlob, DRM_CLIENT_CAP_ATOMIC,
+    DRM_MODE_ATOMIC_ALLOW_MODESET,
+};
+use crate::drm::gbm::{GbmDevice, GBM_BO_USE_RENDERING, GBM_BO_USE_SCANOUT};
+use crate::drm::{ModifiedFormat, INVALID_MODIFIER};
+use crate::format::{Format, XRGB8888};
+use crate::metal::{DrmId, MetalBackend, MetalError};
+use crate::render::{Framebuffer, RenderContext};
+use crate::utils::bitflags::BitflagsExt;
+use crate::{CloneCell, ErrorFmt, State};
+use ahash::AHashMap;
+use bstr::{BString, ByteSlice};
+use std::cell::Cell;
+use std::ffi::CString;
+use std::fmt::{Debug, Formatter};
+use std::rc::Rc;
+use uapi::c;
+
+pub struct PendingDrmDevice {
+    pub id: DrmId,
+    pub devnum: c::dev_t,
+    pub devnode: CString,
+}
+
+#[derive(Debug)]
+pub struct MetalDrmDeviceStatic {
+    pub id: DrmId,
+    pub devnum: c::dev_t,
+    pub devnode: CString,
+    pub master: Rc<DrmMaster>,
+    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
+    pub encoders: AHashMap<DrmEncoder, Rc<MetalEncoder>>,
+    pub planes: AHashMap<DrmPlane, Rc<MetalPlane>>,
+    pub min_width: u32,
+    pub max_width: u32,
+    pub min_height: u32,
+    pub max_height: u32,
+    pub gbm: GbmDevice,
+    pub egl: Rc<RenderContext>,
+}
+
+#[derive(Debug)]
+pub struct MetalDrmDevice {
+    pub dev: Rc<MetalDrmDeviceStatic>,
+    pub connectors: AHashMap<DrmConnector, Rc<MetalConnector>>,
+}
+
+#[derive(Debug)]
+pub struct MetalConnector {
+    pub id: DrmConnector,
+    pub master: Rc<DrmMaster>,
+
+    pub output_id: OutputId,
+
+    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
+    pub modes: Vec<DrmModeInfo>,
+    pub mode: CloneCell<Option<Rc<DrmModeInfo>>>,
+
+    pub connector_type: ConnectorType,
+    pub connector_type_id: u32,
+
+    pub connection: ConnectorStatus,
+    pub mm_width: u32,
+    pub mm_height: u32,
+    pub subpixel: u32,
+
+    pub crtc_id: MutableProperty<DrmCrtc>,
+
+    pub egl_fb: CloneCell<Option<Rc<Framebuffer>>>,
+
+    pub on_change: OnChange,
+}
+
+#[derive(Default)]
+pub struct OnChange {
+    pub on_change: CloneCell<Option<Rc<dyn Fn()>>>,
+}
+
+impl Debug for OnChange {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self.on_change.get() {
+            None => f.write_str("None"),
+            Some(_) => f.write_str("Some"),
+        }
+    }
+}
+
+impl Output for MetalConnector {
+    fn id(&self) -> OutputId {
+        self.output_id
+    }
+
+    fn removed(&self) -> bool {
+        false
+    }
+
+    fn width(&self) -> i32 {
+        match self.mode.get() {
+            Some(m) => m.hdisplay as _,
+            _ => 0,
+        }
+    }
+
+    fn height(&self) -> i32 {
+        match self.mode.get() {
+            Some(m) => m.vdisplay as _,
+            _ => 0,
+        }
+    }
+
+    fn on_change(&self, cb: Rc<dyn Fn()>) {
+        self.on_change.on_change.set(Some(cb));
+    }
+}
+
+#[derive(Debug)]
+pub struct MetalCrtc {
+    pub id: DrmCrtc,
+    pub idx: usize,
+    pub master: Rc<DrmMaster>,
+
+    pub possible_planes: AHashMap<DrmPlane, Rc<MetalPlane>>,
+
+    pub connector: Cell<DrmConnector>,
+
+    pub primary_plane: Cell<DrmPlane>,
+    pub cursor_plane: Cell<DrmPlane>,
+
+    pub active: MutableProperty<bool>,
+    pub mode_id: MutableProperty<DrmBlob>,
+
+    pub mode_blob: CloneCell<Option<Rc<PropBlob>>>,
+}
+
+#[derive(Debug)]
+pub struct MetalEncoder {
+    pub id: DrmEncoder,
+    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum PlaneType {
+    Overlay,
+    Primary,
+    Cursor,
+}
+
+#[derive(Debug)]
+pub struct MetalPlane {
+    pub id: DrmPlane,
+    pub master: Rc<DrmMaster>,
+
+    pub ty: PlaneType,
+
+    pub possible_crtcs: u32,
+    pub formats: AHashMap<u32, &'static Format>,
+
+    pub fb: CloneCell<Option<Rc<DrmFramebuffer>>>,
+
+    pub fb_id: MutableProperty<DrmFb>,
+    pub crtc_id: MutableProperty<DrmCrtc>,
+    pub crtc_x: MutableProperty<i32>,
+    pub crtc_y: MutableProperty<i32>,
+    pub crtc_w: MutableProperty<i32>,
+    pub crtc_h: MutableProperty<i32>,
+    pub src_x: MutableProperty<u32>,
+    pub src_y: MutableProperty<u32>,
+    pub src_w: MutableProperty<u32>,
+    pub src_h: MutableProperty<u32>,
+}
+
+impl MetalDrmDevice {}
+
+fn get_connectors(
+    state: &State,
+    dev: &MetalDrmDeviceStatic,
+    ids: &[DrmConnector],
+) -> Result<AHashMap<DrmConnector, Rc<MetalConnector>>, DrmError> {
+    let mut connectors = AHashMap::new();
+    for connector in ids {
+        match create_connector(state, *connector, dev) {
+            Ok(e) => {
+                connectors.insert(e.id, Rc::new(e));
+            }
+            Err(e) => return Err(DrmError::CreateConnector(Box::new(e))),
+        }
+    }
+    Ok(connectors)
+}
+
+fn create_connector(
+    state: &State,
+    connector: DrmConnector,
+    dev: &MetalDrmDeviceStatic,
+) -> Result<MetalConnector, DrmError> {
+    let info = dev.master.get_connector_info(connector, true)?;
+    let mut crtcs = AHashMap::new();
+    for encoder in info.encoders {
+        if let Some(encoder) = dev.encoders.get(&encoder) {
+            for (_, crtc) in &encoder.crtcs {
+                crtcs.insert(crtc.id, crtc.clone());
+            }
+        }
+    }
+    let props = collect_properties(&dev.master, connector)?;
+    Ok(MetalConnector {
+        id: connector,
+        master: dev.master.clone(),
+        output_id: state.output_ids.next(),
+        crtcs,
+        modes: info.modes,
+        mode: Default::default(),
+        connector_type: info.connector_type.into(),
+        connector_type_id: info.connector_type_id,
+        connection: info.connection.into(),
+        mm_width: info.mm_width,
+        mm_height: info.mm_height,
+        subpixel: info.subpixel,
+        crtc_id: props.get("CRTC_ID")?.map(|v| DrmCrtc(v as _)),
+        egl_fb: Default::default(),
+        on_change: Default::default(),
+    })
+}
+
+fn create_encoder(
+    encoder: DrmEncoder,
+    master: &Rc<DrmMaster>,
+    crtcs: &AHashMap<DrmCrtc, Rc<MetalCrtc>>,
+) -> Result<MetalEncoder, DrmError> {
+    let info = master.get_encoder_info(encoder)?;
+    let mut possible = AHashMap::new();
+    for crtc in crtcs.values() {
+        if info.possible_crtcs.contains(1 << crtc.idx) {
+            possible.insert(crtc.id, crtc.clone());
+        }
+    }
+    Ok(MetalEncoder {
+        id: encoder,
+        crtcs: possible,
+    })
+}
+
+fn create_crtc(
+    crtc: DrmCrtc,
+    idx: usize,
+    master: &Rc<DrmMaster>,
+    planes: &AHashMap<DrmPlane, Rc<MetalPlane>>,
+) -> Result<MetalCrtc, DrmError> {
+    let mask = 1 << idx;
+    let mut possible_planes = AHashMap::new();
+    for plane in planes.values() {
+        if plane.possible_crtcs.contains(mask) {
+            possible_planes.insert(plane.id, plane.clone());
+        }
+    }
+    let props = collect_properties(master, crtc)?;
+    Ok(MetalCrtc {
+        id: crtc,
+        idx,
+        master: master.clone(),
+        possible_planes,
+        connector: Cell::new(DrmConnector::NONE),
+        primary_plane: Cell::new(DrmPlane::NONE),
+        cursor_plane: Cell::new(DrmPlane::NONE),
+        active: props.get("ACTIVE")?.map(|v| v == 1),
+        mode_id: props.get("MODE_ID")?.map(|v| DrmBlob(v as u32)),
+        mode_blob: Default::default(),
+    })
+}
+
+fn create_plane(plane: DrmPlane, master: &Rc<DrmMaster>) -> Result<MetalPlane, DrmError> {
+    let info = master.get_plane_info(plane)?;
+    let mut formats = AHashMap::new();
+    for format in info.format_types {
+        if let Some(f) = crate::format::formats().get(&format) {
+            formats.insert(format, *f);
+        } else {
+            // log::warn!(
+            //     "{:?} supports unknown format '{:?}'",
+            //     plane,
+            //     crate::format::debug(format)
+            // );
+        }
+    }
+    let props = collect_properties(master, plane)?;
+    let ty = match props.props.get(b"type".as_bstr()) {
+        Some((def, val)) => match &def.ty {
+            DrmPropertyType::Enum { values, .. } => 'ty: {
+                for v in values {
+                    if v.value == *val {
+                        match v.name.as_bytes() {
+                            b"Overlay" => break 'ty PlaneType::Overlay,
+                            b"Primary" => break 'ty PlaneType::Primary,
+                            b"Cursor" => break 'ty PlaneType::Cursor,
+                            _ => return Err(DrmError::UnknownPlaneType(v.name.to_owned())),
+                        }
+                    }
+                }
+                return Err(DrmError::InvalidPlaneType(*val));
+            }
+            _ => return Err(DrmError::InvalidPlaneTypeProperty),
+        },
+        _ => {
+            return Err(DrmError::MissingProperty(
+                "type".to_string().into_boxed_str(),
+            ))
+        }
+    };
+    Ok(MetalPlane {
+        id: plane,
+        master: master.clone(),
+        ty,
+        possible_crtcs: info.possible_crtcs,
+        formats,
+        fb: Default::default(),
+        fb_id: props.get("FB_ID")?.map(|v| DrmFb(v as _)),
+        crtc_id: props.get("CRTC_ID")?.map(|v| DrmCrtc(v as _)),
+        crtc_x: props.get("CRTC_X")?.map(|v| v as i32),
+        crtc_y: props.get("CRTC_Y")?.map(|v| v as i32),
+        crtc_w: props.get("CRTC_W")?.map(|v| v as i32),
+        crtc_h: props.get("CRTC_H")?.map(|v| v as i32),
+        src_x: props.get("SRC_X")?.map(|v| v as u32),
+        src_y: props.get("SRC_Y")?.map(|v| v as u32),
+        src_w: props.get("SRC_W")?.map(|v| v as u32),
+        src_h: props.get("SRC_H")?.map(|v| v as u32),
+    })
+}
+
+fn collect_properties<T: DrmObject>(
+    master: &Rc<DrmMaster>,
+    t: T,
+) -> Result<CollectedProperties, DrmError> {
+    let mut props = AHashMap::new();
+    for prop in master.get_properties(t)? {
+        let def = master.get_property(prop.id)?;
+        props.insert(def.name.clone(), (def, prop.value));
+    }
+    Ok(CollectedProperties { props })
+}
+
+struct CollectedProperties {
+    props: AHashMap<BString, (DrmPropertyDefinition, u64)>,
+}
+
+impl CollectedProperties {
+    fn get(&self, name: &str) -> Result<MutableProperty<u64>, DrmError> {
+        match self.props.get(name.as_bytes().as_bstr()) {
+            Some((def, value)) => Ok(MutableProperty {
+                id: def.id,
+                value: Cell::new(*value),
+            }),
+            _ => Err(DrmError::MissingProperty(name.to_string().into_boxed_str())),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MutableProperty<T: Copy> {
+    pub id: DrmProperty,
+    pub value: Cell<T>,
+}
+
+impl<T: Copy> MutableProperty<T> {
+    fn map<U: Copy, F>(self, f: F) -> MutableProperty<U>
+    where
+        F: FnOnce(T) -> U,
+    {
+        MutableProperty {
+            id: self.id,
+            value: Cell::new(f(self.value.into_inner())),
+        }
+    }
+}
+
+impl MetalBackend {
+    pub fn creat_drm_device(
+        &self,
+        pending: PendingDrmDevice,
+        master: &Rc<DrmMaster>,
+    ) -> Result<MetalDrmDevice, MetalError> {
+        if let Err(e) = master.set_client_cap(DRM_CLIENT_CAP_ATOMIC, 2) {
+            return Err(MetalError::AtomicModesetting(e));
+        }
+        let resources = master.get_resources()?;
+
+        let mut planes = AHashMap::new();
+        for plane in master.get_planes()? {
+            match create_plane(plane, master) {
+                Ok(p) => {
+                    planes.insert(p.id, Rc::new(p));
+                }
+                Err(e) => return Err(MetalError::CreatePlane(e)),
+            }
+        }
+
+        let mut crtcs = AHashMap::new();
+        for (idx, crtc) in resources.crtcs.iter().copied().enumerate() {
+            match create_crtc(crtc, idx, master, &planes) {
+                Ok(c) => {
+                    crtcs.insert(c.id, Rc::new(c));
+                }
+                Err(e) => return Err(MetalError::CreateCrtc(e)),
+            }
+        }
+
+        let mut encoders = AHashMap::new();
+        for encoder in resources.encoders {
+            match create_encoder(encoder, master, &crtcs) {
+                Ok(e) => {
+                    encoders.insert(e.id, Rc::new(e));
+                }
+                Err(e) => return Err(MetalError::CreateEncoder(e)),
+            }
+        }
+
+        let gbm = match GbmDevice::new(master) {
+            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 dev = MetalDrmDeviceStatic {
+            id: pending.id,
+            devnum: pending.devnum,
+            devnode: pending.devnode,
+            master: master.clone(),
+            crtcs,
+            encoders,
+            planes,
+            min_width: resources.min_width,
+            max_width: resources.max_width,
+            min_height: resources.min_height,
+            max_height: resources.max_height,
+            gbm,
+            egl,
+        };
+
+        let connectors = get_connectors(&self.state, &dev, &resources.connectors)?;
+
+        let slf = MetalDrmDevice {
+            dev: Rc::new(dev),
+            connectors,
+        };
+
+        self.reset_drm_device(&slf)?;
+
+        Ok(slf)
+    }
+
+    pub fn refresh_drm_device(&self, dev: MetalDrmDevice) -> Result<MetalDrmDevice, DrmError> {
+        let resources = dev.dev.master.get_resources()?;
+        let connectors = get_connectors(&self.state, &dev.dev, &resources.connectors)?;
+        Ok(MetalDrmDevice {
+            dev: dev.dev.clone(),
+            connectors,
+        })
+    }
+
+    fn reset_drm_device(&self, dev: &MetalDrmDevice) -> Result<(), DrmError> {
+        let mut changes = dev.dev.master.change(DRM_MODE_ATOMIC_ALLOW_MODESET);
+        for connector in dev.connectors.values() {
+            if connector.crtc_id.value.take().is_some() {
+                changes.change_object(connector.id, |c| {
+                    c.change(connector.crtc_id.id, 0);
+                })
+            }
+        }
+        for plane in dev.dev.planes.values() {
+            changes.change_object(plane.id, |c| {
+                if plane.crtc_id.value.take().is_some() {
+                    c.change(plane.crtc_id.id, 0);
+                }
+                if plane.fb_id.value.take().is_some() {
+                    c.change(plane.fb_id.id, 0);
+                }
+            })
+        }
+        for crtc in dev.dev.crtcs.values() {
+            changes.change_object(crtc.id, |c| {
+                if crtc.active.value.take() {
+                    c.change(crtc.active.id, 0);
+                }
+                if crtc.mode_id.value.take().is_some() {
+                    c.change(crtc.mode_id.id, 0);
+                }
+            })
+        }
+        if let Err(e) = changes.commit(0) {
+            return Err(DrmError::ResetFailed(Box::new(e)));
+        }
+        Ok(())
+    }
+
+    pub fn init_drm_device(&self, dev: &Rc<MetalDrmDevice>) {
+        for connector in dev.connectors.values() {
+            if let Err(e) = self.init_drm_connector(dev, connector) {
+                log::error!("Could not initialize drm connector: {}", ErrorFmt(e));
+            }
+        }
+    }
+
+    fn init_drm_connector(
+        &self,
+        dev: &Rc<MetalDrmDevice>,
+        connector: &Rc<MetalConnector>,
+    ) -> Result<(), MetalError> {
+        if connector.connection != ConnectorStatus::Connected {
+            return Ok(());
+        }
+        let crtc = 'crtc: {
+            for crtc in connector.crtcs.values() {
+                if crtc.connector.get().is_none() {
+                    break 'crtc crtc.clone();
+                }
+            }
+            return Err(MetalError::NoCrtcForConnector);
+        };
+        let primary_plane = 'plane: {
+            for plane in crtc.possible_planes.values() {
+                if plane.ty == PlaneType::Primary
+                    && plane.crtc_id.value.get().is_none()
+                    && plane.formats.contains_key(&XRGB8888.drm)
+                {
+                    break 'plane plane.clone();
+                }
+            }
+            return Err(MetalError::NoPrimaryPlaneForConnector);
+        };
+        let mode = match connector.modes.first() {
+            Some(m) => m,
+            _ => return Err(MetalError::NoModeForConnector),
+        };
+        let mode_blob = mode.create_blob(&connector.master)?;
+        let format = ModifiedFormat {
+            format: XRGB8888,
+            modifier: INVALID_MODIFIER,
+        };
+        let bo = dev.dev.gbm.create_bo(
+            mode.hdisplay as i32,
+            mode.vdisplay as i32,
+            &format,
+            GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT,
+        );
+        let bo = match bo {
+            Ok(b) => b,
+            Err(e) => return Err(MetalError::ScanoutBuffer(e)),
+        };
+        let drm_fb = match connector.master.add_fb(&bo) {
+            Ok(fb) => Rc::new(fb),
+            Err(e) => return Err(MetalError::Framebuffer(e)),
+        };
+        let egl_fb = match dev.dev.egl.dmabuf_fb(&bo.dma()) {
+            Ok(fb) => fb,
+            Err(e) => return Err(MetalError::ImportFb(e)),
+        };
+        let mut changes = connector.master.change(DRM_MODE_ATOMIC_ALLOW_MODESET);
+        changes.change_object(connector.id, |c| {
+            c.change(connector.crtc_id.id, crtc.id.0 as _);
+        });
+        changes.change_object(crtc.id, |c| {
+            c.change(crtc.active.id, 1);
+            c.change(crtc.mode_id.id, mode_blob.id().0 as _);
+        });
+        changes.change_object(primary_plane.id, |c| {
+            c.change(primary_plane.fb_id.id, drm_fb.id().0 as _);
+            c.change(primary_plane.crtc_id.id, crtc.id.0 as _);
+            c.change(primary_plane.crtc_x.id, 0);
+            c.change(primary_plane.crtc_y.id, 0);
+            c.change(primary_plane.crtc_w.id, mode.hdisplay as _);
+            c.change(primary_plane.crtc_h.id, mode.vdisplay as _);
+            c.change(primary_plane.src_x.id, 0);
+            c.change(primary_plane.src_y.id, 0);
+            c.change(primary_plane.src_w.id, (mode.hdisplay as u64) << 16);
+            c.change(primary_plane.src_h.id, (mode.vdisplay as u64) << 16);
+        });
+        if let Err(e) = changes.commit(0) {
+            return Err(MetalError::Configure(e));
+        }
+        connector.crtc_id.value.set(crtc.id);
+        connector.egl_fb.set(Some(egl_fb));
+        connector.mode.set(Some(Rc::new(mode.clone())));
+        crtc.connector.set(connector.id);
+        crtc.active.value.set(true);
+        crtc.mode_id.value.set(mode_blob.id());
+        crtc.mode_blob.set(Some(Rc::new(mode_blob)));
+        primary_plane.fb_id.value.set(drm_fb.id());
+        primary_plane.fb.set(Some(drm_fb));
+        primary_plane.crtc_id.value.set(crtc.id);
+        primary_plane.crtc_x.value.set(0);
+        primary_plane.crtc_y.value.set(0);
+        primary_plane.crtc_w.value.set(mode.hdisplay as _);
+        primary_plane.crtc_h.value.set(mode.vdisplay as _);
+        primary_plane.src_x.value.set(0);
+        primary_plane.src_y.value.set(0);
+        primary_plane.src_w.value.set((mode.hdisplay as u32) << 16);
+        primary_plane.src_h.value.set((mode.vdisplay as u32) << 16);
+        self.state
+            .backend_events
+            .push(BackendEvent::NewOutput(connector.clone()));
+        log::info!(
+            "Initialized connector {}-{} with mode {:?}",
+            connector.connector_type,
+            connector.connector_type_id,
+            mode
+        );
+        Ok(())
+    }
+}

src/backends/xorg.rs

@@ -1,4 +1,7 @@
-use crate::backend::{Backend, BackendEvent, KeyState, InputEvent, Output, OutputId, ScrollAxis, InputDeviceId, InputDevice};
+use crate::backend::{
+    Backend, BackendEvent, InputDevice, InputDeviceId, InputEvent, KeyState, Output, OutputId,
+    ScrollAxis,
+};
 use crate::drm::drm::{Drm, DrmError};
 use crate::drm::gbm::{GbmDevice, GbmError, GBM_BO_USE_RENDERING};
 use crate::drm::{ModifiedFormat, INVALID_MODIFIER};
@@ -97,7 +100,7 @@ impl XcbCon {
 
             let c = xcb.xcb_connect(ptr::null(), ptr::null_mut());
             match xcb.xcb_connection_has_error(c) {
-                0 => { },
+                0 => {}
                 n => return Err(XorgBackendError::CannotConnect(n.into())),
             }
             let errors = XcbErrorParser::new(&xcb, c);
@@ -231,7 +234,7 @@ fn get_drm(con: &XcbCon) -> Result<Drm, XorgBackendError> {
         assert!(res.nfd == 1);
         let fd = *con.dri.xcb_dri3_open_reply_fds(con.c, &mut *res);
         let fd = OwnedFd::new(fd);
-        Ok(Drm::new(fd.raw(), true)?)
+        Ok(Drm::reopen(fd.raw(), true)?)
     }
 }
 
@@ -574,10 +577,14 @@ impl XorgBackend {
             self.mouse_seats.set(info.attachment, seat.clone());
             self.state
                 .backend_events
-                .push(BackendEvent::NewInputDevice(Rc::new(XorgSeatMouse(seat.clone()))));
+                .push(BackendEvent::NewInputDevice(Rc::new(XorgSeatMouse(
+                    seat.clone(),
+                ))));
             self.state
                 .backend_events
-                .push(BackendEvent::NewInputDevice(Rc::new(XorgSeatKeyboard(seat.clone()))));
+                .push(BackendEvent::NewInputDevice(Rc::new(XorgSeatKeyboard(
+                    seat.clone(),
+                ))));
         }
     }
 
@@ -1118,7 +1125,11 @@ impl InputDevice for XorgSeatKeyboard {
                     }
                 };
                 if res.status != ffi::XCB_GRAB_STATUS_SUCCESS as _ {
-                    log::error!("Could not grab device {}: status = {}", self.0.kb, res.status);
+                    log::error!(
+                        "Could not grab device {}: status = {}",
+                        self.0.kb,
+                        res.status
+                    );
                 }
             } else {
                 let cookie = con