Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3004 → Rev 3005

/branches/tracing/uspace/app/debug/include/arch.h
40,16 → 40,15
 
#include "arch/types.h"
#include "../dthread.h"
#include "../breakpoint.h"
 
void arch_breakpoint_add(uintptr_t addr);
int arch_breakpoint_set(breakpoint_t *b);
int arch_breakpoint_remove(breakpoint_t *b);
void arch_event_breakpoint(thash_t thread_hash);
void arch_event_trap(dthread_t *dt);
void arch_dump_regs(thash_t thash);
void arch_set_singlestep(dthread_t *dt, int enable);
void arch_breakpoint_remove(int id);
void arch_breakpoint_list(void);
 
 
#endif
 
/** @}
/branches/tracing/uspace/app/debug/cmd.c
42,6 → 42,7
#include "main.h"
#include "cons.h"
#include "dthread.h"
#include "breakpoint.h"
#include "include/arch.h"
#include "cmd.h"
 
86,7 → 87,8
addr = strtoul(argv[1], NULL, 0);
 
cons_printf("You requested a breakpoint at 0x%x\n", addr);
arch_breakpoint_add(addr);
// arch_breakpoint_add(addr);
breakpoint_add(addr);
}
 
static void cmd_ct(int argc, char *argv[])
123,7 → 125,8
 
printf("remove breakpoint %d\n", bid);
 
arch_breakpoint_remove(bid);
// arch_breakpoint_remove(bid);
breakpoint_remove(bid);
}
 
 
166,7 → 169,8
{
(void)argc; (void)argv;
 
arch_breakpoint_list();
//arch_breakpoint_list();
breakpoint_list();
}
 
 
/branches/tracing/uspace/app/debug/main.c
46,6 → 46,7
#include "cmd.h"
#include "cons.h"
#include "dthread.h"
#include "breakpoint.h"
#include "include/arch.h"
#include "fib_synch.h"
#include "main.h"
67,9 → 68,6
 
volatile int paused;
 
breakpoint_t brk_list[MAX_BRKPTS];
int lifted_brkpt;
 
fcv_t go_cv;
 
static void command_split(char *cmd_str)
156,9 → 154,13
/*
* Called by a fibril (from arch code) when a breakpoint is hit.
*/
void breakpoint_hit(void)
void breakpoint_hit(breakpoint_t *b)
{
cons_printf("breakpoint hit\n");
dthread_t *dt;
 
dt = dthread_get();
cons_printf("Thread %d hit breakpoint %d at 0x%lx\n",
dt->id, b->id, b->addr);
thread_stop();
}
 
387,6 → 389,7
paused = 0;
list_initialize(&dthreads);
breakpoint_init();
cwt = NULL;
 
fcv_init(&go_cv);
/branches/tracing/uspace/app/debug/main.h
40,20 → 40,12
 
#include "include/arch/types.h"
#include "fib_synch.h"
#include "breakpoint.h"
 
typedef struct {
int set;
unsigned addr;
breakpoint_arch_t arch;
} breakpoint_t;
 
#define MAX_BRKPTS 64
extern breakpoint_t brk_list[MAX_BRKPTS];
 
extern int app_phone;
extern fcv_t go_cv;
 
void breakpoint_hit(void);
void breakpoint_hit(breakpoint_t *b);
void singlestep_hit(void);
 
 
/branches/tracing/uspace/app/debug/Makefile
47,6 → 47,7
fib_synch.c \
cons.c \
dthread.c \
breakpoint.c \
main.c
 
GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))
/branches/tracing/uspace/app/debug/arch/mips32/include/types.h
84,6 → 84,11
uint32_t k1; /* We use it as thread-local pointer */
} istate_t;
 
static inline uint32_t istate_get_pc(istate_t *istate)
{
return istate->epc;
}
 
#endif
 
