Migration to C++!

8 files changed, 91 insertions, 90 deletions

diff --git a/src/kernel/mem/_dlmalloc.h b/src/kernel/mem/_dlmalloc.h
index 7b2e2cc..a80273c 100644
--- a/src/kernel/mem/_dlmalloc.h
+++ b/src/kernel/mem/_dlmalloc.h
@@ -1,6 +1,7 @@
 #ifndef DEF_DLMALLOC_H
 #define DEF_DLMALLOC_H
 
+#include <types.h>
 #include "lib/std.h"
 #include <stdlib_common.h>
 #include <string.h>
@@ -16,6 +17,8 @@
 #define USE_LOCKS 2
 
 
+
+
 /* Version identifier to allow people to support multiple versions */
 #ifndef DLMALLOC_VERSION
 #define DLMALLOC_VERSION 20805
diff --git a/src/kernel/mem/gdt.c b/src/kernel/mem/gdt.cpp
index 494aaf2..49fbd82 100644
--- a/src/kernel/mem/gdt.c
+++ b/src/kernel/mem/gdt.cpp
@@ -2,14 +2,14 @@
 #include <stdlib_common.h>
 #include <core/monitor.h>
 
-extern void gdt_flush(uint32_t);	//ASM (imported from idt_.asm)
-extern void tss_flush();
+extern "C" void gdt_flush(uint32_t);	//ASM (imported from idt_.asm)
+extern "C" void tss_flush();
 
 #define GDT_ENTRIES 6	// The contents of each entry is defined in gdt_init.
 
