debug.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <sys/kassert.h>
#include <sys/kdebug.h>
#include "../dev/console.h"

Include dependency graph for debug.c:

Go to the source code of this file.

Macros
#define	DEBUG_MAX_LINE   128
#define	DEBUG_MAX_ARGS   16
#define	PHELP(_cmd, _msg)   kprintf("%-16s %s\n", _cmd, _msg)

Functions
void	Debug_PrintHex (const char *data, size_t length, off_t off, size_t limit)
uint64_t	Debug_GetValue (uintptr_t addr, int size, bool isSigned)
void	Debug_PrintSymbol (uintptr_t off, int strategy)
uint64_t	Debug_StrToInt (const char *s)
uint64_t	Debug_SymbolToInt (const char *s)
static void	Debug_Help (int argc, const char *argv[])
	REGISTER_DBGCMD (help, "Display the list of commands", Debug_Help)
static void	Debug_Echo (int argc, const char *argv[])
	REGISTER_DBGCMD (echo, "Echo arguments", Debug_Echo)
static void	Debug_Dump (int argc, const char *argv[])
	REGISTER_DBGCMD (dump, "Dump a region of memory", Debug_Dump)
static void	Debug_Disasm (int argc, const char *argv[])
	REGISTER_DBGCMD (disasm, "Disassemble", Debug_Disasm)
void	Debug_Prompt ()

Variables
DebugCommand	__kdbgcmd_start []
DebugCommand	__kdbgcmd_end []

Macro Definition Documentation

DEBUG_MAX_ARGS

#define DEBUG_MAX_ARGS   16

Definition at line 27 of file debug.c.

DEBUG_MAX_LINE

#define DEBUG_MAX_LINE   128

Definition at line 26 of file debug.c.

PHELP

#define PHELP	(		_cmd,
			_msg
	)		kprintf("%-16s %s\n", _cmd, _msg)

Definition at line 166 of file debug.c.

Function Documentation

Debug_Disasm()

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

static

Definition at line 224 of file debug.c.

{
    uintptr_t off;
    int len = 1;
 
    if (argc != 2 && argc != 3) {
        kprintf("Disasm requires 2 or 3 arguments\n");
        return;
    }
 
    off = Debug_SymbolToInt(argv[1]);
    if (argc == 3)
        len = Debug_SymbolToInt(argv[2]);
    kprintf("Disassembly 0x%llx:\n", off);
    
    for (; len > 0; len--)
    {
        off = db_disasm(off, false);
    }
}

Here is the call graph for this function:

Debug_Dump()

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

static

Definition at line 205 of file debug.c.

{
    uint64_t off, len;
 
    if (argc != 3)
    {
        kprintf("Dump requires 3 arguments\n");
        return;
    }
 
    off = Debug_SymbolToInt(argv[1]);
    len = Debug_SymbolToInt(argv[2]);
    kprintf("Dump 0x%llx 0x%llx\n", off, len);
    Debug_PrintHex((const char *)off, len, 0, len);
}

Here is the call graph for this function:

Debug_Echo()

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

static

Definition at line 191 of file debug.c.

{
    int i;
 
    for (i = 1; i < argc; i++)
    {
        kprintf("%s ", argv[i]);
    }
    kprintf("\n");
}

Here is the call graph for this function:

Debug_GetValue()

uint64_t Debug_GetValue	(	uintptr_t	addr,
		int	size,
		bool	isSigned
	)

Definition at line 81 of file debug.c.

{
    switch (size)
    {
        case 1: {
            uint8_t *val = (uint8_t *)addr;
            if (isSigned && ((*val & 0x80) == 0x80)) {
                return (uint64_t)*val | 0xFFFFFFFFFFFFFF00ULL; 
            }
            return *val;
        }
        case 2: {
            uint16_t *val = (uint16_t *)addr;
            if (isSigned && ((*val & 0x8000) == 0x8000)) {
                return (uint64_t)*val | 0xFFFFFFFFFFFF0000ULL; 
            }
            return *val;
        }
        case 4: {
            uint32_t *val = (uint32_t *)addr;
            if (isSigned && ((*val & 0x80000000) == 0x80000000)) {
                return (uint64_t)*val | 0xFFFFFFFF00000000ULL; 
            }
            return *val;
        }
        case 8: {
            uint64_t *val = (uint64_t *)addr;
            return *val;
        }
        default: {
            kprintf("Debug_GetValue: Unknown size parameter '%d'\n", size);
            return (uint64_t)-1;
        }
    }
}

Here is the call graph for this function:

Debug_Help()

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

static

Definition at line 172 of file debug.c.

{
    int i;
    uintptr_t commands = (uintptr_t)&__kdbgcmd_end - (uintptr_t)&__kdbgcmd_start;
    commands /= sizeof(DebugCommand);
    DebugCommand *cmds = (DebugCommand *)&__kdbgcmd_start;
 
    kprintf("Commands:\n");
    for (i = 0; i < commands; i++)
    {
        kprintf("%-16s %s\n", cmds[i].name, cmds[i].description);
    }
 
    PHELP("continue", "Continue execution");
}

Here is the call graph for this function:

Debug_PrintHex()

void Debug_PrintHex	(	const char *	data,
		size_t	length,
		off_t	off,
		size_t	limit
	)

