void CreateDefaultHeap() {
Process* pProcess = ProcessManager::GetInstance()->g_pCurProcess;
Thread* pThread = (Thread*)List_GetData(pProcess->pThreadQueue, "", 0);
//Thread* pThread = ProcessManager::GetInstance()->g_pThread;
void* pHeapaaPhys = (void*)pmmngr_alloc_blocks(300);
u32int heapAddess = pThread->imageBase + pThread->imageSize + PAGE_SIZE + PAGE_SIZE * 2;
heapAddess = heapAddess - (heapAddess % PAGE_SIZE);
//u32int heapAddess = 0xB0000000;
DebugPrintf("\nheap adress %x", heapAddess);
for (int i = 0; i < 300; i++)
{
vmmngr_mapPhysicalAddress(pProcess->pPageDirectory,
(uint32_t)heapAddess + i * PAGE_SIZE,
(uint32_t)pHeapaaPhys + i * PAGE_SIZE,
I86_PTE_PRESENT | I86_PTE_WRITABLE | I86_PTE_USER);
}
//pmmngr_load_PDBR((physical_addr)pProcezss->pPageDirectory);
memset((void*)heapAddess, 0, 300 * PAGE_SIZE);
DebugPrintf("\nimageSize %x", pThread->imageSize);
pThread->lpHeap = create_heap((u32int)heapAddess, (uint32_t)heapAddess + 300 * 4096, (uint32_t)heapAddess + 300 * 4096, 0, 0);
//DebugPrintf("\nThread Creation Success %x", pThread->lpHeap);
//DebugPrintf("\ndfsdfds %x", pHeapPhys);
//DebugPrintf("\nkkkkk");
}
int _cdecl kmain (multiboot_info* bootinfo) {
//! get kernel size passed from boot loader
uint32_t kernelSize=0;
_asm mov word ptr [kernelSize], dx
//! make demo look nice :)
DebugClrScr (0x13);
DebugGotoXY (0,0);
DebugSetColor (0x3F);
DebugPrintf (" ~[ Physical Memory Manager Demo ]~ ");
DebugGotoXY (0,24);
DebugSetColor (0x3F);
DebugPrintf (" ");
DebugGotoXY (0,2);
DebugSetColor (0x17);
//! initialize hal
hal_initialize ();
//! enable interrupts and install exception handlers
enable ();
setvect (0,(void (__cdecl &)(void))divide_by_zero_fault);
setvect (1,(void (__cdecl &)(void))single_step_trap);
setvect (2,(void (__cdecl &)(void))nmi_trap);
setvect (3,(void (__cdecl &)(void))breakpoint_trap);
setvect (4,(void (__cdecl &)(void))overflow_trap);
setvect (5,(void (__cdecl &)(void))bounds_check_fault);
setvect (6,(void (__cdecl &)(void))invalid_opcode_fault);
setvect (7,(void (__cdecl &)(void))no_device_fault);
setvect (8,(void (__cdecl &)(void))double_fault_abort);
setvect (10,(void (__cdecl &)(void))invalid_tss_fault);
setvect (11,(void (__cdecl &)(void))no_segment_fault);
setvect (12,(void (__cdecl &)(void))stack_fault);
setvect (13,(void (__cdecl &)(void))general_protection_fault);
setvect (14,(void (__cdecl &)(void))page_fault);
setvect (16,(void (__cdecl &)(void))fpu_fault);
setvect (17,(void (__cdecl &)(void))alignment_check_fault);
setvect (18,(void (__cdecl &)(void))machine_check_abort);
setvect (19,(void (__cdecl &)(void))simd_fpu_fault);
//! get memory size in KB
uint32_t memSize = 1024 + bootinfo->m_memoryLo + bootinfo->m_memoryHi*64;
//! initialize the physical memory manager
//! we place the memory bit map used by the PMM at the end of the kernel in memory
pmmngr_init (memSize, 0x100000 + kernelSize*512);
DebugPrintf("pmm initialized with %i KB physical memory; memLo: %i memHi: %i\n\n",
memSize,bootinfo->m_memoryLo,bootinfo->m_memoryHi);
DebugSetColor (0x19);
DebugPrintf ("Physical Memory Map:\n");
memory_region* region = (memory_region*)0x1000;
for (int i=0; i<15; ++i) {
//! sanity check; if type is > 4 mark it reserved
if (region[i].type>4)
region[i].type=1;
//! if start address is 0, there is no more entries, break out
if (i>0 && region[i].startLo==0)
break;
//! display entry
DebugPrintf ("region %i: start: 0x%x%x length (bytes): 0x%x%x type: %i (%s)\n", i,
region[i].startHi, region[i].startLo,
region[i].sizeHi,region[i].sizeLo,
region[i].type, strMemoryTypes[region[i].type-1]);
//! if region is avilable memory, initialize the region for use
if (region[i].type==1)
pmmngr_init_region (region[i].startLo, region[i].sizeLo);
}
//! deinit the region the kernel is in as its in use
pmmngr_deinit_region (0x100000, kernelSize*512);
DebugSetColor (0x17);
DebugPrintf ("\npmm regions initialized: %i allocation blocks; used or reserved blocks: %i\nfree blocks: %i\n",
pmmngr_get_block_count (), pmmngr_get_use_block_count (), pmmngr_get_free_block_count () );
//! allocating and deallocating memory examples...
DebugSetColor (0x12);
uint32_t* p = (uint32_t*)pmmngr_alloc_block ();
DebugPrintf ("\np allocated at 0x%x", p);
uint32_t* p2 = (uint32_t*)pmmngr_alloc_blocks (2);
DebugPrintf ("\nallocated 2 blocks for p2 at 0x%x", p2);
pmmngr_free_block (p);
p = (uint32_t*)pmmngr_alloc_block ();
DebugPrintf ("\nUnallocated p to free block 1. p is reallocated to 0x%x", p);
pmmngr_free_block (p);
pmmngr_free_blocks (p2, 2);
return 0;
}
Thread* ProcessManager::CreateThread(Process* pProcess, FILE* file)
{
unsigned char buf[512];
IMAGE_DOS_HEADER* dosHeader = 0;
IMAGE_NT_HEADERS* ntHeaders = 0;
unsigned char* memory = 0;
/* read 512 bytes into buffer */
volReadFile(file, buf, 512);
if (!validateImage(buf)) {
volCloseFile(file);
return 0;
}
dosHeader = (IMAGE_DOS_HEADER*)buf;
ntHeaders = (IMAGE_NT_HEADERS*)(dosHeader->e_lfanew + (uint32_t)buf);
Thread* pThread = new Thread();
pThread->pParent = pProcess;
pThread->kernelStack = 0;
pThread->priority = 1;
pThread->state = PROCESS_STATE_ACTIVE;
pThread->initialStack = 0;
pThread->stackLimit = (void*)((uint32_t)pThread->initialStack + 4096);
pThread->imageBase = ntHeaders->OptionalHeader.ImageBase;
pThread->imageSize = ntHeaders->OptionalHeader.SizeOfImage;
memset(&pThread->frame, 0, sizeof(trapFrame));
pThread->frame.eip = (uint32_t)ntHeaders->OptionalHeader.AddressOfEntryPoint + ntHeaders->OptionalHeader.ImageBase;
pThread->frame.flags = 0x200;
int pageRest = 0;
if ((pThread->imageSize % 4096) > 0)
pageRest = 1;
pProcess->dwPageCount = (pThread->imageSize / 4096) + pageRest;
memory = (unsigned char*)pmmngr_alloc_blocks(pProcess->dwPageCount);
/* map page into address space */
for (int i = 0; i <pProcess->dwPageCount; i++)
{
//DebugPrintf("\ndsfdsd");
vmmngr_mapPhysicalAddress(pProcess->pPageDirectory,
ntHeaders->OptionalHeader.ImageBase + i * 4096,
(uint32_t)memory + i * 4096,
I86_PTE_PRESENT | I86_PTE_WRITABLE | I86_PTE_USER);
}
memset(memory, 0, pThread->imageSize);
memcpy(memory, buf, 512);
/* load image into memory */
int fileRest = 0;
if ((pThread->imageSize % 512) != 0)
fileRest = 1;
int readCount = (pThread->imageSize / 512) + fileRest;
for (int i = 1; i < readCount; i++) {
if (file->eof == 1)
break;
volReadFile(file, memory + 512 * i, 512);
}
/* close file and return process ID */
volCloseFile(file);
/* Create userspace stack (process esp=0x100000) */
void* stack = (void*)(ntHeaders->OptionalHeader.ImageBase + ntHeaders->OptionalHeader.SizeOfImage + PAGE_SIZE);
void* stackPhys = (void*)pmmngr_alloc_block();
/* map user process stack space */
vmmngr_mapPhysicalAddress(pProcess->pPageDirectory,
(uint32_t)stack,
(uint32_t)stackPhys,
I86_PTE_PRESENT | I86_PTE_WRITABLE | I86_PTE_USER);
/* Create Heap*/
/* final initialization */
pThread->initialStack = stack;
pThread->frame.esp = (uint32_t)pThread->initialStack;
pThread->frame.ebp = pThread->frame.esp;
//DebugPrintf("\nThread Creation Success");
return pThread;
}
int _k_main(struct multiboot_info *bootinfo)
{
int i;
uint32_t memSize;
struct memory_region* region;
uint32_t *p,*p2;
/*Initialize hardware drivers*/
hw_initialize();
//! install our exception handlers
setvect (0, divide_by_zero_fault);
setvect (1, single_step_trap);
setvect (2, nmi_trap);
setvect (3, breakpoint_trap);
setvect (4, overflow_trap);
setvect (5, bounds_check_fault);
setvect (6, invalid_opcode_fault);
setvect (7, no_device_fault);
setvect (8, double_fault_abort);
setvect (10, invalid_tss_fault);
setvect (11, no_segment_fault);
setvect (12, stack_fault);
setvect (13, general_protection_fault);
setvect (14, page_fault);
setvect (16, fpu_fault);
setvect (17, alignment_check_fault);
setvect (18, machine_check_abort);
setvect (19, simd_fpu_fault);
ClrScr (0x13);
GotoXY (0,0);
SetColor (0x12);
Puts ("\n zygote OS v0.01\n");
SetColor (0x17);
/* Puts ("Enabled A20!\n");
Puts ("Initialized GDT and IDT!\n");
Puts ("Installed PIC, PIT, and exception handlers!\n");
Printf ("Cpu vender: %s \n", get_cpu_vender ());*/
//! get memory size in KB
memSize = 1024 + bootinfo->m_memoryLo + bootinfo->m_memoryHi*64;
//! initialize the physical memory manager
//! we place the memory bit map used by the PMM at the end of the kernel in memory
pmmngr_init (memSize, 0x100000);
Printf("pmm initialized with %i KB physical memory; memLo: %i memHi: %i\n",
memSize,bootinfo->m_memoryLo,bootinfo->m_memoryHi);
SetColor (0x19);
Printf ("Physical Memory Map:\n");
region = (struct memory_region*)0x1000;
for (i=0; i<15; ++i) {
//! sanity check; if type is > 4 mark it reserved
if (region[i].type>4)
region[i].type=1;
//! if start address is 0, there is no more entries, break out
if (i>0 && region[i].startLo==0)
break;
//! display entry
Printf ("region %i: start: 0x%x%x length (bytes): 0x%x%x type: %i (%s)\n", i,
region[i].startHi, region[i].startLo,
region[i].sizeHi,region[i].sizeLo,
region[i].type, strMemoryTypes[region[i].type-1]);
//! if region is avilable memory, initialize the region for use
if (region[i].type==1)
pmmngr_init_region (region[i].startLo, region[i].sizeLo);
}
SetColor (0x17);
Printf ("\npmm regions initialized: %i allocation blocks; used or reserved blocks: %i\nfree blocks: %i\n",
pmmngr_get_block_count (), pmmngr_get_use_block_count (), pmmngr_get_free_block_count () );
//! allocating and deallocating memory examples...
SetColor (0x12);
p = (uint32_t*)pmmngr_alloc_block ();
Printf ("\np allocated at 0x%x", p);
p2 = (uint32_t*)pmmngr_alloc_blocks (2);
Printf ("\nallocated 2 blocks for p2 at 0x%x", p2);
pmmngr_free_block (p);
p = (uint32_t*)pmmngr_alloc_block ();
Printf ("\nUnallocated p to free block 1. p is reallocated to 0x%x", p);
pmmngr_free_block (p);
pmmngr_free_blocks (p2, 2);
//To test divide by zero exception
//i = 10/0;
Puts ("\nHitting any key will fire the default handlers \n");
for(;;) {
}
};