/** @}
/branches/tracing/uspace/app/debug/arch/mips32/src/mips32.c
40,45 → 40,57
 
#include "../../../cons.h"
#include "../../../main.h"
#include "../../../breakpoint.h"
#include "../../../include/arch.h"
 
#define OPCODE_BREAK 0x0000000d
 
void arch_breakpoint_add(uintptr_t addr)
static unsigned buffer[1024];
 
int arch_breakpoint_set(breakpoint_t *b)
{
uint32_t brkp;
int rc;
breakpoint_t *brk;
int i;
 
brk = NULL;
for (i = 0; i < MAX_BRKPTS; i++)
if (brk_list[i].set == 0) {
brk = brk_list+i;
break;
}
rc = udebug_mem_read(app_phone, &b->arch.back, b->addr,
sizeof(b->arch.back));
if (rc < 0) return rc;
 
if (!brk) {
cons_printf("too many breakpoints\n");
return;
}
 
rc = udebug_mem_read(app_phone, &brk->arch.back, addr, sizeof(&brk->arch.back));
cons_printf("udebug_mem_read() -> %d\n", rc);
brkp = OPCODE_BREAK;
rc = udebug_mem_write(app_phone, &brkp, addr, sizeof(brkp));
// for (i=0; i<256; i++) rc = udebug_mem_write(app_phone, &brkp, addr+4*i, sizeof(brkp));
rc = udebug_mem_write(app_phone, &brkp, b->addr, sizeof(brkp));
cons_printf("udebug_mem_write() -> %d\n", rc);
if (rc < 0) return rc;
 
brk->addr = addr;
brk->set = 1;
return 0;
}
 
static unsigned buffer[1024];
static breakpoint_t *lifted_brkpt;
int arch_breakpoint_remove(breakpoint_t *b)
{
int rc;
 
if (b->active) {
rc = udebug_mem_write(app_phone, &b->arch.back, b->addr + 4, 1);
if (rc < 0) {
cons_printf("error writing memory\n");
return rc;
}
active_bkpt = NULL;
} else {
rc = udebug_mem_write(app_phone, &b->arch.back, b->addr, 1);
if (rc < 0) {
cons_printf("error writing memory\n");
return rc;
}
}
 
return 0;
 
}
 
void arch_event_breakpoint(thash_t thread_hash)
{
breakpoint_t *b;
int rc;
uint32_t epc;
int brk_addr;
92,37 → 104,28
cons_printf("EPC was 0x%08x\n", epc);
brk_addr = epc;
 
int bi;
for (bi = 0; bi < MAX_BRKPTS; bi++) {
if (brk_list[bi].set && brk_list[bi].addr == brk_addr)
break;
}
if (bi < MAX_BRKPTS) {
cons_printf("breakpoint %d hit\n", bi);
breakpoint_hit();
b = breakpoint_find_by_addr(brk_addr);
if (b != NULL) {
rc = udebug_mem_write(app_phone, &b->arch.back, brk_addr, 4);
cons_printf("udebug_mem_write(phone, 0x%x, 0x%02x, 1) -> %d\n", brk_addr, b->arch.back, rc);
rc = udebug_mem_read(app_phone, &b->arch.back, brk_addr + 4, 4);
rc = udebug_mem_write(app_phone, &brkp, brk_addr + 4, 4);
active_bkpt = b;
 
rc = udebug_mem_write(app_phone, &brk_list[bi].arch.back, brk_addr, 4);
cons_printf("udebug_mem_write(phone, 0x%x, 0x%02x, 1) -> %d\n", brk_addr, brk_list[bi].arch.back, rc);
rc = udebug_mem_read(app_phone, &brk_list[bi].arch.back, brk_addr+4, 4);
rc = udebug_mem_write(app_phone, &brkp, brk_addr+4, 4);
lifted_brkpt = &brk_list[bi];
return;
breakpoint_hit(b);
}
 
for (bi = 0; bi < MAX_BRKPTS; bi++) {
if (brk_list[bi].set && brk_list[bi].addr + 4 == brk_addr)
break;
}
if (bi < MAX_BRKPTS) {
cons_printf("restoring breakpoint %d\n", bi);
rc = udebug_mem_write(app_phone, &brk_list[bi].arch.back, brk_addr, 4);
rc = udebug_mem_read(app_phone, &brk_list[bi].arch.back, brk_addr-4, 4);
rc = udebug_mem_write(app_phone, &brkp, brk_addr-4, 4);
lifted_brkpt = NULL;
b = breakpoint_find_by_addr(brk_addr - 4);
if (b != NULL && b->active) {
cons_printf("restoring breakpoint %d\n", b->id);
rc = udebug_mem_write(app_phone, &b->arch.back, brk_addr, 4);
rc = udebug_mem_read(app_phone, &b->arch.back, brk_addr - 4, 4);
rc = udebug_mem_write(app_phone, &brkp, brk_addr - 4, 4);
active_bkpt = NULL;
return;
}
 
cons_printf("unrecognized breakpoint at 0x%x\n", brk_addr);
cons_printf("Unrecognized breakpoint at 0x%lx\n", brk_addr);
}
 
void arch_event_trap(dthread_t *dt)
139,13 → 142,5
{
}
 
void arch_breakpoint_remove(int id)
{
}
 
void arch_breakpoint_list(void)
{
}
 
/** @}
*/
/branches/tracing/uspace/app/debug/arch/ia32/src/ia32.c
45,75 → 45,44
 