Definition at line 30 of file debug.c.

{
    const size_t row_size = 16;
    bool stop = false;
 
    size_t row;
    for (row = 0; !stop; row++) {
        size_t ix = row * row_size;
        if (ix >= limit || ix >= length)
            return;
 
        kprintf("%08lx  ", (uintptr_t)data+ix);
        size_t col;
        for (col = 0; col < row_size; col++) { 
            size_t ixc = ix + col;
            if ((limit != 0 && ixc >= limit) || ixc >= length) {
                stop = true;
                for (; col < row_size; col++) {
                    kprintf("   ");
                }
                break;
            }
            ixc += off;
 
            kprintf("%02X ", (unsigned char)data[ixc]);
        }
        kprintf("  |");
 
        for (col = 0; col < row_size; col++) { 
            size_t ixc = ix + col;
            if ((limit != 0 && ixc >= limit) || ixc >= length) {
                stop = true;
                for (; col < row_size; col++) {
                    kprintf(" ");
                }
                break;
            }
            ixc += off;
 
            unsigned char c = (unsigned char)data[ixc];
            if (c >= 0x20 && c < 0x7F)
                kprintf("%c", c);
            else
                kprintf(".");
        }
        kprintf("|");
        kprintf("\n");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Debug_PrintSymbol()

void Debug_PrintSymbol	(	uintptr_t	off,
		int	strategy
	)

Definition at line 118 of file debug.c.

{
    kprintf("0x%llx", off);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Debug_Prompt()

void Debug_Prompt

(

)

Definition at line 248 of file debug.c.

{
    int argc;
    char *argv[DEBUG_MAX_ARGS];
    char *nextArg, *last;
    char buf[DEBUG_MAX_LINE];
 
    kprintf("Entered Debugger!\n");
 
    /*
     * DebugCommand must be 128 bytes for the Section array to align properly
     */
    ASSERT(sizeof(DebugCommand) == 128);
 
    while (1) {
        kprintf("kdbg> ");
 
        // read input
        Console_Gets((char *)&buf, DEBUG_MAX_LINE);
 
        // parse input
        nextArg = strtok_r(buf, " \t\r\n", &last);
        for (argc = 0; argc < DEBUG_MAX_ARGS; argc++) {
            if (nextArg == NULL)
                break;
 
            argv[argc] = nextArg;
            nextArg = strtok_r(NULL, " \t\r\n", &last);
        }
 
        if (strcmp(argv[0], "continue") == 0) {
            return; // Continue
        } else {
            // execute command
            int i;
            uintptr_t commands = (uintptr_t)&__kdbgcmd_end - (uintptr_t)&__kdbgcmd_start;
            commands /= sizeof(DebugCommand);
            DebugCommand *cmds = (DebugCommand *)&__kdbgcmd_start;
            bool found = false;
 
            for (i = 0; i < commands; i++)
            {
                if (strcmp(argv[0], cmds[i].name) == 0)
                {
                    cmds[i].func(argc, (const char **)argv);
                    found = true;
                }
            }
 
            if (strcmp(argv[0], "") == 0)
                continue;
 
            if (!found)
                kprintf("Unknown command '%s'\n", argv[0]);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Debug_StrToInt()

uint64_t Debug_StrToInt

(

const char *

s

)

Definition at line 124 of file debug.c.

{
    int i = 0;
    int base = 10;
    uint64_t val = 0;
 
    if (s[0] == '0' && s[1] == 'x')
    {
        base = 16;
        i = 2;
    }
 
    while (s[i] != '\0') {
        if (s[i] >= '0' && s[i] <= '9') {
            val = val * base + (uint64_t)(s[i] - '0');
        } else if (s[i] >= 'a' && s[i] <= 'f') {
            if (base != 16)
                kprintf("Not base 16!\n");
            val = val * base + (uint64_t)(s[i] - 'a' + 10);
        } else if (s[i] >= 'A' && s[i] <= 'F') {
            if (base != 16)
                kprintf("Not base 16!\n");
            val = val * base + (uint64_t)(s[i] - 'A' + 10);
        } else {
            kprintf("Not a number!\n");
        }
        i++;
    }
 
    return val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Debug_SymbolToInt()

uint64_t Debug_SymbolToInt

(

const char *

s

)

Definition at line 157 of file debug.c.

{
    if (*s >= '0' || *s <= '9')
        return Debug_StrToInt(s);
 
    kprintf("Unknown symbol '%s'\n");
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

REGISTER_DBGCMD() [1/4]

REGISTER_DBGCMD	(	disasm	,
		"Disassemble"	,
		Debug_Disasm
	)

REGISTER_DBGCMD() [2/4]

REGISTER_DBGCMD	(	dump	,
		"Dump a region of memory"	,
		Debug_Dump
	)

REGISTER_DBGCMD() [3/4]

REGISTER_DBGCMD	(	echo	,
		"Echo arguments"	,
		Debug_Echo
	)

REGISTER_DBGCMD() [4/4]

REGISTER_DBGCMD	(	help	,
		"Display the list of commands"	,
		Debug_Help
	)

Variable Documentation

__kdbgcmd_end

DebugCommand __kdbgcmd_end[]

extern

__kdbgcmd_start

DebugCommand __kdbgcmd_start[]

extern