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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
// Copyright 2017 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use std::mem;
use std::fs::File;
use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
use libc::{read, write, eventfd, dup, c_void};
use {Result, errno_result};
/// A safe wrapper around a Linux eventfd (man 2 eventfd).
///
/// An eventfd is useful because it is sendable across processes and can be used for signaling in
/// and out of the KVM API. They can also be polled like any other file descriptor.
pub struct EventFd {
eventfd: File,
}
impl EventFd {
/// Creates a new blocking EventFd with an initial value of 0.
pub fn new() -> Result<EventFd> {
// This is safe because eventfd merely allocated an eventfd for our process and we handle
// the error case.
let ret = unsafe { eventfd(0, 0) };
if ret < 0 {
return errno_result();
}
// This is safe because we checked ret for success and know the kernel gave us an fd that we
// own.
Ok(EventFd { eventfd: unsafe { File::from_raw_fd(ret) } })
}
/// Adds `v` to the eventfd's count, blocking until this won't overflow the count.
pub fn write(&self, v: u64) -> Result<()> {
// This is safe because we made this fd and the pointer we pass can not overflow because we
// give the syscall's size parameter properly.
let ret = unsafe {
write(self.as_raw_fd(),
&v as *const u64 as *const c_void,
mem::size_of::<u64>())
};
if ret <= 0 {
return errno_result();
}
Ok(())
}
/// Blocks until the the eventfd's count is non-zero, then resets the count to zero.
pub fn read(&self) -> Result<u64> {
let mut buf: u64 = 0;
let ret = unsafe {
// This is safe because we made this fd and the pointer we pass can not overflow because
// we give the syscall's size parameter properly.
read(self.as_raw_fd(),
&mut buf as *mut u64 as *mut c_void,
mem::size_of::<u64>())
};
if ret <= 0 {
return errno_result();
}
Ok(buf)
}
/// Clones this EventFd, internally creating a new file descriptor. The new EventFd will share
/// the same underlying count within the kernel.
pub fn try_clone(&self) -> Result<EventFd> {
// This is safe because we made this fd and properly check that it returns without error.
let ret = unsafe { dup(self.as_raw_fd()) };
if ret < 0 {
return errno_result();
}
// This is safe because we checked ret for success and know the kernel gave us an fd that we
// own.
Ok(EventFd { eventfd: unsafe { File::from_raw_fd(ret) } })
}
}
impl AsRawFd for EventFd {
fn as_raw_fd(&self) -> RawFd {
self.eventfd.as_raw_fd()
}
}
unsafe impl ::Pollable for EventFd {
fn pollable_fd(&self) -> RawFd {
self.eventfd.as_raw_fd()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn new() {
EventFd::new().unwrap();
}
#[test]
fn read_write() {
let evt = EventFd::new().unwrap();
evt.write(55).unwrap();
assert_eq!(evt.read(), Ok(55));
}
#[test]
fn clone() {
let evt = EventFd::new().unwrap();
let evt_clone = evt.try_clone().unwrap();
evt.write(923).unwrap();
assert_eq!(evt_clone.read(), Ok(923));
}
}
|