| epoll.rs |
Linux `epoll` support.
# Examples
```no_run
# #[cfg(feature = "net")]
# fn main() -> std::io::Result<()> {
use rustix::buffer::spare_capacity;
use rustix::event::epoll;
use rustix::fd::AsFd;
use rustix::io::{ioctl_fionbio, read, write};
use rustix::net::{
accept, bind, listen, socket, AddressFamily, Ipv4Addr, SocketAddrV4, SocketType,
};
use std::collections::HashMap;
use std::os::unix::io::AsRawFd;
// Create a socket and listen on it.
let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, None)?;
bind(&listen_sock, &SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0))?;
listen(&listen_sock, 1)?;
// Create an epoll object. Using `Owning` here means the epoll object will
// take ownership of the file descriptors registered with it.
let epoll = epoll::create(epoll::CreateFlags::CLOEXEC)?;
// Register the socket with the epoll object.
epoll::add(
&epoll,
&listen_sock,
epoll::EventData::new_u64(1),
epoll::EventFlags::IN,
)?;
// Keep track of the sockets we've opened.
let mut next_id = epoll::EventData::new_u64(2);
let mut sockets = HashMap::new();
// Process events.
let mut event_list = Vec::with_capacity(4);
loop {
epoll::wait(&epoll, spare_capacity(&mut event_list), None)?;
for event in event_list.drain(..) {
let target = event.data;
if target.u64() == 1 {
// Accept a new connection, set it to non-blocking, and
// register to be notified when it's ready to write to.
let conn_sock = accept(&listen_sock)?;
ioctl_fionbio(&conn_sock, true)?;
epoll::add(
&epoll,
&conn_sock,
next_id,
epoll::EventFlags::OUT | epoll::EventFlags::ET,
)?;
// Keep track of the socket.
sockets.insert(next_id, conn_sock);
next_id = epoll::EventData::new_u64(next_id.u64() + 1);
} else {
// Write a message to the stream and then unregister it.
let target = sockets.remove(&target).unwrap();
write(&target, b"hello\n")?;
let _ = epoll::delete(&epoll, &target)?;
}
}
}
# }
# #[cfg(not(feature = "net"))]
# fn main() {}
``` |
10369 |
- |
| eventfd.rs |
|
573 |
- |
| kqueue.rs |
An API for interfacing with `kqueue`. |
14702 |
- |
| mod.rs |
Event operations. |
862 |
- |
| pause.rs |
|
1123 |
- |
| poll.rs |
|
1878 |
- |
| port.rs |
Solaris/illumos event ports.
# Examples
```
# fn test() -> std::io::Result<()> {
use rustix::event::port;
use rustix::stdio::stdout;
use std::io;
let some_fd = stdout();
let some_userdata = 7 as *mut _;
// Create a port.
let port = port::create()?;
// Associate `some_fd` with the port.
unsafe {
port::associate_fd(&port, some_fd, port::PollFlags::IN, some_userdata)?;
}
// Get a single event.
let event = port::get(&port, None)?;
assert_eq!(event.userdata(), some_userdata);
# Ok(())
# }
``` |
5620 |
- |
| select.rs |
The `select` function.
# Safety
`select` is unsafe due to I/O safety. |
12427 |
- |