static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
// if (tf->tf_trapno == 14)
// page_fault_handler(tf);
cprintf("TRAP NO : %d\n", tf->tf_trapno);
int r;
switch (tf->tf_trapno) {
case T_PGFLT :
page_fault_handler(tf);
break;
case T_BRKPT :
monitor(tf);
break;
case T_DEBUG :
monitor(tf);
break;
case T_SYSCALL :
r = syscall(tf->tf_regs.reg_eax, tf->tf_regs.reg_edx, tf->tf_regs.reg_ecx, tf->tf_regs.reg_ebx, tf->tf_regs.reg_edi, tf->tf_regs.reg_esi);
tf->tf_regs.reg_eax = r;
break;
default :
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
uint32_t fault_va;
if(tf->tf_trapno >= 0 && tf->tf_trapno < 255)
{
switch(tf->tf_trapno)
{
case T_PGFLT://page fault
page_fault_handler(tf);
return;
case T_BRKPT:
monitor(tf);
return;
case T_SYSCALL:
//fault_va = rcr2();
//cprintf("[%08x] user fault va %08x ip %08x\n",curenv->env_id, fault_va, tf->tf_eip);
//cprintf("T_SYSCALL\n");
// print_trapframe(tf);
tf->tf_regs.reg_eax = syscall(tf->tf_regs.reg_eax, tf->tf_regs.reg_edx, tf->tf_regs.reg_ecx,tf->tf_regs.reg_ebx, tf->tf_regs.reg_edi, tf->tf_regs.reg_esi);
return;
}
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_TIMER) {
lapic_eoi();
sched_yield();
return;
}
// Handle keyboard and serial interrupts.
// LAB 5: Your code here.
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
switch(tf->tf_trapno)
{
case T_PGFLT: page_fault_handler(tf);
return;
case T_BRKPT: monitor(tf);
return;
case T_SYSCALL:
tf->tf_regs.reg_rax = syscall(tf->tf_regs.reg_rax,tf->tf_regs.reg_rdx,tf->tf_regs.reg_rcx,tf->tf_regs.reg_rbx, tf->tf_regs.reg_rdi, tf->tf_regs.reg_rsi);
return;
}
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
// Handle clock and serial interrupts.
// LAB 4: Your code here.
switch(tf->tf_trapno){
case T_SYSCALL:
tf->tf_regs.reg_eax = syscall(tf->tf_regs.reg_eax,
tf->tf_regs.reg_edx,
tf->tf_regs.reg_ecx,
tf->tf_regs.reg_ebx,
tf->tf_regs.reg_edi,
tf->tf_regs.reg_esi);
return ;
case T_PGFLT:
page_fault_handler(tf);
return ;
case T_BRKPT:
monitor(tf);
return ;
case IRQ_OFFSET + IRQ_TIMER:
sched_yield();
return ;
}
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
void segv_sigaction(int signum, siginfo_t* sinfo, void * p){
// Check signal
if (SIGSEGV != signum) {
printf ("Bad handler for bad signal...\n");
exit (1);
}
// Check if fault is from managed segment
if(sinfo->si_addr < start_addr || sinfo->si_addr >= size*PAGESIZE+start_addr){
printf("Segfault somewhere else... good luck...\n");
printf(" Hint: run the debugger and set a breakpoint for this line\n");
exit(1);
}
// Check cause of fault
if(sinfo->si_code != SEGV_ACCERR){
printf("Object not mapped...\n");
printf(" Hint: run the debugger and set a breakpoint for this line\n");
exit(1);
}
// Find out virtual page in fault
page_virt pv=PAGEOF(sinfo->si_addr);
// If not invalid then setDirtyBit
// Allow read, but wait until page has been loaded...
if(mmu_array[pv].pp != INVALID){
if(!mmu_array[pv].accessed){
struct timeval delay;
struct timeval now;
gettimeofday(&now,NULL);
timeradd(&delay,&delay_load,&delay);
timersub(&delay,&now,&delay);
if(delay.tv_sec >= 0){
int UNUSED r;
struct timespec s;
TV2TS(delay,s);
//do{
// r=nanosleep(&s,&s);
// }while(r < 0 && errno == EINTR);
}
mmu_setAccessedBit(pv);
}else{
mmu_setDirtyBit(pv);
}
}else{
// Else call page fault handler
stats_faults++;
page_fault_handler(pv);
}
// Check that translation has been added
if(mmu_array[pv].pp == INVALID){
printf("Page fault handler did not update MMU...\n");
exit(1);
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
if (tf ->tf_trapno == IRQ_OFFSET + IRQ_TIMER) {
lapic_eoi();
sched_yield();
return;
}
// Unexpected trap: The user process or the kernel has a bug.
// if (tf->tf_trapno == 14)
// page_fault_handler(tf);
// cprintf("TRAP NO : %d\n", tf->tf_trapno);
int r;
switch (tf->tf_trapno) {
case T_PGFLT :
page_fault_handler(tf);
break;
case T_BRKPT :
monitor(tf);
break;
case T_DEBUG :
monitor(tf);
break;
case T_SYSCALL :
r = syscall(tf->tf_regs.reg_eax, tf->tf_regs.reg_edx, tf->tf_regs.reg_ecx, tf->tf_regs.reg_ebx, tf->tf_regs.reg_edi, tf->tf_regs.reg_esi);
tf->tf_regs.reg_eax = r;
break;
default :
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
}
void
trap(struct Trapframe *tf)
{
int ret;
// Handle processor exceptions
// Your code here.
switch(tf->tf_trapno)
{
case T_BRKPT:
while(1)
monitor(NULL);
break;
case T_PGFLT:
page_fault_handler(tf);
tf->tf_eflags |= FL_IF;
//env_pop_tf(tf);
memcpy(&curenv->env_tf, tf, sizeof(*tf));
env_run(curenv);
return;
case T_SYSCALL:
ret = syscall(tf->tf_eax, tf->tf_edx, tf->tf_ecx, tf->tf_ebx,
tf->tf_edi, tf->tf_esi);
tf->tf_eax = ret;
tf->tf_eflags |= FL_IF;
// env_pop_tf(tf);
memcpy(&curenv->env_tf, tf, sizeof(*tf));
env_run(curenv);
case IRQ_OFFSET:
sched_yield();
break;
case IRQ_KBD:
kbd_intr();
memcpy(&curenv->env_tf, tf, sizeof(*tf));
env_run(curenv);
break;
default:
break;
}
// the user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
uint32_t ret;
if ( tf->tf_trapno == T_PGFLT ) {
page_fault_handler(tf);
return;
}
if ( tf->tf_trapno == T_BRKPT ) {
monitor(tf);
return;
}
if ( tf->tf_trapno == T_SYSCALL ) {
//cprintf("==== i am here\n");
ret = syscall( tf->tf_regs.reg_eax, tf->tf_regs.reg_edx, tf->tf_regs.reg_ecx, tf->tf_regs.reg_ebx, tf->tf_regs.reg_edi, tf->tf_regs.reg_esi);
if ( ret < 0 ) {
panic("trap_dispatch: The System Call number is invalid");
}
tf->tf_regs.reg_eax = ret;
//cprintf("bobo -------------:%x\n", tf->tf_regs.reg_eax);
return;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
void
trap(struct Trapframe *tf)
{
// print_trapframe(tf);
// Handle processor exceptions
// Your code here.
if(tf->tf_trapno == 0xE)
page_fault_handler(tf);
else if(tf->tf_trapno == T_SYSCALL)
{
syscall(tf->tf_eax, tf->tf_edx, tf->tf_ecx, tf->tf_ebx, tf->tf_esi, tf->tf_edi);
}
// Handle external interrupts
if (tf->tf_trapno == IRQ_OFFSET+0) {
// irq 0 -- clock interrupt
sched_yield();
}
if (tf->tf_trapno == IRQ_OFFSET+4) {
serial_intr();
return;
}
if (IRQ_OFFSET <= tf->tf_trapno
&& tf->tf_trapno < IRQ_OFFSET+MAX_IRQS) {
// just ingore spurious interrupts
printf("spurious interrupt on irq %d\n",
tf->tf_trapno - IRQ_OFFSET);
print_trapframe(tf);
return;
}
// the user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
int32_t ret_code;
// Handle processor exceptions.
// LAB 3: Your code here.
switch(tf->tf_trapno) {
case (T_PGFLT):
page_fault_handler(tf);
break;
case (T_BRKPT):
print_trapframe(tf);
monitor(tf);
break;
case (T_DEBUG):
monitor(tf);
break;
case (T_SYSCALL):
// print_trapframe(tf);
ret_code = syscall(
tf->tf_regs.reg_eax,
tf->tf_regs.reg_edx,
tf->tf_regs.reg_ecx,
tf->tf_regs.reg_ebx,
tf->tf_regs.reg_edi,
tf->tf_regs.reg_esi);
tf->tf_regs.reg_eax = ret_code;
break;
default:
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
}
/**
* @author Ivan Gualandri
* @version 1.0
*
* Questa funzione gestira a livello centralizzato le varie eccezione
*/
void _globalException(int n, int error)
{
switch (n) {
case DIVIDE_ERROR:
_kputs("Divide Error\n");
break;
case DEBUG_EXC:
_kputs("Debug Exception\n");
break;
case NMI_INTERRUPT:
_kputs("NMI Exception\n");
break;
case OVERFLOW:
_kputs("OverFlow Exception\n");
break;
case BOUND_RANGE_EXCEED:
_kputs("Bound Exception\n");
break;
case DEV_NOT_AVL:
_kputs("Device Not Available Exception\n");
break;
case COPROC_SEG_OVERRUN:
_kputs("CoProcessor Segment Overrun\n");
break;
case BREAKPOINT:
_kputs("BreakPoint\n");
break;
case INVALID_TSS:
_kputs("Invalid TSS\n");
break;
case SEGMENT_NOT_PRESENT:
_kputs("Segment Not Present\n");
break;
case STACK_SEGMENT_FAULT:
_kputs("Stack Segment Fault Exception\n");
break;
case GENERAL_PROTECTION:
_kputs("General Protection Exception\n");
break;
case INVALID_OPCODE:
_kputs("Invalid Opcode Exception\n");
break;
case PAGE_FAULT:
page_fault_handler (error);
break;
case INT_RSV:
_kputs("Intel Reserved\n");
break;
case FLOATING_POINT_ERR:
_kputs("Floating Point Exception\n");
break;
case ALIGNMENT_CHECK:
_kputs("Alignment Check Exception\n");
break;
case MACHINE_CHECK:
_kputs("Machine Check Exception\n");
break;
case DOUBLE_FAULT:
_kputs("Double Fault Exception\n");
break;
case SIMD_FP_EXC:
_kputs ("Simd Floating Point Exception\n");
break;
default:
_kputs ("Unknown exception\n");
break;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
static int page_to_age = 0;
int page_to_age_first = page_to_age;
int num_page_updates = NPAGEUPDATES_FACTOR*NPAGESFREE_LOW_THRESHOLD;
struct PteChain *pp_refs_chain;
char page_accessed;
// Handle processor exceptions.
// LAB 3: Your code here.
if (tf->tf_trapno == T_PGFLT) {
page_fault_handler(tf);
return;
}
else if (tf->tf_trapno == T_BRKPT) {
monitor(tf); // breakpoint exceptions invoke the kernel monitor
return;
}
else if (tf->tf_trapno == T_SYSCALL) {
tf->tf_regs.reg_eax = syscall(tf->tf_regs.reg_eax, tf->tf_regs.reg_edx, tf->tf_regs.reg_ecx, tf->tf_regs.reg_ebx, tf->tf_regs.reg_edi, tf->tf_regs.reg_esi);
return;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_TIMER) {
lapic_eoi();
// Update the age of some physical pages
// If we fall below the thresholds, update more pages than usual
// This is somewhat arbitrary, we can tweak these numbers
// We also might want to increase the order of magnitude of the number of pages we update per clock tick
// This will require some testing and profiling
// There is also no reason why num_page_updates is based on the threshold values, it can be incremented by its own macros
if (num_free_pages <= NPAGESFREE_LOW_THRESHOLD) {
num_page_updates += NPAGEUPDATES_FACTOR*NPAGESFREE_HIGH_THRESHOLD;
}
if (num_free_pages <= NPAGESFREE_HIGH_THRESHOLD) {
num_page_updates += NPAGEUPDATES_FACTOR*NPAGESFREE_LOW_THRESHOLD;
}
for ( ; num_page_updates >= 0; --num_page_updates) {
// Find the next page that is currently mapped in user space, by finding one with a nonzero pp_ref
while (!pages[page_to_age].pp_ref) {
// If we wrap around to where we started, stop updating page ages
if ((page_to_age=(page_to_age+1)%npages) == page_to_age_first) {
goto end_of_page_age_updates;
}
}
// Iterate through all of the user space PTEs that map to this page
// If any of them have been accessed, increment the age, and then clear the PTE_A bit in all of the PTEs
page_accessed = 0;
for (pp_refs_chain = pages[page_to_age].pp_refs_chain; pp_refs_chain; pp_refs_chain = pp_refs_chain->pc_link) {
if (*pp_refs_chain->pc_pte & PTE_A) {
page_accessed = 1;
pages[page_to_age].age += PAGE_AGE_INCREMENT_ON_ACCESS;
for ( ; pp_refs_chain; pp_refs_chain = pp_refs_chain->pc_link) {
*(pp_refs_chain->pc_pte) &= ~PTE_A;
}
break;
}
}
pages[page_to_age].age = (pages[page_to_age].age > MAX_PAGE_AGE ? MAX_PAGE_AGE : pages[page_to_age].age);
if (!page_accessed) {
if (pages[page_to_age].age >= (uint8_t)PAGE_AGE_DECREMENT_ON_CLOCK) {
pages[page_to_age].age -= (uint8_t)PAGE_AGE_DECREMENT_ON_CLOCK;
}
else {
pages[page_to_age].age = 0;
}
}
// If we wrap around to where we started, stop updating page ages
if ((page_to_age=(page_to_age+1)%npages) == page_to_age_first) {
goto end_of_page_age_updates;
}
}
end_of_page_age_updates:
sched_yield();
}
// Handle keyboard and serial interrupts.
// LAB 5: Your code here.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_KBD) {
lapic_eoi();
kbd_intr();
return;
}
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SERIAL) {
lapic_eoi();
serial_intr();
return;
}
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
int32_t ret;
switch (tf->tf_trapno){
case T_PGFLT:{ //14
page_fault_handler(tf);
return;
}
case T_BRKPT:{ //3
breakpoint_handler(tf);
return;
}
case T_DEBUG:{
breakpoint_handler(tf);
return;
}
case T_SYSCALL:{
ret = system_call_handler(tf);
tf->tf_regs.reg_eax = ret;
return;
}
case IRQ_OFFSET+IRQ_TIMER:{
lapic_eoi();
time_tick();
sched_yield();
return;
}
case IRQ_OFFSET+IRQ_KBD:{
kbd_intr();
return;
}
case IRQ_OFFSET+IRQ_SERIAL:{
serial_intr();
return;
}
case IRQ_OFFSET+IRQ_E1000:{
e1000_trap_handler();
return;
}
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
// Add time tick increment to clock interrupts.
// Be careful! In multiprocessors, clock interrupts are
// triggered on every CPU.
// LAB 6: Your code here.
// Handle keyboard and serial interrupts.
// LAB 5: Your code here.
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
// TODO: chky
int r;
switch (tf->tf_trapno) {
case T_PGFLT:
page_fault_handler(tf);
break;
case T_BRKPT:
// TODO: lab3 ex6 challenge
monitor(tf);
break;
case T_SYSCALL:
r = syscall(tf->tf_regs.reg_eax, // syscallno
tf->tf_regs.reg_edx, // a1
tf->tf_regs.reg_ecx, // a2
tf->tf_regs.reg_ebx, // a3
tf->tf_regs.reg_edi, // a4
tf->tf_regs.reg_esi // a5
);
tf->tf_regs.reg_eax = r;
return;
default:
break;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
// TODO: chky
if (tf->tf_trapno == IRQ_OFFSET + IRQ_TIMER) {
lapic_eoi();
sched_yield();
return;
}
// chky end
// Handle keyboard and serial interrupts.
// LAB 5: Your code here.
// TODO: chky
if (tf->tf_trapno == IRQ_OFFSET + IRQ_KBD) {
kbd_intr();
return;
}
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SERIAL) {
serial_intr();
return;
}
// chky end
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
int32_t res;
// Handle processor exceptions.
// LAB 3: Your code here.
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
// Add time tick increment to clock interrupts.
// Be careful! In multiprocessors, clock interrupts are
// triggered on every CPU.
// LAB 6: Your code here.
// Handle keyboard and serial interrupts.
// LAB 5: Your code here.
//if(tf->tf_trapno == 48 && tf->tf_regs.reg_eax==7)
//{
//cprintf("trap no = %d at cpu %d env %x\n",tf->tf_trapno,cpunum(),curenv->env_id);
//print_trapframe(tf);
//}
switch(tf->tf_trapno)
{
case IRQ_OFFSET + IRQ_TIMER:
//cprintf("clock interrupt on irq 7 on cpu %d\n",cpunum());
//print_trapframe(tf);
//cprintf(" eip 0x%08x\n", tf->tf_eip);
//cprintf(" esp 0x%08x\n", tf->tf_esp);
lapic_eoi();
time_tick();
sched_yield();
break;
case IRQ_OFFSET + IRQ_SERIAL:
serial_intr(); break;
case IRQ_OFFSET + IRQ_KBD:
kbd_intr(); break;
case T_DIVIDE: tf->tf_regs.reg_ecx = 1; break;
case T_PGFLT: page_fault_handler(tf); goto err;
case T_SYSCALL:
res = syscall(tf->tf_regs.reg_eax,tf->tf_regs.reg_edx,tf->tf_regs.reg_ecx,tf->tf_regs.reg_ebx,tf->tf_regs.reg_edi,tf->tf_regs.reg_esi);
tf->tf_regs.reg_eax = res; break;
case T_BRKPT:print_trapframe(tf);monitor(NULL);break;
default: goto err;
}
return;
err:
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
int32_t ret;
// if (tf->tf_trapno != 48) cprintf("****** No. %d\n", tf->tf_trapno);
// Handle clock interrupts.
// LAB 4: Your code here.
if (tf->tf_trapno == IRQ_OFFSET + 0){
// cprintf("Timer interrupt\n");
time_tick();
sched_yield();
return ;
}
// Add time tick increment to clock interrupts.
// LAB 6: Your code here.
// Add time_tick above sched_yield
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// LAB 7: Keyboard interface
if (tf->tf_trapno == IRQ_OFFSET + 1){
kbd_intr();
return ;
}
if (tf->tf_trapno == IRQ_OFFSET + 4){
serial_intr();
return ;
}
if (tf->tf_trapno == T_DIVIDE || tf->tf_trapno == T_ILLOP || tf->tf_trapno == T_GPFLT){
// cprintf("*************");
// return ;
}
if (tf->tf_trapno == T_DEBUG){
// Debug info
// cprintf("*** trap %08x %s ***\n", tf->tf_trapno, trapname(tf->tf_trapno));
// Invoke monitor
monitor(tf);
return ;
}
if (tf->tf_trapno == T_BRKPT){
// Debug info
// cprintf("*** trap %08x %s ***\n", tf->tf_trapno, trapname(tf->tf_trapno));
// Invoke monitor
monitor(tf);
return ;
}
if (tf->tf_trapno == T_PGFLT){
page_fault_handler(tf);
}
if (tf->tf_trapno == T_SYSCALL){
ret = syscall(tf->tf_regs.reg_eax,
tf->tf_regs.reg_edx,
tf->tf_regs.reg_ecx,
tf->tf_regs.reg_ebx,
tf->tf_regs.reg_edi,
tf->tf_regs.reg_esi);
tf->tf_regs.reg_eax = ret;
return ;
}
// Handle keyboard and serial interrupts.
// LAB 7: Your code here.
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT){
if (tf->tf_trapno == T_DEBUG){
return ;
}
panic("unhandled trap in kernel");
}
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
//---------------------------------------- Lab3 ------------------------------------------------------------
if (tf->tf_trapno == T_PGFLT) {
//cprintf("pagefault!\n");
page_fault_handler(tf);
return;
}
if (tf->tf_trapno == T_BRKPT) {
//cprintf("brkpt!\n");
monitor(tf);
return;
}
if (tf->tf_trapno == T_DEBUG) {
my_monitor(tf);
return;
}
if (tf->tf_trapno == T_SYSCALL) {
//cprintf("Syscall!\n");
tf->tf_regs.reg_eax = syscall(tf->tf_regs.reg_eax, tf->tf_regs.reg_edx, tf->tf_regs.reg_ecx,
tf->tf_regs.reg_ebx, tf->tf_regs.reg_edi, tf->tf_regs.reg_esi);
if (tf->tf_regs.reg_eax < 0)
panic("syscall failed: %e\n", tf->tf_regs.reg_eax);
return;
}
//---------------------------------------- Lab3 ------------------------------------------------------------
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
//------------ Lab4 ----------------------------------------------------------------------------------------
if (tf->tf_trapno == IRQ_OFFSET + IRQ_TIMER) {
// cprintf("clock interrupt!\n");
lapic_eoi();
sched_yield();
return;
}
//------------ Lab4 ----------------------------------------------------------------------------------------
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
// dec 15,2010 sunus
switch(tf->tf_trapno)
{
case T_PGFLT :
{
page_fault_handler(tf);
break;
}
case T_DEBUG :
cprintf("encounter a breakpoint!\n"); /*fall through*/
case T_BRKPT :
{
monitor(tf);
break;
}
case T_SYSCALL :
{
(tf->tf_regs).reg_eax =
syscall(
(tf->tf_regs).reg_eax,
(tf->tf_regs).reg_edx,
(tf->tf_regs).reg_ecx,
(tf->tf_regs).reg_ebx,
(tf->tf_regs).reg_edi,
(tf->tf_regs).reg_esi);
return ;
}
default : ; /* do nothing */
}
// Handle clock interrupts.
// LAB 4: Your code here.
// JAN 30,2011,SUNUS
if(tf->tf_trapno == IRQ_OFFSET + IRQ_TIMER)
{
sched_yield();
return;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
if (tf->tf_trapno == T_BRKPT) {
print_trapframe(tf);
// cprintf("Breakpoint!\n");
while (1)
monitor(NULL);
} else if (tf->tf_trapno == T_PGFLT) {
page_fault_handler(tf);
return;
} else if (tf->tf_trapno == T_SYSCALL) {
uint32_t syscallno;
uint32_t a1, a2, a3, a4, a5;
syscallno = tf->tf_regs.reg_eax;
a1 = tf->tf_regs.reg_edx;
a2 = tf->tf_regs.reg_ecx;
a3 = tf->tf_regs.reg_ebx;
a4 = tf->tf_regs.reg_edi;
a5 = tf->tf_regs.reg_esi;
int32_t ret = syscall(syscallno, a1, a2, a3, a4, a5);
tf->tf_regs.reg_eax = ret;
return;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_TIMER) {
time_tick();
lapic_eoi(); /* what's that? */
sched_yield();
}
// Handle keyboard and serial interrupts.
// LAB 5: Your code here.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_KBD) {
kbd_intr();
return;
}
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SERIAL) {
serial_intr();
return;
}
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
void int0E(registers* regs) {
page_fault_handler(regs->errCode);
return;
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
//<<<<<<< HEAD
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
//cprintf("entering trap dispathc\n");
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
//<<<<<<< HEAD
// Add time tick increment to clock interrupts.
// Be careful! In multiprocessors, clock interrupts are
// triggered on every CPU.
// LAB 6: Your code here.
//=======
//<<<<<<< HEAD
//>>>>>>> lab5
// Handle keyboard and serial interrupts.
// LAB 5: Your code here.
if(tf->tf_trapno==IRQ_OFFSET+IRQ_KBD)
{
//cprintf("IRQ_OFFSET+IRQ_KBD trap\n");
kbd_intr();
return;
}
if(tf->tf_trapno==IRQ_OFFSET+IRQ_SERIAL)
{
//cprintf("IRQ_OFFSET+IRQ_serial trap\n");
serial_intr();
return;
}
//=======
//=======
if(tf->tf_trapno==T_PGFLT)
{
// cprintf("pagefault handler\n");
page_fault_handler(tf);
return;
} else if((tf->tf_trapno==T_GPFLT)) {
print_trapframe(tf);
return;
}
else if(tf->tf_trapno==T_BRKPT)
{
// cprintf("T_BRKPT");
monitor(tf);
return;
}
else if(tf->tf_trapno==T_SYSCALL)
{// cprintf("calling syscal'\n");
tf->tf_regs.reg_rax =syscall(tf->tf_regs.reg_rax,tf->tf_regs.reg_rdx,tf->tf_regs.reg_rcx,tf->tf_regs.reg_rbx,tf->tf_regs.reg_rdi,tf->tf_regs.reg_rsi);
// cprintf("syscall exit\n");
return;
}
//>>>>>>> lab3
//>>>>>>> lab4
// Unexpected trap: The user process or the kernel has a bug.
else if(tf->tf_trapno == IRQ_OFFSET + IRQ_TIMER)
{
lapic_eoi();
time_tick();
sched_yield();
}
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
cprintf("destroy env\n");
env_destroy(curenv);
return;
}
// cprintf("exiting trap_dispatch\n");
}
static void
trap_dispatch(struct Trapframe *tf)
{
uint32_t temp;
// Switch on the trap number
switch(tf->tf_trapno) {
case T_DEBUG:
// Unset the step flag in EFLAGS before entering the monitor
tf->tf_eflags &= ~FL_TF;
case T_BRKPT:
// Use breakpoints and debug interrupts as a shortcut to
// start the kernel monitor
monitor(tf);
return;
case T_PGFLT:
// Handle page faults with their own handler.
page_fault_handler(tf);
return;
case T_SYSCALL:
// For system calls, pass arguments to the syscall handler
// and return the result in register EAX.
//
// The number must be stored away, and tf->tf_regs.reg_eax
// set to 0 before the call. This is because some system
// calls such as sys_ipc_recv don't return (due to a call to
// sched_yield()), but expect to return 0 for the return value.
// If reg_eax is not cleared, then whatever is in it might be
// mistaken for the return value. -_-
temp = tf->tf_regs.reg_eax;
tf->tf_regs.reg_eax = 0;
tf->tf_regs.reg_eax = syscall(temp,
tf->tf_regs.reg_edx,
tf->tf_regs.reg_ecx,
tf->tf_regs.reg_ebx,
tf->tf_regs.reg_edi,
tf->tf_regs.reg_esi);
return;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
if(tf->tf_trapno == IRQ_OFFSET+IRQ_TIMER) {
// Timer interrupts should cause the scheduler to be run
lapic_eoi();
sched_yield();
}
// Handle keyboard and serial interrupts.
if(tf->tf_trapno == IRQ_OFFSET+IRQ_KBD) {
// kern/console.c function that handles the keyboard
kbd_intr();
return;
}
if(tf->tf_trapno == IRQ_OFFSET+IRQ_SERIAL) {
// kern/console.c function that handles serial input
serial_intr();
return;
}
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
switch(tf->tf_trapno) {
case T_PGFLT:
page_fault_handler(tf);
return;
case T_BRKPT:
case T_DEBUG:
monitor(tf);
return;
case T_SYSCALL:
tf->tf_regs.reg_eax = syscall(tf->tf_regs.reg_eax, // syscall #
tf->tf_regs.reg_edx, // arg1
tf->tf_regs.reg_ecx, // arg2
tf->tf_regs.reg_ebx, // arg3
tf->tf_regs.reg_edi, // arg4
tf->tf_regs.reg_esi);// arg5
return;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// Add time tick increment to clock interrupts.
// Be careful! In multiprocessors, clock interrupts are
// triggered on every CPU.
// LAB 4: Your code here.
// LAB 6: Your code here.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_TIMER) {
time_tick();
lapic_eoi();
sched_yield();
return;
}
// Handle keyboard and serial interrupts.
// LAB 7: Your code here.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SERIAL) {
serial_intr();
return;
}
if (tf->tf_trapno == IRQ_OFFSET + IRQ_KBD) {
kbd_intr();
return;
}
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
int32_t sc_ret;
assert(tf != NULL);
switch (tf->tf_trapno) {
case T_PGFLT:
page_fault_handler(tf);
return;
case T_BRKPT:
case T_DEBUG:
/* break into the kernel monitor */
while (1) {
monitor(tf);
}
return;
case T_SYSCALL:
sc_ret = syscall(tf->tf_regs.reg_eax, tf->tf_regs.reg_edx,
tf->tf_regs.reg_ecx, tf->tf_regs.reg_ebx,
tf->tf_regs.reg_edi, tf->tf_regs.reg_esi);
tf->tf_regs.reg_eax = sc_ret;
return;
default:
break;
}
// Handle clock interrupts.
// LAB 4: Your code here.
// Add time tick increment to clock interrupts.
// LAB 6: Your code here.
switch (tf->tf_trapno) {
case (IRQ_OFFSET + IRQ_TIMER):
time_tick();
sched_yield();
return;
case (IRQ_OFFSET + IRQ_KBD):
//cprintf("Keyboard interrupt on irq %d\n", IRQ_KBD);
kbd_intr();
return;
case (IRQ_OFFSET + IRQ_SERIAL):
//cprintf("Serial interrupt on irq %d\n", IRQ_SERIAL);
serial_intr();
return;
default:
break;
}
if (tf->tf_trapno == (IRQ_OFFSET + e100_irq_line)) {
cprintf("E100 interrupt on irq %d\n", e100_irq_line);
return;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle keyboard and serial interrupts.
// LAB 7: Your code here.
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
static void
trap_dispatch(struct Trapframe *tf)
{
// Handle processor exceptions.
// LAB 3: Your code here.
//print_trapframe(tf);
if(tf->tf_trapno == T_PGFLT)
{
page_fault_handler(tf);
}
else if(tf->tf_trapno == T_BRKPT)
{
monitor(tf);
}
else if(tf->tf_trapno == T_SYSCALL)
{
tf->tf_regs.reg_rax = syscall(tf->tf_regs.reg_rax, tf->tf_regs.reg_rdx,
tf->tf_regs.reg_rcx, tf->tf_regs.reg_rbx,
tf->tf_regs.reg_rdi, tf->tf_regs.reg_rsi);
return;
}
// Handle spurious interrupts
// The hardware sometimes raises these because of noise on the
// IRQ line or other reasons. We don't care.
if (tf->tf_trapno == IRQ_OFFSET + IRQ_SPURIOUS) {
cprintf("Spurious interrupt on irq 7\n");
print_trapframe(tf);
return;
}
// Handle clock interrupts. Don't forget to acknowledge the
// interrupt using lapic_eoi() before calling the scheduler!
// LAB 4: Your code here.
// Handle keyboard and serial interrupts.
// LAB 5: Your code here.
else if(tf->tf_trapno == (IRQ_OFFSET + IRQ_TIMER))
{
lapic_eoi();
sched_yield();
}
else if(tf->tf_trapno == (IRQ_OFFSET + IRQ_KBD))
{
kbd_intr();
sched_yield();
}
else if(tf->tf_trapno == (IRQ_OFFSET + IRQ_SERIAL))
{
serial_intr();
sched_yield();
}
// Unexpected trap: The user process or the kernel has a bug.
print_trapframe(tf);
if (tf->tf_cs == GD_KT)
panic("unhandled trap in kernel");
else {
env_destroy(curenv);
return;
}
}
