int i;
unsigned int cr0;

install_interrupt_handler(14, &page_fault);

// Allocate a new frame for the page directory to sit in
unsigned int *pd = (unsigned int*)AllocateFrame();  // AllocateFrame() returns the next page aligned address that is free

// Clear it
memset_dw(pd, 0, 0x1000);

// Create the first page table entry to go in the new page directory
unsigned int *pt = (unsigned int*)AllocateFrame();

// Assign it to the page directory and set its flags
pd[0] = (unsigned int)pt | PAGE_PRESENT | PAGE_WRITE;

// Identity map the first 4MB of physical memory to it
for (i = 0; i < 1024; i++)
   pt[i] = (i*0x1000) | PAGE_PRESENT | PAGE_WRITE;

SwitchPageDirectory(pd);  // simply does - asm volatile("mov %0, %%cr3" : : "r" (pd));

// Enable paging
asm volatile ("mov %%cr0, %0" : "=r" (cr0));
cr0 |= 0x80000000;
asm volatile ("mov %0, %%cr0" : : "r" (cr0));

pagingActive = 1;

// quick test of page fault handler
unsigned int *ptr = (unsigned int*)0xC0000000;
*ptr = 500;

// quick test of page fault handler
unsigned int *ptr = (unsigned int*)0xC0000000;
unsigned int doPageFault = *ptr;
doPageFault++;

isr13:
  cli
  ; this exception already pushes an error code
  push byte 13
  jmp isr_common_stub

isr_common_stub:
  pusha

  mov ax, ds
  push eax

  mov ax, 0x10   ; Load the Kernel Data Segment Descriptor
  mov ds, ax
  mov es, ax
  mov fs, ax
  mov gs, ax

  push esp
  call fault_handler
  add esp, 4

  pop ebx
  mov ds, bx
  mov es, bx
  mov fs, bx
  mov gs, bx

  popa
  add esp, 8   ; Cleans up the pushed error code and pushed ISR number
  iret      ; Pop 5 things at once: CS, EIP, EFLAGS, SS, and ESP

void fault_handler(struct regs *r)
{
  void (*handler)(struct regs *r);

  handler = isrs[r->int_no];

  if (handler)
    handler(r);

  /* Is this a fault whose number is from 0 to 31? */
  if (r->int_no < 32)
  {
    /* Display the description for the exception that occurred */
    /* For now, deal with the exception by entering an infinite loop */
    puts (exception_messages[r->int_no]);
    puts (" System Halted!\n");
    for (;;);
  }
}

void gdt_set_gate(int num, unsigned long base, unsigned long limit, unsigned char access, unsigned char gran);

// The null descriptor
gdt_set_gate(0, 0, 0, 0, 0);
 
// The second entry is the Code Segment.  The base address is 0, the limit is 4 GB, it uses 4 KB granularity, uses 32 bit opcodes
gdt_set_gate(1, 0, 0xFFFFFFFF, 0x9A, 0xCF);
 
// The third entry is the Data Segment.  Its the same as the Code Segment, but the descriptor type is that of a Data Segment
gdt_set_gate(2, 0, 0xFFFFFFFF, 0x92, 0xCF);

gdt[num].granularity = (limit >> 16) & 0x0F;