Struct DualFailureDumpReport 

#[non_exhaustive]
pub struct DualFailureDumpReport {
    pub schema: String,
    pub early: Option<FailureDumpReport>,
    pub late: FailureDumpReport,
    pub early_max_age_jiffies: u64,
    pub early_threshold_jiffies: u64,
    pub early_skipped_reason: Option<String>,
}

Pair of failure-dump snapshots captured at two points in a stall.

early is taken when the host-side runnable_at scanner observes any task with jiffies - p->scx.runnable_at > watchdog_timeout/2 (mirrors the kernel’s check_rq_for_timeouts walk over rq->scx.runnable_list). late is taken at the same trigger as the single-snapshot path: the BPF probe’s ktstr_err_exit_detected latch flipping after a sched_ext error-class exit.

early == None when the watchdog half-way threshold never triggered before late fired (e.g. an immediate scheduler error in init_task before any task became runnable). Diffing late against early shows what BPF state changed during the stall window — the value-add over the single-snapshot dump.

No user toggle — auto-repro engages this automatically. Only the auto-repro VM emits this shape; crate::test_support::probe::attempt_auto_repro is the single call site flipping the builder’s dual_snapshot flag, and there is no public ktstr surface for asking for it from a primary VM. Test authors don’t need to know about it — when an auto-repro fires, the file at <test>-<variant_hash>.repro.failure-dump.json changes shape from FailureDumpReport to this wrapper.

Note: there is no Default impl. The late field is required by the doc invariant (“the freeze coordinator only writes a DualFailureDumpReport after the late snapshot has been captured”); a Default::default() would have produced a wrapper with an empty late report whose maps/vcpu_regs vectors silently lie about a successful capture. Construct via the struct literal with an explicit late: FailureDumpReport.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

schema: String

Wire-format discriminant. Always "dual" for this variant, pinning SCHEMA_DUAL. Mirror of FailureDumpReport::schema — consumers branch on it before deserializing.

early: Option<FailureDumpReport>

Snapshot at the watchdog half-way point. None when the stall fired before the half-way scanner crossed its threshold.

late: FailureDumpReport

Snapshot at the error-exit latch trigger. Always present (the freeze coordinator only writes a DualFailureDumpReport after the late snapshot has been captured; if the run ends with only an early snapshot the file is not written at all).

early_max_age_jiffies: u64

Maximum jiffies - p->scx.runnable_at observed by the runnable_at scanner at the moment the early snapshot fired. Zero when early is None.

To recover the kernel’s full watchdog_timeout, double Self::early_threshold_jiffies — the scanner trigger fires at half the watchdog, so the threshold field carries watchdog_timeout / 2. Diff early_max_age_jiffies against 2 * early_threshold_jiffies to see how close the system was to the SCX_EXIT_ERROR_STALL emission line at the early-trigger point.

early_threshold_jiffies: u64

The half-way trigger threshold the scanner compared against when capturing the early snapshot, expressed in guest jiffies. Equals (watchdog_timeout_ms * CONFIG_HZ) / 1000 / 2 at the moment the snapshot fired. Zero when early is None.

Surfaced alongside early_max_age_jiffies so a downstream consumer reading the JSON does not have to recompute the kernel-internal jiffies arithmetic to reproduce the trigger condition.

early_skipped_reason: Option<String>

Structured reason the early snapshot is absent. None when the early snapshot was captured (the Self::early field is Some). When the early field is None, this carries a short machine-friendly string identifying which of the known failure modes occurred:

• "scan prerequisites unavailable: <prereq>" — the per-CPU runnable_at scan never resolved its dependencies (most often <prereq> names the missing kernel symbol / BTF entry).
• "max_age never crossed threshold (peak={peak}j, threshold={threshold}j)" — the scan ran but the maximum observed runnable-age stayed below the half-way mark for the whole VM lifetime. Indicates a non-stall err-class exit (e.g. scx_bpf_error()).
• "scx_tick stall — no per-task runnable_at data" — the stall path that drove the late capture has no per-task runnable_at to scan (the kernel’s “watchdog failed to check in” path raises SCX_EXIT_ERROR_STALL from the scx_tick kernel side without any task on rq->scx.runnable_list).

Display rendering at super::display surfaces this string directly; the previous “stall fired before half-way threshold, or runnable_at scan setup failed” generic text is replaced with the structured reason whenever this field is Some.

Trait Implementations

impl Clone for DualFailureDumpReport

fn clone(&self) -> DualFailureDumpReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DualFailureDumpReport

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DualFailureDumpReport

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DualFailureDumpReport

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

Formats the value using the given formatter.

impl Serialize for DualFailureDumpReport

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

where __S: Serializer,

Serialize this value into the given Serde serializer.