Skip to content

Commit b8ef114

Browse files
mkroeningmkroening
authored
Merge pull request #1064 from mkroening/simple-poll-event
refactor(PollEvent): simplify flag propagation
2 parents 294fabd + 6f6cf95 commit b8ef114

File tree

5 files changed

+64
-183
lines changed

5 files changed

+64
-183
lines changed

‎src/fd/eventfd.rs‎

Lines changed: 9 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -142,37 +142,24 @@ impl ObjectInterface for EventFd {
142142
}
143143

144144
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
145-
let mut result: PollEvent = PollEvent::empty();
146145
let guard = self.state.lock().await;
147146

147+
let mut available = PollEvent::empty();
148+
148149
if guard.counter < u64::MAX - 1 {
149-
if event.contains(PollEvent::POLLOUT) {
150-
result.insert(PollEvent::POLLOUT);
151-
}
152-
if event.contains(PollEvent::POLLWRNORM) {
153-
result.insert(PollEvent::POLLWRNORM);
154-
}
155-
if event.contains(PollEvent::POLLWRBAND) {
156-
result.insert(PollEvent::POLLWRBAND);
157-
}
150+
available.insert(PollEvent::POLLOUT | PollEvent::POLLWRNORM | PollEvent::POLLWRBAND);
158151
}
159152

160153
if guard.counter > 0 {
161-
if event.contains(PollEvent::POLLIN) {
162-
result.insert(PollEvent::POLLIN);
163-
}
164-
if event.contains(PollEvent::POLLRDNORM) {
165-
result.insert(PollEvent::POLLRDNORM);
166-
}
167-
if event.contains(PollEvent::POLLRDBAND) {
168-
result.insert(PollEvent::POLLRDBAND);
169-
}
154+
available.insert(PollEvent::POLLIN | PollEvent::POLLRDNORM | PollEvent::POLLRDBAND);
170155
}
171156

172157
drop(guard);
173158

