diff --git a/quest/m1/stream-credit/README.md b/quest/m1/stream-credit/README.md index fcda393f586..3f4b7c29445 100644 --- a/quest/m1/stream-credit/README.md +++ b/quest/m1/stream-credit/README.md @@ -37,8 +37,9 @@ which JS cannot raise; Chrome stalled at 103, Firefox at 100): quest until #7670 merges. - Decided 2026-11-07 (maintainer, /quest-plan from the API shape audit): - ✅ delete Rust's `StreamCredit` hook too, with no replacement hook - ([no-credit-hook](/quest/m1/stream-credit/no-credit-hook.md)). #7894's + ✅ delete Rust's `StreamCredit` hook too, with no replacement hook: a + transport's open waits only for credit, writing a WebTransport header as + the stream's first data. #7894's reversal removed the JS half; the Rust trait kept it because the open line reads it. Not chosen: keeping the hook and recording why. @@ -49,4 +50,3 @@ receiving every group, and nothing hanging. ## Required - [Takeover](/quest/m1/stream-credit/takeover.md) - on lite-07 a higher-priority group takes over an acknowledged stream, and a group that lost its stream resumes -- [Transports report no stream credit](/quest/m1/stream-credit/no-credit-hook.md) - `StreamCredit` and the `poll::Session::stream_credit` hook are gone, and the open line infers a credit wait from its own state diff --git a/quest/m1/stream-credit/no-credit-hook.md b/quest/m1/stream-credit/no-credit-hook.md deleted file mode 100644 index 301831fb95d..00000000000 --- a/quest/m1/stream-credit/no-credit-hook.md +++ /dev/null @@ -1,29 +0,0 @@ -# [S] Transports report no stream credit - -## Goal - -`moq_net::transport::StreamCredit`, `Dir`, and the `poll::Session::stream_credit` -hook are gone, so no transport implements a credit API. The open line -(`rs/moq-net/src/transport/open.rs`) decides when a waiting open preempts a -lower-ranked stream from its own state, as `js/net` already does, and an -open waiting on something other than credit still never triggers a reset. - -## Plan - -Decided 2026-11-07 (maintainer, /quest-plan from the API shape audit): -✅ "Delete, no hooks" (rejected: keeping the hook and recording why). This -follows the [moq-dev/moq#7894](https://github.com/moq-dev/moq/pull/7894) -reversal recorded in this epic ("the signal is the open line's waiting -state, with no transport credit or blocked API") and overrides -[moq-dev/moq#8088](https://github.com/moq-dev/moq/pull/8088)'s refutation, -which kept the hook because the open line reads it. - -The hook exists today so an open waiting on a WebTransport stream header is -not mistaken for a credit wait (`make_room`, open.rs). Remove that case at -its source, for example by having a transport's open complete only once -credit is granted and write the header after, so a pending head always means -credit. Implementers of `poll::Session` (moq-tokio, moq-uring, qmux, the -memory transport) drop their implementations. - -Breaking for transport implementers; the Impact section says what replaces -the hook. diff --git a/rs/moq-net/src/transport.rs b/rs/moq-net/src/transport.rs index 4d2c12aa27f..3d4337dbeed 100644 --- a/rs/moq-net/src/transport.rs +++ b/rs/moq-net/src/transport.rs @@ -164,37 +164,6 @@ impl ReceiveWindow { } } -/// Which streams a session opens: one-way, or both ways. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Dir { - /// Unidirectional streams. - Uni, - /// Bidirectional streams. - Bi, -} - -/// The streams a peer still lets this side open in one direction, as the transport last heard. -/// -/// A peer grants a bounded number of streams, and an open beyond them waits for it to grant -/// more. A session reads this to tell an open waiting for that credit from one waiting on -/// anything else. See [`poll::Session::stream_credit`]. -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -#[non_exhaustive] -pub struct StreamCredit { - /// The streams this side may still open before the peer grants more. - pub available: u64, - /// Whether an open was refused for lack of credit since the peer last granted more, so - /// this side waits for the peer, as QUIC's STREAMS_BLOCKED says. - pub blocked: bool, -} - -impl StreamCredit { - /// `available` streams left, `blocked` once an open was refused for lack of them. - pub fn new(available: u64, blocked: bool) -> Self { - Self { available, blocked } - } -} - /// Limits to change on a live session with [`poll::Session::set_limits`]. Each `None` leaves /// its limit as it is. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] @@ -429,16 +398,6 @@ pub mod poll { Err(super::LimitsError::Unsupported) } - /// Return the peer's stream credit in `dir`, or `None` when the transport cannot say, - /// as a browser's WebTransport cannot. - /// - /// Read whenever an open waits, so the session knows whether the peer's credit is what - /// it waits for. - fn stream_credit(&self, dir: super::Dir) -> Option { - let _ = dir; - None - } - /// Export 32 bytes of keying material from this session's handshake under `label` and /// `context` (RFC 8446 section 7.5), or `None` when the transport has no exporter. /// @@ -659,10 +618,6 @@ pub mod poll { (**self).set_limits(limits) } - fn stream_credit(&self, dir: super::Dir) -> Option { - (**self).stream_credit(dir) - } - fn export_keying_material(&self, label: &[u8], context: &[u8]) -> Option<[u8; 32]> { (**self).export_keying_material(label, context) } diff --git a/rs/moq-net/src/transport/boxed.rs b/rs/moq-net/src/transport/boxed.rs index 91350aaeabe..71afba9795f 100644 --- a/rs/moq-net/src/transport/boxed.rs +++ b/rs/moq-net/src/transport/boxed.rs @@ -12,9 +12,9 @@ use std::task::{Poll, ready}; use bytes::{Buf, Bytes}; -use super::open::{self, Open}; +use super::open::{self, Dir, Open}; use super::poll::{self, SendOptions}; -use super::{Address, CloseKind, Dir, Limits, LimitsError, Probe, ReceiveWindow, StreamCredit, Wire}; +use super::{Address, CloseKind, Limits, LimitsError, Probe, ReceiveWindow, Wire}; /// A boxed [`poll::Boxable`] session, shared by every task that uses it. #[derive(Clone)] @@ -35,7 +35,7 @@ impl Session { session, }); Self { - opens: Arc::new(open::Lines::new(Arc::downgrade(&inner))), + opens: Default::default(), inner, closing: Default::default(), work: Default::default(), @@ -168,15 +168,6 @@ impl Shared { /// open: once it is gone, nothing is paused. type Budget = Weak>; -/// The transport a session's lines read the peer's stream credit from, which they never keep -/// open. -pub(super) type Transport = Weak>; - -/// The peer's stream credit in `dir`, or `None` once the transport is gone or cannot say. -pub(super) fn stream_credit(transport: &Transport, dir: Dir) -> Option { - transport.upgrade()?.session.stream_credit(dir) -} - /// A boxed transport error, keeping both code registries and the message. #[derive(Debug)] pub(crate) struct Error(Box); @@ -580,7 +571,6 @@ pub(super) trait ErasedSession: Send + Sync { fn probe(&self) -> Option; fn receive_window(&self) -> Option; fn set_limits(&self, limits: Limits) -> Result<(), LimitsError>; - fn stream_credit(&self, dir: Dir) -> Option; fn export_keying_material(&self, label: &[u8], context: &[u8]) -> Option<[u8; 32]>; } @@ -722,10 +712,6 @@ impl ErasedSession for S { poll::Session::set_limits(self, limits) } - fn stream_credit(&self, dir: Dir) -> Option { - poll::Session::stream_credit(self, dir) - } - fn export_keying_material(&self, label: &[u8], context: &[u8]) -> Option<[u8; 32]> { poll::Session::export_keying_material(self, label, context) } @@ -931,10 +917,6 @@ impl poll::Session for Session { self.inner.session.set_limits(limits) } - fn stream_credit(&self, dir: Dir) -> Option { - self.inner.session.stream_credit(dir) - } - fn export_keying_material(&self, label: &[u8], context: &[u8]) -> Option<[u8; 32]> { self.inner.session.export_keying_material(label, context) } diff --git a/rs/moq-net/src/transport/memory.rs b/rs/moq-net/src/transport/memory.rs index d982bacc455..799e4c34ddf 100644 --- a/rs/moq-net/src/transport/memory.rs +++ b/rs/moq-net/src/transport/memory.rs @@ -30,10 +30,7 @@ use std::{ collections::VecDeque, pin::Pin, - sync::{ - Arc, - atomic::{AtomicBool, Ordering}, - }, + sync::Arc, task::{Poll, ready}, time::Duration, }; @@ -216,9 +213,6 @@ type Credit = Arc; #[derive(Default)] struct Open { count: usize, - /// Whether an open pended since a stream last returned its credit. Atomic, so a pending - /// open's read-only check sets it without waking itself. - blocked: AtomicBool, } /// Counted in an open-stream total until dropped. @@ -228,7 +222,6 @@ impl Drop for Opened { fn drop(&mut self) { let mut open = self.0.lock(); open.count -= 1; - *open.blocked.get_mut() = false; } } @@ -248,7 +241,6 @@ fn poll_credit( if open.count < max { return Poll::Ready(()); } - open.blocked.store(true, Ordering::Relaxed); Poll::Pending }) else { return closed.map(Err); @@ -257,18 +249,6 @@ fn poll_credit( Poll::Ready(Ok(Some(Arc::new(Opened(open.clone()))))) } -/// What is left of `max` streams beyond those in `open`, unbounded without a `max`. -fn stream_credit(open: &kio::Shared, max: Option) -> super::StreamCredit { - let Some(max) = max else { - return super::StreamCredit::new(u64::MAX, false); - }; - let open = open.read(); - super::StreamCredit::new( - max.saturating_sub(open.count) as u64, - open.blocked.load(Ordering::Relaxed), - ) -} - /// Streams and datagrams one side has yet to accept. struct Incoming { uni: kio::Queue, @@ -451,15 +431,6 @@ impl poll::Session for Session { )) } - fn stream_credit(&self, dir: super::Dir) -> Option { - let outgoing = self.side.outgoing(); - let config = &self.conn().config; - Some(match dir { - super::Dir::Uni => stream_credit(&outgoing.uni_open, config.max_concurrent_uni_streams), - super::Dir::Bi => stream_credit(&outgoing.bi_open, config.max_concurrent_bi_streams), - }) - } - fn export_keying_material(&self, label: &[u8], context: &[u8]) -> Option<[u8; 32]> { // Length-prefixed, so no label and context pair collides with another. let lengths = [u8::try_from(label.len()).ok()?, u8::try_from(context.len()).ok()?]; @@ -821,7 +792,6 @@ mod tests { task::{Wake, Waker}, }; - use super::super::{Dir, StreamCredit}; use super::*; use poll::{RecvStream as _, SendStream as _, Session as _}; @@ -948,19 +918,14 @@ mod tests { ..Default::default() }); let open = |a: &Session, waiter: &kio::Waiter| a.poll_open_uni(waiter, Default::default()); - let credit = |a: &Session| a.stream_credit(Dir::Uni).unwrap(); - assert_eq!(credit(&a), StreamCredit::new(2, false)); // Streams the peer has not accepted yet hold credit too. let mut finished = ready(open(&a, &noop())).unwrap(); let _reset = ready(open(&a, &noop())).unwrap(); - assert_eq!(credit(&a), StreamCredit::new(0, false), "none refused yet"); let count = Arc::new(Count::default()); let waiter = kio::Waiter::new(Waker::from(count.clone())); assert!(open(&a, &waiter).is_pending()); assert_eq!(count.0.load(Ordering::Relaxed), 0, "being blocked wakes nobody"); - assert_eq!(credit(&a), StreamCredit::new(0, true)); - assert!(!credit(&b).blocked, "each side blocks alone"); // Credit is per direction. let _back = ready(open(&b, &noop())).unwrap(); @@ -973,7 +938,6 @@ mod tests { assert!(open(&a, &waiter).is_pending(), "an unread FIN keeps the credit"); assert_eq!(ready(read(&mut recv, usize::MAX)).unwrap(), None); assert!(count.0.load(Ordering::Relaxed) > 0); - assert_eq!(credit(&a), StreamCredit::new(1, false), "returned credit unblocks"); let _third = ready(open(&a, &noop())).unwrap(); assert!(open(&a, &noop()).is_pending()); diff --git a/rs/moq-net/src/transport/open.rs b/rs/moq-net/src/transport/open.rs index 5d973cb0689..fa0b5f1fa47 100644 --- a/rs/moq-net/src/transport/open.rs +++ b/rs/moq-net/src/transport/open.rs @@ -6,9 +6,9 @@ //! ranked exactly as the transport will send their streams, and only the first in line asks //! the transport for credit, so returning credit goes to the most important open. //! -//! An open can also wait on something other than credit, such as a WebTransport stream's -//! header, so the line asks the transport's [`StreamCredit`] whether the peer is what it waits -//! for. +//! A transport's open waits only for the peer's credit, writing anything it puts in front of a +//! stream, such as a WebTransport header, as the stream's first data. So a pending head of the +//! line means the peer's credit has run out. //! //! The session also lists the group streams it has open, each with its rank and whether the //! peer has acknowledged everything written to it. A unidirectional open waiting for the peer's @@ -22,9 +22,17 @@ use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::{Arc, Mutex, Weak}; use std::task::Poll; -use super::boxed::{self, Transport}; +use super::boxed; use super::poll::SendOptions; -use super::{Dir, StreamCredit}; + +/// Which streams a session opens: one-way, or both ways. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(super) enum Dir { + /// Unidirectional streams. + Uni, + /// Bidirectional streams. + Bi, +} /// Where an open or an open stream ranks: the order the transport sends its stream in. /// @@ -122,9 +130,9 @@ impl Line { self.waiting.keys().next().copied() } - /// Say why the line starts waiting: the peer's stream credit, unless the transport reports - /// otherwise, and what the session's open group streams could make room with. - fn start(credit: Option, lines: &Lines) { + /// Say that the line starts waiting for the peer's stream credit, and what the session's open + /// group streams could make room with. + fn start(lines: &Lines) { if !tracing::enabled!(tracing::Level::DEBUG) { return; } @@ -132,23 +140,12 @@ impl Line { let open_streams = open.len(); let acknowledged = open.iter().filter(|stream| stream.acknowledged == Some(true)).count(); let lowest = open.first().map(|stream| stream.rank); - match credit { - Some(credit) if !credit.blocked => { - tracing::debug!( - available = credit.available, - open_streams, - acknowledged, - ?lowest, - "opens wait in priority order for the transport" - ) - } - _ => tracing::debug!( - open_streams, - acknowledged, - ?lowest, - "out of the peer's stream credit: opens wait in priority order" - ), - } + tracing::debug!( + open_streams, + acknowledged, + ?lowest, + "out of the peer's stream credit: opens wait in priority order" + ); } fn join(&mut self, rank: Rank) -> Key { @@ -184,27 +181,16 @@ impl Line { /// The lines of one session's opens, and the group streams it has open, shared by every task /// opening on it. +#[derive(Default)] pub(crate) struct Lines { uni: Mutex, bi: Mutex, listing: Mutex, /// The last turn handed to a send group, so every group's turn is its own. turns: AtomicU64, - /// Whose stream credit the opens wait for. - pub(super) transport: Transport, } impl Lines { - pub(super) fn new(transport: Transport) -> Self { - Self { - uni: Default::default(), - bi: Default::default(), - listing: Default::default(), - turns: AtomicU64::new(0), - transport, - } - } - /// A turn after every one handed out before. pub(super) fn next_turn(&self) -> u64 { self.turns.fetch_add(1, Ordering::Relaxed) + 1 @@ -224,13 +210,8 @@ impl Lines { self.listing().streams.remove(&key); } - /// Reset the lowest-ranked open group stream each waiting open not yet owed a reset preempts, - /// unless the transport reports it refused no open, so the open waits on something else, - /// such as a WebTransport header. + /// Reset the lowest-ranked open group stream each waiting open not yet owed a reset preempts. fn make_room(&self, line: &mut Line) { - if boxed::stream_credit(&self.transport, Dir::Uni).is_some_and(|credit| !credit.blocked) { - return; - } let owed: Vec = line.waiting.keys().skip(line.resets).map(|key| key.rank.0).collect(); if owed.is_empty() { return; @@ -324,7 +305,7 @@ impl Open { if let Poll::Ready(res) = open(waiter) { return Poll::Ready(took_turn(res, lines, options)); } - Line::start(boxed::stream_credit(&lines.transport, dir), lines); + Line::start(lines); let key = line.join(rank); line.waiting.get_mut(&key).expect("just joined").register(waiter); self.place = Some((lines.clone(), dir, key)); @@ -395,14 +376,6 @@ impl Drop for Open { } } -#[cfg(test)] -impl Default for Lines { - /// Lines without a transport, which therefore never says why they wait. - fn default() -> Self { - Self::new(std::sync::Weak::>::new()) - } -} - #[cfg(test)] mod tests { use std::sync::atomic::{AtomicUsize, Ordering}; @@ -553,40 +526,6 @@ mod tests { assert!(lines.line(Dir::Uni).waiting.is_empty()); } - /// A session reports the peer's stream credit through its line's transport, blocked once - /// an open in line was refused, and nothing once the transport is gone. - #[test] - fn the_line_reads_the_transports_credit() { - use super::super::{memory, poll::Session as _}; - - let (a, _b) = memory::pair(memory::Config { - max_concurrent_uni_streams: Some(1), - ..Default::default() - }); - let session = boxed::Session::new(a); - let waiter = kio::Waiter::noop(); - let options = || SendOptions { - group: None, - priority: 0, - }; - let mut first = Open::default(); - let opened = session.poll_open_uni(&mut first, &waiter, options()); - assert!(matches!(opened, Poll::Ready(Ok(_)))); - assert_eq!(session.stream_credit(Dir::Uni), Some(StreamCredit::new(0, false))); - - let mut second = Open::default(); - assert!(session.poll_open_uni(&mut second, &waiter, options()).is_pending()); - assert_eq!(session.stream_credit(Dir::Uni), Some(StreamCredit::new(0, true))); - let transport = session.opens.transport.clone(); - assert_eq!( - boxed::stream_credit(&transport, Dir::Uni), - Some(StreamCredit::new(0, true)) - ); - - drop((second, session)); - assert_eq!(boxed::stream_credit(&transport, Dir::Uni), None); - } - /// Out of credit, each waiting open resets the lowest stream below it, one reset in flight /// per waiting open, and opens once the peer returns the credit. #[test] diff --git a/rs/moq-quic/README.md b/rs/moq-quic/README.md index b02e532b2be..22885a320ad 100644 --- a/rs/moq-quic/README.md +++ b/rs/moq-quic/README.md @@ -97,7 +97,6 @@ Changes on top of the upstream commit, besides the renames: - **Stopped after a local reset**: moq-tokio's driver resolves `send::Finished::stopped` with `None` once the stream is reset locally, as it already did once the reset was acknowledged and the stream freed. A local reset wakes `send::Stream::poll_end`, where quinn reports no event for it, so quinn leaves a pending `stopped` waiting, and its waker registered, until the connection closes. Not offered upstream yet; quinn 0.11 has the same gap. - **Namespaced streams** (`send`, `recv`, `stream`): quinn's `SendStream`, `RecvStream`, and their error zoo become `send::Stream` and `recv::Stream` with one `send::Error` (streams and datagrams) and one `recv::Error` (reads and leases), adding `Blocked`, and `Closed` for an ID the stream no longer has state for. `send::Stream::write` takes `&mut impl Buf`, splitting a `Bytes` source off without a copy, in place of `write` and `write_chunks`, and `Datagrams::send` takes `impl Buf` the same way, so a chained header costs no copy. An outgoing stream's `send::End` (finished and acknowledged, stopped, or reset) stays queryable until `send::Stream::release`, so a driver needs no table of its own for how a stream ended. A `send::Offset` comes only from `offset()` and is tagged to its stream, so `reset_at` and `acked` cannot be handed one past the data written. A port touching a public stream method has to be redone against these names. - **Connection limits** (`Limits`, `Connection::set_limits`, and the drivers' `set_limits`): one validated call changes a live connection's stream limit and windows, refusing values a peer would reject and changing nothing then. moq-tokio and moq-uring re-export the type, so both runtimes check limits the same way. Not offered upstream: it only bundles quinn's existing setters. -- **Stream credit state** (`Streams::credit`, `Streams::blocked`): the streams the peer still lets this side open in a direction, and whether an open was refused since the peer last raised its limit, the state STREAMS\_BLOCKED reports. moq-net reads them so a waiting open knows whether the peer's credit is what it waits for. quinn exposes neither; not offered upstream yet. - **Stream credit with held streams**: batch `MAX_STREAMS` updates only while the peer still has advertised stream credit. Once it opens the last advertised stream, return freed credit even below the batch threshold, so long-lived streams cannot deadlock the others. The same threshold remains in quinn `main`; not offered upstream yet. - **Indexed send buffer** (`SendBuffer::get`): each retained write keeps its stream offset, and a STREAM frame's data comes from one binary search, instead of quinn walking every write from the oldest unacknowledged one for each piece, which costs a triangular number of visits when many small writes are in flight. Not offered upstream yet. - **No receive-state recycling** (`StreamsState::stream_recv_freed`): a completed stream's `Recv` is dropped, where quinn keeps it in `free_recv` with its chunk list at peak capacity for the next stream. Recycled state stayed allocated per peak concurrent stream for the connection's lifetime: about 550 B per stream, and about 113 KiB for one that once buffered a 2,048-packet backlog. Reusing it saved only 0.1 to 0.3% of a burst's instructions. `benches/receive_bursts.rs` measures both. Stream ID hash tables and waiter tables contract geometrically as streams go away and release every slot when empty; drained control queues and obsolete credit updates are dropped when nothing remains to send. A surviving stream cannot pin a burst's hash-table capacity. A cherry-pick touching `StreamRecv`, `free_recv`, or `reinit` has nothing to apply to. Not offered upstream yet. diff --git a/rs/moq-quic/src/connection/streams/mod.rs b/rs/moq-quic/src/connection/streams/mod.rs index 919011125de..45b97466fc6 100644 --- a/rs/moq-quic/src/connection/streams/mod.rs +++ b/rs/moq-quic/src/connection/streams/mod.rs @@ -127,17 +127,6 @@ impl<'a> Streams<'a> { Poll::Pending } - /// How many more streams the peer lets this side open in `dir` before it raises its limit. - pub fn credit(&self, dir: Dir) -> u64 { - self.state.max[dir as usize].saturating_sub(self.state.next[dir as usize]) - } - - /// Whether an open in `dir` was refused since the peer last raised its limit, so this side - /// waits for its MAX_STREAMS, as the STREAMS_BLOCKED it sends says. - pub fn blocked(&self, dir: Dir) -> bool { - self.state.open_refused[dir as usize] - } - /// The number of streams that may have unacknowledged data. pub fn send_streams(&self) -> usize { self.state.send_streams diff --git a/rs/moq-quic/src/tests/mod.rs b/rs/moq-quic/src/tests/mod.rs index 350f62ccff8..2b8315d060f 100644 --- a/rs/moq-quic/src/tests/mod.rs +++ b/rs/moq-quic/src/tests/mod.rs @@ -1566,44 +1566,19 @@ fn streams_blocked() { let mut pair = Pair::new(Default::default(), server); let (client_ch, server_ch) = pair.connect(); - assert_eq!(pair.client_streams(client_ch).credit(Dir::Uni), 1); - assert!(!pair.client_streams(client_ch).blocked(Dir::Uni)); - - // Use up the only stream slot: out of credit, but not blocked until an open is refused + // Use up the only stream slot, then try to open another let s = pair .client_streams(client_ch) .open(Dir::Uni, Default::default()) .expect("first uni stream"); - assert_eq!(pair.client_streams(client_ch).credit(Dir::Uni), 0); - assert!(!pair.client_streams(client_ch).blocked(Dir::Uni)); assert_eq!(pair.client_streams(client_ch).open(Dir::Uni, Default::default()), None); - assert!(pair.client_streams(client_ch).blocked(Dir::Uni)); - assert!( - !pair.client_streams(client_ch).blocked(Dir::Bi), - "each direction blocks alone" - ); // Send data so the STREAMS_BLOCKED piggybacks on an outgoing packet pair.client_send(client_ch, s).write(&mut &b"hi"[..]).unwrap(); - pair.client_send(client_ch, s).finish().unwrap(); pair.drive(); assert_eq!(pair.client_conn_mut(client_ch).stats().frame_tx.streams_blocked_uni, 1); assert_eq!(pair.server_conn_mut(server_ch).stats().frame_rx.streams_blocked_uni, 1); - // Still blocked once STREAMS_BLOCKED is sent: only the peer's MAX_STREAMS clears it - assert!(pair.client_streams(client_ch).blocked(Dir::Uni)); - - // The server reads the stream to its end, which frees the slot for a MAX_STREAMS - assert_eq!(pair.server_streams(server_ch).accept(Dir::Uni), Some(s)); - let mut recv = pair.server_recv(server_ch, s); - let mut chunks = recv.read().unwrap(); - assert_matches!(chunks.next(usize::MAX), Ok(Some(_))); - assert_matches!(chunks.next(usize::MAX), Ok(None)); - chunks.finalize(); - pair.drive(); - - assert_eq!(pair.client_streams(client_ch).credit(Dir::Uni), 1); - assert!(!pair.client_streams(client_ch).blocked(Dir::Uni)); } #[test] diff --git a/rs/moq-tokio/src/quic/driver/connection.rs b/rs/moq-tokio/src/quic/driver/connection.rs index 325d7a3696e..57ecb750778 100644 --- a/rs/moq-tokio/src/quic/driver/connection.rs +++ b/rs/moq-tokio/src/quic/driver/connection.rs @@ -500,18 +500,6 @@ impl Connection { self.0.state.lock().inner.export_keying_material(label, context) } - /// The peer's stream credit in `dir`, as this connection last heard it. - #[cfg(feature = "net")] - pub(crate) fn stream_credit(&self, dir: moq_net::transport::Dir) -> moq_net::transport::StreamCredit { - let dir = match dir { - moq_net::transport::Dir::Uni => Dir::Uni, - moq_net::transport::Dir::Bi => Dir::Bi, - }; - let mut state = self.0.state.lock(); - let streams = state.inner.streams(); - moq_net::transport::StreamCredit::new(streams.credit(dir), streams.blocked(dir)) - } - /// How many send streams the connection still holds state for #[cfg(test)] pub(crate) fn send_streams(&self) -> usize { diff --git a/rs/moq-tokio/src/quic/web/send.rs b/rs/moq-tokio/src/quic/web/send.rs index 8259295b714..5cb22b48842 100644 --- a/rs/moq-tokio/src/quic/web/send.rs +++ b/rs/moq-tokio/src/quic/web/send.rs @@ -7,7 +7,7 @@ use std::{ task::{Context, Poll}, }; -use bytes::Buf; +use bytes::{Buf, Bytes}; use futures::FutureExt; use crate::quic::driver::send; @@ -15,8 +15,9 @@ use crate::quic::web::CloseReason; /// A stream that can be used to send bytes. See [`crate::quic::driver::send::Stream`]. /// -/// Dropping it before [`finish`](Self::finish) resets it with code 0, still delivering the -/// WebTransport header. +/// A stream this side opened writes its WebTransport header ahead of its first data, so opening +/// one waits only for the peer's stream credit. Dropping it before [`finish`](Self::finish) +/// resets it with code 0, still delivering the header once written. /// /// This wrapper is mainly needed for error codes, which is unfortunate. /// WebTransport uses u32 error codes and they're mapped in a reserved HTTP/3 error space. @@ -24,9 +25,14 @@ use crate::quic::web::CloseReason; pub struct Stream { state: State, close: Arc, - /// The end of the WebTransport header this side wrote first, which a reset must still deliver. + /// The WebTransport header still to write ahead of any data, empty once written or for a + /// stream without one. + unwritten: Bytes, + /// The end of the WebTransport header once written, which a reset must still deliver. header: Option, id: crate::quic::driver::stream::Id, + /// Holds the waiter of an [`AsyncWrite`](tokio::io::AsyncWrite) write across polls. + park: kio::Park, } /// The mutable terminal state required by moq-net's poll trait. @@ -34,19 +40,55 @@ pub struct Stream { enum State { Open(send::Stream), Finished(send::Finished), + /// Finished before its header fit, so it was reset with nothing sent. + Unsent, /// Reset, with the peer's stop code if it arrived first. Reset(Result, send::Error>), } impl Stream { - pub(crate) fn new(mut stream: send::Stream, close: Arc, header: Option) -> Self { - stream.set_drop_reset(header, close.encode_stream_code(0)); - Self { + /// Wrap `stream`, writing `header` ahead of its data: a WebTransport stream this side + /// opened, or empty for one without a header. + pub(crate) fn new(mut stream: send::Stream, close: Arc, header: Bytes) -> Self { + stream.set_drop_reset(None, close.encode_stream_code(0)); + let mut this = Self { id: stream.id(), state: State::Open(stream), close, - header, + unwritten: header, + header: None, + park: Default::default(), + }; + // Write the header now when it fits, so the peer can accept the stream before its + // first data. Whatever does not fit waits for that data; a failure resurfaces there. + let _ = this.poll_header(&kio::Waiter::noop()); + this + } + + /// Write what is left of the WebTransport header, ready once none is left. + fn poll_header(&mut self, waiter: &kio::Waiter) -> Poll> { + if !self.unwritten.has_remaining() { + return Poll::Ready(Ok(())); } + let State::Open(stream) = &mut self.state else { + return Poll::Ready(Err(Error::ClosedStream)); + }; + while self.unwritten.has_remaining() { + if let Err(err) = std::task::ready!(stream.poll_write_buf(waiter, &mut self.unwritten)) { + return Poll::Ready(Err(self.map_error(err))); + } + } + let offset = stream.offset(); + stream.set_drop_reset(Some(offset), self.close.encode_stream_code(0)); + self.header = Some(offset); + Poll::Ready(Ok(())) + } + + /// Write from `buf` after the header, returning the size written. + fn poll_write_buf(&mut self, waiter: &kio::Waiter, buf: &mut impl Buf) -> Poll> { + std::task::ready!(self.poll_header(waiter))?; + let result = std::task::ready!(self.open()?.poll_write_buf(waiter, buf)); + Poll::Ready(result.map_err(|e| self.map_error(e))) } /// Decode the peer's stop code, and report a session error, or a stop for a session @@ -78,8 +120,8 @@ impl Stream { /// This is a u32 with WebTransport because we share the error space with HTTP/3. /// A raw QUIC session sends the code as is. Does nothing once already reset. /// - /// The WebTransport header still reaches the peer, so it can tell which session the reset - /// belongs to. + /// A WebTransport header already written still reaches the peer, so it can tell which + /// session the reset belongs to. fn reset_mut(&mut self, code: u32) { let code = self.close.encode_stream_code(code); // The driver task can process a STOP_SENDING at any moment. The reset settles, under the @@ -103,7 +145,7 @@ impl Stream { } stopped.now_or_never() } - state @ State::Reset(_) => { + state @ (State::Reset(_) | State::Unsent) => { self.state = state; return; } @@ -120,6 +162,7 @@ impl Stream { State::Open(stream) => stream.poll_closed(waiter), State::Finished(stream) => stream.poll_closed(waiter), State::Reset(result) => Poll::Ready(result.clone()), + State::Unsent => return Poll::Ready(Err(Error::Unsent)), }; result.map(|result| match result { Ok(None) => Ok(None), @@ -132,8 +175,11 @@ impl Stream { } /// Finish sending, retaining a handle to acknowledgements and peer cancellation. + /// + /// A stream whose WebTransport header never fit is reset instead, and the handle fails + /// with [`Error::Unsent`]. pub fn finish(mut self) -> Finished { - self.finish_mut(); + let _ = self.finish_mut(); Finished { stream: self, park: Default::default(), @@ -147,25 +193,40 @@ impl Stream { /// Write from `buf`, returning the size written. See [`send::Stream::write`]. pub async fn write(&mut self, buf: &mut impl Buf) -> Result { - let result = self.open()?.write(buf).await; - result.map_err(|e| self.map_error(e)) + kio::wait(|waiter| self.poll_write_buf(waiter, buf)).await } /// Write all of `buf` to the stream. See [`send::Stream::write_all`]. - pub async fn write_all(&mut self, buf: impl Buf) -> Result<(), Error> { - let result = self.open()?.write_all(buf).await; - result.map_err(|e| self.map_error(e)) + pub async fn write_all(&mut self, mut buf: impl Buf) -> Result<(), Error> { + while buf.has_remaining() { + self.write(&mut buf).await?; + } + Ok(()) } /// Mark the stream as finished, such that no more data can be written. See /// [`send::Stream::finish`]. Does nothing if it was already finished or reset. - fn finish_mut(&mut self) { - if matches!(self.state, State::Open(_)) { - let State::Open(stream) = std::mem::replace(&mut self.state, State::Reset(Ok(None))) else { - unreachable!() - }; - self.state = State::Finished(stream.finish()); + /// + /// A stream whose header still does not fit could never deliver its FIN, so it is reset + /// instead, failing with [`Error::Unsent`] here and from `poll_closed`. + fn finish_mut(&mut self) -> Result<(), Error> { + if !matches!(self.state, State::Open(_)) { + return Ok(()); + } + match self.poll_header(&kio::Waiter::noop()) { + Poll::Ready(Ok(())) => {} + Poll::Ready(Err(err)) => return Err(err), + Poll::Pending => { + self.reset_mut(0); + self.state = State::Unsent; + return Err(Error::Unsent); + } } + let State::Open(stream) = std::mem::replace(&mut self.state, State::Reset(Ok(None))) else { + unreachable!() + }; + self.state = State::Finished(stream.finish()); + Ok(()) } /// Set the priority within the stream's send group, or session-wide when ungrouped. @@ -173,7 +234,7 @@ impl Stream { match &mut self.state { State::Open(stream) => stream.set_priority(priority), State::Finished(stream) => stream.set_priority(priority), - State::Reset(_) => {} + State::Reset(_) | State::Unsent => {} } } @@ -182,7 +243,7 @@ impl Stream { match &self.state { State::Open(stream) => stream.priority(), State::Finished(stream) => stream.priority(), - State::Reset(_) => 0, + State::Reset(_) | State::Unsent => 0, } } @@ -191,7 +252,7 @@ impl Stream { match &mut self.state { State::Open(stream) => stream.set_group(group), State::Finished(stream) => stream.set_group(group), - State::Reset(_) => {} + State::Reset(_) | State::Unsent => {} } } @@ -209,11 +270,13 @@ impl Stream { } impl tokio::io::AsyncWrite for Stream { - fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll> { - match &mut self.state { - State::Open(stream) => Pin::new(stream).poll_write(cx, buf), - _ => Poll::Ready(Err(io::ErrorKind::BrokenPipe.into())), - } + fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, mut buf: &[u8]) -> Poll> { + let this = self.get_mut(); + let waiter = this.park.hold(cx).clone(); + this.poll_write_buf(&waiter, &mut buf).map_err(|err| match err { + Error::ClosedStream => io::ErrorKind::BrokenPipe.into(), + err => io::Error::other(err), + }) } fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context) -> Poll> { @@ -222,8 +285,7 @@ impl tokio::io::AsyncWrite for Stream { fn poll_shutdown(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll> { // Already finished or reset, so there is nothing left to shut. - self.finish_mut(); - Poll::Ready(Ok(())) + Poll::Ready(self.finish_mut().map_err(io::Error::other)) } } @@ -235,8 +297,7 @@ impl moq_net::transport::poll::SendStream for Stream { self.poll_write_buf(waiter, &mut buf) } fn poll_write_buf(&mut self, waiter: &kio::Waiter, buf: &mut B) -> Poll> { - let result = self.open()?.poll_write_buf(waiter, buf); - result.map_err(|e| self.map_error(e)) + Self::poll_write_buf(self, waiter, buf) } fn set_priority(&mut self, priority: i64) { Self::set_priority(self, priority); @@ -245,8 +306,7 @@ impl moq_net::transport::poll::SendStream for Stream { Self::set_group(self, Some(group)); } fn finish(&mut self) -> Result<(), Self::Error> { - Self::finish_mut(self); - Ok(()) + Self::finish_mut(self) } fn reset(&mut self, code: u32) { Self::reset_mut(self, code); @@ -259,10 +319,13 @@ impl moq_net::transport::poll::SendStream for Stream { }) } fn acknowledged(&self) -> Option { + if self.unwritten.has_remaining() { + return Some(false); + } Some(match &self.state { State::Open(stream) => stream.acknowledged(), State::Finished(stream) => stream.acknowledged(), - State::Reset(_) => false, + State::Reset(_) | State::Unsent => false, }) } } @@ -333,6 +396,11 @@ pub enum Error { /// The stream was already finished or reset. #[error("stream closed")] ClosedStream, + + /// The stream was finished before its WebTransport header fit the peer's flow control, so + /// it was reset with nothing sent. + #[error("finished before the stream header could be sent")] + Unsent, } impl From for Error { diff --git a/rs/moq-tokio/src/quic/web/session.rs b/rs/moq-tokio/src/quic/web/session.rs index 55f9b0e9b2f..699502bb25a 100644 --- a/rs/moq-tokio/src/quic/web/session.rs +++ b/rs/moq-tokio/src/quic/web/session.rs @@ -37,8 +37,6 @@ pub struct Session { // Why the session closed: set once by a local close() or the background task // when a remote CloseWebTransportSession capsule is received. close: Arc, - - opening: Arc>, } /// Whether a [`Session`] is WebTransport over HTTP/3 or a raw QUIC connection. @@ -120,7 +118,6 @@ impl Session { conn, mode: Mode::Web(Arc::new(web)), close: close.clone(), - opening: Default::default(), }; // Run a background task to read capsules from the CONNECT recv stream. @@ -244,7 +241,7 @@ impl Session { .poll_accept_bi(waiter) .map_ok(|(send, recv)| { ( - SendStream::new(send, self.close.clone(), None), + SendStream::new(send, self.close.clone(), Bytes::new()), RecvStream::new(recv, self.close.clone()), ) }) @@ -252,66 +249,29 @@ impl Session { } } - /// Open a unidirectional stream scheduled by `options`, writing its WebTransport header. + /// Open a unidirectional stream scheduled by `options`, pending only for the peer's stream + /// credit. The stream writes its WebTransport header ahead of its first data. #[kio::wrapper] pub fn poll_open_uni(&self, waiter: &Waiter, options: send::Options<'_>) -> Poll> { - self.opening.poll(waiter, |opening, cx| { - if opening.uni.is_none() { - let send = std::task::ready!(self.conn.poll_open_uni( - opening.park.hold(cx), - send::Options { - group: None, - priority: i64::MAX - } - )) - .map_err(|e| self.map_error(e))?; - let header = self.web().map_or_else(Bytes::new, |web| web.header_uni.clone()); - opening.uni = Some((send, header)); - } - let (send, header) = opening.uni.as_mut().unwrap(); - let result = std::task::ready!(poll_header(send, opening.park.hold(cx), header)); - let (mut send, _) = opening.uni.take().unwrap(); - result.map_err(|e| self.map_error(e))?; - send.set_priority(options.priority); - send.set_group(options.group); - let header = self.web().map(|_| send.offset()); - Poll::Ready(Ok(SendStream::new(send, self.close.clone(), header))) - }) + let send = std::task::ready!(self.conn.poll_open_uni(waiter, options)).map_err(|e| self.map_error(e))?; + let header = self.web().map_or_else(Bytes::new, |web| web.header_uni.clone()); + Poll::Ready(Ok(SendStream::new(send, self.close.clone(), header))) } - /// Open a bidirectional stream scheduled by `options`, writing its WebTransport header. + /// Open a bidirectional stream scheduled by `options`, pending only for the peer's stream + /// credit. The stream writes its WebTransport header ahead of its first data. #[kio::wrapper] pub fn poll_open_bi( &self, waiter: &Waiter, options: send::Options<'_>, ) -> Poll> { - self.opening.poll(waiter, |opening, cx| { - if opening.bi.is_none() { - let (mut send, recv) = std::task::ready!(self.conn.poll_open_bi( - opening.park.hold(cx), - send::Options { - group: None, - priority: i64::MAX - } - )) - .map_err(|e| self.map_error(e))?; - send.set_priority(i64::MAX); - let header = self.web().map_or_else(Bytes::new, |web| web.header_bi.clone()); - opening.bi = Some((send, recv, header)); - } - let (send, _, header) = opening.bi.as_mut().unwrap(); - let result = std::task::ready!(poll_header(send, opening.park.hold(cx), header)); - let (mut send, recv, _) = opening.bi.take().unwrap(); - result.map_err(|e| self.map_error(e))?; - send.set_priority(options.priority); - send.set_group(options.group); - let header = self.web().map(|_| send.offset()); - Poll::Ready(Ok(( - SendStream::new(send, self.close.clone(), header), - RecvStream::new(recv, self.close.clone()), - ))) - }) + let (send, recv) = std::task::ready!(self.conn.poll_open_bi(waiter, options)).map_err(|e| self.map_error(e))?; + let header = self.web().map_or_else(Bytes::new, |web| web.header_bi.clone()); + Poll::Ready(Ok(( + SendStream::new(send, self.close.clone(), header), + RecvStream::new(recv, self.close.clone()), + ))) } /// The next datagram, with its WebTransport session header removed. @@ -532,7 +492,6 @@ impl Session { conn, mode: Mode::Raw { alpn }, close: Arc::new(CloseReason::new(true)), - opening: Default::default(), } } @@ -584,24 +543,6 @@ impl Session { } } -#[derive(Default)] -struct Opening { - // Driver wakes must go through the bridge, so they cannot reenter its held lock. - park: kio::Park, - uni: Option<(send::Stream, Bytes)>, - bi: Option<(send::Stream, crate::quic::driver::recv::Stream, Bytes)>, -} - -fn poll_header(send: &mut send::Stream, waiter: &Waiter, header: &mut Bytes) -> Poll> { - while header.has_remaining() { - std::task::ready!(send.poll_write_buf(waiter, header)).map_err(|err| match err { - crate::quic::driver::send::Error::Connection(err) => Error::from(err), - err => Error::Write(err), - })?; - } - Poll::Ready(Ok(())) -} - impl fmt::Debug for Session { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.conn.fmt(f) @@ -871,7 +812,7 @@ impl SessionAccept { if let Some((send, recv)) = res { // Wrap the streams in our own types for correct error codes. // The peer opened it, so this half carries no header. - let send = SendStream::new(send, self.close.clone(), None); + let send = SendStream::new(send, self.close.clone(), Bytes::new()); let recv = RecvStream::new(recv, self.close.clone()); return Poll::Ready(Ok((send, recv))); } @@ -1067,10 +1008,6 @@ impl moq_net::transport::poll::Session for Session { .set_limits(quic) .map_err(|err| moq_net::transport::LimitsError::Refused(err.to_string())) } - /// The connection's credit, which every WebTransport session on it shares. - fn stream_credit(&self, dir: moq_net::transport::Dir) -> Option { - Some(self.conn.stream_credit(dir)) - } /// The connection's exporter on raw QUIC; on WebTransport, this session's own. fn export_keying_material(&self, label: &[u8], context: &[u8]) -> Option<[u8; 32]> { match self.web() { @@ -1329,38 +1266,61 @@ mod tests { (client.unwrap(), server.unwrap()) } - /// Both session kinds report the connection's stream credit, blocked once an open waits for - /// the peer to grant more. + /// Out of connection flow control, an open still returns its stream at once and the + /// stream's header waits for room with its data, so an open waits only for stream credit. #[tokio::test] - async fn stream_credit_follows_the_connection() { - use moq_net::transport::{Dir, StreamCredit, poll::Session as _}; + async fn an_open_waits_only_for_stream_credit() { + use moq_net::transport::poll::SendStream as _; for framed in [false, true] { let mut server_transport = crate::quic::driver::transport::Config::default(); - server_transport.limits.max_streams = std::num::NonZeroU64::new(4); + server_transport.limits.receive_window = std::num::NonZeroU64::new(16 * 1024); let (client, server, _endpoints, _gate) = gated_pair_with_transport(server_transport, Default::default()).await; - let (client, _server) = sessions(framed, client, server).await; - - // HTTP/3 spends some of the credit on its own streams before the session starts. - let start = client.stream_credit(Dir::Bi).unwrap(); - assert!(start.available > 0 && !start.blocked, "framed: {framed}"); - let mut opened = Vec::new(); - for left in (0..start.available).rev() { - opened.push(client.open_bi(send::Options::default()).await.unwrap()); - assert_eq!(client.stream_credit(Dir::Bi), Some(StreamCredit::new(left, false))); + let (client, server) = sessions(framed, client, server).await; + + // The server reads nothing yet, so the connection's window stays spent. + let payload = Bytes::from(vec![0xa5; 64 * 1024]); + let mut rest = payload.clone(); + let mut first = client.open_uni(Default::default()).await.unwrap(); + while matches!(first.poll_write_buf(&Waiter::noop(), &mut rest), Poll::Ready(Ok(_))) {} + assert!(rest.has_remaining(), "framed: {framed}"); + let Poll::Ready(Ok(mut second)) = client.poll_open_uni(&Waiter::noop(), Default::default()) else { + panic!("framed: {framed}: the open waited on more than stream credit"); + }; + // A stream finished before its header fits could never deliver its FIN. + let Poll::Ready(Ok(mut empty)) = client.poll_open_uni(&Waiter::noop(), Default::default()) else { + panic!("framed: {framed}: the open waited on more than stream credit"); + }; + if framed { + assert!(matches!( + moq_net::transport::poll::SendStream::finish(&mut empty), + Err(crate::quic::web::send::Error::Unsent) + )); + assert!(matches!( + empty.poll_closed(&Waiter::noop()), + Poll::Ready(Err(crate::quic::web::send::Error::Unsent)) + )); } - let pending = moq_net::transport::poll::Session::poll_open_bi( - &client, - &Waiter::noop(), - moq_net::transport::poll::SendOptions::default(), - ); - assert!(pending.is_pending(), "framed: {framed}"); - assert_eq!(client.stream_credit(Dir::Bi), Some(StreamCredit::new(0, true))); - assert!( - !client.stream_credit(Dir::Uni).unwrap().blocked, - "each direction blocks alone" - ); + drop(empty); + + let send = async { + first.write_all(rest).await.unwrap(); + second.write_all(&b"second"[..]).await.unwrap(); + (first.finish(), second.finish()) + }; + let recv = async { + let mut read = Vec::new(); + for _ in 0..2 { + let mut recv = server.accept_uni().await.unwrap(); + read.push(recv.read_to_end(payload.len()).await.unwrap()); + } + read.sort_by_key(Vec::len); + read + }; + let (finished, read) = tokio::join!(send, recv); + assert_eq!(read, [b"second".to_vec(), payload.to_vec()], "framed: {framed}"); + drop(finished); } } diff --git a/rs/moq-uring/src/quic/driver/connection.rs b/rs/moq-uring/src/quic/driver/connection.rs index 76785931860..85467057ab0 100644 --- a/rs/moq-uring/src/quic/driver/connection.rs +++ b/rs/moq-uring/src/quic/driver/connection.rs @@ -351,17 +351,6 @@ impl Connection { let conn = self.shared.conn.borrow(); moq_net::transport::ReceiveWindow::new(conn.receive_window(), conn.stream_receive_window()) } - - /// The peer's stream credit in `dir`, as this connection last heard it. - pub(crate) fn stream_credit(&self, dir: moq_net::transport::Dir) -> moq_net::transport::StreamCredit { - let dir = match dir { - moq_net::transport::Dir::Uni => Dir::Uni, - moq_net::transport::Dir::Bi => Dir::Bi, - }; - let mut conn = self.shared.conn.borrow_mut(); - let streams = conn.streams(); - moq_net::transport::StreamCredit::new(streams.credit(dir), streams.blocked(dir)) - } } impl Clone for Connection { diff --git a/rs/moq-uring/src/quic/web.rs b/rs/moq-uring/src/quic/web.rs index 2ee216c4119..6f867bac637 100644 --- a/rs/moq-uring/src/quic/web.rs +++ b/rs/moq-uring/src/quic/web.rs @@ -359,7 +359,6 @@ struct State { /// disabled. Clones share the session, which closes with code 0 once its last /// clone and stream are gone. pub struct Session { - opening: Rc>, handles: Rc, conn: Connection, /// The WebTransport layering, or `None` for raw QUIC. @@ -407,7 +406,6 @@ impl Session { /// WebTransport layering: streams and datagrams pass through untouched. pub fn raw(conn: Connection) -> Self { Self { - opening: Default::default(), handles: Handles::new(&conn, None), conn, web: None, @@ -483,7 +481,6 @@ impl Session { .spawn(async move { read_capsules(capsules, capsule_conn, recv).await }); Self { - opening: Default::default(), handles: Handles::new(&conn, Some(&web)), conn, web: Some(web), @@ -499,7 +496,6 @@ impl Session { impl Clone for Session { fn clone(&self) -> Self { Self { - opening: self.opening.clone(), handles: self.handles.clone(), conn: self.conn.clone(), web: self.web.clone(), @@ -516,14 +512,6 @@ impl std::fmt::Debug for Session { } } -#[derive(Default)] -struct Opening { - // Driver wakes must go through the bridge, so they cannot reenter its held lock. - park: kio::Park, - uni: Option<(SendStream, Bytes)>, - bi: Option<(SendStream, RecvStream, Bytes)>, -} - impl Session { /// The next unidirectional stream, after its session header. #[kio::wrapper] @@ -568,7 +556,7 @@ impl Session { .poll_accept_bi(waiter) .map_ok(|(send, recv)| { ( - SendStream::new(send, &self.handles, None), + SendStream::new(send, &self.handles, Bytes::new()), RecvStream::new(recv, &self.handles), ) }) @@ -578,7 +566,7 @@ impl Session { loop { if let Some((send, recv)) = state.ready_bi.pop_front() { return Poll::Ready(Ok(( - SendStream::new(send, &self.handles, None), + SendStream::new(send, &self.handles, Bytes::new()), RecvStream::new(recv, &self.handles), ))); } @@ -601,69 +589,33 @@ impl Session { }) } - /// Open a unidirectional stream scheduled by `options`. + /// Open a unidirectional stream scheduled by `options`, pending only for the peer's stream + /// credit. The stream writes its session header ahead of its first data. #[kio::wrapper] pub fn poll_open_uni( &self, waiter: &kio::Waiter, options: driver_send::Options<'_>, ) -> Poll> { - self.opening.poll(waiter, |opening, cx| { - if opening.uni.is_none() { - let inner = ready!(self.conn.poll_open_uni( - opening.park.hold(cx), - driver_send::Options { - group: None, - priority: i64::MAX - } - )) - .map_err(|err| self.map_err(err))?; - let header = self.web.as_ref().map(|web| web.header_uni.clone()).unwrap_or_default(); - opening.uni = Some((SendStream::new(inner, &self.handles, None), header)); - } - let (send, header) = opening.uni.as_mut().unwrap(); - let result = ready!(send.poll_header(opening.park.hold(cx), header)); - let (mut send, _) = opening.uni.take().unwrap(); - result?; - send.set_priority(options.priority); - send.set_group(options.group); - Poll::Ready(Ok(send)) - }) + let send = ready!(self.conn.poll_open_uni(waiter, options)).map_err(|err| self.map_err(err))?; + let header = self.web.as_ref().map(|web| web.header_uni.clone()).unwrap_or_default(); + Poll::Ready(Ok(SendStream::new(send, &self.handles, header))) } - /// Open a bidirectional stream scheduled by `options`. + /// Open a bidirectional stream scheduled by `options`, pending only for the peer's stream + /// credit. The stream writes its session header ahead of its first data. #[kio::wrapper] pub fn poll_open_bi( &self, waiter: &kio::Waiter, options: driver_send::Options<'_>, ) -> Poll> { - self.opening.poll(waiter, |opening, cx| { - if opening.bi.is_none() { - let (mut send, recv) = ready!(self.conn.poll_open_bi( - opening.park.hold(cx), - driver_send::Options { - group: None, - priority: i64::MAX - } - )) - .map_err(|e| self.map_err(e))?; - send.set_priority(i64::MAX); - let header = self.web.as_ref().map(|web| web.header_bi.clone()).unwrap_or_default(); - opening.bi = Some(( - SendStream::new(send, &self.handles, None), - RecvStream::new(recv, &self.handles), - header, - )); - } - let (send, _, header) = opening.bi.as_mut().unwrap(); - let result = ready!(send.poll_header(opening.park.hold(cx), header)); - let (mut send, recv, _) = opening.bi.take().unwrap(); - result?; - send.set_priority(options.priority); - send.set_group(options.group); - Poll::Ready(Ok((send, recv))) - }) + let (send, recv) = ready!(self.conn.poll_open_bi(waiter, options)).map_err(|err| self.map_err(err))?; + let header = self.web.as_ref().map(|web| web.header_bi.clone()).unwrap_or_default(); + Poll::Ready(Ok(( + SendStream::new(send, &self.handles, header), + RecvStream::new(recv, &self.handles), + ))) } /// The next datagram, with its session header removed. @@ -824,10 +776,6 @@ impl moq_net::transport::poll::Session for Session { quic.receive_window = limits.receive_window; Self::set_limits(self, quic).map_err(|err| moq_net::transport::LimitsError::Refused(err.to_string())) } - /// The connection's credit, which every WebTransport session on it shares. - fn stream_credit(&self, dir: moq_net::transport::Dir) -> Option { - Some(self.conn.stream_credit(dir)) - } /// The connection's exporter on raw QUIC; on WebTransport, this session's own. fn export_keying_material(&self, label: &[u8], context: &[u8]) -> Option<[u8; 32]> { match &self.web { diff --git a/rs/moq-uring/src/quic/web/send.rs b/rs/moq-uring/src/quic/web/send.rs index fd7d5d41eef..02acf02598c 100644 --- a/rs/moq-uring/src/quic/web/send.rs +++ b/rs/moq-uring/src/quic/web/send.rs @@ -6,15 +6,16 @@ use std::{ task::{Context, Poll}, }; -use bytes::Buf; +use bytes::{Buf, Bytes}; use super::Handles; use crate::quic::driver::send; /// A stream that can be used to send bytes. See [`crate::quic::send::Stream`]. /// -/// Dropping it before [`finish`](Self::finish) resets it with code 0, still delivering the -/// WebTransport header. +/// A stream this side opened writes its WebTransport header ahead of its first data, so opening +/// one waits only for the peer's stream credit. Dropping it before [`finish`](Self::finish) +/// resets it with code 0, still delivering the header once written. /// /// This wrapper is mainly needed for error codes, which is unfortunate. /// WebTransport uses u32 error codes and they're mapped in a reserved HTTP/3 error space. @@ -22,7 +23,10 @@ use crate::quic::driver::send; pub struct Stream { state: State, close: Rc, - /// The end of the WebTransport header this side wrote first, which a reset must still deliver. + /// The WebTransport header still to write ahead of any data, empty once written or for a + /// stream without one. + unwritten: Bytes, + /// The end of the WebTransport header once written, which a reset must still deliver. header: Option, id: crate::quic::stream::Id, } @@ -32,19 +36,28 @@ pub struct Stream { enum State { Open(send::Stream), Finished(send::Finished), + /// Finished before its header fit, so it was reset with nothing sent. + Unsent, /// Reset, with the peer's stop code if it arrived first. Reset(Result, send::Error>), } impl Stream { - pub(super) fn new(mut stream: send::Stream, close: &Rc, header: Option) -> Self { - stream.set_drop_reset(header, close.encode_stream_code(0)); - Self { + /// Wrap `stream`, writing `header` ahead of its data: a WebTransport stream this side + /// opened, or empty for one without a header. + pub(super) fn new(mut stream: send::Stream, close: &Rc, header: Bytes) -> Self { + stream.set_drop_reset(None, close.encode_stream_code(0)); + let mut this = Self { id: stream.id(), state: State::Open(stream), close: close.clone(), - header, - } + unwritten: header, + header: None, + }; + // Write the header now when it fits, so the peer can accept the stream before its + // first data. Whatever does not fit waits for that data; a failure resurfaces there. + let _ = this.poll_header(&kio::Waiter::noop()); + this } /// Decode the peer's stop code, and report a session error, or a stop for a session @@ -76,8 +89,8 @@ impl Stream { /// This is a u32 with WebTransport because we share the error space with HTTP/3. /// A raw QUIC session sends the code as is. Does nothing once already reset. /// - /// The WebTransport header still reaches the peer, so it can tell which session the reset - /// belongs to. + /// A WebTransport header already written still reaches the peer, so it can tell which + /// session the reset belongs to. fn reset_mut(&mut self, code: u32) { let code = self.close.encode_stream_code(code); // The connection is driven on this thread, so no STOP_SENDING lands between this check @@ -85,7 +98,7 @@ impl Stream { let stopped = match &self.state { State::Open(stream) => stream.poll_closed(&kio::Waiter::noop()), State::Finished(stream) => stream.poll_closed(&kio::Waiter::noop()), - State::Reset(_) => return, + State::Reset(_) | State::Unsent => return, }; let stopped = match stopped { Poll::Ready(result) => result, @@ -100,7 +113,7 @@ impl Stream { Some(header) => stream.reset_at(header, code), None => stream.reset(code), }, - State::Reset(_) => unreachable!(), + State::Reset(_) | State::Unsent => unreachable!(), } } @@ -112,6 +125,7 @@ impl Stream { State::Open(stream) => stream.poll_closed(waiter), State::Finished(stream) => stream.poll_closed(waiter), State::Reset(result) => Poll::Ready(result.clone()), + State::Unsent => return Poll::Ready(Err(Error::Unsent)), }; result.map(|result| match result { Ok(None) => Ok(None), @@ -124,8 +138,11 @@ impl Stream { } /// Finish sending, retaining a handle to acknowledgements and peer cancellation. + /// + /// A stream whose WebTransport header never fit is reset instead, and the handle fails + /// with [`Error::Unsent`]. pub fn finish(mut self) -> Finished { - self.finish_mut(); + let _ = self.finish_mut(); Finished { stream: self, park: Default::default(), @@ -137,51 +154,68 @@ impl Stream { self.reset_mut(code); } - /// Write the WebTransport header of a stream being opened, failing as the session would. - pub(super) fn poll_header( - &mut self, - waiter: &kio::Waiter, - header: &mut bytes::Bytes, - ) -> Poll> { + /// Write what is left of the WebTransport header, ready once none is left. + fn poll_header(&mut self, waiter: &kio::Waiter) -> Poll> { + if !self.unwritten.has_remaining() { + return Poll::Ready(Ok(())); + } let State::Open(stream) = &mut self.state else { - unreachable!("a stream is open until its header is written"); + return Poll::Ready(Err(Error::ClosedStream)); }; - while header.has_remaining() { - if let Err(err) = std::task::ready!(stream.poll_write_buf(waiter, header)) { - let gone = match &err { - send::Error::Stopped(code) => self.close.session_gone(*code), - _ => None, - }; - return Poll::Ready(Err(gone.unwrap_or_else(|| self.close.map(err.into())))); + while self.unwritten.has_remaining() { + if let Err(err) = std::task::ready!(stream.poll_write_buf(waiter, &mut self.unwritten)) { + return Poll::Ready(Err(self.map_error(err))); } } let offset = stream.offset(); stream.set_drop_reset(Some(offset), self.close.encode_stream_code(0)); - self.header = self.close.web.as_ref().map(|_| offset); + self.header = Some(offset); Poll::Ready(Ok(())) } + /// Write from `buf` after the header, returning the size written. + fn poll_write_buf(&mut self, waiter: &kio::Waiter, buf: &mut impl Buf) -> Poll> { + std::task::ready!(self.poll_header(waiter))?; + let result = std::task::ready!(self.open()?.poll_write_buf(waiter, buf)); + Poll::Ready(result.map_err(|e| self.map_error(e))) + } + /// Write from `buf`, returning the size written. See [`send::Stream::write`]. pub async fn write(&mut self, buf: &mut impl Buf) -> Result { - let result = self.open()?.write(buf).await; - result.map_err(|e| self.map_error(e)) + kio::wait(|waiter| self.poll_write_buf(waiter, buf)).await } /// Write all of `buf` to the stream. See [`send::Stream::write_all`]. - pub async fn write_all(&mut self, buf: impl Buf) -> Result<(), Error> { - let result = self.open()?.write_all(buf).await; - result.map_err(|e| self.map_error(e)) + pub async fn write_all(&mut self, mut buf: impl Buf) -> Result<(), Error> { + while buf.has_remaining() { + self.write(&mut buf).await?; + } + Ok(()) } /// Mark the stream as finished, such that no more data can be written. See /// [`send::Stream::finish`]. Does nothing if it was already finished or reset. - fn finish_mut(&mut self) { - if matches!(self.state, State::Open(_)) { - let State::Open(stream) = std::mem::replace(&mut self.state, State::Reset(Ok(None))) else { - unreachable!() - }; - self.state = State::Finished(stream.finish()); + /// + /// A stream whose header still does not fit could never deliver its FIN, so it is reset + /// instead, failing with [`Error::Unsent`] here and from `poll_closed`. + fn finish_mut(&mut self) -> Result<(), Error> { + if !matches!(self.state, State::Open(_)) { + return Ok(()); + } + match self.poll_header(&kio::Waiter::noop()) { + Poll::Ready(Ok(())) => {} + Poll::Ready(Err(err)) => return Err(err), + Poll::Pending => { + self.reset_mut(0); + self.state = State::Unsent; + return Err(Error::Unsent); + } } + let State::Open(stream) = std::mem::replace(&mut self.state, State::Reset(Ok(None))) else { + unreachable!() + }; + self.state = State::Finished(stream.finish()); + Ok(()) } /// Set the priority within the stream's send group, or session-wide when ungrouped. @@ -189,7 +223,7 @@ impl Stream { match &mut self.state { State::Open(stream) => stream.set_priority(priority), State::Finished(stream) => stream.set_priority(priority), - State::Reset(_) => {} + State::Reset(_) | State::Unsent => {} } } @@ -198,7 +232,7 @@ impl Stream { match &self.state { State::Open(stream) => stream.priority(), State::Finished(stream) => stream.priority(), - State::Reset(_) => 0, + State::Reset(_) | State::Unsent => 0, } } @@ -207,7 +241,7 @@ impl Stream { match &mut self.state { State::Open(stream) => stream.set_group(group), State::Finished(stream) => stream.set_group(group), - State::Reset(_) => {} + State::Reset(_) | State::Unsent => {} } } @@ -232,8 +266,7 @@ impl moq_net::transport::poll::SendStream for Stream { self.poll_write_buf(waiter, &mut buf) } fn poll_write_buf(&mut self, waiter: &kio::Waiter, buf: &mut B) -> Poll> { - let result = self.open()?.poll_write_buf(waiter, buf); - result.map_err(|e| self.map_error(e)) + Self::poll_write_buf(self, waiter, buf) } fn set_priority(&mut self, priority: i64) { Self::set_priority(self, priority); @@ -242,8 +275,7 @@ impl moq_net::transport::poll::SendStream for Stream { Self::set_group(self, Some(group)); } fn finish(&mut self) -> Result<(), Self::Error> { - Self::finish_mut(self); - Ok(()) + Self::finish_mut(self) } fn reset(&mut self, code: u32) { Self::reset_mut(self, code); @@ -256,10 +288,13 @@ impl moq_net::transport::poll::SendStream for Stream { }) } fn acknowledged(&self) -> Option { + if self.unwritten.has_remaining() { + return Some(false); + } Some(match &self.state { State::Open(stream) => stream.acknowledged(), State::Finished(stream) => stream.acknowledged(), - State::Reset(_) => false, + State::Reset(_) | State::Unsent => false, }) } } @@ -330,6 +365,11 @@ pub enum Error { /// The stream was already finished or reset. #[error("stream closed")] ClosedStream, + + /// The stream was finished before its WebTransport header fit the peer's flow control, so + /// it was reset with nothing sent. + #[error("finished before the stream header could be sent")] + Unsent, } impl From for Error { diff --git a/rs/moq-uring/src/transport/local.rs b/rs/moq-uring/src/transport/local.rs index 8c2086ce81a..860856443d4 100644 --- a/rs/moq-uring/src/transport/local.rs +++ b/rs/moq-uring/src/transport/local.rs @@ -118,10 +118,6 @@ impl poll::Session for Local { self.0.set_limits(limits) } - fn stream_credit(&self, dir: moq::Dir) -> Option { - self.0.stream_credit(dir) - } - fn export_keying_material(&self, label: &[u8], context: &[u8]) -> Option<[u8; 32]> { self.0.export_keying_material(label, context) } diff --git a/rs/moq-uring/tests/integration/web.rs b/rs/moq-uring/tests/integration/web.rs index 2a668696515..0f3019b3957 100644 --- a/rs/moq-uring/tests/integration/web.rs +++ b/rs/moq-uring/tests/integration/web.rs @@ -10,6 +10,7 @@ use crate::support; use std::net::UdpSocket; +use std::task::Poll; use moq_net::origin; use moq_net::transport::poll::SendStream as _; @@ -288,6 +289,87 @@ fn a_clean_finish_closes_a_stream() { client.join().expect("client thread"); } +/// Out of the peer's connection window, an open still returns its stream at once and the +/// stream's header waits for room with its data, so an open waits only for stream credit. +#[test] +fn an_open_waits_only_for_stream_credit() { + let Some(mut worker) = worker() else { return }; + let handle = worker.handle(); + let certs = support::certs().expect("certificates"); + let endpoint = h3_endpoint(&handle, &certs); + let payload = vec![0xa5; 64 * 1024]; + // The client reads nothing until the server opened its second stream. + let (opened, wait) = tokio::sync::oneshot::channel::<()>(); + let url = format!("https://{}/window", endpoint.local_addr()); + let expected = payload.clone(); + let client = std::thread::spawn(move || { + let _ = rind_rustls::default_provider().unwrap().install_default(); + let rt = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .expect("tokio runtime"); + rt.block_on(async move { + let request = moq_tokio::quic::web::proto::ConnectRequest::new(url::Url::parse(&url).expect("url")) + .with_protocol(PROTO); + let mut transport = moq_tokio::quic::driver::transport::Config::default(); + transport.limits.receive_window = std::num::NonZeroU64::new(16 * 1024); + let session = crate::support::web_connect(request, transport).await.expect("connect"); + wait.await.expect("the server opened both streams"); + let mut read = Vec::new(); + for _ in 0..2 { + let mut recv = session.accept_uni().await.expect("accept uni"); + read.push(read_all(&mut recv).await); + } + read.sort_by_key(Vec::len); + assert_eq!(read, [b"second".to_vec(), expected]); + session.close(0, "done"); + session.closed().await; + }); + }); + worker + .block_on(async move { + let conn = endpoint.accept().await.expect("accept"); + let request = quic::web::Request::accept(conn).await.expect("handshake"); + let session = request + .respond(quic::web::proto::ConnectResponse::OK.with_protocol(PROTO)) + .await + .expect("respond"); + let mut first = kio::wait(|waiter| session.poll_open_uni(waiter, Default::default())) + .await + .expect("open uni"); + let mut rest = bytes::Bytes::from(payload); + while matches!( + first.poll_write_buf(&kio::Waiter::noop(), &mut rest), + Poll::Ready(Ok(_)) + ) {} + assert!(!rest.is_empty(), "the client's window never ran out"); + let Poll::Ready(Ok(mut second)) = session.poll_open_uni(&kio::Waiter::noop(), Default::default()) else { + panic!("the open waited on more than stream credit"); + }; + // A stream finished before its header fits could never deliver its FIN. + let Poll::Ready(Ok(mut empty)) = session.poll_open_uni(&kio::Waiter::noop(), Default::default()) else { + panic!("the open waited on more than stream credit"); + }; + assert!(matches!( + moq_net::transport::poll::SendStream::finish(&mut empty), + Err(quic::web::send::Error::Unsent) + )); + assert!(matches!( + empty.poll_closed(&kio::Waiter::noop()), + Poll::Ready(Err(quic::web::send::Error::Unsent)) + )); + drop(empty); + opened.send(()).expect("the client waits"); + first.write_all(rest).await.expect("write"); + second.write_all(&b"second"[..]).await.expect("write"); + let (first, second) = (first.finish(), second.finish()); + kio::wait(|waiter| session.poll_closed(waiter)).await; + drop((first, second)); + }) + .expect("worker"); + client.join().expect("client thread"); +} + /// A datagram that names no session, or another one, is dropped rather than ending the session. #[test] fn a_stray_datagram_is_dropped() { @@ -867,10 +949,10 @@ fn a_reset_stream_keeps_its_header() { client.join().expect("client thread"); } -/// A stream opened with no connection credit left still delivers its header -/// when reset, rather than a plain reset of a stream the peer cannot place. +/// A stream reset before its header fits the connection's credit carried nothing, so it +/// goes out as a plain reset the peer drops unseen, and the next stream arrives intact. #[test] -fn a_reset_stream_keeps_its_header_without_credit() { +fn a_stream_reset_before_its_header_fits_never_reaches_the_session() { use std::task::Poll; let Some(mut worker) = worker() else { return }; @@ -894,18 +976,14 @@ fn a_reset_stream_keeps_its_header_without_credit() { .with_protocol(PROTO); let session = crate::support::web_connect(request, transport).await.expect("connect"); - // Reading the filler returns the credit the reset stream waits on. + // Reading the filler returns the credit the last stream waits on. let mut filler = session.accept_uni().await.expect("accept_uni"); read_all(&mut filler).await; let accept = kio::clock::timeout(std::time::Duration::from_secs(5), session.accept_uni()); - let mut recv = accept.await.expect("the reset stream arrives").expect("accept_uni"); - let err = recv.read_chunk(usize::MAX).await.expect_err("the server reset it"); - assert!( - matches!(err, moq_tokio::quic::web::recv::Error::Reset(7)), - "got {err:?}" - ); - // Only now, so the close cannot overtake the reset stream. + let mut recv = accept.await.expect("the last stream arrives").expect("accept_uni"); + assert_eq!(read_all(&mut recv).await, PAYLOAD); + // Only now, so the close cannot overtake the last stream. session.close(CLOSE_CODE, CLOSE_REASON); session.closed().await; }); @@ -935,6 +1013,11 @@ fn a_reset_stream_keeps_its_header_without_credit() { .expect("open_uni"); send.reset(7); + let last = kio::wait(|waiter| session.poll_open_uni(waiter, Default::default())) + .await + .expect("open_uni"); + write_finish(last, PAYLOAD).await; + kio::wait(|waiter| session.poll_closed(waiter)).await; }) .expect("worker"); diff --git a/rs/qmux/src/session.rs b/rs/qmux/src/session.rs index 829d79d8a50..d0918b18501 100644 --- a/rs/qmux/src/session.rs +++ b/rs/qmux/src/session.rs @@ -416,16 +416,6 @@ impl poll::Session for Session { quic.receive_window = limits.receive_window; Session::set_limits(self, quic).map_err(|err| net::LimitsError::Refused(err.to_string())) } - - fn stream_credit(&self, dir: net::Dir) -> Option { - let dir = match dir { - net::Dir::Uni => Dir::Uni, - net::Dir::Bi => Dir::Bi, - }; - let mut state = self.inner.lock(); - let streams = state.conn.streams(); - Some(net::StreamCredit::new(streams.credit(dir), streams.blocked(dir))) - } } /// A snapshot of the session's metrics; its [`net::Wire`] holds the byte counts. diff --git a/rs/qmux/src/session/tests.rs b/rs/qmux/src/session/tests.rs index 7ab9d8e4558..dc35e21cfaf 100644 --- a/rs/qmux/src/session/tests.rs +++ b/rs/qmux/src/session/tests.rs @@ -456,25 +456,19 @@ async fn the_peer_limits_concurrent_streams() { let mut server = config(Version::QMux02); server.limits.max_streams = std::num::NonZeroU64::new(1); let (client, server) = pair(config(Version::QMux02), server).await; - let credit = |dir| client.stream_credit(dir).unwrap(); - assert_eq!(credit(net::Dir::Uni), net::StreamCredit::new(1, false)); let mut first = client.open_uni(SendOptions::default()).await.unwrap(); - assert_eq!(credit(net::Dir::Uni), net::StreamCredit::new(0, false)); let mut opening = std::pin::pin!(client.open_uni(SendOptions::default())); assert!( futures_poll_once(&mut opening).await.is_none(), "no credit for a second stream" ); - assert_eq!(credit(net::Dir::Uni), net::StreamCredit::new(0, true)); - assert_eq!(credit(net::Dir::Bi), net::StreamCredit::new(1, false), "per direction"); first.finish().unwrap(); let mut recv = server.accept_uni().await.unwrap(); read_all(&mut recv).await.unwrap(); drop(recv); opening.await.expect("credit returned once the first stream is done"); - assert!(!credit(net::Dir::Uni).blocked, "the peer's MAX_STREAMS unblocks"); } /// Poll `future` once, after letting every other task run.