working on smp

8 files changed, 135 insertions, 76 deletions

diff --git a/kernel/acpi.c b/kernel/acpi.c
index 084c193..f5c18ca 100644
--- a/kernel/acpi.c
+++ b/kernel/acpi.c
@@ -62,7 +62,7 @@ uint8_t *apci_get_next_entry(uint8_t *addr,smp_processors *procdata)
 
     if(*addr==0)
     {
-	klog("MADT Entry: LocalAPIC ()");
+	klog("Type 0: LocalAPIC (enabled=%d)",addr[4]&1);
 	// usable
 	if(addr[4]&1)
 	{
@@ -78,10 +78,18 @@ uint8_t *apci_get_next_entry(uint8_t *addr,smp_processors *procdata)
     }
     else if(*addr==1)
     {
-	klog("MADT Entry: IO APIC 0x%08X",addr[4]);
+	klog("Type 1: IO APIC (id=%d) (addr=0x%08X) (base=%d)",addr[2], *((uint32_t*)&addr[4]),*((uint32_t*)&addr[8]));
     }
-    else if(*addr==2)klog("MADT Entry: Interrupt Source Override");
-    else klog("MADT Entry: type:0x%X",*addr);
+    else if(*addr==2){
+	klog("Type 2: Interrupt Source Override (bus src=%d) (irq src=%d) (global=%d) (flags=%d)",addr[2],addr[3],*((uint32_t*)&addr[4]),*((uint16_t*)&addr[8]));
+
+    }
+    else if(*addr==4){
+	klog("Type 4: Non-maskable interrupts (proc id=%d) (flags=%d) (LINT#=%d)",addr[2],*((uint16_t*)&addr[3]),addr[5]);
+    
+    }
+    else if(*addr==5){kpanic("Entry Type 5 : Local APIC Address Override. 64-bit address??");}
+    else kpanic("MADT Entry: type:0x%X",*addr);
 
     return addr+addr[1];
 }
@@ -102,14 +110,14 @@ void acpi_check_madt(uint32_t *madt,smp_processors *procdata)
 	entry+=sizeof(acpi_madt);
 
 	procdata->local_apic_address=table->apic_local;
+	klog("Local Apic Address: 0x%08X",table->apic_local);
 	procdata->flags=table->flags;
+	klog("Flags (Dual 8259): %d",table->flags);
 
 	while(entry<end)
 	{
 	    entry=apci_get_next_entry(entry,procdata);
 	}
-
-	
     }
 }
 
diff --git a/kernel/interrupts.c b/kernel/interrupts.c
index 501ccd4..4eb2a35 100644
--- a/kernel/interrupts.c
+++ b/kernel/interrupts.c
@@ -94,68 +94,102 @@ void errlog(uint32_t error_code)
     klog("error_code: 0x%08X",error_code);
 }
 
-void defklog(uint32_t eip, uint16_t cs, uint32_t flags)
+void defklog(uint32_t esp)
 {
-    klog("eip: 0x%08X",eip);
-    klog("segment: 0x%08X",cs);
-    klog("eflags: 0x%08X",flags);
+    klog("EXCEPTION: eip: 0x%08X",*(uint32_t *)esp);
+    esp+=4;
+    klog("EXCEPTION: segment: 0x%08X",*(uint16_t *)esp);
+    esp+=4;
+    klog("EXCPETION: eflags: 0x%08X",*(uint32_t *)esp);
 }
 
-void show_error(uint32_t err)
+void show_selector_error(uint32_t err)
 {
-   klog("interrupt error code:  0x%08x",err);
-   klog("External Event: %x",err&0b001);
+   klog("Selector Error Details:");
+   klog("External Event: %x",err&0b1);
    klog("Location: %x",err&0b110);
    klog("Selector: %x",err&0b1111111111111000);
 }
 
