Meaty Skeleton: Difference between revisions

 

 

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

documentation explicitly states that libgcc requires the freestanding

environment to supply the <tt>memcmp</tt>, <tt>memcpy</tt>, <tt>memmove</tt>,

will satisfy this requirement by creating a special kernel C library (libk) that

contains the parts of the user-space libc that are ''freestanding'' (doesn't

a manner that will continue to serve you well for the foreseeable future. This

serves as both inspiration and as an example for those that wish to something

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

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

is just an example.

 

We will name this new example operating system <tt>myos</tt>. This is just a

decide to call your operating system.

 

 

== Building a Cross-Compiler ==

 

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

cross-compiler, though any <tt>ix86-elf</tt> target (but no less than i386) will

do fine for our purposes here.

 

 

 

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

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

 

 

== 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

types and macros that are useful. Your kernel standard library will supply a

number of useful functions (such as <tt>strlen</tt>) that doesn't require system

 

== Makefile Design ==

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 ==

 

in the directory <tt>libc/</tt>. The standard library is split into two

versions: freestanding and hosted. The difference is that the freestanding

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.

from <tt>sys/stat.h</tt> would be in <tt>libc/sys/stat/stat.c</tt>.

 

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

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 ==

 

 

 

 

 

 

 

 

 

==== 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 ====

 

 

#include <sys/cdefs.h>

#include <stddef.h>

 

 

int memcmp(const void*, const void*, size_t);

size_t strlen(const char*);

 

 

#endif

 

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

 

#ifndef _STDIO_H

#define _STDIO_H 1

#include <sys/cdefs.h>

 

 

int printf(const char* __restrict, ...);

int puts(const char*);

 

 

#endif

 

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

 

 

#define __myos_libc 1

 

#endif

 

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

 

#ifndef _STDLIB_H

#define _STDLIB_H 1

#include <sys/cdefs.h>

 

 

__attribute__((__noreturn__))

void abort(void);

 

 

#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>

 

=== Miscellaneous ===

 

 

==== build.sh ====

 

set -e

. ./headers.sh

 

for PROJECT in $PROJECTS; do

done

 

You should make this executable script executable by running:

chmod +x build.sh

 

==== clean.sh ====

 

set -e

. ./config.sh

 

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"

export CPPFLAGS=''

 

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

fi

 

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

 

#!/bin/sh

 

You should make this executable script executable by running:

chmod +x default-host.sh

 

==== headers.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 ====

 

set -e

. ./build.sh

EOF

grub-mkrescue -o myos.iso isodir

 

You should make this executable script executable by running:

chmod +x iso.sh

 

==== qemu.sh ====

 

set -e

. ./iso.sh

 

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

 

== Cross-Compiling the Operating System ==

the source tree by invoking:

 

./clean.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

 

== Moving Forward ==

 

=== Improving the Build System ===

 

It is probably worth improving the build system. For instance, it could be

useful if <tt>build.sh</tt> accepted command-line options, or perhaps if it used

 

=== User-Space ===

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

 

[[Category:C]]