paging.c File Reference

#include <system.h>
#include <string.h>
#include "mem/heap.h"
#include "mem/paging.h"

Include dependency graph for paging.c:

Go to the source code of this file.

Functions
void	set_bit (u32int addr)
void	clear_bit (u32int addr)
u32int	get_bit (u32int addr)
u32int	find_free ()
page_entry *	get_page (u32int addr, page_dir *dir, int make_table)
void	init_paging ()
void	load_page_dir (page_dir *new_dir)
void	new_frame (page_entry *page)

Variables
u32int	mem_size = 0x4000000
u32int	page_size = 0x1000
u32int	nframes
u32int *	frames
page_dir *	kdir = 0
page_dir *	cdir = 0
u32int	phys_alloc_addr
heap *	kheap

Function Documentation

void clear_bit

(

u32int

addr

)

Definition at line 44 of file paging.c.

References frames, and page_size.

{
  u32int frame  = addr/page_size;
  u32int index  = frame/32;
  u32int offset = frame%32;
  frames[index] &= ~(1 << offset);
}

u32int find_free

(

)

Definition at line 68 of file paging.c.

References frames, and nframes.

Referenced by new_frame().

{
  u32int i,j;
  for (i=0; i<nframes/32; i++)
    if (frames[i] != 0xFFFFFFFF) //if frame not full
      for (j=0; j<32; j++) //find first free bit
    if (!(frames[i] & (1 << j)))
      return i*32+j;

  return -1; //no free frames
}

u32int get_bit

(

u32int

addr

)

Definition at line 56 of file paging.c.

References frames, and page_size.

{
  u32int frame  = addr/page_size;
  u32int index  = frame/32;
  u32int offset = frame%32;
  return (frames[index] & (1 << offset));  
}

page_entry* get_page	(	u32int	addr,
		page_dir *	dir,
		int	make_table
	)

Definition at line 85 of file paging.c.

References _kmalloc(), page_size, page_table::pages, page_dir::tables, and page_dir::tables_phys.

Referenced by _kmalloc(), and init_paging().

{
  u32int phys_addr;
  u32int index = addr / page_size / 1024;
  u32int offset = addr / page_size % 1024;
  
  //return it if it exists
  if (dir->tables[index])
    return &dir->tables[index]->pages[offset];
  
  //create it
  else if (make_table){
    dir->tables[index] = (page_table*)_kmalloc(sizeof(page_table), 1, &phys_addr);
    dir->tables_phys[index] = phys_addr | 0x7; //enable present, writable
    return &dir->tables[index]->pages[offset];
  }
  else return 0;
}

void init_paging

(

)

Definition at line 111 of file paging.c.

References _kmalloc(), frames, get_page(), KHEAP_BASE, KHEAP_MIN, KHEAP_SIZE, kmalloc(), load_page_dir(), make_heap(), mem_size, memset(), new_frame(), nframes, PAGE_SIZE, page_size, and phys_alloc_addr.

Referenced by kmain().

{
  //create frame bitmap
  nframes = (u32int)(mem_size/page_size);
  frames = (u32int*)kmalloc(nframes/32);
  memset(frames, 0, nframes/32);

  //create kernel directory
  kdir = (page_dir*)_kmalloc(sizeof(page_dir), 1, 0); //page aligned
  memset(kdir, 0, sizeof(page_dir));

  //get pages for kernel heap
  u32int i = 0x0;
  for(i=KHEAP_BASE; i<(KHEAP_BASE+KHEAP_MIN); i+=1){
    get_page(i,kdir,1);
  }

  //perform identity mapping of used memory
  //note: placement_addr gets incremented in get_page,
  //so we're mapping the first frames as well
  i = 0x0;
  while (i < (phys_alloc_addr+0x10000)){
    new_frame(get_page(i,kdir,1));
    i += page_size;
  }

  //allocate heap frames now that the placement addr has increased.
  //placement addr increases here for heap
  for(i=KHEAP_BASE; i<(KHEAP_BASE+KHEAP_MIN);i+=PAGE_SIZE){
    new_frame(get_page(i,kdir,1));
  }

  //load the kernel page directory; enable paging
  load_page_dir(kdir);

  //setup the kernel heap
  kheap = make_heap(KHEAP_BASE, KHEAP_SIZE, KHEAP_BASE+KHEAP_MIN);
}

void load_page_dir

(

page_dir *

new_dir

)

Definition at line 158 of file paging.c.

References page_dir::tables_phys.

Referenced by init_paging().

{
  cdir = new_dir;
  asm volatile ("mov %0,%%cr3":: "b"(&cdir->tables_phys[0]));
  u32int cr0;
  asm volatile ("mov %%cr0,%0": "=b"(cr0));
  cr0 |= 0x80000000;
  asm volatile ("mov %0,%%cr0":: "b"(cr0));
}

void new_frame

(

page_entry *

page

)

Definition at line 173 of file paging.c.

References find_free(), page_entry::frameaddr, kpanic(), page_size, page_entry::present, set_bit(), page_entry::usermode, and page_entry::writeable.

Referenced by init_paging().

{
  u32int index;
  if (page->frameaddr != 0) return;
  if ( (u32int)(-1) == (index=find_free()) ) kpanic("Out of memory");
  
  //mark a frame as in-use
  set_bit(index*page_size);
  page->present   = 1;
  page->frameaddr = index;
  page->writeable = 1;
  page->usermode  = 0;
}

void set_bit

(

u32int

addr

)

Definition at line 32 of file paging.c.

References frames, and page_size.

Referenced by new_frame().

{
  u32int frame  = addr/page_size;
  u32int index  = frame/32;
  u32int offset = frame%32;
  frames[index] |= (1 << offset);
}

Variable Documentation

page_dir* cdir = 0

Definition at line 22 of file paging.c.

u32int* frames

Definition at line 19 of file paging.c.

Referenced by clear_bit(), find_free(), get_bit(), init_paging(), and set_bit().

page_dir* kdir = 0

Definition at line 21 of file paging.c.

heap* kheap

Definition at line 14 of file heap.c.

u32int mem_size = 0x4000000

Definition at line 15 of file paging.c.

Referenced by init_paging().

u32int nframes

Definition at line 18 of file paging.c.

Referenced by find_free(), and init_paging().

u32int page_size = 0x1000

Definition at line 16 of file paging.c.

Referenced by clear_bit(), get_bit(), get_page(), init_paging(), new_frame(), and set_bit().

u32int phys_alloc_addr

Definition at line 22 of file heap.c.

Referenced by _kmalloc(), and init_paging().