Make kernel multiboot compatible

Makefile

@@ -17,7 +17,7 @@ cobj=$(csrc:%.c=%.o)
 deps = $(csrc:%.c=%.d)
 
 kernel:$(asmobj) $(cobj) linker.ld
-	$(CXX) $(LDFLAGS) $(cobj) $(asmobj) -o $@ -T linker.ld
+	$(CC) -m32  -ffreestanding -nostdlib  $(cobj) $(asmobj) -o $@ -T linker.ld
 
 fd.img: kernel
 	dd if=/dev/zero of=$@ bs=512 count=2880
@@ -33,7 +33,7 @@ core/irq_handler.o:core/irq_handler.c
 	$(AS) $(ASFLAGS) -o $@ $<
 
 test:kernel
-	qemu-system-x86_64 -fda $<
+	qemu-system-x86_64 -kernel $<
 
 clean:
 	$(RM) kernel $(asmobj) $(cobj) $(deps)

boot.asm

@@ -0,0 +1,90 @@
+; 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:
+ 
+; 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 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
+	;    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:

boot.s

@@ -0,0 +1,109 @@
+/* Declare constants for the multiboot header. */
+.set ALIGN,    1<<0             /* align loaded modules on page boundaries */
+.set MEMINFO,  1<<1             /* provide memory map */
+.set FLAGS,    ALIGN | MEMINFO  /* this is the Multiboot 'flag' field */
+.set MAGIC,    0x1BADB002       /* 'magic number' lets bootloader find the header */
+.set CHECKSUM, -(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
+.long MAGIC
+.long FLAGS
+.long 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:
+.skip 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.
+*/
+.section .text
+.global _start
+.type _start, @function
+_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 $stack_top, %esp
+
+	/*
+	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.
+	*/
+	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
+	   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
+1:	hlt
+	jmp 1b
+
+/*
+Set the size of the _start symbol to the current location '.' minus its start.
+This is useful when debugging or when you implement call tracing.
+*/
+.size _start, . - _start

linker.ld

@@ -1,26 +1,43 @@
-ENTRY(boot)
+/* The bootloader will look at this image and start execution at the symbol
-OUTPUT_FORMAT("binary")
+   designated as the entry point. */
-SECTIONS {
+ENTRY(_start)
-	. = 0x7c00;
+
-	.text :
+/* Tell where the various sections of the object files will be put in the final
+   kernel image. */
+SECTIONS
 {
-		*(.boot)
+	/* Begin putting sections at 1 MiB, a conventional place for kernels to be
+	   loaded at by the bootloader. */
+	. = 1M;
+
+	/* First put the multiboot header, as it is required to be put very early
+	   early in the image or the bootloader won't recognize the file format.
+	   Next we'll put the .text section. */
+	.text BLOCK(4K) : ALIGN(4K)
+	{
+		*(.multiboot)
 		*(.text)
 	}
 
-	.rodata :
+	/* Read-only data. */
+	.rodata BLOCK(4K) : ALIGN(4K)
 	{
 		*(.rodata)
 	}
 
-	.data :
+	/* Read-write data (initialized) */
+	.data BLOCK(4K) : ALIGN(4K)
 	{
 		*(.data)
 	}
 
-	.bss :
+	/* Read-write data (uninitialized) and stack */
+	.bss BLOCK(4K) : ALIGN(4K)
 	{
+		*(COMMON)
 		*(.bss)
 	}
-}
 
+	/* The compiler may produce other sections, by default it will put them in
+	   a segment with the same name. Simply add stuff here as needed. */
+}

mbr.asm

@@ -1,161 +0,0 @@
-section .boot
-bits 16
-global boot
-boot:
-	jmp main
-
-display_enable:
-    push bp
-    mov bp, sp
-    mov ah, 0h      ; 00h    Set Video Mode
-    mov al, 07h     ; Txt, monochrome, 80x25
-
-    int 10h
-
-    mov sp, bp
-    pop bp
-    ret
-
-print:
-    push bp
-    mov bp, sp
-    mov si, [bp + 4]; put first function arg in si. sp is stask pointer
-.loop:
-    lodsb           ; load si content into al then inc si
-    cmp al, 0;
-    je .end
-
-    mov ah, 0eh
-    mov bx, 0
-    int 10h
-
-    jmp .loop
-
-.end:
-    mov sp, bp
-    pop bp
-    ret
-
-println:
-    push bp
-    mov bp, sp
-    push word [bp + 4]
-    call print
-    add sp, 2
-
-    mov ah, 03h     ; read cursor position
-    int 10h         ; row number in dh. Col in dl
-
-    inc dh          ; goto next line
-    mov dl, 0
-
-    mov ah, 02h     ; Set Cursor Position
-    int 10h
-    mov sp, bp
-    pop bp
-    ret
-
-hello db 'Booting matOs', 0
-
-main:
-    sti             ; enable virtual interupts
-    mov [disk],dl   ; save disk used to boot by bios
-
-    call display_enable
-
-    push hello
-    call println
-    add sp, 2
-
-; Switch in 32bits Protected mode
-
-    ; Activate A20 http://wiki.osdev.org/A20_Line to be able to access more than 1Mb memory
-    mov ah, 0h
-    mov ax, 0x2401
-    int 0x15
-
-    ; Change video mode to display VGA
-    mov ax, 0x3
-    int 0x10
-
-    ; http://www.ctyme.com/intr/rb-0607.htm
-    ; Bios read first 512 bytes, read next disk sector
-    mov ah, 0x2    ;read sectors
-    mov al, 15     ;sectors to read
-    mov ch, 0      ;cylinder idx
-    mov dh, 0      ;head idx
-    mov cl, 2      ;sector idx
-    mov dl, [disk] ;disk idx
-    mov bx, copy_target;target pointer
-    int 0x13
-
-    cli ; disable interruption when setting GDT
-
-    ; switch in 32 bits
-    lgdt [gdt_pointer] ; switch in 32bits here
-    mov eax, cr0
-    or eax,0x1; set the protected mode bit on special CPU reg cr0
-    mov cr0, eax
-    jmp CODE_SEG:boot2 ; In protected mode we need to add the segment selector
-
-; GDT table desciption could be found http://wiki.osdev.org/Global_Descriptor_Table
-; here we define the 3 64bits segment needed: null segment, code segment and data segment
-gdt_start: ;null segment
-	dq 0x0
-gdt_code:  ;code segment
-	dw 0xFFFF	; limit [0:15]
-	dw 0x0		; base [0:15]
-	db 0x0		; base [16:23]
-	db 10011010b    ; access byte:  Present(1)| Priv(2) 0 ->kernel 3->userspace | 1 | Executable(1) | Direction/Conformity (1) | RW(1) | Accessed(1)
-	db 11001111b	; Granularity(1) | Size (1) 0-> 16bit mode 1->32protected mode | 0 | 0 | Limit [16:19]
-	db 0x0		; base [24:31]
-gdt_data:
-	dw 0xFFFF
-	dw 0x0
-	db 0x0
-	db 10010010b
-	db 11001111b
-	db 0x0
-gdt_end:
-gdt_pointer:
-	dw gdt_end - gdt_start
-	dd gdt_start
-disk:
-	db 0x0
-CODE_SEG equ gdt_code - gdt_start
-DATA_SEG equ gdt_data - gdt_start
-
-times 510 - ($-$$) db 0
-dw 0xaa55
-copy_target:
-bits 32
-boot2:
-	mov ax, DATA_SEG ; set all segments to point to DATA_SEG https://en.wikipedia.org/wiki/X86_memory_segmentation
-	mov ds, ax       ; Data segment
-	mov es, ax	 ; Extra Segment (for string operation)
-	mov fs, ax	 ; No Specific use
-	mov gs, ax	 ; No Specific use
-	mov ss, ax	 ; stack segment
-	mov esi,hello32
-	mov ebx,0xb8000 ; Cannot use BIOS anymore, use VGA Text buffer instead
-
-.loop32:
-	lodsb
-	or al,al
-	jz halt
-	or eax,0x0100 ; blue bg
-	mov word [ebx], ax
-	add ebx,2
-	jmp .loop32
-halt:
-	mov esp,kernel_stack_top
-	extern kmain
-	call kmain
-	cli
-	hlt
-hello32: db "Hello 32 bits world!",0
-section .bss
-align 4
-kernel_stack_bottom: equ $
-	resb 16384 ; 16 KB
-kernel_stack_top: