diff --git a/.github/workflows/model-sync.yml b/.github/workflows/model-sync.yml index 7655ad00..29b17d92 100644 --- a/.github/workflows/model-sync.yml +++ b/.github/workflows/model-sync.yml @@ -36,6 +36,14 @@ jobs: run: python3 scripts/check-model-sync.py events - name: Every model is trace-validated (or allowlisted), coverage floors hold run: python3 scripts/check-model-sync.py models + # The planted-bug patches (docs/TESTING.md, "Planted-bug sensitivity") + # must keep applying to the code they mutate, or the matrix rots silently. + # A PR that moves planted code regenerates the affected patches. + - name: Planted-bug patches apply + run: | + for p in verification/planted/patches/*.patch; do + git apply --check "$p" || { echo "::error file=$p::no longer applies; regenerate it against this tree"; exit 1; } + done # On merge_group and push the script passes: the pull_request run # already enforced it (labels are not visible in the merge queue). - name: Modelled code changes update their model diff --git a/CHANGELOG.md b/CHANGELOG.md index b4bff54b..59c48e6c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,9 @@ ## Unreleased +- Regenerate the 11 planted-bug patches (04, 10-17, 19, 20) that no longer + applied, each planting the same fault where the code now lives, and check in + the required `model-sync` job that every planted patch still applies. - Move the private `backend-experiments`, `io-experiments` and `profiling-experiments` features out of `spawned-rt` and `spawned-concurrency` into a standalone, unpublished crate in diff --git a/docs/TESTING.md b/docs/TESTING.md index 7762641b..014f3e2f 100644 --- a/docs/TESTING.md +++ b/docs/TESTING.md @@ -1538,7 +1538,25 @@ The runner applies a patch, runs each layer, records `caught`/`missed` and the wall time in `OUT/results.tsv`, then reverts the patch and deletes any proptest seed files the run created (a seed found under one bug must not help the next). Simulator and fuzzer tapes go to `OUT/tmp`. Patches touch -`concurrency/src` only; they are never applied in CI. +`concurrency/src` only. CI never runs them, but the required `model-sync` +check runs `git apply --check` on every patch, so a PR that moves planted +code must regenerate the affected patches (same fault, new location). + +Regenerated after 0.8.0 (the 0.8 lifecycle rewrite and the file splits had +left 11 patches unapplicable), each planting the same fault where the code now +lives: 04 (`supervision.rs`), 10, 12, 13 (`link.rs`), 11 (`link/table.rs`), +14 (`child_handle.rs`), 15, 16 (`monitor/fence.rs`, shared by both modes), +17 (`monitor.rs`), 19 (`tasks/actor/lifecycle.rs`), 20 +(`tasks/actor/actor_ref.rs`). Three are adapted to the 0.8 design: 11 keeps +the *caller's* record (the receiver-side fence makes dropping only the peer's +record harmless); 12 delivers `Normal` instead of `NoProc` (0.8 linking to a +dead peer reports `NoProc`, OTP's `noproc`); 14 plants the fault in +`ChildHandle::stop_with_reason(Shutdown)` (`shutdown()` was removed in 0.8). +A spot check with each applied (unit and integration tests only) caught 04, +10, 11, 12, 13, 15, 16 and 19; 15, a miss in every layer below, is now caught +by `demonitor_before_target_dies_suppresses_down` and +`demonitor_releases_waiter` in both modes. The table predates the +regeneration; rerun the matrix before citing rows 04, 10-17, 19 and 20. **Results** (2026-11-12, after the follow-ups below, `53c0995d`, the 30-core shared server at `nice 19`, one patch at a time). Times are seconds for the @@ -1561,10 +1579,10 @@ cells are from that rerun; the first matrix (without that oracle) missed both. | 08 | Exhausted budget retires the child instead of failing the supervisor | 212 (19 tests) | 14 | 8 | 2 (V5) | 14 | - | | 09 | Nested supervisor's restart mode ignored (always Permanent) | 44 (1 test) | 14 | 8 | <1 (V1) | - | - | | 10 | `Normal` exit kills a non-trapping linked peer | 46 | 15 | 8 | 1 (X3) | - | - | -| 11 | `unlink` removes only the caller's edge | 43 (2 unit tests) | - | - | 17 (X5) | - | - | -| 12 | Linking to a dead peer reports `Normal`, not its reason | 54 | - | 8 | <1 (X3) | - | - | +| 11 | `unlink` is one-sided (the peer's death still signals the caller) | 43 (2 unit tests) | - | - | 17 (X5) | - | - | +| 12 | Linking to a dead peer reports `Normal`, not `NoProc` | 54 | - | 8 | <1 (X3) | - | - | | 13 | Actor killed through a link exits `Normal` (no transitive propagation) | 43 | 17 | 9 | <1 (X3) | - | - | -| 14 | `ChildHandle::shutdown` commits `Normal` instead of `Shutdown` | 44 | 17 | 9 | <1 (X8) | - | - | +| 14 | An administrative `Shutdown` stop commits `Normal` | 44 | 17 | 9 | <1 (X8) | - | - | | 15 | Monitor waiter delivers `Down` after `demonitor` removed it | - | - | - | - | - | - | | 16 | Monitoring an already-dead actor gives no `Down` | 137 | - | 9 | 5 (X1) | - | - | | 17 | Exiting observer does not cancel its monitor waiters | 59 | 14 | - | - | - | - | diff --git a/verification/planted/patches/04-sup-transient-restarts-on-shutdown.patch b/verification/planted/patches/04-sup-transient-restarts-on-shutdown.patch index 138ab830..908d2c83 100644 --- a/verification/planted/patches/04-sup-transient-restarts-on-shutdown.patch +++ b/verification/planted/patches/04-sup-transient-restarts-on-shutdown.patch @@ -1,15 +1,15 @@ Planted bug 04 (sup-transient-restarts-on-shutdown): Transient restarts on Shutdown (only Normal treated as clean) diff --git a/concurrency/src/supervision.rs b/concurrency/src/supervision.rs -index 328ed91b..ff3b2a99 100644 +index 3ed4dfe6..6e80f9ce 100644 --- a/concurrency/src/supervision.rs +++ b/concurrency/src/supervision.rs -@@ -41,7 +41,7 @@ impl RestartMode { - fn restarts(self, reason: Option<&ExitReason>) -> bool { +@@ -54,7 +54,7 @@ impl RestartMode { match self { Self::Permanent => true, -- Self::Transient => reason.map(ExitReason::is_abnormal).unwrap_or(true), -+ Self::Transient => reason.map(|r| *r != ExitReason::Normal).unwrap_or(true), + Self::Transient => { +- cleanup_failed || reason.map(ExitReason::is_abnormal).unwrap_or(true) ++ cleanup_failed || reason.map(|r| *r != ExitReason::Normal).unwrap_or(true) + } Self::Temporary => false, } - } diff --git a/verification/planted/patches/10-link-normal-exit-kills.patch b/verification/planted/patches/10-link-normal-exit-kills.patch index 85738c01..0f7b7845 100644 --- a/verification/planted/patches/10-link-normal-exit-kills.patch +++ b/verification/planted/patches/10-link-normal-exit-kills.patch @@ -1,16 +1,16 @@ Planted bug 10 (link-normal-exit-kills): A Normal exit kills a non-trapping linked peer diff --git a/concurrency/src/link.rs b/concurrency/src/link.rs -index 48cf54a8..a05dd0bd 100644 +index ff5b35ef..e350368a 100644 --- a/concurrency/src/link.rs +++ b/concurrency/src/link.rs -@@ -95,9 +95,6 @@ pub(crate) fn make_signal( - // stop_with_reason(Kill) bypasses the target's trap_exit flag. - // Normal exit signals are silently dropped unless the peer is trapping - let trapping = peer_trap_exit.load(Ordering::Acquire); -- if matches!(reason, ExitReason::Normal) && !trapping { -- return; -- } - if trapping { - // Send Exit message to the peer's mailbox - let exit = Exit { +@@ -307,7 +307,8 @@ fn apply_signal( + let _ = send(exit); // admission may be closed if the peer just died + return; + } +- if exit.reason == ExitReason::Normal { ++ // Planted: only a direct Normal signal is ignored; a Normal link notice kills. ++ if exit.reason == ExitReason::Normal && origin == Origin::Direct { + return; + } + if request.untrapped(exit.reason) { diff --git a/verification/planted/patches/11-link-unlink-one-sided.patch b/verification/planted/patches/11-link-unlink-one-sided.patch index 2323059b..373a019c 100644 --- a/verification/planted/patches/11-link-unlink-one-sided.patch +++ b/verification/planted/patches/11-link-unlink-one-sided.patch @@ -1,15 +1,17 @@ -Planted bug 11 (link-unlink-one-sided): unlink removes only the caller's edge; the peer still signals it +Planted bug 11 (link-unlink-one-sided): unlink is one-sided: the caller keeps its record, so the peer's death still signals it -diff --git a/concurrency/src/link.rs b/concurrency/src/link.rs -index 48cf54a8..c68b389b 100644 ---- a/concurrency/src/link.rs -+++ b/concurrency/src/link.rs -@@ -192,7 +192,7 @@ pub(crate) fn unregister_link( - if own_id == peer_id || Arc::ptr_eq(own, peer) { - return; - } -- let removed = with_pair(own, peer, |a, b| (remove(a, peer_id), remove(b, own_id))); -+ let removed = with_pair(own, peer, |a, _b| remove(a, peer_id)); - drop(removed); +diff --git a/concurrency/src/link/table.rs b/concurrency/src/link/table.rs +index c7ce16e5..f57cc071 100644 +--- a/concurrency/src/link/table.rs ++++ b/concurrency/src/link/table.rs +@@ -157,9 +157,7 @@ pub(crate) fn remove_pair( + peer_id: ActorId, + peer: &LinkTable, + ) -> (Option, Option) { +- with_pair(own_id, own, peer_id, peer, |a, b| { +- (remove(a, peer_id), remove(b, own_id)) +- }) ++ with_pair(own_id, own, peer_id, peer, |_a, b| (None, remove(b, own_id))) } + /// Receiver-side delivery: under the receiver's table lock, apply the notice diff --git a/verification/planted/patches/12-link-dead-peer-normal.patch b/verification/planted/patches/12-link-dead-peer-normal.patch index 0a52e68d..762fd80f 100644 --- a/verification/planted/patches/12-link-dead-peer-normal.patch +++ b/verification/planted/patches/12-link-dead-peer-normal.patch @@ -1,16 +1,15 @@ -Planted bug 12 (link-dead-peer-normal): Linking to an already-exited peer reports Normal instead of its reason +Planted bug 12 (link-dead-peer-normal): Linking to an already-exited peer reports Normal instead of NoProc diff --git a/concurrency/src/link.rs b/concurrency/src/link.rs -index 48cf54a8..a85bdb9a 100644 +index ff5b35ef..45e66107 100644 --- a/concurrency/src/link.rs +++ b/concurrency/src/link.rs -@@ -154,7 +154,8 @@ pub(crate) fn register_link( - return None; - } - if let Some(reason) = &b.exited { -- return Some(reason.clone()); -+ let _ = reason; -+ return Some(ExitReason::Normal); - } - a.entries.push(LinkEntry { - peer_id, +@@ -383,7 +383,7 @@ fn link_in_section( + }); + } + let delivery = if outcome == LinkOutcome::NoProc && !try_only { +- deliver_notice_in_section(own_links, own, peer.id, gen, ExitReason::NoProc) ++ deliver_notice_in_section(own_links, own, peer.id, gen, ExitReason::Normal) + } else { + DeliveryCleanup::default() + }; diff --git a/verification/planted/patches/13-exit-linked-cause-dropped.patch b/verification/planted/patches/13-exit-linked-cause-dropped.patch index 263de5cd..20d7a8c9 100644 --- a/verification/planted/patches/13-exit-linked-cause-dropped.patch +++ b/verification/planted/patches/13-exit-linked-cause-dropped.patch @@ -1,15 +1,21 @@ Planted bug 13 (exit-linked-cause-dropped): An actor killed through a link exits Normal, so the crash stops propagating -diff --git a/concurrency/src/actor_cleanup.rs b/concurrency/src/actor_cleanup.rs -index 69e376ff..0fa2c19d 100644 ---- a/concurrency/src/actor_cleanup.rs -+++ b/concurrency/src/actor_cleanup.rs -@@ -72,7 +72,7 @@ impl ActorCleanup { - } - } - if matches!(reason, ExitReason::Normal) { -- if let Some(linked) = cause.as_ref() { -+ if let Some(linked) = cause.as_ref().filter(|c| !c.is_abnormal()) { - reason = linked.clone(); - } - if reason == ExitReason::Normal { +diff --git a/concurrency/src/link.rs b/concurrency/src/link.rs +index ff5b35ef..cf77cea9 100644 +--- a/concurrency/src/link.rs ++++ b/concurrency/src/link.rs +@@ -310,7 +310,13 @@ fn apply_signal( + if exit.reason == ExitReason::Normal { + return; + } +- if request.untrapped(exit.reason) { ++ // Planted: a link notice ends the receiver Normal, dropping the cause. ++ let reason = if origin == Origin::Link { ++ ExitReason::Normal ++ } else { ++ exit.reason ++ }; ++ if request.untrapped(reason) { + drop(request); + (target.wake)(); + } diff --git a/verification/planted/patches/14-exit-shutdown-reports-normal.patch b/verification/planted/patches/14-exit-shutdown-reports-normal.patch index 5a980e24..e3659fd9 100644 --- a/verification/planted/patches/14-exit-shutdown-reports-normal.patch +++ b/verification/planted/patches/14-exit-shutdown-reports-normal.patch @@ -1,15 +1,18 @@ -Planted bug 14 (exit-shutdown-reports-normal): ChildHandle::shutdown commits Normal instead of Shutdown +Planted bug 14 (exit-shutdown-reports-normal): An administrative Shutdown stop (ChildHandle::stop_with_reason(Shutdown); `shutdown()` before 0.8) commits Normal diff --git a/concurrency/src/child_handle.rs b/concurrency/src/child_handle.rs -index dbcd8611..76b5df14 100644 +index 3b94d213..541fee9c 100644 --- a/concurrency/src/child_handle.rs +++ b/concurrency/src/child_handle.rs -@@ -190,7 +190,7 @@ impl ChildHandle { - /// Request an ordered cooperative shutdown without replacing an earlier - /// committed cause. A cleanup panic remains an abnormal exit. - pub fn shutdown(&self) { -- crate::link::stop_with_reason(&self.linked_reason, ExitReason::Shutdown, || { -+ crate::link::stop_with_reason(&self.linked_reason, ExitReason::Normal, || { - (self.cancel)() +@@ -170,6 +170,11 @@ impl ChildHandle { + /// runs. `stop_with_reason(Kill)` ends `Kill`; use [`kill`](Self::kill) + /// for the untrappable kill signal that ends `Killed`. + pub fn stop_with_reason(&self, reason: ExitReason) { ++ let reason = if reason == ExitReason::Shutdown { ++ ExitReason::Normal ++ } else { ++ reason ++ }; + crate::link::stop_with_reason(self.target.id, &self.target.request, reason, || { + (self.target.wake)() }); - } diff --git a/verification/planted/patches/15-mon-down-after-demonitor.patch b/verification/planted/patches/15-mon-down-after-demonitor.patch index 5ca108e9..da8ad616 100644 --- a/verification/planted/patches/15-mon-down-after-demonitor.patch +++ b/verification/planted/patches/15-mon-down-after-demonitor.patch @@ -1,15 +1,41 @@ Planted bug 15 (mon-down-after-demonitor): The monitor waiter delivers Down even when demonitor already removed it -diff --git a/concurrency/src/tasks/actor.rs b/concurrency/src/tasks/actor.rs -index a7fb0ec2..09ec5c06 100644 ---- a/concurrency/src/tasks/actor.rs -+++ b/concurrency/src/tasks/actor.rs -@@ -458,7 +458,7 @@ impl Context { - .as_mut() - .and_then(|entries| entries.remove(&monitor_ref)) - .is_some(); -- if deliver { -+ if deliver || reason.is_abnormal() { - let _ = actor_ref.send(Down { - monitor_ref, - reason, +diff --git a/concurrency/src/monitor/fence.rs b/concurrency/src/monitor/fence.rs +index f7bbaa27..d7778cf3 100644 +--- a/concurrency/src/monitor/fence.rs ++++ b/concurrency/src/monitor/fence.rs +@@ -83,7 +83,7 @@ pub(crate) fn register( + /// and enqueue the `Down` (`deliver`) in one critical section, so once + /// [`demonitor`] returns no `Down` of this monitor is enqueued, and one + /// already enqueued is flushed. Returns whether it was delivered. +-pub(crate) fn deliver( ++pub(crate) fn deliver( + table: &Entries, + key: &K, + deliver: impl FnOnce(), +@@ -95,7 +95,14 @@ pub(crate) fn deliver( + *entry = Entry::Queued; + true + } +- _ => false, ++ Some(Entry::Queued) => false, ++ // Planted: a removed (demonitored) entry is delivered anyway. ++ None => { ++ if let Some(entries) = guard.as_mut() { ++ entries.insert(key.clone(), Entry::Queued); ++ } ++ true ++ } + }; + if active { + deliver(); +@@ -155,7 +162,8 @@ pub(crate) fn demonitor( + let entry = guard.as_mut().and_then(|entries| entries.remove(key))?; + removed(); + match entry { +- Entry::Active(value) => Some(value), ++ // Planted: the waiter is not woken, so it still delivers. ++ Entry::Active(_value) => None, + Entry::Queued => None, + } + } diff --git a/verification/planted/patches/16-mon-dead-target-no-down.patch b/verification/planted/patches/16-mon-dead-target-no-down.patch index cbe3cecf..b12e950f 100644 --- a/verification/planted/patches/16-mon-dead-target-no-down.patch +++ b/verification/planted/patches/16-mon-dead-target-no-down.patch @@ -1,15 +1,18 @@ Planted bug 16 (mon-dead-target-no-down): Monitoring an already-dead actor returns an inert ref and no Down -diff --git a/concurrency/src/tasks/actor.rs b/concurrency/src/tasks/actor.rs -index a7fb0ec2..92ed728e 100644 ---- a/concurrency/src/tasks/actor.rs -+++ b/concurrency/src/tasks/actor.rs -@@ -424,7 +424,7 @@ impl Context { - // The token check makes registration inert once shutdown starts. - // The closed table below serializes registration with exit cleanup, - // even on paths that unwind before cancelling the owner token. -- if self.shared.cancellation_token.is_cancelled() { -+ if self.shared.cancellation_token.is_cancelled() || !target.is_alive() { - return monitor_ref; - } - let Some(monitors) = monitors.as_mut() else { +diff --git a/concurrency/src/monitor/fence.rs b/concurrency/src/monitor/fence.rs +index f7bbaa27..d40d7c7e 100644 +--- a/concurrency/src/monitor/fence.rs ++++ b/concurrency/src/monitor/fence.rs +@@ -70,9 +70,8 @@ pub(crate) fn register( + return Registration::Inert; + }; + if target_dead() { +- late(); +- entries.insert(key, Entry::Queued); +- return Registration::Late; ++ let _ = late; ++ return Registration::Inert; + } + entries.insert(key, Entry::Active(value)); + active(); diff --git a/verification/planted/patches/17-mon-cleanup-keeps-waiters.patch b/verification/planted/patches/17-mon-cleanup-keeps-waiters.patch index 4c682ebe..4fef3ff4 100644 --- a/verification/planted/patches/17-mon-cleanup-keeps-waiters.patch +++ b/verification/planted/patches/17-mon-cleanup-keeps-waiters.patch @@ -1,14 +1,14 @@ Planted bug 17 (mon-cleanup-keeps-waiters): An exiting observer does not cancel its monitor waiters (they hold its handle until the target dies) diff --git a/concurrency/src/monitor.rs b/concurrency/src/monitor.rs -index 578f835c..40a53974 100644 +index 2a7c5d66..e4459eda 100644 --- a/concurrency/src/monitor.rs +++ b/concurrency/src/monitor.rs -@@ -69,9 +69,7 @@ impl Drop for MonitorCleanup { - #[cfg(spawned_sim)] - let monitors: std::collections::BTreeMap = - monitors.into_iter().map(|(r, t)| (r.0, t)).collect(); -- for token in monitors.into_values() { +@@ -94,9 +94,7 @@ impl Drop for MonitorCleanup { + monitors.sort_unstable_by_key(|(r, _)| r.0); + monitors + }; +- for (_, token) in monitors { - token.cancel(); - } + std::mem::forget(monitors); diff --git a/verification/planted/patches/19-mb-handle-after-stop.patch b/verification/planted/patches/19-mb-handle-after-stop.patch index 35131f3b..a9af4140 100644 --- a/verification/planted/patches/19-mb-handle-after-stop.patch +++ b/verification/planted/patches/19-mb-handle-after-stop.patch @@ -1,16 +1,17 @@ Planted bug 19 (mb-handle-after-stop): The run loop keeps handling queued messages after stop (D4) -diff --git a/concurrency/src/tasks/actor.rs b/concurrency/src/tasks/actor.rs -index a7fb0ec2..200d1e8c 100644 ---- a/concurrency/src/tasks/actor.rs -+++ b/concurrency/src/tasks/actor.rs -@@ -1273,9 +1273,6 @@ async fn run_actor_lifecycle( - // Stop and closed-mailbox both take the normal lifecycle exit, - // just like the cancellation arm below. Check before consuming - // work, including when receive resumes from a pending poll. -- if cancellation_token.is_cancelled() { -- return std::task::Poll::Ready(None); -- } - let result = rx.poll_recv(cx); - #[cfg(feature = "backend-experiments")] - if let Some(turn) = &mut turn { +diff --git a/concurrency/src/tasks/actor/lifecycle.rs b/concurrency/src/tasks/actor/lifecycle.rs +index a88489ac..443f67ff 100644 +--- a/concurrency/src/tasks/actor/lifecycle.rs ++++ b/concurrency/src/tasks/actor/lifecycle.rs +@@ -443,9 +443,7 @@ pub(super) async fn run_actor_lifecycle( + #[cfg(all(test, not(feature = "lifecycle-trace"), not(spawned_sim)))] + stop_receive_probe::before_receive(); + let received = rx.poll_recv(cx); +- let result = cancellation_token.after_receive(received, |item| { +- rx.hold_for_shutdown(item); +- }); ++ let result = received; + #[cfg(feature = "lifecycle-trace")] + if let std::task::Poll::Ready(Some(envelope)) = &result { + crate::lifecycle_trace::life_emit(trace_id, || { diff --git a/verification/planted/patches/20-mb-send-deferred.patch b/verification/planted/patches/20-mb-send-deferred.patch index e41e3645..34ab0903 100644 --- a/verification/planted/patches/20-mb-send-deferred.patch +++ b/verification/planted/patches/20-mb-send-deferred.patch @@ -1,22 +1,29 @@ Planted bug 20 (mb-send-deferred): ActorRef::send enqueues from a spawned task, so a later request can overtake it (D1) -diff --git a/concurrency/src/tasks/actor.rs b/concurrency/src/tasks/actor.rs -index a7fb0ec2..dc6fabc2 100644 ---- a/concurrency/src/tasks/actor.rs -+++ b/concurrency/src/tasks/actor.rs -@@ -749,7 +749,14 @@ impl ActorRef { +diff --git a/concurrency/src/tasks/actor/actor_ref.rs b/concurrency/src/tasks/actor/actor_ref.rs +index c32dc8d3..8046bf5e 100644 +--- a/concurrency/src/tasks/actor/actor_ref.rs ++++ b/concurrency/src/tasks/actor/actor_ref.rs +@@ -31,12 +31,16 @@ impl ActorRef { A: Handler, M: Message, { -- enqueue(&self.shared.sender, &self.shared.mailbox, msg, None) -+ if self.shared.cancellation_token.is_cancelled() { -+ return Err(ActorError::ActorStopped); -+ } +- enqueue_send( +- &self.shared.sender, +- &self.shared.mailbox, +- &self.shared.replies, +- msg, +- ) + let this = self.clone(); -+ spawned_rt::tasks::spawn(async move { -+ let _ = enqueue(&this.shared.sender, &this.shared.mailbox, msg, None); ++ let _ = rt::spawn(async move { ++ let _ = enqueue_send( ++ &this.shared.sender, ++ &this.shared.mailbox, ++ &this.shared.replies, ++ msg, ++ ); + }); + Ok(()) } - /// Send a request and get a raw oneshot receiver for the reply. + /// Send a request without waiting (`gen_server:send_request/2` with an explicit deadline) and get diff --git a/verification/planted/patches/INDEX.tsv b/verification/planted/patches/INDEX.tsv index f839e55f..5d512a88 100644 --- a/verification/planted/patches/INDEX.tsv +++ b/verification/planted/patches/INDEX.tsv @@ -9,16 +9,16 @@ id name file bug 08 sup-budget-exhaustion-silent supervision/run.rs Exhausting the restart budget retires the child instead of failing the supervisor 09 nested-restart-mode-ignored supervision/nested.rs A nested supervisor's restart mode is ignored (always Permanent) 10 link-normal-exit-kills link.rs A Normal exit kills a non-trapping linked peer -11 link-unlink-one-sided link.rs unlink removes only the caller's edge; the peer still signals it -12 link-dead-peer-normal link.rs Linking to an already-exited peer reports Normal instead of its reason -13 exit-linked-cause-dropped actor_cleanup.rs An actor killed through a link exits Normal, so the crash stops propagating -14 exit-shutdown-reports-normal child_handle.rs ChildHandle::shutdown commits Normal instead of Shutdown -15 mon-down-after-demonitor tasks/actor.rs The monitor waiter delivers Down even when demonitor already removed it -16 mon-dead-target-no-down tasks/actor.rs Monitoring an already-dead actor returns an inert ref and no Down +11 link-unlink-one-sided link/table.rs unlink is one-sided: the caller keeps its record, so the peer's death still signals it +12 link-dead-peer-normal link.rs Linking to an already-exited peer reports Normal instead of NoProc +13 exit-linked-cause-dropped link.rs An actor killed through a link exits Normal, so the crash stops propagating +14 exit-shutdown-reports-normal child_handle.rs An administrative Shutdown stop (ChildHandle::stop_with_reason(Shutdown); `shutdown()` before 0.8) commits Normal +15 mon-down-after-demonitor monitor/fence.rs The monitor waiter delivers Down even when demonitor already removed it +16 mon-dead-target-no-down monitor/fence.rs Monitoring an already-dead actor returns an inert ref and no Down 17 mon-cleanup-keeps-waiters monitor.rs An exiting observer does not cancel its monitor waiters (they hold its handle until the target dies) 18 reg-not-removed-on-death system.rs A managed actor's registered name is never removed when its scope ends -19 mb-handle-after-stop tasks/actor.rs The run loop keeps handling queued messages after stop (D4) -20 mb-send-deferred tasks/actor.rs ActorRef::send enqueues from a spawned task, so a later request can overtake it (D1) +19 mb-handle-after-stop tasks/actor/lifecycle.rs The run loop keeps handling queued messages after stop (D4) +20 mb-send-deferred tasks/actor/actor_ref.rs ActorRef::send enqueues from a spawned task, so a later request can overtake it (D1) 21 timer-after-cancel tasks/time.rs send_after ignores its own cancellation token (fires after cancel) 22 timer-interval-outlives-actor tasks/time.rs send_interval keeps ticking after its actor stops (only its own token stops it) 23 sys-shutdown-forward-order system.rs ActorSystem shutdown stops targets in admission order instead of reverse