---

paging.c File Reference

Paging manager. More...

#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>

Go to the source code of this file.

Functions
dword	pop_frame ()
	Pop a free frame from the free frames stack. Exceptions: 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.
void	push_frame (dword p_addr)
	Push a free frame into the free frames stack. Parameters: p_addr  The page number you want to push. Note: The value p_addr must be the page number! If you know the physical address you have to divide this value to PAGE_SIZE.
bool	map_page (dword vir_addr, dword phys_addr, word attribs)
	Map a physical address into a virtual address for the current address space. Parameters: vir_addr  The virtual address. phys_addr  The physical address. attribs  The attributes mask for this page. Returns: TRUE on success; FALSE if out-of-memory.
void	unmap_page (dword vir_addr)
	Unmap a page, but doesn't destroy the physical frame. Parameters: vir_addr  The virtual address you want to unmap.
void	delete_page (dword vir_addr)
	Unmap a page and destroy the physical frame where the address is mapped. Parameters: vir_addr  The virtual address you want to delete.
void *	get_temp_page ()
	Get a free virtual page from the temporary memory area. Returns: The address of the temporary page or NULL if out of memory.
void	free_temp_page (void *p, bool do_delete)
	Free a virtual temporary page allocated by get_temp_page(). Parameters: p  The temporary page virtual address. do_delete  TRUE free the page and also the physical frame; FALSE unmap the page only, do not free the physical frame.
dword	vir_to_phys (dword vir_addr)
	Translate a virtual address into the physical address. Parameters: vir_addr  The virtual address to be translated.
int	page_fault_handler (dword err_code, dword cr2)
	This is the page-fault handler. Every time a page-fault occurs, this routine must be invoked. Parameters: err_code  The error code from the CPU. cr2  The address that caused the fault. Returns: 0 success; < 0 otherwise.
void	init_free_frames ()
	Initialize the free frames stack. Note: This routine must be called once, when the system is initializing.
void	init_paging ()
	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	dump_dirty_pages ()
	Dump the dirty pages to stdout.
void	dump_free_frames ()
	Dump the free frames to stdout.
void	check_free_frames_integrity ()
	This process checks the free frames stack integrity. Warning: This is a process so it must end with auto_kill();.
Variables
volatile dword	PHYS_MEM_DIM
	The physical memory dimension. Initialized in paging.c.
dword	KERNEL_TOP
	The kernel bounds. These variables must be declared externally into the linker script.
dword	KERNEL_END_TEXT
	The kernel bounds. These variables must be declared externally into the linker script.
dword *	K_VIR_END
	End of kernel virtual space.
dword *	free_frames = (dword *)&KERNEL_TOP
	Free-frames stack - placed just above kernel memory.
volatile dword	K_PDBR [PAGE_SIZE/sizeof(dword)]
	Master page directory.

---

Detailed Description

Paging manager.

Author:

Andrea Righi <drizzt@inwind.it>

Date:

Last update:
2003-12-16 Andrea Righi: Fixed get_temp_page() and free_temp_page() bugs.
2004-01-24 Andrea Righi: Added the NULL-pointer mapping check in the page fault handler.
2004-02-07 Andrea Righi: Added the fast_clear_page using MMX extensions to clear a page after is mapped.

Note:

Copyright (©) 2003 Andrea Righi

Note:

This is the GNU linker script (LD) where are declared some external variables used by the paging manager.

/* kernel.ld
 *      The GNU linker script for minirighi.
 *      Author: Andrea Righi <drizzt@inwind.it>
 */

OUTPUT_FORMAT("elf32-i386","elf32-i386","elf32-i386")

K_VIR_START = 0xC0000000;
K_PHYS_START = 0x100000;
K_STACK_SIZE = 0x1000;
PAGE_SIZE = 0x1000;

ENTRY (_start)

