OSDev.org

Code: Select all

////////////////////////////////////////////////////
//	PHYSICAL MEMORY MANAGER


char physPagesBitmap[65536]; // 1 Byte represents 8 Pages of 4KB

void _setPhysPageState( unsigned long page, char state ) {
	unsigned long off = page / (8 * 4096);
	unsigned long bit = (page % (8 * 4096)) / 4096;

	physPageBitmap [off] = state << bit;
} 

char _queryPhysPageState( unsigned long page) {
	unsigned long off = page / (8 * 4096);
	unsigned long bit = (page % (8 * 4096)) / 4096;
 
	return physPageBitmap [off] & ( 1 << bit);
}

	

int initPhysMemMgr(unsigned long physSize) {

	unsigned long addrSEnd = (unsigned long)&end; //End of kernel (somewhere above 1MB)

	unsigned long startMem = addrEnd + (addrEnd%4096==0?0:4096-addrSEnd);
	unsigned long endMem = physSize - (physSize%4096==0?0:physSize%4096);

	if(startMem % 4096 != 0) {  // Should never get here, unless something wrong above
		////////////////////
		//Error Handling
		return 0;
	}

	unsigned long pageIndex = 0;
	for(;(pageIndex < 2048 * 1024 * 1024) & pageIndex < ;pageIndex += 4096) {
		if(pageIndex < startMem) {
			_setPhysPageState(pageIndex,1); // 1 Means allocated
		} else if(pageIndex >= startMem && pageIndex < endMem) {
			_setPhysPageState(pageIndex,0); // 0 means unallocated
		} else // pageIndex >= endMem
			_setPhysPageState(pageIndex,1); // 1 means allocated + reserved
	}
		
	return 1; // always here
}

void* allocPhysPage( void ) {
	unsigned long base = 0;

	for(;base < 65536;base++)
		if(physPagesBitmap[base] != 0xFF)
			break;
	if(base >= 65536) 
		return NULL;


	unsigned long page = base * (8*4096) ;
	unsigned long offset = 0;

	for(;offset<8;offset++;page+=4096) {
		if( _queryPhysPageState(page) == 0) {
			_setPhysPageState(page, 1);
			break;
		}
	}
	
	if(offset >=8) 
		return NULL;
	else
		return (void*)page;
}

void freePhysPage( void* page ) {
	unsigned long _page = (unsigned long)page;
	
	if(_page < startMem)
		return;
	else if(_page >= endMem) 
		return;
	else
		_setPhysPageState(_page,0);
} 

Code: Select all

unsigned long *vpt_base = (unsigned long *) 0x1FC00000;   //508mb 
unsigned long *vpd_base = (unsigned long *) (0x1FC00000 + 127 * 4096);

int vmm_map(unsigned long virt_page, unsigned long phys_page, unsigned long PTE_flags, unsigned long PDE_flags) 
{ 
	unsigned long temp_phys_addr; 
	
	if (phys_page == 0)
	{
		return -1;
	}

	if( (vpd_base[virt_page / 1024] & 1) == 0 ) 
	{ 
		// No page table mapped 
	  	temp_phys_addr = (mm_alloc() * 4096); 
	  	vpd_base[virt_page / 1024] = temp_phys_addr;
	  	vpd_base[virt_page / 1024] = vpd_base[virt_page / 1024] | PDE_flags | 1; 
	  	_vmm_invalidate_addr(vpd_base + (virt_page / 1024));
	} 
	if( (vpt_base[virt_page] & 1) != 0 ) 
	{
		return 0; 
	}
	
	vpt_base[virt_page] = (phys_page * 4096);
	vpt_base[virt_page] = vpt_base[virt_page] | PTE_flags | 1; 
	_vmm_invalidate_addr(virt_page * 4096);

	return 0; 
}

Code: Select all

	//////////////////////////////////////////////////////////////
	// 	0 - 4K		V86
	//	4K - 640K	DMA 
	//	640 - 1023K	BIOS Services / Video
	//	1MB - ~4MB	Kernel Code
	//	~4MB - ~508MB	Reserved for Kernel [code] + Drivers
	//	508MB - 512MB	Memory Services 
	//	512MB - 2GB	Kernel Memory Heap
	//	2GB - 2GB + 4KB Unallocated
	//	2GB + 4KB - 4GB User Space

Code: Select all

char kernelMemHeapMap[49152]; // Bitmap that manages the shared kernel memory space between 512MB - 2GB

unsigned long* pageTables = 0x1FC00000; // Controls which pages are mapped
unsigned long* pageDirectory = 0x1FC00000 + (127 * 4096);
	

int setPageInfo( unsigned long vaddr, unsigned long paddr, unsigned long pte_flags, unsigned long page_flags)	{

	if( (pageDirectory[ (vaddr / 4096) /1024] & 1) == 0)  {
		pageDirectory[ (vaddr / 4096) / 1024] = (unsigned long)allocPhysPage() | pte_flags | 1;
		// invalidatePage( pageDirectory );
	}
	if( (pageDirectory[ (vaddr / 4096) / 1024] & 1) == 0)
		return 0;
	vpt_base[ vaddr / 4096 ] = paddr | page_flags | 1;
	// invalidatePage( pageTables );
	return 1;
}

unsigned long getPageInfo( unsigned long vaddr ) {
	return pageDirectory[ (vaddr / 4096) / 1024];
}

int getPageFlags( unsigned long vaddr ) { return getPageInfo(vaddr) & 0xFFFF; }
int getPagePhys( unsigned long vaddr) {return getPageInfo(vaddr) & ~0xFFFF;}

Code: Select all

int initVirtMemManager( void ) {
	//////////////////////////////////////////////////////////////
	// 	0 - 4K		V86
	//	4K - 640K	DMA 
	//	640 - 1023K	BIOS Services / Video
	//	1MB - ~4MB	Kernel Code
	//	~4MB - ~508MB	Reserved for Kernel [code] + Drivers
	//	508MB - 512MB	Memory Services 
	//	512MB - 2GB	Kernel Memory Heap
	//	2GB - 2GB + 4KB Unallocated
	//	2GB + 4KB - 4GB User Space

	//////////////////////////////////////////
	//	Init so we have mapped the kernel + everything below < 1MB, and the Memory Services 

	void* pageDirectory = allocPhysPage();
	memset( pageDirectory , 0 , 4096 );

	pageDirectory[127] = pageDirectory;
	unsigned long index = 0;
	for(index = 0; index < startMem; index += 4096) 
		setPageInfo ( pageDirectory, pageDirectory + 127,index, index, 3, 3,0);


	writeCR3( pageDirectory );
	writeCR0( readCR0() | 0x80000000);
	

}


///////////////////////////////
//	For Processes
unsigned long* creatVMMContext() {
	void* ctxPageDirectory = allocVirtPage();
	memset( ctxPageDirectory, 0 , 4096);

	ctxPageDirectory[127] = ctxPageDirectory;
	unsigned long index = 0;
	for(index = 0; index < startMem; index += 4096) 
		setPageInfo ( pageDirectory, pageDirectory + 127,index, index, 3, 3,0);

	return ctxPageDirectory; // Virt address of a new page directory [for processes]
}