Meaty Skeleton: Difference between revisions

 

 

This tutorial also serves as the initial template tutorial on how to

indirectly other minor Unix and ABI semantics. Adapt what you wish from this

tutorial. Note that the shell script and Make-based build system constructed in

is no pressing need to make this portable across all operating systems as this

is just an example.

 

== Building a Cross-Compiler ==

 

You ''must'' use a [[GCC Cross-Compiler]] in this tutorial as in the

 

You ''must'' configure your cross-binutils with the <tt>--with-sysroot</tt> option, otherwise linking will mysteriously fail with the ''this linker was not configured to use sysroots'' error message. If you forgot to configure your cross-binutils with that option, you'll have to rebuild it, but you can keep your cross-gcc.

 

== System Root ==

 

 

:<tt>/usr/include</tt>

:<tt>/usr/lib</tt>

 

 

:<tt>/home/bwayne/myos/sysroot/usr/include</tt>

The <tt>/home/bwayne/myos/sysroot</tt> directory acts as a fake root directory for your operating system. This is called a system root, or ''sysroot''.

 

 

In this example the cross system root is located as <tt>sysroot/</tt>, which is

<tt>sysroot/boot</tt> directory.

 

 

The <tt>-elf</tt> targets have no user-space and are incapable of having one. We configured the compiler with system root support, so it will look in <tt>${SYSROOT}/usr/lib</tt> as expected. We prevented the compiler from searching for a standard library using the --without-headers option when building <tt>i686-elf-gcc</tt>, so it will ''not'' look in <tt>${SYSROOT}/usr/include</tt>. (Once you add a user-space and a libc, you will configure your custom cross-gcc with <tt>--with-sysroot</tt> and it will look in <tt>${SYSROOT}/usr/include</tt>. As a temporary work-around until you get that far, we fix it by passing <tt>-isystem=/usr/include</tt>).

 

 

== System Headers ==

cross-compile your operating system. This is <tt>useful</tt> as it allows you to

provide the compiler a copy of your headers before you actually compile your

 

Note how your cross-compiler comes with a number of fully freestanding headers

are used, while a default is used if the user has no opinion. The makefiles also

make sure that particular options are always in CFLAGS. This is done by having

mandatory options the project makefile requires:

 

# Default CFLAGS:

CFLAGS?=-O2 -g

# Add mandatory options to CFLAGS:

CFLAGS:=$(CFLAGS) -Wall -Wextra

 

== Architecture Directories ==

from the main kernel.

 

[[Bare Bones]] tutorial.

 

The kernel implements the correct way of [[Calling_Global_Constructors|invoking

global constructors]] (useful for C++ code and C code using

 

 

== libc and libk Design ==

of <tt>strlen</tt> and such.

 

entirely useless, except being a skeleton we can build on when we add user-space

in a later tutorial.

The standard headers use a BSD-like scheme where <tt>sys/cdefs.h</tt> declares

a bunch of useful preprocessor macros meant for internal use by the standard

<tt>extern "C" {</tt> and <tt>}</tt> such that C++ code can correctly

link against libc (as libc doesn't use C++ linkage). Note also how the compiler

provides the internal keyword __restrict unconditionally (even in C89) mode,

which is useful for adding the restrict keyword to function prototypes even when

 

 

examples and serve to satisfy ABI requirements. Note that the <tt>printf</tt>

 

== Source Code ==

--->

 

 

 

 

Operating systems development is about being an expert. Take the time to read the code carefully through and understand it. Please seek further information and help if you don't understand aspects of it. This code is minimal and almost everything is done deliberately, often to pre-emptively solve future problems.

 

=== kernel ===

 

==== kernel/include/kernel/tty.h ====

 

#ifndef _KERNEL_TTY_H

#define _KERNEL_TTY_H

 

#endif

 

==== kernel/Makefile ====

 

 

CFLAGS?=-O2 -g

INCLUDEDIR?=$(PREFIX)/include

 

LDFLAGS:=$(LDFLAGS)

LIBS:=$(LIBS) -nostdlib -lk -lgcc

 

 

include $(ARCHDIR)/make.config

 

CFLAGS:=$(CFLAGS) $(KERNEL_ARCH_CFLAGS)

LDFLAGS:=$(LDFLAGS) $(KERNEL_ARCH_LDFLAGS)

LIBS:=$(LIBS) $(KERNEL_ARCH_LIBS)

 

$(KERNEL_ARCH_OBJS) \

kernel/kernel.o \

 

 

 

 

all: myos.kernel

 

 

 

 

 

clean:

 

install: install-headers install-kernel

install-headers:

mkdir -p $(DESTDIR)$(INCLUDEDIR)

 

install-kernel: myos.kernel

mkdir -p $(DESTDIR)$(BOOTDIR)

cp myos.kernel $(DESTDIR)$(BOOTDIR)

 

==== kernel/kernel/kernel.c ====

 

#include <stdio.h>

 

#include <kernel/tty.h>

 

terminal_initialize();

printf("Hello, kernel World!\n");

}

 

==== kernel/arch/i386/tty.c ====

 

#include <stdbool.h>

#include <stddef.h>

#include <string.h>

 

 

 

terminal_row = 0;

terminal_column = 0;

terminal_buffer = VGA_MEMORY;

const size_t index = y * VGA_WIDTH + x;

}

}

}

 

