boot.s

# http://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 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 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-i686.rb

#######################################################################
#
# This is a kernbuild buildfile for the Bare-Bone Example @ osdev.org
#     http://wiki.osdev.org/Bare_Bones
#
# You need ruby to run it. It is tested with ruby 1.9 but 2.0 and
# later should just work as well.
# Do (building)
#  ruby build-i686.rb
#  make
# Do (running)
#  qemu-system-i386 -kernel myos.bin
#
#######################################################################

require './kernbuild.rb'

Compiler.add "c"   , cc:"i686-elf-gcc" , cflags:"-std=gnu99 -ffreestanding -O2 -Wall -Wextra"
Compiler.add "c++" , cc:"i686-elf-g++" , cflags:"-std=gnu99 -ffreestanding -O2 -Wall -Wextra"
Compiler.add "s"   , cc:"i686-elf-as"  , cflags:""
Linker.add ld:"i686-elf-gcc -T linker.ld", ldflags:"-ffreestanding -O2 -nostdlib", ldlibs:"-lgcc"

Makefile.project("")
Makefile.open('Makefile')

Makefile.rule "all",["myos.bin"],[]

add_mod "myos.bin" ,"kernel.c","boot.s"

Makefile.close

kernbuild.rb

#
# Copyright (c) 2016 Simon Schmidt
#
# This software is provided 'as-is', without any express or implied
# warranty. Permission is granted to anyone to use this software for
# any purpose, including commercial applications, and to alter it and
# redistribute it freely.
#

######################################################################
#
# This software is Kind-of a minimal CMAKE-workalike, but optimized
# for Bare-Metal / Kernel developement.
#
######################################################################

module Language
	EXT = {"cc"=>"c++", "asm"=>"s"}
	def Language.reduce(name)
		ext = (name.downcase.match(/\.([a-z0-9_]+)/) or [nil,"txt"])[1]
		while Language::EXT[ext] do ext = Language::EXT[ext] end
		ext
	end
end

module Compiler
	FLAGS = [""]
	STEPX = {
		"c"   => ["%{cc} -c %%{src} -o %%{dest} %{cflags} %%{flags}"],
		"c++" => ["%{cc} -c %%{src} -o %%{dest} %{cflags} %%{flags}"],
		"s"   => ["%{cc}    %%{src} -o %%{dest} %{cflags} %%{flags}"]
	}
	STEP = {}
	def Compiler.add(l,conf)
		if STEPX[l]
			STEP[l] = STEPX[l].map{|a| a % conf}
		end
	end
	def Compiler.flags(f)
		FLAGS[0]=f
	end
	def Compiler.incls(ic)
		FLAGS[0]="-I#{Makefile::SRCPREFIX[0]}#{ic}"
	end
	def Compiler.compile(name,dest)
		ext = Language.reduce(name)
		(Compiler::STEP[ext] or ["false"]).map{|a| a % {src: name,dest: dest,flags: FLAGS[0]} }
	end
end

module Linker
	STEPX = ["%{ld} -o %%{dest} %{ldflags} %%{parts} %{ldlibs}"] # -lgcc
	STEP = [["false"]]
	def Linker.add(conf)
		STEP[0] = STEPX.map{|a| a % conf }
	end
	def Linker.link(dest,parts)
		steps = STEP[0].map{|a| a % {dest: dest,parts: parts.join(" ")} }
		Makefile.rule(dest,parts,steps)
	end
end

module Makefile
	OUT = [$stdout]
	HAS = {}
	REPL = {"/"=>"_1","_"=>"_2"}
	REGX = /[\/\_]/
	SRCPREFIX = [""]
	DSTPREFIX = [""]
	def Makefile.rule(name,need,steps)
		a = steps.map{|a| "\t#{a}\n"}.join("\n")
		b = "#{name}: #{need.join(" ")}\n#{a}\n"
		Makefile::OUT[0].write(b)
	end
	def Makefile.need(src)
		if HAS[src]
			return HAS[src]
		end
		srcx = src[SRCPREFIX[0].length..-1].gsub(REGX,REPL)
		dest = "#{DSTPREFIX[0]}#{srcx}.o"
		Makefile.rule(dest,[src],Compiler.compile(src,dest))
		HAS[src] = dest
		dest
	end
	def Makefile.open(x)
		Makefile::OUT[0] = File.open(x,'w')
	end
	def Makefile.close
		if Makefile::OUT[0] == $stdout
			return
		end
		Makefile::OUT[0].close
		Makefile::OUT[0] = $stdout
	end
	def Makefile.project(src,dst="KBCache/")
		begin
			Dir.mkdir(dst)
		rescue
		end
		SRCPREFIX[0]=src
		DSTPREFIX[0]=dst
	end
	def Makefile.glob(path)
		Dir.glob("#{SRCPREFIX[0]}#{path}")
	end
end

def add_mod(m,*depsrc)
	Linker.link(m,depsrc.map{|a| Makefile.need(a) })
end

kernel.c

/* http://wiki.osdev.org/Bare_Bones */

/* Surely you will remove the processor conditionals and this comment
   appropriately depending on whether or not you use 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
 
/* Hardware text mode color constants. */
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_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_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));
}
 
#if defined(__cplusplus)
extern "C" /* Use C linkage for kernel_main. */
#endif
void kernel_main(void) {
	/* Initialize terminal interface */
	terminal_initialize();
 
	/* Newline support is left as an exercise. */
	terminal_writestring("Hello, kernel World!\n");
}

linker.ld

/* http://wiki.osdev.org/Bare_Bones */
/* 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)
	}

	/* 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. */
}