自学教程：C++ trapname函数代码示例

voidprint_trapframe(struct Trapframe *tf){	cprintf("TRAP frame at %p from CPU %d/n", tf, cpunum());	print_regs(&tf->tf_regs);	cprintf("  es   0x----%04x/n", tf->tf_es);	cprintf("  ds   0x----%04x/n", tf->tf_ds);	cprintf("  trap 0x%08x %s/n", tf->tf_trapno, trapname(tf->tf_trapno));	// If this trap was a page fault that just happened	// (so %cr2 is meaningful), print the faulting linear address.	if (tf == last_tf && tf->tf_trapno == T_PGFLT)		cprintf("  cr2  0x%08x/n", rcr2());	cprintf("  err  0x%08x", tf->tf_err);	// For page faults, print decoded fault error code:	// U/K=fault occurred in user/kernel mode	// W/R=a write/read caused the fault	// PR=a protection violation caused the fault (NP=page not present).	if (tf->tf_trapno == T_PGFLT)		cprintf(" [%s, %s, %s]/n",			tf->tf_err & 4 ? "user" : "kernel",			tf->tf_err & 2 ? "write" : "read",			tf->tf_err & 1 ? "protection" : "not-present");	else		cprintf("/n");	cprintf("  eip  0x%08x/n", tf->tf_eip);	cprintf("  cs   0x----%04x/n", tf->tf_cs);	cprintf("  flag 0x%08x/n", tf->tf_eflags);	if ((tf->tf_cs & 3) != 0) {		cprintf("  esp  0x%08x/n", tf->tf_esp);		cprintf("  ss   0x----%04x/n", tf->tf_ss);	}}

voidprint_trapframe(struct trapframe *tf) {    cprintf("trapframe at %p/n", tf);    print_regs(&tf->tf_regs);    cprintf("  ds   0x----%04x/n", tf->tf_ds);    cprintf("  es   0x----%04x/n", tf->tf_es);    cprintf("  fs   0x----%04x/n", tf->tf_fs);    cprintf("  gs   0x----%04x/n", tf->tf_gs);    cprintf("  trap 0x%08x %s/n", tf->tf_trapno, trapname(tf->tf_trapno));    cprintf("  err  0x%08x/n", tf->tf_err);    cprintf("  eip  0x%08x/n", tf->tf_eip);    cprintf("  cs   0x----%04x/n", tf->tf_cs);    cprintf("  flag 0x%08x ", tf->tf_eflags);    int i, j;    for (i = 0, j = 1; i < sizeof(IA32flags) / sizeof(IA32flags[0]); i ++, j <<= 1) {        if ((tf->tf_eflags & j) && IA32flags[i] != NULL) {            cprintf("%s,", IA32flags[i]);        }    }    cprintf("IOPL=%d/n", (tf->tf_eflags & FL_IOPL_MASK) >> 12);    if (!trap_in_kernel(tf)) {        cprintf("  esp  0x%08x/n", tf->tf_esp);        cprintf("  ss   0x----%04x/n", tf->tf_ss);    }}

static voidprinttrap(u_int vector, struct trapframe *frame, int isfatal, int user){	register_t va = 0;	printf("/n");	printf("%s %s trap:/n", isfatal ? "fatal" : "handled",	    user ? "user" : "kernel");	printf("/n");	printf("   exception       = 0x%x (%s)/n", vector, trapname(vector));		switch (vector) {	case EXC_DTMISS:	case EXC_DSI:		va = frame->cpu.booke.dear;		break;	case EXC_ITMISS:	case EXC_ISI:		va = frame->srr0;		break;	}	printf("   virtual address = 0x%08x/n", va);	printf("   srr0            = 0x%08x/n", frame->srr0);	printf("   srr1            = 0x%08x/n", frame->srr1);	printf("   curthread       = %p/n", curthread);	if (curthread != NULL)		printf("          pid = %d, comm = %s/n",		    curthread->td_proc->p_pid, curthread->td_proc->p_comm);	printf("/n");}

void print_trapframe(struct trapframe *tf){	kprintf("trapframe at %p/n", tf);	print_regs(&tf->tf_regs);	kprintf("  usr_lr   0x%08x/n", tf->__tf_user_lr);	kprintf("  sp   0x%08x/n", tf->tf_esp);	kprintf("  lr   0x%08x/n", tf->tf_epc);	kprintf("  spsr 0x%08x %s/n", tf->tf_sr, modenames[tf->tf_sr & 0xF]);	kprintf("  trap 0x%08x %s/n", tf->tf_trapno, trapname(tf->tf_trapno));	kprintf("  err  0x%08x/n", tf->tf_err);}

voidprint_trapframe(struct Trapframe *tf){	cprintf("TRAP frame at %p/n", tf);	print_regs(&tf->tf_regs);	cprintf("  es   0x----%04x/n", tf->tf_es);	cprintf("  ds   0x----%04x/n", tf->tf_ds);	cprintf("  trap 0x%08x %s/n", tf->tf_trapno, trapname(tf->tf_trapno));	cprintf("  err  0x%08x/n", tf->tf_err);	cprintf("  eip  0x%08x/n", tf->tf_eip);	cprintf("  cs   0x----%04x/n", tf->tf_cs);	cprintf("  flag 0x%08x/n", tf->tf_eflags);	cprintf("  esp  0x%08x/n", tf->tf_esp);	cprintf("  ss   0x----%04x/n", tf->tf_ss);}

void print_trapframe(struct trapframe *tf){	PRINT_HEX("trapframe at ", tf);	print_regs(&tf->tf_regs);	PRINT_HEX(" $ra/t: ", tf->tf_ra);	PRINT_HEX(" BadVA/t: ", tf->tf_vaddr);	PRINT_HEX(" Status/t: ", tf->tf_status);	PRINT_HEX(" Cause/t: ", tf->tf_cause);	PRINT_HEX(" EPC/t: ", tf->tf_epc);	if (!trap_in_kernel(tf)) {		kprintf("Trap in usermode: ");	} else {		kprintf("Trap in kernel: ");	}	kprintf(trapname(GET_CAUSE_EXCODE(tf->tf_cause)));	kputchar('/n');}

voidprint_trapframe(struct Trapframe *tf){	printf("TRAP frame at %p/n", tf);	printf("  edi  0x%08x/n", tf->tf_edi);	printf("  esi  0x%08x/n", tf->tf_esi);	printf("  ebp  0x%08x/n", tf->tf_ebp);	printf("  oesp 0x%08x/n", tf->tf_oesp);	printf("  ebx  0x%08x/n", tf->tf_ebx);	printf("  edx  0x%08x/n", tf->tf_edx);	printf("  ecx  0x%08x/n", tf->tf_ecx);	printf("  eax  0x%08x/n", tf->tf_eax);	printf("  es   0x----%04x/n", tf->tf_es);	printf("  ds   0x----%04x/n", tf->tf_ds);	printf("  trap 0x%08x %s/n", tf->tf_trapno, trapname(tf->tf_trapno));	printf("  err  0x%08x/n", tf->tf_err);	printf("  eip  0x%08x/n", tf->tf_eip);	printf("  cs   0x----%04x/n", tf->tf_cs);	printf("  flag 0x%08x/n", tf->tf_eflags);	printf("  esp  0x%08x/n", tf->tf_esp);	printf("  ss   0x----%04x/n", tf->tf_ss);}

voidprint_trapframe(struct trapframe *tf) {    PRINT_HEX("trapframe at ", tf);    print_regs(&tf->tf_regs);    PRINT_HEX(" $ra/t: ", tf->tf_ra);    PRINT_HEX(" BadVA/t: ", tf->tf_vaddr);    PRINT_HEX(" Status/t: ", tf->tf_status);    PRINT_HEX(" Cause/t: ", tf->tf_cause);    PRINT_HEX(" EPC/t: ", tf->tf_epc);    if (!trap_in_kernel(tf)) {      kprintf("Trap in usermode: ");    }else{      kprintf("Trap in kernel: ");    }    kprintf(trapname(GET_CAUSE_EXCODE(tf->tf_cause)));    kputchar('/n');  //   /*    int i;    for (i = 0; i < 20; ++i) {        int *addr = (int*)(tf->tf_epc + i * 4);        kprintf("0x%08x=0x%08x/n", addr, *addr);    } //   */}

voidprint_trapframe(struct trapframe *tf){	cprintf("TRAP frame at %p/n", tf);	cprintf("  edi  0x%x/n", tf->edi);	cprintf("  esi  0x%x/n", tf->esi);	cprintf("  ebp  0x%x/n", tf->ebp);	cprintf("  oesp 0x%x/n", tf->oesp);	cprintf("  ebx  0x%x/n", tf->ebx);	cprintf("  edx  0x%x/n", tf->edx);	cprintf("  ecx  0x%x/n", tf->ecx);	cprintf("  eax  0x%x/n", tf->eax);	cprintf("  es   0x----%x/n", tf->es);	cprintf("  ds   0x----%x/n", tf->ds);	cprintf("  trap 0x%x %s/n", tf->trapno, trapname(tf->trapno));	cprintf("  err  0x%x/n", tf->err);	cprintf("  eip  0x%x/n", tf->eip);	cprintf("  cs   0x----%x/n", tf->cs);	cprintf("  flag 0x%x/n", tf->eflags);	cprintf("  esp  0x%x/n", tf->esp);	cprintf("  ss   0x----%x/n", tf->ss);}

//.........这里部分代码省略.........	if(ureg->type != PsrMfiq && rem < 256) {		dumpregs(ureg);		panic("trap %d stack bytes remaining (%s), "			  "up=#%8.8lux ureg=#%8.8lux pc=#%8.8ux"			  ,rem, up?up->text:"", up, ureg, ureg->pc);		for(;;);	}	itype = ureg->type;	/*	All interrupts/exceptions should be resumed at ureg->pc-4,		except for Data Abort which resumes at ureg->pc-8. */	if(itype == PsrMabt+1)		ureg->pc -= 8;	else ureg->pc -= 4;	if(up){		up->pc = ureg->pc;		up->dbgreg = ureg;	}	switch(itype) {	case PsrMirq:		t = m->ticks;		/* CPU time per proc */		up = nil;		/* no process at interrupt level */		irq(ureg);		up = m->proc;		preemption(m->ticks - t);		m->intr++;		break;	case PsrMund:		if(*(ulong*)ureg->pc == BREAK && breakhandler) {			int s;			Proc *p;			p = up;			s = breakhandler(ureg, p);			if(s == BrkSched) {				p->preempted = 0;				sched();			} else if(s == BrkNoSched) {				/* stop it being preempted until next instruction */				p->preempted = 1;				if(up)					up->dbgreg = 0;				return;			}			break;		}		if(up == nil) goto faultpanic;		spllo();		if(waserror()) {			if(waslo(ureg->psr) && up->type == Interp)				disfault(ureg, up->env->errstr);			setpanic();			dumpregs(ureg);			panic("%s", up->env->errstr);		}		if(!fpiarm(ureg)) {			dumpregs(ureg);			sys_trap_error(ureg->type);		}		poperror();		break;	case PsrMsvc: /* Jump through 0 or SWI */		if(waslo(ureg->psr) && up && up->type == Interp) {			spllo();			dumpregs(ureg);			sys_trap_error(ureg->type);		}		setpanic();		dumpregs(ureg);		panic("SVC/SWI exception");		break;	case PsrMabt: /* Prefetch abort */		if(catchdbg && catchdbg(ureg, 0))			break;		/* FALL THROUGH */	case PsrMabt+1: /* Data abort */		if(waslo(ureg->psr) && up && up->type == Interp) {			spllo();			faultarm(ureg);		}		print("Data Abort/n");		/* FALL THROUGH */	default:faultpanic:		setpanic();		dumpregs(ureg);		panic("exception %uX %s/n", ureg->type, trapname(ureg->type));		break;	}	splhi();	if(up)		up->dbgreg = 0;		/* becomes invalid after return from trap */}

voidtrap(struct trapframe *frame){	struct thread	*td;	struct proc	*p;#ifdef KDTRACE_HOOKS	uint32_t inst;#endif	int		sig, type, user;	u_int		ucode;	ksiginfo_t	ksi;	PCPU_INC(cnt.v_trap);	td = curthread;	p = td->td_proc;	type = ucode = frame->exc;	sig = 0;	user = frame->srr1 & PSL_PR;	CTR3(KTR_TRAP, "trap: %s type=%s (%s)", td->td_name,	    trapname(type), user ? "user" : "kernel");#ifdef KDTRACE_HOOKS	/*	 * A trap can occur while DTrace executes a probe. Before	 * executing the probe, DTrace blocks re-scheduling and sets	 * a flag in its per-cpu flags to indicate that it doesn't	 * want to fault. On returning from the probe, the no-fault	 * flag is cleared and finally re-scheduling is enabled.	 *	 * If the DTrace kernel module has registered a trap handler,	 * call it and if it returns non-zero, assume that it has	 * handled the trap and modified the trap frame so that this	 * function can return normally.	 */	if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, type) != 0)		return;#endif	if (user) {		td->td_pticks = 0;		td->td_frame = frame;		if (td->td_cowgen != p->p_cowgen)			thread_cow_update(td);		/* User Mode Traps */		switch (type) {		case EXC_RUNMODETRC:		case EXC_TRC:			frame->srr1 &= ~PSL_SE;			sig = SIGTRAP;			ucode = TRAP_TRACE;			break;#ifdef __powerpc64__		case EXC_ISE:		case EXC_DSE:			if (handle_user_slb_spill(&p->p_vmspace->vm_pmap,			    (type == EXC_ISE) ? frame->srr0 : frame->dar) != 0){				sig = SIGSEGV;				ucode = SEGV_MAPERR;			}			break;#endif		case EXC_DSI:		case EXC_ISI:			sig = trap_pfault(frame, 1);			if (sig == SIGSEGV)				ucode = SEGV_MAPERR;			break;		case EXC_SC:			syscall(frame);			break;		case EXC_FPU:			KASSERT((td->td_pcb->pcb_flags & PCB_FPU) != PCB_FPU,			    ("FPU already enabled for thread"));			enable_fpu(td);			break;		case EXC_VEC:			KASSERT((td->td_pcb->pcb_flags & PCB_VEC) != PCB_VEC,			    ("Altivec already enabled for thread"));			enable_vec(td);			break;		case EXC_VSX:			KASSERT((td->td_pcb->pcb_flags & PCB_VSX) != PCB_VSX,			    ("VSX already enabled for thread"));			if (!(td->td_pcb->pcb_flags & PCB_VEC))				enable_vec(td);			if (!(td->td_pcb->pcb_flags & PCB_FPU))				save_fpu(td);			td->td_pcb->pcb_flags |= PCB_VSX;			enable_fpu(td);			break;//.........这里部分代码省略.........