OSDev.org

Code: Select all

asm("movl %0,%%eax\n" 
	"movl %%eax,%%cr3\n"
	"movl %%cr0,%%eax\n"
	"orl $0x80000000,%%eax\n"
	"movl %%eax,%%cr0\n"
	"jmp 1f\n"
	"1:\n"
	"movl $1f,%%eax\n"
	"jmp *%%eax\n"
	"1:":: "m" (page_directory));

Code: Select all

#include <libc\stdlib.h>
#include <libc\stdio.h>
#include <libc\string.h>
#include <mm.h>
#include <kernel.h>

extern size_t end;

/* lookup table */

unsigned long bit_pattern[] = 
{ 
	0x00000008, 0x00000004, 0x00000002, 0x00000001, 
	0x00000080, 0x00000040, 0x00000020, 0x00000010,  
	0x00000800, 0x00000400, 0x00000200, 0x00000100,  
	0x00008000, 0x00004000, 0x00002000, 0x00001000,    
	0x00080000, 0x00040000, 0x00020000, 0x00010000, 
	0x00800000, 0x00400000, 0x00200000, 0x00100000,      
	0x08000000, 0x04000000, 0x02000000, 0x01000000, 
	0x80000000, 0x40000000, 0x20000000, 0x10000000,
};

/* bit setting functions */

void clear_bit(unsigned long* field, unsigned long index)
{
	*field = ((*field) & (~bit_pattern[index]));
}

void set_bit(unsigned long* field, unsigned long index)
{
	*field = ((*field) | (bit_pattern[index]));
}

unsigned long is_bit_set(unsigned long field, unsigned long index)
{
	if((field | (~bit_pattern[index])) == ~bit_pattern[index])
	{
		return 0;
	}

	return 1;
}

/* some global data, info about paging memory */

addr_t* page_directory;

size_t num_pte = 0;
size_t num_pde = 0;

static addr_t MemoryStart = (addr_t)&end;
addr_t MemoryEnd = 0;
size_t MemorySize = 0;

size_t Pages = 0;
size_t PagesInUse = 0;

addr_t* Bitmap;
size_t BitmapSize;

size_t ref_ptr_one = 0;
size_t ref_ptr_two = 0;

/* some lookup values */

#define LOOKUP_VALUE_L2			131072

size_t lk1;

addr_t AllocPage()
{
	while(ref_ptr_one < lk1)
	{
		while(ref_ptr_two < 32)
		{
			if(!is_bit_set(Bitmap[ref_ptr_one], ref_ptr_two))
			{
				set_bit((unsigned long*)&Bitmap[ref_ptr_one], ref_ptr_two);
				PagesInUse++;
				return MemoryStart + (ref_ptr_one * LOOKUP_VALUE_L2) + (ref_ptr_two * PAGE_SIZE);
			}

			ref_ptr_two++;
		}

		ref_ptr_two = 0;
		ref_ptr_one++;
	}

	// try going to begin of bitmap
	// first chek if we have any pages left
	if(!(Pages - PagesInUse))
	{
		// out of memory
		return 0;
	}

	/* reset parameters */
	ref_ptr_two = 0;
	ref_ptr_one = 0;

	/* retry */ 
	return AllocPage();
}

void FreePage(addr_t address)
{
	// just clear a bit ;)
	unsigned long page = ((address - MemoryStart) / 4096);
	unsigned long entry = (page / 32);
	unsigned long index = (page % 32);

	clear_bit((unsigned long*)&Bitmap[entry], index);

	PagesInUse--;
}

