Enum DetailKind 

pub enum DetailKind {
    Starved,
    Stuck,
    Unfair,
    Isolation,
    Benchmark,
    Migration,
    PageLocality,
    CrossNodeMigration,
    SlowTier,
    Monitor,
    SchedulerCrashed,
    SchedulerExitedCleanly,
    SchedulerDiedUnknownReason,
    SchedulerEvent,
    Temporal,
    WorkerStalled,
    Skip,
    Other,
}

Category tag for an AssertDetail. Enables structural filtering (e.g. by AssertPlan) without matching on substrings of human-readable messages, which is fragile if wording changes.

Notes previously lived as a DetailKind::Note variant on AssertDetail; they now live on AssertResult::info_notes as InfoNote values. See AssertResult::note / AssertResult::with_note for the producer-side migration and InfoNote for the rationale (structurally-separate context stream so sidecar consumers iterating details count only real failures without a “forgot to filter kind == Note” miscount class of bug).

Variants

Starved

A worker made zero progress.

Stuck

A worker was stuck off-CPU longer than the gap threshold.

Unfair

Spread between best and worst worker exceeded the fairness threshold.

Isolation

A worker ran on a CPU outside its expected cpuset.

Benchmark

Throughput / benchmarking threshold failure (p99, CV, rate).

Migration

Migration-ratio threshold failure (migrations per iteration).

PageLocality

NUMA page locality threshold failure.

CrossNodeMigration

Cross-node migration threshold failure.

SlowTier

Slow-tier (memory tier) threshold failure.

Monitor

Monitor-subsystem anomaly (imbalance, DSQ depth, rq_clock stall). Use one of DetailKind::SchedulerCrashed / DetailKind::SchedulerExitedCleanly / DetailKind::SchedulerDiedUnknownReason for scheduler-liveness failures.

SchedulerCrashed

Scheduler process observed to have died (via sched_pid probe returning ESRCH or wait on the leader) AND the BPF probe observed a non-clean trace_sched_ext_exit event before the liveness check fired. The crash classification covers SCX_EXIT_ERROR, SCX_EXIT_ERROR_STALL, watchdog kick, and BPF-side error paths — every kernel exit that latches ktstr_err_exit_detected in the probe BSS.

Distinguished from DetailKind::SchedulerExitedCleanly (SCX_EXIT_NONE clean teardown) so the console-dump gate and downstream triage can tell a real crash from a benign completion. Consumers wanting to gate on “any scheduler exit” should match both variants via matches!(d.kind, SchedulerCrashed | SchedulerExitedCleanly).

SchedulerExitedCleanly

Scheduler process observed to have died with the probe BSS ktstr_err_exit_detected latch unset — the kernel ran the SCX_EXIT_NONE clean-teardown path (sysrq, explicit unregister) without latching an error. Surfaces alongside SchedulerCrashed because both are “scheduler exited” signals; splitting them lets the operator distinguish a benign shutdown from a real fault without re-parsing console output.

SchedulerDiedUnknownReason

Scheduler process observed to have died but the BPF probe has no classification yet — either the probe never armed for this run (no scheduler attached, host-only test) or the poll thread has not completed a first iteration since the prior reset. Operators triaging this variant should check whether the probe pipeline was wired before concluding “scheduler-exit classification is broken”.

SchedulerEvent

SCX event-counter threshold failure. An error-class SCX_EV_* counter (e.g. enq_skip_exiting, enq_skip_migration_disabled, dispatch_local_dsq_offline) crossed the configured bound. Distinct from the process-liveness variants (DetailKind::SchedulerCrashed / DetailKind::SchedulerExitedCleanly / DetailKind::SchedulerDiedUnknownReason) and DetailKind::Monitor (imbalance / DSQ-depth / rq_clock-stall): this kind flags individual event-counter regressions surfaced by assert_scx_events_clean. The counters themselves originate in the kernel’s per-task scx_event_stats (see kernel/sched/ext.c — SCX_EV_* macros); ktstr reads aggregated deltas via monitor::ScxEventDeltas and presents them to the assertion as (name, count) pairs.

Temporal

Temporal assertion failure on a periodic-capture SampleSeries. One of the seven built-in patterns (nondecreasing / strictly_increasing, rate_within, steady_within, converges_to, always_true, ratio_within) or a per-sample scalar comparator invoked via .each(...) reported a violation. The detail message names the pattern, the offending sample tag(s), and the observed-vs-expected values; the stdout --- temporal assertions --- summary in test_support::output aggregates the same kind into per-assertion pass/fail rows.

WorkerStalled

Host-mode worker stall detected by crate::scenario::host_stall. The polling thread observed Δnr_switches == 0 AND Δsum_exec_runtime == 0 across the configured window for a worker pid — the task neither got picked nor preempted for at least STALL_WINDOW * poll_interval ms. Distinct from DetailKind::Stuck (worker-side report: a worker was off-CPU longer than the in-test gap threshold): this kind fires from the host-side polling thread when running host-mode (no VM boot) and is the only stall signal available in that mode.

Skip

Skip notification (scenario could not run under this topology/flags).

Other

Uncategorized — falls through when a detail has no specific kind.

Trait Implementations

impl Clone for DetailKind

fn clone(&self) -> DetailKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DetailKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DetailKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for DetailKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DetailKind

fn eq(&self, other: &DetailKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DetailKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for DetailKind

impl Eq for DetailKind

impl StructuralPartialEq for DetailKind