Create src directory and basic serial stuff

Currently makefile doesn't work

src/asm.c

+/*
+  asm.c contains x86 specific functions for executing low level code
+*/
+
+#include "asm.h"
+
+// Wrapper for outb
+// Stolen from http://wiki.osdev.org/Inline_Assembly/Examples
+static inline void outb(uint16_t port, uint8_t val) {
+    asm volatile ("outb %0, %1" : : "a"(val), "Nd"(port));
+}
+
+// Wrapper for inb
+static inline uint8_t inb(uint16_t port) {
+    uint8_t ret;
+    asm volatile ("inb %1, %0" : "=a"(ret) : "Nd"(port));
+    return ret;
+}

src/asm.h

+/*
+  asm.h exports archatecture specific functions for hardware interaction
+*/
+
+#include <stdint.h>
+
+// Functions for reading and writing to/from x86 IO ports
+static inline void outb(uint16_t port, uint8_t val);
+static inline uint8_t inb(uint16_t port);

src/head.asm

+; Declare constants used for creating a 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 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
+align 4
+	dd MAGIC
+	dd FLAGS
+	dd CHECKSUM
+ 
+; Currently the stack pointer register (esp) points at anything and using it may
+; cause massive harm. Instead, we'll provide our own stack. We will allocate
+; room for a small temporary stack by creating a symbol at the bottom of it,
+; then allocating 16384 bytes for it, and finally creating a symbol at the top.
+section .bootstrap_stack, nobits
+align 4
+stack_bottom:
+resb 16384
+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
+_start:
+	; Welcome to kernel mode! We now have sufficient code for the bootloader to
+	; load and run our operating system. It doesn't do anything interesting yet.
+	; Perhaps we would like to call printf("Hello, World\n"). You should now
+	; realize one of the profound truths about kernel mode: There is nothing
+	; there unless you provide it yourself. There is no printf function. There
+	; is no <stdio.h> header. If you want a function, you will have to code it
+	; yourself. And that is one of the best things about kernel development:
+	; you get to make the entire system yourself. You have absolute and complete
+	; power over the machine, there are no security restrictions, no safe
+	; guards, no debugging mechanisms, there is nothing but what you build.
+ 
+	; By now, you are perhaps tired of assembly language. You realize some
+	; things simply cannot be done in C, such as making the multiboot header in
+	; 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
+ 
+	; We are now ready to actually execute C code. We cannot embed that in an
+	; assembly file, so we'll create a kernel.c file in a moment. In that file,
+	; we'll create a C entry point called kernel_main and call it here.
+	extern kernel_main
+	call kernel_main
+ 
+	; In case the function returns, we'll want to put the computer into an
+	; infinite loop. To do that, we use the clear interrupt ('cli') instruction
+	; to disable interrupts, the halt instruction ('hlt') to stop the CPU until
+	; the next interrupt arrives, and jumping to the halt instruction if it ever
+	; continues execution, just to be safe.
+	cli
+.hang:
+	hlt
+	jmp .hang

src/kern.c

