@@ -129,7 +129,10 @@ impl AsyncRead for DuplexStream {
129129 cx : & mut task:: Context < ' _ > ,
130130 buf : & mut ReadBuf < ' _ > ,
131131 ) -> Poll < std:: io:: Result < ( ) > > {
132- Pin :: new ( & mut * self . read . lock ( ) ) . poll_read ( cx, buf)
132+ let mut wakers = Wakers :: default ( ) ;
133+ let ret = Pin :: new ( & mut * self . read . lock ( ) ) . poll_read_deferred ( cx, buf, & mut wakers) ;
134+ wakers. wake ( ) ;
135+ ret
133136 }
134137}
135138
@@ -140,15 +143,22 @@ impl AsyncWrite for DuplexStream {
140143 cx : & mut task:: Context < ' _ > ,
141144 buf : & [ u8 ] ,
142145 ) -> Poll < std:: io:: Result < usize > > {
143- Pin :: new ( & mut * self . write . lock ( ) ) . poll_write ( cx, buf)
146+ let mut wakers = Wakers :: default ( ) ;
147+ let ret = Pin :: new ( & mut * self . write . lock ( ) ) . poll_write_deferred ( cx, buf, & mut wakers) ;
148+ wakers. wake ( ) ;
149+ ret
144150 }
145151
146152 fn poll_write_vectored (
147153 self : Pin < & mut Self > ,
148154 cx : & mut task:: Context < ' _ > ,
149155 bufs : & [ std:: io:: IoSlice < ' _ > ] ,
150156 ) -> Poll < Result < usize , std:: io:: Error > > {
151- Pin :: new ( & mut * self . write . lock ( ) ) . poll_write_vectored ( cx, bufs)
157+ let mut wakers = Wakers :: default ( ) ;
158+ let ret =
159+ Pin :: new ( & mut * self . write . lock ( ) ) . poll_write_vectored_deferred ( cx, bufs, & mut wakers) ;
160+ wakers. wake ( ) ;
161+ ret
152162 }
153163
154164 fn is_write_vectored ( & self ) -> bool {
@@ -166,17 +176,51 @@ impl AsyncWrite for DuplexStream {
166176 #[ allow( unused_mut) ]
167177 fn poll_shutdown (
168178 mut self : Pin < & mut Self > ,
169- cx : & mut task:: Context < ' _ > ,
179+ _ : & mut task:: Context < ' _ > ,
170180 ) -> Poll < std:: io:: Result < ( ) > > {
171- Pin :: new ( & mut * self . write . lock ( ) ) . poll_shutdown ( cx)
181+ let read_waker = self . write . lock ( ) . close_write ( ) ;
182+ if let Some ( waker) = read_waker {
183+ waker. wake ( ) ;
184+ }
185+ Poll :: Ready ( Ok ( ( ) ) )
172186 }
173187}
174188
175189impl Drop for DuplexStream {
176190 fn drop ( & mut self ) {
177191 // notify the other side of the closure
178- self . write . lock ( ) . close_write ( ) ;
179- self . read . lock ( ) . close_read ( ) ;
192+ let read_waker = self . write . lock ( ) . close_write ( ) ;
193+ let write_waker = self . read . lock ( ) . close_read ( ) ;
194+ // wake after releasing the locks, as the wakers may access the pipe
195+ if let Some ( waker) = read_waker {
196+ waker. wake ( ) ;
197+ }
198+ if let Some ( waker) = write_waker {
199+ waker. wake ( ) ;
200+ }
201+ }
202+ }
203+
204+ /// Wakers taken out of a `SimplexStream` by a read or write.
205+ ///
206+ /// A `DuplexStream` keeps its `SimplexStream`s behind a mutex, and wakes and
207+ /// drops these wakers only after releasing it, as they may access the pipe.
208+ /// The halves returned by `simplex()` are still polled under the mutex in
209+ /// `split`.
210+ #[ derive( Default ) ]
211+ struct Wakers {
212+ /// The waker of the other side of the pipe, which needs to be woken.
213+ wake : Option < Waker > ,
214+ /// The previously registered waker, which was replaced by a new one.
215+ replaced : Option < Waker > ,
216+ }
217+
218+ impl Wakers {
219+ fn wake ( self ) {
220+ if let Some ( waker) = self . wake {
221+ waker. wake ( ) ;
222+ }
223+ drop ( self . replaced ) ;
180224 }
181225}
182226
@@ -229,26 +273,27 @@ impl SimplexStream {
229273 }
230274 }
231275
232- fn close_write ( & mut self ) {
276+ /// Closes the pipe and returns the reader's waker, which needs to be woken
277+ /// so it learns that no more data will come.
278+ #[ must_use]
279+ fn close_write ( & mut self ) -> Option < Waker > {
233280 self . is_closed = true ;
234- // needs to notify any readers that no more data will come
235- if let Some ( waker) = self . read_waker . take ( ) {
236- waker. wake ( ) ;
237- }
281+ self . read_waker . take ( )
238282 }
239283
240- fn close_read ( & mut self ) {
284+ /// Closes the pipe and returns the writer's waker, which needs to be woken
285+ /// so it learns that it has to abort.
286+ #[ must_use]
287+ fn close_read ( & mut self ) -> Option < Waker > {
241288 self . is_closed = true ;
242- // needs to notify any writers that they have to abort
243- if let Some ( waker) = self . write_waker . take ( ) {
244- waker. wake ( ) ;
245- }
289+ self . write_waker . take ( )
246290 }
247291
248292 fn poll_read_internal (
249293 mut self : Pin < & mut Self > ,
250294 cx : & mut task:: Context < ' _ > ,
251295 buf : & mut ReadBuf < ' _ > ,
296+ wakers : & mut Wakers ,
252297 ) -> Poll < std:: io:: Result < ( ) > > {
253298 if self . buffer . has_remaining ( ) {
254299 let max = self . buffer . remaining ( ) . min ( buf. remaining ( ) ) ;
@@ -257,15 +302,13 @@ impl SimplexStream {
257302 if max > 0 {
258303 // The passed `buf` might have been empty, don't wake up if
259304 // no bytes have been moved.
260- if let Some ( waker) = self . write_waker . take ( ) {
261- waker. wake ( ) ;
262- }
305+ wakers. wake = self . write_waker . take ( ) ;
263306 }
264307 Poll :: Ready ( Ok ( ( ) ) )
265308 } else if self . is_closed {
266309 Poll :: Ready ( Ok ( ( ) ) )
267310 } else {
268- self . read_waker = Some ( cx. waker ( ) . clone ( ) ) ;
311+ wakers . replaced = self . read_waker . replace ( cx. waker ( ) . clone ( ) ) ;
269312 Poll :: Pending
270313 }
271314 }
@@ -274,35 +317,35 @@ impl SimplexStream {
274317 mut self : Pin < & mut Self > ,
275318 cx : & mut task:: Context < ' _ > ,
276319 buf : & [ u8 ] ,
320+ wakers : & mut Wakers ,
277321 ) -> Poll < std:: io:: Result < usize > > {
278322 if self . is_closed {
279323 return Poll :: Ready ( Err ( std:: io:: ErrorKind :: BrokenPipe . into ( ) ) ) ;
280324 }
281325 let avail = self . max_buf_size - self . buffer . len ( ) ;
282326 if avail == 0 {
283- self . write_waker = Some ( cx. waker ( ) . clone ( ) ) ;
327+ wakers . replaced = self . write_waker . replace ( cx. waker ( ) . clone ( ) ) ;
284328 return Poll :: Pending ;
285329 }
286330
287331 let len = buf. len ( ) . min ( avail) ;
288332 self . buffer . extend_from_slice ( & buf[ ..len] ) ;
289- if let Some ( waker) = self . read_waker . take ( ) {
290- waker. wake ( ) ;
291- }
333+ wakers. wake = self . read_waker . take ( ) ;
292334 Poll :: Ready ( Ok ( len) )
293335 }
294336
295337 fn poll_write_vectored_internal (
296338 mut self : Pin < & mut Self > ,
297339 cx : & mut task:: Context < ' _ > ,
298340 bufs : & [ std:: io:: IoSlice < ' _ > ] ,
341+ wakers : & mut Wakers ,
299342 ) -> Poll < Result < usize , std:: io:: Error > > {
300343 if self . is_closed {
301344 return Poll :: Ready ( Err ( std:: io:: ErrorKind :: BrokenPipe . into ( ) ) ) ;
302345 }
303346 let avail = self . max_buf_size - self . buffer . len ( ) ;
304347 if avail == 0 {
305- self . write_waker = Some ( cx. waker ( ) . clone ( ) ) ;
348+ wakers . replaced = self . write_waker . replace ( cx. waker ( ) . clone ( ) ) ;
306349 return Poll :: Pending ;
307350 }
308351
@@ -317,24 +360,21 @@ impl SimplexStream {
317360 rem -= len;
318361 }
319362
320- if let Some ( waker) = self . read_waker . take ( ) {
321- waker. wake ( ) ;
322- }
363+ wakers. wake = self . read_waker . take ( ) ;
323364 Poll :: Ready ( Ok ( avail - rem) )
324365 }
325- }
326366
327- impl AsyncRead for SimplexStream {
328367 cfg_coop ! {
329- fn poll_read (
368+ fn poll_read_deferred (
330369 self : Pin <& mut Self >,
331370 cx: & mut task:: Context <' _>,
332371 buf: & mut ReadBuf <' _>,
372+ wakers: & mut Wakers ,
333373 ) -> Poll <std:: io:: Result <( ) >> {
334374 ready!( crate :: trace:: trace_leaf( cx) ) ;
335375 let coop = ready!( crate :: task:: coop:: poll_proceed( cx) ) ;
336376
337- let ret = self . poll_read_internal( cx, buf) ;
377+ let ret = self . poll_read_internal( cx, buf, wakers ) ;
338378 if ret. is_ready( ) {
339379 coop. made_progress( ) ;
340380 }
@@ -343,28 +383,28 @@ impl AsyncRead for SimplexStream {
343383 }
344384
345385 cfg_not_coop ! {
346- fn poll_read (
386+ fn poll_read_deferred (
347387 self : Pin <& mut Self >,
348388 cx: & mut task:: Context <' _>,
349389 buf: & mut ReadBuf <' _>,
390+ wakers: & mut Wakers ,
350391 ) -> Poll <std:: io:: Result <( ) >> {
351392 ready!( crate :: trace:: trace_leaf( cx) ) ;
352- self . poll_read_internal( cx, buf)
393+ self . poll_read_internal( cx, buf, wakers )
353394 }
354395 }
355- }
356396
357- impl AsyncWrite for SimplexStream {
358397 cfg_coop ! {
359- fn poll_write (
398+ fn poll_write_deferred (
360399 self : Pin <& mut Self >,
361400 cx: & mut task:: Context <' _>,
362401 buf: & [ u8 ] ,
402+ wakers: & mut Wakers ,
363403 ) -> Poll <std:: io:: Result <usize >> {
364404 ready!( crate :: trace:: trace_leaf( cx) ) ;
365405 let coop = ready!( crate :: task:: coop:: poll_proceed( cx) ) ;
366406
367- let ret = self . poll_write_internal( cx, buf) ;
407+ let ret = self . poll_write_internal( cx, buf, wakers ) ;
368408 if ret. is_ready( ) {
369409 coop. made_progress( ) ;
370410 }
@@ -373,26 +413,28 @@ impl AsyncWrite for SimplexStream {
373413 }
374414
375415 cfg_not_coop ! {
376- fn poll_write (
416+ fn poll_write_deferred (
377417 self : Pin <& mut Self >,
378418 cx: & mut task:: Context <' _>,
379419 buf: & [ u8 ] ,
420+ wakers: & mut Wakers ,
380421 ) -> Poll <std:: io:: Result <usize >> {
381422 ready!( crate :: trace:: trace_leaf( cx) ) ;
382- self . poll_write_internal( cx, buf)
423+ self . poll_write_internal( cx, buf, wakers )
383424 }
384425 }
385426
386427 cfg_coop ! {
387- fn poll_write_vectored (
428+ fn poll_write_vectored_deferred (
388429 self : Pin <& mut Self >,
389430 cx: & mut task:: Context <' _>,
390431 bufs: & [ std:: io:: IoSlice <' _>] ,
432+ wakers: & mut Wakers ,
391433 ) -> Poll <Result <usize , std:: io:: Error >> {
392434 ready!( crate :: trace:: trace_leaf( cx) ) ;
393435 let coop = ready!( crate :: task:: coop:: poll_proceed( cx) ) ;
394436
395- let ret = self . poll_write_vectored_internal( cx, bufs) ;
437+ let ret = self . poll_write_vectored_internal( cx, bufs, wakers ) ;
396438 if ret. is_ready( ) {
397439 coop. made_progress( ) ;
398440 }
@@ -401,15 +443,53 @@ impl AsyncWrite for SimplexStream {
401443 }
402444
403445 cfg_not_coop ! {
404- fn poll_write_vectored (
446+ fn poll_write_vectored_deferred (
405447 self : Pin <& mut Self >,
406448 cx: & mut task:: Context <' _>,
407449 bufs: & [ std:: io:: IoSlice <' _>] ,
450+ wakers: & mut Wakers ,
408451 ) -> Poll <Result <usize , std:: io:: Error >> {
409452 ready!( crate :: trace:: trace_leaf( cx) ) ;
410- self . poll_write_vectored_internal( cx, bufs)
453+ self . poll_write_vectored_internal( cx, bufs, wakers )
411454 }
412455 }
456+ }
457+
458+ impl AsyncRead for SimplexStream {
459+ fn poll_read (
460+ self : Pin < & mut Self > ,
461+ cx : & mut task:: Context < ' _ > ,
462+ buf : & mut ReadBuf < ' _ > ,
463+ ) -> Poll < std:: io:: Result < ( ) > > {
464+ let mut wakers = Wakers :: default ( ) ;
465+ let ret = self . poll_read_deferred ( cx, buf, & mut wakers) ;
466+ wakers. wake ( ) ;
467+ ret
468+ }
469+ }
470+
471+ impl AsyncWrite for SimplexStream {
472+ fn poll_write (
473+ self : Pin < & mut Self > ,
474+ cx : & mut task:: Context < ' _ > ,
475+ buf : & [ u8 ] ,
476+ ) -> Poll < std:: io:: Result < usize > > {
477+ let mut wakers = Wakers :: default ( ) ;
478+ let ret = self . poll_write_deferred ( cx, buf, & mut wakers) ;
479+ wakers. wake ( ) ;
480+ ret
481+ }
482+
483+ fn poll_write_vectored (
484+ self : Pin < & mut Self > ,
485+ cx : & mut task:: Context < ' _ > ,
486+ bufs : & [ std:: io:: IoSlice < ' _ > ] ,
487+ ) -> Poll < Result < usize , std:: io:: Error > > {
488+ let mut wakers = Wakers :: default ( ) ;
489+ let ret = self . poll_write_vectored_deferred ( cx, bufs, & mut wakers) ;
490+ wakers. wake ( ) ;
491+ ret
492+ }
413493
414494 fn is_write_vectored ( & self ) -> bool {
415495 true
@@ -423,7 +503,9 @@ impl AsyncWrite for SimplexStream {
423503 mut self : Pin < & mut Self > ,
424504 _: & mut task:: Context < ' _ > ,
425505 ) -> Poll < std:: io:: Result < ( ) > > {
426- self . close_write ( ) ;
506+ if let Some ( waker) = self . close_write ( ) {
507+ waker. wake ( ) ;
508+ }
427509 Poll :: Ready ( Ok ( ( ) ) )
428510 }
429511}
0 commit comments