Merge branch 'interrupts'

include/idt.h

@@ -2,6 +2,7 @@
 #define IDT_H
 
 #include "types.h"
+#include "isr.h"
 
 struct IDT {
     uint32_t base;
@@ -20,37 +21,4 @@ struct IDT createIDT(uint32_t base, uint16_t selector, uint8_t flags);
 void encodeIDT(uint8_t* idtEntry, struct IDT source);
 void initializeIDT();
 
-extern void isr0 (); 
-extern void isr1 ();
-extern void isr2 ();
-extern void isr3 ();
-extern void isr4 ();
-extern void isr5 ();
-extern void isr6 ();
-extern void isr7 ();
-extern void isr8 ();
-extern void isr9 ();
-extern void isr10();
-extern void isr11(); 
-extern void isr12();
-extern void isr13();
-extern void isr14();
-extern void isr15();
-extern void isr16();
-extern void isr17();
-extern void isr18();
-extern void isr19();
-extern void isr20();
-extern void isr21();
-extern void isr22();
-extern void isr23();
-extern void isr24();
-extern void isr25();
-extern void isr26();
-extern void isr27();
-extern void isr28();
-extern void isr29();
-extern void isr30();
-extern void isr31();
-
 #endif // IDT_H

include/isr.h

@@ -10,4 +10,40 @@ struct registers{
     uint32_t eip, cs, eflags, useresp, ss;
 } __attribute__((packed));
 
+extern void isr_common_stub();
+extern void isr_handler(struct registers regs);
+
+extern void isr0 (); 
+extern void isr1 ();
+extern void isr2 ();
+extern void isr3 ();
+extern void isr4 ();
+extern void isr5 ();
+extern void isr6 ();
+extern void isr7 ();
+extern void isr8 ();
+extern void isr9 ();
+extern void isr10();
+extern void isr11(); 
+extern void isr12();
+extern void isr13();
+extern void isr14();
+extern void isr15();
+extern void isr16();
+extern void isr17();
+extern void isr18();
+extern void isr19();
+extern void isr20();
+extern void isr21();
+extern void isr22();
+extern void isr23();
+extern void isr24();
+extern void isr25();
+extern void isr26();
+extern void isr27();
+extern void isr28();
+extern void isr29();
+extern void isr30();
+extern void isr31();
+
 #endif // ISR_H

src/boot.s

@@ -5,45 +5,24 @@ FLAGS    equ  MBALIGN | MEMINFO ; this is the Multiboot 'flag' field
 MAGIC    equ  0x1BADB002        ; 'magic number' lets bootloader find the header
 CHECKSUM equ -(MAGIC + FLAGS)   ; checksum of above, to prove we are multiboot
  
-; Declare a multiboot header that marks the program as a kernel. These are magic
-; values that are documented in the multiboot standard. The bootloader will
-; search for this signature in the first 8 KiB of the kernel file, aligned at a
-; 32-bit boundary. The signature is in its own section so the header can be
-; forced to be within the first 8 KiB of the kernel file.
 section .multiboot
 align 4
 	dd MAGIC
 	dd FLAGS
 	dd CHECKSUM
  
-; The multiboot standard does not define the value of the stack pointer register
-; (esp) and it is up to the kernel to provide a stack. This allocates room for a
-; small stack by creating a symbol at the bottom of it, then allocating 16384
-; bytes for it, and finally creating a symbol at the top. The stack grows
-; downwards on x86. The stack is in its own section so it can be marked nobits,
-; which means the kernel file is smaller because it does not contain an
-; uninitialized stack. The stack on x86 must be 16-byte aligned according to the
-; System V ABI standard and de-facto extensions. The compiler will assume the
-; stack is properly aligned and failure to align the stack will result in
-; undefined behavior.
 section .bss
 align 16
 stack_bottom:
 resb 16384 ; 16 KiB
 stack_top:
  
-; The linker script specifies _start as the entry point to the kernel and the
-; bootloader will jump to this position once the kernel has been loaded. It
-; doesn't make sense to return from this function as the bootloader is gone.
-; Declare _start as a function symbol with the given symbol size.
 section .text
 
 global reloadSegments ; Flush GDT
 reloadSegments:
-   ; Reload CS register containing code selector:
    JMP   0x08:reload_CS ; 0x08 points at the new code selector
 reload_CS:
-   ; Reload data segment registers:
    MOV   AX, 0x10 ; 0x10 points at the new data selector
    MOV   DS, AX
    MOV   ES, AX
@@ -56,7 +35,7 @@ reload_CS:
   [GLOBAL isr%1]        ; %1 accesses the first parameter.
   isr%1:
     cli
-    push byte 0
+    push byte %1
     push byte %1
     jmp isr_common_stub
 %endmacro
@@ -102,12 +81,8 @@ ISR_NOERRCODE 29
 ISR_NOERRCODE 30
 ISR_NOERRCODE 31
 
-
 [EXTERN isr_handler]
 
-; This is our common ISR stub. It saves the processor state, sets
-; up for kernel mode segments, calls the C-level fault handler,
-; and finally restores the stack frame.
 isr_common_stub:
    pusha                    ; Pushes edi,esi,ebp,esp,ebx,edx,ecx,eax
 
@@ -133,54 +108,12 @@ isr_common_stub:
    sti
    iret           ; pops 5 things at once: CS, EIP, EFLAGS, SS, and ESP
 
+
 global _start:function (_start.end - _start)
 _start:
-	; The bootloader has loaded us into 32-bit protected mode on a x86
-	; machine. Interrupts are disabled. Paging is disabled. The processor
-	; state is as defined in the multiboot standard. The kernel has full
-	; control of the CPU. The kernel can only make use of hardware features
-	; and any code it provides as part of itself. There's no printf
-	; function, unless the kernel provides its own <stdio.h> header and a
-	; printf implementation. There are no security restrictions, no
-	; safeguards, no debugging mechanisms, only what the kernel provides
-	; itself. It has absolute and complete power over the
-	; machine.
- 
-	; To set up a stack, we set the esp register to point to the top of our
-	; stack (as it grows downwards on x86 systems). This is necessarily done
-	; in assembly as languages such as C cannot function without a stack.
 	mov esp, stack_top
-    
-    
-	; This is a good place to initialize crucial processor state before the
-	; high-level kernel is entered. It's best to minimize the early
-	; environment where crucial features are offline. Note that the
-	; processor is not fully initialized yet: Features such as floating
-	; point instructions and instruction set extensions are not initialized
-	; yet. The GDT should be loaded here. Paging should be enabled here.
-	; C++ features such as global constructors and exceptions will require
-	; runtime support to work as well.
- 
-	; Enter the high-level kernel. The ABI requires the stack is 16-byte
-	; aligned at the time of the call instruction (which afterwards pushes
-	; the return pointer of size 4 bytes). The stack was originally 16-byte
-	; aligned above and we've since pushed a multiple of 16 bytes to the
-	; stack since (pushed 0 bytes so far) and the alignment is thus
-	; preserved and the call is well defined.
-        ; note, that if you are building on Windows, C functions may have "_" prefix in assembly: _kernel_main
    	extern kernel_main
 	call kernel_main
- 
-	; If the system has nothing more to do, put the computer into an
-	; infinite loop. To do that:
-	; 1) Disable interrupts with cli (clear interrupt enable in eflags).
-	;    They are already disabled by the bootloader, so this is not needed.
-	;    Mind that you might later enable interrupts and return from
-	;    kernel_main (which is sort of nonsensical to do).
-	; 2) Wait for the next interrupt to arrive with hlt (halt instruction).
-	;    Since they are disabled, this will lock up the computer.
-	; 3) Jump to the hlt instruction if it ever wakes up due to a
-	;    non-maskable interrupt occurring or due to system management mode.
 	cli
 
 .hang:	hlt

src/gdt.c

@@ -1,4 +1,5 @@
 #include "gdt.h"
+#include "print.h"
 
 extern void reloadSegments();
 
@@ -11,6 +12,10 @@ void encodeGDT(uint8_t* gdtEntry, struct GDT source) {
         // Size: 1 (32 bit protected mode)
         gdtEntry[6] = 0xC0;
     }
+    else if (source.limit == 0) {
+        // Don't set any granularity for null entry
+        gdtEntry[6] = 0;
+    }
     else {
         // Granularity: 0 (1 byte segments)
         // Size: 1

src/kernel.c

@@ -15,7 +15,6 @@ void kernel_main(void) {
     initializeIDT();
     printToMonitor("Hello\n");
     printIntToMonitor(10, 10);
-    asm ("int $0x3");
+    asm("int $0x01");
-    asm ("int $0x4");
 }