+#if !defined(__cplusplus)
+#include <stdbool.h> /* C doesn't have booleans by default. */
+#endif
+#include <stddef.h>
+#include <stdint.h>
+ 
+/* Check if the compiler thinks we are targeting the wrong operating system. */
+#if defined(__linux__)
+#error "You are not using a cross-compiler, you will most certainly run into trouble"
+#endif
+ 
+/* This tutorial will only work for the 32-bit ix86 targets. */
+#if !defined(__i386__)
+#error "This tutorial needs to be compiled with a ix86-elf compiler"
+#endif
+
+#include "serial.h"
+ 
+/* Hardware text mode color constants. */
+enum vga_color {
+	COLOR_BLACK = 0,
+	COLOR_BLUE = 1,
+	COLOR_GREEN = 2,
+	COLOR_CYAN = 3,
+	COLOR_RED = 4,
+	COLOR_MAGENTA = 5,
+	COLOR_BROWN = 6,
+	COLOR_LIGHT_GREY = 7,
+	COLOR_DARK_GREY = 8,
+	COLOR_LIGHT_BLUE = 9,
+	COLOR_LIGHT_GREEN = 10,
+	COLOR_LIGHT_CYAN = 11,
+	COLOR_LIGHT_RED = 12,
+	COLOR_LIGHT_MAGENTA = 13,
+	COLOR_LIGHT_BROWN = 14,
+	COLOR_WHITE = 15,
+};
+ 
+uint8_t make_color(enum vga_color fg, enum vga_color bg) {
+	return fg | bg << 4;
+}
+ 
+uint16_t make_vgaentry(char c, uint8_t color) {
+	uint16_t c16 = c;
+	uint16_t color16 = color;
+	return c16 | color16 << 8;
+}
+ 
+size_t strlen(const char* str) {
+	size_t ret = 0;
+	while ( str[ret] != 0 )
+		ret++;
+	return ret;
+}
+ 
+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() {
+	terminal_row = 0;
+	terminal_column = 0;
+	terminal_color = make_color(COLOR_LIGHT_GREY, 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] = make_vgaentry(' ', 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] = make_vgaentry(c, color);
+}
+ 
+void terminal_putchar(char c) {
+	terminal_putentryat(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_writestring(const char* data) {
+	size_t datalen = strlen(data);
+	for (size_t i = 0; i < datalen; i++)
+		terminal_putchar(data[i]);
+}
+ 
+#if defined(__cplusplus)
+extern "C" /* Use C linkage for kernel_main. */
+#endif
+void kernel_main() {
+	/* Initialize terminal interface */
+	terminal_initialize();
+ 
+	/* Since there is no support for newlines in terminal_putchar
+         * yet, '\n' will produce some VGA specific character instead.
+         * This is normal.
+         */
+	terminal_writestring("Hello, kernel World!\n");
+    serial_init();
+    serial_writestring("Hello, kernel World!\n");    
+}

src/linker.ld

+/* 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
+{
+	/* 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)
+	}
+
+	/* 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)
+		*(.bootstrap_stack)
+	}
+
+	/* 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. */
+}

src/makefile

+C=/home/adam/college/kernel/cross/bin/i686-elf-gcc
+
+all:
+	/usr/bin/nasm -felf32 head.asm -o boot.o
+	$C *.c -std=gnu99 -ffreestanding -O2 -Wall -Wextra -c
+	$C -T linker.ld -o myos.bin -ffreestanding -O2 -nostdlib *.o -lgcc
+
+clean:

src/serial.c

+/*
+  serial.c has functions for handling and writing to the serial port. Often used for debugging
+*/
+
+#include "serial.h"
+
+#define SERIAL_IO_PORT 0x3f8 // COM1
+
+void serial_init() {
+    outb(SERIAL_IO_PORT + 1, 0x00);    // Disable all interrupts
+    outb(SERIAL_IO_PORT + 3, 0x80);    // Enable DLAB (set baud rate divisor)
+    outb(SERIAL_IO_PORT + 0, 0x03);    // Set divisor to 3 (lo byte) 38400 baud
+    outb(SERIAL_IO_PORT + 1, 0x00);    //                  (hi byte)
+    outb(SERIAL_IO_PORT + 3, 0x03);    // 8 bits, no parity, one stop bit
+    outb(SERIAL_IO_PORT + 2, 0xC7);    // Enable FIFO, clear them, with 14-byte threshold
+    outb(SERIAL_IO_PORT + 4, 0x0B);    // IRQs enabled, RTS/DSR set
+}
+
+int is_transmit_empty() {
+    return inb(SERIAL_IO_PORT + 5) & 0x20;
+}
+
+void serial_writechar(char a) {
+    while (is_transmit_empty() == 0);
+
+    outb(SERIAL_IO_PORT,a);
+}
+
+void serial_writestring(char* s) {
+    while (s) {
+        serial_writechar(*s);
+        s++;
+    }
+}

src/serial.h

+/*
+  serial.h contains headers for the serial interaction functions
+*/
+
+#include "asm.h"
+
+// Initilizes the first serial port
+void serial_init();
+
+// Tests that the serial transmit channel is free
+int is_transmit_empty();
+
+// Write a single character to serial
+void serial_writechar(char a);
+
+// Write a null terminated string to serial
+void serial_writestring(char* s);