debug.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <sys/kassert.h>
#include <sys/kconfig.h>
#include <sys/kdebug.h>
#include <sys/mp.h>
#include <machine/amd64.h>
#include <machine/amd64op.h>
#include <machine/atomic.h>
#include <machine/trap.h>
#include <machine/lapic.h>
#include <machine/mp.h>

Include dependency graph for debug.c:

Go to the source code of this file.

Functions
void	Debug_HaltCPUs ()
void	Debug_ResumeCPUs ()
void	Debug_HaltIPI (TrapFrame *tf)
void	Debug_Breakpoint (TrapFrame *tf)
static void	Debug_Registers (int argc, const char *argv[])
	REGISTER_DBGCMD (registers, "Show CPU registers", Debug_Registers)
static void	Debug_Backtrace (int argc, const char *argv[])
	REGISTER_DBGCMD (backtrace, "Print backtrace", Debug_Backtrace)
static void	Debug_SetBreakpoint (int argc, const char *argv[])
	REGISTER_DBGCMD (bkpt, "Set breakpoint", Debug_SetBreakpoint)
static void	Debug_ClearBreakpoint (int argc, const char *argv[])
	REGISTER_DBGCMD (clrbkpt, "Clear breakpoint", Debug_ClearBreakpoint)
static void	Debug_ListBreakpoints (int argc, const char *argv[])
	REGISTER_DBGCMD (bkpts, "List breakpoint", Debug_ListBreakpoints)
static void	Debug_Reboot (int argc, const char *argv[])
	REGISTER_DBGCMD (reboot, "Reboot computer", Debug_Reboot)

Variables
TrapFrame *	frames [MAX_CPUS]
static volatile uint64_t	debugLock = 0
static volatile uint64_t	debugCmd = 0
static volatile uint64_t	debugHalted = 0

Function Documentation

Debug_Backtrace()

static void Debug_Backtrace ( int  argc, const char *  argv[]  )

static

Definition at line 130 of file debug.c.

{
    TrapFrame *tf = frames[CPU()];
    uint64_t *ptr;
    uint64_t rip;
    uint64_t rbp;
 
    if (argc == 2) {
        int cpuNo = Debug_StrToInt(argv[1]);
        if (cpuNo >= MAX_CPUS) {
            kprintf("Invalid CPU number\n");
            return;
        }
        tf = frames[cpuNo];
    }
 
    rip = tf->rip;
    rbp = tf->rbp;
 
    kprintf("%-16s %-16s\n", "IP Pointer", "Base Pointer");
    while (3) {
        kprintf("%016llx %016llx\n", rip, rbp);
        ptr = (uint64_t *)rbp;
        if (rbp == 0ULL || rip == 0ULL) {
            break;
        }
        rbp = ptr[0];
        rip = ptr[1];
    }
}

Here is the call graph for this function:

Debug_Breakpoint()

void Debug_Breakpoint

(

TrapFrame *

tf

)

Definition at line 67 of file debug.c.

