Skip to content

Commit df4443e

Browse files
committed
Merge 'tokio-1.51.6' into 'tokio-1.53.x' (#8638)
2 parents c5e4d9e + f00b2e6 commit df4443e

7 files changed

Lines changed: 370 additions & 58 deletions

File tree

‎tokio/CHANGELOG.md‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -208,6 +208,33 @@ This release reverts the LIFO slot stealing change introduced in 1.51.0
208208
[#8035]: https://github.com/tokio-rs/tokio/pull/8035
209209
[#8040]: https://github.com/tokio-rs/tokio/pull/8040
210210

211+
# 1.51.6 (October 13th, 2026)
212+
213+
### Added
214+
215+
- io: add `AsyncFd::register` and `AsyncFd::register_with_interest` ([#8587])
216+
217+
### Changed
218+
219+
- io: deprecate `AsyncFd::{new, with_interest, try_new, try_with_interest}` ([#8587])
220+
221+
### Fixed
222+
223+
- io: wake and drop `DuplexStream` wakers outside the lock ([#8618])
224+
- macros: avoid `unreachable_code` in `join!` and `try_join!` for `Infallible` ([#8518])
225+
- runtime: fix paused time auto-advancing when I/O wakes a task on `current_thread` ([#8595])
226+
- sync: wake waiters outside the lock when closing a semaphore ([#8529])
227+
- test: fix several flaky tests ([#8196], [#8427], [#8609])
228+
229+
[#8196]: https://github.com/tokio-rs/tokio/pull/8196
230+
[#8427]: https://github.com/tokio-rs/tokio/pull/8427
231+
[#8518]: https://github.com/tokio-rs/tokio/pull/8518
232+
[#8529]: https://github.com/tokio-rs/tokio/pull/8529
233+
[#8587]: https://github.com/tokio-rs/tokio/pull/8587
234+
[#8595]: https://github.com/tokio-rs/tokio/pull/8595
235+
[#8609]: https://github.com/tokio-rs/tokio/pull/8609
236+
[#8618]: https://github.com/tokio-rs/tokio/pull/8618
237+
211238
# 1.51.5 (October 3rd, 2026)
212239

213240
### Fixed

‎tokio/src/io/util/mem.rs‎

Lines changed: 128 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -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

175189
impl 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

Comments
 (0)