void mm_install(unsigned long mem)
{
	puts("creating paging bitmap... ");

	MemoryStart = MemoryStart + (4096 - (MemoryStart % 4096)); // align
	MemoryEnd = mem * 1024;
	MemorySize = MemoryEnd - MemoryStart;

	Pages = MemorySize / PAGE_SIZE;

	Bitmap = (addr_t*)MemoryStart;
	BitmapSize = (Pages / 32) * 4; // in Bytes

	memset(Bitmap, 0, ((BitmapSize / 4096) + 1) * 4096); /* zero bitmap */

	while(PagesInUse < (BitmapSize / 4096) + 1)
	{
		set_bit((unsigned long*)Bitmap, PagesInUse);
		PagesInUse++;
	}

	lk1 = (BitmapSize / 4) + 1;

	puts("OK\n");

	puts("testing memory... "); // just 1 chek, slows boot, but better to prevent crashes ;)
	// the more the memory the more time it takes to boot ;)

	addr_t* i = (addr_t*)Bitmap + (PagesInUse * 4096);

	// first loop
	for(; i < (addr_t*)MemoryEnd; i = i + 4)
	{
		*i = (addr_t)i;

		if(*i != (addr_t)i)
		{
			printf("error @ 0x%x loop 1", (addr_t)i);
			asm("hlt");
		}
	}

	addr_t* j = (addr_t*)Bitmap + (PagesInUse * 4096);
	i = (addr_t*)Bitmap + (PagesInUse * 4096);
	// second loop
	for(; j < (addr_t*)MemoryEnd; j = j + 4, i = i + 4)
	{
		*i = ~*i;

		if(*i != ~(addr_t)j) // chek with real answer
		{
			printf("error @ 0x%x loop 2", (addr_t)i);
			asm("hlt");
		}
	}

	puts("OK\nfilling with 0... ");
	
	i = (addr_t*)Bitmap + (PagesInUse * 4096);

	// zero memory
	for(; i < (addr_t*)MemoryEnd; i = i + 4)
	{
		*i = 0x00000000;
	}

	puts("OK\nloading page tables... ");



/* **************************************************** */
/* PROBLEMS START HERE!!!!!!!!!!!!!!!!!!!!!!                                    */
/* **************************************************** */


	/* we map all physical memory into kernel virutal memory */
	/* 1:1 mapping */

	/* calculate number of pte's and pde's we need */
	num_pte = (mem * 1024) / PAGE_SIZE;
	num_pde = (num_pte / 1024) + 1; // round up

	size_t iterator_a = 0;
	size_t iterator_b = 0;

	addr_t base = 0x00000000;

	// allocate memory for pd
	page_directory = (addr_t*)AllocPage();

	if((addr_t)page_directory % 4096) // error if not aligned (debug function)
	{
		printf("Error: %d 0x%08x", (addr_t)page_directory % 4096, (addr_t)page_directory);
		asm("hlt");
	}

	memset(page_directory, 0, PAGE_SIZE); /* force empty table */

	addr_t* pde; // page table entry

	// fill pd with pde's and pte's
	while(iterator_a < num_pde && num_pte)
	{
		pde = (addr_t*)AllocPage();

		// fill it with pte's
		while(iterator_b < 1024 && num_pte)
		{
			pde[iterator_b] = base | 3; // attribute set to: supervisor level, read/write, present(011 in binary)
			base += PAGE_SIZE; // 4096 = 4kb

			iterator_b++;
			num_pte--;
		}

		iterator_a++;
		iterator_b = 0;

		page_directory[iterator_a] = (addr_t)pde;
		page_directory[iterator_a] = page_directory[iterator_a] | 3;
	}

	num_pte = (mem * 1024) / PAGE_SIZE; // restore

/* don't work commented out */
	// write_cr3, read_cr3, write_cr0, and read_cr0 all come from the assembly functions
	//write_cr3((addr_t)page_directory); // put that page directory address into CR3
	//write_cr0(read_cr0() | 0x80000000); // set the paging bit in CR0 to 1

/* above doesn't work let's try something else */

	asm("movl %0,%%eax\n" 
	"movl %%eax,%%cr3\n"
	"movl %%cr0,%%eax\n"
	"orl $0x80000000,%%eax\n"
	"movl %%eax,%%cr0\n"
	"jmp 1f\n"
	"1:\n"
	"movl $1f,%%eax\n"
	"jmp *%%eax\n"
	"1:":: "m" (page_directory));

/* reboot here -_- doesn't work either */

	puts("OK\n");
}

Code: Select all

addr: 0x00000000 pde: 0 pte: 0
addr: 0x00001000 pde: 0 pte: 1
addr: 0x00002000 pde: 0 pte: 2
addr: 0x00003000 pde: 0 pte: 3
addr: 0x00004000 pde: 0 pte: 4
addr: 0x00005000 pde: 0 pte: 5
addr: 0x00006000 pde: 0 pte: 6
addr: 0x00007000 pde: 0 pte: 7
addr: 0x00008000 pde: 0 pte: 8
addr: 0x00009000 pde: 0 pte: 9

Code: Select all

addr: 0x00400000 pde: 1 pte: 0

Code: Select all

/* we map all physical memory into kernel virutal memory */
   /* 1:1 mapping */

   /* calculate number of pte's and pde's we need */
   num_pte = (mem * 1024) / PAGE_SIZE;
   num_pde = (num_pte / 1024) + 1; // round up

   size_t iterator_a = 0;
   size_t iterator_b = 0;

   addr_t base = 0x00000000;

   // allocate memory for pd
   page_directory = (addr_t*)AllocPage();

   if((addr_t)page_directory % 4096) // error if not aligned (debug function)
   {
      printf("Error: %d 0x%08x", (addr_t)page_directory % 4096, (addr_t)page_directory);
      asm("hlt");
   }

   memset(page_directory, 0, PAGE_SIZE); /* force empty table */

   addr_t* pde; // page table entry

   // fill pd with pde's and pte's
   while(iterator_a < num_pde && num_pte)
   {
      pde = (addr_t*)AllocPage();

      // fill it with pte's
      while(iterator_b < 1024 && num_pte)
      {
         pde[iterator_b] = base | 3; // attribute set to: supervisor level, read/write, present(011 in binary)
         base += PAGE_SIZE; // 4096 = 4kb

         iterator_b++;
         num_pte--;
      }

      iterator_a++;
      iterator_b = 0;

      page_directory[iterator_a] = (addr_t)pde;
      page_directory[iterator_a] = page_directory[iterator_a] | 3;
   }

   num_pte = (mem * 1024) / PAGE_SIZE; // restore

   asm("movl %0,%%eax\n"
   "movl %%eax,%%cr3\n"
   "movl %%cr0,%%eax\n"
   "orl $0x80000000,%%eax\n"
   "movl %%eax,%%cr0\n"
   "jmp 1f\n"
   "1:\n"
   "movl $1f,%%eax\n"
   "jmp *%%eax\n"
   "1:":: "m" (page_directory));

   puts("OK\n"); 

Code: Select all

while(iterator_a < num_pde && num_pte) 
{ 
   pde = (addr_t*)AllocPage(); 

   // fill it with pte's 
   while(iterator_b < 1024 && num_pte) 
   { 
      pde[iterator_b] = base | 3;  
      base += PAGE_SIZE;

      iterator_b++; 
      num_pte--; 
   } 

   page_directory[iterator_a] = (addr_t)pde; 
   page_directory[iterator_a] = page_directory[iterator_a] | 3; 

   iterator_a++; 
   iterator_b = 0; 
}