init kernel

3 files changed, 283 insertions, 0 deletions

diff --git a/kernel/src/boot.s b/kernel/src/boot.s
new file mode 100644
index 0000000..a7d2a6b
--- /dev/null
+++ b/kernel/src/boot.s
@@ -0,0 +1,116 @@
+.intel_syntax noprefix
+
+/* Adapted from https://wiki.osdev.org/Bare_Bones */
+
+/* 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 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 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 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
+  jmp quit
+
+quit:
+  hlt
+	jmp quit
+
+/*
+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
diff --git a/kernel/src/kernel.c b/kernel/src/kernel.c
new file mode 100644
index 0000000..32ba4bd
--- /dev/null
+++ b/kernel/src/kernel.c
@@ -0,0 +1,115 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/* TODO: Implement strlen in libc */
+size_t
+strlen(const char* str)
+{
+  size_t len = 0;
+  while (str[len])
+    len++;
+
+  return len;
+}
+
+/* Hardware text mode color constants. */
+typedef enum {
+  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,
+} vga_color;
+
+static const uint8_t VGA_WIDTH = 80;
+static const uint8_t VGA_HEIGHT = 25;
+
+uint8_t terminal_row;
+uint8_t terminal_column;
+uint8_t terminal_color;
+uint16_t *terminal_buffer;
+
+uint8_t
+vga_entry_color(vga_color fg, vga_color bg)
+{
+  /*
+   * bg   fg
+   * 1110 0101
+  */
+  return bg << 4 | fg;
+}
+
+uint16_t
+vga_entry(unsigned char character, uint8_t color)
+{
+  /*
+   * TODO: Unsure if this understanding
+   * is correct.
+   * color     character
+   * 1110 0101 1001 1010
+  */
+  return (uint16_t) color << 8 | (uint16_t) character;
+}
+
+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 (uint8_t y = 0; y < VGA_HEIGHT; y++)
+    for (uint8_t x = 0; x < VGA_WIDTH; x++) {
+      size_t index = y * VGA_WIDTH + x;
+      terminal_buffer[index] = vga_entry(' ', terminal_color);
+    }
+}
+
+void
+terminal_put_entry_at(char c, uint8_t color, uint8_t x, uint8_t y)
+{
+  uint8_t index = y * VGA_WIDTH + x;
+  terminal_buffer[index] = vga_entry(c, color);
+}
+
+void
+terminal_write_char(char c)
+{
+  terminal_put_entry_at(c, terminal_color, terminal_column, terminal_row);
+  if (++terminal_column == VGA_WIDTH) {
+    terminal_column = 0;
+    if (++terminal_row == VGA_HEIGHT)
+      terminal_row = 0;
+  }
+}
+
+void
+terminal_write_string(char *data)
+{
+  size_t size = strlen(data);
+  for (size_t i = 0; i < size; i++)
+    terminal_write_char(data[i]);
+}
+
+void
+kernel_main(void)
+{
+  terminal_initialize();
+  terminal_write_string("kernel");
+}
diff --git a/kernel/src/linker.ld b/kernel/src/linker.ld
new file mode 100644
index 0000000..f00fa2d
--- /dev/null
+++ b/kernel/src/linker.ld
@@ -0,0 +1,52 @@
+/* The bootloader will look at this image and start execution at the symbol
+   designated as the entry point. */
+ENTRY(_start)
+
+/* Tell where the various sections of the object files will be put in the final
+   kernel image. */
+SECTIONS
+{
+	/* It used to be universally recommended to use 1M as a start offset,
+	   as it was effectively guaranteed to be available under BIOS systems.
+	   However, UEFI has made things more complicated, and experimental data
+	   strongly suggests that 2M is a safer place to load. In 2016, a new
+	   feature was introduced to the multiboot2 spec to inform bootloaders
+	   that a kernel can be loaded anywhere within a range of addresses and
+	   will be able to relocate itself to run from such a loader-selected
+	   address, in order to give the loader freedom in selecting a span of
+	   memory which is verified to be available by the firmware, in order to
+	   work around this issue. This does not use that feature, so 2M was
+	   chosen as a safer option than the traditional 1M. */
+	. = 2M;
+
+	/* First put the multiboot header, as it is required to be put very 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)
+	}
+
+	/* Read-only data. */
+	.rodata BLOCK(4K) : ALIGN(4K)
+	{
+		*(.rodata)
+	}
+
+	/* Read-write data (initialized) */
+	.data BLOCK(4K) : ALIGN(4K)
+	{
+		*(.data)
+	}
+
+	/* 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. */
+}