#define OPCODE_INT3 0xCC
 
static breakpoint_t *lifted_brkpt;
 
void arch_breakpoint_add(uintptr_t addr)
int arch_breakpoint_set(breakpoint_t *b)
{
char brkp[1];
int rc;
breakpoint_t *brk;
int i;
 
brk = NULL;
for (i = 1; i < MAX_BRKPTS; i++)
if (brk_list[i].set == 0) { brk = brk_list+i; break; }
rc = udebug_mem_read(app_phone, &b->arch.back, b->addr, 1);
cons_printf("udebug_mem_read() -> %d\n", rc);
if (rc < 0) return rc;
 
if (!brk) {
cons_printf("too many breakpoints\n");
return;
}
brkp[0] = OPCODE_INT3;
rc = udebug_mem_write(app_phone, brkp, b->addr, 1);
if (rc < 0) return rc;
 
rc = udebug_mem_read(app_phone, &brk->arch.back, addr, 1);
cons_printf("udebug_mem_read() -> %d\n", rc);
brkp[0] = OPCODE_INT3;
rc = udebug_mem_write(app_phone, brkp, addr, 1);
cons_printf("udebug_mem_write() -> %d\n", rc);
 
brk->addr = addr;
brk->set = 1;
 
cons_printf("Added breakpoint %d\n", i);
return 0;
}
 
