src/arch/x86/except_c old.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/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[0x30]; 
int (*first_routine[0x30])(except_t*);  /*list of procs to be executed as first-try for each interrupt*/
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(")");
  }
  
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)(except_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)(except_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(except_t *code)
 {
/*tell us wtf is wrong*/
        cout ("\nSYSFAIL");
        cout ("\nexception condition #");
        coutb (code->uu.iret->code);
        cout ("- ");
        cout ((char*) except_names[code->uu.iret->code]);
        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->uu.iret->thread_eip, code->uu.iret->regs.r_ebp);

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

//for invalid page faults
int PageFault(except_t *code)
 {
static int level=0;
        level++;
        if (level==2)
                sysfail("double invalid page fault");
        if (level==3)
         {
                cout("\ntriple invalid page fault");
                asm volatile ("cli\nhlt");
         }
        cout("\nSYSFAIL");
        cout("\npage fault, %eip=0x");
        cout(code->uu.iret->thread_eip);
        cout(", %cr2=0x");
        cout(code->cr2);
        /*call trace*/
        if (code->uu.iret->thread_cs == Arch::x86::GDT::code_sel_kernel)
                /*sanity check- kernel mode exception*/
        debug_dump_call_trace(code->uu.iret->thread_eip, code->uu.iret->regs.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");
        return ESUCCESS;
 }

//for stack/double faults
void double_fault()
 {
//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
        cout("\nSYSFAIL\ndouble fault\n");
        cout( mem_ksize);
//halt
        asm volatile ("cli\nhlt");
        for(;;);
 }

//for kernel stack faults
void stack_fault()
 {
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
        cout("\nSYSFAIL\nstack fault\n");
        cout((uint32)stack_frame);
        cout((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(except_t *code)
 {
        return ESUCCESS;
 }

//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;
         }
 }

//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                          *
*                                                          *
***********************************************************/

---