1 use crate::errno::Errno;
2 use crate::Result;
3 use libc::{self, c_int};
4 use std::mem;
5 use std::os::unix::io::RawFd;
6 use std::ptr;
7
8 libc_bitflags!(
9 pub struct EpollFlags: c_int {
10 EPOLLIN;
11 EPOLLPRI;
12 EPOLLOUT;
13 EPOLLRDNORM;
14 EPOLLRDBAND;
15 EPOLLWRNORM;
16 EPOLLWRBAND;
17 EPOLLMSG;
18 EPOLLERR;
19 EPOLLHUP;
20 EPOLLRDHUP;
21 EPOLLEXCLUSIVE;
22 #[cfg(not(target_arch = "mips"))]
23 EPOLLWAKEUP;
24 EPOLLONESHOT;
25 EPOLLET;
26 }
27 );
28
29 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
30 #[repr(i32)]
31 #[non_exhaustive]
32 pub enum EpollOp {
33 EpollCtlAdd = libc::EPOLL_CTL_ADD,
34 EpollCtlDel = libc::EPOLL_CTL_DEL,
35 EpollCtlMod = libc::EPOLL_CTL_MOD,
36 }
37
38 libc_bitflags! {
39 pub struct EpollCreateFlags: c_int {
40 EPOLL_CLOEXEC;
41 }
42 }
43
44 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
45 #[repr(transparent)]
46 pub struct EpollEvent {
47 event: libc::epoll_event,
48 }
49
50 impl EpollEvent {
new(events: EpollFlags, data: u64) -> Self51 pub fn new(events: EpollFlags, data: u64) -> Self {
52 EpollEvent {
53 event: libc::epoll_event {
54 events: events.bits() as u32,
55 u64: data,
56 },
57 }
58 }
59
empty() -> Self60 pub fn empty() -> Self {
61 unsafe { mem::zeroed::<EpollEvent>() }
62 }
63
events(&self) -> EpollFlags64 pub fn events(&self) -> EpollFlags {
65 EpollFlags::from_bits(self.event.events as c_int).unwrap()
66 }
67
data(&self) -> u6468 pub fn data(&self) -> u64 {
69 self.event.u64
70 }
71 }
72
73 #[inline]
epoll_create() -> Result<RawFd>74 pub fn epoll_create() -> Result<RawFd> {
75 let res = unsafe { libc::epoll_create(1024) };
76
77 Errno::result(res)
78 }
79
80 #[inline]
epoll_create1(flags: EpollCreateFlags) -> Result<RawFd>81 pub fn epoll_create1(flags: EpollCreateFlags) -> Result<RawFd> {
82 let res = unsafe { libc::epoll_create1(flags.bits()) };
83
84 Errno::result(res)
85 }
86
87 #[inline]
epoll_ctl<'a, T>( epfd: RawFd, op: EpollOp, fd: RawFd, event: T, ) -> Result<()> where T: Into<Option<&'a mut EpollEvent>>,88 pub fn epoll_ctl<'a, T>(
89 epfd: RawFd,
90 op: EpollOp,
91 fd: RawFd,
92 event: T,
93 ) -> Result<()>
94 where
95 T: Into<Option<&'a mut EpollEvent>>,
96 {
97 let mut event: Option<&mut EpollEvent> = event.into();
98 if event.is_none() && op != EpollOp::EpollCtlDel {
99 Err(Errno::EINVAL)
100 } else {
101 let res = unsafe {
102 if let Some(ref mut event) = event {
103 libc::epoll_ctl(epfd, op as c_int, fd, &mut event.event)
104 } else {
105 libc::epoll_ctl(epfd, op as c_int, fd, ptr::null_mut())
106 }
107 };
108 Errno::result(res).map(drop)
109 }
110 }
111
112 #[inline]
epoll_wait( epfd: RawFd, events: &mut [EpollEvent], timeout_ms: isize, ) -> Result<usize>113 pub fn epoll_wait(
114 epfd: RawFd,
115 events: &mut [EpollEvent],
116 timeout_ms: isize,
117 ) -> Result<usize> {
118 let res = unsafe {
119 libc::epoll_wait(
120 epfd,
121 events.as_mut_ptr() as *mut libc::epoll_event,
122 events.len() as c_int,
123 timeout_ms as c_int,
124 )
125 };
126
127 Errno::result(res).map(|r| r as usize)
128 }
129