terminal_color = color;

}

 

const size_t index = y * VGA_WIDTH + x;

}

 

terminal_column = 0;

{

}

}

}

 

terminal_putchar(data[i]);

}

 

terminal_write(data, strlen(data));

}

 

==== kernel/arch/i386/crtn.S ====

ret

</pre>

 

==== kernel/arch/i386/make.config ====

 

 

$(ARCHDIR)/boot.o \

$(ARCHDIR)/tty.o \

 

==== kernel/arch/i386/crti.S ====

*(COMMON)

*(.bss)

}

 

 

<pre>

.set ALIGN, 1<<0 # align loaded modules on page boundaries

.set MEMINFO, 1<<1 # provide memory map

 

# Reserve a stack for the initial thread.

stack_bottom:

.skip 16384 # 16 KiB

_start:

movl $stack_top, %esp

 

# Call the global constructors.

# Hang if kernel_main unexpectedly returns.

cli

.size _start, . - _start

</pre>

 

<pre>

*.kernel

</pre>

 

==== libc/include/string.h ====

 

#ifndef _STRING_H

#define _STRING_H 1

 

#endif

 

==== libc/include/stdio.h ====

 

#ifndef _STDIO_H

#define _STDIO_H 1

 

#include <sys/cdefs.h>

 

#ifdef __cplusplus

 

#endif

 

==== libc/include/sys/cdefs.h ====

 

#ifndef _SYS_CDEFS_H

#define _SYS_CDEFS_H 1

 

#endif

 

==== libc/include/stdlib.h ====

 

#ifndef _STDLIB_H

#define _STDLIB_H 1

 

#endif

 

==== libc/Makefile ====

 

 

CFLAGS?=-O2 -g

LIBDIR?=$(EXEC_PREFIX)/lib

 

 

 

include $(ARCHDIR)/make.config

 

CFLAGS:=$(CFLAGS) $(ARCH_CFLAGS)

LIBK_CFLAGS:=$(LIBK_CFLAGS) $(KERNEL_ARCH_CFLAGS)

 

$(ARCH_FREEOBJS) \

stdio/printf.o \

string/strlen.o \

 

$(ARCH_HOSTEDOBJS) \

 

$(FREEOBJS) \

$(HOSTEDOBJS) \

 

 

 

all: $(BINARIES)

 

libc.a: $(OBJS)

$(AR) rcs $@ $(OBJS)

 

libk.a: $(LIBK_OBJS)

$(AR) rcs $@ $(LIBK_OBJS)

 

 

 

 

 

clean:

 

install: install-headers install-libs

install-headers:

mkdir -p $(DESTDIR)$(INCLUDEDIR)

 

install-libs: $(BINARIES)

mkdir -p $(DESTDIR)$(LIBDIR)

cp $(BINARIES) $(DESTDIR)$(LIBDIR)

 

==== libc/stdlib/abort.c ====

 

#include <stdio.h>

#include <stdlib.h>

 

__attribute__((__noreturn__))

// TODO: Add proper kernel panic.

__builtin_unreachable();

}

 

==== libc/string/memmove.c ====

 

#include <string.h>

 

unsigned char* dst = (unsigned char*) dstptr;

const unsigned char* src = (const unsigned char*) srcptr;

dst[i] = src[i];

dst[i-1] = src[i-1];

return dstptr;

}

 

==== libc/string/strlen.c ====

 

