[GOOD] BUILD 0.1.0.450 DATE 8/29/2011 AT 10:30 AM

==================================================== + Changed 'align 0x4' line above multiboot header in loader.asm to 'align 4' + Removed -e option for echo in build.sh + Modified build.sh for linux + Fixed triple fault when enabling paging + Fixed page faults at memory manager initialization + Fixed 'mem' console function + Added more info about page fault at crash screen + Added Panic() macro + Added verbose mode for memory manager [ BAD] BUILD 0.1.0.390 DATE 8/27/2011 AT 10:54 PM ==================================================== + Added stdlib routines, separated in different files + Rewritten physical memory manager + Added virtual mem manager + Added memory allocation/freeing + Added memory library + Added temporary allocation (at end of kernel), until paging is started - Removed functionality from debug console function 'mem' - Removed system.h, the one remaining function now in stdio.h
2021-09-14 18:48:57 +03:00
parent b6ddeca1c3
commit 913e65b856
326 changed files with 6990 additions and 12229 deletions
--- a/Kernel/library/ctype.c
+++ b/Kernel/library/ctype.c
@ -0,0 +1,146 @@
+#include<ctype.h>
+
+unsigned char _ctype[256] =
+{
+    0,                              // -1 EOF
+    _CTYPE_ISCONTROL,               // 00 (NUL)
+    _CTYPE_ISCONTROL,               // 01 (SOH)
+    _CTYPE_ISCONTROL,               // 02 (STX)
+    _CTYPE_ISCONTROL,               // 03 (ETX)
+    _CTYPE_ISCONTROL,               // 04 (EOT)
+    _CTYPE_ISCONTROL,               // 05 (ENQ)
+    _CTYPE_ISCONTROL,               // 06 (ACK)
+    _CTYPE_ISCONTROL,               // 07 (BEL)
+    _CTYPE_ISCONTROL,               // 08 (BS)
+    _CTYPE_ISSPACE+_CTYPE_ISCONTROL,        // 09 (HT)
+    _CTYPE_ISSPACE+_CTYPE_ISCONTROL,        // 0A (LF)
+    _CTYPE_ISSPACE+_CTYPE_ISCONTROL,        // 0B (VT)
+    _CTYPE_ISSPACE+_CTYPE_ISCONTROL,        // 0C (FF)
+    _CTYPE_ISSPACE+_CTYPE_ISCONTROL,        // 0D (CR)
+    _CTYPE_ISCONTROL,               // 0E (SI)
+    _CTYPE_ISCONTROL,               // 0F (SO)
+    _CTYPE_ISCONTROL,               // 10 (DLE)
+    _CTYPE_ISCONTROL,               // 11 (DC1)
+    _CTYPE_ISCONTROL,               // 12 (DC2)
+    _CTYPE_ISCONTROL,               // 13 (DC3)
+    _CTYPE_ISCONTROL,               // 14 (DC4)
+    _CTYPE_ISCONTROL,               // 15 (NAK)
+    _CTYPE_ISCONTROL,               // 16 (SYN)
+    _CTYPE_ISCONTROL,               // 17 (ETB)
+    _CTYPE_ISCONTROL,               // 18 (CAN)
+    _CTYPE_ISCONTROL,               // 19 (EM)
+    _CTYPE_ISCONTROL,               // 1A (SUB)
+    _CTYPE_ISCONTROL,               // 1B (ESC)
+    _CTYPE_ISCONTROL,               // 1C (FS)
+    _CTYPE_ISCONTROL,               // 1D (GS)
+    _CTYPE_ISCONTROL,               // 1E (RS)
+    _CTYPE_ISCONTROL,               // 1F (US)
+    _CTYPE_ISSPACE+_CTYPE_ISBLANK,          // 20 SPACE
+    _CTYPE_ISPUNCT,                 // 21 !
+    _CTYPE_ISPUNCT,                 // 22 "
+    _CTYPE_ISPUNCT,                 // 23 #
+    _CTYPE_ISPUNCT,                 // 24 $
+    _CTYPE_ISPUNCT,                 // 25 %
+    _CTYPE_ISPUNCT,                 // 26 &
+    _CTYPE_ISPUNCT,                 // 27 '
+    _CTYPE_ISPUNCT,                 // 28 (
+    _CTYPE_ISPUNCT,                 // 29 )
+    _CTYPE_ISPUNCT,                 // 2A *
+    _CTYPE_ISPUNCT,                 // 2B +
+    _CTYPE_ISPUNCT,                 // 2C ,
+    _CTYPE_ISPUNCT,                 // 2D -
+    _CTYPE_ISPUNCT,                 // 2E .
+    _CTYPE_ISPUNCT,                 // 2F /
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 30 0
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 31 1
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 32 2
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 33 3
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 34 4
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 35 5
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 36 6
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 37 7
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 38 8
+    _CTYPE_ISDIGIT+_CTYPE_ISHEX,            // 39 9
+    _CTYPE_ISPUNCT,                 // 3A :
+    _CTYPE_ISPUNCT,                 // 3B ;
+    _CTYPE_ISPUNCT,                 // 3C <
+    _CTYPE_ISPUNCT,                 // 3D =
+    _CTYPE_ISPUNCT,                 // 3E >
+    _CTYPE_ISPUNCT,                 // 3F ?
+    _CTYPE_ISPUNCT,                 // 40 @
+    _CTYPE_ISUPPER+_CTYPE_ISHEX,            // 41 A
+    _CTYPE_ISUPPER+_CTYPE_ISHEX,            // 42 B
+    _CTYPE_ISUPPER+_CTYPE_ISHEX,            // 43 C
+    _CTYPE_ISUPPER+_CTYPE_ISHEX,            // 44 D
+    _CTYPE_ISUPPER+_CTYPE_ISHEX,            // 45 E
+    _CTYPE_ISUPPER+_CTYPE_ISHEX,            // 46 F
+    _CTYPE_ISUPPER,                 // 47 G
+    _CTYPE_ISUPPER,                 // 48 H
+    _CTYPE_ISUPPER,                 // 49 I
+    _CTYPE_ISUPPER,                 // 4A J
+    _CTYPE_ISUPPER,                 // 4B K
+    _CTYPE_ISUPPER,                 // 4C L
+    _CTYPE_ISUPPER,                 // 4D M
+    _CTYPE_ISUPPER,                 // 4E N
+    _CTYPE_ISUPPER,                 // 4F O
+    _CTYPE_ISUPPER,                 // 50 P
+    _CTYPE_ISUPPER,                 // 51 Q
+    _CTYPE_ISUPPER,                 // 52 R
+    _CTYPE_ISUPPER,                 // 53 S
+    _CTYPE_ISUPPER,                 // 54 T
+    _CTYPE_ISUPPER,                 // 55 U
+    _CTYPE_ISUPPER,                 // 56 V
+    _CTYPE_ISUPPER,                 // 57 W
+    _CTYPE_ISUPPER,                 // 58 X
+    _CTYPE_ISUPPER,                 // 59 Y
+    _CTYPE_ISUPPER,                 // 5A Z
+    _CTYPE_ISPUNCT,                 // 5B [
+    _CTYPE_ISPUNCT,                 // 5C backslash
+    _CTYPE_ISPUNCT,                 // 5D ]
+    _CTYPE_ISPUNCT,                 // 5E ^
+    _CTYPE_ISPUNCT,                 // 5F _
+    _CTYPE_ISPUNCT,                 // 60 `
+    _CTYPE_ISLOWER+_CTYPE_ISHEX,            // 61 a
+    _CTYPE_ISLOWER+_CTYPE_ISHEX,            // 62 b
+    _CTYPE_ISLOWER+_CTYPE_ISHEX,            // 63 c
+    _CTYPE_ISLOWER+_CTYPE_ISHEX,            // 64 d
+    _CTYPE_ISLOWER+_CTYPE_ISHEX,            // 65 e
+    _CTYPE_ISLOWER+_CTYPE_ISHEX,            // 66 f
+    _CTYPE_ISLOWER,                 // 67 g
+    _CTYPE_ISLOWER,                 // 68 h
+    _CTYPE_ISLOWER,                 // 69 i
+    _CTYPE_ISLOWER,                 // 6A j
+    _CTYPE_ISLOWER,                 // 6B k
+    _CTYPE_ISLOWER,                 // 6C l
+    _CTYPE_ISLOWER,                 // 6D m
+    _CTYPE_ISLOWER,                 // 6E n
+    _CTYPE_ISLOWER,                 // 6F o
+    _CTYPE_ISLOWER,                 // 70 p
+    _CTYPE_ISLOWER,                 // 71 q
+    _CTYPE_ISLOWER,                 // 72 r
+    _CTYPE_ISLOWER,                 // 73 s
+    _CTYPE_ISLOWER,                 // 74 t
+    _CTYPE_ISLOWER,                 // 75 u
+    _CTYPE_ISLOWER,                 // 76 v
+    _CTYPE_ISLOWER,                 // 77 w
+    _CTYPE_ISLOWER,                 // 78 x
+    _CTYPE_ISLOWER,                 // 79 y
+    _CTYPE_ISLOWER,                 // 7A z
+    _CTYPE_ISPUNCT,                 // 7B {
+    _CTYPE_ISPUNCT,                 // 7C +
+    _CTYPE_ISPUNCT,                 // 7D }
+    _CTYPE_ISPUNCT,                 // 7E ~
+    _CTYPE_ISCONTROL,               // 7F (DEL)
+    // and the rest are 0...
+};
+
+
+int toupper(int c)
+{
+    return ((islower(c)) ? (c-'a'+'A') : c);
+}
+
+int tolower(int c)
+{
+    return((isupper(c)) ? (c-'A'+'a') : c);
+}
--- a/Kernel/library/memory/memory_alloc.c
+++ b/Kernel/library/memory/memory_alloc.c
@ -0,0 +1,84 @@
+/*
+ * memory_alloc.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+
+#include <memory-add.h>
+
+extern uint32 mem_kernel_end;
+extern uint8 mem_initialized;
+
+// Used prior to proper initialization
+uint32 _malloc_init1 (uint32 size, uint8 page_aligned)
+{
+	uint32 ret = mem_kernel_end;
+
+	if (page_aligned && (ret & 0xfff)) ret = (ret & 0xfffff000) + 0x1000;
+	mem_kernel_end = size + ret;
+
+	LogMem("%#Allocated %u bytes (%spage aligned) at end of kernel (0x%x).\n", ColorLightMagenta, size, ((page_aligned) ? "" : "not "), ret);
+	return (ret);
+}
+
+uint32 _malloc_init2 (uint32 size, uint8 page_aligned, uint32* phys)
+{
+	uint32 ret = MemHeapAlloc(size, page_aligned, KernelHeap, KernelDirectory);
+
+	if (phys)
+	{
+		Page *pg = PagingGetPage(ret, 0, KernelDirectory);
+		*phys = (*pg & PageFrame) + (ret & 0xFFF);
+
+		LogMem("%#Allocated %u bytes (%spage aligned) at address 0x%x (phys=%x).\n", ColorLightMagenta, size, ((page_aligned) ? "" : "not "), ret, *phys);
+	}
+
+	else {
+		LogMem("%#Allocated %u bytes (%spage aligned) at address 0x%x.\n", ColorLightMagenta, size, ((page_aligned) ? "" : "not "), ret);
+	}
+
+	return ret;
+}
+
+// Allocate 'size' bytes
+void* kmalloc (uint32 size)
+{
+	if (!mem_initialized) return 0;
+	if (mem_initialized == 1) return (void*)_malloc_init1(size, 0);
+
+	return (void*)_malloc_init2(size,0,0);
+}
+
+// Allocate 'size' bytes, page aligned
+void* kmalloc_a(uint32 size)
+{
+	if (!mem_initialized) return 0;
+	if (mem_initialized == 1) return (void*)_malloc_init1(size, 1);
+
+	return (void*)_malloc_init2(size,1,0);
+}
+
+void* kmalloc_p(uint32 size, uint32* phys)
+{
+	if (!mem_initialized) return 0;
+	if (mem_initialized == 1) 	{
+		*phys = _malloc_init1(size,0);
+		return (void*)(*phys);
+	}
+
+	return (void*)_malloc_init2(size,0,phys);
+}
+
+void* kmalloc_ap(uint32 size, uint32* phys)
+{
+	if (!mem_initialized) return 0;
+	
+	uint32 ret;
+	if (mem_initialized == 1) 	{
+		*phys = ret = _malloc_init1(size,1);
+	}
+	
+	else ret = _malloc_init2(size,1,phys);
+	return (void*)ret;
+}
--- a/Kernel/library/memory/memory_alloc.c~
+++ b/Kernel/library/memory/memory_alloc.c~
@ -0,0 +1,87 @@
+/*
+ * memory_alloc.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+
+#include <memory-add.h>
+
+extern uint32 mem_kernel_end;
+extern uint8 mem_initialized;
+
+// Used prior to proper initialization
+uint32 _malloc_init1 (uint32 size, uint8 page_aligned)
+{
+	uint32 ret = mem_kernel_end;
+
+	if (page_aligned && (ret & 0xfff)) ret = (ret & 0xfffff000) + 0x1000;
+	mem_kernel_end = size + ret;
+
+	LogMem("%#Allocated %u bytes (%spage aligned) at end of kernel (0x%x).\n", ColorLightMagenta, size, ((page_aligned) ? "" : "not "), ret);
+	return (ret);
+}
+
+uint32 _malloc_init2 (uint32 size, uint8 page_aligned, uint32* phys)
+{
+	uint32 ret = MemHeapAlloc(size, page_aligned, KernelHeap, KernelDirectory);
+
+	if (phys)
+	{
+		Page *pg = PagingGetPage(ret, 0, KernelDirectory);
+		*phys = (*pg & PageFrame) + (ret & 0xFFF);
+
+		LogMem("%#Allocated %u bytes (%spage aligned) at address 0x%x (phys=%x).\n", ColorLightMagenta, size, ((page_aligned) ? "" : "not "), ret, *phys);
+	}
+
+	else {
+		LogMem("%#Allocated %u bytes (%spage aligned) at address 0x%x.\n", ColorLightMagenta, size, ((page_aligned) ? "" : "not "), ret);
+	}
+
+	return ret;
+}
+
+// Allocate 'size' bytes
+void* kmalloc (uint32 size)
+{
+	if (!mem_initialized) return 0;
+	if (mem_initialized == 1) return (void*)_malloc_init1(size, 0);
+
+	return (void*)_malloc_init2(size,0,0);
+}
+
+// Allocate 'size' bytes, page aligned
+void* kmalloc_a(uint32 size)
+{
+	if (!mem_initialized) return 0;
+	if (mem_initialized == 1) return (void*)_malloc_init1(size, 1);
+
+	return (void*)_malloc_init2(size,1,0);
+}
+
+void* kmalloc_p(uint32 size, uint32* phys)
+{
+	if (!mem_initialized) return 0;
+	if (mem_initialized == 1) 	{
+		*phys = _malloc_init1(size,0);
+		return (void*)(*phys);
+	}
+
+	return (void*)_malloc_init2(size,0,phys);
+}
+
+void* kmalloc_ap(uint32 size, uint32* phys)
+{
+	if (!mem_initialized) return 0;
+	
+	uint32 ret;
+	if (mem_initialized == 1) 	{
+		*phys = ret = _malloc_init1(size,1);
+	}
+	
+	else ret = _malloc_init2(size,1,phys);
+	
+	LogMem("%#kmalloc_ap requested, returned 0x%x, phys = 0x%x.\n", ColorMagenta, ret, *phys);
+
+	return (void*)ret;
+}
--- a/Kernel/library/memory/memory_free.c
+++ b/Kernel/library/memory/memory_free.c
@ -0,0 +1,20 @@
+/*
+ * memory_free.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+
+#include <memory-add.h>
+
+extern uint8 mem_initialized;
+
+void kfree(void* addr)
+{
+	if (mem_initialized < 2) {
+		ErrorMem("%#Tried to free at address 0x%x when memory manager is uninitialized.\n", ColorLightRed, (uint32)addr);
+		return;
+	}
+
+	MemHeapFree((uint32)addr, KernelHeap, KernelDirectory);
+}
--- a/Kernel/library/memory/memory_info.c
+++ b/Kernel/library/memory/memory_info.c
@ -0,0 +1,48 @@
+/*
+ * memory_info.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+
+#include <memory-add.h>
+// MemoryGetFree(), MemoryGetTotal(), MemoryGet blah blah...
+
+// Returns total physical memory in bytes
+uint32 MemoryGetTotal()
+{
+	return (TotalMemory);
+}
+
+// Returns total free physical memory in bytes
+uint32 MemoryGetFree()
+{
+	return (TotalFrames - UsedFrames) * 0x4;
+}
+
+// Total used physical memory in bytes
+uint32 MemoryGetUsed()
+{
+	return UsedFrames * 0x4;
+}
+
+// Same as above functions, but in frames
+uint32 MemoryGetFrameSize()
+{
+	return 0x4;
+}
+
+uint32 MemoryGetFramesTotal()
+{
+	return TotalFrames;
+}
+
+uint32 MemoryGetFramesUsed()
+{
+	return UsedFrames;
+}
+
+uint32 MemoryGetFramesFree()
+{
+	return (TotalFrames - UsedFrames);
+}
--- a/Kernel/library/memory/memory_info.c~
+++ b/Kernel/library/memory/memory_info.c~
@ -0,0 +1,48 @@
+/*
+ * memory_info.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+
+#include <memory-add.h>
+// MemoryGetFree(), MemoryGetTotal(), MemoryGet blah blah...
+
+// Returns total physical memory in bytes
+uint32 MemoryGetTotal()
+{
+	return (TotalMemory);
+}
+
+// Returns total free physical memory in bytes
+uint32 MemoryGetFree()
+{
+	return (TotalFrames - UsedFrames) * 0x4;
+}
+
+// Total used physical memory in bytes
+uint32 MemoryGetUsed()
+{
+	return UsedFrames * 0x4;
+}
+
+// Same as above functions, but in frames
+uint32 MemoryGetFrameSize()
+{
+	return 0x1000;
+}
+
+uint32 MemoryGetFramesTotal()
+{
+	return TotalFrames;
+}
+
+uint32 MemoryGetFramesUsed()
+{
+	return UsedFrames;
+}
+
+uint32 MemoryGetFramesFree()
+{
+	return (TotalFrames - UsedFrames);
+}
--- a/Kernel/library/memory/memory_init.c
+++ b/Kernel/library/memory/memory_init.c
@ -0,0 +1,88 @@
+/*
+ * memory-init.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <memory-add.h>
+#include <multiboot.h>
+#include <debugio.h>
+#include "../../drivers/cmos/cmos.h"
+#include <stdio.h>
+
+
+uint32 mem_kernel_end = 0;
+uint8 mem_initialized = 0;
+
+uint32 _memory_get_total_mem(MultibootInfo* info)
+{
+	// Grub was nice enough to give us info
+	if (info->Flags & MultibootInfo_MEMORY) return (1024 + info->MemoryUpper);
+
+	// No? Get info from CMOS
+	uint8 low, high;
+	uint32 total;
+
+	low = CmosRead(0x30);
+	high = CmosRead(0x31);
+	total = (uint32)(low | high<<8) + 1024;
+
+	ErrorMem("%#Missing memory info from bootloader. Reading from CMOS: %ukb\n", ColorLightRed, total);
+
+	return total;
+}
+
+void _memory_reserve_system(MultibootInfo* info)
+{
+	MagicBreakpoint();
+	if ((info->Flags & MultibootInfo_MEM_MAP) != 0)
+	{
+		MultibootMemoryMapEntry* location = (MultibootMemoryMapEntry*)info->MemoryMapAddress;
+
+		while ((uint32)location < (info->MemoryMapAddress + info->MemoryMapLength))
+		{
+			if (location->Type > 1)
+				MemPhReserveFrames((uint32)location->Address, (uint32)location->Length);
+
+			location = (MultibootMemoryMapEntry*) ((uint32)location + location->Size + sizeof(uint32));
+		}
+	}
+
+	else
+	{
+		ErrorMem("%#Missing %#memory map%# info from bootloader.\n", ColorLightRed, ColorWhite, ColorLightRed);
+
+		// Standard memory hole at 15mb
+		MemPhReserveFrames(0x00F00000, 0x00100000);
+	}
+
+	// Standard reserved memory areas
+	MemPhReserveFrames(0x0, 0x400 + 256);	// Real mode IVT, BDA
+	MemPhReserveFrames(0x1000, 0x2400);		// DMA buffer
+	MemPhReserveFrames(0x9FC00, 385*1024); // EBDA, Video memory, ROM area
+}
+
+
+void MemoryInitialize (MultibootInfo* info)
+{
+	uint32 totalSystemMemory = _memory_get_total_mem(info);
+
+	MemPhInitialize(totalSystemMemory);
+	PagingInitialize(0x200000);
+
+	_memory_reserve_system(info);
+
+	KernelHeap = MemHeapCreate(KERNEL_HEAP_START, KERNEL_HEAP_START
+			+ KERNEL_HEAP_INITIAL_SIZE, 0xCFFFF000, 3);	// is kernel, writeable
+
+	LogMem("Done initializing memory!");
+	
+	mem_initialized = 2;
+}
+
+void MemoryTempInitialize (uint32 kernel_end)
+{
+	mem_initialized = 1;
+	mem_kernel_end = kernel_end;
+	LogMem("Initialized temporary memory manager, allocating from %#0x%x.\n", kernel_end);
+}
--- a/Kernel/library/memory/memory_init.c~
+++ b/Kernel/library/memory/memory_init.c~
@ -0,0 +1,92 @@
+/*
+ * memory-init.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <memory-add.h>
+#include <multiboot.h>
+#include <debugio.h>
+#include "../../drivers/cmos/cmos.h"
+#include <stdio.h>
+
+
+uint32 mem_kernel_end = 0;
+uint8 mem_initialized = 0;
+
+uint32 _memory_get_total_mem(MultibootInfo* info)
+{
+	// Grub was nice enough to give us info
+	if (info->Flags & MultibootInfo_MEMORY) return (1024 + info->MemoryUpper);
+
+	// No? Get info from CMOS
+	uint8 low, high;
+	uint32 total;
+
+	low = CmosRead(0x30);
+	high = CmosRead(0x31);
+	total = (uint32)(low | high<<8) + 1024;
+
+	ErrorMem("%#Missing memory info from bootloader. Reading from CMOS: %ukb\n", ColorLightRed, total);
+
+	return total;
+}
+
+void _memory_reserve_system(MultibootInfo* info)
+{
+	MagicBreakpoint();
+	if ((info->Flags & MultibootInfo_MEM_MAP) != 0)
+	{
+		MultibootMemoryMapEntry* location = (MultibootMemoryMapEntry*)info->MemoryMapAddress;
+
+		while ((uint32)location < (info->MemoryMapAddress + info->MemoryMapLength))
+		{
+			if (location->Type > 1)
+				MemPhReserveFrames((uint32)location->Address, (uint32)location->Length);
+
+			location = (MultibootMemoryMapEntry*) ((uint32)location + location->Size + sizeof(uint32));
+		}
+	}
+
+	else
+	{
+		ErrorMem("%#Missing %#memory map%# info from bootloader.\n", ColorLightRed, ColorWhite, ColorLightRed);
+
+		// Standard memory hole at 15mb
+		MemPhReserveFrames(0x00F00000, 0x00100000);
+	}
+
+	// Standard reserved memory areas
+	MemPhReserveFrames(0x0, 0x400 + 256);	// Real mode IVT, BDA
+	MemPhReserveFrames(0x1000, 0x2400);		// DMA buffer
+	MemPhReserveFrames(0x9FC00, 385*1024); // EBDA, Video memory, ROM area
+}
+
+
+void MemoryInitialize (MultibootInfo* info)
+{
+	uint32 totalSystemMemory = _memory_get_total_mem(info);
+
+	MemPhInitialize(totalSystemMemory);
+	PagingInitialize(0x200000);
+
+	LogMem("Reserving important areas...\n");
+	
+	_memory_reserve_system(info);
+
+	LogMem("Allocating kernel heap...\n");
+	
+	KernelHeap = MemHeapCreate(KERNEL_HEAP_START, KERNEL_HEAP_START
+			+ KERNEL_HEAP_INITIAL_SIZE, 0xCFFFF000, 3);	// is kernel, writeable
+
+	LogMem("Done initializing memory!");
+	
+	mem_initialized = 2;
+}
+
+void MemoryTempInitialize (uint32 kernel_end)
+{
+	mem_initialized = 1;
+	mem_kernel_end = kernel_end;
+	LogMem("Initialized temporary memory manager, allocating from %#0x%x.\n", kernel_end);
+}
--- a/Kernel/library/stdio.c
+++ b/Kernel/library/stdio.c
@ -0,0 +1,44 @@
+#include <stdio.h>
+#include "../hal/keyboard/keyboard.h"
+
+uint8 inportb (uint16 _port) {
+      uint8 rv;
+      __asm__ __volatile__ ("inb %1, %0" : "=a" (rv) : "dN" (_port));
+      return rv;
+}
+
+Key ReadKey()
+{
+	Key key;
+
+	do {
+		KeyboardLastScancode = 0xFF ;
+		while (KeyboardLastScancode == 0xFF) ;
+
+		key.Scancode = KeyboardLastScancode;
+
+	} while (KeyboardLastStatus & 1);
+
+	if (KeyboardGetKeyStatus(KeyboardKeyLeftShift) || KeyboardGetKeyStatus(KeyboardKeyRightShift))
+		key.Character = KeyboardMapShift[key.Scancode];
+	else key.Character = KeyboardMap[key.Scancode];
+
+	return key;
+}
+
+KeyEvent ReadKeyEvent()
+{
+	KeyEvent key;
+
+	KeyboardLastScancode = 0xFF ;
+	while (KeyboardLastScancode == 0xFF) ;
+
+	key.Scancode = KeyboardLastScancode;
+	key.Pressed = 1 - (KeyboardLastStatus & 1);
+	
+	if (KeyboardGetKeyStatus(KeyboardKeyLeftShift) || KeyboardGetKeyStatus(KeyboardKeyRightShift))
+		key.Character = KeyboardMapShift[key.Scancode];
+	else key.Character = KeyboardMap[key.Scancode];
+
+	return key;
+}
--- a/Kernel/library/stdlib/convert_ops.c
+++ b/Kernel/library/stdlib/convert_ops.c
@ -0,0 +1,100 @@
+/*
+ * convert_ops.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <stdlib.h>
+
+const string _Numbers = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+int32 ConvertIntToString (string buffer, int32 number, int32 base)
+{
+	if (base > 36 || base < 2) return 0;
+
+	int32 len = numlen (number, base), beg = 0, i;
+	uint32 n = (uint32) number;
+
+	// If number is negative and in base 10, we put a '-' in front
+	if (number < 0 && base == 10) buffer[beg++] = '-';
+
+	// Put every digit in string
+	for (i = len-1; i>=beg; i--)
+	{
+		buffer[i] = _Numbers[n % base];
+		n /= base;
+	}
+
+	buffer[len] = 0;
+	return number;
+}
+
+uint32 ConvertUIntToString (string buffer, uint32 number, int32 base)
+{
+	if (base > 36 || base < 2) return 0;
+
+	int32 len = unumlen (number, base), i;
+
+	// Put every digit in string
+	for (i = len-1; i >= 0; i--)
+	{
+		buffer[i] = _Numbers[number % base];
+		number /= base;
+	}
+
+	buffer[len] = 0;
+	return number;
+}
+
+int32 ConvertStringToInt (string buffer)
+{
+	int8 negative = (buffer[0] == '-');
+	int32 pos = (buffer[0] == '-' );
+
+	int32 number = 0;
+
+	while (IsDigit(buffer[pos]))
+	{
+		number = number*10 + (buffer[pos] - '0');
+		pos++;
+	}
+
+	if (negative) return -number;
+	return number;
+}
+
+uint32 ConvertStringToUInt (string buffer)
+{
+	int32 pos = 0;
+	int32 number = 0;
+
+	while (IsDigit(buffer[pos]))
+	{
+		number = number*10 + (buffer[pos] - '0');
+		pos++;
+	}
+
+	return number;
+}
+
+uint32 ConvertStringToIntHex (string buffer)
+{
+	int32 pos = 0;
+	uint32 number = 0;
+
+	// Skip first 2 digits if it is in format 0xXXXX...
+	if (buffer[1] == 'x' || buffer[1] == 'X') pos = 2;
+
+	while (IsHexDigit(buffer[pos]))
+	{
+		number = number*0x10;
+
+		if (IsDigit(buffer[pos])) number += buffer[pos] - '0';
+		else if (buffer[pos] >= 'a' && buffer[pos] <= 'f') number += 10 + buffer[pos] - 'a';
+		else if (buffer[pos] >= 'A' && buffer[pos] <= 'F') number += 10 + buffer[pos] - 'A';
+
+		pos++;
+	}
+
+	return number;
+}
--- a/Kernel/library/stdlib/mem_ops.c
+++ b/Kernel/library/stdlib/mem_ops.c
@ -0,0 +1,42 @@
+/*
+ * mem_ops.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <types.h>
+
+void *memcpy(void *dest, const void *src, uint32 count)
+{
+	uint8* d = (uint8*) dest;
+	const uint8* s = (const uint8*) src;
+
+	while (count-- != 0)
+		*d++ = *s++;
+
+	return dest;
+}
+
+int32 memcmp(const void *s1, const void *s2, uint32 count)
+{
+	const uint8 *us1 = (const uint8*) s1;
+	const uint8 *us2 = (const uint8*) s2;
+
+	while (count-- != 0)
+	{
+		if (*us1 != *us2) return (*us1 < *us2) ? -1 : 1;
+		us1++; us2++;
+	}
+
+	return 0;
+}
+
+
+void *memset(void *dest, uint8 val, uint32 count)
+{
+	uint8 *temp = (uint8 *)dest;
+	while (count-- != 0)
+		*temp++ = val;
+
+	return dest;
+}
--- a/Kernel/library/stdlib/num_ops.c
+++ b/Kernel/library/stdlib/num_ops.c
@ -0,0 +1,39 @@
+/*
+ * num_ops.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <types.h>
+
+uint32 numlen (int32 number, int32 base)
+{
+	// Sanity check
+	if (base < 2) return 0;
+
+	uint32 len = (number < 0 && base == 10);	// add minus sign
+	if (number == 0) return 1;
+
+	while (number) 	{
+		number /= base;
+		++len;
+	}
+
+	return len;
+}
+
+uint32 unumlen (uint32 number, int32 base)
+{
+	// Sanity check
+	if (base < 2) return 0;
+
+	uint32 len = 0;
+	if (number == 0) return 1;
+
+	while (number) 	{
+		number /= base;
+		++len;
+	}
+
+	return len;
+}
--- a/Kernel/library/stdlib/ord_arr.c
+++ b/Kernel/library/stdlib/ord_arr.c
@ -0,0 +1,112 @@
+/*
+ * ord-arr.c
+ *
+ *  Created on: Aug 25, 2011
+ *      Author: Tiberiu
+ */
+
+
+/*
+ * memory.c
+ *
+ *  Created on: Aug 24, 2011
+ *      Author: Tiberiu
+ */
+
+#include <stdlib.h>
+#include <memory.h>
+
+int StandardComparePredicate (uint32 a, uint32 b)
+{
+	if (a > b) return 1;
+	else if (a == b) return 0;
+	return -1;
+}
+
+OrderedArray OrderedArrayCreate (uint32 maxSize, ComparePredicate p)
+{
+	OrderedArray ret;
+	ret.Data = (unsigned*) kmalloc(maxSize);
+	memset(ret.Data, 0, maxSize);
+	ret.Size = 0;
+	ret.SizeLimit = maxSize;
+	ret.Compare = (p == 0) ? StandardComparePredicate : p;
+
+	return ret;
+}
+
+OrderedArray OrderedArrayPlace (uint32 addr, uint32 maxSize, ComparePredicate p)
+{
+	OrderedArray ret;
+	ret.Data = (unsigned*)addr;
+	memset(ret.Data, 0, maxSize);
+	ret.Size = 0;
+	ret.SizeLimit = maxSize;
+	ret.Compare = (p == 0) ? StandardComparePredicate : p;
+
+	return ret;
+}
+
+void OrderedArrayDispose (OrderedArray* arr)
+{
+	kfree(arr->Data);
+}
+
+uint32 OrderedArrayBinarySearch (uint32 key, uint32* array, uint32 length, ComparePredicate predicate)
+{
+	if (!predicate) return 0;
+
+	uint32 left = 0, right = length, mid;
+
+	while (left < right)
+	{
+		mid = left + (right-left) / 2;
+
+		int r = (*predicate)(key, array[mid]);
+
+		if (r > 0) left = mid + 1;
+		else if (r < 0) right = mid;
+		else return mid;
+	}
+	mid = left + (right-left) / 2;
+
+	return mid;
+}
+
+uint32 OrderedArraySearch (uint32 key, OrderedArray* arr, ComparePredicate predicate)
+{
+	uint32 r = OrderedArrayBinarySearch(key,arr->Data,arr->Size,predicate);
+
+	if (arr->Data[r] != key) return 0xffffffff;
+	return r;
+}
+
+void OrderedArrayInsert (uint32 item, OrderedArray* arr)
+{
+	if (arr->Size >= arr->SizeLimit) return;
+
+	uint32 location = OrderedArrayBinarySearch(item, arr->Data, arr->Size, arr->Compare);
+
+	uint32 i;
+	for (i = arr->Size; i > location && arr->Size > 0; i--)
+		arr->Data[i] = arr->Data[i-1];
+
+	arr->Data[location] = item;
+	arr->Size++;
+}
+
+uint32 OrderedArrayLookup (uint32 index, OrderedArray* arr)
+{
+	if (index >= arr->Size) return 0;
+	return arr->Data[index];
+}
+
+void OrderedArrayDeleteIndex (uint32 index, OrderedArray* arr)
+{
+	if (index >= arr->Size) return;
+
+	uint32 i;
+	for (i = index + 1; i < arr->Size; i++)
+		arr->Data[i - 1] = arr->Data[i];
+	arr->Size--;
+}
--- a/Kernel/library/stdlib/str_ops.c
+++ b/Kernel/library/stdlib/str_ops.c
@ -0,0 +1,39 @@
+/*
+ * str_ops.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <types.h>
+
+uint32 strlen (string s)
+{
+	string end = s;
+	while (*end != '\0')
+		end++;
+
+	return (uint32)(end - s);
+}
+
+int32 strcmp (string a, string b)
+{
+	unsigned char c1, c2;
+
+	while (*a != '\0' && *b != '\0' && *a == *b) {
+		a++; b++;
+	}
+
+	c1 = (*(unsigned char*) a);
+	c2 = (*(unsigned char*) b);
+	return ((c1 < c2) ? -1 : (c1 > c2));
+}
+
+string strcpy (string s1, const string s2)
+{
+	char *dst = s1;
+	const char *src = s2;
+
+	while ((*dst++ = *src++) != '\0') ;
+
+	return s1;
+}
--- a/Kernel/library/storage.c
+++ b/Kernel/library/storage.c
@ -0,0 +1,18 @@
+/*
+ * storage.c
+ *
+ *  Created on: Aug 23, 2011
+ *      Author: Tiberiu
+ */
+
+#include <storage.h>
+
+void ConvertLbaToChs(uint32 SectorsPerTrack, uint32 lba, uint32 *cyl, uint32 *head, uint32 *sector)
+{
+	// Avoid division by 0
+	if (SectorsPerTrack == 0) return;
+
+	*head = (lba % (SectorsPerTrack * 2)) / SectorsPerTrack;
+	*cyl = lba / (SectorsPerTrack * 2);
+	*sector = lba % SectorsPerTrack + 1;
+}
--- a/Kernel/library/time.c
+++ b/Kernel/library/time.c
@ -0,0 +1,98 @@
+#include <time.h>
+extern volatile TimeSystem _internal_time;
+extern uint32 _internal_frequency_hz;
+
+// Length of months (summed)
+const int16 MonthLen[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
+
+
+TimeSystem TimeConvertToTimeSystem (Time t)
+{
+	TimeSystem sys = {0,0};
+	
+	t.Year--; t.Month--; t.Day--; t.WeekDay--;
+
+	sys.Time = (uint32)(t.Hour * 3600000) + (uint32)(t.Minute * 60000) + (uint32)(t.Second * 1000) + (uint32)t.Milisecond;
+
+	if (t.Year < 0) return sys;
+
+	sys.Date = (uint32)(t.Day) + (uint32)(MonthLen[t.Month])
+			+ (uint32)((t.Year/4) * (365*4 + 1)) + (uint32)(t.Year%4 * 365);
+			
+	return sys;
+}
+
+Time TimeConvertToTime (TimeSystem InternalTime)
+{
+	Time t;
+	t.Milisecond = InternalTime.Time % 1000;
+	t.Second = (InternalTime.Time / 1000) % 60;
+	t.Minute = (InternalTime.Time / 60000) % 60;
+	t.Hour = (InternalTime.Time / 3600000);
+
+	
+	uint32 DayOfYear = (InternalTime.Date % 1461) % 365;
+	t.Year = (InternalTime.Date / 1461)*4 + (InternalTime.Date % 1461)/365 + 1;
+	t.Month = 11;
+	while ((int32)DayOfYear < (MonthLen[t.Month] + (t.Year % 4 == 0 && t.Month>1))) t.Month--;
+	t.WeekDay = InternalTime.Date % 7;
+	t.Day = DayOfYear - MonthLen[t.Month] - (t.Year % 4 == 0 && t.Month>1);
+
+	t.Month++; t.WeekDay++; t.Day++;
+
+	return t;
+} 
+
+uint16 TimeCalculateWeekday (Time t)
+{
+	t.Year--;
+	uint32 d = (uint32)(t.Day-1) + (uint32)(MonthLen[t.Month-1]) +
+			+ (uint32)((t.Year/4) * (365*4 + 1)) + (uint32)(t.Year%4 * 365);
+			
+	return 1 + (d%7);
+}
+
+
+TimeSystem TimeGetInternalTime()
+{
+	return _internal_time;
+}
+
+void TimeSetInternalTime(TimeSystem t)
+{
+	_internal_time = t;
+}
+
+uint32 TimeGetInternalFrequency ()
+{
+	return _internal_frequency_hz;
+}
+
+void TimeSetInternalFrequency (uint32 f)
+{
+	_internal_frequency_hz = f;
+}
+
+
+TimeSystem _timer;
+#define MILISECONDS_IN_DAY 86400000
+
+void TimerStart (uint32 ms)
+{
+	_timer = TimeGetInternalTime();
+	_timer.Time += ms;
+
+	if (_timer.Time >= MILISECONDS_IN_DAY)
+		{
+			_timer.Date++;
+			_timer.Time-=MILISECONDS_IN_DAY;
+		}
+}
+
+uint8 TimerIsDone ()
+{
+	TimeSystem now = TimeGetInternalTime();
+	if (_timer.Date >= now.Date && _timer.Time > now.Time) return 0;
+
+	return 1;
+}