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(;;) { } };