SECTIONS
{
        .text K_VIR_START : AT(K_PHYS_START)
        {
                KERNEL_TEXT = .;
                *(.text*)
                *(.rodata*)
                . = ALIGN(PAGE_SIZE);
                KERNEL_END_TEXT = .;
        }

        .data : AT(K_PHYS_START + (KERNEL_DATA - KERNEL_TEXT))
        {
                KERNEL_DATA = .;
                *(.data*)
                . = ALIGN(PAGE_SIZE);
                KERNEL_END_DATA = .;
        }

        .bss : AT(K_PHYS_START + (KERNEL_BSS - KERNEL_TEXT))
        {
                _stack_end = .;
                . += K_STACK_SIZE;
                _stack_start = .;
                K_STACK_START = .;

                KERNEL_BSS = .;
                *(.bss*)
                . = ALIGN(PAGE_SIZE);
                *(COMMON*)
                . = ALIGN(PAGE_SIZE);
                KERNEL_END_BSS = .;
        }
        . = ALIGN(PAGE_SIZE);
        KERNEL_TOP = .;
}

Definition in file paging.c.

---

Function Documentation

void check_free_frames_integrity (    )

This process checks the free frames stack integrity. Warning: This is a process so it must end with auto_kill();. Definition at line 545 of file paging.c. { 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 ); }

void delete_page (  dword    vir_addr )

Unmap a page and destroy the physical frame where the address is mapped. Parameters: vir_addr  The virtual address you want to delete. Definition at line 224 of file paging.c. { 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); }

void dump_dirty_pages (    )

Dump the dirty pages to stdout. Definition at line 493 of file paging.c. { // 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"); }

void dump_free_frames (    )

Dump the free frames to stdout. Definition at line 520 of file paging.c. { 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"); }

void free_temp_page (  void *    p, bool    do_delete )

Free a virtual temporary page allocated by get_temp_page(). Parameters: p  The temporary page virtual address. do_delete  TRUE free the page and also the physical frame; FALSE unmap the page only, do not free the physical frame. Definition at line 333 of file paging.c. { // 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 ); } }

void* get_temp_page (    )

Get a free virtual page from the temporary memory area. Returns: The address of the temporary page or NULL if out of memory. Definition at line 285 of file paging.c. { 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 ); } }

void init_free_frames (    )

Initialize the free frames stack. Note: This routine must be called once, when the system is initializing. Definition at line 431 of file paging.c. { // 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; }

void init_paging (    )

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!!! Definition at line 456 of file paging.c. { 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]; }

bool map_page (  dword    vir_addr, dword    phys_addr, word    attribs )

Map a physical address into a virtual address for the current address space. Parameters: vir_addr  The virtual address. phys_addr  The physical address. attribs  The attributes mask for this page. Returns: TRUE on success; FALSE if out-of-memory. Definition at line 115 of file paging.c. { 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); }

dword pop_frame (    )

Pop a free frame from the free frames stack. Exceptions: 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. Definition at line 61 of file paging.c. { 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); }

void push_frame (  dword    p_addr )

Push a free frame into the free frames stack. Parameters: p_addr  The page number you want to push. Note: The value p_addr must be the page number! If you know the physical address you have to divide this value to PAGE_SIZE. Definition at line 88 of file paging.c. { 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); }

void unmap_page (  dword    vir_addr )

Unmap a page, but doesn't destroy the physical frame. Parameters: vir_addr  The virtual address you want to unmap. Definition at line 172 of file paging.c. { 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); }

dword vir_to_phys (  dword    vir_addr )

Translate a virtual address into the physical address. Parameters: vir_addr  The virtual address to be translated. Definition at line 350 of file paging.c. { if (*ADDR_TO_PDE(vir_addr) == NULL) return(NULL); return ((*ADDR_TO_PTE(vir_addr) & -PAGE_SIZE) + (vir_addr % PAGE_SIZE)); }

---

Variable Documentation

dword* free_frames = (dword *)&KERNEL_TOP

Free-frames stack - placed just above kernel memory. Definition at line 48 of file paging.c.

volatile dword K_PDBR[PAGE_SIZE/sizeof(dword)]

Master page directory. Definition at line 51 of file paging.c.

dword* K_VIR_END

End of kernel virtual space. Definition at line 45 of file paging.c.

dword KERNEL_END_TEXT

The kernel bounds. These variables must be declared externally into the linker script. Definition at line 42 of file paging.c.

dword KERNEL_TOP

The kernel bounds. These variables must be declared externally into the linker script. Definition at line 42 of file paging.c.

---