---

exception.c

Go to the documentation of this file.

/*!     \file arch/i386/kernel/exception.c
 *      \brief Exceptions manager.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2004-01-24
 *      \note Copyright (&copy;) 2003 Andrea Righi
 *
 * \n<b>From: &lt;INTEL 80386 PROGRAMMER'S REFERENCE MANUAL 1986&gt;</b>
 * <table>
 * <tr><td><b>Identifier</b></td><td><b>Description</b></td></tr>
 *
 * <tr><td align="center">0</td><td>Divide error</td>
 * <tr><td align="center">1</td><td>Debug exception</td>
 * <tr><td align="center">2</td><td>Nonmaskable interrupt</td>
 * <tr><td align="center">3</td><td>Breakpoint (one-byte INT 3 instruction)</td>
 * <tr><td align="center">4</td><td>Overflow (INTO instruction)</td>
 * <tr><td align="center">5</td><td>Bounds check (BOUND instruction)</td>
 * <tr><td align="center">6</td><td>Invalid opcode</td>
 * <tr><td align="center">7</td><td>Coprocessor not available</td>
 * <tr><td align="center">8</td><td>Double fault</td>
 * <tr><td align="center">9</td><td>(reserved)</td>
 * <tr><td align="center">10</td><td>Invalid TSS</td>
 * <tr><td align="center">11</td><td>Segment not present</td>
 * <tr><td align="center">12</td><td>Stack exception</td>
 * <tr><td align="center">13</td><td>General protection</td>
 * <tr><td align="center">14</td><td>Page fault</td>
 * <tr><td align="center">15</td><td>(reserved)</td>
 * <tr><td align="center">16</td><td>Coprecessor error</td>
 *
 * <tr><td align="center">17-31</td><td>(reserved)</td>
 * <tr><td align="center">32-255</td><td>Available for external interrupts via INTR pin</td>
 *
 * </table>
 */

#include <const.h>

#include <kernel/console.h>
#include <kernel/task.h>

#include <arch/i386.h>
#include <arch/interrupt.h>
#include <arch/mem.h>
#include <arch/paging.h>
#include <arch/v86.h>

#include <arch/exception.h>

/** \ingroup Kernel
 *  \defgroup KException Exception Manager
 *  The exception manager.
 *  @{
 */

//! \brief Panic routine.
/**
 *      The task that calls this routine must be killed.
 *      If it is invoked by the kernel we can only halt
 *      the system!
 */
void panic()
{
        // The task should be killed.
        kprintf("\n\rTask [%s] (%i) killed!\n\r", get_pname(), get_pid());
        if ( get_pid() )
                auto_kill( 1 );
        else
                halt();
}

//! \brief
//!     Dump the CPU registers.
//! \param c The context of the current task after an exception.
static __inline__ void dump_registers( exc_context_t *c )
{
        register uint16_t ss;
        register uint32_t cr0, cr2, cr3, cr4;

        // Save stack segment register.
        __asm__ __volatile__ ("movw %%ss, %0": "=&r"(ss) : );

        // Save control registers.
        __asm__ __volatile__ ("movl %%cr0, %0" : "=&r"(cr0) : );
        __asm__ __volatile__ ("movl %%cr2, %0" : "=&r"(cr2) : );
        __asm__ __volatile__ ("movl %%cr3, %0" : "=&r"(cr3) : );
        __asm__ __volatile__ ("movl %%cr2, %0" : "=&r"(cr4) : );

        // Dump registers.
        kprintf("\n\reax = %#010x  ds = %#010x  cr0 = %#010x  esp    = %#010x", c->eax, c->ds, cr0, c->esp);
        kprintf("\n\rebx = %#010x  es = %#010x  cr2 = %#010x  ebp    = %#010x", c->ebx, c->es, cr2, c->ebp);
        kprintf("\n\recx = %#010x  fs = %#010x  cr3 = %#010x  eip    = %#010x", c->ecx, c->fs, cr3, c->eip);
        kprintf("\n\redx = %#010x  gs = %#010x  cr4 = %#010x  eflags = %#010x", c->edx, c->gs, cr4, c->eflags);
        kprintf("\n\resi = %#010x  ss = %#010x  exc = %#010x", c->esi, ss, c->EXC);
        kprintf("\n\redi = %#010x  cs = %#010x  err = %#010x", c->edi, c->cs, c->err_code);
}

//! \brief
//!     This is the default exception handler. It is invoked
//!     every time an exception occurs. The kernel must route the
//!     exececution to the opportune procedures to correctly manage
//!     the exception.
//! \param c The context of the current task after an exception.
void default_exception(exc_context_t *c)
{
        switch( c->EXC )
        {
                case 0x00:
                kprintf("\n\rException 00: DIVISION BY ZERO\n\r");
                break;

                case 0x01:
                kprintf("\n\rException 01: DEBUG EXCEPTION DETECTED\n\r");
                break;

                case 0x02:
                kprintf("\n\rException 02: NON MASKABLE INTERRUPT\n\r");
                break;

                case 0x03:
                kprintf("\n\rException 03: BREAKPOINT INSTRUCTION DETECTED\n\r");
                dump_registers( c );
                kprintf("\n\rBreakpoint from task [%s] (%i)\n\r", get_pname(), get_pid());
                // After a breakpoint we can restore execution.
                return;
                break;

                case 0x04:
                kprintf("\n\rException 04: INTO DETECTED OVERFLOW\n\r");
                break;

                case 0x05:
                kprintf("\n\rException 05: BOUND RANGE EXCEEDED\n\r");
                break;

                case 0x06:
                kprintf("\n\rException 06: INVALID OPCODE\n\r");
                break;

                case 0x07:
                kprintf("\n\rException 07: PROCESSOR EXTENSION NOT AVAILABLE\n\r");
                break;

                case 0x08:
                kprintf("\n\rException 08: DOUBLE FAULT DETECTED\n\r");
                break;

                case 0x09:
                kprintf("\n\rException 09: PROCESSOR EXTENSION PROTECTION FAULT\n\r");
                break;

                case 0x0A:
                kprintf("\n\rException 0A: INVALID TASK STATE SEGMENT\n\r");
                break;

                case 0x0B:
                kprintf("\n\rException 0B: SEGMENT NOT PRESENT\n\r");
                break;

                case 0x0C:
                kprintf("\n\rException 0C: STACK FAULT\n\r");
                break;

                case 0x0D:
                if ((c->eflags & EFLAGS_VM) == EFLAGS_VM)
                {
                        v86_monitor();
                        return;
                }
                kprintf("\n\rException 0D: GENERAL PROTECTION FAULT\n\r");
                break;

                case 0x0E:
                if ((c->err_code & P_PRESENT) != P_PRESENT)
                {
                        register uint32_t cr2;
                        __asm__ __volatile__ ("movl %%cr2, %0" : "=&r"(cr2));
                        if ( !page_fault_handler(c->err_code, cr2) )
                                return;
                }
                kprintf(        "\n\rException 0E: PAGE FAULT (protection fault)!\n\r");
                break;

                case 0x0F:
                kprintf("\n\rException 0F: UNKNOWN EXCEPTION\n\r");
                break;

                default:
                kprintf("\n\rException %02X: UNEXPECTED !!!\n\r", c->EXC);
                break;
        }

        // Dump the CPU registers.
        dump_registers( c );
        panic();
}

/** @} */ // end of KException

---