init

.gitignore

@@ -2,4 +2,6 @@
 *.bin
 *.elf
 *.img
-isodir/
+isodir/
+.vscode/
+.idea/

Makefile

@@ -0,0 +1,47 @@
+CFLAGS = -ffreestanding -nostdlib -fno-builtin -fno-stack-protector -Wall -Wextra
+LDFLAGS = -ffreestanding -nostdlib -lgcc
+ASFLAGS =
+
+CC = i686-elf-gcc
+AS = i686-elf-as
+LD = i686-elf-gcc
+GRUB_FILE = grub-file
+GRUB_MKRESCUE = grub-mkrescue
+
+KERNEL = myos.bin
+ISO = myos.iso
+
+SOURCES_C = kernel.c gdt.c
+SOURCES_ASM = boot.s idt_load.s gdt_flush.s pit_handler.s
+OBJECTS = $(SOURCES_C:.c=.o) $(SOURCES_ASM:.s=.o)
+
+ISO_DIR = isodir
+GRUB_DIR = $(ISO_DIR)/boot/grub
+
+.PHONY: all clean iso
+
+all: $(ISO)
+
+$(KERNEL): $(OBJECTS) linker.ld
+	$(LD) -T linker.ld -o $(KERNEL) $(OBJECTS) $(LDFLAGS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+%.o: %.s
+	$(AS) $(ASFLAGS) $< -o $@
+
+iso: $(ISO)
+
+$(ISO): $(KERNEL) grub.cfg
+	mkdir -p $(GRUB_DIR)
+	cp $(KERNEL) $(ISO_DIR)/boot/$(KERNEL)
+	cp grub.cfg $(GRUB_DIR)/grub.cfg
+	$(GRUB_MKRESCUE) -o $(ISO) $(ISO_DIR)
+
+check-multiboot: $(KERNEL)
+	$(GRUB_FILE) --is-x86-multiboot $(KERNEL) && echo "multiboot confirmed" || echo "the file is not multiboot"
+
+clean:
+	rm -f $(OBJECTS) $(KERNEL) $(ISO)
+	rm -rf $(ISO_DIR)

boot.s

@@ -0,0 +1,89 @@
+.set ALIGN,    1<<0             
+.set MEMINFO,  1<<1             
+.set FLAGS,    ALIGN | MEMINFO
+.set MAGIC,    0x1BADB002       /* multiboot 1 */
+.set CHECKSUM, -(MAGIC + FLAGS)
+
+.section .multiboot
+.align 4
+.long MAGIC
+.long FLAGS
+.long CHECKSUM
+
+.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 the
+	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 pushed a multiple of 16 bytes to the
+	stack since (pushed 0 bytes so far), so the alignment has thus been
+	preserved and the call is well defined.
+	*/
+	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
+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

build.sh

@@ -0,0 +1,18 @@
+set -ex
+
+i686-elf-as boot.s -o boot.o
+i686-elf-as idt_load.s -o idt_load.o
+i686-elf-gcc -c kernel.c -o kernel.o -std=gnu99 -ffreestanding -O2 -Wall -Wextra
+i686-elf-gcc -T linker.ld -o myos.bin -ffreestanding -O2 -nostdlib boot.o kernel.o idt_load.o -lgcc
+
+if grub-file --is-x86-multiboot myos.bin; then
+  echo multiboot confirmed
+else
+  echo the file is not multiboot
+fi
+
+
+mkdir -p isodir/boot/grub
+cp myos.bin isodir/boot/myos.bin
+cp grub.cfg isodir/boot/grub/grub.cfg
+grub-mkrescue -o myos.iso isodir

gdt.c

@@ -0,0 +1,29 @@
+#include "gdt.h"
+
+struct gdt_entry gdt[3];
+struct gdt_ptr gdtp;
+
+extern void gdt_flush(uint32_t);
+
+void gdt_set_gate(int num, uint32_t base, uint32_t limit, uint8_t access, uint8_t gran) {
+    gdt[num].base_low = (base & 0xFFFF);
+    gdt[num].base_middle = (base >> 16) & 0xFF;
+    gdt[num].base_high = (base >> 24) & 0xFF;
+
+    gdt[num].limit_low = (limit & 0xFFFF);
+    gdt[num].granularity = (limit >> 16) & 0x0F;
+
+    gdt[num].granularity |= gran & 0xF0;
+    gdt[num].access = access;
+}
+
+void gdt_install() {
+    gdtp.limit = (sizeof(struct gdt_entry) * 3) - 1;
+    gdtp.base = (uint32_t)&gdt;
+
+    gdt_set_gate(0, 0, 0, 0, 0);                // Null segment
+    gdt_set_gate(1, 0, 0xFFFFFFFF, 0x9A, 0xCF); // Code segment
+    gdt_set_gate(2, 0, 0xFFFFFFFF, 0x92, 0xCF); // Data segment
+
+    //gdt_flush((uint32_t)&gdtp); //TODO: KERNEL PANIC
+}

gdt.h

@@ -0,0 +1,26 @@
+#ifndef GDT_H
+#define GDT_H
+
+#include <stdint.h>
+
+struct gdt_entry {
+    uint16_t limit_low;
+    uint16_t base_low;
+    uint8_t base_middle;
+    uint8_t access;
+    uint8_t granularity;
+    uint8_t base_high;
+} __attribute__((packed));
+
+struct gdt_ptr {
+    uint16_t limit;
+    uint32_t base;
+} __attribute__((packed));
+
+extern struct gdt_entry gdt[3];
+extern struct gdt_ptr gdtp;
+
+void gdt_set_gate(int num, uint32_t base, uint32_t limit, uint8_t access, uint8_t gran);
+void gdt_install();
+
+#endif

gdt_flush.s

@@ -0,0 +1,17 @@
+.section .text
+.global gdt_flush
+gdt_flush:
+    push %eax
+    mov %esp, %eax
+    add $4, %eax
+    lgdt (%eax)
+    pop %eax
+    movw $0x10, %ax
+    movw %ax, %ds
+    movw %ax, %es
+    movw %ax, %fs
+    movw %ax, %gs
+    movw %ax, %ss
+    ljmp $0x08, $flush2
+flush2:
+    ret

grub.cfg

@@ -0,0 +1,3 @@
+menuentry "dead" {
+	multiboot /boot/myos.bin
+}

idt_load.s

@@ -0,0 +1,5 @@
+.section .text
+.global idt_load
+idt_load:
+    lidt [idtp]
+    ret

kernel.c

@@ -0,0 +1,252 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "gdt.h"
+
+#define IDT_ENTRIES 256
+
+struct idt_entry {
+    uint16_t base_lo;
+    uint16_t sel;
+    uint8_t always0;
+    uint8_t flags;
+    uint16_t base_hi;
+} __attribute__((packed));
+
+struct idt_ptr {
+    uint16_t limit;
+    uint32_t base;
+} __attribute__((packed));
+
+struct idt_entry idt[IDT_ENTRIES];
+struct idt_ptr idtp;
+
+extern void idt_load();
+extern void isr_handler();
+extern void irq_handler();
+extern void pit_handler_asm();
+
+static inline void outb(uint16_t port, uint8_t val) {
+    asm volatile ("outb %0, %1" : : "a"(val), "Nd"(port));
+}
+
+static inline uint8_t inb(uint16_t port) {
+    uint8_t ret;
+    asm volatile ("inb %1, %0" : "=a"(ret) : "Nd"(port));
+    return ret;
+}
+
+void idt_set_gate(uint8_t num, uint32_t base, uint16_t sel, uint8_t flags) {
+    idt[num].base_lo = base & 0xFFFF;
+    idt[num].base_hi = (base >> 16) & 0xFFFF;
+    idt[num].sel = sel;
+    idt[num].always0 = 0;
+    idt[num].flags = flags | 0x60; // Set the interrupt gate flag
+}
+
+void idt_install() {
+    idtp.limit = (sizeof(struct idt_entry) * IDT_ENTRIES) - 1;
+    idtp.base = (uint32_t)&idt;
+    idt_load();
+}
+
+void pic_remap(int offset1, int offset2) {
+    unsigned char a1, a2;
+
+    a1 = inb(0x21);
+    a2 = inb(0xA1);
+
+    outb(0x20, 0x11);
+    outb(0xA0, 0x11);
+    outb(0x21, offset1);
+    outb(0xA1, offset2);
+    outb(0x21, 0x04);
+    outb(0xA1, 0x02);
+
+    outb(0x21, 0x01);
+    outb(0xA1, 0x01);
+
+    outb(0x21, a1);
+    outb(0xA1, a2);
+}
+
+enum vga_color {
+    VGA_COLOR_BLACK = 0,
+    VGA_COLOR_BLUE = 1,
+    VGA_COLOR_GREEN = 2,
+    VGA_COLOR_CYAN = 3,
+    VGA_COLOR_RED = 4,
+    VGA_COLOR_MAGENTA = 5,
+    VGA_COLOR_BROWN = 6,
+    VGA_COLOR_LIGHT_GREY = 7,
+    VGA_COLOR_DARK_GREY = 8,
+    VGA_COLOR_LIGHT_BLUE = 9,
+    VGA_COLOR_LIGHT_GREEN = 10,
+    VGA_COLOR_LIGHT_CYAN = 11,
+    VGA_COLOR_LIGHT_RED = 12,
+    VGA_COLOR_LIGHT_MAGENTA = 13,
+    VGA_COLOR_LIGHT_BROWN = 14,
+    VGA_COLOR_WHITE = 15,
+};
+
+static inline uint8_t vga_entry_color(enum vga_color fg, enum vga_color bg) {
+    return fg | bg << 4;
+}
+
+static inline uint16_t vga_entry(unsigned char uc, uint8_t color) {
+    return (uint16_t) uc | (uint16_t) color << 8;
+}
+
+size_t strlen(const char* str) {
+    size_t len = 0;
+    while (str[len])
+        len++;
+    return len;
+}
+
+static const size_t VGA_WIDTH = 80;
+static const size_t VGA_HEIGHT = 25;
+
+size_t terminal_row;
+size_t terminal_column;
+uint8_t terminal_color;
+uint16_t* terminal_buffer;
+
+void terminal_initialize(void) {
+    terminal_row = 0;
+    terminal_column = 0;
+    terminal_color = vga_entry_color(VGA_COLOR_LIGHT_GREY, VGA_COLOR_BLACK);
+    terminal_buffer = (uint16_t*) 0xB8000;
+    for (size_t y = 0; y < VGA_HEIGHT; y++) {
+        for (size_t x = 0; x < VGA_WIDTH; x++) {
+            const size_t index = y * VGA_WIDTH + x;
+            terminal_buffer[index] = vga_entry(' ', terminal_color);
+        }
+    }
+}
+
+void terminal_setcolor(uint8_t color) {
+    terminal_color = color;
+}
+
+void terminal_putentryat(char c, uint8_t color, size_t x, size_t y) {
+    const size_t index = y * VGA_WIDTH + x;
+    terminal_buffer[index] = vga_entry(c, color);
+}
+
+void terminal_scroll(void) {
+    for (size_t y = 0; y < VGA_HEIGHT - 1; y++) {
+        for (size_t x = 0; x < VGA_WIDTH; x++) {
+            terminal_buffer[y * VGA_WIDTH + x] = terminal_buffer[(y + 1) * VGA_WIDTH + x];
+        }
+    }
+    for (size_t x = 0; x < VGA_WIDTH; x++) {
+        terminal_buffer[(VGA_HEIGHT - 1) * VGA_WIDTH + x] = vga_entry(' ', terminal_color);
+    }
+    terminal_row = VGA_HEIGHT - 1;
+}
+
+void terminal_putchar(char c) {
+    if (c == '\n') {
+        terminal_column = 0;
+        if (++terminal_row == VGA_HEIGHT) {
+            terminal_scroll();
+        }
+    } else {
+        terminal_putentryat(c, terminal_color, terminal_column, terminal_row);
+        if (++terminal_column == VGA_WIDTH) {
+            terminal_column = 0;
+            if (++terminal_row == VGA_HEIGHT) {
+                terminal_scroll();
+            }
+        }
+    }
+}
+
+void terminal_write(const char* data, size_t size) {
+    for (size_t i = 0; i < size; i++)
+        terminal_putchar(data[i]);
+}
+
+void terminal_writestring(const char* data) {
+    terminal_write(data, strlen(data));
+}
+
+volatile uint32_t tick = 0;
+
+void pit_handler() {
+    tick++;
+    outb(0x20, 0x20);
+}
+
+void delay(uint32_t milliseconds) {
+    uint32_t end = tick + milliseconds;
+    while (tick < end) {
+        asm volatile("hlt");
+    }
+}
+
+uint8_t vga_color_from_char(char color_code) {
+    switch (color_code) {
+        case '0': return VGA_COLOR_BLACK;
+        case '1': return VGA_COLOR_BLUE;
+        case '2': return VGA_COLOR_GREEN;
+        case '3': return VGA_COLOR_CYAN;
+        case '4': return VGA_COLOR_RED;
+        case '5': return VGA_COLOR_MAGENTA;
+        case '6': return VGA_COLOR_BROWN;
+        case '7': return VGA_COLOR_LIGHT_GREY;
+        case '8': return VGA_COLOR_DARK_GREY;
+        case '9': return VGA_COLOR_LIGHT_BLUE;
+        case 'a': return VGA_COLOR_LIGHT_GREEN;
+        case 'b': return VGA_COLOR_LIGHT_CYAN;
+        case 'c': return VGA_COLOR_LIGHT_RED;
+        case 'd': return VGA_COLOR_LIGHT_MAGENTA;
+        case 'e': return VGA_COLOR_LIGHT_BROWN;
+        case 'f': return VGA_COLOR_WHITE;
+        default: return VGA_COLOR_LIGHT_GREY;
+    }
+}
+
+void terminal_writestring_with_colors(const char* data) {
+    while (*data) {
+        if (*data == '&' && (*(data + 1) >= '0' && *(data + 1) <= '9' || *(data + 1) >= 'a' && *(data + 1) <= 'f')) {
+            terminal_setcolor(vga_entry_color(vga_color_from_char(*(data + 1)), VGA_COLOR_BLACK));
+            data += 2;
+        } else {
+            terminal_putchar(*data);
+            data++;
+        }
+    }
+}
+
+#define PIT_FREQUENCY 1193182
+#define PIT_CHANNEL_0 0x40
+#define PIT_COMMAND 0x43
+
+void pit_set_frequency(uint32_t frequency) {
+    uint32_t divisor = PIT_FREQUENCY / frequency;
+    outb(PIT_COMMAND, 0x36);
+    outb(PIT_CHANNEL_0, divisor & 0xFF);
+    outb(PIT_CHANNEL_0, (divisor >> 8) & 0xFF);
+}
+
+
+
+void kernel_main(void) {
+    terminal_initialize();
+    //gdt_install();
+    idt_install();
+    pic_remap(0x20, 0x28);
+    pit_set_frequency(1000);
+    idt_set_gate(32, (uint32_t)pit_handler_asm, 0x08, 0x8E);
+    asm volatile("sti");
+    terminal_writestring_with_colors("Hello, kernel World!\n&5Magenta String Example\nThis is a &4red string&7.\n");
+    for (int i = 0; i < 30; i++) {
+        terminal_writestring_with_colors("Line ");
+        terminal_putchar('0' + (i / 10));
+        terminal_putchar('0' + (i % 10));
+        terminal_writestring_with_colors("\n");
+        delay(1000);
+    }
+}

linker.ld

@@ -0,0 +1,24 @@
+ENTRY(_start)
+
+SECTIONS
+{
+    . = 1M;
+
+    .text ALIGN(4K) :
+    {
+        *(.multiboot)
+        *(.text)
+        *(.rodata)
+    }
+
+    .data ALIGN(4K) :
+    {
+        *(.data)
+    }
+
+    .bss ALIGN(4K) :
+    {
+        *(.bss)
+        *(COMMON)
+    }
+}

pit_handler.s

@@ -0,0 +1,12 @@
+.section .text
+.global pit_handler_asm
+
+pit_handler_asm:
+    push %eax               # Save the registers used by the C handler
+    push %ecx
+    push %edx
+    call pit_handler        # Call the C handler
+    pop %edx                # Restore the registers in reverse order
+    pop %ecx
+    pop %eax
+    iret                    # Return from interrupt