ZLOX_VOID zlox_switch_page_directory(ZLOX_PAGE_DIRECTORY *dir)
{
	ZLOX_UINT32 cr0_val;
    current_directory = dir;
    asm volatile("mov %0, %%cr3":: "r"(dir->tablesPhysical));
    asm volatile("mov %%cr0, %0": "=r"(cr0_val));
    cr0_val |= 0x80000000; // Enable paging!
    asm volatile("mov %0, %%cr0":: "r"(cr0_val));
}

/* zlox_paging.h Defines the interface for and structures relating to paging.*/

#ifndef _ZLOX_PAGING_H_
#define _ZLOX_PAGING_H_

#include "zlox_common.h"
#include "zlox_isr.h"

struct _ZLOX_PAGE
{
    ZLOX_UINT32 present    : 1;   // Page present in memory
    ZLOX_UINT32 rw         : 1;   // Read-only if clear, readwrite if set
    ZLOX_UINT32 user       : 1;   // Supervisor level only if clear
    ZLOX_UINT32 accessed   : 1;   // Has the page been accessed since last refresh?
    ZLOX_UINT32 dirty      : 1;   // Has the page been written to since last refresh?
    ZLOX_UINT32 unused     : 7;   // Amalgamation of unused and reserved bits
    ZLOX_UINT32 frame      : 20;  // Frame address (shifted right 12 bits)
}__attribute__((packed));

typedef struct _ZLOX_PAGE ZLOX_PAGE;

struct _ZLOX_PAGE_TABLE
{
	ZLOX_PAGE pages[1024];
}__attribute__((packed));

typedef struct _ZLOX_PAGE_TABLE ZLOX_PAGE_TABLE;

typedef struct _ZLOX_PAGE_DIRECTORY
{
    /**
       Array of pointers to pagetables.
    **/
    ZLOX_PAGE_TABLE *tables[1024];
    /**
       Array of pointers to the pagetables above, but gives their *physical*
       location, for loading into the CR3 register.
    **/
    ZLOX_UINT32 tablesPhysical[1024];

    /**
       The physical address of tablesPhysical. This comes into play
       when we get our kernel heap allocated and the directory
       may be in a different location in virtual memory.
    **/
    ZLOX_UINT32 physicalAddr;
}ZLOX_PAGE_DIRECTORY;

ZLOX_VOID zlox_init_paging();

#endif //_ZLOX_PAGING_H_

..................................
..................................

ZLOX_UINT32 *frames;

..................................
..................................
ZLOX_VOID zlox_init_paging()
{
    ZLOX_UINT32 i;
    // The size of physical memory. For the moment we 
    // assume it is 16MB big.
    ZLOX_UINT32 mem_end_page = 0x1000000;

    nframes = mem_end_page / 0x1000;
    frames = (ZLOX_UINT32 *)zlox_kmalloc(nframes/8);
    zlox_memset((ZLOX_UINT8 *)frames, 0, nframes/8);

    // Let's make a page directory.
    kernel_directory = (ZLOX_PAGE_DIRECTORY *)zlox_kmalloc_a(sizeof(ZLOX_PAGE_DIRECTORY));
    // we must clean the memory of kernel_directory!
    zlox_memset((ZLOX_UINT8 *)kernel_directory, 0, sizeof(ZLOX_PAGE_DIRECTORY));
    current_directory = kernel_directory;

    // We need to identity map (phys addr = virt addr) from
    // 0x0 to the end of used memory, so we can access this
    // transparently, as if paging wasn't enabled.
    // NOTE that we use a while loop here deliberately.
    // inside the loop body we actually change placement_address
    // by calling kmalloc(). A while loop causes this to be
    // computed on-the-fly rather than once at the start.
    i = 0;
    while (i < placement_address)
    {
        // Kernel code is readable but not writeable from userspace.
        zlox_alloc_frame( zlox_get_page(i, 1, kernel_directory), 0, 0);
        i += 0x1000;
    }
    // Before we enable paging, we must register our page fault handler.
    zlox_register_interrupt_callback(14,zlox_page_fault);

    // Now, enable paging!
    zlox_switch_page_directory(kernel_directory);
}

/* zlox_kheap.c Kernel heap functions, also provides
            a placement malloc() for use before the heap is 
            initialised. */

#include "zlox_kheap.h"

// end is defined in the linker script.
extern ZLOX_UINT32 _end;
ZLOX_UINT32 placement_address = (ZLOX_UINT32)&_end;

ZLOX_UINT32 zlox_kmalloc_int(ZLOX_UINT32 sz, ZLOX_SINT32 align, ZLOX_UINT32 *phys)
{
    ZLOX_UINT32 tmp;
    // This will eventually call malloc() on the kernel heap.
    // For now, though, we just assign memory at placement_address
    // and increment it by sz. Even when we've coded our kernel
    // heap, this will be useful for use before the heap is initialised.
    if (align == 1 && (placement_address & 0x00000FFF) )
    {
        // Align the placement address;
        placement_address &= 0xFFFFF000;
        placement_address += 0x1000;
    }
    if (phys)
    {
        *phys = placement_address;
    }
    tmp = placement_address;
    placement_address += sz;
    return tmp;
}

ZLOX_UINT32 zlox_kmalloc_a(ZLOX_UINT32 sz)
{
    return zlox_kmalloc_int(sz, 1, 0);
}

ZLOX_UINT32 zlox_kmalloc_p(ZLOX_UINT32 sz, ZLOX_UINT32 *phys)
{
    return zlox_kmalloc_int(sz, 0, phys);
}

ZLOX_UINT32 zlox_kmalloc_ap(ZLOX_UINT32 sz, ZLOX_UINT32 *phys)
{
    return zlox_kmalloc_int(sz, 1, phys);
}

ZLOX_UINT32 zlox_kmalloc(ZLOX_UINT32 sz)
{
    return zlox_kmalloc_int(sz, 0, 0);
}

ZLOX_VOID zlox_init_paging()
{
................................
................................
    // Before we enable paging, we must register our page fault handler.
    zlox_register_interrupt_callback(14,zlox_page_fault);

    // Now, enable paging!
    zlox_switch_page_directory(kernel_directory);
................................
................................
}

................................
................................

ZLOX_VOID zlox_page_fault(ZLOX_ISR_REGISTERS regs)
{
    // A page fault has occurred.
    // The faulting address is stored in the CR2 register.
    ZLOX_UINT32 faulting_address;
	ZLOX_SINT32 present;
	ZLOX_SINT32 rw;
	ZLOX_SINT32 us;
	ZLOX_SINT32 reserved;
	ZLOX_SINT32 id;

    asm volatile("mov %%cr2, %0" : "=r" (faulting_address));
    
    // The error code gives us details of what happened.
    present   = !(regs.err_code & 0x1); // Page not present
    rw = regs.err_code & 0x2;           // Write operation?
    us = regs.err_code & 0x4;           // Processor was in user-mode?
    reserved = regs.err_code & 0x8;     // Overwritten CPU-reserved bits of page entry?
    id = regs.err_code & 0x10;          // Caused by an instruction fetch?

    // Output an error message.
    zlox_monitor_write("Page fault! ( ");

    if (present)  
	zlox_monitor_write("present ");
    if (rw)
	zlox_monitor_write("read-only ");
    if (us) 
	zlox_monitor_write("user-mode ");
    if (reserved) 
	zlox_monitor_write("reserved ");
    if(id)
	zlox_monitor_write("instruction fetch ");

    zlox_monitor_write(") at 0x");

    zlox_monitor_write_hex(faulting_address);
    zlox_monitor_write("\n");

    ZLOX_PANIC("Page fault");
}