exception.c File Reference

#include "userprog/exception.h"
#include <inttypes.h>
#include <stdio.h>
#include "userprog/gdt.h"
#include "threads/interrupt.h"
#include "threads/thread.h"
#include "intrinsic.h"

Include dependency graph for exception.c:

Functions
static void	kill (struct intr_frame *)
static void	page_fault (struct intr_frame *)
void	exception_init (void)
void	exception_print_stats (void)

Variables
static long long	page_fault_cnt

Function Documentation

exception_init()

void exception_init

(

void

)

                      {
    /* These exceptions can be raised explicitly by a user program,
       e.g. via the INT, INT3, INTO, and BOUND instructions.  Thus,
       we set DPL==3, meaning that user programs are allowed to
       invoke them via these instructions. */
    intr_register_int (3, 3, INTR_ON, kill, "#BP Breakpoint Exception");
    intr_register_int (4, 3, INTR_ON, kill, "#OF Overflow Exception");
    intr_register_int (5, 3, INTR_ON, kill,
            "#BR BOUND Range Exceeded Exception");
 
    /* These exceptions have DPL==0, preventing user processes from
       invoking them via the INT instruction.  They can still be
       caused indirectly, e.g. #DE can be caused by dividing by
       0.  */
    intr_register_int (0, 0, INTR_ON, kill, "#DE Divide Error");
    intr_register_int (1, 0, INTR_ON, kill, "#DB Debug Exception");
    intr_register_int (6, 0, INTR_ON, kill, "#UD Invalid Opcode Exception");
    intr_register_int (7, 0, INTR_ON, kill,
            "#NM Device Not Available Exception");
    intr_register_int (11, 0, INTR_ON, kill, "#NP Segment Not Present");
    intr_register_int (12, 0, INTR_ON, kill, "#SS Stack Fault Exception");
    intr_register_int (13, 0, INTR_ON, kill, "#GP General Protection Exception");
    intr_register_int (16, 0, INTR_ON, kill, "#MF x87 FPU Floating-Point Error");
    intr_register_int (19, 0, INTR_ON, kill,
            "#XF SIMD Floating-Point Exception");
 
    /* Most exceptions can be handled with interrupts turned on.
       We need to disable interrupts for page faults because the
       fault address is stored in CR2 and needs to be preserved. */
    intr_register_int (14, 0, INTR_OFF, page_fault, "#PF Page-Fault Exception");
}

Here is the call graph for this function:

Here is the caller graph for this function:

exception_print_stats()

void exception_print_stats

(

void

)

                             {
    printf ("Exception: %lld page faults\n", page_fault_cnt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kill()

static void kill ( struct intr_frame *  f )

static

                            {
    /* This interrupt is one (probably) caused by a user process.
       For example, the process might have tried to access unmapped
       virtual memory (a page fault).  For now, we simply kill the
       user process.  Later, we'll want to handle page faults in
       the kernel.  Real Unix-like operating systems pass most
       exceptions back to the process via signals, but we don't
       implement them. */
 
    /* The interrupt frame's code segment value tells us where the
       exception originated. */
    switch (f->cs) {
        case SEL_UCSEG:
            /* User's code segment, so it's a user exception, as we
               expected.  Kill the user process.  */
            printf ("%s: dying due to interrupt %#04llx (%s).\n",
                    thread_name (), f->vec_no, intr_name (f->vec_no));
            intr_dump_frame (f);
            thread_exit ();
 
        case SEL_KCSEG:
            /* Kernel's code segment, which indicates a kernel bug.
               Kernel code shouldn't throw exceptions.  (Page faults
               may cause kernel exceptions--but they shouldn't arrive
               here.)  Panic the kernel to make the point.  */
            intr_dump_frame (f);
            PANIC ("Kernel bug - unexpected interrupt in kernel");
 
        default:
            /* Some other code segment?  Shouldn't happen.  Panic the
               kernel. */
            printf ("Interrupt %#04llx (%s) in unknown segment %04x\n",
                    f->vec_no, intr_name (f->vec_no), f->cs);
            thread_exit ();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

page_fault()

static void page_fault ( struct intr_frame *  f )

static

                                  {
    bool not_present;  /* True: not-present page, false: writing r/o page. */
    bool write;        /* True: access was write, false: access was read. */
    bool user;         /* True: access by user, false: access by kernel. */
    void *fault_addr;  /* Fault address. */
 
    /* Obtain faulting address, the virtual address that was
       accessed to cause the fault.  It may point to code or to
       data.  It is not necessarily the address of the instruction
       that caused the fault (that's f->rip). */
 
    fault_addr = (void *) rcr2();
 
    /* Turn interrupts back on (they were only off so that we could
       be assured of reading CR2 before it changed). */
    intr_enable ();
 
 
    /* Determine cause. */
    not_present = (f->error_code & PF_P) == 0;
    write = (f->error_code & PF_W) != 0;
    user = (f->error_code & PF_U) != 0;
 
#ifdef VM
    /* For project 3 and later. */
    if (vm_try_handle_fault (f, fault_addr, user, write, not_present))
        return;
#endif
 
    exit(-1); // TC "bad-*" 통과를 위함(exit를 안해주면 kill로 그냥 삭제됨)
    /* Count page faults. */
    page_fault_cnt++;
 
    /* If the fault is true fault, show info and exit. */
    printf ("Page fault at %p: %s error %s page in %s context.\n",
            fault_addr,
            not_present ? "not present" : "rights violation",
            write ? "writing" : "reading",
            user ? "user" : "kernel");
    kill (f);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

page_fault_cnt

long long page_fault_cnt

static