-static struct tss_entry tss_entry;
-static struct gdt_entry gdt_entries[GDT_ENTRIES];
-static struct gdt_ptr gdt_ptr;
+static tss_entry tss_entry;
+static gdt_entry gdt_entries[GDT_ENTRIES];
+static gdt_ptr gdt_ptr;
 
 /*	This function is called by the task_switch function on each context switch.
 	It updates the TSS so that an interrupt will be handled on the correct kernel stack
@@ -33,11 +33,11 @@ static void gdt_setGate(int num, uint32_t base, uint32_t limit, uint8_t access,
 /*	For internal use only. Writes one entry of the GDT, that entry being a pointer to the TSS. */
 static void gdt_writeTss(int num, uint32_t ss0, uint32_t esp0) {
 	uint32_t base = (uint32_t)&tss_entry;
-	uint32_t limit = base + sizeof(struct tss_entry);
+	uint32_t limit = base + sizeof(tss_entry);
 
 	gdt_setGate(num, base, limit, 0xE9, 0);
 
-	memset(&tss_entry, 0, sizeof(struct tss_entry));
+	memset(&tss_entry, 0, sizeof(tss_entry));
 
 	tss_entry.ss0 = ss0; tss_entry.esp0 = esp0;
 
@@ -47,7 +47,7 @@ static void gdt_writeTss(int num, uint32_t ss0, uint32_t esp0) {
 
 /*	Write data to the GDT and enable it. */
 void gdt_init() {
-	gdt_ptr.limit = (sizeof(struct gdt_entry) * GDT_ENTRIES) - 1;
+	gdt_ptr.limit = (sizeof(gdt_entry) * GDT_ENTRIES) - 1;
 	gdt_ptr.base = (uint32_t)&gdt_entries;
 
 	gdt_setGate(0, 0, 0, 0, 0);					//Null segment
diff --git a/src/kernel/mem/mem.c b/src/kernel/mem/mem.cpp
index 3310b70..5e04de3 100644
--- a/src/kernel/mem/mem.c
+++ b/src/kernel/mem/mem.cpp
@@ -16,7 +16,7 @@
 #define KHEAP_MAXSIZE 0x08000000
 
 size_t mem_placementAddr;
-int _no_more_ksbrk = 0;
+bool _no_more_ksbrk = false;
 
 
 // ******************************
@@ -79,7 +79,7 @@ void kfree_page(void* ptr) {
 //																	*************************
 
 void* ksbrk(size_t size) {
-	if (_no_more_ksbrk == 0) {		// ksbrk is NOT being called by dlmalloc
+	if (!_no_more_ksbrk) {		// ksbrk is NOT being called by dlmalloc
 		if (size & 0x0FFF) {
 			size = (size & 0xFFFFF000) + 0x1000;
 		}
@@ -103,7 +103,7 @@ void* ksbrk(size_t size) {
 			er_end = mem_placementAddr;
 			if (er_end & 0x0FFF) er_end = (er_end & 0xFFFFF000) + 0x1000;
 			for (i = er_begin; i < er_end; i += 0x1000) {
-				struct page *p = pagedir_getPage(kernel_pagedir, i, 1);
+				page *p = pagedir_getPage(kernel_pagedir, i, 1);
 				size_t f = frame_alloc();
 				page_map(p, f, 0, 0);
 				/* (DBG) monitor_write("<map "); monitor_writeHex(i); monitor_write(" ");
@@ -126,11 +126,11 @@ void* ksbrk(size_t size) {
 
 void kbrk(void* ptr) {
 	monitor_write("<kbrk ");
-	monitor_writeHex(ptr);
+	monitor_writeHex((uint32_t)ptr);
 	monitor_write(">\n");
 
 	if ((size_t)ptr > (size_t)&end) {
-		ksbrk(ptr - (size_t)mem_placementAddr);
+		ksbrk((size_t)ptr - (size_t)mem_placementAddr);
 	} else {
 		PANIC("INVALID KBRK.");
 	}
diff --git a/src/kernel/mem/mem.h b/src/kernel/mem/mem.h
index cb9c396..085d9ce 100644
--- a/src/kernel/mem/mem.h
+++ b/src/kernel/mem/mem.h
@@ -11,19 +11,17 @@ void* kmalloc_page(size_t *phys);
 void kfree_page(void* page);
 
 // Internal, used by dlmalloc
-void* ksbrk(size_t size);
-void kbrk(void* ptr);
+extern "C" void* ksbrk(size_t size);
+extern "C" void kbrk(void* ptr);
 
 #define kmalloc dlmalloc
 #define kfree dlfree
 
-void kheap_init();
-
-extern int _no_more_ksbrk;
+extern bool _no_more_ksbrk;
 extern size_t mem_placementAddr;
-extern void end;	//Symbol defined by linker : end of kernel code
+extern "C" size_t end;	//Symbol defined by linker : end of kernel code
 
-extern void k_highhalf_addr;	// Symbol defined by linker : high half position of the kerne
+extern "C" size_t k_highhalf_addr;	// Symbol defined by linker : high half position of the kerne
 								// Should be at 0xC0000000
 #define K_HIGHHALF_ADDR ((size_t)(&k_highhalf_addr))
 
diff --git a/src/kernel/mem/paging.c b/src/kernel/mem/paging.cpp
index 0527f06..eb7e615 100644
--- a/src/kernel/mem/paging.c
+++ b/src/kernel/mem/paging.cpp
@@ -7,24 +7,24 @@
 #include <core/sys.h>
 #include <task/task.h>
 
-static struct bitset frames;
+static bitset frames;
 
-struct page_directory *kernel_pagedir, *current_pagedir;
+page_directory *kernel_pagedir, *current_pagedir;
 
 /**************************		PHYSICAL MEMORY ALLOCATION	************************/
 
 /*	Allocates a page of physical memory. */
 uint32_t frame_alloc() {
-	uint32_t free = bitset_firstFree(&frames);
+	uint32_t free = frames.firstFree();
 	if (free == (uint32_t) -1) {
 		PANIC("No more frames to allocate, system is out of memory!");
 	}
-	bitset_set(&frames, free);
+	frames.set(free);
 	return free;
 }
 
 void frame_free(uint32_t id) {
-	bitset_clear(&frames, id);
+	frames.clear(id);
 }
 
 /*************************		PAGING INITIALIZATION		*****************************/
@@ -38,11 +38,11 @@ void paging_init(size_t totalRam) {
 	uint32_t i;
 
 	frames.size = totalRam / 0x1000;
-	frames.bits = ksbrk(INDEX_FROM_BIT(frames.size));
+	frames.bits = (uint32_t*)ksbrk(INDEX_FROM_BIT(frames.size));
 
-	kernel_pagedir = ksbrk(sizeof(struct page_directory));
+	kernel_pagedir = (page_directory*)ksbrk(sizeof(page_directory));
 	kernel_pagedir->mappedSegs = 0;
-	kernel_pagedir->tablesPhysical = kmalloc_page(&kernel_pagedir->physicalAddr);
+	kernel_pagedir->tablesPhysical = (uint32_t*)kmalloc_page(&kernel_pagedir->physicalAddr);
 	for (i = 0; i < 1024; i++) {
 		kernel_pagedir->tables[i] = 0;
 		kernel_pagedir->tablesPhysical[i] = 0;
@@ -76,7 +76,7 @@ void paging_cleanup() {
 
 /*	Switch to a page directory. Can be done if we are sure not to be interrupted by a task switch.
 	Example use for cross-memory space writing in linker/elf.c */
-void pagedir_switch(struct page_directory *pd) {
+void pagedir_switch(page_directory *pd) {
 	current_pagedir = pd;
 	asm volatile("mov %0, %%cr3" : : "r"(pd->physicalAddr));
 	uint32_t cr0;
@@ -86,11 +86,11 @@ void pagedir_switch(struct page_directory *pd) {
 }
 
 /*	Creates a new page directory for a process, and maps the kernel page tables on it. */
-struct page_directory *pagedir_new() {
+page_directory *pagedir_new() {
 	uint32_t i;
 
-	struct page_directory *pd = kmalloc(sizeof(struct page_directory));
-	pd->tablesPhysical = kmalloc_page(&pd->physicalAddr);
+	page_directory *pd = new page_directory();
+	pd->tablesPhysical = (uint32_t*)kmalloc_page(&pd->physicalAddr);
 	pd->mappedSegs = 0;
 
 	for (i = 0; i < 1024; i++) {
@@ -106,7 +106,7 @@ struct page_directory *pagedir_new() {
 }
 
 /*	Deletes a page directory, cleaning it up. */
-void pagedir_delete(struct page_directory *pd) {
+void pagedir_delete(page_directory *pd) {
 	uint32_t i;
 	//Unmap segments
 	while (pd->mappedSegs != 0) seg_unmap(pd->mappedSegs);
@@ -121,9 +121,9 @@ void pagedir_delete(struct page_directory *pd) {
 /*	Handle a paging fault. First, looks for the corresponding segment.
 	If the segment was found and it handles the fault, return normally.
 	Else, display informatinos and return an error. */
-uint32_t paging_fault(struct registers *regs) {
+uint32_t paging_fault(registers *regs) {
 	size_t addr;
-	struct segment_map *seg = 0;
+	segment_map *seg = 0;
 	asm volatile("mov %%cr2, %0" : "=r"(addr));
 
 	seg = current_pagedir->mappedSegs;
@@ -153,14 +153,14 @@ uint32_t paging_fault(struct registers *regs) {
 /*	Gets the corresponding page in a page directory for a given address.
 	If make is set, the necessary page table can be created.
 	Can return 0 if make is not set. */
-struct page *pagedir_getPage(struct page_directory *pd, uint32_t address, int make) {
+page *pagedir_getPage(page_directory *pd, uint32_t address, int make) {
 	address /= 0x1000;
 	uint32_t table_idx = address / 1024;
 
 	if (pd->tables[table_idx]) {
 		return &pd->tables[table_idx]->pages[address %  1024];
 	} else if (make) {
-		pd->tables[table_idx] = kmalloc_page(pd->tablesPhysical + table_idx);
+		pd->tables[table_idx] = (page_table*)kmalloc_page(pd->tablesPhysical + table_idx);
 
 		memset((uint8_t*)pd->tables[table_idx], 0, 0x1000);
 		pd->tablesPhysical[table_idx] |= 0x07;
@@ -176,7 +176,7 @@ struct page *pagedir_getPage(struct page_directory *pd, uint32_t address, int ma
 }
 
 /*	Modifies a page structure so that it is mapped to a frame. */
-void page_map(struct page *page, uint32_t frame, uint32_t user, uint32_t rw) {
+void page_map(page *page, uint32_t frame, uint32_t user, uint32_t rw) {
 	if (page != 0 && page->frame == 0 && page->present == 0) {
 		page->present = 1;
 		page->rw = (rw ? 1 : 0);
@@ -186,7 +186,7 @@ void page_map(struct page *page, uint32_t frame, uint32_t user, uint32_t rw) {
 }
 
 /*	Modifies a page structure so that it is no longer mapped to a frame. */
-void page_unmap(struct page *page) {
+void page_unmap(page *page) {
 	if (page != 0) {
 		page->frame = 0;
 		page->present = 0;
@@ -194,7 +194,7 @@ void page_unmap(struct page *page) {
 }
 
 /*	Same as above but also frees the frame. */
-void page_unmapFree(struct page *page) {
+void page_unmapFree(page *page) {
 	if (page != 0) {
 		if (page->frame != 0) frame_free(page->frame);
 		page->frame = 0;
diff --git a/src/kernel/mem/paging.h b/src/kernel/mem/paging.h
index 2d5713f..f91fe37 100644
--- a/src/kernel/mem/paging.h
+++ b/src/kernel/mem/paging.h
@@ -18,32 +18,32 @@ struct page {
 };
 
 struct page_table {
-	struct page pages[1024];
+	page pages[1024];
 };
 
 struct segment_map;
 struct page_directory {
-	struct page_table *tables[1024];	//Virtual addresses of page tables
+	page_table *tables[1024];	//Virtual addresses of page tables
 	uint32_t *tablesPhysical;			//Pointer to the virtual address of the page directory (contain phys addr of pt)
 	uint32_t physicalAddr;				//Physical address of info above
-	struct segment_map *mappedSegs;
+	segment_map *mappedSegs;
 };
 
-extern struct page_directory *kernel_pagedir, *current_pagedir;
+extern page_directory *kernel_pagedir, *current_pagedir;
 
 uint32_t frame_alloc();
 void frame_free(uint32_t id);
 
 void paging_init(size_t totalRam);
 void paging_cleanup();
-void pagedir_switch(struct page_directory *pd);
-struct page_directory *pagedir_new();	//Creates a brand new empty page directory for a process, with kernel pages
-void pagedir_delete(struct page_directory *pagedir);
-struct page *pagedir_getPage(struct page_directory *pd, uint32_t address, int make);
-void page_map(struct page *page, uint32_t frame, uint32_t user, uint32_t rw);
-void page_unmap(struct page *page);
-void page_unmapFree(struct page *page);
-
-uint32_t paging_fault(struct registers *regs);	//returns a boolean : 1 if unhandled, 0 if ok
+void pagedir_switch(page_directory *pd);
+page_directory *pagedir_new();	//Creates a brand new empty page directory for a process, with kernel pages
+void pagedir_delete(page_directory *pagedir);
+page *pagedir_getPage(page_directory *pd, uint32_t address, int make);
+void page_map(page *page, uint32_t frame, uint32_t user, uint32_t rw);
+void page_unmap(page *page);
+void page_unmapFree(page *page);
+
+uint32_t paging_fault(registers *regs);	//returns a boolean : 1 if unhandled, 0 if ok
 
 #endif
diff --git a/src/kernel/mem/seg.c b/src/kernel/mem/seg.cpp
index 4a33db3..c29e94e 100644
--- a/src/kernel/mem/seg.c
+++ b/src/kernel/mem/seg.cpp
@@ -4,8 +4,8 @@
 
 /*	Call this function when mapping a segment to a page directory.
 	Calls the appropriate map method and updates the segment's and pagedir's information. */
-struct segment_map *seg_map(struct segment* seg, struct page_directory *pagedir, size_t offset) {
-	struct segment_map *sm = seg->map(seg, pagedir, offset);
+segment_map *seg_map(segment* seg, page_directory *pagedir, size_t offset) {
+	segment_map *sm = seg->map(seg, pagedir, offset);
 	if (sm == 0) return 0;
 	seg->mappings++;
 	sm->seg = seg;
@@ -18,18 +18,18 @@ struct segment_map *seg_map(struct segment* seg, struct page_directory *pagedir,
 /*	Call this function when unmapping a segment from a page directory.
 	The segment will automatically be deleted if it is not mapped.
 	Calls the appropriate unmap method and updates the segment's and pagedir's information. */
-void seg_unmap(struct segment_map *map) {
+void seg_unmap(segment_map *map) {
 	map->seg->unmap(map);
 	if (map->pagedir->mappedSegs == map) {
 		map->pagedir->mappedSegs = map->pagedir->mappedSegs->next;
 	} else {
-		struct segment_map *m = map->pagedir->mappedSegs;
+		segment_map *m = map->pagedir->mappedSegs;
 		while (m->next != 0 && m->next != map) m = m->next;
 		if (m->next == map) m->next = map->next;
 	}
 	map->seg->mappings--;
 	if (map->seg->mappings == 0) {
-		map->seg->delete(map->seg);
+		map->seg->del(map->seg);
 		kfree(map->seg->seg_data);
 		kfree(map->seg);
 	}
@@ -38,37 +38,37 @@ void seg_unmap(struct segment_map *map) {
 
 // ************************************   SIMPLESEG stuff *************
  
-static struct segment_map* simpleseg_map(struct segment* seg, struct page_directory* pagedir, size_t offset);
-static void simpleseg_unmap(struct segment_map*);
-static void simpleseg_delete(struct segment *seg);
-static int simpleseg_handleFault(struct segment_map* map, size_t addr, int write);
+static segment_map* simpleseg_map(segment* seg, page_directory* pagedir, size_t offset);
+static void simpleseg_unmap(segment_map*);
+static void simpleseg_delete(segment *seg);
+static int simpleseg_handleFault(segment_map* map, size_t addr, int write);
 
 /*	Call this when creating a simpleseg.
 	Creates the simpleseg structure and the segment structure and fills them up. */
-struct segment* simpleseg_make(size_t start, size_t len, int writable) {
-	struct simpleseg *ss = kmalloc(sizeof(struct simpleseg));
-	struct segment *se = kmalloc(sizeof(struct segment));
+segment* simpleseg_make(size_t start, size_t len, int writable) {
+	simpleseg *ss = new simpleseg(); 
+	segment *se = new segment();
 	se->seg_data = ss;
 	se->mappings = 0;
 	se->map = simpleseg_map;
 	se->unmap = simpleseg_unmap;
-	se->delete = simpleseg_delete;
+	se->del = simpleseg_delete;
 	se->handle_fault = simpleseg_handleFault;
 	ss->writable = writable; ss->start = start; ss->len = len;
 	return se;
 }
 
 /*	For internal use only. Called when a simpleseg is mapped to a pagedirectory. */
-struct segment_map* simpleseg_map(struct segment* seg, struct page_directory* pagedir, size_t offset) {
-	struct segment_map *sm = kmalloc(sizeof(struct segment_map));
-	sm->start = ((struct simpleseg*)(seg->seg_data))->start;
-	sm->len = ((struct simpleseg*)(seg->seg_data))->len;
+segment_map* simpleseg_map(segment* seg, page_directory* pagedir, size_t offset) {
+	segment_map *sm = new segment_map();
+	sm->start = ((simpleseg*)(seg->seg_data))->start;
+	sm->len = ((simpleseg*)(seg->seg_data))->len;
 	return sm;
 }
 
 /*	For internal use only. Called when a simpleseg is unmapped.
 	Frees all the allocated pages. */
-void simpleseg_unmap(struct segment_map* sm) {
+void simpleseg_unmap(segment_map* sm) {
 	size_t i;
 	for (i = sm->start; i < sm->start + sm->len; i += 0x1000) {
 		page_unmapFree(pagedir_getPage(sm->pagedir, i, 0));
@@ -76,28 +76,28 @@ void simpleseg_unmap(struct segment_map* sm) {
 }
 
 /*	For internal use only. Handles a page fault. Can allocate and map a frame if necessary. */
-int simpleseg_handleFault(struct segment_map* sm, size_t addr, int write) {
-	struct simpleseg *ss = sm->seg->seg_data;
+int simpleseg_handleFault(segment_map* sm, size_t addr, int write) {
+	simpleseg *ss = (simpleseg*)sm->seg->seg_data;
 	if (write && !ss->writable) return 1;
 	addr &= 0xFFFFF000;
-	struct page *p = pagedir_getPage(sm->pagedir, addr, 1);
+	page *p = pagedir_getPage(sm->pagedir, addr, 1);
 	if (p->frame != 0) return 1;
 	page_map(p, frame_alloc(), 1, ss->writable);
 	return 0;
 }
 
 /*	For internal use only. Called when the simpleseg is deleted. Does nothing. */
-void simpleseg_delete(struct segment* seg) {
+void simpleseg_delete(segment* seg) {
 }
 
 /*	Call this to resize a simpleseg. Ajusts the size and frees pages if the new size is smaller.*/
-int simpleseg_resize(struct segment_map *map, size_t len) {
+int simpleseg_resize(segment_map *map, size_t len) {
 	size_t i;
 
 	if (map == 0) return -1;
-	if (map->seg->delete != simpleseg_delete) return -2;	//check segment is a simpleseg
+	if (map->seg->del != simpleseg_delete) return -2;	//check segment is a simpleseg
 
-	struct simpleseg *s = (struct simpleseg*)map->seg->seg_data;
+	simpleseg *s = (simpleseg*)map->seg->seg_data;
 	if (len & 0xFFF) len = (len & 0xFFFFF000) + 0x1000;
 	if (len < map->len) {
 		for (i = map->start + len; i < map->start + map->len; i += 0x1000) {
diff --git a/src/kernel/mem/seg.h b/src/kernel/mem/seg.h
index d37ba59..ea95dfa 100644
--- a/src/kernel/mem/seg.h
+++ b/src/kernel/mem/seg.h
@@ -12,23 +12,23 @@ struct segment {
 	int mappings;
 
 	// these 4 functions must not be used directly by anyone
-	struct segment_map* (*map)(struct segment* seg, struct page_directory* pagedir, size_t offset);
-	void (*unmap)(struct segment_map*);
-	void (*delete)(struct segment* seg);
-	int (*handle_fault)(struct segment_map* map, size_t addr, int write);	//0 if ok, 1 if segfault
+	segment_map* (*map)(segment* seg, page_directory* pagedir, size_t offset);
+	void (*unmap)(segment_map*);
+	void (*del)(segment* seg);
+	int (*handle_fault)(segment_map* map, size_t addr, int write);	//0 if ok, 1 if segfault
 };
 
 struct segment_map {
-	struct segment* seg;
-	struct page_directory* pagedir;
+	segment* seg;
+	page_directory* pagedir;
 	size_t start, len;
-	struct segment_map *next;
+	segment_map *next;
 };
 
 //parameter offset in seg_map doesn't need to be used
-struct segment_map *seg_map(struct segment* seg, struct page_directory* pagedir, size_t offset);
-/*	When unmapping a segment, the segment is deleted if it is not mapped anywhere anymore. */
-void seg_unmap(struct segment_map* map);
+segment_map *seg_map(segment* seg, page_directory* pagedir, size_t offset);
+//	When unmapping a segment, the segment is deleted if it is not mapped anywhere anymore.
+void seg_unmap(segment_map* map);
 
 /// *************************************     SIMPLESEG stuff *****************
 
@@ -37,7 +37,7 @@ struct simpleseg {
 	size_t start, len;
 };
 
-struct segment* simpleseg_make(size_t start, size_t len, int writable);
-int simpleseg_resize(struct segment_map *map, size_t len);
+segment* simpleseg_make(size_t start, size_t len, int writable);
+int simpleseg_resize(segment_map *map, size_t len);
 
 #endif