---

paging.c

Go to the documentation of this file.

/*!     \file arch/i386/kernel/paging.c
 *      \brief Paging manager.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update:\n
 *              2003-12-16 Andrea Righi:
 *                      Fixed get_temp_page() and free_temp_page()
 *                      bugs.\n
 *              2004-01-24 Andrea Righi:
 *                      Added the NULL-pointer mapping check in the
 *                      page fault handler.\n
 *              2004-02-07 Andrea Righi:
 *                      Added the fast_clear_page using MMX extensions
 *                      to clear a page after is mapped.\n
 *      \note Copyright (&copy;) 2003 Andrea Righi
 *
 *      \note
 *              This is the GNU linker script (LD) where are declared
 *              some external variables used by the paging manager.
 *              \include kernel.ld
 */

#include <const.h>

#include <arch/i386.h>
#include <arch/mem.h>
#include <arch/mmx.h>

#include <kernel/console.h>
#include <kernel/multiboot.h>
#include <kernel/kernel_map.h>
#include <kernel/keyboard.h>
#include <kernel/speaker.h>
#include <kernel/task.h>

#include <arch/paging.h>

//! Total amount of physical memory.
volatile dword PHYS_MEM_DIM;

//! The kernel bounds. These variables must be declared externally into
//! the linker script.
extern dword KERNEL_TOP, KERNEL_END_TEXT;

//! End of kernel virtual space.
dword *K_VIR_END;

//! Free-frames stack - placed just above kernel memory.
dword *free_frames = (dword *)&KERNEL_TOP;

//! Master page directory.
volatile dword K_PDBR[PAGE_SIZE/sizeof(dword)];

// --- Free frames stack operators ------------------------------------ //

//! \brief Pop a free frame from the free frames stack.
//! \exception NULL Out-of-memory.
//! \note
//!     The function returns the address expressed in the page number
//!     format. This value will be multiplied by #PAGE_SIZE to obtain
//!     the real physical address of the frame.
dword pop_frame()
{
        dword ret;
        dword IF = GET_IF();

        disable();

        if (*free_frames != NULL)
        {
                ret = *free_frames++;

                SET_IF(IF);
                return(ret);
        }

        // Out of memory!!! //
        SET_IF(IF);
        return(NULL);
}

//! \brief Push a free frame into the free frames stack.
//! \param p_addr
//!     The page number you want to push.
//! \note
//!     The value \p p_addr must be the page number! \n
//!     If you know the physical address you have to divide this
//!     value to #PAGE_SIZE.
void push_frame(dword p_addr)
{
        dword IF = GET_IF();

        disable();

        // Push the frame into free frames stack //
        if ((dword)free_frames > ((dword)&KERNEL_TOP))
        {
                *(--free_frames)=p_addr;
        }

        SET_IF(IF);
}

// --- Mapping operators ---------------------------------------------- //

//! \brief
//!     Map a physical address into a virtual address for the
//!     current address space.
//! \param vir_addr The virtual address.
//! \param phys_addr The physical address.
//! \param attribs
//!     The attributes mask for this page.
//! \return
//!     \li #TRUE on success;
//!     \li #FALSE if out-of-memory.
bool map_page(dword vir_addr, dword phys_addr, word attribs)
{
        dword *PTE;
        dword i;
        dword IF = GET_IF();

        // Round virtual & physical address to the page boundary //
        vir_addr = PAGE_ALIGN(vir_addr);
        phys_addr = PAGE_ALIGN(phys_addr);

        // Get only valid attribs //
        attribs &= (PAGE_SIZE-1);

        disable();

        // If the page directory entry is NULL must be created //
        if (*ADDR_TO_PDE(vir_addr) == NULL)
        {
                // Create a new page table //
                PTE = (dword *)(pop_frame() * PAGE_SIZE);
                if (PTE == NULL)
                {
                        // Out of memory!!! //
                        SET_IF(IF);
                        return(FALSE);
                }

                // Set the PDE as present, user level, read-write //
                *ADDR_TO_PDE(vir_addr) = (dword)PTE | P_PRESENT | P_USER | P_WRITE;

                // Flush the whole TLB cache //
                flush_tlb_all();

                // NULL every PTE entry //
                for (i=PAGE_DIR_ALIGN(vir_addr); i<PAGE_DIR_ALIGN_UP(vir_addr); i+=PAGE_SIZE)
                {
                        *ADDR_TO_PTE(i) = NULL;
                }

                // Update master page directory //
                if (vir_addr >= K_VIR_START)
                        K_PDBR[vir_addr/(PAGE_SIZE*1024)] = *ADDR_TO_PDE(vir_addr);
        }

        // Store the physical address into the page table entry //
        *ADDR_TO_PTE(vir_addr) = (dword)phys_addr | attribs;

        // Invalidate the page in the TLB cache //
        flush_tlb_single(vir_addr);

        SET_IF(IF);
        return(TRUE);
}

