-#include "exception.h"
+#include "userprog/exception.h"
#include <inttypes.h>
-#include "gdt.h"
-#include "lib/lib.h"
+#include <stdio.h>
+#include "userprog/gdt.h"
#include "threads/interrupt.h"
#include "threads/thread.h"
+/* Number of page faults processed. */
+static long long page_fault_cnt;
+
static void kill (struct intr_frame *);
static void page_fault (struct intr_frame *);
intr_register (14, 0, INTR_OFF, page_fault, "#PF Page-Fault Exception");
}
+/* Prints exception statistics. */
+void
+exception_print_stats (void)
+{
+ printf ("Exception: %lld page faults\n", page_fault_cnt);
+}
+
/* Handler for an exception (probably) caused by a user process. */
static void
kill (struct intr_frame *f)
case SEL_UCSEG:
/* User's code segment, so it's a user exception, as we
expected. Kill the user process. */
- printk ("%s: dying due to interrupt %#04x (%s).\n",
- thread_name (thread_current ()),
- f->vec_no, intr_name (f->vec_no));
+ printf ("%s: dying due to interrupt %#04x (%s).\n",
+ thread_name (), f->vec_no, intr_name (f->vec_no));
intr_dump_frame (f);
thread_exit ();
default:
/* Some other code segment? Shouldn't happen. Panic the
kernel. */
- printk ("Interrupt %#04x (%s) in unknown segment %04x\n",
+ printf ("Interrupt %#04x (%s) in unknown segment %04x\n",
f->vec_no, intr_name (f->vec_no), f->cs);
thread_exit ();
}
#define PF_U 0x4 /* 0: kernel, 1: user process. */
/* Page fault handler. This is a skeleton that must be filled in
- to implement virtual memory.
+ to implement virtual memory. Some solutions to project 2 may
+ also require modifying this code.
At entry, the address that faulted is in CR2 (Control Register
2) and information about the fault, formatted as described in
static void
page_fault (struct intr_frame *f)
{
- bool not_present, write, user;
- uint32_t fault_addr;
-
- /* Obtain faulting address, then turn interrupts back on.
- (Interrupts were only off so that we could be assured of
- reading CR2 before it changed.)
-
- The faulting address is not necesarily the address of the
- instruction that caused the fault--that's in F's eip
- member. Rather, it's the linear address that was accessed
- to cause the fault, which is probably an address of data,
- not code. */
- asm ("movl %%cr2, %0" : "=r" (fault_addr));
+ 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->eip).
+ See [IA32-v2a] "MOV--Move to/from Control Registers" and
+ [IA32-v3] 5.14 "Interrupt 14--Page Fault Exception
+ (#PF)". */
+ asm ("mov %0, %%cr2" : "=r" (fault_addr));
+
+ /* Turn interrupts back on (they were only off so that we could
+ be assured of reading CR2 before it changed). */
intr_enable ();
+ /* Count page faults. */
+ page_fault_cnt++;
+
/* Determine cause. */
not_present = (f->error_code & PF_P) == 0;
write = (f->error_code & PF_W) != 0;
/* To implement virtual memory, delete the rest of the function
body, and replace it with code that brings in the page to
which fault_addr refers. */
- printk ("Page fault at %08"PRIx32": %s error %s page in %s context.\n",
+ printf ("Page fault at %p: %s error %s page in %s context.\n",
fault_addr,
not_present ? "not present" : "rights violation",
write ? "writing" : "reading",