-//
-
-void int_default()
+void show_page_fault_error(uint32_t error_code)
 {
-   klog("default handler");
-   kpanic("unhandled interrupt (is this a panic or should just iognore?)");
-}
-
-void exception_handle_0(){   kpanic("Divide by 0");    }
-void exception_handle_1(){   kpanic("Single step (debugger)");    }
-void exception_handle_2(){   kpanic("Non Maskable Interrupt");    }
-void exception_handle_3(){   kpanic("Breakpoint (debugger)");    }
-void exception_handle_4(){   kpanic("Overflow");    }
-void exception_handle_5(){   kpanic("Bounds check");    }
-void exception_handle_6(){   kpanic("Undefined OP Code");    }
-void exception_handle_7(){   kpanic("No coprocessor");    }
-void exception_handle_8(){   kpanic("Double Fault");    }
-void exception_handle_9(){   kpanic("Coprocessor Segment Overrun");    }
-void exception_handle_10(){   kpanic("Invalid TSS");    }
-void exception_handle_11(){   kpanic("Segment Not Present");    }
-void exception_handle_12(){   kpanic("Stack Segment Overrun");    }
-
-void exception_handle_13(uint32_t error_code,uint32_t eip,uint16_t cs,uint16_t unused, uint32_t flags)
-{
-    errlog(error_code);
-    defklog(eip,cs,flags);
-
-    kpanic("Exception: Fault: General Protection Fault");   
+   klog("Page Fault Error Details:");
+   klog("error_code_P (Present): %d",error_code&1?1:0);
+   klog("error_code_W/R (Write): %d",error_code&2?1:0);
+   klog("error_code_U/S (User): %d",error_code&4?1:0);
+   klog("error_code_RSVD (Reserved Write) : %d",error_code&8?1:0);
+   klog("error_code_I/D (Instruction Fetch): %d",error_code&16?1:0);
+   klog("at addr: 0x%08X",x86_get_cr(2));
 }
 
-void exception_handle_14(uint32_t error_code,uint32_t eip,uint16_t cs,uint16_t unused, uint32_t flags)
+void exception_handle(uint32_t esp, uint32_t irq)  
 {
-   errlog(error_code);
-   klog("error_code_P: %d",error_code&1?1:0);
-   klog("error_code_W/R: %d",error_code&2?1:0);
-   klog("error_code_U/S: %d",error_code&4?1:0);
-   klog("error_code_RSVD: %d",error_code&8?1:0);
-   klog("error_code_I/D: %d",error_code&16?1:0);
-   klog("at addr: 0x%08X",x86_get_cr(2));
-   defklog(eip,cs,flags);
-   kpanic("Exception: Fault: Page Fault");
+    uint32_t error_code=0;
+
+    klog("EXCEPTION: vector nr.: %d",irq);
+
+    switch(irq){ //this interrupts push also an error_code
+	case 8:
+	case 10:
+	case 11:
+	case 12:
+	case 13:
+	case 14:
+	case 17:
+	case 30:
+	    error_code = *(uint32_t *)esp;
+	    esp+=4;
+    }
+    klog("EXCEPTION: error_code: %d",irq);
+    defklog(esp);
+
+    switch(irq){
+	case 0:
+	    kpanic("Divide by 0");
+	case 1:
+	    kpanic("Single step (debugger)");
+	case 2:
+	    kpanic("Non Maskable Interrupt");
+	case 3:
+	    kpanic("Breakpoint (debugger)");
+	case 4:
+	    kpanic("Overflow");
+	case 5:
+	    kpanic("Bounds check");
+	case 6:
+	    kpanic("Undefined OP Code");
+	case 7:
+	    kpanic("No coprocessor");
+	case 8:
+	    kpanic("Double Fault");
+	case 9:
+	    kpanic("Coprocessor Segment Overrun");
+	case 10:
+	    show_selector_error(error_code);
+	    kpanic("Invalid TSS");
+	case 11:
+	    show_selector_error(error_code);
+	    kpanic("Segment Not Present");
+	case 12:
+	    show_selector_error(error_code);
+	    kpanic("Stack Segment Overrun");
+	case 13:
+	    show_selector_error(error_code);
+	    kpanic("Exception: Fault: General Protection Fault");
+	case 14:
+	    show_page_fault_error(error_code);
+	    kpanic("Exception: Fault: Page Fault");
+	case 15:
+	    kpanic("RESERVED");
+	case 16:
+	    kpanic("Coprocessor error");
+	case 17:
+	    kpanic("Alignment Check");
+	case 18:
+	    kpanic("Machine Check");
+    }
 }
 
-void exception_handle_15(){   kpanic("Unassigned");    }
-void exception_handle_16(){   kpanic("Coprocessor error");    }
-void exception_handle_17(){   kpanic("Alignment Check");    }
-void exception_handle_18(){   kpanic("Machine Check");    }
 
 // set default handler for all interrupts for a start
 void interrupts_init(uint16_t sel)
diff --git a/kernel/kernel.c b/kernel/kernel.c
index bf6910d..493fb93 100644
--- a/kernel/kernel.c
+++ b/kernel/kernel.c
@@ -1,5 +1,4 @@
 #include <stdint.h>
-
 #include "kernel/kernel.h"
 
 #include "kernel/mem.h"
diff --git a/kernel/kernel.h b/kernel/kernel.h
index f73c116..4c480e5 100644
--- a/kernel/kernel.h
+++ b/kernel/kernel.h
@@ -18,6 +18,7 @@
 
 #define KMALLOC_MEM_SIZE  1024*1024*8  // 8MB for in kernel-memory
 #define NUMBER_SPINLOCKS 16
