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

autocommit 2022-03-11 19:24:53 CET

Browse source
This commit is contained in:
Julian Orth 2022-03-11 19:24:53 +01:00
parent b1890894b2
commit 0ae73ab9c4
9 changed files with 277 additions and 66 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/async_engine.rs
View file

@ -529,6 +529,7 @@ mod fd {
use crate::utils::numcell::NumCell;
use std::cell::{Cell, RefCell};
use std::error::Error;
use std::fmt::{Debug, Formatter};
use std::future::Future;
use std::pin::Pin;
use std::rc::Rc;
@ -641,6 +642,12 @@ mod fd {
pub(super) data: Rc<AsyncFdData>,
}
impl Debug for AsyncFd {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AsyncFd").finish_non_exhaustive()
}
}
impl Clone for AsyncFd {
fn clone(&self) -> Self {
self.data.ref_count.fetch_add(1);

4
src/backends/metal.rs
View file

@ -15,7 +15,7 @@ use crate::udev::{UdevError, UdevMonitor};
use crate::utils::copyhashmap::CopyHashMap;
use crate::utils::oserror::OsError;
use crate::utils::syncqueue::SyncQueue;
use crate::{CloneCell, RenderError, State, Udev};
use crate::{AsyncError, CloneCell, RenderError, State, Udev};
use std::cell::{Cell, RefCell};
use std::ffi::{CStr, CString};
use std::future::pending;
@ -69,6 +69,8 @@ pub enum MetalError {
CreateEncoder(#[source] DrmError),
#[error(transparent)]
DrmError(#[from] DrmError),
#[error("Could not create an async fd for the drm fd")]
CreateDrmAsyncFd(#[source] AsyncError),
}
pub async fn run(state: Rc<State>) -> MetalError {

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

@ -11,6 +11,7 @@ use bstr::ByteSlice;
use std::cell::Cell;
use std::rc::Rc;
use uapi::{c, OwnedFd};
use crate::utils::nonblock::set_nonblock;
const DRM: &[u8] = b"drm";
const INPUT: &[u8] = b"input";
@ -191,12 +192,13 @@ impl MetalBackend {
return;
}
};
if res.inactive == TRUE {
if let Err(e) = set_nonblock(res.fd.raw()) {
log::error!("Could set drm fd to non-blocking: {}", ErrorFmt(e));
return;
}
let master = Rc::new(DrmMaster::new(res.fd.clone()));
let dev = match slf.creat_drm_device(dev, &master) {
Ok(d) => Rc::new(d),
Ok(d) => d,
Err(e) => {
log::error!("Could not initialize drm device: {}", ErrorFmt(e));
return;
@ -300,6 +302,10 @@ impl MetalBackend {
if res.inactive == TRUE {
return;
}
if let Err(e) = set_nonblock(res.fd.raw()) {
log::error!("Could set input fd to non-blocking: {}", ErrorFmt(e));
return;
}
dev.fd.set(Some(res.fd.clone()));
let inputdev = match slf.libinput.open(dev.devnode.as_c_str()) {
Ok(d) => d,

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

@ -1,17 +1,12 @@
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::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, DRM_MODE_ATOMIC_NONBLOCK, DRM_MODE_PAGE_FLIP_EVENT, DrmEvent};
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 crate::{CloneCell, ErrorFmt, NumCell, State};
use ahash::AHashMap;
use bstr::{BString, ByteSlice};
use std::cell::Cell;
@ -19,6 +14,7 @@ use std::ffi::CString;
use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use uapi::c;
use crate::async_engine::{AsyncFd, SpawnedFuture};
pub struct PendingDrmDevice {
pub id: DrmId,
@ -41,6 +37,18 @@ pub struct MetalDrmDeviceStatic {
pub max_height: u32,
pub gbm: GbmDevice,
pub egl: Rc<RenderContext>,
pub async_fd: AsyncFd,
pub handle_events: HandleEvents,
}
pub struct HandleEvents {
pub handle_events: Cell<Option<SpawnedFuture<()>>>,
}
impl Debug for HandleEvents {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("HandleEvents").finish_non_exhaustive()
}
}
#[derive(Debug)]
@ -60,6 +68,9 @@ pub struct MetalConnector {
pub modes: Vec<DrmModeInfo>,
pub mode: CloneCell<Option<Rc<DrmModeInfo>>>,
pub buffers: CloneCell<Option<Rc<[RenderBuffer; 2]>>>,
pub next_buffer: NumCell<usize>,
pub connector_type: ConnectorType,
pub connector_type_id: u32,
@ -68,6 +79,9 @@ pub struct MetalConnector {
pub mm_height: u32,
pub subpixel: u32,
pub primary_plane: CloneCell<Option<Rc<MetalPlane>>>,
pub cursor_plane: Cell<DrmPlane>,
pub crtc_id: MutableProperty<DrmCrtc>,
pub egl_fb: CloneCell<Option<Rc<Framebuffer>>>,
@ -125,10 +139,7 @@ pub struct MetalCrtc {
pub possible_planes: AHashMap<DrmPlane, Rc<MetalPlane>>,
pub connector: Cell<DrmConnector>,
pub primary_plane: Cell<DrmPlane>,
pub cursor_plane: Cell<DrmPlane>,
pub connector: CloneCell<Option<Rc<MetalConnector>>>,
pub active: MutableProperty<bool>,
pub mode_id: MutableProperty<DrmBlob>,
@ -159,8 +170,6 @@ pub struct MetalPlane {
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>,
@ -214,12 +223,16 @@ fn create_connector(
crtcs,
modes: info.modes,
mode: Default::default(),
buffers: Default::default(),
next_buffer: 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,
primary_plane: Default::default(),
cursor_plane: Default::default(),
crtc_id: props.get("CRTC_ID")?.map(|v| DrmCrtc(v as _)),
egl_fb: Default::default(),
on_change: Default::default(),
@ -263,9 +276,7 @@ fn create_crtc(
idx,
master: master.clone(),
possible_planes,
connector: Cell::new(DrmConnector::NONE),
primary_plane: Cell::new(DrmPlane::NONE),
cursor_plane: Cell::new(DrmPlane::NONE),
connector: Default::default(),
active: props.get("ACTIVE")?.map(|v| v == 1),
mode_id: props.get("MODE_ID")?.map(|v| DrmBlob(v as u32)),
mode_blob: Default::default(),
@ -316,7 +327,6 @@ fn create_plane(plane: DrmPlane, master: &Rc<DrmMaster>) -> Result<MetalPlane, D
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),
@ -378,10 +388,10 @@ impl<T: Copy> MutableProperty<T> {
impl MetalBackend {
pub fn creat_drm_device(
&self,
self: &Rc<Self>,
pending: PendingDrmDevice,
master: &Rc<DrmMaster>,
) -> Result<MetalDrmDevice, MetalError> {
) -> Result<Rc<MetalDrmDevice>, MetalError> {
if let Err(e) = master.set_client_cap(DRM_CLIENT_CAP_ATOMIC, 2) {
return Err(MetalError::AtomicModesetting(e));
}
@ -425,8 +435,12 @@ impl MetalBackend {
Ok(r) => Rc::new(r),
Err(e) => return Err(MetalError::CreateRenderContex(e)),
};
let async_fd = match self.state.eng.fd(master.fd()) {
Ok(f) => f,
Err(e) => return Err(MetalError::CreateDrmAsyncFd(e)),
};
let dev = MetalDrmDeviceStatic {
let dev = Rc::new(MetalDrmDeviceStatic {
id: pending.id,
devnum: pending.devnum,
devnode: pending.devnode,
@ -439,28 +453,67 @@ impl MetalBackend {
min_height: resources.min_height,
max_height: resources.max_height,
gbm,
egl,
};
egl: egl.clone(),
async_fd,
handle_events: HandleEvents {
handle_events: Cell::new(None),
},
});
let connectors = get_connectors(&self.state, &dev, &resources.connectors)?;
let slf = MetalDrmDevice {
dev: Rc::new(dev),
let slf = Rc::new(MetalDrmDevice {
dev,
connectors,
};
});
self.reset_drm_device(&slf)?;
let handler = self.state.eng.spawn(self.clone().handle_drm_events(slf.clone()));
slf.dev.handle_events.handle_events.set(Some(handler));
self.state.render_ctx.set(Some(egl));
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,
})
async fn handle_drm_events(self: Rc<Self>, dev: Rc<MetalDrmDevice>) {
loop {
if let Err(e) = dev.dev.async_fd.readable().await {
log::error!("Could not register the DRM fd for reading: {}", ErrorFmt(e));
break;
}
loop {
match dev.dev.master.event() {
Ok(Some(e)) => self.handle_drm_event(e, &dev),
Ok(None) => break,
Err(e) => {
log::error!("Could not read DRM event: {}", ErrorFmt(e));
return;
}
}
}
}
}
fn handle_drm_event(self: &Rc<Self>, event: DrmEvent, dev: &Rc<MetalDrmDevice>) {
match event {
DrmEvent::FlipComplete { tv_sec, tv_usec, sequence, crtc_id } => self.handle_drm_flip_event(
dev, crtc_id, tv_sec, tv_usec, sequence
),
}
}
fn handle_drm_flip_event(self: &Rc<Self>, dev: &Rc<MetalDrmDevice>, crtc_id: DrmCrtc, _tv_sec: u32, _tv_usec: u32, _sequence: u32) {
let crtc = match dev.dev.crtcs.get(&crtc_id) {
Some(c) => c,
_ => return,
};
let connector = match crtc.connector.get() {
Some(c) => c,
_ => return,
};
self.present(&connector);
}
fn reset_drm_device(&self, dev: &MetalDrmDevice) -> Result<(), DrmError> {
@ -506,6 +559,39 @@ impl MetalBackend {
}
}
fn create_scanout_buffers(&self, dev: &Rc<MetalDrmDevice>, connector: &Rc<MetalConnector>, format: &ModifiedFormat, width: i32, height: i32) -> Result<[RenderBuffer; 2], MetalError> {
let create = || self.create_scanout_buffer(dev, connector, format, width, height);
Ok([
create()?,
create()?,
])
}
fn create_scanout_buffer(&self, dev: &Rc<MetalDrmDevice>, connector: &Rc<MetalConnector>, format: &ModifiedFormat, width: i32, height: i32) -> Result<RenderBuffer, MetalError> {
let bo = dev.dev.gbm.create_bo(
width,
height,
&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)),
};
Ok(RenderBuffer {
drm: drm_fb,
egl: egl_fb,
})
}
fn init_drm_connector(
&self,
dev: &Rc<MetalDrmDevice>,
@ -542,24 +628,7 @@ impl MetalBackend {
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 buffers = self.create_scanout_buffers(dev, connector, &format, mode.hdisplay as _, mode.vdisplay as _)?;
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 _);
@ -569,7 +638,7 @@ impl MetalBackend {
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.fb_id.id, buffers[0].drm.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);
@ -583,15 +652,7 @@ impl MetalBackend {
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.fb_id.value.set(buffers[0].drm.id());
primary_plane.crtc_id.value.set(crtc.id);
primary_plane.crtc_x.value.set(0);
primary_plane.crtc_y.value.set(0);
@ -601,6 +662,14 @@ impl MetalBackend {
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);
connector.crtc_id.value.set(crtc.id);
connector.mode.set(Some(Rc::new(mode.clone())));
connector.buffers.set(Some(Rc::new(buffers)));
connector.primary_plane.set(Some(primary_plane.clone()));
crtc.connector.set(Some(connector.clone()));
crtc.active.value.set(true);
crtc.mode_id.value.set(mode_blob.id());
crtc.mode_blob.set(Some(Rc::new(mode_blob)));
self.state
.backend_events
.push(BackendEvent::NewOutput(connector.clone()));
@ -610,6 +679,35 @@ impl MetalBackend {
connector.connector_type_id,
mode
);
self.present(connector);
Ok(())
}
fn present(&self, connector: &Rc<MetalConnector>) {
let buffers = match connector.buffers.get() {
None => return,
Some(b) => b,
};
let plane = match connector.primary_plane.get() {
Some(p) => p,
_ => return,
};
let buffer = &buffers[connector.next_buffer.fetch_add(1) % buffers.len()];
if let Some(node) = self.state.root.outputs.get(&connector.output_id) {
buffer.egl.render(&*node, &self.state, Some(node.position.get()));
}
let mut changes = connector.master.change(DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT);
changes.change_object(plane.id, |c| {
c.change(plane.fb_id.id, buffer.drm.id().0 as _);
});
if let Err(e) = changes.commit(0) {
log::error!("Could not set plane framebuffer: {}", ErrorFmt(e));
}
}
}
#[derive(Debug)]
pub struct RenderBuffer {
drm: Rc<DrmFramebuffer>,
egl: Rc<Framebuffer>,
}

65
src/drm/drm.rs
View file

@ -1,17 +1,18 @@
mod sys;
use std::cell::RefCell;
use crate::drm::drm::sys::{create_lease, drm_mode_modeinfo, get_cap, get_device_name_from_fd2, get_minor_name_from_fd, get_node_type_from_fd, get_nodes, is_master, mode_addfb2, mode_atomic, mode_create_blob, mode_destroy_blob, mode_get_resources, mode_getconnector, mode_getencoder, mode_getplane, mode_getplaneresources, mode_getproperty, mode_obj_getproperties, mode_rmfb, set_client_cap, DRM_DISPLAY_MODE_LEN, DRM_MODE_ATOMIC_TEST_ONLY, DRM_MODE_FB_MODIFIERS, DRM_MODE_OBJECT_BLOB, DRM_MODE_OBJECT_CONNECTOR, DRM_MODE_OBJECT_CRTC, DRM_MODE_OBJECT_ENCODER, DRM_MODE_OBJECT_FB, DRM_MODE_OBJECT_MODE, DRM_MODE_OBJECT_PLANE, DRM_MODE_OBJECT_PROPERTY, gem_close, prime_fd_to_handle};
use crate::drm::drm::sys::{create_lease, drm_mode_modeinfo, get_cap, get_device_name_from_fd2, get_minor_name_from_fd, get_node_type_from_fd, get_nodes, is_master, mode_addfb2, mode_atomic, mode_create_blob, mode_destroy_blob, mode_get_resources, mode_getconnector, mode_getencoder, mode_getplane, mode_getplaneresources, mode_getproperty, mode_obj_getproperties, mode_rmfb, set_client_cap, DRM_DISPLAY_MODE_LEN, DRM_MODE_ATOMIC_TEST_ONLY, DRM_MODE_FB_MODIFIERS, DRM_MODE_OBJECT_BLOB, DRM_MODE_OBJECT_CONNECTOR, DRM_MODE_OBJECT_CRTC, DRM_MODE_OBJECT_ENCODER, DRM_MODE_OBJECT_FB, DRM_MODE_OBJECT_MODE, DRM_MODE_OBJECT_PLANE, DRM_MODE_OBJECT_PROPERTY, gem_close, prime_fd_to_handle, drm_event, drm_event_vblank};
use crate::utils::oserror::OsError;
use ahash::AHashMap;
use bstr::{BString, ByteSlice};
use std::ffi::CString;
use std::fmt::{Debug, Display, Formatter};
use std::mem;
use std::mem::MaybeUninit;
use std::ops::Deref;
use std::rc::{Rc, Weak};
use thiserror::Error;
use uapi::{c, OwnedFd, Ustring};
use uapi::{c, Errno, OwnedFd, Ustring};
use crate::drm::gbm::GbmBo;
use crate::drm::INVALID_MODIFIER;
@ -21,6 +22,7 @@ pub use sys::{
DRM_CLIENT_CAP_ATOMIC, DRM_MODE_ATOMIC_ALLOW_MODESET, DRM_MODE_ATOMIC_NONBLOCK,
DRM_MODE_PAGE_FLIP_EVENT,
};
use crate::utils::syncqueue::SyncQueue;
#[derive(Debug, Error)]
pub enum DrmError {
@ -74,6 +76,10 @@ pub enum DrmError {
AddFb(#[source] OsError),
#[error("Could not convert prime fd to gem handle")]
GemHandle(#[source] OsError),
#[error("Could not read events from the drm fd")]
ReadEvents(#[source] OsError),
#[error("Read invalid data from drm device")]
InvalidRead,
}
fn render_node_name(fd: c::c_int) -> Result<Ustring, DrmError> {
@ -114,6 +120,10 @@ impl Drm {
})
}
pub fn fd(&self) -> &Rc<OwnedFd> {
&self.fd
}
pub fn raw(&self) -> c::c_int {
self.fd.raw()
}
@ -132,6 +142,8 @@ pub struct DrmMaster {
u32_bufs: Stack<Vec<u32>>,
u64_bufs: Stack<Vec<u64>>,
gem_handles: RefCell<AHashMap<u32, Weak<GemHandle>>>,
events: SyncQueue<DrmEvent>,
buf: RefCell<Box<[MaybeUninit<u8>; 1024]>>,
}
impl Debug for DrmMaster {
@ -155,6 +167,8 @@ impl DrmMaster {
u32_bufs: Default::default(),
u64_bufs: Default::default(),
gem_handles: Default::default(),
events: Default::default(),
buf: RefCell::new(Box::new([MaybeUninit::uninit(); 1024])),
}
}
@ -284,6 +298,53 @@ impl DrmMaster {
handles.insert(handle, Rc::downgrade(&h));
Ok(h)
}
pub fn event(&self) -> Result<Option<DrmEvent>, DrmError> {
if self.events.is_empty() {
let mut buf = self.buf.borrow_mut();
let mut buf = match uapi::read(self.raw(), buf.as_mut_slice()) {
Ok(b) => b,
Err(Errno(c::EAGAIN)) => return Ok(None),
Err(e) => return Err(DrmError::ReadEvents(e.into())),
};
while buf.len() > 0 {
let header: drm_event = match uapi::pod_read_init(buf) {
Ok(e) => e,
_ => return Err(DrmError::InvalidRead),
};
let len = header.length as usize;
if len > buf.len() {
return Err(DrmError::InvalidRead);
}
match header.ty {
sys::DRM_EVENT_FLIP_COMPLETE => {
let event: drm_event_vblank = match uapi::pod_read_init(buf) {
Ok(e) => e,
_ => return Err(DrmError::InvalidRead),
};
self.events.push(DrmEvent::FlipComplete {
tv_sec: event.tv_sec,
tv_usec: event.tv_usec,
sequence: event.sequence,
crtc_id: DrmCrtc(event.crtc_id),
});
}
_ => { },
}
buf = &mut buf[len as usize..];
}
}
Ok(self.events.pop())
}
}
pub enum DrmEvent {
FlipComplete {
tv_sec: u32,
tv_usec: u32,
sequence: u32,
crtc_id: DrmCrtc,
},
}
pub struct DrmFramebuffer {

26
src/drm/drm/sys.rs
View file

@ -13,7 +13,7 @@ use bstr::ByteSlice;
use std::ffi::CString;
use std::io::{BufRead, BufReader};
use std::mem;
use uapi::{c, OwnedFd, Ustring};
use uapi::{c, OwnedFd, Pod, Ustring};
pub unsafe fn ioctl<T>(fd: c::c_int, request: c::c_ulong, t: &mut T) -> Result<c::c_int, OsError> {
let mut ret;
@ -1032,3 +1032,27 @@ pub fn gem_close(fd: c::c_int, handle: u32) -> Result<(), OsError> {
}
Ok(())
}
pub const DRM_EVENT_VBLANK : u32 = 0x01;
pub const DRM_EVENT_FLIP_COMPLETE : u32 = 0x02;
pub const DRM_EVENT_CRTC_SEQUENCE : u32 = 0x03;
#[repr(C)]
pub struct drm_event {
pub ty: u32,
pub length: u32,
}
unsafe impl Pod for drm_event { }
#[repr(C)]
pub struct drm_event_vblank {
pub base: drm_event,
pub user_data: u64,
pub tv_sec: u32,
pub tv_usec: u32,
pub sequence: u32,
pub crtc_id: u32,
}
unsafe impl Pod for drm_event_vblank { }

1
src/utils/mod.rs
View file

@ -21,3 +21,4 @@ pub mod tri;
pub mod vasprintf;
pub mod vec_ext;
pub mod vecstorage;
pub mod nonblock;

8
src/utils/nonblock.rs Normal file
View file

@ -0,0 +1,8 @@
use uapi::{c};
use crate::utils::oserror::OsError;
pub fn set_nonblock(fd: c::c_int) -> Result<(), OsError> {
let fl = uapi::fcntl_getfl(fd)?;
uapi::fcntl_setfl(fd, fl | c::SOCK_NONBLOCK)?;
Ok(())
}

4
src/utils/syncqueue.rs
View file

@ -24,4 +24,8 @@ impl<T> SyncQueue<T> {
pub fn pop(&self) -> Option<T> {
unsafe { self.el.get().deref_mut().pop_front() }
}
pub fn is_empty(&self) -> bool {
unsafe { self.el.get().deref_mut().is_empty() }
}
}