From d3cbfabc6d16eefad6de480f8bd0dbe5ba867f61 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 19 Oct 2026 12:47:11 -0700 Subject: [PATCH 1/4] chore: claim track status race quest From 6e02817cf15c786f454cf0087b0b5b75ef4ab39c Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 19 Oct 2026 12:58:06 -0700 Subject: [PATCH 2/4] fix(net): register subscriptions before exposing track demand Register subscriptions before requests or demand can wake their serving session, and derive each subscribed origin query from that same track instance. Remove the TRACK_STATUS fallback to SUBSCRIBE so query-only and fetch-only refusals remain terminal. Validation: all four deterministic regressions pass, including the scripted peer refusing TRACK_STATUS with 0xFFFFFFFF. The two model regressions failed before the model fix; the front regression still failed with only the model fix. Full moq-net tests are running; just check remains pending. External relay reporting remains deferred under the authorized GitHub organization scope. Co-Authored-By: GPT-6.1-Sol --- rs/moq-net/src/ietf/subscriber.rs | 291 +++++++++++++++++++++--------- rs/moq-net/src/model/broadcast.rs | 88 ++++++++- rs/moq-net/src/model/origin.rs | 11 +- rs/moq-net/src/model/track.rs | 51 ++++-- 4 files changed, 325 insertions(+), 116 deletions(-) diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 3c9b053c66e..bb5cb56f436 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -2533,19 +2533,16 @@ where // SUBSCRIBEs: its TRACK_STATUS answer cannot say whether the track is timed. let mut target = match request.subscription() { None if ietf::TrackStatusOk::describes_track(self.version) => { - match self.track_status(&broadcast_path, &track_name, request).await { - Some(Target::Resume(idle)) => { - let Some(next) = self - .linger(&broadcast_path, &track_name, idle, &mut group_fetches, &mut gate) - .await - else { - return; - }; - Target::Resume(next) - } - Some(target) => target, - None => return, - } + let Some(idle) = self.track_status(&broadcast_path, &track_name, request).await else { + return; + }; + let Some(next) = self + .linger(&broadcast_path, &track_name, idle, &mut group_fetches, &mut gate) + .await + else { + return; + }; + Target::Resume(next) } _ => Target::Request(request), }; @@ -3596,18 +3593,15 @@ where } } - /// Learn a track nobody subscribes to from TRACK_STATUS, and accept it as a copy with no - /// subscription ([`Target::Resume`]), which [`Self::linger`] serves fetches from and - /// subscribes once someone does. A publisher that does not implement TRACK_STATUS hands - /// the request back ([`Target::Request`]) to be learned from SUBSCRIBE. `None` once the - /// request was refused or abandoned: a publisher that refuses the track's status refuses - /// the fetch-only request too. + /// Learn a track nobody subscribes to from TRACK_STATUS, accepting an idle copy that + /// [`Self::linger`] serves fetches from and subscribes once someone does. `None` once + /// refused or abandoned: a refused status fails the query-only or fetch-only request. async fn track_status( &mut self, broadcast_path: &Path<'_>, track_name: &str, request: track::Request, - ) -> Option { + ) -> Option { let validity = self.validity.start(); // An allocated ID is always sent, as in `subscribe_once`. let request_id = match validity.run(self.control.next_request_id(&self.runtime)).await { @@ -3687,12 +3681,6 @@ where }; let ok = match ok { Ok(ok) => ok, - // NOT_SUPPORTED refuses the method, not the track. The origin queries a track before - // its first reader's subscription lands, so this is often a subscriber's request. - Err(Error::Unsupported) => { - tracing::debug!(broadcast = %self.origin.absolute(broadcast_path), track = %track_name, "track status not supported, subscribing"); - return Some(Target::Request(request)); - } Err(err) => { tracing::debug!(%err, broadcast = %self.origin.absolute(broadcast_path), track = %track_name, "track status refused"); request.reject(err); @@ -3706,12 +3694,12 @@ where track.received(); // Nothing feeds this copy live: what it caches is fetched, never the live edge. track.set_idle(); - Some(Target::Resume(Idle { + Some(Idle { demand: track.demand(), track, dynamic, timescale: ok.properties.timescale, - })) + }) } /// Read the answer to a TRACK_STATUS: TRACK_STATUS_OK, or the publisher's refusal as an @@ -7170,73 +7158,198 @@ mod tests { buf } - /// A publisher without TRACK_STATUS still serves the track: its NOT_SUPPORTED refuses - /// the method, so the request is learned from SUBSCRIBE instead. The origin queries a new - /// track before its first reader's subscription lands, so a reader reaching such a - /// publisher through a relay takes this path. + /// Serve the front's request on its wake, before the requesting call can return. + /// A peer that refuses TRACK_STATUS must still receive SUBSCRIBE for a catalog reader. #[moq_clock::test] - async fn an_unsupported_track_status_subscribes_instead() { - for version in [Version::Draft18, Version::Draft19, Version::Draft22] { - let refused = message( - ietf::RequestError::ID, - &ietf::RequestError { - request_id: None, - error_code: request::to_code(&Error::Unsupported, request::Kind::TrackStatus, version), - reason_phrase: "TRACK_STATUS is not supported".into(), - retry_interval: 0, - }, - version, - ); - let subscribe_ok = message( - ietf::SubscribeOk::ID, - &ietf::SubscribeOk { - request_id: None, - track_alias: 7, - largest: None, - properties: Default::default(), - }, - version, - ); - let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![refused, subscribe_ok]); - let log = session.log.clone(); - let (tasks, _task_set) = crate::util::TaskSet::new(); - let mut subscriber = Subscriber::new( - crate::time::sim(), - session, - crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), - None, - peer::PeerSetup::default(), - crate::Hop::new(1).unwrap(), - None, - version, - tasks, - Default::default(), - ); + async fn a_catalog_subscription_never_requests_track_status() { + use std::sync::{Arc, Mutex}; + use std::task::{Context, Wake, Waker}; - let producer = crate::broadcast::Info::default().produce(); - let mut dynamic = producer.dynamic(); - let consumer = producer.consume(); - let track = consumer.track("video").unwrap(); - let mut query = std::pin::pin!(track.query()); - assert!(futures::poll!(query.as_mut()).is_pending()); - let request = dynamic.requested_track().await.expect("no track requested"); + struct Peer { + version: Version, + dynamic: Mutex>, + park: Mutex, + log: Mutex>, + } + impl Wake for Peer { + fn wake(self: Arc) { + self.wake_by_ref(); + } + fn wake_by_ref(self: &Arc) { + let (dynamic, request) = { + let mut dynamic = self.dynamic.lock().unwrap(); + let Some(serving) = dynamic.as_mut() else { return }; + let mut park = self.park.lock().unwrap(); + let waker = Waker::from(self.clone()); + let waiter = park.hold(&Context::from_waker(&waker)); + let Poll::Ready(Ok(request)) = serving.poll_requested_track(waiter) else { + return; + }; + *park = kio::Park::default(); + (dynamic.take().unwrap(), request) + }; + let version = self.version; + // The subscriber chooses its wire request from this snapshot. Answer a + // TRACK_STATUS with the undefined code used by the refusing peer. + let answer = if request.subscription().is_none() { + message( + ietf::RequestError::ID, + &ietf::RequestError { + request_id: None, + error_code: u32::MAX.into(), + reason_phrase: "TRACK_STATUS is refused".into(), + retry_interval: 0, + }, + version, + ) + } else { + message( + ietf::SubscribeOk::ID, + &ietf::SubscribeOk { + request_id: None, + track_alias: 7, + largest: None, + properties: Default::default(), + }, + version, + ) + }; + let session = crate::lite::test_transport::ScriptedSession::new(answer); + *self.log.lock().unwrap() = Some(session.log.clone()); + let mut serving = Box::pin(async move { + let (tasks, _task_set) = crate::util::TaskSet::new(); + let mut subscriber = Subscriber::new( + crate::time::sim(), + session, + crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(), + Control::new(None, false), + None, + peer::PeerSetup::default(), + crate::Hop::new(2).unwrap(), + None, + version, + tasks, + Default::default(), + ); + subscriber + .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .await; + }); + // Run the request classification before the front can add demand after + // its query. The simulator takes over only once the wire work parks. + if std::future::Future::poll(serving.as_mut(), &mut Context::from_waker(Waker::noop())).is_pending() { + drop(moq_clock::sim::spawn(serving)); + } + } + } - let serving = moq_clock::sim::spawn(async move { - subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) - .await; + for version in [Version::Draft18, Version::Draft19, Version::Draft22] { + let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let source = origin.publish("broadcast", Default::default()).unwrap(); + let resolved = origin.consume().request_broadcast("broadcast", None).await.unwrap(); + let peer = Arc::new(Peer { + version, + dynamic: Mutex::new(Some(source.dynamic())), + park: Default::default(), + log: Default::default(), }); - settle().await; - - assert!(query.await.is_ok(), "{version}: NOT_SUPPORTED refused the track"); - assert!(track.subscribe(None).await.is_ok(), "{version}: the reader was refused"); + peer.wake_by_ref(); + let result = resolved.track("catalog").unwrap().subscribe(None).await; + let log = peer.log.lock().unwrap(); assert_eq!( - control_message_types(&log, version)[..2], - [ietf::TrackStatus::ID, ietf::Subscribe::ID], - "{version}" + control_message_types(log.as_ref().expect("the front asked its source"), version), + [ietf::Subscribe::ID], + "{version}: a subscribing reader sent TRACK_STATUS" ); - serving.abort(); + assert!(result.is_ok(), "{version}: the catalog reader was refused"); + } + } + + /// Query-only and fetch-only demand fail with the peer's TRACK_STATUS refusal, + /// including NOT_SUPPORTED and undefined codes, without opening a subscription. + #[moq_clock::test] + async fn a_refused_track_status_never_subscribes() { + for version in [ + Version::Draft14, + Version::Draft15, + Version::Draft16, + Version::Draft18, + Version::Draft19, + Version::Draft22, + ] { + for code in [3, u64::from(u32::MAX)] { + for fetching in [false, true] { + let refused = if version == Version::Draft14 { + message( + ietf::TRACK_STATUS_ERROR_14, + &ietf::SubscribeError { + request_id: RequestId(0), + error_code: code, + reason_phrase: "TRACK_STATUS is refused".into(), + }, + version, + ) + } else { + message( + ietf::RequestError::ID, + &ietf::RequestError { + request_id: matches!(version, Version::Draft15 | Version::Draft16) + .then_some(RequestId(0)), + error_code: code, + reason_phrase: "TRACK_STATUS is refused".into(), + retry_interval: 0, + }, + version, + ) + }; + let session = crate::lite::test_transport::ScriptedSession::new(refused); + let log = session.log.clone(); + let (tasks, _task_set) = crate::util::TaskSet::new(); + let mut subscriber = Subscriber::new( + crate::time::sim(), + session, + crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), + Control::new(None, false), + None, + peer::PeerSetup::default(), + crate::Hop::new(1).unwrap(), + None, + version, + tasks, + Default::default(), + ); + + let producer = crate::broadcast::Info::default().produce(); + let mut dynamic = producer.dynamic(); + let consumer = producer.consume(); + let track = consumer.track("video").unwrap(); + let mut pending = Box::pin(async { + if fetching { + track.fetch_group(0, None).await.map(|_| ()) + } else { + track.query().await.map(|_| ()) + } + }); + assert!(futures::poll!(pending.as_mut()).is_pending()); + let request = dynamic.requested_track().await.expect("no track requested"); + let mut serving = + Box::pin(subscriber.run_subscribe(Path::new("broadcast"), dynamic, None, request)); + assert!( + futures::poll!(serving.as_mut()).is_ready(), + "{version}: refusal was not terminal" + ); + match pending.await.expect_err("TRACK_STATUS was refused") { + Error::Unsupported => assert_eq!(code, 3), + Error::Remote(value) => assert_eq!(u64::from(value), code), + err => panic!("{version}, fetching: {fetching}: wrong refusal: {err:?}"), + } + assert_eq!( + control_message_types(&log, version), + [ietf::TrackStatus::ID], + "{version}" + ); + } + } } } diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index 14e0ba9aa8e..c14f3e76984 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -999,8 +999,13 @@ impl Consumer { } /// Join the demand of the track serving `name`, requesting it from a [`Dynamic`] - /// when nothing serves it yet. Errors as [`Self::track`] does. - pub(super) fn resolve_track(&self, name: &str) -> Result, Error> { + /// when nothing serves it yet. Registers the subscription before exposing demand. + /// Errors as [`Self::track`] does. + pub(super) fn resolve_track( + &self, + name: &str, + subscription: Option<&track::Subscription>, + ) -> Result<(kio::Consumer, Option), Error> { let mut state = self.state.lock(); if state.closing { @@ -1010,8 +1015,8 @@ impl Consumer { // Reuse a live producer if one is already publishing the track. `get` drops a // closed entry and returns `None`, so we fall through to a fresh request. if let Some(weak) = state.tracks.get(name) { - match weak.try_consume() { - Some(consumer) => return Ok(consumer), + match weak.try_consume(subscription) { + Some(resolved) => return Ok(resolved), // It closed between the liveness probe and the count bump (an idle // teardown committing under us). Reclaim it and request the track // again, rather than handing back a consumer of a dead track. @@ -1023,7 +1028,7 @@ impl Consumer { if let Some(pending) = state.requests.join(name) { // Coalesce onto a queued request for the same name. - return Ok(pending.join()); + return Ok(pending.join(subscription)); } // Allocate the name once and share the same Arc across the request, the @@ -1031,7 +1036,7 @@ impl Consumer { // cache pool through its `Arc`, same as a producer-created track. let name: Arc = name.into(); let request = track::Request::new(self.info.clone(), name.clone()).with_sequence(state.sequence(&name)); - let consumer = request.join(); + let resolved = request.join(subscription); // With no handler alive to serve it, the request is dropped: `NotFound` beats // handing back a consumer that would only resolve `Dropped`. @@ -1039,7 +1044,7 @@ impl Consumer { return Err(Error::NotFound); } - Ok(consumer) + Ok(resolved) } /// Read the track serving `name` now, without joining its demand or requesting it. @@ -1246,6 +1251,75 @@ mod test { #[cfg(feature = "async")] use std::time::Duration; + #[test] + fn a_subscription_is_registered_before_its_request_is_visible() { + struct Serve { + dynamic: std::sync::Mutex, + request: std::sync::Mutex>, + subscription: std::sync::Mutex>>, + } + impl std::task::Wake for Serve { + fn wake(self: Arc) { + self.wake_by_ref(); + } + fn wake_by_ref(self: &Arc) { + let Poll::Ready(Ok(request)) = self.dynamic.lock().unwrap().poll_requested_track(&kio::Waiter::noop()) + else { + return; + }; + *self.subscription.lock().unwrap() = Some(request.subscription()); + *self.request.lock().unwrap() = Some(request); + } + } + + let producer = Info::new().produce(); + let serve = Arc::new(Serve { + dynamic: std::sync::Mutex::new(producer.dynamic()), + request: Default::default(), + subscription: Default::default(), + }); + let consumer = producer.consume().track("catalog").unwrap(); + let waiter = kio::Waiter::new(std::task::Waker::from(serve.clone())); + assert!(serve.dynamic.lock().unwrap().poll_requested_track(&waiter).is_pending()); + let expected = track::Subscription::default().with_priority(3); + let _pending = consumer.subscribe(expected.clone()); + assert_eq!(*serve.subscription.lock().unwrap(), Some(Some(expected))); + } + + #[test] + fn a_subscription_is_registered_before_its_demand_is_visible() { + struct Inspect { + track: track::Producer, + seen: std::sync::Mutex>>, + } + impl std::task::Wake for Inspect { + fn wake(self: Arc) { + self.wake_by_ref(); + } + fn wake_by_ref(self: &Arc) { + *self.seen.lock().unwrap() = Some(self.track.subscription()); + } + } + + for lookup in [false, true] { + let producer = Info::new().produce(); + let inspect = Arc::new(Inspect { + track: producer.create_track("catalog", None).unwrap(), + seen: Default::default(), + }); + let waiter = kio::Waiter::new(std::task::Waker::from(inspect.clone())); + assert!(inspect.track.demand().poll_used(&waiter).is_pending()); + let consumer = if lookup { + producer.consume().track("catalog").unwrap() + } else { + inspect.track.consume() + }; + let expected = track::Subscription::default().with_priority(3); + let _pending = consumer.subscribe(expected.clone()); + assert_eq!(*inspect.seen.lock().unwrap(), Some(Some(expected)), "lookup: {lookup}"); + } + } + #[test] fn unique_names_are_never_reused() { let producer = Info::new().produce(); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 4947b99e5f8..ead45f65376 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -3133,11 +3133,14 @@ async fn serve_front(task: FrontTask) -> Vec { let closing = sources.get(&source).is_some_and(|s| s.is_closing()); match sources.get(&source).map(|s| s.track(&name)) { Some(Ok(lookup)) => { - // `into_inner` sheds the `Pending` future wrapper so only - // the pollable (which is `Sync`) is held across the wait. - let query = lookup.query().into_inner(); + // Subscribe before the query exposes upstream demand, and query + // that same instance even if the broadcast changes meanwhile. + let sub = io.weak.subscription().map(|demand| lookup.subscribe(demand)); + let query = match &sub { + Some(sub) => sub.query(), + None => lookup.query().into_inner(), + }; let copy = query.track(); - let sub = io.weak.subscription().map(|demand| copy.subscribe(demand)); io.query = Some(Asked { source, copy, diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index ffb8e42da81..020a6af3425 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -3232,8 +3232,14 @@ impl TrackWeak { /// of [`Producer::abort_unused`]: a request either joins in time to decline the /// teardown, or gets nothing and re-requests the track. It is never handed a track /// that is already on its way out. - pub(super) fn try_consume(&self) -> Option> { - self.state.try_consume() + pub(super) fn try_consume( + &self, + subscription: Option<&Subscription>, + ) -> Option<(kio::Consumer, Option)> { + // Register before the first consumer can wake the serving session, while + // still refusing a copy whose idle teardown already committed. + let preferences = subscription.map(|value| Preferences::register(self.state.read(), value.clone())); + Some((self.state.try_consume()?, preferences)) } /// Read the cached track without joining its demand. @@ -3507,20 +3513,22 @@ impl Consumer { /// The track a request made now reads, joined to its consumer count. A broadcast /// that cannot serve the name answers with a track closed with its error. - fn resolve(&self) -> kio::Consumer { - match &self.source { - Source::Track(state) => state.consume(), - Source::Broadcast(broadcast, current) => match broadcast.resolve_track(&self.name) { - Ok(state) => state, - Err(Error::Unroutable) if let Some(current) = current => current.consume(), + fn resolve(&self, subscription: Option<&Subscription>) -> (kio::Consumer, Option) { + let state = match &self.source { + Source::Track(state) => state.clone(), + Source::Broadcast(broadcast, current) => match broadcast.resolve_track(&self.name, subscription) { + Ok(resolved) => return resolved, + Err(Error::Unroutable) if let Some(current) = current => current.clone(), Err(err) => { let request = Request::new(self.broadcast.clone(), self.name.clone()); - let state = request.state.consume(); + let state = request.peek(); request.reject(err); state } }, - } + }; + let preferences = subscription.map(|value| Preferences::register(state.read(), value.clone())); + (state.consume(), preferences) } /// Run `f` on the track instance this handle reads now, without joining its consumer @@ -3562,8 +3570,8 @@ impl Consumer { /// the floor that the budget convicts, so the default budget of zero delivers only /// the latest group and a larger one reaches back over what it can still use. pub fn subscribe(&self, subscription: impl Into>) -> kio::Pending { - let state = self.resolve(); - let subscription = Preferences::register(state.read(), subscription.into().unwrap_or_default()); + let (state, subscription) = self.resolve(Some(&subscription.into().unwrap_or_default())); + let subscription = subscription.expect("a subscription was requested"); kio::Pending::new(Subscribing { name: self.name.clone(), @@ -3748,7 +3756,7 @@ impl Consumer { /// handler request. pub fn fetch_group(&self, sequence: u64, options: impl Into>) -> kio::Pending { let options = options.into().unwrap_or_default(); - let state = self.resolve(); + let state = self.resolve(None).0; let resume = state.read().routes.clone(); // One fetch per calling context, counted here (coalesced upstream work is @@ -3820,7 +3828,7 @@ impl Consumer { kio::Pending::new(Querying { name: self.name.clone(), broadcast: self.broadcast.clone(), - state: self.resolve(), + state: self.resolve(None).0, stats: self.stats.clone(), }) } @@ -3939,6 +3947,16 @@ pub struct Subscribing { } impl Subscribing { + /// Query the same track with this subscription already registered. + pub(super) fn query(&self) -> Querying { + Querying { + name: self.name.clone(), + broadcast: self.broadcast.clone(), + state: self.state.clone(), + stats: self.stats.clone(), + } + } + /// Poll until the peer confirms the subscription, yielding the [`Subscriber`]. /// Errors if the track is aborted or not found. pub fn poll_ok(&self, waiter: &kio::Waiter) -> Poll> { @@ -5837,8 +5855,9 @@ impl Request { } /// Join the eventual track's demand, for a request made through its broadcast. - pub(super) fn join(&self) -> kio::Consumer { - self.state.consume() + pub(super) fn join(&self, subscription: Option<&Subscription>) -> (kio::Consumer, Option) { + let preferences = subscription.map(|value| Preferences::register(self.state.read(), value.clone())); + (self.state.consume(), preferences) } /// Read the eventual track without joining its demand. From 3f74a75feb7064412297267eb116a1f977868696 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 19 Oct 2026 17:22:06 -0700 Subject: [PATCH 3/4] fix(net): join a served track outside the broadcast lock Registering a subscription wakes the serving session, which may re-enter the broadcast. Join the live track after releasing the broadcast lock and look the name up again if its idle teardown wins the race. Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/model/broadcast.rs | 70 +++++++++++++++++++++++-------- 1 file changed, 53 insertions(+), 17 deletions(-) diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index c14f3e76984..475e003b655 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -1006,28 +1006,34 @@ impl Consumer { name: &str, subscription: Option<&track::Subscription>, ) -> Result<(kio::Consumer, Option), Error> { - let mut state = self.state.lock(); + let mut state = loop { + let mut state = self.state.lock(); - if state.closing { - return Err(Error::Unroutable); - } + if state.closing { + return Err(Error::Unroutable); + } - // Reuse a live producer if one is already publishing the track. `get` drops a - // closed entry and returns `None`, so we fall through to a fresh request. - if let Some(weak) = state.tracks.get(name) { - match weak.try_consume(subscription) { - Some(resolved) => return Ok(resolved), - // It closed between the liveness probe and the count bump (an idle - // teardown committing under us). Reclaim it and request the track - // again, rather than handing back a consumer of a dead track. - None => { - state.tracks.remove(name); - } + // Reuse a live producer if one is already publishing the track. `get` drops a + // closed entry and returns `None`, so we fall through to a fresh request. + let Some(weak) = state.tracks.get(name) else { + break state; + }; + // Join outside the lock: the subscription and the first consumer wake the + // serving session, which may re-enter this broadcast. The track's own lock + // still orders the join against its idle teardown. + drop(state); + if let Some(resolved) = weak.try_consume(subscription) { + return Ok(resolved); } - } + // It closed between the liveness probe and the count bump (an idle teardown + // committing under us). Look again: `get` reclaims it and the track is + // requested again, rather than handing back a consumer of a dead track. + }; if let Some(pending) = state.requests.join(name) { - // Coalesce onto a queued request for the same name. + // Coalesce onto a queued request for the same name. Joining under the lock + // wakes no subscription observer: only a handler that popped the request + // can watch its subscriptions, and popping moves it to `tracks`. return Ok(pending.join(subscription)); } @@ -1320,6 +1326,36 @@ mod test { } } + #[test] + fn a_subscription_wakes_its_observers_outside_the_broadcast_lock() { + struct Reenter { + broadcast: Consumer, + woken: std::sync::atomic::AtomicBool, + } + impl std::task::Wake for Reenter { + fn wake(self: Arc) { + self.wake_by_ref(); + } + fn wake_by_ref(self: &Arc) { + // Deadlocks if the subscribe that woke us still holds the broadcast lock. + let _ = self.broadcast.track("other"); + self.woken.store(true, std::sync::atomic::Ordering::Relaxed); + } + } + + let producer = Info::new().produce(); + let mut track = producer.create_track("catalog", None).unwrap(); + let reenter = Arc::new(Reenter { + broadcast: producer.consume(), + woken: Default::default(), + }); + let waiter = kio::Waiter::new(std::task::Waker::from(reenter.clone())); + assert!(track.poll_subscription_changed(&waiter).is_pending()); + let consumer = producer.consume().track("catalog").unwrap(); + let _pending = consumer.subscribe(track::Subscription::default().with_priority(3)); + assert!(reenter.woken.load(std::sync::atomic::Ordering::Relaxed)); + } + #[test] fn unique_names_are_never_reused() { let producer = Info::new().produce(); From be30a6b56e4c39871d8262d643b376dbb77bc253 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 19 Oct 2026 19:09:14 -0700 Subject: [PATCH 4/4] test(net): arm the demand test through Demand::poll_state Main dropped Demand::poll_used. poll_state arms the same first-consumer edge while the track is idle. Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/model/broadcast.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index f512f759ced..c77c979c977 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -1314,7 +1314,7 @@ mod test { seen: Default::default(), }); let waiter = kio::Waiter::new(std::task::Waker::from(inspect.clone())); - assert!(inspect.track.demand().poll_used(&waiter).is_pending()); + assert_eq!(inspect.track.demand().poll_state(&waiter), track::DemandState::Idle); let consumer = if lookup { producer.consume().track("catalog").unwrap() } else {