+#define SPINLOCK_LOG 0
 
 #define S1(x) #x
 #define S2(x) S1(x)
diff --git a/kernel/log.c b/kernel/log.c
index c7c1bb7..b0eeab5 100644
--- a/kernel/log.c
+++ b/kernel/log.c
@@ -1,8 +1,12 @@
 #include "log.h"
+#include "kernel.h"
+
 
 #include <stdarg.h>
 #include <stdbool.h>
 
+#include "spinlock.h"
+
 #include "kernel/kernel.h"
 #include "kernel/fifo.h"
 #include "driver/serial.h"
@@ -43,7 +47,9 @@ void log(char *module_name, int prio, char *format_string, ...)
 
     tfp_sprintf(buf_log,"\033[36;40m%s\033[31;40m %s:\033[37;40m %s\n",buf_time,module_name,buf_info);
 
+    spinlock_spin(SPINLOCK_LOG);
     log_string(buf_log);
+    spinlock_release(SPINLOCK_LOG);
 }
 
 /*
diff --git a/kernel/smp.c b/kernel/smp.c
index 4aff013..ea926ca 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -20,29 +20,40 @@ volatile uint8_t proc;
 uint32_t cpu_counter[SMP_MAX_PROC];
 
 uint32_t local_apic_addr;
+extern uint32_t LLOCK;
 
 void smp_main()
 {
+    uint32_t ebp=kballoc(1);
+    asm volatile("mov %0, %%ebp"::"r"(ebp));
+    asm volatile("mov %ebp, %esp");
+    asm volatile("jmp kernel_ap");
+}
 
-//    klog("local apic_addr:0x%08X",local_apic_addr);
+void kernel_ap()
+{
+    LLOCK=0;
 
-    // // uint32_t *reg=local_apic_addr+FOOLOS_APIC_ID;
-    //klog("local apic id: 0x%08X",(*reg));
+    uint32_t *reg;
+    reg=local_apic_addr+FOOLOS_APIC_ID;
+    klog("smp local apic id: %d",(*reg));
 
     // // // *reg=local_apic_addr+FOOLOS_APIC_SPUR_INT;
     // // // *reg|=0x100;//0xffffffff; // all bits 1 and interrupt 255
 //    *reg=0;//xffffffff; // all bits 1 and interrupt 255
 
     int_install();
-    
+   
     x86_sti();
 
-
-
-    while(1)__asm__("hlt");
+    while(1){
+	klog("%d",*reg);
+	for(int i=0;i<1000000000;i++);
+    }
 
 //    switch_to_user_mode();
 //    int x=1/0;
+    /*
 
     while(1);
 
@@ -54,10 +65,11 @@ void smp_main()
 
     proc=c1=c2=c3=0;
     for(int i=0;i<SMP_MAX_PROC;i++)cpu_counter[i]=0;
+    */
 }
 
 
-void kernel_ap()
+void kernel_ap_old()
 {
 	proc++;
 	uint8_t p=proc;
diff --git a/kernel/spinlock.c b/kernel/spinlock.c
index 03efa6e..b7ff6b7 100644
--- a/kernel/spinlock.c
+++ b/kernel/spinlock.c
@@ -1,26 +1,17 @@
 #include "spinlock.h"
-
 #include "kernel.h"
 
 #include "asm_x86.h"
 
-
 static volatile uint32_t spinlocks[NUMBER_SPINLOCKS];
 
-void check_spinlocks()
-{
-    klog("Spinlocks at 0x%08X ",spinlocks);
-    for(int i=0;i<NUMBER_SPINLOCKS;i++)
-    klog("%d",spinlocks[i]);
-}
-
-void lock_spin(uint32_t i)
+void spinlock_spin(uint32_t i)
 {
     uint32_t *addr=spinlocks+i;
     while(x86_xchg(addr,1));
 }
 
-void lock_release(uint32_t i)
+void spinlock_release(uint32_t i)
 {
     uint32_t *addr=spinlocks+i;
     asm("movb $0,%0"::"m"(*addr));
diff --git a/kernel/spinlock.h b/kernel/spinlock.h
index 8ce2f57..daa1a50 100644
--- a/kernel/spinlock.h
+++ b/kernel/spinlock.h
@@ -1,6 +1,14 @@
 /*
  * @file
  *
+ * Spinlock 
+ * ========
+ *
+ * Use this locks only for very short time!
+ * 
+ *
+ * Ref
+ * ---
  * https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
  */
 
@@ -9,7 +17,7 @@
 
 #include <stdint.h>
 
-void lock_spin(spinlock);
-void lock_release(spinlock);
+void spinlock_spin(uint32_t num);
+void spinlock_release(uint32_t num);
 
 #endif