entailz/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

Merge pull request #186 from mahkoh/drm-lease

Browse source 
wayland: implement wp-drm-lease-v1
This commit is contained in:
mahkoh 2024-04-26 22:52:32 +02:00 • committed by GitHub
commit fe2663fca3
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
41 changed files with 1622 additions and 170 deletions
Download patch file Download diff file Expand all files Collapse all files

2
deploy-notes.md
View file

@ -1,5 +1,7 @@
# Unreleased
- Needs jay-compositor release.
# 1.1.0
- Needs jay-config release.

5
docs/features.md
View file

@ -118,6 +118,10 @@ You can explicitly opt into giving applications access to privileged protocols v
Jay's shortcut system allows you to execute an action when a key is pressed and to execute a different action when the key is released.
## VR
Jay's supports leasing VR headsets to applications.
## Protocol Support
Jay supports the following wayland protocols:
@ -139,6 +143,7 @@ Jay supports the following wayland protocols:
| wp_alpha_modifier_v1 | 1 | |
| wp_content_type_manager_v1 | 1 | |
| wp_cursor_shape_manager_v1 | 1 | |
| wp_drm_lease_device_v1 | 1 | |
| wp_fractional_scale_manager_v1 | 1 | |
| wp_linux_drm_syncobj_manager_v1 | 1 | |
| wp_presentation | 1 | |

1
release-notes.md
View file

@ -3,6 +3,7 @@
- Add support for wp-security-manager-v1.
- Add support for xdg-dialog-v1.
- Add support for ext-transient-seat-v1.
- Add support for wp-drm-lease-v1.
# 1.1.0 (2024-04-22)

4
src/acceptor.rs
View file

@ -1,7 +1,7 @@
use {
crate::{
async_engine::SpawnedFuture,
client::{ClientCaps, CAP_LAYER_SHELL},
client::{ClientCaps, CAPS_DEFAULT},
state::State,
utils::{errorfmt::ErrorFmt, oserror::OsError, xrd::xrd},
},
@ -154,7 +154,7 @@ impl Acceptor {
state.eng.spawn(accept(
acc.socket.insecure.clone(),
state.clone(),
CAP_LAYER_SHELL,
CAPS_DEFAULT,
)),
];
state.acceptor.set(Some(acc.clone()));

29
src/backend.rs
View file

@ -6,7 +6,7 @@ use {
gfx_api::{GfxFramebuffer, SyncFile},
ifs::wl_seat::wl_pointer::{CONTINUOUS, FINGER, HORIZONTAL_SCROLL, VERTICAL_SCROLL, WHEEL},
libinput::consts::DeviceCapability,
video::drm::{ConnectorType, DrmError, DrmVersion},
video::drm::{ConnectorType, DrmConnector, DrmError, DrmVersion},
},
jay_config::video::GfxApi,
std::{
@ -15,7 +15,7 @@ use {
fmt::{Debug, Display, Formatter},
rc::Rc,
},
uapi::c,
uapi::{c, OwnedFd},
};
linear_ids!(ConnectorIds, ConnectorId);
@ -59,6 +59,7 @@ pub struct MonitorInfo {
pub initial_mode: Mode,
pub width_mm: i32,
pub height_mm: i32,
pub non_desktop: bool,
}
#[derive(Copy, Clone, Debug)]
@ -90,6 +91,12 @@ pub trait Connector {
None
}
fn set_mode(&self, mode: Mode);
fn set_non_desktop_override(&self, non_desktop: Option<bool>) {
let _ = non_desktop;
}
fn drm_object_id(&self) -> Option<DrmConnector> {
None
}
}
#[derive(Debug)]
@ -99,6 +106,8 @@ pub enum ConnectorEvent {
Disconnected,
Removed,
ModeChanged(Mode),
Unavailable,
Available,
}
pub trait HardwareCursor: Debug {
@ -282,4 +291,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>);
}

35
src/backends/metal/monitor.rs
View file

@ -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());
}

529
src/backends/metal/video.rs
View file

