src/arch/x86/except_c.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       except_c.cpp, version 1.1                          *
************************************************************
*                                                          *
*interruption handler chaining                             *
*                                                          *
*03'05'04- forked from o.05 branch.s except_c.cpp(1.1)     *
*                                                          *
***********************************************************/

/*
We manage exceptions and irqs this way:
chain_handler() tries to invoke first_handler. if no success:
there is a list of possible handler @ int_lists, which is a linked list.
the chain_handler() invokes each of them until one of them returns ESUCCESS.
this means that the handler found was able to resolve the problem.
on start, the last handler for exceptions hangs the comp with some debug msgs,
and the last handler for irqs does nothing and returns ESUCCESS.
*/

#include "src/common/shared.hpp"
#include "src/arch/x86/gdt.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/heap.hpp"
#include "src/memory/pager.hpp"
#include "src/common/io.hpp"
#include "src/thread/thread.hpp"
#include "src/thread/process.hpp"
#include "src/thread/scheduler.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/irq.hpp"


void (*exc)();
void (*irq_h)();

namespace Arch {
namespace x86 {
namespace Interr {


list_t* int_lists[0x31]; 
int (*first_routine[0x31])(except2_t*); /*list of procs to be executed as first-try for each interrupt*/
const char *except_names[0x20] =
        {"division error", "unhandled debug exception", "non-maskable interrupt",
        "unhandled breakpoint", "overflow", "bounds check", "invalid opcode",
        "coprocessor not availlable", "double fault", "coprocessor segment overrun",
        "invalid TSS", "segment not present", "stack exception","General Protection Fault",
        "invalid page fault", "unhandled unknown", "coprocessor error", "alignment check",
        "machine check", "SIMD floating-point exception", "unhandled unknown",
        "unhandled unknown", "unhandled unknown", "unhandled unknown","unhandled unknown",
        "unhandled unknown", "unhandled unknown", "unhandled unknown","unhandled unknown",
        "unhandled unknown", "unhandled unknown", "unhandled unknown"};

// extern "C" void pr (int i);
// void pr (int i) 
//  {
//              cout("(");
//              cout(i);
//              cout(")");
//   }

bool inInterruptHandler=false;

bool isInInterruptHandler() {
   return inInterruptHandler;
}

char stackSpace[STACKSZ*STACKCNT];
char *stackPtr[STACKCNT]={&stackSpace[STACKSZ*1],&stackSpace[STACKSZ*2],
                                &stackSpace[STACKSZ*3],&stackSpace[STACKSZ*4],
                                &stackSpace[STACKSZ*5],&stackSpace[STACKSZ*6],
                                &stackSpace[STACKSZ*7],&stackSpace[STACKSZ*8],
                                &stackSpace[STACKSZ*9],&stackSpace[STACKSZ*10],
                                &stackSpace[STACKSZ*11],&stackSpace[STACKSZ*12],
                                &stackSpace[STACKSZ*13],&stackSpace[STACKSZ*14],
                                &stackSpace[STACKSZ*15],&stackSpace[STACKSZ*16]};
uint32 volatile stackVac=0;
char *stack1;
char *reta;
struct chh_t cd1;

//note: the following functions and it's asm stub has to run under IF=0 before the stack contents have been made a copy
//and after they have been copied back. This is because, before we change the stack we will probably run
//on some static buffer. If IF=1, chain_handler would reenter and destroy the data we put there.
void chain2(struct chh_t *code);
void chain_handler(struct chh_t code)
 {
//      cout(">");
//      cout(code.c1);
        asm volatile("mov %%ebp, %%eax":"=a"(reta));
        memmove(&cd1, &code, sizeof(struct chh_t));
//first, check if there's a bloody, free stack availlable
        if(stackVac>=STACKCNT)
                sysfail("no free stacks for the interrupt");
//use the bloody stack
        stack1= stackPtr[stackVac];
        stackVac++;

//get a shot for the damn stack
        asm volatile ("mov %%eax, %%esp"::"a"(stack1-sizeof(struct except2_t)));
        asm volatile("mov %esp, %ebp"); //for the tracing subsystem

//<------ WOHOO! we are on our private stack now.
        chain2(&code);
 }

void chain2(struct chh_t *code)
 {
char StackCopy[CHAINHANDLERSTACKCOPY];
//save the stack contents, so that chain_handler will be able to reenter. do it only for user stacks,
//because a kernel stack won't be a static char STACK[100].
        if (code->cs != GDT::code_sel_kernel)
                memmove(&StackCopy,reta, CHAINHANDLERSTACKCOPY);

struct except2_t *cd2=(struct except2_t*)stack1;
//copy the data. They are on a common stack which will be soon probably overwritten.
        memmove(&cd2->r,&cd1.r, sizeof(struct reg_dump));
        cd2->c1=cd1.c1;
        cd2->c2=cd1.c2;
        cd2->ebp=cd1.ebp;
        cd2->stack=stack1;
        cd2->reta=reta;
        cd2->eip=cd1.eip;
        cd2->cs=cd1.cs;
        cd2->eflags=cd1.eflags;
        if (cd2->cs == GDT::code_sel_kernel) {
                cd2->ss= GDT::data_sel_kernel;
                cd2->esp= cd2->r.r_temp_esp;    //doh, i don't know what offset of the stack it is
         } else {
                cd2->esp=*(uint32*)(reta+sizeof(struct chh_t)+sizeof(int)*2);   //call:eip,ebp
                cd2->ss=*(uint32*)((uint32)&code+sizeof(code)+sizeof(int)*3);   //call:eip,ebp; esp
          }

        asm volatile("movl %%cr2, %%eax":"=a"(cd2->cr2));

//save code ptr
        if (::Thread::Scheduler::multitasking_running)
                current_thread->env.cd= cd2;
   inInterruptHandler=true;
/*EXEC HANDLERS*/
list_t *item;
/*try the run_first routine*/
        if ( !((((uint32*)(first_routine))[cd2->c1])&&
                                (((first_routine[cd2->c1](cd2)) == ESUCCESS))) )
/*try the handlers*/
        for (item = int_lists[cd2->c1];item; item = item -> next)
                if((item->proc(cd2) == ESUCCESS)) break;
        asm volatile("cli");    //what if the handlers enabled ints?

   inInterruptHandler=false;

/*if this an irq, send eoi*/
        if (cd2->c1 >= 0x20) IOPorts::outb(0x20, 0x20);
        if (cd2->c1 >= 0x28) IOPorts::outb(0xa0, 0x20);

/* cleanup */
        stackVac--;
        stackPtr[stackVac]=cd2->stack;
        if (::Thread::Scheduler::multitasking_running)
                current_thread->env.cd= NULL;

//restore the stack contents
        if (code->cs != GDT::code_sel_kernel)
                memmove(cd2->reta, StackCopy, CHAINHANDLERSTACKCOPY);
//if any changes were made to the reg_dump struct, copy the changes
        memmove((char*)cd2->reta+CHAINREGCOPY, &cd2->r, sizeof(struct reg_dump));

        asm volatile ("mov %%eax, %%ebp"::"a"(cd2->reta));
//      cout("<");
//      cout(code.c1);
 }

// void chain_handler(except_t *code)
//  {
// list_t *item;
//      cout(" >");cout(code->uu.iret->code);
// /*try the run_first routine*/
//      if ( !((((uint32*)(first_routine))[code->uu.iret->code])&&
//                              (((first_routine[code->uu.iret->code](code)) == ESUCCESS))) )
// /*try the handlers*/
//      for (item = int_lists[code -> uu.iret->code];item; item = item -> next)
//              if((item->proc(code) == ESUCCESS)) break;
// /*if this an irq, send eoi*/
//      if (code -> uu.iret->code >= 0x20) IOPorts::outb(0x20, 0x20);
//      if (code ->uu.iret->code >= 0x28) IOPorts::outb(0xa0, 0x20);
//      cout(" <");cout(code->uu.iret->code);
//  }

//add a handler to the chain as the first handler.
uint32 add2interr_chain(uint32 int_no, int(*proc)(except2_t*))
 {
list_t *item;

/*create and add a new item*/
        item = (list_t*) Memory::Heap::heap0.malloc(sizeof(list_t),NO_ALIGN, FAC_INTERR|FAC_EXCLIST, NULL);
        item -> next = int_lists[int_no];
        item -> proc = proc;
        int_lists[int_no] = item;

        return (uint32) item;
                //this is the value we use later to delete
                //handlers from chain
 }
 
/*install first routine handler*/
void install_first_routine(uint32 n, uint32 (*proc)(except2_t*))
 {
/*install to first_routine list*/
        ((uint32*)first_routine)[n]=(uint32)proc;
 }

//delete a handler from the chain
uint32 del_chainHdl(uint32 int_no, uint32 ptr)
 {
list_t *item, *prev;

        prev = (list_t*) NULL;
        item = int_lists[int_no];
        while (item)
         {
         /*is this the hanlder we're lookin for?*/
                if (item == (list_t*) ptr)
                 {
                        //this is when the handler is not first
                        if (prev) prev->next = item -> next;
                                else
                                //when we are deleting the first handler
                                int_lists[int_no] = item -> next;

                        Memory::Heap::heap0.free(item);
                        return ESUCCESS;
                 }
                prev = item;
                item = item -> next;
         }
        return (uint32)EINVAL;
 }

/*temporary unhandled exception*/
int Exception(except2_t *code)
 {
        asm volatile("cli");
        TTYDisableLock=true;
/*tell us wtf is wrong*/
        alert ("\nSYSFAIL");
   alert(" (sysfail_dbg=");
   alert2(sysfail_dbg);
   alert(")");
        alert ("\nexception condition #");
        coutb (code->c1);
        write_bochs_num(code->c1, 16, 256, 'A');
        alert ("- ");
        alert ((char*) except_names[code->c1]);
        alert("\n%eip=0x");alert(code->eip);
//      kprintf(", eip: %x, val: %x\n", code->uu.iret->thread_eip, code->uu.iret->val);
// /*call trace*/
//      if (code->uu.iret->thread_cs == Arch::x86::GDT::code_sel_kernel)
//              /*sanity check- kernel mode exception*/
//      debug_dump_call_trace(code->eip, code->r.r_ebp);

/*dieee, slowly and painfully*/
        panic();
        return ESUCCESS;
 }

//for invalid page faults
int PageFault(except2_t *code)
 {
        asm volatile("cli");
        TTYDisableLock=true;    // the console routines will disrespect locks. we don't want to cout() from an exception handler when it's locked
static int level=0;
        level++;
        if (level==2)
                sysfail("double invalid page fault");
        if (level==3)
         {
                alert("\ntriple invalid page fault");
                asm volatile ("cli\nhlt");
         }
        alert("\nSYSFAIL");
   alert(" (sysfail_dbg=");
   alert2(sysfail_dbg);
   alert(")");
        alert("\npage fault, %eip=0x");
        alert(code->eip);
        alert(", %cr2=0x");alert(code->cr2);
        /*call trace*/
        if (code->cs == Arch::x86::GDT::code_sel_kernel)
                /*sanity check- kernel mode exception*/
   alert(" PF ");
        debug_dump_call_trace(code->eip, code->r.r_ebp);
//      if (code->uu.iret->code == INT_PF)
//       {
//      //some info
//              cout("offending ");
//      //read/write
//              if (code->cr2 & PTE_WRITEABLE)
//                      cout("write");
//              else
//                      cout("read");
//              cout (" in ");
//      //kernel/user
//              if (code->cr2 & PTE_USER)
//                      cout("user");
//              else
//                      cout("supervisor");
//              cout(" mode- ");
//      //not present/protection
//              if (code->cr2 & PTE_PRESENT)
//                      cout("page level protection violation");
//              else
//                      cout("page not present");
//              kprintf(" at %0x\n", code->cr2);
//       }

//      asm volatile ("cli\nhlt");
        for(;;);
        return ESUCCESS;
 }

//for stack/double faults
void double_fault()
 {
        TTYDisableLock=true;
//put the error logo in the upper left corner
        (*(uint8*)0xb8004)='D'; (*(uint8*)0xb8005)=' ';
        (*(uint8*)0xb8006)='F'; (*(uint8*)0xb8007)=' ';
        (*(uint8*)0xb8008)='E'; (*(uint8*)0xb8009)=' ';
        (*(uint8*)0xb800a)='X'; (*(uint8*)0xb800b)=' ';
//complain
        alert("\nSYSFAIL\ndouble fault\n");
   alert(" (sysfail_dbg=");
   alert2(sysfail_dbg);
   alert(")\n");
        alert( mem_ksize);
//halt
        asm volatile ("cli\nhlt");
        for(;;);
 }

//for kernel stack faults
void stack_fault()
 {
        TTYDisableLock=true;
struct
 {
//double_fault frame:
        uint32 old_ebp;         //push %ebp
//iret frame:
        uint32 thread_eip;
        uint32 thread_cs;
        uint32 thread_eflags;
//optional- for user threads:
        uint32 thread_3_esp;
        uint32 thread_3_ss;
 } *stack_frame;                //doesn't work!!!!

//get the stack_frame
        asm volatile ("mov %%ebp, %%eax": "=a" (stack_frame));
//put the error logo in the upper left corner
        (*(uint8*)0xb8004)='S'; (*(uint8*)0xb8005)=' ';
        (*(uint8*)0xb8006)='F'; (*(uint8*)0xb8007)=' ';
        (*(uint8*)0xb8008)='E'; (*(uint8*)0xb8009)=' ';
        (*(uint8*)0xb800a)='X'; (*(uint8*)0xb800b)=' ';
//complain
        alert("\nSYSFAIL\nstack fault\n");
   alert(" (sysfail_dbg=");
   alert2(sysfail_dbg);
   alert(")\n");
        alert((uint32)stack_frame);
        alert((char*)&current_thread->name);
        /*&Memory::Heap::heap0*/
        /*&current_thread->proc->heap*/
        debug_heap_stats(&::Thread::heap);
//halt
        asm volatile ("cli\nhlt");
        for(;;);
 }

//nop handler for irqs
int Irq_H(except2_t *code)
 {
//      kprintf("irq 0x%x: nobody cared!\n", code->c1-0x20);
        return ESUCCESS;
 }

extern "C" int SysEnter(except2_t *code);

//init interrupt chaining
void init_int_chains(idt_service *ptr)
 {
uint32 n;
/*clear first-routine list*/
        for (n=0; n<0x30; n++)
                ((uint32*)&first_routine)[n] = NULL;
/*possible to disable exceptions*/
#ifndef DISABLE_EXCEPTIONS
/*install exception handlers*/
        ptr->set_int(0x00, &intr0x00, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x01, &intr0x01, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x02, &intr0x02, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x03, &intr0x03, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x04, &intr0x04, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x05, &intr0x05, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x06, &intr0x06, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x07, &intr0x07, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
//special for double exception; task gate
        ptr->set_int(0x08, NULL, Arch::x86::GDT::tss_sel_kernel_df, 0x8500);
        ptr->set_int(0x09, &intr0x09, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x0a, &intr0x0a, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x0b, &intr0x0b, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
//special for stack exception; task gate
        ptr->set_int(0x0c, NULL, Arch::x86::GDT::tss_sel_kernel_sf, 0x8500);
        ptr->set_int(0x0d, &intr0x0d, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);

        ptr->set_int(0x0f, &intr0x0f, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x10, &intr0x10, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x11, &intr0x11, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x12, &intr0x12, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x13, &intr0x13, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x14, &intr0x14, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x15, &intr0x15, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x16, &intr0x16, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x17, &intr0x17, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x18, &intr0x18, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x19, &intr0x19, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x1a, &intr0x1a, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x1b, &intr0x1b, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x1c, &intr0x1c, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x1d, &intr0x1d, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x1e, &intr0x1e, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x1f, &intr0x1f, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
#endif
        ptr->set_int(0x0e, &intr0x0e, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);

        ptr->set_int(0x20, &intr0x20, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x21, &intr0x21, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x22, &intr0x22, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x23, &intr0x23, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x24, &intr0x24, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x25, &intr0x25, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x26, &intr0x26, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x27, &intr0x27, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x28, &intr0x28, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x29, &intr0x29, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x2a, &intr0x2a, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x2b, &intr0x2b, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x2c, &intr0x2c, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x2d, &intr0x2d, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x2e, &intr0x2e, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);
        ptr->set_int(0x2f, &intr0x2f, Arch::x86::GDT::code_sel_kernel, DEF_INT_FLAGS);

/*install the chain_handler*/
        ptr->install_except((void(*)())&chain_handler);

/*install chains for exceptions; page fault handler will be changed later*/
        for (n=0; n<0x20; n++)
         {
                int_lists[n] = (list_t*)Memory::Heap::heap0.malloc(sizeof(list_t),NO_ALIGN,FAC_INTERR|FAC_EXCLIST, NULL);
                int_lists[n]->next = 0;
                int_lists[n]->proc = &Exception;
         }

/*change the handler for page fault handler*/
        int_lists[INT_PF]->proc= &PageFault;

/*interrupt chains for irqs*/
        for (n=0x20; n<0x30; n++)
         {
                int_lists[n] = (list_t*)Memory::Heap::heap0.malloc(sizeof(list_t),NO_ALIGN,FAC_INTERR|FAC_EXCLIST, NULL);
                int_lists[n]->next = 0;
                int_lists[n]->proc = &Irq_H;
         }
/* exclusive- 0x30 for sysenter. Although int 0x30 would might invoke the handler, the DPL is an issue and also
the handler will try to sysexit after the int. */
        int_lists[SYSENT]= (list_t*)Memory::Heap::heap0.malloc(sizeof(list_t),NO_ALIGN,FAC_INTERR|FAC_EXCLIST, NULL);
        int_lists[SYSENT]->next = 0;
        int_lists[SYSENT]->proc = &SysEnter;
 }

//destruct the interrupt chaining technologies
void done_int_chains()
 {
/*disable all irqs*/
        __asm__ __volatile__ ("cli");   /*from now on we do not have
                                                                         *exception handling*/
        IOPorts::outb(DEF_PIC_M_PORT+1, 0xff);
        IOPorts::outb(DEF_PIC_S_PORT+1, 0xff);

uint32 n;
list_t *item, *temp;
/*free all the lists*/
        for (n=0; n< 0x30; n++)
         {
                item = int_lists[n];
                while (item)
                 {
                        temp = item -> next;
                        Memory::Heap::heap0.free(item);
                        item = temp;
                 }
         }
 }


   };   /*namespace Interr*/
  };    /*namespace x86*/
 };     /*namespace Arch*/

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---