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

/* * General trap (exception) handling function for mips. * This is called by the assembly-language exception handler once * the trapframe has been set up. */  voidmips_trap(struct trapframe *tf){//kprintf("mips_trap:epc=0x%x cause=%x badvaddr=0x%08x/n", tf->tf_epc, (tf->tf_cause >> 2) & 0x1F, tf->tf_vaddr);  // dispatch based on what type of trap occurred  // used for previous projects  if (current == NULL) {    trap_dispatch(tf);  }  else {    // keep a trapframe chain in stack    struct trapframe *otf = current->tf;    current->tf = tf;    bool in_kernel = trap_in_kernel(tf);    trap_dispatch(tf);    current->tf = otf;    if (!in_kernel) {      if (current->flags & PF_EXITING) {        do_exit(-E_KILLED);      }      if (current->need_resched) {        schedule();      }    }  }}

/* * * trap - handles or dispatches an exception/interrupt. if and when trap() returns, * the code in kern/trap/trapentry.S restores the old CPU state saved in the * trapframe and then uses the iret instruction to return from the exception. * */voidtrap(struct trapframe *tf) {    // dispatch based on what type of trap occurred    // used for previous projects    if (current == NULL) {        trap_dispatch(tf);    }    else {        // keep a trapframe chain in stack        struct trapframe *otf = current->tf;        current->tf = tf;            bool in_kernel = trap_in_kernel(tf);            trap_dispatch(tf);            current->tf = otf;        if (!in_kernel) {            if (current->flags & PF_EXITING) {                do_exit(-E_KILLED);            }            if (current->need_resched) {                schedule();            }        }    }}

voidtrap(struct Trapframe *tf){	asm volatile("cld" : : : "cc");	assert(!(read_eflags() & FL_IF));	// cprintf("Incoming TRAP frame at %p/n", tf);	if ((tf->tf_cs & 3) == 3) {		// Trapped from user mode.		// Copy trap frame (which is currently on the stack)		// into 'curenv->env_tf', so that running the environment		// will restart at the trap point.		assert(curenv);		curenv->env_tf = *tf;		// The trapframe on the stack should be ignored from here on.		tf = &curenv->env_tf;	}		// Dispatch based on what type of trap occurred	trap_dispatch(tf);	// If we made it to this point, then no other environment was	// scheduled, so we should return to the current environment	// if doing so makes sense.	if (curenv && curenv->env_status == ENV_RUNNABLE)		env_run(curenv);	else		sched_yield();}

voidtrap(struct Trapframe *tf){	// The environment may have set DF and some versions	// of GCC rely on DF being clear	asm volatile("cld" ::: "cc");	// Halt the CPU if some other CPU has called panic()	extern char *panicstr;	if (panicstr)		asm volatile("hlt");	// Re-acqurie the big kernel lock if we were halted in	// sched_yield()	if (xchg(&thiscpu->cpu_status, CPU_STARTED) == CPU_HALTED)		lock_kernel();	// Check that interrupts are disabled.  If this assertion	// fails, DO NOT be tempted to fix it by inserting a "cli" in	// the interrupt path.	assert(!(read_eflags() & FL_IF));	if ((tf->tf_cs & 3) == 3) {		// Trapped from user mode.		// Acquire the big kernel lock before doing any		// serious kernel work.		// LAB 4: Your code here.		assert(curenv);		lock_kernel();		// Garbage collect if current enviroment is a zombie		if (curenv->env_status == ENV_DYING) {			env_free(curenv);			curenv = NULL;			sched_yield();		}		// Copy trap frame (which is currently on the stack)		// into 'curenv->env_tf', so that running the environment		// will restart at the trap point.		curenv->env_tf = *tf;		// The trapframe on the stack should be ignored from here on.		tf = &curenv->env_tf;	}	// Record that tf is the last real trapframe so	// print_trapframe can print some additional information.	last_tf = tf;	// Dispatch based on what type of trap occurred	trap_dispatch(tf);	// If we made it to this point, then no other environment was	// scheduled, so we should return to the current environment	// if doing so makes sense.	if (curenv && curenv->env_status == ENV_RUNNING)		env_run(curenv);	else		sched_yield();}

voidtrap(struct Trapframe *tf){	// The environment may have set DF and some versions	// of GCC rely on DF being clear	asm volatile("cld" ::: "cc");	// Check that interrupts are disabled.  If this assertion	// fails, DO NOT be tempted to fix it by inserting a "cli" in	// the interrupt path.	assert(!(read_eflags() & FL_IF));	if ((tf->tf_cs & 3) == 3) {		// Trapped from user mode.		// Copy trap frame (which is currently on the stack)		// into 'curenv->env_tf', so that running the environment		// will restart at the trap point.		assert(curenv);		curenv->env_tf = *tf;		// The trapframe on the stack should be ignored from here on.		tf = &curenv->env_tf;	}		// Dispatch based on what type of trap occurred	trap_dispatch(tf);	// If we made it to this point, then no other environment was	// scheduled, so we should return to the current environment	// if doing so makes sense.	if (curenv && curenv->env_status == ENV_RUNNABLE)		env_run(curenv);	else		sched_yield();}

void trap(struct trapframe *tf){	// used for previous projects	if (pls_read(current) == NULL) {		trap_dispatch(tf);	} else {		// keep a trapframe chain in stack		struct trapframe *otf = pls_read(current)->tf;		pls_read(current)->tf = tf;		bool in_kernel = trap_in_kernel(tf);		trap_dispatch(tf);		pls_read(current)->tf = otf;		if (!in_kernel) {			may_killed();			if (pls_read(current)->need_resched) {				schedule();			}		}	}}

void trap(struct frame *tf){		// The environment may have set DF and some versions	// of GCC rely on DF being clear	asm volatile("cld" ::: "cc");	assert(!(read_eflags() & FL_IF));		curtask->trapframe = tf;	if ((tf->tf_cs & 3) == 3) {			} else {		//print_frame(tf);		//panic("kernel double fault/n");	}	trap_dispatch(tf);		schedule();}

voidtrap(struct Trapframe *tf){    //struct Trapframe *tf = &tf_;	// The environment may have set DF and some versions	// of GCC rely on DF being clear	asm volatile("cld" ::: "cc");	// Check that interrupts are disabled.  If this assertion	// fails, DO NOT be tempted to fix it by inserting a "cli" in	// the interrupt path.	assert(!(read_eflags() & FL_IF));	cprintf("Incoming TRAP frame at %p/n", tf);	if ((tf->tf_cs & 3) == 3) {		// Trapped from user mode.		assert(curenv);		// Copy trap frame (which is currently on the stack)		// into 'curenv->env_tf', so that running the environment		// will restart at the trap point.		curenv->env_tf = *tf;		// The trapframe on the stack should be ignored from here on.		tf = &curenv->env_tf;	}	// Record that tf is the last real trapframe so	// print_trapframe can print some additional information.	last_tf = tf;	// Dispatch based on what type of trap occurred	trap_dispatch(tf);	// Return to the current environment, which should be running.	assert(curenv && curenv->env_status == ENV_RUNNING);	env_run(curenv);}

/* * * trap - handles or dispatches an exception/interrupt. if and when trap() returns, * the code in kern/trap/trapentry.S restores the old CPU state saved in the * trapframe and then uses the iret instruction to return from the exception. * */voidtrap(struct trapframe *tf) {    // dispatch based on what type of trap occurred    trap_dispatch(tf);}