int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
func_info * func_ptr = 0;
char format[150];
char formatEIP[150];
struct Eipdebuginfo info;
strcpy(format,"ebp %08x eip %08x args %08x %08x %08x %08x %08x\n");
strcpy(formatEIP, "\t%s:%d: %.*s+%d\n");
cprintf("Stack backtrace:\n");
func_ptr = (func_info*)read_ebp();
while(func_ptr != NULL){
cprintf(format,func_ptr,func_ptr->eip,func_ptr->args[0],func_ptr->args[1]
, func_ptr->args[2], func_ptr->args[3],func_ptr->args[4]);
debuginfo_eip((uintptr_t)func_ptr->eip,&info);
cprintf(formatEIP,
info.eip_file,
info.eip_line,
info.eip_fn_namelen,
(char*)info.eip_fn_name,(uintptr_t)func_ptr->eip - info.eip_fn_addr);
func_ptr = (func_info*) func_ptr->prevfunc_ebp;
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
unsigned ebp = read_ebp();
while (ebp) {
struct Eipdebuginfo info;
unsigned eip = *((unsigned *)ebp + 1);
debuginfo_eip(eip, &info);
cprintf("ebp %08x eip %08x args %08x %08x %08x %08x %08x %s:%d: %.*s+%d\n",
ebp,
eip,
*((unsigned *)ebp + 2),
*((unsigned *)ebp + 3),
*((unsigned *)ebp + 4),
*((unsigned *)ebp + 5),
*((unsigned *)ebp + 6),
info.eip_file,
info.eip_line,
info.eip_fn_namelen, info.eip_fn_name,
(char*)eip - (char*)info.eip_fn_addr);
ebp = *(unsigned*)ebp;
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
uint32_t ebp,eip;
struct Eipdebuginfo info;
int i=0;
ebp=read_ebp();
while(ebp != 0) {
eip = *((uint32_t *)(ebp+4));
// change ip to addr
// debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info)
debuginfo_eip((uintptr_t)eip,&info);
cprintf("ebp %0x eip %0x ",ebp,eip);
cprintf("args ");
for(i=0;i<=4;i++)
cprintf("%0x ",*(uint32_t *)(ebp+8+4*i));
cprintf("\n");
cprintf(" eipfile: %s eipfunc: %s ",info.eip_file,info.eip_fn_name);
cprintf("\n");
ebp=*((uint32_t *)ebp);
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
uint32_t ebp, eip;
int i;
cprintf("Stack backtrace:\n");
ebp = read_ebp();
while (ebp) {
eip = ((uint32_t *) ebp)[1];
cprintf(" ebp %08x eip %08x ", ebp, eip);
cprintf("args ");
for (i = 1; i <= 5; i++) {
cprintf("%08x ", ((uint32_t *) ebp)[1 + i]);
}
cprintf("\n");
struct Eipdebuginfo info;
if (!debuginfo_eip(eip, &info))
cprintf("\t%s:%d: %.*s+%d\n", info.eip_file, info.eip_line,
info.eip_fn_namelen, info.eip_fn_name,
eip - info.eip_fn_addr);
ebp = ((uint32_t *) ebp)[0];
}
return 0;
}
// print the current backtrace of the thread.
void
backtrace(void)
{
// hw1: fill in your code here.
//cprintf("not implemented yet\n");
extern void main(void);
uint ebp, eip, up_ebp, retaddr;
uint arg0, arg1, arg2, arg3, arg4;
ebp = read_ebp();
eip = (uint)backtrace;
while(eip)
{
up_ebp = *(uint *)ebp;
retaddr = *(uint *)(ebp + 4);
arg0 = *(uint *)(ebp + 8);
arg1 = *(uint *)(ebp + 12);
arg2 = *(uint *)(ebp + 16);
arg3 = *(uint *)(ebp + 20);
arg4 = *(uint *)(ebp + 24);
cprintf("ebp %x eip %x args %x %x %x %x %x\n",
ebp, eip, arg0, arg1, arg2, arg3, arg4);
ebp = up_ebp;
eip = retaddr;
}
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
uint32_t eip=read_eip();
uint32_t ebp=read_ebp();
uint32_t esp=ebp;
int i;
struct Eipdebuginfo info;
cprintf("Stack backtrace:\n");
// in Entry.S it sets ebp to 0 at first,so if ebp==0 then we know that there is no more stack.
while(ebp!=0) {
cprintf("ebp %08x eip %08x args ",ebp,eip);
// pop the saved ebp to current ebp.
ebp=*(uint32_t *)esp;
esp+=4;
// pop the saved eip to current eip.
eip=*(uint32_t *)esp;
esp+=4;
for(i=0;i<=4;i++){
cprintf("%08x ",*(uint32_t *)esp);
esp+=4;
}
cprintf("\n");
cprintf(" ");
debuginfo_eip(eip,&info);
cprintf("%s:%d: ",info.eip_file, info.eip_line);
cprintf("%.*s",info.eip_fn_namelen, info.eip_fn_name);
cprintf("+%d", eip-info.eip_fn_addr);
cprintf("\n");
esp=ebp;
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
uint32_t *addr = 0;
char format[FORMAT_LENGTH] = {0};
char formatName[FORMAT_LENGTH] = { 0 };
struct Eipdebuginfo info;
strcpy(format,
" ebp %08x eip %08x args %08x %08x %08x %08x %08x");
strcpy(formatName, " %s:%d: %.*s+%d\n");
addr = (uint32_t *)read_ebp();
cprintf("Stack backtrace\n");
for (; NULL != addr;)
{
cprintf(format, EBP(addr), EIP(addr), ARG(addr, 0),
ARG(addr, 1), ARG(addr, 2), ARG(addr, 3),
ARG(addr, 4));
debuginfo_eip(EIP(addr), &info);
cprintf(formatName,
info.eip_file,
info.eip_line,
info.eip_fn_namelen,
info.eip_fn_name, EIP(addr)-info.eip_fn_addr);
addr = (uint32_t*)*addr;
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
cprintf("Stack backtrace:\n");
uint32_t ebp = read_ebp();
uint32_t eip; // = read_eip();
struct Eipdebuginfo info;
int idxStr;
while (ebp != 0) {
// print registers
cprintf(" ebp %x", ebp);
eip = *(uint32_t*)(ebp + 4);
cprintf(" eip %x", eip);
cprintf(" args %08x", *(uint32_t*)(ebp + 8));
cprintf(" %08x", *(uint32_t*)(ebp + 12));
cprintf(" %08x", *(uint32_t*)(ebp + 16));
cprintf(" %08x", *(uint32_t*)(ebp + 20));
cprintf(" %08x\n", *(uint32_t*)(ebp + 24));
ebp = *(uint32_t*)ebp;
// print line numbers
debuginfo_eip((uintptr_t)eip, &info);
cprintf(" %s", info.eip_file);
cprintf(":%d: ", info.eip_line);
for (idxStr = 0; idxStr < info.eip_fn_namelen; idxStr++)
cprintf("%c", info.eip_fn_name[idxStr]);
cprintf("+%d\n", eip - info.eip_fn_addr);
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{ struct Eipdebuginfo info;
unsigned int *ebp=(unsigned int *)read_ebp();
unsigned int *esp=(unsigned int *)read_esp();
unsigned int *eip=0;
unsigned int arg[5];
int i=0;
while(ebp)
{
for(i=0;i<5;i++)
arg[i]=*(ebp+i+2);
eip=ebp+1;
debuginfo_eip(*eip,&info);
cprintf(" ebp %08x eip %08x args ",(unsigned int)ebp,*eip );
for(i=0;i<5;++i)
cprintf("%08x ", arg[i]);
cprintf("\n");
cprintf("\t\t%s:%u:%.*s+%u\n",
info.eip_file,
info.eip_line,
info.eip_fn_namelen,
info.eip_fn_name,
*eip-info.eip_fn_addr);
esp=ebp+2;
ebp=(unsigned int *)*ebp;
}
return 0;
}
// Acquire the lock.
// Loops (spins) until the lock is acquired.
// Holding a lock for a long time may cause
// other CPUs to waste time spinning to acquire it.
void
spinlock_acquire(struct spinlock *lk)
{
if(spinlock_holding(lk))
panic("Already holding lock.");
while(xchg(&(lk->locked), 1) != 0)
pause();
lk->cpu = cpu_cur();
debug_trace(read_ebp(), lk->eips);
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
unsigned int *ebp = (unsigned int *)read_ebp();
do
{
ebp = dump_stack(ebp);
}while(ebp);
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
uint32_t *ebp = (uint32_t*)read_ebp();
struct Eipdebuginfo info;
cprintf ("Stack backtrace:\n");
while (ebp != 0x0){
cprintf (" ebp %08x eip %08x args %08x %08x %08x %08x %08x\n", ebp, ebp[1], ebp[2], ebp[3], ebp[4], ebp[5], ebp[6]);
debuginfo_eip(ebp[1],&info);
cprintf ("%s:%d: %.*s+%d\n", info.eip_file, info.eip_line, info.eip_fn_namelen,info.eip_fn_name, ebp[1]-info.eip_fn_addr);
ebp = (uint32_t*) ebp[0];
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
uint32_t* ebp = (uint32_t*) read_ebp();
cprintf("Stack backtrace:\n");
while (ebp) {
cprintf("ebp %x eip %x args", ebp, ebp[1]);
int i;
for (i = 2; i <= 6; ++i)
cprintf(" %08.x", ebp[i]);
cprintf("\n");
ebp = (uint32_t*) *ebp;
}
return 0;
}
// Record the current call stack in pcs[] by following the %ebp chain.
static void
get_caller_pcs(uint32_t pcs[])
{
uint32_t *ebp;
int i;
ebp = (uint32_t *)read_ebp();
for (i = 0; i < 10; i++){
if (ebp == 0 || ebp < (uint32_t *)ULIM)
break;
pcs[i] = ebp[1]; // saved %eip
ebp = (uint32_t *)ebp[0]; // saved %ebp
}
for (; i < 10; i++)
pcs[i] = 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
uint32_t* ebp = (uint32_t*) read_ebp();
cprintf("Stack backtrace:\n");
while (ebp != 0) {
cprintf(" ebp %08x eip %08x", ebp, *(ebp+1));
cprintf(" args %08x %08x %08x %08x %08x\n", *(ebp+2), *(ebp+3), *(ebp+4), *(ebp+5), *(ebp+6));
struct Eipdebuginfo info;
debuginfo_eip(*(ebp+1), &info);
cprintf(" %s:%d: %.*s+%d\n", info.eip_file, info.eip_line, info.eip_fn_namelen, info.eip_fn_name, *(ebp + 1) - info.eip_fn_addr);
ebp = (uint32_t*) *ebp;
}
return 0;
}
int
cpu(void)
{
// Cannot call cpu when interrupts are enabled:
// result not guaranteed to last long enough to be used!
// Would prefer to panic but even printing is chancy here:
// everything, including cprintf, calls cpu, at least indirectly
// through acquire and release.
if(read_eflags()&FL_IF){
static int n;
if(n++ == 0)
cprintf("cpu called from %x with interrupts enabled\n",
((uint32_t*)read_ebp())[1]);
}
if(lapic)
return lapic[ID]>>ID_SHIFT;
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
struct Eipdebuginfo info;
int i = 1;
uint32_t* ebp = (uint32_t*) read_ebp();
uint32_t eip = *(ebp + 1); // return address
cprintf("Stack backtrace:\n");
for (; ebp != 0; ebp = (uint32_t*)(*(ebp)), eip = *(ebp + 1)) {
cprintf(" ebp %08x eip %08x args", ebp, eip);
for (i = 1; i <= 5; ++i)
cprintf(" %08x", *(ebp + 1 + i));
cprintf("\n");
debuginfo_eip((uintptr_t)(*(ebp + 1)), &info);
cprintf(" %s:%d: %.*s+%u\n", info.eip_file, info.eip_line, info.eip_fn_namelen, info.eip_fn_name, (unsigned int)(*(ebp + 1) - info.eip_fn_addr));
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
// 寄存器ebp 的值是当前栈帧的最高地址，而且这个最高地址对应的内存单元里面存放的值恰好是调用者栈帧的最高地址
// 寄存器eip 存放的是cpu 执行下一条指令的地址
uint32_t *ebp = (uint32_t *)read_ebp();
struct Eipdebuginfo info;
cprintf("Stack backtrace:\n");
while (ebp) {
cprintf("ebp %08x eip %08x args %08x %08x %08x %08x %08x\n", ebp, ebp[1], ebp[2], ebp[3], ebp[4], ebp[5], ebp[6]);
uint32_t eip = ebp[1];
debuginfo_eip(eip, &info);
cprintf("%s:%d : %.*s+%d\n", info.eip_file, info.eip_line, info.eip_fn_namelen, info.eip_fn_name, (eip - info.eip_fn_addr));
ebp = (uint32_t *)(*ebp);
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
int * ebp = (int *) read_ebp();
uint32_t eip;
uint32_t arg[5];
struct Eipdebuginfo info;
while (ebp != 0){
eip = ebp[1];
arg[0] = ebp[2];
arg[1] = ebp[3];
arg[2] = ebp[4];
arg[3] = ebp[5];
arg[4] = ebp[6];
cprintf("ebp %08x eip %08x args %08x %08x %08x %08x %08x\n",ebp,eip,arg[0],arg[1],arg[2],arg[3],arg[4]);
debuginfo_eip(eip, &info);
cprintf("%s:%d: %.*s+%d\n",info.eip_file, info.eip_line, info.eip_fn_namelen ,info.eip_fn_name, eip-info.eip_fn_addr);
ebp= (int *) ebp[0];
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
uint32_t ebp, eip, *p;
struct Eipdebuginfo info;
ebp = read_ebp();
while (ebp != 0)
{
p = (uint32_t *) ebp;
eip = p[1];
cprintf("ebp %x eip %x args %08x %08x %08x %08x %08x\n", ebp, eip, p[2], p[3], p[4], p[5], p[6]);
if (debuginfo_eip(eip, &info) == 0)
{
int fn_offset = eip - info.eip_fn_addr;
cprintf("%s:%d: %.*s+%d\n", info.eip_file, info.eip_line, info.eip_fn_namelen, info.eip_fn_name, fn_offset);
}
ebp = p[0];
}
return 0;
}
int
csa_backtrace(int argc, char **argv, struct Trapframe *tf)
{
uint32_t* ebp = (uint32_t*) read_ebp();
cprintf("Stack backtrace:\n");
while (ebp) {
uint32_t eip = ebp[1];
cprintf("ebp %x eip %x args", ebp, eip);
int i;
for (i = 2; i <= 6; ++i)
cprintf(" %08.x", ebp[i]);
cprintf("\n");
struct Eipdebuginfo info;
debuginfo_eip(eip, &info);
cprintf("\t%s:%d: %.*s+%d\n",
info.eip_file, info.eip_line,
info.eip_fn_namelen, info.eip_fn_name,
eip-info.eip_fn_addr);
// kern/monitor.c:143: monitor+106
ebp = (uint32_t*) *ebp;
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
//The ebp value of the program, which calls the mon_backtrace
int regebp = read_ebp();
regebp = *((int *)regebp);
int *ebp = (int *)regebp;
cprintf("Stack backtrace:\n");
//If only we haven't pass the stack frame of i386_init
while((int)ebp != 0x0) {
cprintf(" ebp %08x", (int)ebp);
cprintf(" eip %08x", *(ebp+1));
cprintf(" args");
cprintf(" %08x", *(ebp+2));
cprintf(" %08x", *(ebp+3));
cprintf(" %08x", *(ebp+4));
cprintf(" %08x", *(ebp+5));
cprintf(" %08x\n", *(ebp+6));
ebp = (int *)(*ebp);
}
return 0;
}
//exception dispatcher
void _on_exception(int code, int codedata, CPUState *cpudata) {
e9printf("_on_exception called. code: %d, codedata: %d, cpudata: %p\n", code, codedata, cpudata);
e9printf(" eax: %x, ebx: %x, edx: %x\n", read_eax(), read_ebx(), read_edx());
e9printf(" ebp: %x, esp: %x, eip: %x\n\n", read_ebp(), read_esp(), get_eip());
//sanitize code, just to be safe
code = code & 31;
int handled = 0;
for (LinkNode *node=exception_stacks[code].first; node; node=node->next) {
ExceptionHandler handler = node->data;
if (handler(code, codedata, cpudata)) {
handled = 1;
break;
}
}
if (!handled) {
e9printf("Unhandled exception %d\n", code);
kerror(-1, "Unhandled exception");
}
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
uint32_t * ebp;
ebp = (uint32_t *)read_ebp();
cprintf("Stack backtrace:\n");
while(ebp != 0){
cprintf(" ebp %08x eip %08x args %08x %08x %08x %08x %08x\n",
ebp, (uint32_t *)ebp[1], ebp[2], ebp[3], ebp[4] , ebp[5], ebp[6]);
struct Eipdebuginfo dinfo;
debuginfo_eip((uintptr_t)(uint32_t *)ebp[1], &dinfo);
char tmpname[30];
strcpy(tmpname, dinfo.eip_fn_name);
tmpname[dinfo.eip_fn_namelen] = '\0';
cprintf(" %s:%d: %s+%u\n", dinfo.eip_file, dinfo.eip_line, tmpname, (uint32_t)ebp[1] - dinfo.eip_fn_addr);
ebp = (uint32_t *)ebp[0];
}
return 0;
}
int
mon_backtrace(int argc, char **argv, struct Trapframe *tf)
{
// Your code here.
uint32_t *ebp;
uint32_t eip;
uint32_t arg0, arg1, arg2, arg3, arg4;
ebp = (uint32_t *)read_ebp();
eip = ebp[1];
arg0 = ebp[2];
arg1 = ebp[3];
arg2 = ebp[4];
arg3 = ebp[5];
arg4 = ebp[6];
cprintf("Stack backtrace:\n");
while(ebp != 0) {
char fn[100];
cprintf(" ebp %08x eip %08x args %08x %08x %08x %08x %08x\n",
ebp, eip, arg0, arg1, arg2, arg3, arg4);
struct Eipdebuginfo info;
debuginfo_eip(eip, &info);
snprintf(fn, info.eip_fn_namelen+1, "%s", info.eip_fn_name);
cprintf(" %s:%u: %s+%u\n", info.eip_file, info.eip_line, fn, eip - info.eip_fn_addr);
ebp = (uint32_t *)ebp[0];
eip = ebp[1];
arg0 = ebp[2];
arg1 = ebp[3];
arg2 = ebp[4];
arg3 = ebp[5];
arg4 = ebp[6];
}
return 0;
}
void dump_stack(void)
{
dump_stack_ptr(read_ebp());
}
void Inspector::print_backtrace() {
print_backtrace(read_ebp());
}
