hippOS/bootstrap.asm

; Declare constants for the multiboot header.
MBALIGN  equ  1 << 0            ; align loaded modules on page boundaries
MEMINFO  equ  1 << 1            ; provide memory map
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:

section .data
gdt_ptr:
   dw gdt_end - gdt - 1
   dq gdt
gdt:
   ; generated using https://wiki.osdev.org/GDT_Tutorial#Some_stuff_to_make_your_life_easy
   ; signature for create_descriptor function: void create_descriptor(uint32_t base, uint32_t limit, uint16_t flag)
   dq 0x0000000000000000   ; create_descriptor(0, 0, 0);
   dq 0x00CF9A000000FFFF   ; create_descriptor(0, 0x000FFFFF, (GDT_CODE_PL0));
   dq 0x00CF92000000FFFF   ; create_descriptor(0, 0x000FFFFF, (GDT_DATA_PL0));
gdt_end:


; 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 _start:function (_start.end - _start)
load_gdt:
	lgdt [gdt_ptr]
	; Reload CS register containing code selector:
    JMP   0x08:.reload_CS ; 0x08 is a stand-in for your code segment
.reload_CS:
   	; Reload data segment registers:
   	MOV   AX, 0x10 ; 0x10 is a stand-in for your data segment
   	MOV   DS, AX
   	MOV   ES, AX
   	MOV   FS, AX
   	MOV   GS, AX
   	MOV   SS, AX
   	RET
_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.

   call load_gdt
 
   ; 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: _kmain
   extern kmain
   call kmain
 
   ; 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
   ;    kmain (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
   jmp .hang
.end: