Corrigi alguns bugs com a heap, devido a inicialização estar errada.

Me livrei de algumas coisas inuteis tb.

CMakeLists.txt

@@ -73,6 +73,7 @@ FILE(GLOB GENERIC_KERNEL_SOURCES
 	"src/kernel/*.s"
 	"src/kernel/*.cpp"
 	"src/kernel/kpp/*.cpp"
+	"src/kernel/fs/*.cpp"
 #	"src/kernel/*.c"
 )
 

src/kernel/arch/i386/start.s

@@ -33,17 +33,12 @@ multiboot_addr:
 	.globl multiboot_addr
 	.zero	4
 
-end_malloc_addr:
-	.globl end_malloc_addr
-	.zero	4
-
 start:
+	call disable_interrupts
 
 	movl %eax, multiboot_magic
 	movl %ebx, multiboot_addr
 
-	call disable_interrupts
-
 	call _at_global_begin
 	call main
 	call _at_global_end

src/kernel/boot/multiboot.hpp

@@ -124,7 +124,7 @@ struct multiboot_header{
 	multiboot_uint32_t width;
 	multiboot_uint32_t height;
 	multiboot_uint32_t depth;
-};
+} __attribute__((packed)) ;
 
 /* The symbol table for a.out. */
 struct multiboot_aout_symbol_table
@@ -195,7 +195,7 @@ struct multiboot_info
 	multiboot_uint16_t vbe_interface_seg;
 	multiboot_uint16_t vbe_interface_off;
 	multiboot_uint16_t vbe_interface_len;
-};
+} __attribute__((packed)) ;
 typedef struct multiboot_info multiboot_info_t;
 
 struct multiboot_mmap_entry
@@ -225,7 +225,7 @@ typedef struct multiboot_mod_list multiboot_module_t;
 
 #endif /* ! ASM_FILE */
 
-extern struct multiboot_header *multiboot_addr;
+extern multiboot_info_t *multiboot_addr;
 extern uint32_t multiboot_magic;
 
 #endif /* ! MULTIBOOT_HEADER */

src/kernel/compiler/gcc/new.cpp

@@ -19,20 +19,22 @@
 #include	<kernel/debug.hpp>
 #include	<kernel/kmalloc.hpp>
 
+#include	<isa_specific_code.hpp>
+#include	<plataform_specific_code.hpp>
+
 void *operator new[](unsigned int s){
 	void *p=(void*)(kmalloc(s));
 	if( ! p ){
-		kdebug(2,"Bad alloc %d\n",s);
+		kdebug(3,"Bad alloc %d\n",s);
 	}	
-//	kprintf("p=%p\n",p);
 	return p;
 }
 
 void *operator new(unsigned int s){
 	void *p=(void*)(kmalloc(s));
 	if( ! p ){
-		kdebug(2,"Bad alloc %d\n",s);
-	}	
+		kdebug(3,"Bad alloc %d\n",s);
+	}
 	return p;
 }
 

src/kernel/kheap.cpp

@@ -57,7 +57,7 @@ uint32_t KHeap::find_smallest_hole(const uint32_t &size, const bool &page_align)
 
 static KHeap *kheap_kfree_handler=0;
 
