fixing gdt and interrupts

5 files changed, 108 insertions, 108 deletions

diff --git a/kernel/interrupts.c b/kernel/interrupts.c
index fed2b28..51d8f8e 100644
--- a/kernel/interrupts.c
+++ b/kernel/interrupts.c
@@ -51,7 +51,7 @@ void int_default()
 {
    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"default handler");
 }
-/*
+
 
 void show_error(uint32_t err)
 {
@@ -61,23 +61,23 @@ void show_error(uint32_t err)
    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Selector: %x",err&0b1111111111111000);
 }
 
-//void int_irq0(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Divide by 0");   X86_IRQ_END }
-void int_irq1(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Single step (debugger)");   X86_IRQ_END }
-void int_irq2(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Non Maskable Interrupt");   X86_IRQ_END }
-void int_irq3(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Breakpoint (debugger)");   X86_IRQ_END }
-void int_irq4(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Overflow");   X86_IRQ_END }
-void int_irq5(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Bounds check");   X86_IRQ_END }
-void int_irq6(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Undefined OP Code");   X86_IRQ_END }
-void int_irq7(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"No coprocessor");   X86_IRQ_END }
-void int_irq8(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Double Fault");   X86_IRQ_END }
-void int_irq9(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Coprocessor Segment Overrun");   X86_IRQ_END }
-void int_irq10(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Invalid TSS");   X86_IRQ_END }
-void int_irq11(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Segment Not Present");   X86_IRQ_END }
-void int_irq12(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Stack Segment Overrun");   X86_IRQ_END }
-
-void int_irq13()
+
+void exception_handle_0(){   panic(FOOLOS_MODULE_NAME,"Divide by 0");    }
+void exception_handle_1(){   panic(FOOLOS_MODULE_NAME,"Single step (debugger)");    }
+void exception_handle_2(){   panic(FOOLOS_MODULE_NAME,"Non Maskable Interrupt");    }
+void exception_handle_3(){   panic(FOOLOS_MODULE_NAME,"Breakpoint (debugger)");    }
+void exception_handle_4(){   panic(FOOLOS_MODULE_NAME,"Overflow");    }
+void exception_handle_5(){   panic(FOOLOS_MODULE_NAME,"Bounds check");    }
+void exception_handle_6(){   panic(FOOLOS_MODULE_NAME,"Undefined OP Code");    }
+void exception_handle_7(){   panic(FOOLOS_MODULE_NAME,"No coprocessor");    }
+void exception_handle_8(){   panic(FOOLOS_MODULE_NAME,"Double Fault");    }
+void exception_handle_9(){   panic(FOOLOS_MODULE_NAME,"Coprocessor Segment Overrun");    }
+void exception_handle_10(){   panic(FOOLOS_MODULE_NAME,"Invalid TSS");    }
+void exception_handle_11(){   panic(FOOLOS_MODULE_NAME,"Segment Not Present");    }
+void exception_handle_12(){   panic(FOOLOS_MODULE_NAME,"Stack Segment Overrun");    }
+
+void exception_handle_13()
 {
-    X86_IRQ_BEGIN  
      
     uint32_t err;
     asm("pop %eax");  // get Error Code
@@ -85,16 +85,13 @@ void int_irq13()
     show_error(err);
 
     panic(FOOLOS_MODULE_NAME,"General Protection Fault");   
-
-    X86_IRQ_END 
 }
 
-void int_irq14(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Page Fault");   X86_IRQ_END }
-void int_irq15(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Unassigned");   X86_IRQ_END }
-void int_irq16(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Coprocessor error");   X86_IRQ_END }
-void int_irq17(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Alignment Check");   X86_IRQ_END }
-void int_irq18(){ X86_IRQ_BEGIN  panic(FOOLOS_MODULE_NAME,"Machine Check");   X86_IRQ_END }
-*/
+void exception_handle_15(){   panic(FOOLOS_MODULE_NAME,"Unassigned");    }
+void exception_handle_16(){   panic(FOOLOS_MODULE_NAME,"Coprocessor error");    }
+void exception_handle_17(){   panic(FOOLOS_MODULE_NAME,"Alignment Check");    }
+void exception_handle_18(){   panic(FOOLOS_MODULE_NAME,"Machine Check");    }
+
 
 //set a handler for a specific interrupt
 void int_install_ir(int irq, uint16_t flags, uint16_t sel, void *addr)
