Multiboot1 Bare Bones with NASM: Difference between revisions
Jump to navigation
Jump to search
[unchecked revision] | [unchecked revision] |
Content deleted Content added
m Actually fix indention. I need to check my edits more closely. |
m Mintsuki moved page Bare Bones with NASM to Multiboot1 Bare Bones with NASM: New title better suits page contents. |
||
(16 intermediate revisions by 10 users not shown) | |||
Line 5: | Line 5: | ||
We will now create a file called boot.asm and discuss its contents. In this example, we are using the [[NASM|Netwide Assembler]] which is not part of your previously built cross-compiler toolchain and you will have to install it separately. |
We will now create a file called boot.asm and discuss its contents. In this example, we are using the [[NASM|Netwide Assembler]] which is not part of your previously built cross-compiler toolchain and you will have to install it separately. |
||
<syntaxhighlight lang="asm"> |
|||
The very most important piece to create is the multiboot header, as it must be very early in the kernel binary, or the bootloader will fail to recognize us. |
|||
; 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 |
|||
<source lang="asm"> |
|||
; |
; 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 |
|||
MBALIGN equ 1<<0 ; align loaded modules on page boundaries |
|||
; 32-bit boundary. The signature is in its own section so the header can be |
|||
MEMINFO equ 1<<1 ; provide memory map |
|||
; forced to be within the first 8 KiB of the kernel file. |
|||
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 header as in the Multiboot Standard. We put this into a special |
|||
; section so we can force the header to be in the start of the final program. |
|||
; You don't need to understand all these details as it is just magic values that |
|||
; is documented in the multiboot standard. The bootloader will search for this |
|||
; magic sequence and recognize us as a multiboot kernel. |
|||
section .multiboot |
section .multiboot |
||
align 4 |
align 4 |
||
dd MAGIC |
dd MAGIC |
||
dd |
dd MBFLAGS |
||
dd CHECKSUM |
dd CHECKSUM |
||
; The multiboot standard does not define the value of the stack pointer register |
|||
; Currently the stack pointer register (esp) points at anything and using it may |
|||
; (esp) and it is up to the kernel to provide a stack. This allocates room for a |
|||
; cause massive harm. Instead, we'll provide our own stack. We will allocate |
|||
; |
; 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, |
|||
section .bootstrap_stack |
|||
; which means the kernel file is smaller because it does not contain an |
|||
align 4 |
|||
; 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: |
stack_bottom: |
||
resb 16384 ; 16 KiB |
|||
stack_top: |
stack_top: |
||
Line 39: | Line 43: | ||
; bootloader will jump to this position once the kernel has been loaded. It |
; 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. |
; 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 |
section .text |
||
global _start |
global _start:function (_start.end - _start) |
||
_start: |
_start: |
||
; The bootloader has loaded us into 32-bit protected mode on a x86 |
|||
; Welcome to kernel mode! We now have sufficient code for the bootloader to |
|||
; machine. Interrupts are disabled. Paging is disabled. The processor |
|||
; load and run our operating system. It doesn't do anything interesting yet. |
|||
; state is as defined in the multiboot standard. The kernel has full |
|||
; Perhaps we would like to call printf("Hello, World\n"). You should now |
|||
; |
; 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 |
|||
; yourself. And that is one of the best things about kernel development: |
|||
; safeguards, no debugging mechanisms, only what the kernel provides |
|||
; you get to make the entire system yourself. You have absolute and complete |
|||
; itself. It has absolute and complete power over the |
|||
; power over the machine, there are no security restrictions, no safe |
|||
; machine. |
|||
; guards, no debugging mechanisms, there is nothing but what you build. |
|||
; To set up a stack, we set the esp register to point to the top of our |
|||
; By now, you are perhaps tired of assembly language. You realize some |
|||
; stack (as it grows downwards on x86 systems). This is necessarily done |
|||
; things simply cannot be done in C, such as making the multiboot header in |
|||
; in assembly as languages such as C cannot function without a stack. |
|||
; the right section and setting up the stack. However, you would like to |
|||
; write the operating system in a higher level language, such as C or C++. |
|||
; To that end, the next task is preparing the processor for execution of |
|||
; such code. C doesn't expect much at this point and we only need to set up |
|||
; a stack. Note that the processor is not fully initialized yet and stuff |
|||
; such as floating point instructions are not available yet. |
|||
; To set up a stack, we simply set the esp register to point to the top of |
|||
; our stack (as it grows downwards). |
|||
mov esp, stack_top |
mov esp, stack_top |
||
; This is a good place to initialize crucial processor state before the |
|||
; We are now ready to actually execute C code. We cannot embed that in an |
|||
; high-level kernel is entered. It's best to minimize the early |
|||
; assembly file, so we'll create a kernel.c file in a moment. In that file, |
|||
; environment where crucial features are offline. Note that the |
|||
; we'll create a C entry point called kernel_main and call it here. |
|||
; 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 |
call kernel_main |
||
; |
; If the system has nothing more to do, put the computer into an |
||
; infinite loop. To do that |
; 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. |
|||
; the next interrupt arrives, and jumping to the halt instruction if it ever |
|||
; Mind that you might later enable interrupts and return from |
|||
; continues execution, just to be safe. |
|||
; 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 |
cli |
||
.hang: |
.hang: hlt |
||
hlt |
|||
jmp .hang |
jmp .hang |
||
.end: |
|||
</source> |
|||
</syntaxhighlight> |
|||
You can then assemble boot.asm using: |
You can then assemble boot.asm using: |
||
< |
<syntaxhighlight lang="bash">nasm -felf32 boot.asm -o boot.o</syntaxhighlight> |
||
== Kernel == |
|||
<syntaxhighlight lang="asm"> |
|||
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 |
|||
</syntaxhighlight> |
|||
Similar as before, to assemble it: |
|||
<syntaxhighlight lang="bash">nasm -felf32 kernel.asm -o kernel.o</syntaxhighlight> |
|||
[[Category:Tutorials]] |
|||
[[Category:Bare bones tutorials]] |
|||
[[Category:Assembly]] |
Latest revision as of 13:36, 21 June 2024
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