-void kheap_kfree(void *p){
+void kheap_kfree(uint32_t p){
 	kdebug(8,"KHeap *kheap_kfree_handler=%p\n",kheap_kfree_handler);
 	kheap_kfree_handler->free(p);
 }
@@ -81,6 +81,8 @@ KHeap::KHeap(Paging &paging ) :
 void KHeap::install(uint32_t start, const uint32_t &end, const uint32_t &max, const bool &supervisor, const bool &readonly)
 {
 	index=new Ordered_array<header_t*>( (void*)(start), KHEAP_INDEX_SIZE );
+////	index=(Ordered_array<header_t*>*)( kmalloc( sizeof(index) ) );
+////	index->init( (void*)(start), KHEAP_INDEX_SIZE );
 //	heap_t *heap = (heap_t*)( kmalloc(sizeof(heap_t)) );
 
 	// All our assumptions are made on startAddress and endAddress being page-aligned.

src/kernel/kheap.hpp

@@ -62,6 +62,9 @@ class KHeap{
 		  Releases a block allocated with 'alloc'.
 		 **/
 		void free(void *p);
+/*		~KHeap(){
+			delete index;
+		}*/
 };
 
 #endif	/* ----- #ifndef kheap_INC  ----- */

src/kernel/kmalloc.cpp

@@ -21,32 +21,34 @@
 #include	<kernel/monitor.hpp>
 #include	<kernel/boot/multiboot.hpp>
 
+uint32_t KMalloc::static_end_kmalloc_addr;
+
 static kmalloc_handler_t kmalloc_handler=0;
 static kfree_handler_t kfree_handler=0;
 
 inline uint32_t kmalloc_basic(const uint32_t &sz, uint32_t *phys, const bool &align){
-	if( align && (end_malloc_addr & 0xFFFFF000) ){ // If the address is not already page-aligned
+	if( align && ( end_malloc_addr()&0xFFFFF000 ) ){ // If the address is not already page-aligned
 		// Align it.
-		end_malloc_addr &= 0xFFFFF000;
-		end_malloc_addr += 0x1000;
+		set_end_malloc_addr( end_malloc_addr()&0xFFFFF000 );
+		set_end_malloc_addr( end_malloc_addr()+0x1000 );
 	}
 	if (phys){
-		*phys = end_malloc_addr;
+		*phys=end_malloc_addr();
 	}
-	uint32_t tmp = end_malloc_addr;
-	end_malloc_addr += sz;
+	uint32_t tmp=end_malloc_addr();
+	set_end_malloc_addr( end_malloc_addr()+sz );
 	return tmp;
 }
 
 inline uint32_t kmalloc_int(const uint32_t &sz, uint32_t *phys, const bool &align){
 	uint32_t ret;
+
 	if( kmalloc_handler ){
 		ret=kmalloc_handler(sz, phys, align);
-//		kprintf("kmalloc_int: Alloc! %p\n",ret);
-		return ret;
+	}else{
+		ret=kmalloc_basic(sz, phys, align);
 	}
-	ret=kmalloc_basic(sz, phys, align);
-//	kprintf("kmalloc_int: Alloc! %p\n",ret);
+//	kprintf("kmalloc_int: sz=%p ret=%p kmalloc_handler=%p\n",sz,ret,&kmalloc_handler);
 	return ret;
 }
 
@@ -56,7 +58,7 @@ inline void kfree_basic(uint32_t addr){
 
 inline void kfree_int(const uint32_t sz){
 	kdebug(8,"free_int:\n");
-	if( sz<=end_malloc_addr ){
+	if( sz<=end_malloc_addr() ){
 		kdebug(2,"kfree_int: Not free %u<=%u!\n",sz,end_malloc_addr);
 		return;
 	}
@@ -109,5 +111,13 @@ extern "C" {
 	kfree_handler_t kfree_get_handler(){
 		return kfree_handler;
 	}
+	uint32_t end_malloc_addr(){
+		return KMalloc::static_end_kmalloc_addr;
+//		return static_end_kmalloc_addr;
+	}
+	void set_end_malloc_addr(uint32_t p){
+		KMalloc::static_end_kmalloc_addr=p;
+//		static_end_kmalloc_addr=p;
+	}
 }
 

src/kernel/kmalloc.hpp

@@ -3,12 +3,24 @@
 
 #include	<stdint.h>
 #include	<kernel/boot/multiboot.hpp>
+#include	<kernel/kpp/utils.hpp>
+
+class KMalloc{
+	declare_a(uint32_t,end_of_memory);
+
+	private:
+	public:
+		KMalloc( const uint32_t &p ){
+			end_of_memory(p);
+			static_end_kmalloc_addr=p;
+		}
+		static uint32_t static_end_kmalloc_addr;
+};
 
 extern "C" {
-	extern uint32_t end_malloc_addr;
 
 	typedef uint32_t (*kmalloc_handler_t)(const uint32_t &sz, uint32_t *phys, const bool &align);
-	typedef uint32_t (*kfree_handler_t)(const uint32_t addr);
+	typedef void (*kfree_handler_t)(const uint32_t addr);
 
 	// page aligned.
 	uint32_t kmalloc_a(const uint32_t &sz);
@@ -29,6 +41,9 @@ extern "C" {
 
 	void kfree_set_handler(kfree_handler_t new_handler);
 	kfree_handler_t kfree_get_handler();
+
+	uint32_t end_malloc_addr();
+	void set_end_malloc_addr(uint32_t p);
 }
 
 #endif   /* ----- #ifndef kmalloc_INC  ----- */

src/kernel/kpp/ordered_array.hpp

@@ -20,6 +20,7 @@ class Ordered_array{
 //		typedef value_type data_t;
 		Ordered_array( const size_t &max_size );
 		Ordered_array( const void *addr, const size_t &max_size );
+		void init( const void *addr, const size_t &max_size );
 		data_t &operator[]( const size_t &pos );
 		void remove( size_t index );
 		void insert(const data_t &data);
@@ -43,6 +44,14 @@ Ordered_array<data_t>::Ordered_array( const void* addr, const size_t &max_size )
 	this->max_size(max_size);
 }
 
+template<class data_t>
+void Ordered_array<data_t>::init( const void* addr, const size_t &max_size ){
+	base=(data_t*)(addr);
+	memset( base, 0, max_size*sizeof(base));
+	size(0);
+	this->max_size(max_size);
+}
+
 template<class data_t>
 data_t &Ordered_array<data_t>::operator[]( const size_t &pos ){
 	ASSERT( pos<size() );

src/kernel/main.cpp

@@ -31,20 +31,21 @@ class t{
 		}
 };
 
+KMalloc auxxx( end_malloc_addr() );
+
 t x1(1);
 
 GDT gdt;
 IDT idt;
 
-Paging paging(0x2000000, idt, KHEAP_START, KHEAP_INITIAL_SIZE);
-KHeap kheap(paging);
-
 IRQ irq( idt );
 Timer pit( irq );
 Keyboard kb( pit, irq );
 
-int main(){
+Paging paging(0x1000000, idt, KHEAP_START, KHEAP_INITIAL_SIZE);
+KHeap kheap(paging);
 
+int main(){
 	if( multiboot_magic!=MULTIBOOT_BOOTLOADER_MAGIC ){
 		kprintf("multiboot Magic number wrong! (%p)\n", multiboot_addr);
 		halt_machine();
@@ -54,15 +55,17 @@ int main(){
 	idt.install();
 
 	char *a1 = new char[8];
-	paging.install();
-
-	kheap.install(KHEAP_START, KHEAP_START+KHEAP_INITIAL_SIZE, 0xCFFFF000, false, false);
 
 	irq.install();
 	pit.install();
 	kb.install();
 
+	paging.install();
+
+	kheap.install(KHEAP_START, KHEAP_START+KHEAP_INITIAL_SIZE, 0xCFFFF000, false, false);
+
 	enable_interrupts();
+//	kb.getch();
 
 /*	
 	uint32_t *ptr = (uint32_t*)0xA0000000;
@@ -86,7 +89,6 @@ int main(){
 	char *x=new char[10];
 	kprintf("x=%p\n",x);
 //	DQueue<char> s;
-//	kb.getch();
 	x[0]='A';
 	x[1]='A';
 	x[2]='A';
@@ -102,8 +104,8 @@ int main(){
 	s.push('\n');
 	s.push('\0');
 
-	x1.print();
-	x1.print();
+//	x1.print();
+//	x1.print();
 	for( int i=0 ; not s.is_empty() ; ++i ){
 		x[i]=s.pop() ;
 	}
@@ -127,13 +129,13 @@ int main(){
 
 	t x2(2);
 	t x3(3);
-	x1.print();
+//	x1.print();
 	x3.print();
 
 	t *a=new t[2];
 	int *p_t2=new int[40];
 
-	x1.print();
+//	x1.print();
 	x3.print();
 
 	kprintf("Vai um delete?\n");
@@ -147,10 +149,10 @@ int main(){
 
 	kprintf("Foi passou delete!!\n");
 
-	x1.print();
+//	x1.print();
 	x2.print();
 
-	kprintf("Final do main kernel!!!!!  %p\n",&x1);
+//	kprintf("Final do main kernel!!!!!  %p\n",&x1);
 	kprintf("Final do main kernel!!!!!\n");
 
 	t tfim(15);

src/kernel/paging.cpp

@@ -28,7 +28,7 @@ void Paging::alloc_frame(page_t *page, const bool &is_kernel, const bool &is_wri
 		return; // Frame was already allocated, return straight away.
 	}else{
 		size_t idx = frames.first(); // idx is now the index of the first free frame.
-		if( idx==(size_t)-1 ){
+		if( idx==(size_t)(-1) ){
 			// PANIC is just a macro that prints a message to the screen then hits an infinite loop.
 			PANIC("No free frames!");
 		}

src/kernel/paging.hpp

@@ -50,26 +50,25 @@ class Paging{
 			const uint32_t &KHEAP_INITIAL_SIZE
 		) :
 			frame_size(0x1000),
-			frame_qtd(0x2000000/frame_size),
+			frame_qtd(mem_size/frame_size),
 			frames(frame_qtd),
 			idt(idt)
 		{
 			kernel_directory = (page_directory_t*)kmalloc_a(sizeof(page_directory_t));
 			memset(kernel_directory, 0, sizeof(page_directory_t));
 			current_directory = kernel_directory;
 
-			uint32_t i=0;
-
 			// Map some pages in the kernel heap area.
 			// Here we call get_page but not alloc_frame. This causes page_table_t's 
 			// to be created where necessary. We can't allocate frames yet because they
 			// they need to be identity mapped first below, and yet we can't increase
 			// placement_address between identity mapping and enabling the heap!
+			uint32_t i=0;
 			for (i = KHEAP_START; i<KHEAP_START+KHEAP_INITIAL_SIZE; i += 0x1000)
 				get_page(i, 1, kernel_directory);
 
 			i=0;
-			while( i<end_malloc_addr+0x1000 ){
+			while( i<end_malloc_addr()+0x1000 ){
 				// Kernel code is readable but not writeable from userspace.
 				alloc_frame( get_page(i, 1, kernel_directory), false, false);
 				i += this->frame_size;