#![allow(unsafe_code)]
use super::super::c;
use crate::backend::io::syscalls::{epoll_add, epoll_create, epoll_del, epoll_mod, epoll_wait};
use crate::fd::{AsFd, AsRawFd, OwnedFd};
#[cfg(feature = "std")]
use crate::fd::{BorrowedFd, FromRawFd, IntoRawFd, RawFd};
use crate::io;
use alloc::vec::Vec;
use bitflags::bitflags;
use core::marker::PhantomData;
use core::ptr::null;
#[doc(inline)]
pub use crate::io::context::*;
bitflags! {
pub struct CreateFlags: c::c_uint {
const CLOEXEC = linux_raw_sys::general::EPOLL_CLOEXEC;
}
}
bitflags! {
#[derive(Default)]
pub struct EventFlags: u32 {
const IN = linux_raw_sys::general::EPOLLIN as u32;
const OUT = linux_raw_sys::general::EPOLLOUT as u32;
const PRI = linux_raw_sys::general::EPOLLPRI as u32;
const ERR = linux_raw_sys::general::EPOLLERR as u32;
const HUP = linux_raw_sys::general::EPOLLHUP as u32;
const ET = linux_raw_sys::general::EPOLLET as u32;
const ONESHOT = linux_raw_sys::general::EPOLLONESHOT as u32;
const WAKEUP = linux_raw_sys::general::EPOLLWAKEUP as u32;
const EXCLUSIVE = linux_raw_sys::general::EPOLLEXCLUSIVE as u32;
}
}
pub struct Epoll<Context: self::Context> {
epoll_fd: OwnedFd,
context: Context,
}
impl<Context: self::Context> Epoll<Context> {
#[inline]
#[doc(alias = "epoll_create1")]
pub fn new(flags: CreateFlags, context: Context) -> io::Result<Self> {
Ok(Self {
epoll_fd: epoll_create(flags)?,
context,
})
}
#[doc(alias = "epoll_ctl")]
pub fn add(
&self,
data: Context::Data,
event_flags: EventFlags,
) -> io::Result<Ref<'_, Context::Target>> {
unsafe {
let target = self.context.acquire(data);
let raw_fd = target.as_fd().as_raw_fd();
let encoded = self.context.encode(target);
epoll_add(
self.epoll_fd.as_fd(),
raw_fd,
&linux_raw_sys::general::epoll_event {
events: event_flags.bits(),
data: encoded,
},
)?;
Ok(self.context.decode(encoded))
}
}
#[doc(alias = "epoll_ctl")]
pub fn mod_(
&self,
target: Ref<'_, Context::Target>,
event_flags: EventFlags,
) -> io::Result<()> {
let raw_fd = target.as_fd().as_raw_fd();
let encoded = self.context.encode(target);
unsafe {
epoll_mod(
self.epoll_fd.as_fd(),
raw_fd,
&linux_raw_sys::general::epoll_event {
events: event_flags.bits(),
data: encoded,
},
)
}
}
#[doc(alias = "epoll_ctl")]
pub fn del(&self, target: Ref<'_, Context::Target>) -> io::Result<Context::Data> {
unsafe {
let raw_fd = target.as_fd().as_raw_fd();
epoll_del(self.epoll_fd.as_fd(), raw_fd)?;
}
Ok(self.context.release(target))
}
#[doc(alias = "epoll_wait")]
pub fn wait<'context>(
&'context self,
event_list: &mut EventVec<'context, Context>,
timeout: c::c_int,
) -> io::Result<()> {
unsafe {
event_list.events.set_len(0);
let nfds = epoll_wait(
self.epoll_fd.as_fd(),
event_list.events[..].as_mut_ptr().cast(),
event_list.events.capacity(),
timeout,
)?;
event_list.events.set_len(nfds);
event_list.context = &self.context;
}
Ok(())
}
}
#[cfg(feature = "std")]
impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> AsRawFd for Epoll<Owning<'context, T>> {
fn as_raw_fd(&self) -> RawFd {
self.epoll_fd.as_raw_fd()
}
}
#[cfg(feature = "std")]
impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> IntoRawFd for Epoll<Owning<'context, T>> {
fn into_raw_fd(self) -> RawFd {
self.epoll_fd.into_raw_fd()
}
}
#[cfg(feature = "std")]
impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> FromRawFd for Epoll<Owning<'context, T>> {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
Self {
epoll_fd: OwnedFd::from_raw_fd(fd),
context: Owning::new(),
}
}
}
#[cfg(feature = "std")]
impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> AsFd for Epoll<Owning<'context, T>> {
fn as_fd(&self) -> BorrowedFd<'_> {
self.epoll_fd.as_fd()
}
}
#[cfg(feature = "std")]
impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> From<Epoll<Owning<'context, T>>>
for OwnedFd
{
fn from(epoll: Epoll<Owning<'context, T>>) -> Self {
epoll.epoll_fd
}
}
#[cfg(feature = "std")]
impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> From<OwnedFd>
for Epoll<Owning<'context, T>>
{
fn from(fd: OwnedFd) -> Self {
Self {
epoll_fd: fd,
context: Owning::new(),
}
}
}
pub struct Iter<'context, Context: self::Context> {
iter: core::slice::Iter<'context, Event>,
context: *const Context,
_phantom: PhantomData<&'context Context>,
}
impl<'context, Context: self::Context> Iterator for Iter<'context, Context> {
type Item = (EventFlags, Ref<'context, Context::Target>);
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|event| {
let decoded = unsafe { (*self.context).decode(event.encoded) };
(event.event_flags, decoded)
})
}
}
#[repr(C)]
#[cfg_attr(target_arch = "x86_64", repr(packed))]
struct Event {
event_flags: EventFlags,
encoded: u64,
}
pub struct EventVec<'context, Context: self::Context> {
events: Vec<Event>,
context: *const Context,
_phantom: PhantomData<&'context Context>,
}
impl<'context, Context: self::Context> EventVec<'context, Context> {
#[inline]
pub fn with_capacity(capacity: usize) -> Self {
Self {
events: Vec::with_capacity(capacity),
context: null(),
_phantom: PhantomData,
}
}
#[inline]
pub fn capacity(&self) -> usize {
self.events.capacity()
}
#[inline]
pub fn reserve(&mut self, additional: usize) {
self.events.reserve(additional);
}
#[inline]
pub fn reserve_exact(&mut self, additional: usize) {
self.events.reserve_exact(additional);
}
#[inline]
pub fn clear(&mut self) {
self.events.clear();
}
#[inline]
pub fn shrink_to_fit(&mut self) {
self.events.shrink_to_fit();
}
#[inline]
pub fn iter(&self) -> Iter<'_, Context> {
Iter {
iter: self.events.iter(),
context: self.context,
_phantom: PhantomData,
}
}
#[inline]
pub fn len(&mut self) -> usize {
self.events.len()
}
#[inline]
pub fn is_empty(&mut self) -> bool {
self.events.is_empty()
}
}
impl<'context, Context: self::Context> IntoIterator for &'context EventVec<'context, Context> {
type IntoIter = Iter<'context, Context>;
type Item = (EventFlags, Ref<'context, Context::Target>);
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}