From dede7fa93eb4d19c6290355af0c5cb342e47e2f6 Mon Sep 17 00:00:00 2001 From: Simponic Date: Mon, 8 Mar 2021 23:28:16 -0700 Subject: [PATCH] No progress on interrupts :( --- include/idt.h | 34 +----------------------- include/isr.h | 36 +++++++++++++++++++++++++ src/boot.s | 73 +++------------------------------------------------ src/gdt.c | 5 ++++ src/kernel.c | 3 +-- 5 files changed, 46 insertions(+), 105 deletions(-) diff --git a/include/idt.h b/include/idt.h index c08cf75..1722820 100644 --- a/include/idt.h +++ b/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 diff --git a/include/isr.h b/include/isr.h index 831a2f4..f2f4aea 100644 --- a/include/isr.h +++ b/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 diff --git a/src/boot.s b/src/boot.s index 2022ea3..416269a 100644 --- a/src/boot.s +++ b/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 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 + 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 diff --git a/src/gdt.c b/src/gdt.c index fa52f38..5f597fd 100644 --- a/src/gdt.c +++ b/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 diff --git a/src/kernel.c b/src/kernel.c index 653cd4e..b26634c 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -15,7 +15,6 @@ void kernel_main(void) { initializeIDT(); printToMonitor("Hello\n"); printIntToMonitor(10, 10); - asm ("int $0x3"); - asm ("int $0x4"); + asm("int $0x01"); }