//! \brief
//!     Unmap a page, but doesn't destroy the physical frame.
//! \param vir_addr The virtual address you want to unmap.
void unmap_page(dword vir_addr)
{
        dword temp;
        dword IF = GET_IF();

        // Align address to the page boundary //
        vir_addr = PAGE_ALIGN(vir_addr);

        if (*ADDR_TO_PDE(vir_addr) == NULL) return;
        if (*ADDR_TO_PTE(vir_addr) == NULL) return;

        disable();

        // Unmap the page //
        *ADDR_TO_PTE(vir_addr) = NULL;

        // Invalidate the page in the TLB cache //
        flush_tlb_single(vir_addr);

        // Check if it is possible to deallocate the frame
        // of the page table used to map the address
        // So let's examine all entries in the page table
        // where the address is mapped.

        for(    temp = PAGE_DIR_ALIGN(vir_addr);
                temp < PAGE_DIR_ALIGN_UP(vir_addr);
                temp += PAGE_SIZE)

                if (*ADDR_TO_PTE(temp) != NULL)
                {
                        SET_IF(IF);
                        return;
                }

        // No PTEs found... deallocate the page table! //
        push_frame(*ADDR_TO_PDE(vir_addr)/PAGE_SIZE);
        *ADDR_TO_PDE(vir_addr) = NULL;

        // Invalidate the whole TLB cache //
        flush_tlb_all();

        // ...and update the master page directory! //
        if (vir_addr >= K_VIR_START)
                K_PDBR[vir_addr/(PAGE_SIZE*1024)] = NULL;

        SET_IF(IF);
}

//! \brief
//!     Unmap a page and destroy the physical frame where the address
//!     is mapped.
//! \param vir_addr The virtual address you want to delete.
void delete_page(dword vir_addr)
{
        dword temp;
        dword IF = GET_IF();

        // Align address to the page boundary //
        vir_addr = PAGE_ALIGN(vir_addr);

        if (*ADDR_TO_PDE(vir_addr) == NULL) return;
        if (*ADDR_TO_PTE(vir_addr) == NULL) return;

        disable();

        // Push the physical frame into the free frames stack //
        if (
                (vir_to_phys(vir_addr) >= DMA_MEMORY_END) &&
                (vir_to_phys(vir_addr) < PHYS_MEM_DIM)
        )
                push_frame(vir_to_phys(vir_addr)/PAGE_SIZE);

        // Unmap the page //
        *ADDR_TO_PTE(vir_addr) = NULL;

        // Invalidate the page in the TLB cache //
        flush_tlb_single(vir_addr);

        // Check if it is possible to deallocate the frame
        // of the page table used to map the address
        // So let's examine all entries in the page table
        // where the address is mapped.

        for(    temp = PAGE_DIR_ALIGN(vir_addr);
                temp < PAGE_DIR_ALIGN_UP(vir_addr);
                temp += PAGE_SIZE )

                if (*ADDR_TO_PTE(temp) != NULL)
                {
                        SET_IF(IF);
                        return;
                }

        // No PTEs found... deallocate the page table! //
        push_frame(*ADDR_TO_PDE(vir_addr)/PAGE_SIZE);
        *ADDR_TO_PDE(vir_addr) = NULL;

        // Ivalidate the whole TLB cache //
        flush_tlb_all();

        // ...and update the master page directory! //
        if (vir_addr >= K_VIR_START)
                K_PDBR[vir_addr/(PAGE_SIZE*1024)] = NULL;

        SET_IF(IF);
}

// --- Temporary pages ------------------------------------------------ //