@@ -148,8 +145,6 @@ void int_init(uint16_t sel)
     int_install_ir(17, 0b10001110, 0x08,&int_irq17);
     int_install_ir(18, 0b10001110, 0x08,&int_irq18);
 
-    
-
     // setup some custom interrupts
     // remember that we shifted all interrupts with the pic by 32
 
diff --git a/kernel/kernel.c b/kernel/kernel.c
index 91e1c45..76ae8d7 100644
--- a/kernel/kernel.c
+++ b/kernel/kernel.c
@@ -26,10 +26,7 @@
 
 void kernel_main(uint32_t eax,uint32_t ebx)
 {
-
     
-    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"kernel_main: eax=0x%08X ebx=0x%08X",eax,ebx);
-
     //
     // Configuring the PIT timer.
     //
@@ -48,6 +45,7 @@ void kernel_main(uint32_t eax,uint32_t ebx)
     {
 	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Loaded by: \"%s\"",info->boot_loader_name);
     }
+
     log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"multiboot flags: 0x%08X",info->flags);
 
     if(info->flags&&1<<0)
@@ -61,6 +59,29 @@ void kernel_main(uint32_t eax,uint32_t ebx)
 	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"cmdline: \"%s\"",info->cmdline);
     }
 
+
+    //
+    //	Memory Init
+    //
+    //  after this is set up we will be able to allocate and deallocate 
+    //  blocks of physical memory :)
+    //
+    //	we know that here, the bootloader placed the memory map and
+    //	its length
+    //
+
+    if(info->flags&&1<<6)
+    {
+	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"memory map of length %d provided by bootloader",info->mmap_length);
+	mem_init(info->mmap_addr,info->mmap_length);
+    }
+
+    else panic(FOOLOS_MODULE_NAME,"Unable to continue without memory map, sorry!");
+
+    // 
+    // Modules
+    //
+    
     if(info->flags&&1<<3)
     {
 	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%d modules loaded",info->mods_count);
@@ -75,39 +96,6 @@ void kernel_main(uint32_t eax,uint32_t ebx)
 	    mod++;
 	}
     }
-
-    if(info->flags&&1<<6)
-    {
-	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"memory map of length %d provided by bootloader",info->mmap_length);
-
-	uint32_t mmap_addr=info->mmap_addr;
-
-	while(mmap_addr<info->mmap_addr+info->mmap_length)
-	{
-	    multiboot_mmap *mmap=mmap_addr;
-	    uint32_t mem_start=mmap->base_addr;
-	    uint32_t mem_end=mmap->base_addr+mmap->length;
-
-	    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%08X - %08X / type: %d, size: %d",
-		    mem_start, mem_end, mmap->type, mmap->size);
-
-	    mmap_addr+=mmap->size+4;
-	}
-
-	
-    }
-    else panic(FOOLOS_MODULE_NAME,"Unable to continue without memory map, sorry!");
-
-    //
-    //	Memory Init
-    //
-    //  after this is set up we will be able to allocate and deallocate 
-    //  blocks of physical memory :)
-    //
-    //	we know that here, the bootloader placed the memory map and
-    //	the number of entries.
-    //
-//    mem_init((physical_address)0xa001,(int)(*((uint16_t *)(0xa000))));
     
 
     //
@@ -118,19 +106,20 @@ void kernel_main(uint32_t eax,uint32_t ebx)
 
     //
     // Activate Virtual Memory (paging)
-//    pdirectory *dir=vmem_init(physbase);
+    pdirectory *dir=vmem_init(physbase);
 
 
     // log buffered messages to console
     log_log();
 
-    while(1);
-
     //
     // Setup Interrupts (code segment: 0x08)
     //
+    
     int_init(0x08);
 