{
    frames[CPU()] = tf;
 
    // Should probably force all cores into the debugger
    while(atomic_swap_uint64(&debugLock, 1) == 1) {
        // Wait to acquire debugger lock
    }
 
    // Stop all processors
    Debug_HaltCPUs();
 
    // Enter prompt
    Debug_Prompt();
 
    // Resume all processors
    Debug_ResumeCPUs();
    atomic_set_uint64(&debugLock, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Debug_ClearBreakpoint()

static void Debug_ClearBreakpoint ( int  argc, const char *  argv[]  )

static

Definition at line 195 of file debug.c.

{
    if (argc != 2) {
        kprintf("clrbkpt [0-3]");
        return;
    }
 
    uint32_t flags = read_dr7();
    switch (argv[1][0]) {
        case '0':
            flags &= ~DR7_DR0G;
            break;
        case '1':
            flags &= ~DR7_DR1G;
            break;
        case '2':
            flags &= ~DR7_DR2G;
            break;
        case '3':
            flags &= ~DR7_DR3G;
            break;
        default:
            kprintf("Specify a breakpoint between 0-3\n");
    }
 
    write_dr7(flags);
}

Here is the call graph for this function:

Debug_HaltCPUs()

void Debug_HaltCPUs

(

)

Definition at line 24 of file debug.c.

{
    debugCmd = 0;
 
    if (MP_GetCPUs() == 1)
        return;
 
    LAPIC_BroadcastNMI(T_DEBUGIPI);
 
    // Wait for processors to enter
    while (debugHalted < (MP_GetCPUs() - 1)) {
        pause();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Debug_HaltIPI()

void Debug_HaltIPI

(

TrapFrame *

tf

)

Definition at line 51 of file debug.c.

{
    MP_SetState(CPUSTATE_HALTED);
    __sync_fetch_and_add(&debugHalted, 1);
 
    frames[CPU()] = tf;
 
    while (debugCmd == 0) {
        pause();
    }
 
    __sync_fetch_and_sub(&debugHalted, 1);
    MP_SetState(CPUSTATE_BOOTED);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Debug_ListBreakpoints()

static void Debug_ListBreakpoints ( int  argc, const char *  argv[]  )

static

Definition at line 226 of file debug.c.

{
    uint32_t flags = read_dr7();
 
    if (flags & DR7_DR0G) {
        kprintf("DR0: 0x%lx\n", read_dr0());
    }
    if (flags & DR7_DR1G) {
        kprintf("DR1: 0x%lx\n", read_dr1());
    }
    if (flags & DR7_DR2G) {
        kprintf("DR2: 0x%lx\n", read_dr2());
    }
    if (flags & DR7_DR3G) {
        kprintf("DR3: 0x%lx\n", read_dr3());
    }
}

Here is the call graph for this function:

Debug_Reboot()

static void Debug_Reboot ( int  argc, const char *  argv[]  )

static

Definition at line 247 of file debug.c.

{
    /*
     * Triple fault the core by loading a non-canonical address into CR3.  We 
     * should use ACPI, or even the keyboard controller if it exists.
     */
    write_cr3(0x8000000000000000ULL);
}

Here is the call graph for this function:

Debug_Registers()

static void Debug_Registers ( int  argc, const char *  argv[]  )

static

Definition at line 88 of file debug.c.

{
    TrapFrame *tf = frames[CPU()];
 
    if (argc == 2) {
        int cpuNo = Debug_StrToInt(argv[1]);
        if (cpuNo >= MAX_CPUS) {
            kprintf("Invalid CPU number\n");
            return;
        }
        tf = frames[cpuNo];
    }
 
    kprintf("Interrupt %d Error Code: %016llx\n",
            tf->vector, tf->errcode);
    kprintf("cr0: %016llx cr2: %016llx\n",
            read_cr0(), read_cr2());
    kprintf("cr3: %016llx cr4: %016llx\n",
            read_cr3(), read_cr4());
    kprintf("dr0: %016llx dr1: %016llx dr2: %016llx\n",
            read_dr0(), read_dr1(), read_dr2());
    kprintf("dr3: %016llx dr6: %016llx dr7: %016llx\n",
            read_dr3(), read_dr6(), read_dr7());
    kprintf("rip: %04x:%016llx rsp: %04x:%016llx\n",
            tf->cs, tf->rip, tf->ss, tf->rsp);
    kprintf("rflags: %016llx ds: %04x es: %04x fs: %04x gs: %04x\n",
            tf->rflags, read_ds(), read_es(), read_fs(), read_gs());
    kprintf("rax: %016llx rbx: %016llx rcx: %016llx\n",
            tf->rax, tf->rbx, tf->rcx);
    kprintf("rdx: %016llx rsi: %016llx rdi: %016llx\n",
            tf->rdx, tf->rsi, tf->rdi);
    kprintf("rbp: %016llx r8:  %016llx r9:  %016llx\n",
            tf->rbp, tf->r8, tf->r9);
    kprintf("r10: %016llx r11: %016llx r12: %016llx\n",
            tf->r10, tf->r11, tf->r12);
    kprintf("r13: %016llx r14: %016llx r15: %016llx\n",
            tf->r13, tf->r14, tf->r15);
}

Here is the call graph for this function:

Debug_ResumeCPUs()

void Debug_ResumeCPUs

(

)

Definition at line 40 of file debug.c.

{
    debugCmd = 1;
 
    // Wait for processors to resume
    while (debugHalted > 0) {
        pause();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Debug_SetBreakpoint()

static void Debug_SetBreakpoint ( int  argc, const char *  argv[]  )

static

Definition at line 164 of file debug.c.

{
    if (argc != 2) {
        kprintf("bkpt [ADDR]");
        return;
    }
 
    uint64_t addr = Debug_StrToInt(argv[1]);
 
    uint32_t flags = read_dr7();
 
    if (!(flags & DR7_DR0G)) {
        write_dr0(addr);
        write_dr7(flags | DR7_DR0G);
    } else if (!(flags & DR7_DR1G)) {
        write_dr1(addr);
        write_dr7(flags | DR7_DR1G);
    } else if (!(flags & DR7_DR2G)) {
        write_dr2(addr);
        write_dr7(flags | DR7_DR2G);
    } else if (!(flags & DR7_DR3G)) {
        write_dr3(addr);
        write_dr7(flags | DR7_DR3G);
    } else {
        kprintf("No more breakpoints left!\n");
    }
}

Here is the call graph for this function:

REGISTER_DBGCMD() [1/6]

REGISTER_DBGCMD	(	backtrace	,
		"Print backtrace"	,
		Debug_Backtrace
	)

REGISTER_DBGCMD() [2/6]

REGISTER_DBGCMD	(	bkpt	,
		"Set breakpoint"	,
		Debug_SetBreakpoint
	)

REGISTER_DBGCMD() [3/6]

REGISTER_DBGCMD	(	bkpts	,
		"List breakpoint"	,
		Debug_ListBreakpoints
	)

REGISTER_DBGCMD() [4/6]

REGISTER_DBGCMD	(	clrbkpt	,
		"Clear breakpoint"	,
		Debug_ClearBreakpoint
	)

REGISTER_DBGCMD() [5/6]

REGISTER_DBGCMD	(	reboot	,
		"Reboot computer"	,
		Debug_Reboot
	)

REGISTER_DBGCMD() [6/6]

REGISTER_DBGCMD	(	registers	,
		"Show CPU registers"	,
		Debug_Registers
	)

Variable Documentation

debugCmd

volatile uint64_t debugCmd = 0

static

Definition at line 20 of file debug.c.

debugHalted

volatile uint64_t debugHalted = 0

static

Definition at line 21 of file debug.c.

debugLock

volatile uint64_t debugLock = 0

static

Definition at line 19 of file debug.c.

frames

TrapFrame* frames[MAX_CPUS]

Definition at line 17 of file debug.c.