159+
let ret = event & available;
160+
174161
future::poll_fn(|cx| {
175-
if result.is_empty() {
162+
if ret.is_empty() {
176163
let mut pinned = core::pin::pin!(self.state.lock());
177164
if let Poll::Ready(mut guard) = pinned.as_mut().poll(cx) {
178165
if event.intersects(
@@ -186,13 +173,13 @@ impl ObjectInterface for EventFd {
186173
guard.write_queue.push_back(cx.waker().clone());
187174
Poll::Pending
188175
} else {
189-
Poll::Ready(Ok(result))
176+
Poll::Ready(Ok(ret))
190177
}
191178
} else {
192179
Poll::Pending
193180
}
194181
} else {
195-
Poll::Ready(Ok(result))
182+
Poll::Ready(Ok(ret))
196183
}
197184
})
198185
.await

‎src/fd/socket/tcp.rs‎

Lines changed: 21 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -168,35 +168,20 @@ impl Socket {
168168
#[async_trait]
169169
impl ObjectInterface for Socket {
170170
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
171-
let mut result: PollEvent = PollEvent::empty();
172-
173171
future::poll_fn(|cx| {
174172
self.with(|socket| match socket.state() {
175173
tcp::State::Closed | tcp::State::Closing | tcp::State::CloseWait => {
176-
if event.contains(PollEvent::POLLOUT) {
177-
result.insert(PollEvent::POLLOUT);
178-
}
179-
if event.contains(PollEvent::POLLWRNORM) {
180-
result.insert(PollEvent::POLLWRNORM);
181-
}
182-
if event.contains(PollEvent::POLLWRBAND) {
183-
result.insert(PollEvent::POLLWRBAND);
184-
}
174+
let available = PollEvent::POLLOUT
175+
| PollEvent::POLLWRNORM | PollEvent::POLLWRBAND
176+
| PollEvent::POLLIN | PollEvent::POLLRDNORM
177+
| PollEvent::POLLRDBAND;
185178

186-
if event.contains(PollEvent::POLLIN) {
187-
result.insert(PollEvent::POLLIN);
188-
}
189-
if event.contains(PollEvent::POLLRDNORM) {
190-
result.insert(PollEvent::POLLRDNORM);
191-
}
192-
if event.contains(PollEvent::POLLRDBAND) {
193-
result.insert(PollEvent::POLLRDBAND);
194-
}
179+
let ret = event & available;
195180

196-
if result.is_empty() {
181+
if ret.is_empty() {
197182
Poll::Ready(Ok(PollEvent::POLLHUP))
198183
} else {
199-
Poll::Ready(Ok(result))
184+
Poll::Ready(Ok(ret))
200185
}
201186
}
202187
tcp::State::FinWait1 | tcp::State::FinWait2 | tcp::State::TimeWait => {
@@ -208,49 +193,31 @@ impl ObjectInterface for Socket {
208193
Poll::Pending
209194
}
210195
_ => {
211-
if socket.may_recv() && self.listen.swap(false, Ordering::Relaxed) {
196+
let mut available = PollEvent::empty();
197+
198+
if socket.can_recv()
199+
|| socket.may_recv() && self.listen.swap(false, Ordering::Relaxed)
200+
{
212201
// In case, we just establish a fresh connection in non-blocking mode, we try to read data.
213-
if event.contains(PollEvent::POLLIN) {
214-
result.insert(PollEvent::POLLIN);
215-
}
216-
if event.contains(PollEvent::POLLRDNORM) {
217-
result.insert(PollEvent::POLLRDNORM);
218-
}
219-
if event.contains(PollEvent::POLLRDBAND) {
220-
result.insert(PollEvent::POLLRDBAND);
221-
}
202+
available.insert(
203+
PollEvent::POLLIN | PollEvent::POLLRDNORM | PollEvent::POLLRDBAND,
204+
);
222205
}
223206

224207
if socket.can_send() {
225-
if event.contains(PollEvent::POLLOUT) {
226-
result.insert(PollEvent::POLLOUT);
227-
}
228-
if event.contains(PollEvent::POLLWRNORM) {
229-
result.insert(PollEvent::POLLWRNORM);
230-
}
231-
if event.contains(PollEvent::POLLWRBAND) {
232-
result.insert(PollEvent::POLLWRBAND);
233-
}
208+
available.insert(
209+
PollEvent::POLLOUT | PollEvent::POLLWRNORM | PollEvent::POLLWRBAND,
210+
);
234211
}
235212

236-
if socket.can_recv() {
237-
if event.contains(PollEvent::POLLIN) {
238-
result.insert(PollEvent::POLLIN);
239-
}
240-
if event.contains(PollEvent::POLLRDNORM) {
241-
result.insert(PollEvent::POLLRDNORM);
242-
}
243-
if event.contains(PollEvent::POLLRDBAND) {
244-
result.insert(PollEvent::POLLRDBAND);
245-
}
246-
}
213+
let ret = event & available;
247214

248-
if result.is_empty() {
215+
if ret.is_empty() {
249216
socket.register_recv_waker(cx.waker());
250217
socket.register_send_waker(cx.waker());
251218
Poll::Pending
252219
} else {
253-
Poll::Ready(Ok(result))
220+
Poll::Ready(Ok(ret))
254221
}
255222
}
256223
})

‎src/fd/socket/udp.rs‎

Lines changed: 15 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -119,44 +119,34 @@ impl Socket {
119119
#[async_trait]
120120
impl ObjectInterface for Socket {
121121
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
122-
let mut result: PollEvent = PollEvent::empty();
123-
124122
future::poll_fn(|cx| {
125123
self.with(|socket| {
126-
if socket.is_open() {
124+
let ret = if socket.is_open() {
125+
let mut avail = PollEvent::empty();
126+
127127
if socket.can_send() {
128-
if event.contains(PollEvent::POLLOUT) {
129-
result.insert(PollEvent::POLLOUT);
130-
}
131-
if event.contains(PollEvent::POLLWRNORM) {
132-
result.insert(PollEvent::POLLWRNORM);
133-
}
134-
if event.contains(PollEvent::POLLWRBAND) {
135-
result.insert(PollEvent::POLLWRBAND);
136-
}
128+
avail.insert(
129+
PollEvent::POLLOUT | PollEvent::POLLWRNORM | PollEvent::POLLWRBAND,
130+
);
137131
}
138132

139133
if socket.can_recv() {
140-
if event.contains(PollEvent::POLLIN) {
141-
result.insert(PollEvent::POLLIN);
142-
}
143-
if event.contains(PollEvent::POLLRDNORM) {
144-
result.insert(PollEvent::POLLRDNORM);
145-
}
146-
if event.contains(PollEvent::POLLRDBAND) {
147-
result.insert(PollEvent::POLLRDBAND);
148-
}
134+
avail.insert(
135+
PollEvent::POLLIN | PollEvent::POLLRDNORM | PollEvent::POLLRDBAND,
136+
);
149137
}
138+
139+
event & avail
150140
} else {
151-
result.insert(PollEvent::POLLNVAL);
152-
}
141+
PollEvent::POLLNVAL
142+
};
153143

154-
if result.is_empty() {
144+
if ret.is_empty() {
155145
socket.register_recv_waker(cx.waker());
156146
socket.register_send_waker(cx.waker());
157147
Poll::Pending
158148
} else {
159-
Poll::Ready(Ok(result))
149+
Poll::Ready(Ok(ret))
160150
}
161151
})
162152
})

‎src/fd/stdio.rs‎

Lines changed: 8 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -84,19 +84,8 @@ pub struct GenericStdout;
8484
#[async_trait]
8585
impl ObjectInterface for GenericStdout {
8686
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
87-
let mut result: PollEvent = PollEvent::empty();
88-
89-
if event.contains(PollEvent::POLLOUT) {
90-
result.insert(PollEvent::POLLOUT);
91-
}
92-
if event.contains(PollEvent::POLLWRNORM) {
93-
result.insert(PollEvent::POLLWRNORM);
94-
}
95-
if event.contains(PollEvent::POLLWRBAND) {
96-
result.insert(PollEvent::POLLWRBAND);
97-
}
98-
99-
Ok(result)
87+
let available = PollEvent::POLLOUT | PollEvent::POLLWRNORM | PollEvent::POLLWRBAND;
88+
Ok(event & available)
10089
}
10190

10291
async fn async_write(&self, buf: &[u8]) -> Result<usize, IoError> {
@@ -119,19 +108,8 @@ pub struct GenericStderr;
119108
#[async_trait]
120109
impl ObjectInterface for GenericStderr {
121110
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
122-
let mut result: PollEvent = PollEvent::empty();
123-
124-
if event.contains(PollEvent::POLLOUT) {
125-
result.insert(PollEvent::POLLOUT);
126-
}
127-
if event.contains(PollEvent::POLLWRNORM) {
128-
result.insert(PollEvent::POLLWRNORM);
129-
}
130-
if event.contains(PollEvent::POLLWRBAND) {
131-
result.insert(PollEvent::POLLWRBAND);
132-
}
133-
134-
Ok(result)
111+
let available = PollEvent::POLLOUT | PollEvent::POLLWRNORM | PollEvent::POLLWRBAND;
112+
Ok(event & available)
135113
}
136114

137115
async fn async_write(&self, buf: &[u8]) -> Result<usize, IoError> {
@@ -165,19 +143,8 @@ pub struct UhyveStdout;
165143
#[async_trait]
166144
impl ObjectInterface for UhyveStdout {
167145
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
168-
let mut result: PollEvent = PollEvent::empty();
169-
170-
if event.contains(PollEvent::POLLOUT) {
171-
result.insert(PollEvent::POLLOUT);
172-
}
173-
if event.contains(PollEvent::POLLWRNORM) {
174-
result.insert(PollEvent::POLLWRNORM);
175-
}
176-
if event.contains(PollEvent::POLLWRBAND) {
177-
result.insert(PollEvent::POLLWRBAND);
178-
}
179-
180-
Ok(result)
146+
let available = PollEvent::POLLOUT | PollEvent::POLLWRNORM | PollEvent::POLLWRBAND;
147+
Ok(event & available)
181148
}
182149

183150
async fn async_write(&self, buf: &[u8]) -> Result<usize, IoError> {
@@ -200,19 +167,8 @@ pub struct UhyveStderr;
200167
#[async_trait]
201168
impl ObjectInterface for UhyveStderr {
202169
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
203-
let mut result: PollEvent = PollEvent::empty();
204-
205-
if event.contains(PollEvent::POLLOUT) {
206-
result.insert(PollEvent::POLLOUT);
207-
}
208-
if event.contains(PollEvent::POLLWRNORM) {
209-
result.insert(PollEvent::POLLWRNORM);
210-
}
211-
if event.contains(PollEvent::POLLWRBAND) {
212-
result.insert(PollEvent::POLLWRBAND);
213-
}
214-
215-
Ok(result)
170+
let available = PollEvent::POLLOUT | PollEvent::POLLWRNORM | PollEvent::POLLWRBAND;
171+
Ok(event & available)
216172
}
217173

218174
async fn async_write(&self, buf: &[u8]) -> Result<usize, IoError> {

‎src/fs/mem.rs‎

Lines changed: 11 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -50,21 +50,16 @@ struct RomFileInterface {
5050
#[async_trait]
5151
impl ObjectInterface for RomFileInterface {
5252
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
53-
let mut result: PollEvent = PollEvent::empty();
5453
let len = self.inner.read().await.data.len();
5554
let pos = *self.pos.lock().await;
5655

57-
if event.contains(PollEvent::POLLIN) && pos < len {
58-
result.insert(PollEvent::POLLIN);
59-
}
60-
if event.contains(PollEvent::POLLRDNORM) && pos < len {
61-
result.insert(PollEvent::POLLRDNORM);
62-
}
63-
if event.contains(PollEvent::POLLRDBAND) && pos < len {
64-
result.insert(PollEvent::POLLRDBAND);
65-
}
56+
let ret = if pos < len {
57+
event.intersection(PollEvent::POLLIN | PollEvent::POLLRDNORM | PollEvent::POLLRDBAND)
58+
} else {
59+
PollEvent::empty()
60+
};
6661

67-
Ok(result)
62+
Ok(ret)
6863
}
6964

7065
async fn async_read(&self, buf: &mut [u8]) -> Result<usize, IoError> {
@@ -135,30 +130,16 @@ pub struct RamFileInterface {
135130
#[async_trait]
136131
impl ObjectInterface for RamFileInterface {
137132
async fn poll(&self, event: PollEvent) -> Result<PollEvent, IoError> {
138-
let mut result: PollEvent = PollEvent::empty();
139133
let len = self.inner.read().await.data.len();
140134
let pos = *self.pos.lock().await;
141135

142-
if event.contains(PollEvent::POLLIN) && pos < len {
143-
result.insert(PollEvent::POLLIN);
144-
}
145-
if event.contains(PollEvent::POLLRDNORM) && pos < len {
146-
result.insert(PollEvent::POLLRDNORM);
147-
}
148-
if event.contains(PollEvent::POLLRDBAND) && pos < len {
149-
result.insert(PollEvent::POLLRDBAND);
150-
}
151-
if event.contains(PollEvent::POLLOUT) {
152-
result.insert(PollEvent::POLLOUT);
153-
}
154-
if event.contains(PollEvent::POLLWRNORM) {
155-
result.insert(PollEvent::POLLWRNORM);
156-
}
157-
if event.contains(PollEvent::POLLWRBAND) {
158-
result.insert(PollEvent::POLLWRBAND);
136+
let mut available = PollEvent::POLLOUT | PollEvent::POLLWRNORM | PollEvent::POLLWRBAND;
137+
138+
if pos < len {
139+
available.insert(PollEvent::POLLIN | PollEvent::POLLRDNORM | PollEvent::POLLRDBAND);
159140
}
160141

161-
Ok(result)
142+
Ok(event & available)
162143
}
163144

164145
async fn async_read(&self, buf: &mut [u8]) -> Result<usize, IoError> {

0 commit comments

Comments
 (0)