@ -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 {
@ -67,7 +73,6 @@ pub struct MetalRenderContext {
pub gfx: Rc<dyn GfxContext>,
}
#[derive(Debug)]
pub struct MetalDrmDevice {
pub backend: Rc<MetalBackend>,
pub id: DrmDeviceId,
@ -89,6 +94,16 @@ 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 {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetalDrmDevice").finish_non_exhaustive()
}
}
impl MetalDrmDevice {
@ -140,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 {
@ -167,6 +296,8 @@ pub struct ConnectorDisplayData {
pub modes: Vec<DrmModeInfo>,
pub mode: Option<DrmModeInfo>,
pub refresh: u32,
pub non_desktop: bool,
pub non_desktop_effective: bool,
pub monitor_manufacturer: String,
pub monitor_name: String,
@ -189,7 +320,81 @@ impl ConnectorDisplayData {
}
}
#[derive(Debug)]
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>,
@ -204,6 +409,9 @@ pub struct MetalConnector {
pub next_buffer: NumCell<usize>,
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>,
@ -211,7 +419,7 @@ pub struct MetalConnector {
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>>>,
@ -240,7 +448,12 @@ pub struct MetalConnector {
pub direct_scanout_active: Cell<bool>,
}
#[derive(Debug)]
impl Debug for MetalConnector {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetalConnnector").finish_non_exhaustive()
}
}
pub struct MetalHardwareCursor {
pub generation: u64,
pub connector: Rc<MetalConnector>,
@ -253,6 +466,13 @@ pub struct MetalHardwareCursor {
pub have_changes: Cell<bool>,
}
impl Debug for MetalHardwareCursor {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetalHardwareCursor")
.finish_non_exhaustive()
}
}
impl HardwareCursor for MetalHardwareCursor {
fn set_enabled(&self, enabled: bool) {
if self.cursor_enabled_pending.replace(enabled) != enabled {
@ -368,8 +588,12 @@ impl MetalConnector {
}
fn send_hardware_cursor(self: &Rc<Self>) {
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() {
@ -392,9 +616,7 @@ impl MetalConnector {
fn connected(&self) -> bool {
let dd = self.display.borrow_mut();
self.enabled.get()
&& dd.connection == ConnectorStatus::Connected
&& self.primary_plane.is_some()
self.enabled.get() && dd.connection == ConnectorStatus::Connected
}
pub fn schedule_present(&self) {
@ -835,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 {
@ -891,6 +1185,13 @@ impl Connector for MetalConnector {
}
fn set_mode(&self, be_mode: Mode) {
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);
@ -912,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));
@ -927,14 +1227,38 @@ impl Connector for MetalConnector {
log::warn!("Could not restore the previous mode: {}", ErrorFmt(e));
};
}
fn set_non_desktop_override(&self, non_desktop: Option<bool>) {
if self.non_desktop_override.replace(non_desktop) == non_desktop {
return;
}
let mut dd = self.display.borrow_mut();
let non_desktop_effective = non_desktop.unwrap_or(dd.non_desktop);
if dd.non_desktop_effective == non_desktop_effective {
return;
}
dd.non_desktop_effective = non_desktop_effective;
drop(dd);
if let Some(dev) = self.backend.device_holder.drm_devices.get(&self.dev.devnum) {
if let Err(e) = self.backend.handle_drm_change_(&dev, true) {
dev.unprocessed_change.set(true);
log::error!("Could not override non-desktop setting: {}", ErrorFmt(e));
}
}
}
fn drm_object_id(&self) -> Option<DrmConnector> {
Some(self.id)
}
}
#[derive(Debug)]
pub struct MetalCrtc {
pub id: DrmCrtc,
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>>>,
@ -946,6 +1270,12 @@ pub struct MetalCrtc {
pub mode_blob: CloneCell<Option<Rc<PropBlob>>>,
}
impl Debug for MetalCrtc {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetalCrtc").finish_non_exhaustive()
}
}
#[derive(Debug)]
pub struct MetalEncoder {
pub id: DrmEncoder,
@ -965,7 +1295,6 @@ pub struct PlaneFormat {
modifiers: IndexSet<Modifier>,
}
#[derive(Debug)]
pub struct MetalPlane {
pub id: DrmPlane,
pub master: Rc<DrmMaster>,
@ -975,6 +1304,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>,
@ -993,6 +1323,12 @@ pub struct MetalPlane {
pub fb_id: DrmProperty,
}
impl Debug for MetalPlane {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetalPlane").finish_non_exhaustive()
}
}
fn get_connectors(
backend: &Rc<MetalBackend>,
dev: &Rc<MetalDrmDevice>,
@ -1024,7 +1360,7 @@ fn create_connector(
connector: DrmConnector,
dev: &Rc<MetalDrmDevice>,
) -> Result<(Rc<MetalConnector>, ConnectorFutures), DrmError> {
let display = create_connector_display_data(connector, dev)?;
let display = create_connector_display_data(connector, dev, None)?;
let slf = Rc::new(MetalConnector {
id: connector,
master: dev.master.clone(),
@ -1035,6 +1371,8 @@ fn create_connector(
buffers: Default::default(),
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(),
@ -1049,7 +1387,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),
@ -1072,6 +1410,7 @@ fn create_connector(
fn create_connector_display_data(
connector: DrmConnector,
dev: &Rc<MetalDrmDevice>,
non_desktop_override: Option<bool>,
) -> Result<ConnectorDisplayData, DrmError> {
let info = dev.master.get_connector_info(connector, true)?;
let mut crtcs = AHashMap::new();
@ -1158,12 +1497,15 @@ fn create_connector_display_data(
}
let props = collect_properties(&dev.master, connector)?;
let connector_type = ConnectorType::from_drm(info.connector_type);
let non_desktop = props.get("non-desktop")?.value.get() != 0;
Ok(ConnectorDisplayData {
crtc_id: props.get("CRTC_ID")?.map(|v| DrmCrtc(v as _)),
crtcs,
modes: info.modes,
mode,
refresh,
non_desktop,
non_desktop_effective: non_desktop_override.unwrap_or(non_desktop),
monitor_manufacturer: manufacturer,
monitor_name: name,
monitor_serial_number: serial_number,
@ -1212,6 +1554,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),
@ -1296,6 +1639,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),
})
}
@ -1449,15 +1793,26 @@ impl MetalBackend {
for c in removed_connectors {
dev.futures.remove(&c);
if let Some(c) = dev.connectors.remove(&c) {
if c.connect_sent.get() {
c.on_change.send_event(ConnectorEvent::Disconnected);
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.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();
for c in dev.connectors.lock().values() {
let mut dd = match create_connector_display_data(c.id, &dev.dev) {
let dd = create_connector_display_data(c.id, &dev.dev, c.non_desktop_override.get());
let mut dd = match dd {
Ok(d) => d,
Err(e) => {
log::error!(
@ -1476,15 +1831,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.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);
}
}
}
}
@ -1516,6 +1894,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()) {
@ -1523,18 +1907,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 _,
}));
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();
}
@ -1639,6 +2021,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)?;
@ -1718,8 +2104,7 @@ impl MetalBackend {
if let Err(e) = self.update_device_properties(dev) {
return Err(MetalError::UpdateProperties(e));
}
let mut preserve = Preserve::default();
self.init_drm_device(dev, &mut preserve)?;
self.init_drm_device(dev, &mut Preserve::default())?;
for connector in dev.connectors.lock().values() {
if connector.primary_plane.is_some() {
connector.schedule_present();
@ -1777,11 +2162,11 @@ impl MetalBackend {
}
let dd = connector.display.borrow_mut();
{
let global = self.state.outputs.get(&connector.connector_id);
let global = self.state.root.outputs.get(&connector.connector_id);
let mut rr = connector.render_result.borrow_mut();
if let Some(g) = &global {
let refresh = dd.refresh;
let bindings = g.node.global.bindings.borrow_mut();
let bindings = g.global.bindings.borrow_mut();
for fb in rr.presentation_feedbacks.drain(..) {
if let Some(bindings) = bindings.get(&fb.client.id) {
for binding in bindings.values() {
@ -1828,6 +2213,8 @@ impl MetalBackend {
if preserve.connectors.contains(&connector.id) {
continue;
}
connector.buffers.set(None);
connector.cursor_buffers.set(None);
connector.primary_plane.set(None);
connector.cursor_plane.set(None);
connector.cursor_enabled.set(false);
@ -1985,8 +2372,7 @@ impl MetalBackend {
}
fn re_init_drm_device(&self, dev: &Rc<MetalDrmDeviceData>) {
let mut preserve = Preserve::default();
if let Err(e) = self.init_drm_device(dev, &mut preserve) {
if let Err(e) = self.init_drm_device(dev, &mut Preserve::default()) {
log::error!("Could not initialize device: {}", ErrorFmt(e));
}
for connector in dev.connectors.lock().values() {
@ -1996,11 +2382,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(()),
@ -2050,9 +2444,9 @@ impl MetalBackend {
for connector in dev.connectors.lock().values() {
let dd = connector.display.borrow_mut();
if !connector.enabled.get() || dd.connection != ConnectorStatus::Connected {
if should_ignore(connector, &dd) {
if dd.crtc_id.value.get().is_some() {
log::debug!("Connector is not connected but has an assigned crtc");
log::debug!("Connector should be ignored but has an assigned crtc");
return false;
}
continue;
@ -2280,12 +2674,12 @@ impl MetalBackend {
changes: &mut Change,
) -> Result<(), MetalError> {
let dd = connector.display.borrow_mut();
if !connector.enabled.get() || dd.connection != ConnectorStatus::Connected {
if should_ignore(connector, &dd) {
return Ok(());
}
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();
}
}
@ -2333,7 +2727,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);
}
@ -2355,6 +2750,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) {
@ -2428,8 +2824,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 } => {}
FrontState::Connected { non_desktop: true }
| FrontState::Removed
| FrontState::Disconnected
| FrontState::Unavailable => return,
}
if log_mode {
log::info!(
@ -2495,3 +2896,9 @@ fn modes_equal(a: &DrmModeInfo, b: &DrmModeInfo) -> bool {
&& a.vrefresh == b.vrefresh
&& a.flags == b.flags
}
fn should_ignore(connector: &MetalConnector, dd: &ConnectorDisplayData) -> bool {
!connector.enabled.get()
|| dd.connection != ConnectorStatus::Connected
|| dd.non_desktop_effective
}

1
src/backends/x.rs
View file

@ -574,6 +574,7 @@ impl XBackend {
},
width_mm: output.width.get(),
height_mm: output.height.get(),
non_desktop: false,
}));
output.changed();
self.present(output).await;

57
src/cli/randr.rs
View file

@ -6,7 +6,7 @@ use {
utils::transform_ext::TransformExt,
wire::{jay_compositor, jay_randr, JayRandrId},
},
clap::{Args, Subcommand},
clap::{Args, Subcommand, ValueEnum},
isnt::std_1::vec::IsntVecExt,
jay_config::video::Transform,
std::{
@ -115,6 +115,21 @@ pub enum OutputCommand {
Enable,
/// Disable the output.
Disable,
/// Override the display's non-desktop setting.
NonDesktop(NonDesktopArgs),
}
#[derive(ValueEnum, Debug, Clone)]
pub enum NonDesktopType {
Default,
False,
True,
}
#[derive(Args, Debug, Clone)]
pub struct NonDesktopArgs {
/// Whether this output is a non-desktop output.
pub setting: NonDesktopType,
}
#[derive(Args, Debug, Clone)]
@ -217,6 +232,7 @@ struct Output {
pub height_mm: i32,
pub current_mode: Option<Mode>,
pub modes: Vec<Mode>,
pub non_desktop: bool,
}
#[derive(Copy, Clone, Debug)]
@ -373,6 +389,16 @@ impl Randr {
enabled: enable as _,
});
}
OutputCommand::NonDesktop(a) => {
self.handle_error(randr, move |msg| {
eprintln!("Could not change the non-desktop setting: {}", msg);
});
tc.send(jay_randr::SetNonDesktop {
self_id: randr,
output: &args.output,
non_desktop: a.setting as _,
});
}
}
tc.round_trip().await;
}
@ -479,12 +505,16 @@ impl Randr {
println!(" product: {}", o.product);
println!(" manufacturer: {}", o.manufacturer);
println!(" serial number: {}", o.serial_number);
println!(" position: {} x {}", o.x, o.y);
println!(" logical size: {} x {}", o.width, o.height);
println!(
" physical size: {}mm x {}mm",
o.width_mm, o.height_mm
);
if o.non_desktop {
println!(" non-desktop");
return;
}
println!(" position: {} x {}", o.x, o.y);
println!(" logical size: {} x {}", o.width, o.height);
if let Some(mode) = &o.current_mode {
print!(" mode: ");
self.print_mode(mode, false);
@ -570,6 +600,27 @@ impl Randr {
height_mm: msg.height_mm,
modes: Default::default(),
current_mode: None,
non_desktop: false,
});
});
jay_randr::NonDesktopOutput::handle(tc, randr, data.clone(), |data, msg| {
let mut data = data.borrow_mut();
let c = data.connectors.last_mut().unwrap();
c.output = Some(Output {
scale: 1.0,
width: 0,
height: 0,
x: 0,
y: 0,
transform: Transform::None,
manufacturer: msg.manufacturer.to_string(),
product: msg.product.to_string(),
serial_number: msg.serial_number.to_string(),
width_mm: msg.width_mm,
height_mm: msg.height_mm,
modes: Default::default(),
current_mode: None,
non_desktop: true,
});
});
jay_randr::Mode::handle(tc, randr, data.clone(), |data, msg| {

4
src/client.rs
View file

@ -54,8 +54,12 @@ bitflags! {
CAP_LAYER_SHELL = 1 << 6,
CAP_SCREENCOPY_MANAGER = 1 << 7,
CAP_SEAT_MANAGER = 1 << 8,
CAP_DRM_LEASE = 1 << 9,
}
pub const CAPS_DEFAULT: ClientCaps = ClientCaps(CAP_LAYER_SHELL.0 | CAP_DRM_LEASE.0);
pub const CAPS_DEFAULT_SANDBOXED: ClientCaps = ClientCaps(CAP_DRM_LEASE.0);
#[derive(Debug, Copy, Clone, Hash, Ord, PartialOrd, Eq, PartialEq)]
pub struct ClientId(u64);

9
src/client/objects.rs
View file

@ -20,6 +20,7 @@ use {
xdg_surface::{xdg_toplevel::XdgToplevel, XdgSurface},
WlSurface,
},
wp_drm_lease_connector_v1::WpDrmLeaseConnectorV1,
wp_linux_drm_syncobj_timeline_v1::WpLinuxDrmSyncobjTimelineV1,
xdg_positioner::XdgPositioner,
xdg_wm_base::XdgWmBase,
@ -32,8 +33,9 @@ use {
wire::{
JayOutputId, JayScreencastId, JayToplevelId, JayWorkspaceId, WlBufferId,
WlDataSourceId, WlOutputId, WlPointerId, WlRegionId, WlRegistryId, WlSeatId,
WlSurfaceId, WpLinuxDrmSyncobjTimelineV1Id, XdgPositionerId, XdgSurfaceId,
XdgToplevelId, XdgWmBaseId, ZwlrDataControlSourceV1Id, ZwpPrimarySelectionSourceV1Id,
WlSurfaceId, WpDrmLeaseConnectorV1Id, WpLinuxDrmSyncobjTimelineV1Id, XdgPositionerId,
XdgSurfaceId, XdgToplevelId, XdgWmBaseId, ZwlrDataControlSourceV1Id,
ZwpPrimarySelectionSourceV1Id,
},
},
std::{cell::RefCell, mem, rc::Rc},
@ -62,6 +64,7 @@ pub struct Objects {
pub timelines: CopyHashMap<WpLinuxDrmSyncobjTimelineV1Id, Rc<WpLinuxDrmSyncobjTimelineV1>>,
pub zwlr_data_sources: CopyHashMap<ZwlrDataControlSourceV1Id, Rc<ZwlrDataControlSourceV1>>,
pub jay_toplevels: CopyHashMap<JayToplevelId, Rc<JayToplevel>>,
pub drm_lease_outputs: CopyHashMap<WpDrmLeaseConnectorV1Id, Rc<WpDrmLeaseConnectorV1>>,
ids: RefCell<Vec<usize>>,
}
@ -92,6 +95,7 @@ impl Objects {
timelines: Default::default(),
zwlr_data_sources: Default::default(),
jay_toplevels: Default::default(),
drm_lease_outputs: Default::default(),
ids: RefCell::new(vec![]),
}
}
@ -126,6 +130,7 @@ impl Objects {
self.timelines.clear();
self.zwlr_data_sources.clear();
self.jay_toplevels.clear();
self.drm_lease_outputs.clear();
}
pub fn id<T>(&self, client_data: &Client) -> Result<T, ClientError>

55
src/config/handler.rs
View file

@ -514,6 +514,14 @@ impl ConfigProxyHandler {
}
}
fn get_output_node(&self, connector: Connector) -> Result<Rc<OutputNode>, CphError> {
let data = self.get_output(connector)?;
match data.node.clone() {
Some(d) => Ok(d),
_ => Err(CphError::OutputIsNotDesktop(connector)),
}
}
fn get_drm_device(&self, dev: DrmDevice) -> Result<Rc<DrmDevData>, CphError> {
match self.state.drm_devs.get(&DrmDeviceId::from_raw(dev.0 as _)) {
Some(dev) => Ok(dev),
@ -783,7 +791,7 @@ impl ConfigProxyHandler {
workspace: WorkspaceSource,
connector: Connector,
) -> Result<(), CphError> {
let output = self.get_output(connector)?;
let output = self.get_output_node(connector)?;
let ws = match workspace {
WorkspaceSource::Explicit(ws) => {
let name = self.get_workspace(ws)?;
@ -797,10 +805,10 @@ impl ConfigProxyHandler {
_ => return Ok(()),
},
};
if ws.is_dummy || output.node.is_dummy {
if ws.is_dummy || output.is_dummy {
return Ok(());
}
if ws.output.get().id == output.node.id {
if ws.output.get().id == output.id {
return Ok(());
}
let link = match &*ws.output_link.borrow() {
@ -811,8 +819,8 @@ impl ConfigProxyHandler {
make_visible_if_empty: true,
source_is_destroyed: false,
};
move_ws_to_output(&link, &output.node, config);
ws.desired_output.set(output.node.global.output_id.clone());
move_ws_to_output(&link, &output, config);
ws.desired_output.set(output.global.output_id.clone());
self.state.tree_changed();
self.state.damage();
Ok(())
@ -856,8 +864,8 @@ impl ConfigProxyHandler {
}
fn handle_connector_mode(&self, connector: Connector) -> Result<(), CphError> {
let connector = self.get_output(connector)?;
let mode = connector.node.global.mode.get();
let connector = self.get_output_node(connector)?;
let mode = connector.global.mode.get();
self.respond(Response::ConnectorMode {
width: mode.width,
height: mode.height,
@ -881,10 +889,9 @@ impl ConfigProxyHandler {
}
fn handle_connector_modes(&self, connector: Connector) -> Result<(), CphError> {
let connector = self.get_output(connector)?;
let connector = self.get_output_node(connector)?;
self.respond(Response::ConnectorModes {
modes: connector
.node
.global
.modes
.iter()
@ -964,8 +971,8 @@ impl ConfigProxyHandler {
}
fn handle_connector_size(&self, connector: Connector) -> Result<(), CphError> {
let connector = self.get_output(connector)?;
let pos = connector.node.global.pos.get();
let connector = self.get_output_node(connector)?;
let pos = connector.global.pos.get();
self.respond(Response::ConnectorSize {
width: pos.width(),
height: pos.height(),
@ -974,9 +981,9 @@ impl ConfigProxyHandler {
}
fn handle_connector_get_scale(&self, connector: Connector) -> Result<(), CphError> {
let connector = self.get_output(connector)?;
let connector = self.get_output_node(connector)?;
self.respond(Response::ConnectorGetScale {
scale: connector.node.global.persistent.scale.get().to_f64(),
scale: connector.global.persistent.scale.get().to_f64(),
});
Ok(())
}
@ -989,8 +996,8 @@ impl ConfigProxyHandler {
return Err(CphError::ScaleTooLarge(scale));
}
let scale = Scale::from_f64(scale);
let connector = self.get_output(connector)?;
connector.node.set_preferred_scale(scale);
let connector = self.get_output_node(connector)?;
connector.set_preferred_scale(scale);
self.state.damage();
Ok(())
}
@ -1000,8 +1007,8 @@ impl ConfigProxyHandler {
connector: Connector,
transform: Transform,
) -> Result<(), CphError> {
let connector = self.get_output(connector)?;
connector.node.update_transform(transform);
let connector = self.get_output_node(connector)?;
connector.update_transform(transform);
self.state.damage();
Ok(())
}
@ -1012,15 +1019,15 @@ impl ConfigProxyHandler {
x: i32,
y: i32,
) -> Result<(), CphError> {
let connector = self.get_output(connector)?;
let connector = self.get_output_node(connector)?;
if x < 0 || y < 0 || x > MAX_EXTENTS || y > MAX_EXTENTS {
return Err(CphError::InvalidConnectorPosition(x, y));
}
let old_pos = connector.node.global.pos.get();
connector.node.set_position(x, y);
let old_pos = connector.global.pos.get();
connector.set_position(x, y);
let seats = self.state.globals.seats.lock();
for seat in seats.values() {
if seat.get_output().id == connector.node.id {
if seat.get_output().id == connector.id {
let seat_pos = seat.position();
seat.set_position(
seat_pos.0.round_down() + x - old_pos.x1(),
@ -1032,8 +1039,8 @@ impl ConfigProxyHandler {
}
fn handle_connector_get_position(&self, connector: Connector) -> Result<(), CphError> {
let connector = self.get_output(connector)?;
let (x, y) = connector.node.global.pos.get().position();
let connector = self.get_output_node(connector)?;
let (x, y) = connector.global.pos.get().position();
self.respond(Response::ConnectorGetPosition { x, y });
Ok(())
}
@ -1813,6 +1820,8 @@ enum CphError {
TimerDoesNotExist(JayTimer),
#[error("Connector {0:?} does not exist or is not connected")]
OutputDoesNotExist(Connector),
#[error("Output {0:?} is not a desktop output")]
OutputIsNotDesktop(Connector),
#[error("{0}x{1} is not a valid connector position")]
InvalidConnectorPosition(i32, i32),
#[error("Keymap {0:?} does not exist")]

4
src/ifs.rs
View file

@ -41,6 +41,10 @@ pub mod wp_content_type_manager_v1;
pub mod wp_content_type_v1;
pub mod wp_cursor_shape_device_v1;
pub mod wp_cursor_shape_manager_v1;
pub mod wp_drm_lease_connector_v1;
pub mod wp_drm_lease_device_v1;
pub mod wp_drm_lease_request_v1;
pub mod wp_drm_lease_v1;
pub mod wp_fractional_scale_manager_v1;
pub mod wp_linux_drm_syncobj_manager_v1;
pub mod wp_linux_drm_syncobj_timeline_v1;

4
src/ifs/ext_session_lock_v1.rs
View file

@ -90,8 +90,8 @@ impl ExtSessionLockV1RequestHandler for ExtSessionLockV1 {
let state = &self.client.state;
state.lock.locked.set(false);
state.lock.lock.take();
for output in state.outputs.lock().values() {
if let Some(surface) = output.node.set_lock_surface(None) {
for output in state.root.outputs.lock().values() {
if let Some(surface) = output.set_lock_surface(None) {
surface.destroy_node();
}
}

4
src/ifs/jay_compositor.rs
View file

@ -220,8 +220,8 @@ impl JayCompositorRequestHandler for JayCompositor {
if let Some(lock) = state.lock.lock.take() {
lock.finish();
}
for output in state.outputs.lock().values() {
if let Some(surface) = output.node.set_lock_surface(None) {
for output in state.root.outputs.lock().values() {
if let Some(surface) = output.set_lock_surface(None) {
surface.destroy_node();
}
}

100
src/ifs/jay_randr.rs
View file

@ -7,6 +7,7 @@ use {
object::{Object, Version},
scale::Scale,
state::{ConnectorData, DrmDevData, OutputData},
tree::OutputNode,
utils::{gfx_api_ext::GfxApiExt, transform_ext::TransformExt},
wire::{jay_randr::*, JayRandrId},
},
@ -64,33 +65,47 @@ impl JayRandr {
enabled: data.connector.enabled() as _,
name: &data.name,
});
if let Some(output) = self.client.state.outputs.get(&data.connector.id()) {
let global = &output.node.global;
let pos = global.pos.get();
self.client.event(Output {
self_id: self.id,
scale: global.persistent.scale.get().to_wl(),
width: pos.width(),
height: pos.height(),
x: pos.x1(),
y: pos.y1(),
transform: global.persistent.transform.get().to_wl(),
manufacturer: &output.monitor_info.manufacturer,
product: &output.monitor_info.product,
serial_number: &output.monitor_info.serial_number,
width_mm: global.width_mm,
height_mm: global.height_mm,
});
let current_mode = global.mode.get();
for mode in &global.modes {
self.client.event(Mode {
let Some(output) = self.client.state.outputs.get(&data.connector.id()) else {
return;
};
let global = match output.node.as_ref().map(|n| &n.global) {
Some(g) => g,
_ => {
self.client.event(NonDesktopOutput {
self_id: self.id,
width: mode.width,
height: mode.height,
refresh_rate_millihz: mode.refresh_rate_millihz,
current: (mode == &current_mode) as _,
manufacturer: &output.monitor_info.manufacturer,
product: &output.monitor_info.product,
serial_number: &output.monitor_info.serial_number,
width_mm: output.monitor_info.width_mm,
height_mm: output.monitor_info.height_mm,
});
return;
}
};
let pos = global.pos.get();
self.client.event(Output {
self_id: self.id,
scale: global.persistent.scale.get().to_wl(),
width: pos.width(),
height: pos.height(),
x: pos.x1(),
y: pos.y1(),
transform: global.persistent.transform.get().to_wl(),
manufacturer: &output.monitor_info.manufacturer,
product: &output.monitor_info.product,
serial_number: &output.monitor_info.serial_number,
width_mm: global.width_mm,
height_mm: global.height_mm,
});
let current_mode = global.mode.get();
for mode in &global.modes {
self.client.event(Mode {
self_id: self.id,
width: mode.width,
height: mode.height,
refresh_rate_millihz: mode.refresh_rate_millihz,
current: (mode == &current_mode) as _,
});
}
}
@ -144,6 +159,18 @@ impl JayRandr {
}
None
}
fn get_output_node(&self, name: &str) -> Option<Rc<OutputNode>> {
let output = self.get_output(name)?;
match output.node.clone() {
Some(n) => return Some(n),
_ => self.send_error(&format!(
"Display connected to {} is not a desktop display",
output.connector.name
)),
}
None
}
}
impl JayRandrRequestHandler for JayRandr {
@ -203,22 +230,22 @@ impl JayRandrRequestHandler for JayRandr {
}
fn set_transform(&self, req: SetTransform, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let Some(c) = self.get_output(req.output) else {
let Some(c) = self.get_output_node(req.output) else {
return Ok(());
};
let Some(transform) = Transform::from_wl(req.transform) else {
self.send_error(&format!("Unknown transform {}", req.transform));
return Ok(());
};
c.node.update_transform(transform);
c.update_transform(transform);
Ok(())
}
fn set_scale(&self, req: SetScale, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let Some(c) = self.get_output(req.output) else {
let Some(c) = self.get_output_node(req.output) else {
return Ok(());
};
c.node.set_preferred_scale(Scale::from_wl(req.scale));
c.set_preferred_scale(Scale::from_wl(req.scale));
Ok(())
}
@ -235,7 +262,7 @@ impl JayRandrRequestHandler for JayRandr {
}
fn set_position(&self, req: SetPosition, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let Some(c) = self.get_output(req.output) else {
let Some(c) = self.get_output_node(req.output) else {
return Ok(());
};
if req.x < 0 || req.y < 0 {
@ -246,7 +273,7 @@ impl JayRandrRequestHandler for JayRandr {
self.send_error(&format!("x and y cannot be greater than {MAX_EXTENTS}"));
return Ok(());
}
c.node.set_position(req.x, req.y);
c.set_position(req.x, req.y);
Ok(())
}
@ -257,6 +284,19 @@ impl JayRandrRequestHandler for JayRandr {
c.connector.set_enabled(req.enabled != 0);
Ok(())
}
fn set_non_desktop(&self, req: SetNonDesktop<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let Some(c) = self.get_connector(req.output) else {
return Ok(());
};
let non_desktop = match req.non_desktop {
0 => None,
1 => Some(false),
_ => Some(true),
};
c.connector.set_non_desktop_override(non_desktop);
Ok(())
}
}
object_base! {

6
src/ifs/wl_seat.rs
View file

@ -596,10 +596,10 @@ impl WlSeatGlobal {
self.update_hardware_cursor_position();
self.trigger_tree_changed();
let output = 'set_output: {
let outputs = self.state.outputs.lock();
let outputs = self.state.root.outputs.lock();
for output in outputs.values() {
if output.node.global.pos.get().contains(x, y) {
break 'set_output output.node.clone();
if output.global.pos.get().contains(x, y) {
break 'set_output output.clone();
}
}
self.state.dummy_output.get().unwrap()

12
src/ifs/wl_seat/event_handling.rs
View file

@ -241,12 +241,12 @@ impl WlSeatGlobal {
mut x: Fixed,
mut y: Fixed,
) {
let output = match self.state.outputs.get(&connector) {
let output = match self.state.root.outputs.get(&connector) {
Some(o) => o,
_ => return,
};
self.set_output(&output.node);
let pos = output.node.global.pos.get();
self.set_output(&output);
let pos = output.global.pos.get();
x += Fixed::from_int(pos.x1());
y += Fixed::from_int(pos.y1());
if let Some(c) = self.constraint.get() {
@ -314,10 +314,10 @@ impl WlSeatGlobal {
let mut y_int = y.round_down();
if !pos.contains(x_int, y_int) {
'warp: {
let outputs = self.state.outputs.lock();
let outputs = self.state.root.outputs.lock();
for output in outputs.values() {
if output.node.global.pos.get().contains(x_int, y_int) {
self.set_output(&output.node);
if output.global.pos.get().contains(x_int, y_int) {
self.set_output(output);
break 'warp;
}
}

93
src/ifs/wp_drm_lease_connector_v1.rs Normal file
View file

@ -0,0 +1,93 @@
use {
crate::{
backend::ConnectorId as BackendConnectorId,
client::{Client, ClientError},
ifs::wp_drm_lease_device_v1::WpDrmLeaseDeviceV1,
leaks::Tracker,
object::{Object, Version},
utils::bindings::Bindings,
wire::{wp_drm_lease_connector_v1::*, WpDrmLeaseConnectorV1Id},
},
std::rc::Rc,
thiserror::Error,
};
pub struct WpDrmLeaseConnectorV1 {
pub id: WpDrmLeaseConnectorV1Id,
pub client: Rc<Client>,
pub tracker: Tracker<Self>,
pub version: Version,
pub device: Rc<WpDrmLeaseDeviceV1>,
pub connector_id: BackendConnectorId,
pub bindings: Rc<Bindings<Self>>,
}
impl WpDrmLeaseConnectorV1 {
fn detach(&self) {
self.bindings.remove(&self.client, self);
}
pub fn send_name(&self, name: &str) {
self.client.event(Name {
self_id: self.id,
name,
});
}
#[allow(dead_code)]
pub fn send_description(&self, description: &str) {
self.client.event(Description {
self_id: self.id,
description,
});
}
pub fn send_connector_id(&self, connector_id: u32) {
self.client.event(ConnectorId {
self_id: self.id,
connector_id,
});
}
pub fn send_done(&self) {
self.client.event(Done { self_id: self.id });
}
pub fn send_withdrawn(&self) {
self.client.event(Withdrawn { self_id: self.id });
}
}
impl WpDrmLeaseConnectorV1RequestHandler for WpDrmLeaseConnectorV1 {
type Error = WpDrmLeaseConnectorV1Error;
fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.detach();
self.client.remove_obj(self)?;
Ok(())
}
}
object_base! {
self = WpDrmLeaseConnectorV1;
version = self.version;
}
impl Object for WpDrmLeaseConnectorV1 {
fn break_loops(&self) {
self.detach();
}
}
dedicated_add_obj!(
WpDrmLeaseConnectorV1,
WpDrmLeaseConnectorV1Id,
drm_lease_outputs
);
#[derive(Debug, Error)]
pub enum WpDrmLeaseConnectorV1Error {
#[error(transparent)]
ClientError(Box<ClientError>),
}
efrom!(WpDrmLeaseConnectorV1Error, ClientError);

228
src/ifs/wp_drm_lease_device_v1.rs Normal file
View file

@ -0,0 +1,228 @@
use {
crate::{
backend::DrmDeviceId,
client::{Client, ClientCaps, ClientError, CAP_DRM_LEASE},
globals::{Global, GlobalName},
ifs::{
wp_drm_lease_connector_v1::WpDrmLeaseConnectorV1,
wp_drm_lease_request_v1::WpDrmLeaseRequestV1,
},
leaks::Tracker,
object::{Object, Version},
state::OutputData,
utils::{bindings::Bindings, errorfmt::ErrorFmt, oserror::OsError},
video::drm::{Drm, DrmError},
wire::{wp_drm_lease_device_v1::*, WpDrmLeaseDeviceV1Id},
},
std::{cell::Cell, rc::Rc},
thiserror::Error,
uapi::{c, OwnedFd},
};
mod removed_device;
pub struct WpDrmLeaseDeviceV1Global {
pub name: GlobalName,
pub device: DrmDeviceId,
pub bindings: Rc<Bindings<WpDrmLeaseDeviceV1>>,
}
impl WpDrmLeaseDeviceV1Global {
fn bind_(
self: Rc<Self>,
id: WpDrmLeaseDeviceV1Id,
client: &Rc<Client>,
version: Version,
) -> Result<(), WpDrmLeaseDeviceV1Error> {
let obj = Rc::new(WpDrmLeaseDeviceV1 {
id,
client: client.clone(),
tracker: Default::default(),
version,
bindings: self.bindings.clone(),
device: self.device,
destroyed: Cell::new(false),
});
track!(client, obj);
client.add_client_obj(&obj)?;
if let Some(dev) = client.state.drm_devs.get(&self.device) {
if let Some(node) = &dev.devnode {
match reopen_card(node) {
Ok(f) => obj.send_drm_fd(&f),
Err(e) => {
log::error!("Could not open master device: {}", ErrorFmt(e));
}
}
}
for c in dev.connectors.lock().keys() {
if let Some(o) = client.state.outputs.get(c) {
if o.monitor_info.non_desktop {
obj.create_connector(&o);
}
}
}
}
obj.send_done();
self.bindings.add(client, &obj);
Ok(())
}
}
global_base!(
WpDrmLeaseDeviceV1Global,
WpDrmLeaseDeviceV1,
WpDrmLeaseDeviceV1Error
);
simple_add_global!(WpDrmLeaseDeviceV1Global);
impl Global for WpDrmLeaseDeviceV1Global {
fn singleton(&self) -> bool {
false
}
fn version(&self) -> u32 {
1
}
fn break_loops(&self) {
self.bindings.clear();
}
fn required_caps(&self) -> ClientCaps {
CAP_DRM_LEASE
}
}
pub struct WpDrmLeaseDeviceV1 {
pub id: WpDrmLeaseDeviceV1Id,
pub client: Rc<Client>,
pub tracker: Tracker<Self>,
pub version: Version,
pub bindings: Rc<Bindings<Self>>,
pub device: DrmDeviceId,
pub destroyed: Cell<bool>,
}
impl WpDrmLeaseDeviceV1 {
fn detach(&self) {
self.destroyed.set(true);
self.bindings.remove(&self.client, self);
}
pub fn create_connector(self: &Rc<Self>, output: &Rc<OutputData>) {
let id = match self.client.new_id() {
Ok(i) => i,
Err(e) => {
self.client.error(e);
return;
}
};
let obj = Rc::new(WpDrmLeaseConnectorV1 {
id,
client: self.client.clone(),
tracker: Default::default(),
version: self.version,
device: self.clone(),
connector_id: output.connector.connector.id(),
bindings: output.lease_connectors.clone(),
});
self.client.add_server_obj(&obj);
self.send_connector(&obj);
obj.send_name(&output.connector.name);
if let Some(id) = output.connector.connector.drm_object_id() {
obj.send_connector_id(id.0);
}
obj.send_done();
output.lease_connectors.add(&self.client, &obj);
}
fn send_drm_fd(&self, fd: &Rc<OwnedFd>) {
self.client.event(DrmFd {
self_id: self.id,
fd: fd.clone(),
});
}
fn send_connector(&self, c: &Rc<WpDrmLeaseConnectorV1>) {
self.client.event(Connector {
self_id: self.id,
id: c.id,
});
}
pub fn send_done(&self) {
self.client.event(Done { self_id: self.id });
}
fn send_released(&self) {
self.client.event(Released { self_id: self.id });
}
}
impl WpDrmLeaseDeviceV1RequestHandler for WpDrmLeaseDeviceV1 {
type Error = WpDrmLeaseDeviceV1Error;
fn create_lease_request(
&self,
req: CreateLeaseRequest,
_slf: &Rc<Self>,
) -> Result<(), Self::Error> {
let obj = Rc::new(WpDrmLeaseRequestV1 {
id: req.id,
client: self.client.clone(),
tracker: Default::default(),
version: self.version,
device: self.device,
connectors: Default::default(),
});
self.client.add_client_obj(&obj)?;
Ok(())
}
fn release(&self, _req: Release, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.detach();
self.send_released();
self.client.remove_obj(self)?;
Ok(())
}
}
object_base! {
self = WpDrmLeaseDeviceV1;
version = self.version;
}
impl Object for WpDrmLeaseDeviceV1 {
fn break_loops(&self) {
self.detach();
}
}
simple_add_obj!(WpDrmLeaseDeviceV1);
#[derive(Debug, Error)]
pub enum WpDrmLeaseDeviceV1Error {
#[error(transparent)]
ClientError(Box<ClientError>),
}
efrom!(WpDrmLeaseDeviceV1Error, ClientError);
#[derive(Debug, Error)]
enum ReopenError {
#[error("Could not open the dev node")]
OpenNode(#[source] OsError),
#[error("Could not drop DRM master")]
DropMaster(#[source] DrmError),
}
fn reopen_card(devnode: &str) -> Result<Rc<OwnedFd>, ReopenError> {
let fd = uapi::open(devnode, c::O_RDWR | c::O_CLOEXEC, 0)
.map_err(|e| ReopenError::OpenNode(e.into()))?;
let fd = Rc::new(fd);
let drm = Drm::open_existing(fd.clone());
if drm.is_master() {
drm.drop_master().map_err(ReopenError::DropMaster)?;
}
Ok(fd)
}

80
src/ifs/wp_drm_lease_device_v1/removed_device.rs Normal file
View file

@ -0,0 +1,80 @@
use {
crate::{
backend::DrmDeviceId,
client::{Client, ClientCaps, ClientError, CAP_DRM_LEASE},
globals::{Global, GlobalName, RemovableWaylandGlobal},
ifs::wp_drm_lease_device_v1::{WpDrmLeaseDeviceV1, WpDrmLeaseDeviceV1Global},
object::Version,
utils::bindings::Bindings,
wire::WpDrmLeaseDeviceV1Id,
},
std::{cell::Cell, rc::Rc},
thiserror::Error,
};
struct RemovedWpDrmLeaseDeviceV1Global {
name: GlobalName,
bindings: Rc<Bindings<WpDrmLeaseDeviceV1>>,
}
impl RemovedWpDrmLeaseDeviceV1Global {
fn bind_(
self: Rc<Self>,
id: WpDrmLeaseDeviceV1Id,
client: &Rc<Client>,
version: Version,
) -> Result<(), RemovedWpDrmLeaseDeviceV1Error> {
let dev = Rc::new(WpDrmLeaseDeviceV1 {
id,
client: client.clone(),
tracker: Default::default(),
version,
bindings: self.bindings.clone(),
device: DrmDeviceId::from_raw(0),
destroyed: Cell::new(false),
});
track!(client, dev);
client.add_client_obj(&dev)?;
dev.send_done();
dev.bindings.add(client, &dev);
Ok(())
}
}
global_base!(
RemovedWpDrmLeaseDeviceV1Global,
WpDrmLeaseDeviceV1,
RemovedWpDrmLeaseDeviceV1Error
);
simple_add_global!(RemovedWpDrmLeaseDeviceV1Global);
impl Global for RemovedWpDrmLeaseDeviceV1Global {
fn singleton(&self) -> bool {
false
}
fn version(&self) -> u32 {
1
}
fn required_caps(&self) -> ClientCaps {
CAP_DRM_LEASE
}
}
impl RemovableWaylandGlobal for WpDrmLeaseDeviceV1Global {
fn create_replacement(&self) -> Rc<dyn Global> {
Rc::new(RemovedWpDrmLeaseDeviceV1Global {
name: self.name,
bindings: Default::default(),
})
}
}
#[derive(Debug, Error)]
pub enum RemovedWpDrmLeaseDeviceV1Error {
#[error(transparent)]
ClientError(Box<ClientError>),
}
efrom!(RemovedWpDrmLeaseDeviceV1Error, ClientError);

84
src/ifs/wp_drm_lease_request_v1.rs Normal file
View file

@ -0,0 +1,84 @@
use {
crate::{
backend::{ConnectorId, DrmDeviceId},
client::{Client, ClientError},
ifs::wp_drm_lease_v1::{WpDrmLeaseV1, WpDrmLeaseV1Lessee},
leaks::Tracker,
object::{Object, Version},
utils::copyhashmap::CopyHashMap,
wire::{wp_drm_lease_request_v1::*, WpDrmLeaseConnectorV1Id, WpDrmLeaseRequestV1Id},
},
std::{cell::Cell, rc::Rc},
thiserror::Error,
};
pub struct WpDrmLeaseRequestV1 {
pub id: WpDrmLeaseRequestV1Id,
pub client: Rc<Client>,
pub tracker: Tracker<Self>,
pub version: Version,
pub device: DrmDeviceId,
pub connectors: CopyHashMap<WpDrmLeaseConnectorV1Id, ConnectorId>,
}
impl WpDrmLeaseRequestV1RequestHandler for WpDrmLeaseRequestV1 {
type Error = WpDrmLeaseRequestV1Error;
fn request_connector(&self, req: RequestConnector, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let c = self.client.lookup(req.connector)?;
if self.device != c.device.device {
return Err(WpDrmLeaseRequestV1Error::MismatchedDevice(c.id));
}
if self.connectors.contains(&c.id) {
return Err(WpDrmLeaseRequestV1Error::RepeatedDevice(c.id));
}
self.connectors.set(c.id, c.connector_id);
Ok(())
}
fn submit(&self, req: Submit, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.client.remove_obj(self)?;
let obj = Rc::new(WpDrmLeaseV1 {
id: req.id,
client: self.client.clone(),
tracker: Default::default(),
version: self.version,
finished: Cell::new(false),
lease: Default::default(),
});
self.client.add_client_obj(&obj)?;
if self.connectors.is_empty() {
return Err(WpDrmLeaseRequestV1Error::EmptyLease);
}
let Some(dev) = self.client.state.drm_devs.get(&self.device) else {
obj.send_finished();
return Ok(());
};
let lessee = Rc::new(WpDrmLeaseV1Lessee { obj });
let connectors: Vec<_> = self.connectors.lock().values().copied().collect();
dev.dev.clone().create_lease(lessee, &connectors);
Ok(())
}
}
object_base! {
self = WpDrmLeaseRequestV1;
version = self.version;
}
impl Object for WpDrmLeaseRequestV1 {}
simple_add_obj!(WpDrmLeaseRequestV1);
#[derive(Debug, Error)]
pub enum WpDrmLeaseRequestV1Error {
#[error(transparent)]
ClientError(Box<ClientError>),
#[error("Connector {0} does not belong to this device")]
MismatchedDevice(WpDrmLeaseConnectorV1Id),
#[error("Connector {0} is already part of this request")]
RepeatedDevice(WpDrmLeaseConnectorV1Id),
#[error("Lease request is empty")]
EmptyLease,
}
efrom!(WpDrmLeaseRequestV1Error, ClientError);

92
src/ifs/wp_drm_lease_v1.rs Normal file
View file

@ -0,0 +1,92 @@
use {
crate::{
backend::{BackendDrmLease, BackendDrmLessee},
client::{Client, ClientError},
leaks::Tracker,
object::{Object, Version},
utils::clonecell::CloneCell,
wire::{wp_drm_lease_v1::*, WpDrmLeaseV1Id},
},
std::{cell::Cell, rc::Rc},
thiserror::Error,
uapi::OwnedFd,
};
pub struct WpDrmLeaseV1Lessee {
pub obj: Rc<WpDrmLeaseV1>,
}
impl BackendDrmLessee for WpDrmLeaseV1Lessee {
fn created(&self, lease: Rc<dyn BackendDrmLease>) {
if !self.obj.finished.get() {
self.obj.send_lease_fd(lease.fd());
self.obj.lease.set(Some(lease));
}
}
}
impl Drop for WpDrmLeaseV1Lessee {
fn drop(&mut self) {
if !self.obj.finished.get() {
self.obj.detach();
self.obj.send_finished();
}
}
}
pub struct WpDrmLeaseV1 {
pub id: WpDrmLeaseV1Id,
pub client: Rc<Client>,
pub tracker: Tracker<Self>,
pub version: Version,
pub finished: Cell<bool>,
pub lease: CloneCell<Option<Rc<dyn BackendDrmLease>>>,
}
impl WpDrmLeaseV1 {
fn detach(&self) {
self.finished.set(true);
self.lease.take();
}
fn send_lease_fd(&self, fd: &Rc<OwnedFd>) {
self.client.event(LeaseFd {
self_id: self.id,
leased_fd: fd.clone(),
});
}
pub fn send_finished(&self) {
self.client.event(Finished { self_id: self.id });
}
}
impl WpDrmLeaseV1RequestHandler for WpDrmLeaseV1 {
type Error = WpDrmLeaseV1Error;
fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.detach();
self.client.remove_obj(self)?;
Ok(())
}
}
object_base! {
self = WpDrmLeaseV1;
version = self.version;
}
impl Object for WpDrmLeaseV1 {
fn break_loops(&self) {
self.detach();
}
}
simple_add_obj!(WpDrmLeaseV1);
#[derive(Debug, Error)]
pub enum WpDrmLeaseV1Error {
#[error(transparent)]
ClientError(Box<ClientError>),
}
efrom!(WpDrmLeaseV1Error, ClientError);

4
src/ifs/wp_security_context_v1.rs
View file

@ -1,6 +1,6 @@
use {
crate::{
client::{Client, ClientCaps, ClientError},
client::{Client, ClientError, CAPS_DEFAULT_SANDBOXED},
leaks::Tracker,
object::{Object, Version},
wire::{wp_security_context_v1::*, WpSecurityContextV1Id},
@ -80,7 +80,7 @@ impl WpSecurityContextV1RequestHandler for WpSecurityContextV1 {
fn commit(&self, _req: Commit, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.check_committed()?;
self.committed.set(true);
let caps = ClientCaps::none() & self.client.bounding_caps;
let caps = CAPS_DEFAULT_SANDBOXED & self.client.bounding_caps;
self.client.state.security_context_acceptors.spawn(
&self.client.state,
self.sandbox_engine.take(),

4
src/ifs/zwlr_layer_shell_v1.rs
View file

@ -65,9 +65,9 @@ impl ZwlrLayerShellV1RequestHandler for ZwlrLayerShellV1 {
break 'get_output output.global.opt.clone();
}
}
let outputs = self.client.state.outputs.lock();
let outputs = self.client.state.root.outputs.lock();
if let Some(output) = outputs.values().next() {
break 'get_output output.node.global.opt.clone();
break 'get_output output.global.opt.clone();
}
return Err(ZwlrLayerShellV1Error::NoOutputs);
}

1
src/it/test_backend.rs
View file

@ -106,6 +106,7 @@ impl TestBackend {
initial_mode: mode,
width_mm: 80,
height_mm: 60,
non_desktop: false,
};
Self {
state: state.clone(),

4
src/it/testrun.rs
View file

@ -109,9 +109,9 @@ impl TestRun {
self.backend.install_default()?;
let seat = self.get_seat("default")?;
self.state.eng.yield_now().await;
let output = match self.state.outputs.lock().values().next() {
let output = match self.state.root.outputs.lock().values().next() {
None => bail!("No output"),
Some(d) => d.node.clone(),
Some(d) => d.clone(),
};
self.cfg
.set_input_device_seat(self.backend.default_kb.common.id, seat.id())?;

1
src/it/tests/t0034_workspace_restoration.rs
View file

@ -42,6 +42,7 @@ async fn test(run: Rc<TestRun>) -> TestResult {
},
width_mm: 0,
height_mm: 0,
non_desktop: false,
};
run.backend
.state

15
src/state.rs
View file

@ -40,6 +40,8 @@ use {
zwp_input_popup_surface_v2::ZwpInputPopupSurfaceV2,
NoneSurfaceExt, WlSurface,
},
wp_drm_lease_connector_v1::WpDrmLeaseConnectorV1,
wp_drm_lease_device_v1::WpDrmLeaseDeviceV1Global,
wp_linux_drm_syncobj_manager_v1::WpLinuxDrmSyncobjManagerV1Global,
zwlr_screencopy_frame_v1::ZwlrScreencopyFrameV1,
zwp_linux_dmabuf_feedback_v1::ZwpLinuxDmabufFeedbackV1,
@ -59,8 +61,8 @@ use {
WorkspaceNode,
},
utils::{
activation_token::ActivationToken, asyncevent::AsyncEvent, clonecell::CloneCell,
copyhashmap::CopyHashMap, errorfmt::ErrorFmt, fdcloser::FdCloser,
activation_token::ActivationToken, asyncevent::AsyncEvent, bindings::Bindings,
clonecell::CloneCell, copyhashmap::CopyHashMap, errorfmt::ErrorFmt, fdcloser::FdCloser,
linkedlist::LinkedList, numcell::NumCell, queue::AsyncQueue, refcounted::RefCounted,
run_toplevel::RunToplevel,
},
@ -268,7 +270,8 @@ pub struct ConnectorData {
pub struct OutputData {
pub connector: Rc<ConnectorData>,
pub monitor_info: MonitorInfo,
pub node: Rc<OutputNode>,
pub node: Option<Rc<OutputNode>>,
pub lease_connectors: Rc<Bindings<WpDrmLeaseConnectorV1>>,
}
pub struct DrmDevData {
@ -280,6 +283,7 @@ pub struct DrmDevData {
pub vendor: Option<String>,
pub model: Option<String>,
pub pci_id: Option<PciId>,
pub lease_global: Rc<WpDrmLeaseDeviceV1Global>,
}
impl DrmDevData {
@ -731,8 +735,9 @@ impl State {
connector.handler.take();
connector.async_event.clear();
}
for (_, output) in self.outputs.lock().drain() {
output.node.clear();
self.outputs.clear();
for output in self.root.outputs.lock().values() {
output.clear();
}
self.dbus.clear();
self.pending_container_layout.clear();

91
src/tasks/connector.rs
View file

@ -1,6 +1,7 @@
use {
crate::{
backend::{Connector, ConnectorEvent, ConnectorId, MonitorInfo},
globals::GlobalName,
ifs::wl_output::{OutputId, PersistentOutputState, WlOutputGlobal},
state::{ConnectorData, OutputData, State},
tree::{move_ws_to_output, OutputNode, OutputRenderData, WsMoveConfig},
@ -70,6 +71,9 @@ impl ConnectorHandler {
}
self.data.async_event.triggered().await;
}
if let Some(dev) = &self.data.drm_dev {
dev.connectors.remove(&self.id);
}
if let Some(config) = self.state.config.get() {
config.del_connector(self.id);
}
@ -87,6 +91,21 @@ impl ConnectorHandler {
model: info.product.clone(),
serial_number: info.serial_number.clone(),
});
if info.non_desktop {
self.handle_non_desktop_connected(info).await;
} else {
self.handle_desktop_connected(info, name, output_id).await;
}
self.data.connected.set(false);
log::info!("Connector {} disconnected", self.data.connector.kernel_id());
}
async fn handle_desktop_connected(
&self,
info: MonitorInfo,
name: GlobalName,
output_id: Rc<OutputId>,
) {
let desired_state = match self.state.persistent_output_states.get(&output_id) {
Some(ds) => ds,
_ => {
@ -155,13 +174,17 @@ impl ConnectorHandler {
let output_data = Rc::new(OutputData {
connector: self.data.clone(),
monitor_info: info,
node: on.clone(),
node: Some(on.clone()),
lease_connectors: Default::default(),
});
self.state.outputs.set(self.id, output_data);
on.schedule_update_render_data();
self.state.root.outputs.set(self.id, on.clone());
self.state.root.update_extents();
global.opt.node.set(Some(on.clone()));
global.opt.global.set(Some(global.clone()));
let mut ws_to_move = VecDeque::new();
if self.state.outputs.len() == 1 {
if self.state.root.outputs.len() == 1 {
let seats = self.state.globals.seats.lock();
let pos = global.pos.get();
let x = (pos.x1() + pos.x2()) / 2;
@ -177,11 +200,11 @@ impl ConnectorHandler {
ws_to_move.push_back(ws);
}
}
for source in self.state.outputs.lock().values() {
if source.node.id == on.id {
for source in self.state.root.outputs.lock().values() {
if source.id == on.id {
continue;
}
for ws in source.node.workspaces.iter() {
for ws in source.workspaces.iter() {
if ws.is_dummy {
continue;
}
@ -203,9 +226,6 @@ impl ConnectorHandler {
if let Some(config) = self.state.config.get() {
config.connector_connected(self.id);
}
on.schedule_update_render_data();
self.state.root.outputs.set(self.id, on.clone());
self.state.root.update_extents();
self.state.add_global(&global);
self.state.tree_changed();
'outer: loop {
@ -224,7 +244,6 @@ impl ConnectorHandler {
}
self.data.async_event.triggered().await;
}
log::info!("Connector {} disconnected", self.data.connector.kernel_id());
if let Some(config) = self.state.config.get() {
config.connector_disconnected(self.id);
}
@ -242,7 +261,6 @@ impl ConnectorHandler {
global.destroyed.set(true);
self.state.root.outputs.remove(&self.id);
self.state.root.update_extents();
self.data.connected.set(false);
self.state.outputs.remove(&self.id);
on.lock_surface.take();
{
@ -255,8 +273,8 @@ impl ConnectorHandler {
surface.send_closed();
}
}
let target = match self.state.outputs.lock().values().next() {
Some(o) => o.node.clone(),
let target = match self.state.root.outputs.lock().values().next() {
Some(o) => o.clone(),
_ => self.state.dummy_output.get().unwrap(),
};
for ws in on.workspaces.iter() {
@ -276,13 +294,56 @@ impl ConnectorHandler {
seat.set_position((tpos.x1() + tpos.x2()) / 2, (tpos.y1() + tpos.y2()) / 2);
}
}
if let Some(dev) = &self.data.drm_dev {
dev.connectors.remove(&self.id);
}
self.state
.remove_output_scale(on.global.persistent.scale.get());
let _ = self.state.remove_global(&*global);
self.state.tree_changed();
self.state.damage();
}
async fn handle_non_desktop_connected(&self, monitor_info: MonitorInfo) {
let output_data = Rc::new(OutputData {
connector: self.data.clone(),
monitor_info,
node: None,
lease_connectors: Default::default(),
});
self.state.outputs.set(self.id, output_data.clone());
let advertise = || {
if let Some(dev) = &self.data.drm_dev {
for binding in dev.lease_global.bindings.lock().values() {
binding.create_connector(&output_data);
binding.send_done();
}
}
};
let withdraw = || {
for (_, con) in output_data.lease_connectors.lock().drain() {
con.send_withdrawn();
if !con.device.destroyed.get() {
con.device.send_done();
}
}
};
advertise();
if let Some(config) = self.state.config.get() {
config.connector_connected(self.id);
}
'outer: loop {
while let Some(event) = self.data.connector.event() {
match event {
ConnectorEvent::Disconnected => break 'outer,
ConnectorEvent::Available => advertise(),
ConnectorEvent::Unavailable => withdraw(),
ev => unreachable!("received unexpected event {:?}", ev),
}
}
self.data.async_event.triggered().await;
}
withdraw();
self.state.outputs.remove(&self.id);
if let Some(config) = self.state.config.get() {
config.connector_disconnected(self.id);
}
}
}

10
src/tasks/drmdev.rs
View file

@ -1,6 +1,7 @@
use {
crate::{
backend::{BackendDrmDevice, DrmDeviceId, DrmEvent},
ifs::wp_drm_lease_device_v1::WpDrmLeaseDeviceV1Global,
state::{DrmDevData, State},
tasks::udev_utils::udev_props,
utils::asyncevent::AsyncEvent,
@ -11,6 +12,12 @@ use {
pub fn handle(state: &Rc<State>, dev: Rc<dyn BackendDrmDevice>) {
let id = dev.id();
let props = udev_props(dev.dev_t(), 1);
let lease_global = Rc::new(WpDrmLeaseDeviceV1Global {
name: state.globals.name(),
device: id,
bindings: Default::default(),
});
state.add_global(&lease_global);
let data = Rc::new(DrmDevData {
dev: dev.clone(),
handler: Cell::new(None),
@ -20,6 +27,7 @@ pub fn handle(state: &Rc<State>, dev: Rc<dyn BackendDrmDevice>) {
vendor: props.vendor,
model: props.model,
pci_id: props.pci_id,
lease_global,
});
let oh = DrvDevHandler {
id,
@ -66,6 +74,8 @@ impl DrvDevHandler {
if let Some(config) = self.state.config.get() {
config.del_drm_dev(self.id);
}
self.data.lease_global.bindings.clear();
let _ = self.state.remove_global(&*self.data.lease_global);
self.data.handler.set(None);
self.state.drm_devs.remove(&self.id);
}

1
src/utils.rs
View file

@ -1,6 +1,7 @@
pub mod activation_token;
pub mod array;
pub mod asyncevent;
pub mod bindings;
pub mod bitfield;
pub mod bitflags;
pub mod buf;

39
src/utils/bindings.rs Normal file
View file

@ -0,0 +1,39 @@
use {
crate::{
client::{Client, ClientId},
object::{Object, ObjectId},
utils::copyhashmap::{CopyHashMap, Locked},
},
std::rc::Rc,
};
pub struct Bindings<P> {
bindings: CopyHashMap<(ClientId, ObjectId), Rc<P>>,
}
impl<P> Default for Bindings<P> {
fn default() -> Self {
Self {
bindings: Default::default(),
}
}
}
impl<P: Object> Bindings<P> {
pub fn add(&self, client: &Client, obj: &Rc<P>) {
let prev = self.bindings.set((client.id, obj.id()), obj.clone());
assert!(prev.is_none());
}
pub fn remove(&self, client: &Client, obj: &P) {
self.bindings.remove(&(client.id, obj.id()));
}
pub fn clear(&self) {
self.bindings.clear();
}
pub fn lock(&self) -> Locked<(ClientId, ObjectId), Rc<P>> {
self.bindings.lock()
}
}

2
src/utils/oserror.rs
View file

@ -163,7 +163,7 @@ static ERRORS: Lazy<&'static [Option<&'static str>]> = Lazy::new(|| {
res.leak()
});
#[derive(Debug)]
#[derive(Debug, Eq, PartialEq)]
pub struct OsError(pub c::c_int);
impl From<Errno> for OsError {

61
src/video/drm.rs
View file

@ -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,
auth_magic, drm_format_modifier, drm_format_modifier_blob, drop_master, get_version,
revoke_lease, DRM_CAP_CURSOR_HEIGHT, DRM_CAP_CURSOR_WIDTH, FORMAT_BLOB_CURRENT,
},
Modifier, INVALID_MODIFIER,
},
@ -137,6 +137,10 @@ 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),
#[error("Could not drop DRM master")]
DropMaster(#[source] OsError),
}
fn render_node_name(fd: c::c_int) -> Result<Ustring, DrmError> {
@ -173,7 +177,6 @@ pub struct Drm {
}
impl Drm {
#[cfg_attr(not(feature = "it"), allow(dead_code))]
pub fn open_existing(fd: Rc<OwnedFd>) -> Self {
Self { fd }
}
@ -211,6 +214,14 @@ impl Drm {
pub fn version(&self) -> Result<DrmVersion, DrmError> {
get_version(self.fd.raw()).map_err(DrmError::Version)
}
pub fn drop_master(&self) -> Result<(), DrmError> {
drop_master(self.fd.raw()).map_err(DrmError::DropMaster)
}
pub fn is_master(&self) -> bool {
auth_magic(self.fd.raw(), 0) != Err(OsError(c::EACCES))
}
}
pub struct InFormat {
@ -242,6 +253,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 +557,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 {

44
src/video/drm/sys.rs
View file

@ -37,6 +37,10 @@ pub unsafe fn ioctl<T>(fd: c::c_int, request: c::c_ulong, t: &mut T) -> Result<c
pub const DRM_IOCTL_BASE: u64 = b'd' as u64;
pub const fn drm_io(nr: u64) -> u64 {
uapi::_IO(DRM_IOCTL_BASE, nr)
}
pub const fn drm_iow<T>(nr: u64) -> u64 {
uapi::_IOW::<T>(DRM_IOCTL_BASE, nr)
}
@ -70,6 +74,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)
@ -1354,3 +1373,28 @@ pub fn sync_ioc_merge(left: c::c_int, right: c::c_int) -> Result<OwnedFd, OsErro
}
Ok(OwnedFd::new(res.fence))
}
const DRM_IOCTL_DROP_MASTER: u64 = drm_io(0x1f);
pub fn drop_master(fd: c::c_int) -> Result<(), OsError> {
let mut res = 0u8;
unsafe {
ioctl(fd, DRM_IOCTL_DROP_MASTER, &mut res)?;
}
Ok(())
}
const DRM_IOCTL_AUTH_MAGIC: u64 = drm_iow::<drm_auth>(0x11);
#[repr(C)]
struct drm_auth {
magic: c::c_uint,
}
pub fn auth_magic(fd: c::c_int, magic: c::c_uint) -> Result<(), OsError> {
let mut res = drm_auth { magic };
unsafe {
ioctl(fd, DRM_IOCTL_AUTH_MAGIC, &mut res)?;
}
Ok(())
}

13
wire/jay_randr.txt
View file

@ -50,6 +50,11 @@ request set_enabled {
enabled: u32,
}
request set_non_desktop {
output: str,
non_desktop: u32,
}
# events
event global {
@ -99,3 +104,11 @@ event mode {
event error {
msg: str,
}
event non_desktop_output {
manufacturer: str,
product: str,
serial_number: str,
width_mm: i32,
height_mm: i32,
}

23
wire/wp_drm_lease_connector_v1.txt Normal file
View file

@ -0,0 +1,23 @@
request destroy {
}
event name {
name: str,
}
event description {
description: str,
}
event connector_id {
connector_id: u32,
}
event done {
}
event withdrawn {
}

23
wire/wp_drm_lease_device_v1.txt Normal file
View file

@ -0,0 +1,23 @@
request create_lease_request {
id: id(wp_drm_lease_request_v1),
}
request release {
}
event drm_fd {
fd: fd,
}
event connector {
id: id(wp_drm_lease_connector_v1),
}
event done {
}
event released {
}

7
wire/wp_drm_lease_request_v1.txt Normal file
View file

@ -0,0 +1,7 @@
request request_connector {
connector: id(wp_drm_lease_connector_v1),
}
request submit {
id: id(wp_drm_lease_v1),
}

11
wire/wp_drm_lease_v1.txt Normal file
View file

@ -0,0 +1,11 @@
request destroy {
}
event lease_fd {
leased_fd: fd,
}
event finished {
}