1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
// Copyright 2025 Google
// SPDX-License-Identifier: MIT
use std::os::fd::OwnedFd;
use rustix::event::epoll;
use rustix::event::epoll::CreateFlags;
use rustix::event::epoll::Event;
use rustix::event::epoll::EventData;
use rustix::event::epoll::EventFlags;
use rustix::event::Timespec;
use rustix::io::Errno;
use crate::MesaResult;
use crate::OwnedDescriptor;
use crate::WaitEvent;
use crate::WaitTimeout;
use crate::WAIT_CONTEXT_MAX;
pub struct WaitContext {
epoll_ctx: OwnedFd,
}
impl WaitContext {
pub fn new() -> MesaResult<WaitContext> {
let epoll = epoll::create(CreateFlags::CLOEXEC)?;
Ok(WaitContext { epoll_ctx: epoll })
}
pub fn add(&mut self, connection_id: u64, descriptor: &OwnedDescriptor) -> MesaResult<()> {
epoll::add(
&self.epoll_ctx,
descriptor,
EventData::new_u64(connection_id),
EventFlags::IN,
)?;
Ok(())
}
pub fn wait(&mut self, timeout: WaitTimeout) -> MesaResult<Vec<WaitEvent>> {
let mut events_buffer: [epoll::Event; WAIT_CONTEXT_MAX] = [Event {
flags: EventFlags::IN,
data: EventData::new_u64(0),
}; WAIT_CONTEXT_MAX];
let epoll_timeout: Option<Timespec> = match timeout {
WaitTimeout::Finite(duration) => Some(duration.try_into()?),
WaitTimeout::NoTimeout => None, // Indefinite wait
};
let num_events = loop {
match epoll::wait(&self.epoll_ctx, &mut events_buffer, epoll_timeout.as_ref()) {
Err(Errno::INTR) => (), // Continue loop on EINTR
result => break result?,
}
};
let events = events_buffer[..num_events]
.iter()
.map(|e| {
let flags: EventFlags = e.flags;
WaitEvent {
connection_id: e.data.u64(),
readable: flags.contains(EventFlags::IN),
hung_up: flags.contains(EventFlags::HUP),
}
})
.collect();
Ok(events)
}
pub fn delete(&mut self, descriptor: &OwnedDescriptor) -> MesaResult<()> {
epoll::delete(&self.epoll_ctx, descriptor)?;
Ok(())
}
}
|