+    //while(1);
+
     //
     // Scan the PCI Bus
     // 
@@ -163,6 +152,9 @@ void kernel_main(uint32_t eax,uint32_t ebx)
     // Initialize Multitasking
     //
     //task_init(dir); //; this will never return!
+    //
+    while(1);
+	    //log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"."); 
  
 }
 
diff --git a/kernel/mem.c b/kernel/mem.c
index 4e7d392..72b92af 100644
--- a/kernel/mem.c
+++ b/kernel/mem.c
@@ -3,6 +3,7 @@
 #include <stdint.h>
 
 #include "config.h"
+#include "multiboot.h"
 #include "lib/logger/log.h"	// logger facilities
 
 //! 8 blocks per byte
@@ -14,6 +15,11 @@
 //! block alignment ??? TODO: what is this!?
 #define PMMNGR_BLOCK_ALIGN	PMMNGR_BLOCK_SIZE
 
+extern uint32_t kernel_start[];
+extern uint32_t kernel_end[];
+extern uint32_t stack_top[];
+extern uint32_t stack_bottom[];
+
 
 //memory map bit array. Each bit represents a 4KB memory block
 static uint32_t *_mmngr_memory_map;
@@ -96,8 +102,9 @@ int mmap_first_free_s (uint32_t x)
 
 void pmmngr_init_region (uint32_t  base, uint32_t size)
 {
-    uint32_t align = base / PMMNGR_BLOCK_SIZE;
-    uint32_t blocks = size / PMMNGR_BLOCK_SIZE;
+    if(base<0x100000)return;
+    uint32_t align = base / PMMNGR_BLOCK_SIZE +1;  // TODO: calc properly
+    uint32_t blocks = size / PMMNGR_BLOCK_SIZE -1;
 
     for (; blocks>0; blocks--) 
     {
@@ -108,8 +115,10 @@ void pmmngr_init_region (uint32_t  base, uint32_t size)
 
 void pmmngr_deinit_region (uint32_t  base, uint32_t size)
 {
-    uint32_t align = base / PMMNGR_BLOCK_SIZE;
-    uint32_t blocks = size / PMMNGR_BLOCK_SIZE;
+    uint32_t align = base / PMMNGR_BLOCK_SIZE -1;	    // TODO: calc properly
+    uint32_t blocks = size / PMMNGR_BLOCK_SIZE +2; 
+
+    //log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%08X, %08X -> deinit %d blocks",base,size,blocks);
 
     for (; blocks>0; blocks--) 
     {
@@ -182,73 +191,72 @@ void pmmngr_free_block (void* p)
 }
 
 
-void mem_init(uint16_t *memmap,uint16_t entries)
+void mem_init(uint32_t memmap,uint32_t length)
 {
-    // log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"the memory map contains %d entries.",entries);
 
-    // count available mem
-    uint32_t total_mem=0, highest_end;
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"kernel loaded at: 0x%08X- 0x%08X",kernel_start,kernel_end);
 
-    //save pointer to memmap
-    uint16_t *save=memmap;
+    // we will place the memory map directly after the kernel for now (TODO: move somewehere else, so modules are not overwritten!)
+    _mmngr_memory_map=kernel_end;
 
-    //print memory map and calc blocks.
-    for(int i=0;i<entries;i++)
-    {
-	int mem=(memmap[4]+(memmap[5]<<16));
-	uint32_t low_end=(((uint32_t)memmap[1])<<16)+memmap[0];
-	uint32_t high_end=low_end+mem-1;
+    // count available mem and track high_end of usable memory
+    uint32_t total_mem=0, highest_end;
 
+    // iterate : print memory map and calc blocks.
+    for(uint32_t mmap_addr=memmap;mmap_addr<memmap+length;)
+    {
+	multiboot_mmap *mmap=mmap_addr;
+	uint64_t mem_start=mmap->base_addr;
+	uint64_t mem_end=mmap->base_addr+mmap->length;
 
 	#ifdef MEM_PRINT_MEMORYMAP
-	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"range:  0x%08x - 0x%08x (%s  %d KB)",
-		low_end,high_end,memmap_type_to_string[memmap[8]-1],mem/1024);
+	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%08X - %08X / type: %s, (size: %d)",
+	    (uint32_t)mem_start, (uint32_t)mem_end, memmap_type_to_string[mmap->type-1], mmap->size);
 	#endif
 
+	uint32_t mem=mmap->length;
+
 	//reclaimable OR usable
-	if(memmap[8]==1||memmap[8]==3)
+	if(mmap->type==1||mmap->type==3)
 	{
 	    total_mem+=mem;
-	    highest_end=high_end;
-
+	    highest_end=mmap->base_addr+mmap->length-1;
 	}
 
-	memmap+=12; // next entry;
+	//next
+	mmap_addr+=mmap->size+4;
     }
 
-    int blocks=highest_end/4096+1;
+    uint32_t blocks=highest_end/4096+1;
     mem_array_size=blocks/32+1;
 
-    _mmngr_memory_map=0x500000;
-    
-    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Init bitmap for 0x%X blocks (size: %d bytes)",blocks,mem_array_size*4);
+    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Init bitmap for %d blocks (array size: %d bytes)",blocks,mem_array_size*4);
 
     pmmngr_init (); //clear memmap
 
-    //restore pointer to memmap
-    memmap=save;
-
-    for(int i=0;i<entries;i++)
+    // iterate : initialize memory
+    for(uint32_t mmap_addr=memmap;mmap_addr<memmap+length;)
     {
-	if(memmap[8]==1||memmap[8]==3)
+	multiboot_mmap *mmap=mmap_addr;
+
+	//reclaimable OR usable
+	if(mmap->type==1||mmap->type==3)
 	{
-	    pmmngr_init_region(memmap[0]+(memmap[1]<<16),memmap[4]+((memmap[5])<<16));
+	    pmmngr_init_region(mmap->base_addr,mmap->length);
 	}
-	memmap+=12;
+
+	//next
+	mmap_addr+=mmap->size+4;
     }
-    
-    // here is somewhere our kernel stuff.
-    // reserve 4Mb (0x100000-0x500000) for kernel and ext2 img
-    // even more!
-    pmmngr_deinit_region(0x0,0x1400000);
+     
 
-    // and here is the memory map that we JUST created!
-    pmmngr_deinit_region(0x500000,mem_array_size*4+PMMNGR_BLOCK_SIZE);
-    
+    // deinitialize kernel + memory (TODO: modules)
+    pmmngr_deinit_region(kernel_start,((uint32_t)kernel_end-(uint32_t)kernel_start));
+    pmmngr_deinit_region(_mmngr_memory_map,mem_array_size*4+PMMNGR_BLOCK_SIZE);
 
     log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Usable Mem: %d (0x%X) bytes. (~%d MB)",total_mem,total_mem,total_mem/1024/1024);
     log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Currently Free 4K blocks: %d blocks.",mem_free_blocks);
-
+   // mmap_show_free();
 }
 
 // analytics
diff --git a/kernel/multiboot.h b/kernel/multiboot.h
index 874e473..c82d7e2 100644
--- a/kernel/multiboot.h
+++ b/kernel/multiboot.h
@@ -1,4 +1,6 @@
 //# https://www.gnu.org/software/grub/manual/multiboot/multiboot.html#Boot-information-format
+#ifndef MULTIBOOT_H
+#define MULTIBOOT_H
 
 
 #include <stdbool.h>
@@ -48,3 +50,5 @@ typedef struct multiboot_mod_struct
     uint32_t reserved;
 
 }multiboot_mod;
+
+#endif
diff --git a/kernel/task.c b/kernel/task.c
index d0c1b0c..a2a2ab8 100644
--- a/kernel/task.c
+++ b/kernel/task.c
@@ -82,6 +82,7 @@ volatile uint32_t my_scheduler(uint32_t oldesp)
 // this gets called by our clock interrupt regularly!
 volatile uint32_t task_switch_next(uint32_t oldesp)
 {
+
     timer_tick();
 
     // check if multitasking has been started