//! \brief
//!     Get a free virtual page from the temporary memory area.
//! \return
//!     The address of the temporary page or NULL if out of memory.
void *get_temp_page()
{
        byte *p = (byte *)K_MEM_TEMP_START;
        size_t frame;
        dword IF = GET_IF();

        disable();

        while(TRUE)
        {
                if ( *ADDR_TO_PDE((size_t)p) )
                {
                        if ( *ADDR_TO_PTE((size_t)p) )
                        {
                                p += PAGE_SIZE;
                                if (p >= (byte *)K_MEM_TEMP_END)
                                {
                                        // Out of temporary memory!     //
                                        SET_IF(IF);
                                        return( NULL );
                                }
                                continue;
                        }
                }
                // OK! A free temporary page has been found!            //
                // Now map this page to a free frame and return the     //
                // virtual address of this page, or NULL if there is    //
                // no free frame.
                frame = ( pop_frame()*PAGE_SIZE );
                if ( frame==NULL )
                {
                        p = NULL;
                }
                else if ( !map_page((dword)p, frame, P_PRESENT | P_WRITE) )
                {
                        p = NULL;
                }
                SET_IF(IF);
                return( (void *)p );
        }
}

//! \brief
//!     Free a virtual temporary page allocated by get_temp_page().
//! \param p The temporary page virtual address.
//! \param do_delete
//!     \li TRUE free the page and also the physical frame;
//!     \li FALSE unmap the page only, do not free the physical frame.
void free_temp_page(void *p, bool do_delete)
{
        // Is the page into the temporary memory range?!                //
        if ( (((dword)p >= (K_MEM_TEMP_START))) && ((dword)p < K_MEM_TEMP_END) )
        {
                if ( do_delete )
                        delete_page( (dword)p );
                else
                        unmap_page( (dword)p );
        }
}

// --- Generic operatators -------------------------------------------- //

//! \brief
//!     Translate a virtual address into the physical address.
//! \param vir_addr The virtual address to be translated.
dword vir_to_phys(dword vir_addr)
{
        if (*ADDR_TO_PDE(vir_addr) == NULL) return(NULL);
        return ((*ADDR_TO_PTE(vir_addr) & -PAGE_SIZE) + (vir_addr % PAGE_SIZE));
}

// --- Page fault handler --------------------------------------------- //

/*! \ingroup Handlers */
//! \brief
//!     This is the page-fault handler. Every time a page-fault
//!     occurs, this routine must be invoked.
//! \param err_code The error code from the CPU.
//! \param cr2 The address that caused the fault.
//! \return
//!     \li 0 success;
//!     \li < 0 otherwise.
int page_fault_handler(dword err_code, dword cr2)
{
        dword phys_addr;

#ifdef PAGE_DEBUG
        kprintf("\n\rPAGE_FAULT : %#010x", cr2);
#endif
        if( cr2==NULL )
        {
                // Cannot map the NULL pointer.
                return( -1 );
        }

        // Get a physical free frame.
        phys_addr = pop_frame()*PAGE_SIZE;

        // If out of memory => return!
        if (phys_addr == NULL)
        {
                set_color(LIGHT_RED);
                kprintf("\n\rPage fault handler panic: Out of memory!!!");
                set_color(DEFAULT_COLOR);
                return(-1);
        }

        // Get only valid err_code //
        err_code &= (P_PRESENT | P_WRITE | P_USER);

        // Map page with correct attributes //
        if (cr2 >= K_VIR_START)
        {
                if (!(map_page(cr2, phys_addr, P_PRESENT | P_WRITE)))
                {
                        // Out of memory!!! //
                        set_color(LIGHT_RED);
                        kprintf("\n\rPage fault handler panic: Out of memory!!!");
                        set_color(DEFAULT_COLOR);
                        return( -1 );
                }
        }
        else
        {
                if (!(map_page(cr2, phys_addr, P_PRESENT | P_WRITE | P_USER)))
                {
                        // Out of memory!!! //
                        set_color(LIGHT_RED);
                        kprintf("\n\rPage fault handler panic: Out of memory!!!");
                        set_color(DEFAULT_COLOR);
                        return( -1 );
                }
        }
        // Null the new page.
        // memsetl((void *)PAGE_ALIGN(cr2), 0, PAGE_SIZE/sizeof(uint32_t));
        fast_clear_page((void *)PAGE_ALIGN(cr2));
        return( 0 );
}