#include <string.h>

 

}

 

==== libc/string/memcmp.c ====

 

#include <string.h>

 

const unsigned char* a = (const unsigned char*) aptr;

const unsigned char* b = (const unsigned char*) bptr;

return -1;

return 1;

return 0;

}

 

==== libc/string/memset.c ====

 

#include <string.h>

 

unsigned char* buf = (unsigned char*) bufptr;

buf[i] = (unsigned char) value;

return bufptr;

}

 

==== libc/string/memcpy.c ====

 

#include <string.h>

 

unsigned char* dst = (unsigned char*) dstptr;

const unsigned char* src = (const unsigned char*) srcptr;

dst[i] = src[i];

return dstptr;

}

 

==== libc/stdio/puts.c ====

 

#include <stdio.h>

 

return printf("%s\n", string);

}

 

==== libc/stdio/putchar.c ====

 

#include <stdio.h>

 

#include <kernel/tty.h>

#endif

 

char c = (char) ic;

terminal_write(&c, sizeof(c));

#else

#endif

return ic;

}

 

==== libc/stdio/printf.c ====

 

#include <stdbool.h>

#include <stdarg.h>

#include <string.h>

 

}

 

va_list parameters;

va_start(parameters, format);

 

int written = 0;

 

amount++;

format += amount;

written += amount;

}

 

 

format++;

char c = (char) va_arg(parameters, int /* char promotes to int */);

format++;

}

}

 

va_end(parameters);

return written;

}

 

==== libc/arch/i386/make.config ====

 

 

 

 

==== libc/.gitignore ====

 

<pre>

*.a

</pre>

 

==== build.sh ====

 

#!/bin/sh

set -e

 

for PROJECT in $PROJECTS; do

done

 

You should make this executable script executable by running:

chmod +x build.sh

 

==== clean.sh ====

 

#!/bin/sh

set -e

 

for PROJECT in $PROJECTS; do

done

 

 

You should make this executable script executable by running:

chmod +x clean.sh

 

==== config.sh ====

 

SYSTEM_HEADER_PROJECTS="libc kernel"

PROJECTS="libc kernel"

 

# Configure the cross-compiler to use the desired system root.

 

# Work around that the -elf gcc targets doesn't have a system include directory

if echo "$HOST" | grep -Eq -- '-elf($|-)'; then

export CC="$CC -isystem=$INCLUDEDIR"

fi

 

==== default-host.sh ====

 

#!/bin/sh

echo i686-elf

 

You should make this executable script executable by running:

chmod +x default-host.sh

 

==== headers.sh ====

 

#!/bin/sh

set -e

. ./config.sh

 

 

for PROJECT in $SYSTEM_HEADER_PROJECTS; do

done

 

You should make this executable script executable by running:

chmod +x headers.sh

 

==== iso.sh ====

 

#!/bin/sh

set -e

EOF

grub-mkrescue -o myos.iso isodir

 

You should make this executable script executable by running:

chmod +x iso.sh

 

==== qemu.sh ====

 

#!/bin/sh

set -e

 

qemu-system-$(./target-triplet-to-arch.sh $HOST) -cdrom myos.iso

 

You should make this executable script executable by running:

chmod +x qemu.sh

 

==== target-triplet-to-arch.sh ====

 

#!/bin/sh

if echo "$1" | grep -Eq 'i[[:digit:]]86-'; then

echo "$1" | grep -Eo '^[[:alnum:]_]*'

fi

 

You should make this executable script executable by running:

chmod +x target-triplet-to-arch.sh

 

==== .gitignore ====

the source tree by invoking:

 

./clean.sh

 

You can install all the system headers into the system root without relying on

[[Hosted GCC Cross-Compiler]], by invoking:

 

./headers.sh

 

You can build a bootable cdrom image of the operating system by invoking:

 

./iso.sh

 

It's probably a good idea to create a quick ''build-and-then-launch'' short-cut

like used in this example to run the system in your favorite emulator quickly:

 

./qemu.sh

 

== Troubleshooting ==

 

 

== Moving Forward ==

 

Early is not too soon to think about security and robustness. You can take advantage of the optional stack smash protector offered by modern compilers that detect stack buffer overruns rather than behaving unexpectedly (or nothing happening, if unlucky).

 

=== User-Space ===

user-space and an [[OS Specific Toolchain]] that fully utilizes the system root.

 

[[Category:C]]