gdb-chat

Automate interactive GDB debugging sessions for the Breenix kernel.

7|Updated Nov 21, 2015
One-click install
npx skills add https://github.com/ryanbreen/breenix --skill gdb-chat
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: gdb-chat
Source: https://github.com/ryanbreen/breenix/tree/main/breenix-gdb-chat
Command: npx skills add https://github.com/ryanbreen/breenix --skill gdb-chat

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill enables interactive, stateful GDB debugging of the Breenix kernel, preserving session state so you can iteratively inspect, modify, and reason about kernel behavior without restarting your debugging environment.

Core Features & Use Cases

  • Persistent sessions: Create and reuse a long-running GDB session connected to QEMU.
  • Command-driven insights: Send GDB commands and receive structured JSON outputs suitable for automation.
  • Serial visibility: Access kernel serial output alongside debugging data to correlate boot messages with state.
  • Use Case: When tracing a crash, start a session, set breakpoints, inspect registers, view backtraces, and collect memory snapshots without reattaching.

Quick Start

Start a session with breenix-gdb-chat/scripts/start_session.py, then query state with breenix-gdb-chat/scripts/gdb_cmd.py and stop with breenix-gdb-chat/scripts/stop_session.py --session SESSION_ID.

Frequently Asked Questions about gdb-chat

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I debug a kernel crash with GDB and QEMU?

GDB kernel debugging with QEMU requires setting breakpoints, inspecting registers, and viewing backtraces while the kernel runs. This Skill automates persistent GDB-QEMU sessions for the Breenix kernel, letting you trace crashes, page faults, and syscall behavior without restarting your debugging environment.

Can I run interactive GDB sessions that persist across multiple commands?

Yes. This Skill maintains stateful GDB sessions connected to QEMU, so you can send commands iteratively, inspect kernel state, set breakpoints, and examine memory without reconnecting or losing context between queries.

How do I correlate kernel serial output with GDB debugging data?

Serial output visibility is built in. This Skill surfaces kernel log messages alongside GDB state inspections, so you can match boot messages, interrupt handlers, and kernel events with register and memory snapshots in a single debugging workflow.

What's the fastest way to set up kernel debugging for Breenix?

Start a persistent session with start_session.py, then query GDB state using gdb_cmd.py and receive structured JSON output. This eliminates manual GDB attachment and session lifecycle management, accelerating crash analysis and register inspection.

Can I inspect memory and registers during kernel execution without stopping the debugger?

Yes. Send GDB commands through gdb_cmd.py to inspect registers, examine memory, view backtraces, and collect snapshots while the kernel runs. Results return as structured JSON suitable for automation and analysis.

Do I need special setup to connect GDB to a remote QEMU target?

This Skill handles remote target connection and symbol loading automatically within persistent GDB sessions. You interact through command-driven queries, eliminating manual GDB protocol configuration for Breenix kernel debugging.