void arch_breakpoint_remove(int id)
int arch_breakpoint_remove(breakpoint_t *b)
{
int rc;
 
if (id < 1 || id >= MAX_BRKPTS || brk_list[id].set == 0) {
cons_printf("No such breakpoint\n");
return;
}
 
if (lifted_brkpt == &brk_list[id]) {
lifted_brkpt = NULL;
if (b->active) {
active_bkpt = NULL;
} else {
rc = udebug_mem_write(app_phone, &brk_list[id].arch.back, brk_list[id].addr, 1);
if (rc < 0) { printf("error writing mem\n"); return; }
rc = udebug_mem_write(app_phone, &b->arch.back, b->addr, 1);
if (rc < 0) {
cons_printf("error writing mem\n");
return rc;
}
}
 
brk_list[id].set = 0;
 
cons_printf("Breakpoint removed\n");
return 0;
}
 
void arch_breakpoint_list(void)
{
int i, cnt;
 
cnt = 0;
for (i = 0; i < MAX_BRKPTS; ++i) {
if (brk_list[i].set != 0) {
cons_printf("Breakpoint %d at 0x%lx\n", i,
brk_list[i].addr);
++cnt;
}
}
if (cnt == 0) cons_printf("No breakpoints set\n");
}
 
void arch_event_breakpoint(thash_t thread_hash)
{
static istate_t istate;
breakpoint_t *b;
int rc;
 
rc = udebug_regs_read(app_phone, thread_hash, &istate);
120,45 → 89,43
// cons_printf("udebug_regs_read -> %d\n", rc);
// cons_printf("EIP was 0x%08x\n", istate.eip);
int brk_addr = istate.eip - 1;
int bi;
for (bi = 0; bi < MAX_BRKPTS; bi++) {
if (brk_list[bi].set && brk_list[bi].addr == brk_addr)
break;
 
b = breakpoint_find_by_addr(brk_addr);
if (!b) {
cons_printf("unrecognized breakpoint at 0x%x\n", brk_addr);
return;
}
 
if (bi < MAX_BRKPTS) {
cons_printf("breakpoint %d hit\n", bi);
istate.eip = brk_addr;
istate.eflags |= 0x0100; /* trap flag */
 
istate.eip = brk_addr;
istate.eflags |= 0x0100; /* trap flag */
// cons_printf("setting EIP to 0x%08x\n", istate.eip);
rc = udebug_regs_write(app_phone, thread_hash, &istate);
if (rc < 0) { printf("error writing regs\n"); return; }
rc = udebug_mem_write(app_phone, &brk_list[bi].arch.back, brk_addr, 1);
if (rc < 0) { printf("error writing mem\n"); return; }
rc = udebug_regs_write(app_phone, thread_hash, &istate);
if (rc < 0) { cons_printf("error writing regs\n"); return; }
rc = udebug_mem_write(app_phone, &b->arch.back, brk_addr, 1);
if (rc < 0) { cons_printf("error writing mem\n"); return; }
// cons_printf("udebug_mem_write(phone, 0x%x, 0x%02x, 1) -> %d\n", brk_addr, brk_list[bi].arch.back, rc);
lifted_brkpt = &brk_list[bi];
 
breakpoint_hit();
} else {
cons_printf("unrecognized breakpoint at 0x%x\n", brk_addr);
}
b->active = true;
active_bkpt = b;
 
breakpoint_hit(b);
}
 
void arch_event_trap(dthread_t *dt)
{
breakpoint_t *b;
static istate_t istate;
unsigned char brkinstr[1];
int rc;
 
// cons_printf("trap event\n");
 
breakpoint_t *lb = lifted_brkpt;
if (lb) {
b = active_bkpt;
if (b) {
brkinstr[0] = OPCODE_INT3;
rc = udebug_mem_write(app_phone, brkinstr, lb->addr, 1);
rc = udebug_mem_write(app_phone, brkinstr, b->addr, 1);
// cons_printf("restore breakpoint -> %d\n", rc);
lifted_brkpt = NULL;
active_bkpt = NULL;
}
 
if (!dt->arch.singlestep) {
197,7 → 164,7
if (rc < 0) { printf("regs read failed\n"); return; }
 
if (enable) istate.eflags |= 0x0100; /* trap flag */
else if (!lifted_brkpt) istate.eflags &= ~0x0100; /* trap flag */
else if (!active_bkpt) istate.eflags &= ~0x0100; /* trap flag */
 
rc = udebug_regs_write(app_phone, dt->hash, &istate);
if (rc < 0) { printf("regs write failed\n"); return; }
/branches/tracing/boot/arch/mips32/loader/Makefile
90,7 → 90,8
$(USPACEDIR)/app/sctrace/sctrace \
$(USPACEDIR)/app/tetris/tetris \
$(USPACEDIR)/app/tester/tester \
$(USPACEDIR)/app/klog/klog
$(USPACEDIR)/app/klog/klog \
$(USPACEDIR)/app/debug/debug
 
OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
COMPONENT_OBJECTS := $(addsuffix .o,$(basename $(notdir $(COMPONENTS))))