// --- Initialization routines ---------------------------------------- //

//! \brief
//!     Initialize the free frames stack.
//! \note
//!     This routine must be called once, when the system is
//!     initializing.
void init_free_frames()
{
        // First physical 16MB are reserved for kernel, BIOS & DMA      //
        // so let's start with free memory area at 16MB                 //
        register dword p_addr=P_ADDR_16MB;

        K_VIR_END = free_frames;
        while (p_addr < ADDR_TO_PAGE(PHYS_MEM_DIM))
        {
                *K_VIR_END++=p_addr++;
        }

        // Last frame is NULL => out of physical memory.                //
        // Kernel virtual address space ends here:                      //
        *K_VIR_END=NULL;
}

//! \brief
//!     Initialize the paging mechanism.
//! \note
//!     This routine must be called once, when the system is
//!     initializing.
//! \warning
//!     This routine must be the first routine of the kernel
//!     initialization process!!!
void init_paging()
{
        extern multiboot_info_t *boot_info;
        size_t addr;

        if (boot_info->flags & 0x02)
        {
                PHYS_MEM_DIM = (boot_info->mem_upper)*1024;
        }
        else
        {
                // Error reading multiboot informations... halting!.
                halt();
        }

        // Initialize free frames stack //
        init_free_frames();

        // Unmap first 4MB identical-map pages.
        *ADDR_TO_PDE(0) = NULL;

        // Flush the whole TLB cache.
        flush_tlb_all();

        // Map part of physical memory into the kernel address space //
        for (addr=PHYS_MEM_START; addr<PHYS_MEM_END; addr+=PAGE_SIZE)
                map_page(addr, addr-PHYS_MEM_START, P_PRESENT | P_WRITE);

        // Initialize master page directory //
        for (addr=0; addr<1024; addr++)
                K_PDBR[addr] = ((dword *)PAGE_DIR_MAP)[addr];
}

// --- Debug functions ------------------------------------------------ //

//! \brief
//!     Dump the dirty pages to stdout.
void dump_dirty_pages()
{
// Show all the dirty pages //

        dword vir_addr;
        dword display=1;

        // Print all the dirty pages //
        kprintf("\n\rDirty pages:\n\r");
        for (vir_addr = 0; vir_addr<PAGE_TABLE_MAP; vir_addr += PAGE_SIZE)
                if (*ADDR_TO_PDE(vir_addr) != NULL)
                        if ((*ADDR_TO_PTE(vir_addr) & P_DIRTY) == P_DIRTY)
                        {
                                if (!(display = display++ % 24))
                                        if (kgetchar() == CTRL_C)
                                        {
                                                kprintf("\n\r");
                                                return;
                                        }
                                kprintf("\n\rvir_addr = %#010x\tpage_entry = %#010x",
                                        vir_addr, *(ADDR_TO_PTE(vir_addr)));
                        }
        kprintf("\n\r");
}

//! \brief
//!     Dump the free frames to stdout.
void dump_free_frames()
{
        dword *f = free_frames;
        dword display=1;

        kprintf("\n\rFree frames list: (KERNEL_TOP=%#010x)\n\r", (dword)&KERNEL_TOP);
        for(;;)
        {
                if (*f == NULL) break;
                if (!(display = display++ % 24))
                        if (kgetchar() == CTRL_C)
                        {
                                kprintf("\n\r");
                                return;
                        }
                kprintf("\n\rframe=%#010x &frame=%#010x", *f, (dword)f);
                f++;
        }
        kprintf("\n\r");
}

//! \brief
//!     This process checks the free frames stack integrity.
//! \warning
//!     This is a process so it must end with auto_kill();
void check_free_frames_integrity()
{
        dword flag, i;
        dword *j;

        kprintf("\n\rChecking free frames integrity (%s)...\n\r", get_pname());
        for (i=P_ADDR_16MB; i<ADDR_TO_PAGE(PHYS_MEM_DIM); i++)
        {
                flag=0;
                for (j=free_frames; j<K_VIR_END; j++)
                {
                        if (*j == i) flag++;
                }
                if (flag>1) kprintf("\n\rError! frame:%#010x", i);
        }
        beep();
        kprintf("\n\rCheck done.\n\r");
        _exit( 0 );
}

---