diff --git a/src/async_engine.rs b/src/async_engine.rs index f12b9b99..f5dde889 100644 --- a/src/async_engine.rs +++ b/src/async_engine.rs @@ -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, } + 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); diff --git a/src/backends/metal.rs b/src/backends/metal.rs index 33f437f6..dcbf2f91 100644 --- a/src/backends/metal.rs +++ b/src/backends/metal.rs @@ -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) -> MetalError { diff --git a/src/backends/metal/monitor.rs b/src/backends/metal/monitor.rs index 76571996..b5060c31 100644 --- a/src/backends/metal/monitor.rs +++ b/src/backends/metal/monitor.rs @@ -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, diff --git a/src/backends/metal/video.rs b/src/backends/metal/video.rs index 4fa75945..849f7e4e 100644 --- a/src/backends/metal/video.rs +++ b/src/backends/metal/video.rs @@ -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, + pub async_fd: AsyncFd, + pub handle_events: HandleEvents, +} + +pub struct HandleEvents { + pub handle_events: Cell>>, +} + +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, pub mode: CloneCell>>, + pub buffers: CloneCell>>, + pub next_buffer: NumCell, + 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>>, + pub cursor_plane: Cell, + pub crtc_id: MutableProperty, pub egl_fb: CloneCell>>, @@ -125,10 +139,7 @@ pub struct MetalCrtc { pub possible_planes: AHashMap>, - pub connector: Cell, - - pub primary_plane: Cell, - pub cursor_plane: Cell, + pub connector: CloneCell>>, pub active: MutableProperty, pub mode_id: MutableProperty, @@ -159,8 +170,6 @@ pub struct MetalPlane { pub possible_crtcs: u32, pub formats: AHashMap, - pub fb: CloneCell>>, - pub fb_id: MutableProperty, pub crtc_id: MutableProperty, pub crtc_x: MutableProperty, @@ -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) -> Result MutableProperty { impl MetalBackend { pub fn creat_drm_device( - &self, + self: &Rc, pending: PendingDrmDevice, master: &Rc, - ) -> Result { + ) -> Result, 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 { - 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, dev: Rc) { + 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, event: DrmEvent, dev: &Rc) { + 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, dev: &Rc, 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, connector: &Rc, 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, connector: &Rc, format: &ModifiedFormat, width: i32, height: i32) -> Result { + 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, @@ -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) { + 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, + egl: Rc, } diff --git a/src/drm/drm.rs b/src/drm/drm.rs index d84f4041..274aadf3 100644 --- a/src/drm/drm.rs +++ b/src/drm/drm.rs @@ -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 { @@ -114,6 +120,10 @@ impl Drm { }) } + pub fn fd(&self) -> &Rc { + &self.fd + } + pub fn raw(&self) -> c::c_int { self.fd.raw() } @@ -132,6 +142,8 @@ pub struct DrmMaster { u32_bufs: Stack>, u64_bufs: Stack>, gem_handles: RefCell>>, + events: SyncQueue, + buf: RefCell; 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, 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 { diff --git a/src/drm/drm/sys.rs b/src/drm/drm/sys.rs index bceb511d..4a86a765 100644 --- a/src/drm/drm/sys.rs +++ b/src/drm/drm/sys.rs @@ -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(fd: c::c_int, request: c::c_ulong, t: &mut T) -> Result { 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 { } diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 63fd2a3f..01584b71 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -21,3 +21,4 @@ pub mod tri; pub mod vasprintf; pub mod vec_ext; pub mod vecstorage; +pub mod nonblock; diff --git a/src/utils/nonblock.rs b/src/utils/nonblock.rs new file mode 100644 index 00000000..059280b8 --- /dev/null +++ b/src/utils/nonblock.rs @@ -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(()) +} diff --git a/src/utils/syncqueue.rs b/src/utils/syncqueue.rs index bfde9b2d..3803865c 100644 --- a/src/utils/syncqueue.rs +++ b/src/utils/syncqueue.rs @@ -24,4 +24,8 @@ impl SyncQueue { pub fn pop(&self) -> Option { unsafe { self.el.get().deref_mut().pop_front() } } + + pub fn is_empty(&self) -> bool { + unsafe { self.el.get().deref_mut().is_empty() } + } }