Bare Bones with NASM
From OSDev Wiki
This article is an extension to the Bare Bones article and describes how to use NASM in a Hello World kernel. Mentally add the following changes to the base article.
Booting the Operating System
Bootstrap Assembly (NASM)
We will now create a file called boot.asm and discuss its contents. In this example, we are using the Netwide Assembler which is not part of your previously built cross-compiler toolchain and you will have to install it separately.
; Declare constants for the multiboot header. MBALIGN equ 1 << 0 ; align loaded modules on page boundaries MEMINFO equ 1 << 1 ; provide memory map MBFLAGS equ MBALIGN | MEMINFO ; this is the Multiboot 'flag' field MAGIC equ 0x1BADB002 ; 'magic number' lets bootloader find the header CHECKSUM equ -(MAGIC + MBFLAGS) ; 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 MBFLAGS 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 _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 jmp .hang .end:
You can then assemble boot.asm using:
nasm -felf32 boot.asm -o boot.o
Kernel
BITS 32 VGA_WIDTH equ 80 VGA_HEIGHT equ 25 VGA_COLOR_BLACK equ 0 VGA_COLOR_BLUE equ 1 VGA_COLOR_GREEN equ 2 VGA_COLOR_CYAN equ 3 VGA_COLOR_RED equ 4 VGA_COLOR_MAGENTA equ 5 VGA_COLOR_BROWN equ 6 VGA_COLOR_LIGHT_GREY equ 7 VGA_COLOR_DARK_GREY equ 8 VGA_COLOR_LIGHT_BLUE equ 9 VGA_COLOR_LIGHT_GREEN equ 10 VGA_COLOR_LIGHT_CYAN equ 11 VGA_COLOR_LIGHT_RED equ 12 VGA_COLOR_LIGHT_MAGENTA equ 13 VGA_COLOR_LIGHT_BROWN equ 14 VGA_COLOR_WHITE equ 15 global kernel_main kernel_main: mov dh, VGA_COLOR_LIGHT_GREY mov dl, VGA_COLOR_BLACK call terminal_set_color mov esi, hello_string call terminal_write_string jmp $ ; IN = dl: y, dh: x ; OUT = dx: Index with offset 0xB8000 at VGA buffer ; Other registers preserved terminal_getidx: push ax; preserve registers shl dh, 1 ; multiply by two because every entry is a word that takes up 2 bytes mov al, VGA_WIDTH mul dl mov dl, al shl dl, 1 ; same add dl, dh mov dh, 0 pop ax ret ; IN = dl: bg color, dh: fg color ; OUT = none terminal_set_color: shl dl, 4 or dl, dh mov [terminal_color], dl ret ; IN = dl: y, dh: x, al: ASCII char ; OUT = none terminal_putentryat: pusha call terminal_getidx mov ebx, edx mov dl, [terminal_color] mov byte [0xB8000 + ebx], al mov byte [0xB8001 + ebx], dl popa ret ; IN = al: ASCII char terminal_putchar: mov dx, [terminal_cursor_pos] ; This loads terminal_column at DH, and terminal_row at DL call terminal_putentryat inc dh cmp dh, VGA_WIDTH jne .cursor_moved mov dh, 0 inc dl cmp dl, VGA_HEIGHT jne .cursor_moved mov dl, 0 .cursor_moved: ; Store new cursor position mov [terminal_cursor_pos], dx ret ; IN = cx: length of string, ESI: string location ; OUT = none terminal_write: pusha .loopy: mov al, [esi] call terminal_putchar dec cx cmp cx, 0 je .done inc esi jmp .loopy .done: popa ret ; IN = ESI: zero delimited string location ; OUT = ECX: length of string terminal_strlen: push eax push esi mov ecx, 0 .loopy: mov al, [esi] cmp al, 0 je .done inc esi inc ecx jmp .loopy .done: pop esi pop eax ret ; IN = ESI: string location ; OUT = none terminal_write_string: pusha call terminal_strlen call terminal_write popa ret ; Exercises: ; - Newline support ; - Terminal scrolling when screen is full ; Note: ; - The string is looped through twice on printing. hello_string db "Hello, kernel World!", 0xA, 0 ; 0xA = line feed terminal_color db 0 terminal_cursor_pos: terminal_column db 0 terminal_row db 0
Similar as before, to assemble it:
nasm -felf32 kernel.asm -o kernel.o