1use super::super::btf_render::{
17 RenderedMember, RenderedValue, is_inline_scalar, is_zero, write_value_at_depth,
18};
19use super::{
20 DegradedFailureDumpReport, DualFailureDumpReport, EventCounterSample, FailureDumpArrayEntry,
21 FailureDumpEntry, FailureDumpMap, FailureDumpPercpuEntry, FailureDumpPercpuHashEntry,
22 FailureDumpReport, FailureDumpReportAny, render_sparkline_i64,
23};
24
25const TABLE_MIN_ENTRIES: usize = 2;
30
31fn try_write_entry_table(
57 f: &mut std::fmt::Formatter<'_>,
58 entries: &[FailureDumpEntry],
59) -> Result<bool, std::fmt::Error> {
60 if entries.len() < TABLE_MIN_ENTRIES {
61 return Ok(false);
62 }
63 if entries.iter().any(|e| e.payload.is_some()) {
67 return Ok(false);
68 }
69 let pairs: Option<Vec<(&Vec<RenderedMember>, &Vec<RenderedMember>)>> = entries
73 .iter()
74 .map(|e| match (&e.key, &e.value) {
75 (
76 Some(RenderedValue::Struct { members: k, .. }),
77 Some(RenderedValue::Struct { members: v, .. }),
78 ) => Some((k, v)),
79 _ => None,
80 })
81 .collect();
82 let Some(pairs) = pairs else {
83 return Ok(false);
84 };
85 if pairs.is_empty() {
86 return Ok(false);
87 }
88
89 let (first_key_name, first_value_name) = match (&entries[0].key, &entries[0].value) {
92 (
93 Some(RenderedValue::Struct { type_name: kn, .. }),
94 Some(RenderedValue::Struct { type_name: vn, .. }),
95 ) => (kn.clone(), vn.clone()),
96 _ => return Ok(false),
97 };
98 for e in &entries[1..] {
99 match (&e.key, &e.value) {
100 (
101 Some(RenderedValue::Struct { type_name: kn, .. }),
102 Some(RenderedValue::Struct { type_name: vn, .. }),
103 ) => {
104 if *kn != first_key_name || *vn != first_value_name {
105 return Ok(false);
106 }
107 }
108 _ => return Ok(false),
109 }
110 }
111
112 let (k0, v0) = pairs[0];
113 let key_names: Vec<&str> = k0.iter().map(|m| m.name.as_str()).collect();
114 let value_names: Vec<&str> = v0.iter().map(|m| m.name.as_str()).collect();
115
116 for (k, v) in &pairs {
122 if k.len() != k0.len() || v.len() != v0.len() {
123 return Ok(false);
124 }
125 for (a, b) in k.iter().zip(k0.iter()) {
126 if a.name != b.name {
127 return Ok(false);
128 }
129 }
130 for (a, b) in v.iter().zip(v0.iter()) {
131 if a.name != b.name {
132 return Ok(false);
133 }
134 }
135 }
136
137 for (k, v) in &pairs {
141 if !k.iter().all(|m| is_inline_scalar(&m.value)) {
142 return Ok(false);
143 }
144 if !v.iter().all(|m| is_inline_scalar(&m.value)) {
145 return Ok(false);
146 }
147 }
148
149 let key_rows: Vec<Vec<String>> = pairs
154 .iter()
155 .map(|(k, _)| k.iter().map(|m| format!("{}", m.value)).collect())
156 .collect();
157 let value_rows: Vec<Vec<String>> = pairs
158 .iter()
159 .map(|(_, v)| v.iter().map(|m| format!("{}", m.value)).collect())
160 .collect();
161
162 let key_widths: Vec<usize> = (0..key_names.len())
166 .map(|c| {
167 let cell_max = key_rows.iter().map(|r| r[c].len()).max().unwrap_or(0);
168 key_names[c].len().max(cell_max)
169 })
170 .collect();
171 let value_widths: Vec<usize> = (0..value_names.len())
172 .map(|c| {
173 let cell_max = value_rows.iter().map(|r| r[c].len()).max().unwrap_or(0);
174 value_names[c].len().max(cell_max)
175 })
176 .collect();
177
178 f.write_str("\n ")?;
180 for (i, name) in key_names.iter().enumerate() {
181 if i > 0 {
182 f.write_str(" ")?;
183 }
184 write!(f, "{:>width$}", name, width = key_widths[i])?;
185 }
186 f.write_str(" | ")?;
187 for (i, name) in value_names.iter().enumerate() {
188 if i > 0 {
189 f.write_str(" ")?;
190 }
191 write!(f, "{:>width$}", name, width = value_widths[i])?;
192 }
193
194 for (key_row, value_row) in key_rows.iter().zip(value_rows.iter()) {
199 f.write_str("\n ")?;
200 for (i, cell) in key_row.iter().enumerate() {
201 if i > 0 {
202 f.write_str(" ")?;
203 }
204 write!(f, "{:>width$}", cell, width = key_widths[i])?;
205 }
206 f.write_str(" | ")?;
207 for (i, cell) in value_row.iter().enumerate() {
208 if i > 0 {
209 f.write_str(" ")?;
210 }
211 write!(f, "{:>width$}", cell, width = value_widths[i])?;
212 }
213 }
214
215 Ok(true)
216}
217
218impl std::fmt::Display for DualFailureDumpReport {
219 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
220 let n_maps = self.late.maps.len();
226 let m_vcpu_regs = self.late.vcpu_regs.len();
227 if self.early.is_some() {
228 if self.early_max_age_jiffies == 0 && self.early_threshold_jiffies == 0 {
235 write!(
236 f,
237 "DualFailureDumpReport: early=present (jiffies not captured), \
238 late=({n_maps} maps, {m_vcpu_regs} vcpu_regs)\n\n",
239 )?;
240 } else {
241 write!(
242 f,
243 "DualFailureDumpReport: early=present (max_age={}j, threshold={}j), \
244 late=({n_maps} maps, {m_vcpu_regs} vcpu_regs)\n\n",
245 self.early_max_age_jiffies, self.early_threshold_jiffies,
246 )?;
247 }
248 } else if let Some(reason) = self.early_skipped_reason.as_deref() {
249 write!(
257 f,
258 "DualFailureDumpReport: early=absent ({reason}), \
259 late=({n_maps} maps, {m_vcpu_regs} vcpu_regs)\n\n",
260 )?;
261 } else {
262 write!(
268 f,
269 "DualFailureDumpReport: early=absent, late=({n_maps} maps, \
270 {m_vcpu_regs} vcpu_regs)\n\n",
271 )?;
272 }
273 match &self.early {
274 Some(early) => {
275 f.write_str("early snapshot (sched_ext watchdog half-way):\n")?;
276 std::fmt::Display::fmt(early, f)?;
277 f.write_str("\n\nlate snapshot (error-exit):\n")?;
278 std::fmt::Display::fmt(&self.late, f)
279 }
280 None => {
281 if let Some(reason) = self.early_skipped_reason.as_deref() {
282 writeln!(
283 f,
284 "late snapshot (error-exit; early snapshot absent: \
285 {reason}):",
286 )?;
287 } else {
288 f.write_str(
289 "late snapshot (error-exit; early snapshot absent \
290 (stall fired before half-way threshold, or runnable_at \
291 scan setup failed) — re-run with RUST_LOG=ktstr=debug \
292 for scan resolution diagnostics):\n",
293 )?;
294 }
295 std::fmt::Display::fmt(&self.late, f)
296 }
297 }
298 }
299}
300
301impl std::fmt::Display for FailureDumpReportAny {
302 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
303 match self {
304 Self::Single(r) => std::fmt::Display::fmt(r, f),
305 Self::Dual(r) => std::fmt::Display::fmt(r.as_ref(), f),
306 Self::Degraded(r) => std::fmt::Display::fmt(r.as_ref(), f),
307 }
308 }
309}
310
311impl std::fmt::Display for DegradedFailureDumpReport {
312 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
321 f.write_str("degraded failure dump:\n")?;
322 writeln!(f, " reason: {}", self.reason)?;
323 if !self.vcpu_regs.is_empty() {
324 let parked = self.vcpu_regs.iter().filter(|s| s.is_some()).count();
325 let total = self.vcpu_regs.len();
326 writeln!(f, " vcpus_parked: {parked}/{total}")?;
327 for (i, slot) in self.vcpu_regs.iter().enumerate() {
328 match slot {
329 Some(s) => writeln!(f, " vcpu {i}: parked, {s}")?,
330 None => writeln!(f, " vcpu {i}: not_parked")?,
331 }
332 }
333 }
334 writeln!(f, " watchpoint_hit: {}", self.watchpoint_hit)?;
335 writeln!(f, " bss_latch_state: {}", self.bss_latch_state)?;
336 if let Some(kind) = self.exit_kind {
337 writeln!(f, " exit_kind: {kind}")?;
338 }
339 if self.elapsed_ms != 0 {
340 writeln!(f, " elapsed_ms: {}", self.elapsed_ms)?;
341 }
342 Ok(())
343 }
344}
345
346impl FailureDumpReport {
347 fn fmt_guest_setup_failure(
354 &self,
355 f: &mut std::fmt::Formatter<'_>,
356 first: &mut bool,
357 ) -> std::fmt::Result {
358 let Some(context) = self
359 .guest_setup_failure
360 .as_ref()
361 .filter(|context| !context.is_empty())
362 else {
363 return Ok(());
364 };
365 if !*first {
366 f.write_str("\n\n")?;
367 }
368 *first = false;
369 f.write_str("guest setup failure:")?;
370 if let Some(stage) = &context.init_stage {
371 write!(f, "\n stage: {stage}")?;
372 }
373 if let Some(phase) = &context.final_guest_phase {
374 write!(f, "\n final_guest_phase: {phase}")?;
375 }
376 if let Some(code) = context.guest_exit_code {
377 write!(f, "\n guest_exit_code: {code}")?;
378 }
379 if let Some(attach) = &context.scheduler_attach_outcome {
380 write!(f, "\n scheduler_attach: {attach}")?;
381 }
382 for (label, tail) in [
383 ("scheduler log tail", &context.scheduler_log_tail),
384 ("init log tail (COM2)", &context.init_log_tail),
385 ("console tail (COM1)", &context.console_tail),
386 ] {
387 if let Some(tail) = tail {
388 write!(f, "\n {label}:")?;
389 for line in tail.lines() {
390 write!(f, "\n {line}")?;
391 }
392 }
393 }
394 Ok(())
395 }
396
397 fn fmt_scx_walker(
398 &self,
399 f: &mut std::fmt::Formatter<'_>,
400 first: &mut bool,
401 ) -> std::fmt::Result {
402 if !self.rq_scx_states.is_empty()
403 || !self.dsq_states.is_empty()
404 || self.scx_sched_state.is_some()
405 {
406 if !*first {
407 f.write_str("\n\n")?;
408 }
409 *first = false;
410 write!(
415 f,
416 "scx_walker: rq_scx={} dsq={} sched={}",
417 self.rq_scx_states.len(),
418 self.dsq_states.len(),
419 if self.scx_sched_state.is_some() {
420 "captured"
421 } else {
422 "absent"
423 },
424 )?;
425 }
426 if !self.is_placeholder
427 && let Some(reason) = &self.scx_walker_unavailable
428 {
429 if !*first {
430 f.write_str("\n\n")?;
431 }
432 *first = false;
433 write!(f, "scx_walker: <unavailable: {reason}>")?;
434 }
435 Ok(())
436 }
437
438 fn fmt_event_counter_timeline(
441 &self,
442 f: &mut std::fmt::Formatter<'_>,
443 first: &mut bool,
444 ) -> std::fmt::Result {
445 if !self.event_counter_timeline.is_empty() {
446 if !*first {
447 f.write_str("\n\n")?;
448 }
449 *first = false;
450 write!(
456 f,
457 "event_counter_timeline: {} samples ({}–{}ms)",
458 self.event_counter_timeline.len(),
459 self.event_counter_timeline
460 .first()
461 .map(|s| s.elapsed_ms)
462 .unwrap_or(0),
463 self.event_counter_timeline
464 .last()
465 .map(|s| s.elapsed_ms)
466 .unwrap_or(0),
467 )?;
468 type EventCounterExtract = (&'static str, fn(&EventCounterSample) -> i64);
475 let extract: [EventCounterExtract; 13] = [
476 ("select_cpu_fallback", |s| s.select_cpu_fallback),
477 ("dispatch_local_dsq_offline", |s| {
478 s.dispatch_local_dsq_offline
479 }),
480 ("dispatch_keep_last", |s| s.dispatch_keep_last),
481 ("enq_skip_exiting", |s| s.enq_skip_exiting),
482 ("enq_skip_migration_disabled", |s| {
483 s.enq_skip_migration_disabled
484 }),
485 ("reenq_immed", |s| s.reenq_immed),
486 ("reenq_local_repeat", |s| s.reenq_local_repeat),
487 ("refill_slice_dfl", |s| s.refill_slice_dfl),
488 ("bypass_duration", |s| s.bypass_duration),
489 ("bypass_dispatch", |s| s.bypass_dispatch),
490 ("bypass_activate", |s| s.bypass_activate),
491 ("insert_not_owned", |s| s.insert_not_owned),
492 ("sub_bypass_dispatch", |s| s.sub_bypass_dispatch),
493 ];
494 for (name, ext) in extract {
495 let series: Vec<i64> = self.event_counter_timeline.iter().map(ext).collect();
496 if series.iter().all(|&v| v == 0) {
497 continue;
498 }
499 let line = render_sparkline_i64(&series);
500 let last = series.last().copied().unwrap_or(0);
501 write!(f, "\n {name:>30} {line} (last={last})")?;
502 }
503 }
504 Ok(())
505 }
506
507 fn fmt_vcpu_perf_at_freeze(
510 &self,
511 f: &mut std::fmt::Formatter<'_>,
512 first: &mut bool,
513 ) -> std::fmt::Result {
514 if !self.vcpu_perf_at_freeze.is_empty() {
515 if !*first {
516 f.write_str("\n\n")?;
517 }
518 *first = false;
519 f.write_str("vcpu_perf_at_freeze:")?;
520 for (i, slot) in self.vcpu_perf_at_freeze.iter().enumerate() {
521 f.write_str("\n ")?;
522 match slot {
523 Some(s) => write!(
524 f,
525 "vcpu {i}: cycles={} insns={} ipc={:.3} cache_misses={} branch_misses={} (en/ru={}/{} ns)",
526 s.cycles,
527 s.instructions,
528 s.ipc(),
529 s.cache_misses,
530 s.branch_misses,
531 s.time_enabled_ns,
532 s.time_running_ns,
533 )?,
534 None => write!(f, "vcpu {i}: <unavailable>")?,
535 }
536 }
537 }
538 Ok(())
539 }
540}
541
542impl std::fmt::Display for FailureDumpReport {
543 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
551 if self.maps.is_empty()
552 && self.vcpu_regs.is_empty()
553 && self.sdt_allocations.is_empty()
554 && self.scx_static_ranges.is_empty()
555 && self.prog_runtime_stats.is_empty()
556 && self.prog_runtime_stats_unavailable.is_none()
557 && self.per_cpu_time.is_empty()
558 && self.per_node_numa.is_empty()
559 && self.per_node_numa_unavailable.is_none()
560 && self.task_enrichments.is_empty()
561 && self.task_enrichments_unavailable.is_none()
562 && self.event_counter_timeline.is_empty()
563 && self.rq_scx_states.is_empty()
564 && self.dsq_states.is_empty()
565 && self.scx_sched_state.is_none()
566 && self.scx_walker_unavailable.is_none()
567 && self.vcpu_perf_at_freeze.is_empty()
568 && self.dump_truncated_at_us.is_none()
569 && self.maps_truncated == 0
570 && self.sdt_alloc_unavailable.is_none()
571 && self
572 .guest_setup_failure
573 .as_ref()
574 .is_none_or(|context| context.is_empty())
575 {
576 return f.write_str("(empty failure dump)");
577 }
578 let rendered_maps: Vec<String> = self.maps.iter().map(|m| format!("{m}")).collect();
586 let mut first = true;
587 self.fmt_guest_setup_failure(f, &mut first)?;
588 if self.is_placeholder {
592 let reason = self
593 .prog_runtime_stats_unavailable
594 .as_deref()
595 .or(self.per_node_numa_unavailable.as_deref())
596 .or(self.task_enrichments_unavailable.as_deref())
597 .or(self.scx_walker_unavailable.as_deref())
598 .or(self.sdt_alloc_unavailable.as_deref());
599 if let Some(reason) = reason {
600 if !first {
601 f.write_str("\n\n")?;
602 }
603 first = false;
604 write!(f, "capture unavailable: {reason}")?;
605 }
606 }
607 for s in &rendered_maps {
608 if !first {
609 f.write_str("\n\n")?;
610 }
611 first = false;
612 f.write_str(s)?;
613 }
614 if !self.vcpu_regs.is_empty() {
615 if !first {
616 f.write_str("\n\n")?;
617 }
618 first = false;
619 f.write_str("vcpu_regs:")?;
620 for (i, slot) in self.vcpu_regs.iter().enumerate() {
621 f.write_str("\n ")?;
622 match slot {
623 Some(s) => write!(f, "vcpu {i}: {s}")?,
624 None => write!(f, "vcpu {i}: <unavailable>")?,
625 }
626 }
627 }
628 for snap in &self.sdt_allocations {
629 if !first {
630 f.write_str("\n\n")?;
631 }
632 first = false;
633 std::fmt::Display::fmt(snap, f)?;
634 }
635 if !self.is_placeholder
636 && let Some(reason) = &self.sdt_alloc_unavailable
637 {
638 if !first {
639 f.write_str("\n\n")?;
640 }
641 first = false;
642 write!(f, "sdt_allocations: <unavailable: {reason}>")?;
643 }
644 if !self.scx_static_ranges.is_empty() {
645 if !first {
646 f.write_str("\n\n")?;
647 }
648 first = false;
649 std::fmt::Display::fmt(&self.scx_static_ranges, f)?;
650 }
651 if !self.prog_runtime_stats.is_empty() {
652 if !first {
653 f.write_str("\n\n")?;
654 }
655 first = false;
656 f.write_str("prog_runtime_stats:")?;
657 for stats in &self.prog_runtime_stats {
658 f.write_str("\n ")?;
659 std::fmt::Display::fmt(stats, f)?;
660 }
661 }
662 if !self.is_placeholder
663 && let Some(reason) = &self.prog_runtime_stats_unavailable
664 {
665 if !first {
666 f.write_str("\n\n")?;
667 }
668 first = false;
669 write!(f, "prog_runtime_stats: <unavailable: {reason}>")?;
670 }
671 if !self.per_cpu_time.is_empty() {
672 if !first {
673 f.write_str("\n\n")?;
674 }
675 first = false;
676 write!(f, "per_cpu_time: {} CPUs captured", self.per_cpu_time.len())?;
681 }
682 if !self.per_node_numa.is_empty() {
683 if !first {
684 f.write_str("\n\n")?;
685 }
686 first = false;
687 write!(
688 f,
689 "per_node_numa: {} nodes captured",
690 self.per_node_numa.len()
691 )?;
692 }
693 if !self.is_placeholder
694 && let Some(reason) = &self.per_node_numa_unavailable
695 {
696 if !first {
697 f.write_str("\n\n")?;
698 }
699 first = false;
700 write!(f, "per_node_numa: <unavailable: {reason}>")?;
701 }
702 if !self.task_enrichments.is_empty() {
703 if !first {
704 f.write_str("\n\n")?;
705 }
706 first = false;
707 write!(
708 f,
709 "task_enrichments: {} tasks captured",
710 self.task_enrichments.len(),
711 )?;
712 }
713 if !self.is_placeholder
714 && let Some(reason) = &self.task_enrichments_unavailable
715 {
716 if !first {
717 f.write_str("\n\n")?;
718 }
719 first = false;
720 write!(f, "task_enrichments: <unavailable: {reason}>")?;
721 }
722 self.fmt_scx_walker(f, &mut first)?;
723 self.fmt_event_counter_timeline(f, &mut first)?;
724 self.fmt_vcpu_perf_at_freeze(f, &mut first)?;
725 if self.dump_truncated_at_us.is_some() || self.maps_truncated > 0 {
731 if !first {
732 f.write_str("\n\n")?;
733 }
734 f.write_str("dump truncated:")?;
735 if let Some(us) = self.dump_truncated_at_us {
736 write!(f, " deadline crossed at {us}us")?;
737 }
738 if self.maps_truncated > 0 {
739 write!(f, " ({} map(s) skipped)", self.maps_truncated)?;
740 }
741 }
742 Ok(())
743 }
744}
745
746impl std::fmt::Display for FailureDumpMap {
747 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
748 let type_str: std::borrow::Cow<'_, str> =
755 match super::render_map::map_type_name(self.map_type) {
756 Some(name) => std::borrow::Cow::Borrowed(name),
757 None => std::borrow::Cow::Owned(format!("{}", self.map_type)),
758 };
759 write!(
760 f,
761 "map {} (type={}, value_size={}, max_entries={})",
762 self.name, type_str, self.value_size, self.max_entries
763 )?;
764 if let Some(err) = &self.error {
765 write!(f, " [error: {err}]")?;
766 }
767 if let Some(value) = &self.value {
768 f.write_str("\n")?;
769 std::fmt::Display::fmt(value, f)?;
770 }
771 if !try_write_entry_table(f, &self.entries)? {
780 for entry in &self.entries {
781 f.write_str("\n")?;
782 std::fmt::Display::fmt(entry, f)?;
783 }
784 }
785 for entry in &self.array_entries {
786 f.write_str("\n")?;
787 std::fmt::Display::fmt(entry, f)?;
788 }
789 for entry in &self.percpu_entries {
790 f.write_str("\n")?;
791 std::fmt::Display::fmt(entry, f)?;
792 }
793 for entry in &self.percpu_hash_entries {
794 f.write_str("\n")?;
795 std::fmt::Display::fmt(entry, f)?;
796 }
797 if let Some(arena) = &self.arena {
798 let total_pages = arena.pages.len();
799 let total_kib: usize = arena.pages.iter().map(|p| p.bytes.len()).sum::<usize>() / 1024;
800 let nonzero = arena
801 .pages
802 .iter()
803 .filter(|p| p.bytes.iter().any(|&b| b != 0))
804 .count();
805 write!(
806 f,
807 "\narena: {total_pages} pages captured ({total_kib} KiB), \
808 {nonzero} non-zero (see sdt_alloc section + JSON for typed data)",
809 )?;
810 if arena.truncated {
811 write!(f, " (truncated, {} declared)", arena.declared_pages)?;
812 }
813 }
814 if let Some(rb) = &self.ringbuf {
815 let pct = if rb.capacity == 0 {
820 0
821 } else {
822 (rb.pending_bytes.saturating_mul(100) / rb.capacity).min(100)
823 };
824 write!(
825 f,
826 "\nringbuf: capacity={}B, pending={}B ({pct}%), \
827 consumer_pos={}, producer_pos={}, pending_pos={}",
828 rb.capacity, rb.pending_bytes, rb.consumer_pos, rb.producer_pos, rb.pending_pos,
829 )?;
830 }
831 if let Some(st) = &self.stack_trace {
832 write!(
833 f,
834 "\nstack_trace: {} of {} buckets populated",
835 st.entries.len(),
836 st.n_buckets,
837 )?;
838 if st.truncated {
839 f.write_str(" (truncated)")?;
840 }
841 if st.buckets_unreadable > 0 {
842 write!(f, " ({} unreadable)", st.buckets_unreadable)?;
843 }
844 for entry in &st.entries {
845 if entry.pcs.is_empty() {
846 write!(f, "\n bucket {}: nr={}", entry.bucket_id, entry.nr)?;
847 } else {
848 write!(f, "\n bucket {}: nr={} pcs=[", entry.bucket_id, entry.nr)?;
856 for (i, pc) in entry.pcs.iter().take(8).enumerate() {
857 if i > 0 {
858 f.write_str(", ")?;
859 }
860 write!(f, "{pc:#x}")?;
861 }
862 let extra = entry.pcs.len().saturating_sub(8);
863 if extra > 0 {
864 write!(f, ", +{extra} more")?;
865 }
866 f.write_str("]")?;
867 }
868 }
869 }
870 if let Some(fda) = &self.fd_array {
871 write!(
872 f,
873 "\nfd_array: {} of {} slots populated",
874 fda.populated, fda.scanned,
875 )?;
876 if fda.truncated {
877 f.write_str(" (slots truncated)")?;
878 }
879 if fda.unreadable > 0 {
880 write!(f, " ({} unreadable)", fda.unreadable)?;
881 }
882 if !fda.indices.is_empty() {
883 f.write_str(" indices=[")?;
887 for (i, idx) in fda.indices.iter().take(16).enumerate() {
888 if i > 0 {
889 f.write_str(", ")?;
890 }
891 write!(f, "{idx}")?;
892 }
893 let extra = fda.indices.len().saturating_sub(16);
894 if extra > 0 {
895 write!(f, ", +{extra} more")?;
896 }
897 f.write_str("]")?;
898 }
899 }
900 Ok(())
901 }
902}
903
904impl std::fmt::Display for FailureDumpEntry {
905 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
926 f.write_str("entry: key=")?;
934 match &self.key {
935 Some(k) => write_value_at_depth(f, k, 1)?,
936 None => write!(f, "{} (raw)", self.key_hex)?,
937 }
938 f.write_str("\n value: ")?;
943 match &self.value {
944 Some(v) => write_value_at_depth(f, v, 1)?,
945 None => write!(f, "{} (raw)", self.value_hex)?,
946 }
947 if let Some(p) = &self.payload {
958 f.write_str("\n .data ")?;
959 write_value_at_depth(f, p, 1)?;
960 }
961 Ok(())
962 }
963}
964
965impl std::fmt::Display for FailureDumpArrayEntry {
966 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
971 write!(f, "key {}: ", self.key)?;
972 match &self.value {
973 Some(v) => write_value_at_depth(f, v, 1)?,
974 None => f.write_str("<unreadable>")?,
975 }
976 Ok(())
977 }
978}
979
980impl std::fmt::Display for FailureDumpPercpuEntry {
981 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
982 let structs: Vec<(usize, &[RenderedMember])> = self
983 .per_cpu
984 .iter()
985 .enumerate()
986 .filter_map(|(cpu, slot)| match slot {
987 Some(RenderedValue::Struct { members, .. }) => Some((cpu, members.as_slice())),
988 _ => None,
989 })
990 .collect();
991
992 if structs.len() < 2 || structs.iter().any(|(_, m)| m.is_empty()) {
993 write!(f, "key {}:", self.key)?;
994 for (cpu, slot) in self.per_cpu.iter().enumerate() {
995 f.write_str("\n")?;
996 match slot {
997 Some(v) => {
998 write!(f, " cpu {cpu}: ")?;
999 std::fmt::Display::fmt(v, f)?;
1000 }
1001 None => write!(f, " cpu {cpu}: <unmapped>")?,
1002 }
1003 }
1004 return Ok(());
1005 }
1006
1007 let type_name = match &self.per_cpu.iter().flatten().next() {
1008 Some(RenderedValue::Struct { type_name, .. }) => type_name.clone(),
1009 _ => None,
1010 };
1011 let n_cpus = self.per_cpu.len();
1012 match &type_name {
1013 Some(name) => write!(f, "key {}: struct {name} ({n_cpus} CPUs)", self.key)?,
1014 None => write!(f, "key {}: ({n_cpus} CPUs)", self.key)?,
1015 }
1016
1017 const PERCPU_DEDUP_CPU_LIMIT: usize = 64;
1027 if n_cpus > PERCPU_DEDUP_CPU_LIMIT {
1028 for (cpu, slot) in self.per_cpu.iter().enumerate() {
1029 f.write_str("\n ")?;
1030 match slot {
1031 Some(v) => {
1032 write!(f, "cpu {cpu}: ")?;
1033 std::fmt::Display::fmt(v, f)?;
1034 }
1035 None => write!(f, "cpu {cpu}: <unmapped>")?,
1036 }
1037 }
1038 return Ok(());
1039 }
1040
1041 let mut groups: Vec<(Vec<usize>, &RenderedValue)> = Vec::new();
1046 let mut unmapped: Vec<usize> = Vec::new();
1047 for (cpu, slot) in self.per_cpu.iter().enumerate() {
1048 match slot {
1049 Some(val) => {
1050 if let Some(g) = groups.iter_mut().find(|(_, v)| *v == val) {
1051 g.0.push(cpu);
1052 } else {
1053 groups.push((vec![cpu], val));
1054 }
1055 }
1056 None => unmapped.push(cpu),
1057 }
1058 }
1059 if groups.len() >= 3 && groups.iter().all(|(cpus, _)| cpus.len() == 1) {
1063 let all_structs: Vec<(usize, &[RenderedMember])> = groups
1064 .iter()
1065 .filter_map(|(cpus, val)| match val {
1066 RenderedValue::Struct { members, .. } => Some((cpus[0], members.as_slice())),
1067 _ => None,
1068 })
1069 .collect();
1070 if all_structs.len() == groups.len()
1071 && all_structs
1072 .iter()
1073 .all(|(_, m)| m.len() == all_structs[0].1.len())
1074 {
1075 let first = all_structs[0].1;
1076 let mut varying: Vec<usize> = Vec::new();
1077 for i in 0..first.len() {
1078 if all_structs[1..]
1079 .iter()
1080 .any(|(_, m)| m[i].value != first[i].value)
1081 {
1082 varying.push(i);
1083 }
1084 }
1085 if !varying.is_empty() && varying.len() < 8 {
1086 f.write_str("\n common:")?;
1089 for (i, m) in first.iter().enumerate() {
1090 if varying.contains(&i) {
1091 continue;
1092 }
1093 if is_zero(&m.value) {
1094 continue;
1095 }
1096 write!(f, "\n {}: ", m.name)?;
1097 std::fmt::Display::fmt(&m.value, f)?;
1098 }
1099 f.write_str("\n per-cpu:")?;
1101 f.write_str("\n cpu")?;
1102 for &vi in &varying {
1103 write!(f, " | {}", first[vi].name)?;
1104 }
1105 for (cpu, members) in &all_structs {
1106 write!(f, "\n {cpu:>3}")?;
1107 for &vi in &varying {
1108 write!(f, " | {}", members[vi].value)?;
1109 }
1110 }
1111 if !unmapped.is_empty() {
1112 write!(f, "\n cpus {unmapped:?}: <unmapped>")?;
1113 }
1114 return Ok(());
1115 }
1116 }
1117 }
1118 for (cpus, val) in &groups {
1120 let cpu_list = if cpus.len() == n_cpus {
1121 "all CPUs".to_string()
1122 } else if cpus.len() == 1 {
1123 format!("cpu {}", cpus[0])
1124 } else if cpus.windows(2).all(|w| w[1] == w[0] + 1) {
1125 format!("cpus {}-{}", cpus[0], cpus.last().unwrap())
1132 } else {
1133 format!("cpus {:?}", cpus)
1134 };
1135 write!(f, "\n {cpu_list}: ")?;
1136 std::fmt::Display::fmt(val, f)?;
1137 }
1138 if !unmapped.is_empty() {
1139 write!(f, "\n cpus {unmapped:?}: <unmapped>")?;
1140 }
1141 Ok(())
1142 }
1143}
1144
1145impl std::fmt::Display for FailureDumpPercpuHashEntry {
1146 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1152 f.write_str("entry: key=")?;
1153 match &self.key {
1154 Some(k) => write_value_at_depth(f, k, 1)?,
1155 None => write!(f, "{} (raw)", self.key_hex)?,
1156 }
1157 for (cpu, slot) in self.per_cpu.iter().enumerate() {
1164 f.write_str("\n ")?;
1165 match slot {
1166 Some(v) => {
1167 write!(f, "cpu {cpu}: ")?;
1168 write_value_at_depth(f, v, 1)?;
1169 }
1170 None => write!(f, "cpu {cpu}: <unmapped>")?,
1171 }
1172 }
1173 Ok(())
1174 }
1175}
1176
1177#[cfg(test)]
1178mod tests {
1179 use super::*;
1180
1181 const DISPLAY_THREAD_PROBE_ENV: &str = "KTSTR_FAILURE_DUMP_DISPLAY_THREAD_PROBE";
1182 const DISPLAY_THREAD_PROBE_MARKER: &str = "failure-dump-display-thread-probe-ok";
1183
1184 #[test]
1192 fn report_display_does_not_create_retained_workers() {
1193 if std::env::var_os(DISPLAY_THREAD_PROBE_ENV).is_some() {
1194 return;
1195 }
1196 let output = std::process::Command::new(std::env::current_exe().unwrap())
1197 .env(DISPLAY_THREAD_PROBE_ENV, "1")
1198 .arg("--exact")
1199 .arg(
1200 "monitor::dump::display::tests::\
1201 report_display_does_not_create_retained_workers_child",
1202 )
1203 .arg("--nocapture")
1204 .arg("--test-threads=1")
1205 .output()
1206 .expect("spawn isolated failure-dump display probe");
1207 let transcript = format!(
1208 "{}{}",
1209 String::from_utf8_lossy(&output.stdout),
1210 String::from_utf8_lossy(&output.stderr)
1211 );
1212 assert!(
1213 output.status.success(),
1214 "isolated failure-dump display probe failed:\n{transcript}"
1215 );
1216 assert!(
1217 transcript.contains(DISPLAY_THREAD_PROBE_MARKER),
1218 "isolated helper did not run (wrong libtest exact name?):\n{transcript}"
1219 );
1220 }
1221
1222 #[test]
1223 fn report_display_does_not_create_retained_workers_child() {
1224 if std::env::var_os(DISPLAY_THREAD_PROBE_ENV).is_none() {
1225 return;
1226 }
1227 let task_count = || {
1228 std::fs::read_dir("/proc/self/task")
1229 .expect("read /proc/self/task")
1230 .count()
1231 };
1232 let report = FailureDumpReport {
1233 maps: (0..8)
1234 .map(|idx| FailureDumpMap {
1235 name: format!("probe_map_{idx}"),
1236 map_type: 2,
1237 value_size: 8,
1238 max_entries: 1,
1239 ..Default::default()
1240 })
1241 .collect(),
1242 ..Default::default()
1243 };
1244 let before = task_count();
1245 let rendered = format!("{report}");
1246 let after = task_count();
1247 assert_eq!(
1248 rendered.matches("\n\n").count(),
1249 7,
1250 "all maps must retain their prior ordered separators"
1251 );
1252 assert_eq!(
1253 after, before,
1254 "failure-dump formatting retained worker threads: before={before}, after={after}"
1255 );
1256 eprintln!("{DISPLAY_THREAD_PROBE_MARKER}");
1257 }
1258
1259 #[test]
1267 fn report_display_event_counter_timeline_separated_from_vcpu_perf() {
1268 let report = FailureDumpReport {
1269 event_counter_timeline: vec![EventCounterSample {
1270 elapsed_ms: 1,
1271 select_cpu_fallback: 5,
1272 ..Default::default()
1273 }],
1274 vcpu_perf_at_freeze: vec![None],
1275 ..Default::default()
1276 };
1277 let out = format!("{report}");
1278 assert!(
1279 out.starts_with("event_counter_timeline: 1 samples (1–1ms)"),
1280 "timeline header missing: {out}"
1281 );
1282 assert!(
1283 out.contains("\n\nvcpu_perf_at_freeze:\n vcpu 0: <unavailable>"),
1284 "missing blank-line separator before vcpu_perf section: {out}"
1285 );
1286 }
1287}