Merge pull request #62 from daniel-k/pr/cmake

Add CMake build system
2025-03-09 00:00:03 +01:00 · 2017-04-09 20:57:12 +02:00 · 2017-04-09 20:57:12 +02:00 · 09cf218db4
commit 09cf218db4
parent 47f5261b94 8380e21463
82 changed files with 1504 additions and 6754 deletions
--- a/.bintray_descriptor.json
+++ b/.bintray_descriptor.json
@ -19,13 +19,17 @@
    },

    "files":
-    [{
-      "includePattern": "../(libhermit[^/]*deb$)", "uploadPattern": "$1",
+    [
+    {
+      "includePattern": "build/(libhermit[^/]*deb$)", "uploadPattern": "$1",
      "matrixParams": {
        "deb_distribution": "vivid",
        "deb_component": "main",
        "deb_architecture": "amd64",
-	"override": 1}
-    }],
+	  "override": 1}
+    },
+    {"includePattern": "build/(libhermit[^/]*rpm$)", "uploadPattern": "$1", "override": 1}
+    {"includePattern": "build/(libhermit[^/]*tar.bz2$)", "uploadPattern": "$1", "override": 1}
+    ],
    "publish": true
 }
--- a/.gitignore
+++ b/.gitignore
@ -1,58 +1,12 @@
-config.log
-config.status
-autom4te.cache
-/Makefile
 *.pcap
 *.config
 *.creator
-*.creator.user
+*.user
 *.files
 *.includes
 *.pyc
 *.callgrind
 *.xray
-*.o
-*.a
-*.dep
-*~
-*.elf
-*.elf32
-*.sym
-*.bin
+**/build/*
+.idea/*
 qemu-vlan0.pcap
-autom4te.cache
-documentation/html/
-include/hermit/config.inc
-include/hermit/config.h
-tools/proxy
-usr/tests/hello
-usr/tests/hello++
-usr/tests/hellof
-usr/tests/jacobi
-usr/tests/thr_hello
-usr/tests/pi
-usr/tests/RCCE_minimum
-usr/tests/signals
-usr/tests/server
-usr/benchmarks/RCCE_pingping
-usr/benchmarks/RCCE_pingpong
-usr/benchmarks/stream
-usr/benchmarks/hg
-usr/benchmarks/netio
-usr/benchmarks/basic
-usr/openmpbench/schedbench
-usr/openmpbench/syncbench
-usr/openmpbench/taskbench
-usr/tmp/
-usr/binutils/
-usr/gcc/
-usr/newlib/
-usr/pte/
-tools/Makefile
-usr/ircce/Makefile
-usr/xray/Makefile
-arch/x86/kernel/boot.h
-usr/binutils/
-usr/gcc/
-usr/newlib/
-usr/pte/
--- a/.travis.yml
+++ b/.travis.yml
@ -1,26 +1,22 @@
 sudo: required
 dist: trusty
 git:
-  submodules: false
+  submodules: true
 language: c
 compiler: gcc
 before_install:
  - echo "deb https://dl.bintray.com/rwth-os/hermitcore vivid main" | sudo tee -a /etc/apt/sources.list
  - travis_retry sudo apt-get -qq update
-  - travis_retry sudo apt-get install -y curl qemu-system-x86 nasm texinfo libmpfr-dev libmpc-dev libgmp-dev libisl-dev flex bison packaging-dev
-  #- sudo apt-get install -y --force-yes binutils-hermit gcc-hermit-bootstrap
+  - travis_retry sudo apt-get install -y curl wget qemu-system-x86 nasm texinfo libmpfr-dev libmpc-dev libgmp-dev libisl-dev flex bison packaging-dev rpm
  - travis_retry sudo apt-get install -y --force-yes binutils-hermit libhermit newlib-hermit pthread-embedded-hermit gcc-hermit
  - git submodule update --init lwip usr/libomp

 script:
-  - cd ..
-  - mv HermitCore libhermit-0.1
-  - tar -czf libhermit_0.1.orig.tar.gz libhermit-0.1 --exclude=.git
-  - cd libhermit-0.1
-  - debuild -e PATH -e CFLAGS_FOR_TARGET -e GOFLAGS_FOR_TARGET -e FCFLAGS_FOR_TARGET -e FFLAGS_FOR_TARGET -e CXXFLAGS_FOR_TARGET -us -uc -j2
-  - sudo dpkg -i ../libhermit*_amd64.deb
-  - make -j2 examples
-  - make test
+  - source cmake/local-cmake.sh
+  - mkdir build
+  - cd build
+  - cmake ..
+  - make -j1 package

 deploy:
  on: master
@ -30,16 +26,3 @@ deploy:
    secure: wo0yLY7xhGZYDqdB05UE+IOXXgYhAwj+zvtZh3ET2253hy35y74cDKMBNGfynH0aauPk8EFmN/LJoYaV/T9QF6pc1bilbqSg1/LJuL7hjAVVFaBSjwlE/Wbbb+EHNX5CR3qmC42SUvbrU+0WNvRu7WJBpZIoH9EtPv2Cj7uRV9+7Mtp/O3Ykl3E5LgkF5iA6Lo03TN+bZ1Vog5MbuJagDTpNa18vJ3jVYaed5gqOkghYYDpc5U9yxN3debS7/8MCl3u9V9uanMAyjc6wtbvJLotVkUwdXK8u9FohuWQ4pTEQ/QspLDDBuxaS3kLNWtzBMNQn6rcYIOWWKyD3uqvIhqjcErX7WChf3oGS1XPFfTHebNrHyV4KGvzkMAJUR/1qC5f4nZCsvgPv/35d702nky3Di2/WZsjD5zUR9g3+vPO8mnM3z8eA6ShVJcxezZ73Co3p0ZnBaF3J438bAKiT4nlrbIVpRzZzo/5nYTx//SefXSAmYCILr/y7xTYBqjfjMQHQZEMZSvJYRPbtP7eVCfWGEa2tG4rQndegUtwS+n1r8atcESL9eeUUM6sa1QzZYDYVseOc9GWcB7SIJzPOm8QTuTlkISHMGJ8FY+KHorP15VkVlr0EZ5c7KY0cBIbWoZGNQTg9+nSgChyf7ElNbAxPiCZsR0zafjMDhfcnzco=
  key:
    secure: JfsqEUO3Z60yGfuK5RSzwMoWZtaYflZtW7QE6R1DVMPEQ+CytzEdV2JaTpY14xz4yz1YpBBuQ0P3Q3e2rf/ORp8N8j7/5m3gfiDi8bRH3gX10r6vCQaUBilj0pz3amWUacxwBUEYR/f1029OnJ1qug30f4ARk7DWyuAePt0OboDXZ3j4JOi8xfXKTzofyKGugU4EuzhmKAbpHaBoX97g8z+gETC+wsBEYio8iD2h0ZOe/qZ0S+JGYkphIKcxpQazKdi3YrmWm0BUZsQRtkgoH7KUZm8vqfOUyVOrK+UGOTz4vXqCWHZ+wG1QRrGPUv8ehLrB26y2o02mmaDWQhM+I3RtllL06JDvDw40xjRImYtzg6xr7Mvl0OTQHprXrkN8gw2IbIivV8v31O46Ov+KIaN3CCx1IncnllBWjEXAIs4zPtvNj2Ad338JTkI/opHmPG0DI0DKE36r8wPZYTs/pHVpc3xEzwKYDklJkICjMLUakUGKppS7eKzKGRMjWvbT0vM/U7hHUcz0lA+BUoXedNmJQ1wBT85Ud8uobuKS4C8QmlgIuF1PI2+6LJr5LsCGZRvg7Pl1SPc3ZQLPHX4ggoLAnZZJiV/0ZPCn7XCLiUS1qws37l0uZT1zJQMFLsw9MGuP58tpT7WDuYYAwma/pL+OKC/JKoDhuJwM1I7wB4s=
-env:
-  global:
-    - PATH=$PATH:/opt/hermit/bin/
-    - HERMIT_ISLE=qemu
-    - HERMIT_CPUS=1
-    - HERMIT_MEM="512M"
-    - HERMIT_KVM="0"
-    - HERMIT_VERBOSE="1"
-    - CFLAGS_FOR_TARGET="-m64 -O3 -ftree-vectorize"
-    - GOFLAGS_FOR_TARGET"=-m64 -O3 -ftree-vectorize"
-    - FCFLAGS_FOR_TARGET"=-m64 -O3 -ftree-vectorize"
-    - FFLAGS_FOR_TARGET="-m64 -O3 -ftree-vectorize"
-    - CXXFLAGS_FOR_TARGET="-m64 -O3 -ftree-vectorize"
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -0,0 +1,196 @@
+cmake_minimum_required(VERSION 3.7)
+
+include(ExternalProject)
+include(cmake/HermitCore.cmake)
+
+project (HermitCore)
+
+### Kernel
+
+# generate config files
+add_subdirectory(include/hermit)
+
+add_kernel_module_sources("kernel"		"kernel/*.c")
+add_kernel_module_sources("libkern"		"libkern/*.c")
+add_kernel_module_sources("mm"			"mm/*.c")
+add_kernel_module_sources("drivers"		"drivers/net/*.c")
+
+set(LWIP_SRC lwip/src)
+add_kernel_module_sources("lwip"	"${LWIP_SRC}/api/*.c")
+add_kernel_module_sources("lwip"	"${LWIP_SRC}/arch/*.c")
+add_kernel_module_sources("lwip"	"${LWIP_SRC}/core/*.c")
+add_kernel_module_sources("lwip"	"${LWIP_SRC}/core/ipv4/*.c")
+add_kernel_module_sources("lwip"	"${LWIP_SRC}/core/ipv6/*.c")
+add_kernel_module_sources("lwip"	"${LWIP_SRC}/netif/*.c")
+
+get_kernel_modules(KERNEL_MODULES)
+foreach(MODULE ${KERNEL_MODULES})
+	get_kernel_module_sources(SOURCES ${MODULE})
+
+	# maintain list of all objects that will end up in libhermit.a
+	list(APPEND KERNEL_OBJECTS $<TARGET_OBJECTS:${MODULE}>)
+
+	add_library(${MODULE} OBJECT ${SOURCES})
+
+	# this is kernel code
+	target_compile_definitions(${MODULE}
+		PRIVATE -D__KERNEL__)
+
+	target_compile_options(${MODULE}
+		PRIVATE ${HERMIT_KERNEL_FLAGS})
+
+	target_include_directories(${MODULE}
+		PUBLIC ${HERMIT_KERNEL_INCLUDES})
+
+	# suppress all LwIP compiler warnings. Not our code, so we cannot fix
+	if("${MODULE}" STREQUAL "lwip")
+		target_compile_options(${MODULE}
+			PRIVATE -w)
+	endif()
+
+endforeach()
+
+# add arch/x86 and its objects
+# TODO: make this conditional when new architectures are implemented
+add_subdirectory(arch/x86)
+list(APPEND KERNEL_OBJECTS
+	$<TARGET_OBJECTS:${X86_KERNEL_ASM_TARGET}>
+	$<TARGET_OBJECTS:${X86_KERNEL_C_TARGET}>)
+
+# finally build libhermit.a
+add_library(hermit STATIC ${KERNEL_OBJECTS})
+
+# after compiling ASM sources, we need to post-process them. Adding this
+# dependency makes sure that this is done before hermit is linked
+add_dependencies(hermit ${X86_KERNEL_TARGET})
+
+add_custom_command(
+	TARGET
+		hermit POST_BUILD
+	# rename sections in final library
+	COMMAND
+		${CMAKE_OBJCOPY} --rename-section .bss=.kbss
+						 --rename-section .text=.ktext
+						 --rename-section .data=.kdata
+						 $<TARGET_FILE:hermit>
+
+	# copy libhermit.a into local prefix directory so that all subsequent
+	# targets can link against the freshly built version (as opposed to
+	# linking against the one supplied by the toolchain)
+	COMMAND
+		${CMAKE_COMMAND} -E make_directory ${LOCAL_PREFIX_ARCH_LIB_DIR}
+	COMMAND
+		${CMAKE_COMMAND} -E copy_if_different
+							$<TARGET_FILE:hermit>
+							${LOCAL_PREFIX_ARCH_LIB_DIR}/
+
+	# and also copy headers into local prefix
+	COMMAND
+		${CMAKE_COMMAND} -E make_directory ${LOCAL_PREFIX_ARCH_INCLUDE_DIR}/hermit
+	COMMAND
+		${CMAKE_COMMAND} -E copy_if_different
+							${CMAKE_BINARY_DIR}/include/hermit/*.h
+							${LOCAL_PREFIX_ARCH_INCLUDE_DIR}/hermit/
+	COMMAND
+		${CMAKE_COMMAND} -E copy_if_different
+							${CMAKE_BINARY_DIR}/include/hermit/*.asm
+							${LOCAL_PREFIX_ARCH_INCLUDE_DIR}/hermit/)
+
+# deploy libhermit.a and headers for package creation
+install(TARGETS hermit
+	DESTINATION ${TARGET_ARCH}/lib)
+install(DIRECTORY include/hermit
+	DESTINATION ${TARGET_ARCH}/include/)
+
+
+### External projects
+#
+# Build projects externally and deploy into temporary common prefix, will later
+# be relocated for installation
+
+## HermitCore's own tools such as Qemu/KVM proxy
+build_external(tools ${HERMIT_ROOT}/tools "")
+build_external(arch_x86_loader ${HERMIT_ROOT}/arch/x86/loader "")
+
+## Intel's OpenMP runtime for x86 (libomp)
+build_external(libiomp ${HERMIT_ROOT}/usr/libomp ""
+		-DHERMIT=1
+		-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
+		-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}/${TARGET_ARCH})
+
+# libomp is part of HermitCore's runtime and should be available before any
+# application will link
+add_dependencies(hermit libiomp)
+
+## iRCCE
+build_external(ircce ${HERMIT_ROOT}/usr/ircce "")
+add_dependencies(hermit ircce)
+
+## XRay profiler
+build_external(xray ${HERMIT_ROOT}/usr/xray "")
+add_dependencies(hermit xray)
+
+## Tests and benchmarks
+build_external(tests ${HERMIT_ROOT}/usr/tests hermit)
+build_external(benchmarks ${HERMIT_ROOT}/usr/benchmarks hermit)
+build_external(openmpbench ${HERMIT_ROOT}/usr/openmpbench hermit)
+
+## relocate the local prefix to our install destination
+install(DIRECTORY ${LOCAL_PREFIX_DIR}/
+	DESTINATION ${CMAKE_INSTALL_PREFIX}/
+	USE_SOURCE_PERMISSIONS)
+
+
+### QEmu
+# Start HermitCore as multi-kernel in a QEmu VM
+
+add_custom_target(qemu
+	COMMAND
+		qemu-system-x86_64
+			-machine accel=kvm -cpu host
+			-smp 10 -m 8G -numa node,nodeid=0,cpus=0-4 -numa node,nodeid=1,cpus=5-9
+			-kernel ${HERMIT_ROOT}/config/bzImage
+			-append "root=/dev/ram0 rootfstype=ramfs init=init console=ttyS0"
+			-net nic,model=rtl8139 -net user -net dump
+			-nographic -monitor telnet:127.0.0.1:1235,server,nowait
+			-fsdev local,security_model=none,id=fsdev0,path=${LOCAL_PREFIX_DIR}
+			-device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=hermit
+			-s
+	USES_TERMINAL VERBATIM)
+
+# create a QEmu target that depends on everything
+get_property(_TARGETS
+	DIRECTORY .
+	PROPERTY BUILDSYSTEM_TARGETS)
+
+add_custom_target(qemu-dep
+	DEPENDS
+		${_TARGETS} qemu)
+
+
+### Packaging
+
+set(CPACK_PACKAGE_NAME libhermit)
+set(CPACK_SYSTEM_NAME all)
+
+set(CPACK_PACKAGE_VERSION_MAJOR 0)
+set(CPACK_PACKAGE_VERSION_MINOR 1)
+set(CPACK_PACKAGE_VERSION_PATCH 0)
+
+set(CPACK_PACKAGE_CONTACT "Daniel Krebs <github@daniel-krebs.net>")
+
+# build .deb, .rpm and .tar.bz2 packages
+set(CPACK_GENERATOR DEB;RPM;TBZ2)
+
+# needed in order for tests and bechmark to use correct install prefix
+set(CPACK_SET_DESTDIR on)
+
+## Debian specific
+# not dependent on Debian system architecture
+set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE all)
+
+## RPM specific
+# libhermit is currently not relocatable
+set(CPACK_PACKAGE_RELOCATABLE FALSE)
+
+include(CPack)
--- a/Makefile.in
+++ b/Makefile.in
@ -1,278 +0,0 @@
-TERM = xterm
-TOPDIR := $(shell pwd)
-ARCH = x86
-NAME = libhermit.a
-DRIVERDIRS = drivers/net
-LWIPDIRS = lwip/src/arch lwip/src/api lwip/src/core lwip/src/core/ipv4 lwip/src/core/ipv6 lwip/src/netif
-KERNDIRS = kernel mm libkern arch/$(ARCH)/kernel arch/$(ARCH)/libkern arch/$(ARCH)/mm $(LWIPDIRS) $(DRIVERDIRS)
-SUBDIRS = $(KERNDIRS)
-TODAY := $(shell date +'%Y%m%d')
-QEMU = @QEMU@ -machine accel=kvm -cpu host
-CROSSDIR = @prefix@/bin
-JOBS = $(shell nproc)
-ARCH_OPT = @ARCH_OPT@
-TOOLCHAIN = @TOOLCHAIN@
-ifeq ($(TOOLCHAIN),0)
-BUILD_BOOTSTRAP =
-BUILD_TOOLCHAIN =
-INSTALL_LIBHERMIT =
-else
-BUILD_BOOTSTRAP = bootstrap
-BUILD_TOOLCHAIN = toolchain
-INSTALL_LIBHERMIT = install_libhermit
-endif
-
-prefix = @prefix@
-INSTALL = @INSTALL@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_DATA = @INSTALL_DATA@
-
-# add path to the cross toolchain
-PATH:=$(PATH):$(CROSSDIR)
-
-# Set your own cross compiler tool chain prefix here
-CROSSCOMPREFIX = x86_64-hermit
-STACKPROT = -fno-stack-protector
-
-FC_FOR_TARGET = $(CROSSCOMPREFIX)-gfortran
-CC_FOR_TARGET = $(CROSSCOMPREFIX)-gcc
-GO_FOR_TARGET = $(CROSSCOMPREFIX)-gccgo
-CXX_FOR_TARGET = $(CROSSCOMPREFIX)-g++
-GCC_FOR_TARGET = $(CROSSCOMPREFIX)-gcc
-CPP_FOR_TARGET = $(CROSSCOMPREFIX)-cpp
-AR_FOR_TARGET = $(CROSSCOMPREFIX)-ar
-AS_FOR_TARGET = $(CROSSCOMPREFIX)-as
-LD_FOR_TARGET = $(CROSSCOMPREFIX)-ld
-NM_FOR_TARGET = $(CROSSCOMPREFIX)-nm
-OBJDUMP_FOR_TARGET = $(CROSSCOMPREFIX)-objdump
-OBJCOPY_FOR_TARGET = $(CROSSCOMPREFIX)-objcopy
-RANLIB_FOR_TARGET = $(CROSSCOMPREFIX)-ranlib
-STRIP_FOR_TARGET = $(CROSSCOMPREFIX)-strip
-READELF_FOR_TARGET = $(CROSSCOMPREFIX)-readelf
-ELFEDIT_FOR_TARGET = $(CROSSCOMPREFIX)-elfedit
-
-MAKE = make
-NASM = nasm
-NASMFLAGS = -felf64 -g -i$(TOPDIR)/include/hermit/
-
-INCLUDE = -I$(TOPDIR)/include -I$(TOPDIR)/arch/$(ARCH)/include  -I$(TOPDIR)/lwip/src/include -I$(TOPDIR)/drivers
-CFLAGS = -g -m64 -Wall -O2 -mno-red-zone -fno-var-tracking-assignments -fstrength-reduce -fomit-frame-pointer -finline-functions -ffreestanding -nostdinc -fno-stack-protector -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -mno-avx -fno-delete-null-pointer-checks -falign-jumps=1 -falign-loops=1 -mno-80387 -mno-fp-ret-in-387 -mskip-rax-setup -fno-common -Wframe-larger-than=1024 -fno-strict-aliasing -fno-asynchronous-unwind-tables -fno-strict-overflow -maccumulate-outgoing-args $(INCLUDE)
-AR = ar
-ARFLAGS = rsv
-RM = rm -rf
-OUTPUT_FORMAT = -O elf64-x86-64-hermit
-
-# Additional flags for profiling using Xray
-PROFILING_LDFLAGS =
-PROFILING_CFLAGS =
-
-ifdef PROFILING
-    PROFILING_LDFLAGS = -lxray
-
-    PROFILING_CFLAGS  = -falign-functions=32 -finstrument-functions
-    PROFILING_CFLAGS += -finstrument-functions-exclude-function-list=_mm_pause,_mm_setcsr,_mm_getcsr # we need this for libiomp to work
-    PROFILING_CFLAGS += -DXRAY -DXRAY_DISABLE_BROWSER_INTEGRATION -DXRAY_NO_DEMANGLE
-    PROFILING_CFLAGS += -DXRAY_ANNOTATE
-endif
-
-CFLAGS_FOR_NEWLIB = -m64 -O3 -ftree-vectorize $(ARCH_OPT) #$(STACKPROT)
-GOFLAGS_FOR_NEWLIB = -m64 -O3 -ftree-vectorize $(ARCH_OPT)
-FCFLAGS_FOR_NEWLIB = -m64 -O3 -ftree-vectorize $(ARCH_OPT)
-FFLAGS_FOR_NEWLIB = -m64 -O3 -ftree-vectorize $(ARCH_OPT)
-CXXFLAGS_FOR_NEWLIB = -m64 -O3 -ftree-vectorize $(ARCH_OPT)
-LDFLAGS_FOR_NEWLIB =
-NASMFLAGS_FOR_NEWLIB = -felf64
-CFLAGS_FOR_TOOLS = -O2 -Wall -std=gnu99
-LDFLAGS_FOR_TOOLS =
-
-# Prettify output
-V = 0
-ifeq ($V,0)
-	Q = @
-	P = > /dev/null
-endif
-
-
-default: all
-
-all: arch/x86/kernel/boot.h $(BUILD_BOOTSTRAP) $(NAME) $(BUILD_TOOLCHAIN) tools loader
-
-toolchain: $(INSTALL_LIBHERMIT)
-	$Q$(MAKE) ARCH=$(ARCH) PREFIX=$(prefix) \
-		LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_NEWLIB)" \
-		GOFLAGS_FOR_TARGET="$(GOFLAGS_FOR_NEWLIB)" \
-		CFLAGS_FOR_TARGET="$(CFLAGS_FOR_NEWLIB)" \
-		FFLAGS_FOR_TARGET="$(FFLAGS_FOR_NEWLIB)" \
-		FCFLAGS_FOR_TARGET="$(FCFLAGS_FOR_NEWLIB)" \
-		FCFLAGS="$(FCFLAGS_FOR_NEWLIB)" \
-		CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_NEWLIB)" \
-		NASMFLAGS="$(NASMFLAGS_FOR_NEWLIB)" \
-		CC_FOR_TARGET=$(CC_FOR_TARGET) \
-		GO_FOR_TARGET=$(GO_FOR_TARGET) \
-		FC_FOR_TARGET=$(FC_FOR_TARGET) \
-		CXX_FOR_TARGET=$(CXX_FOR_TARGET) \
-		GCC_FOR_TARGET=$(GCC_FOR_TARGET) \
-		AR_FOR_TARGET=$(AR_FOR_TARGET) \
-		AS_FOR_TARGET=$(AS_FOR_TARGET) \
-		LD_FOR_TARGET=$(LD_FOR_TARGET) \
-		NM_FOR_TARGET=$(NM_FOR_TARGET) \
-		OBJDUMP_FOR_TARGET=$(OBJDUMP_FOR_TARGET) \
-		OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) \
-		RANLIB_FOR_TARGET=$(RANLIB_FOR_TARGET) \
-		STRIP_FOR_TARGET=$(STRIP_FOR_TARGET) \
-		ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) \
-		READELF_FOR_TARGET=$(READELF_FOR_TARGET) \
-		PROFILING_CFLAGS="$(PROFILING_CFLAGS)" \
-		PROFILING_LDFLAGS="$(PROFILING_LDFLAGS)" -C usr toolchain
-
-libs:
-	$Q$(MAKE) ARCH=$(ARCH) PREFIX=$(prefix) \
-		LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_NEWLIB)" \
-		GOFLAGS_FOR_TARGET="$(GOFLAGS_FOR_NEWLIB)" \
-		CFLAGS_FOR_TARGET="$(CFLAGS_FOR_NEWLIB)" \
-		FFLAGS_FOR_TARGET="$(FFLAGS_FOR_NEWLIB)" \
-		FCFLAGS_FOR_TARGET="$(FCFLAGS_FOR_NEWLIB)" \
-		FCFLAGS="$(FCFLAGS_FOR_NEWLIB)" \
-		CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_NEWLIB)" \
-		NASMFLAGS="$(NASMFLAGS_FOR_NEWLIB)" \
-		CC_FOR_TARGET=$(CC_FOR_TARGET) \
-		GO_FOR_TARGET=$(GO_FOR_TARGET) \
-		FC_FOR_TARGET=$(FC_FOR_TARGET) \
-		CXX_FOR_TARGET=$(CXX_FOR_TARGET) \
-		GCC_FOR_TARGET=$(GCC_FOR_TARGET) \
-		AR_FOR_TARGET=$(AR_FOR_TARGET) \
-		AS_FOR_TARGET=$(AS_FOR_TARGET) \
-		LD_FOR_TARGET=$(LD_FOR_TARGET) \
-		NM_FOR_TARGET=$(NM_FOR_TARGET) \
-		OBJDUMP_FOR_TARGET=$(OBJDUMP_FOR_TARGET) \
-		OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) \
-		RANLIB_FOR_TARGET=$(RANLIB_FOR_TARGET) \
-		STRIP_FOR_TARGET=$(STRIP_FOR_TARGET) \
-		ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) \
-		READELF_FOR_TARGET=$(READELF_FOR_TARGET) \
-		PROFILING_CFLAGS="$(PROFILING_CFLAGS)" \
-		PROFILING_LDFLAGS="$(PROFILING_LDFLAGS)" -C usr libs
-
-bootstrap:
-	$Q$(MAKE) ARCH=$(ARCH) PREFIX=$(prefix) CFLAGS="" LDFLAGS="" -C usr bootstrap
-
-tools:
-	$Q$(MAKE) ARCH=$(ARCH) PREFIX=$(prefix) CFLAGS="$(CFLAGS_FOR_TOOLS)" LDFLAGS="$(LDFLAGS_FOR_TOOLS)" -C tools
-
-loader:
-	$Q$(MAKE) -C arch/$(ARCH)/loader
-
-$(NAME):
-	@echo [AR] $(NAME)
-	$Q$(AR_FOR_TARGET) $(ARFLAGS) -o $(NAME) $^
-	$Q$(OBJCOPY_FOR_TARGET) --rename-section .bss=.kbss --rename-section .text=.ktext --rename-section .data=.kdata $(NAME)
-
-examples:
-	$Q$(MAKE) ARCH=$(ARCH) PREFIX=$(prefix) \
-		LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_NEWLIB)" \
-		GOFLAGS_FOR_TARGET="$(GOFLAGS_FOR_NEWLIB)" \
-		CFLAGS_FOR_TARGET="$(CFLAGS_FOR_NEWLIB)" \
-		FFLAGS_FOR_TARGET="$(FFLAGS_FOR_NEWLIB)" \
-		FCFLAGS_FOR_TARGET="$(FCFLAGS_FOR_NEWLIB)" \
-		FCFLAGS="$(FCFLAGS_FOR_NEWLIB)" \
-		CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_NEWLIB)" \
-		NASMFLAGS="$(NASMFLAGS_FOR_NEWLIB)" \
-		CC_FOR_TARGET=$(CC_FOR_TARGET) \
-		GO_FOR_TARGET=$(GO_FOR_TARGET) \
-		FC_FOR_TARGET=$(FC_FOR_TARGET) \
-		CXX_FOR_TARGET=$(CXX_FOR_TARGET) \
-		GCC_FOR_TARGET=$(GCC_FOR_TARGET) \
-		AR_FOR_TARGET=$(AR_FOR_TARGET) \
-		AS_FOR_TARGET=$(AS_FOR_TARGET) \
-		LD_FOR_TARGET=$(LD_FOR_TARGET) \
-		NM_FOR_TARGET=$(NM_FOR_TARGET) \
-		OBJDUMP_FOR_TARGET=$(OBJDUMP_FOR_TARGET) \
-		OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) \
-		RANLIB_FOR_TARGET=$(RANLIB_FOR_TARGET) \
-		STRIP_FOR_TARGET=$(STRIP_FOR_TARGET) \
-		ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) \
-		READELF_FOR_TARGET=$(READELF_FOR_TARGET) \
-		PROFILING_CFLAGS="$(PROFILING_CFLAGS)" \
-		PROFILING_LDFLAGS="$(PROFILING_LDFLAGS)" -C usr examples
-
-test:
-	. ./test.sh
-
-qemu:
-	$(QEMU) -smp 10 -m 8G -numa node,nodeid=0,cpus=0-4 -numa node,nodeid=1,cpus=5-9 \
-                -kernel config/bzImage \
-                -append "root=/dev/ram0 rootfstype=ramfs init=init console=ttyS0" \
-                -net nic,model=rtl8139 -net user -net dump \
-                -nographic -monitor telnet:127.0.0.1:1235,server,nowait \
-                -fsdev local,security_model=none,id=fsdev0,path=$(shell realpath .) \
-                -device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=hermit \
-                -s
-
-install_libhermit:
-	$Q$(INSTALL_PROGRAM) -d $(prefix)/$(CROSSCOMPREFIX)/lib/
-	$Q$(INSTALL_DATA) $(NAME) $(prefix)/$(CROSSCOMPREFIX)/lib/
-	$Q$(INSTALL_PROGRAM) -d $(prefix)/$(CROSSCOMPREFIX)/include/hermit/
-	$Q$(INSTALL_DATA) include/hermit/* $(prefix)/$(CROSSCOMPREFIX)/include/hermit/
-
-install: install_libhermit
-	$Q$(MAKE) PREFIX=$(prefix) -C usr install
-	$Q$(MAKE) PREFIX=$(prefix) -C tools install
-
-clean:
-	$Q$(RM) $(NAME) $(NAME).sym $(NAME).bin *~
-	$Q$(MAKE) -C tools clean
-	$Q$(MAKE) -C usr clean
-	$Q$(MAKE) -C arch/$(ARCH)/loader clean
-	@echo Cleaned.
-
-veryclean: clean
-	$Q$(RM) qemu-vlan0.pcap include/hermit/config.inc
-	$Q$(MAKE) -C tools veryclean
-	$Q$(MAKE) -C usr veryclean
-	$Q$(MAKE) -C arch/$(ARCH)/loader veryclean
-	@echo Very cleaned
-
-doc:
-	@echo Create documentation...
-	@doxygen
-
-%.o : %.c
-	@echo [CC] $@
-	$Q$(CC_FOR_TARGET) -c -D__KERNEL__ $(CFLAGS) -o $@ $<
-	@echo [DEP] $*.dep
-	$Q$(CC_FOR_TARGET) -MF $*.dep -MT $*.o -MM $(CFLAGS) $<
-
-arch/x86/kernel/boot.bin: arch/x86/kernel/boot.asm
-	@echo "  NASM    $@"
-	$Q$(NASM) -fbin -o $@ $<
-
-arch/x86/kernel/boot.h: arch/x86/kernel/boot.bin
-	@echo "  HEXDUMP $@"
-	$Qecho "static const uint8_t boot_code[] = { \
-		$(shell hexdump -v -e '"0x" 1/1 "%02X" ", "' $<) \
-	};" > $@
-
-include/hermit/config.inc: include/hermit/config.h
-	@echo "; This file is generated automatically from the config.h file." > include/hermit/config.inc
-	@echo "; Before editing this, you should consider editing config.h." >> include/hermit/config.inc
-	@awk '/^#define MAX_CORES/{ print "%define MAX_CORES", $$3 }' include/hermit/config.h >> include/hermit/config.inc
-	@awk '/^#define KERNEL_STACK_SIZE/{ print "%define KERNEL_STACK_SIZE", $$3 }' include/hermit/config.h >> include/hermit/config.inc
-	@awk '/^#define VIDEO_MEM_ADDR/{ print "%define VIDEO_MEM_ADDR", $$3 }' include/hermit/config.h >> include/hermit/config.inc
-	@awk '/^#define CONFIG_VGA/{ print "%define CONFIG_VGA", $$3 }' include/hermit/config.h >> include/hermit/config.inc
-	@awk '/^#define DYNAMIC_TICKS/{ print "%define DYNAMIC_TICKS", $$3 }' include/hermit/config.h >> include/hermit/config.inc
-	@awk '/^#define SAVE_FPU/{ print "%define SAVE_FPU", $$3 }' include/hermit/config.h >> include/hermit/config.inc
-
-%.o : %.asm include/hermit/config.inc
-	@echo [ASM] $@
-	$Q$(NASM) $(NASMFLAGS) -o $@ $<
-	$Q$(ELFEDIT_FOR_TARGET) --output-osabi HermitCore $@
-	#$Q$(OBJCOPY_FOR_TARGET) $(OUTPUT_FORMAT) $@
-
-%.o : %.S
-	@echo [GCC-ASM] $@
-	$Q$(CC_FOR_TARGET) $(CFLAGS) -c -o $@ $<
-
-.PHONY: default all clean qemu gdb usr test toolchain tools examples libs
-
-include $(addsuffix /Makefile,$(SUBDIRS))
--- a/Makefile.inc
+++ b/Makefile.inc
@ -1,20 +0,0 @@
-C_source-$(MODULE) := $(addprefix $(subst _,/,$(MODULE))/,$(filter %.c,$(C_source)))
-ASM_source-$(MODULE) := $(addprefix $(subst _,/,$(MODULE))/,$(filter %.asm,$(ASM_source)))
-C_source :=
-ASM_source :=
-
-OBJS-$(MODULE) := $(C_source-$(MODULE):.c=.o)
-OBJS-$(MODULE) += $(ASM_source-$(MODULE):.asm=.o)
-
-$(MODULE): $(OBJS-$(MODULE))
-
-$(NAME): $(OBJS-$(MODULE))
-
-clean: clean-$(MODULE)
-clean-$(MODULE): clean-% :
-	@echo Cleaning $(subst _,/,$*)
-	$Q$(RM) $(OBJS-$*) $(C_source-$*:.c=.dep)
-
-.PHONY: clean-$(MODULE) $(MODULE)
-
-include $(C_source-$(MODULE):.c=.dep)
--- a/README.md
+++ b/README.md
@ -1,91 +1,268 @@
 # HermitCore - A lightweight unikernel for a scalable and predictable runtime behavior

-The project [HermitCore](http://www.hermitcore.org) is new [unikernel](http://unikernel.org) targeting at a scalable and predictable runtime for high-performance and cloud computing.
-HermitCore extends the multi-kernel approach (like [McKernel](http://www-sys-aics.riken.jp/ResearchTopics/os/mckernel.html)) with unikernel features for a better programmability and scalability for hierarchical systems.
-On the startup of HermitCore applications, cores are isolated from the Linux system enabling the bare-metal of the applications on these cores.
-This approach achieves lower OS jitter and a better scalability compared to full-weight kernels.
-Inter-kernel communication between HermitCore applications and the Linux system is realized by means of an IP interface.
+The project [HermitCore]( http://www.hermitcore.org ) is a new
+[unikernel](http://unikernel.org) targeting a scalable and predictable runtime
+for high-performance and cloud computing. HermitCore extends the multi-kernel
+approach (like
+[McKernel](http://www-sys-aics.riken.jp/ResearchTopics/os/mckernel.html)) with
+unikernel features for a better programmability and scalability for hierarchical
+systems.
+
+
+On the startup of HermitCore applications, cores are isolated from the Linux
+system enabling bare-metal execution of on these cores. This approach achieves
+lower OS jitter and a better scalability compared to full-weight kernels.
+Inter-kernel communication between HermitCore applications and the Linux system
+is realized by means of an IP interface.
+
+In addition to the multi-kernel approach described above, HermitCore can be used
+as a classical standalone unikernel as well. In this case, HermitCore runs a
+single-kernel exclusively on the hardware or within a virtual machine. This
+reduces the resource demand and loweres the boot time which is critical for
+cloud computing applications. It is the result of a research project at RWTH
+Aachen University and is currently an experimental approach, i.e., not
+production ready. Please use it with caution.

-In addition to the multi-kernel approach described above, HermitCore can be used as classical standalone unikernel as well.
-In this case HermitCore runs a single-kernel exclusively on the hardware or within a virtual machine.
-This reduces the resource demand and improves the boot time which is critical for cloud computing applications.
-It is the result of a research project at RWTH Aachen University and is currently an experimental approach, i.e., not production ready.
-Please use it with caution.

 ## Requirements

-The build process works currently only on **x86-based Linux** systems. The following software packets are required to build HermitCore on a Linux system:
+The build process works currently only on **x86-based Linux** systems. To build
+the HermitCore kernel and applications you need:

-* Netwide Assembler (NASM)
-* GNU Make, GNU Binutils
-* Tools and libraries to build *linux*, *binutils* and *gcc* (e.g. flex, bison, MPFR library, GMP library, MPC library, ISL library)
-* texinfo
-* Qemu
+ * CMake
+ * Netwide Assember (NASM)
+ * recent host compiler such as GCC
+ * HermitCore cross-toolchain, i.e. Binutils, GCC, newlib, pthreads-embedded

-On Debian-based systems the packets can be installed by executing:
-```
-  sudo apt-get install qemu-system-x86  nasm texinfo libmpfr-dev libmpc-dev libgmp-dev libisl-dev flex bison
+
+### HermitCore cross-toolchain
+
+We provide prebuilt packages (currently Debian-based only) of the HermitCore
+toolchain, which can be installed as follows:
+
+```bash
+$ echo "deb [trusted=yes] https://dl.bintray.com/rwth-os/hermitcore vivid main" | sudo tee -a /etc/apt/sources.list
+$ sudo apt-get -qq update
+$ sudo apt-get install binutils-hermit newlib-hermit pthread-embedded-hermit gcc-hermit libhermit
 ```

-## Installing HermitCore with by using debian packets
+If you want to build the toolchain yourself, have a look at the following
+repositories, especially at `debian/rules` in each repository:

-We provide binary packets for debian-based systems containing the complete HermitCore toolchain including a cross-compiler.
-To install the packets you have to execute the following commands:
+ * [GCC](https://github.com/RWTH-OS/gcc)
+ * [Binutils](https://github.com/RWTH-OS/binutils)
+ * [Newlib](https://github.com/RWTH-OS/newlib)
+ * [Pthread-embedded](https://github.com/RWTH-OS/pthread-embedded)
+
+Depending on how you want to use HermitCore, you might need additional packages
+such as:
+
+ * QEMU (`apt-get install qemu-system-x86`)
+
+
+## CMake requirements
+
+We require a fairly recent version of CMake (`3.7`) which is not yet present in
+most Linux distributions. We therefore provide a helper script that fetches the
+required CMake binaries from the upstream project and stores them locally, so
+you only need to download it once.
+
+```bash
+$ . cmake/local-cmake.sh
+-- Downloading CMake
+--2017-03-28 16:13:37--  https://cmake.org/files/v3.7/cmake-3.7.2-Linux-x86_64.tar.gz
+Loaded CA certificate '/etc/ssl/certs/ca-certificates.crt'
+Resolving cmake.org... 66.194.253.19
+Connecting to cmake.org|66.194.253.19|:443... connected.
+HTTP request sent, awaiting response... 200 OK
+Length: 30681434 (29M) [application/x-gzip]
+Saving to: ‘cmake-3.7.2-Linux-x86_64.tar.gz’
+
+cmake-3.7.2-Linux-x86_64.tar.gz         100%[===================>]  29,26M  3,74MB/s    in 12s     
+
+2017-03-28 16:13:50 (2,48 MB/s) - ‘cmake-3.7.2-Linux-x86_64.tar.gz’ saved [30681434/30681434]
+
+-- Unpacking CMake
+-- Local CMake v3.7.2 installed to cmake/cmake-3.7.2-Linux-x86_64
+-- Next time you source this script, no download will be neccessary
 ```
-echo "deb [trusted=yes] https://dl.bintray.com/rwth-os/hermitcore vivid main" | sudo tee -a /etc/apt/sources.list
-sudo apt-get -qq update
-sudo apt-get install binutils-hermit newlib-hermit pthread-embedded-hermit gcc-hermit libhermit
+
+So before you build HermitCore you have to source the `local-cmake.sh` script
+everytime you open a new terminal.
+
+	
+## Building HermitCore
+
+```bash
+$ mkdir build
+$ cd build
+$ cmake ..
+$ make
 ```
-This toolchain is able to build applications for [classical unikernel](#building-and-testing-hermitcore-as-classical-standalone-unikernel) environments within virtual machines or bare-metal in a multi-kernel environment.
-For the latter, you have to install the modified Linux kernel.
-An introduction to this execution mode is provided in section [Building and testing HermitCore as multi-kernel on a real machine](#building-and-testing-hermitcore-as-multi-kernel-on a-real-machine).

-## Building and testing HermitCore as multi-kernel within a virtual machine
+If your toolchain is not located in `/opt/hermit/bin` then you have to supply
+its location to the `cmake` command above like so:

-1. Please make sure that you cloned this repository and all its submodules.
-2. To configure the system, run the *configure* script in the directory, which contains this *README*.
-   With the flag `--with-toolchain`, the HermitCore's complete cross toolchain (cross compiler, binutils, etc.) will be downloaded and built.
-   **NOTE**: This requires write access to the installation directory, which is specified by the flag `--prefix`.
-   At the end of this *README* in section *Tips* you find hints to enable optimization for the target.
-3. The command `make all` build the the HermitCore kernel and depending on the configuration flags the cross toolchain.
-4. Install the kernel with `make install`.
-5. Build all example applications with `make examples`.
-6. To start a virtual machine and to boot a small Linux version use the command `make qemu`.
-   Per default, the virtual machine has 10 cores, 2 NUMA nodes, and 8 GiB RAM.
-   To increase or to decrease the machine size, the label `qemu` in the Makefile has to be modified accordingly.
-7. Inside the VM runs a small Linux system, which already includes the patches for HermitCore.
-   Per NUMA node (= HermitCore isle) there is a directory called `isleX` under `/sys/hermit` , where `X` represents the NUMA node ID.
-   The demo applications are located in the directories `/hermit/usr/{tests,benchmarks}`.
-   A HermitCore loader is already registered.
-   By starting a HermitCore application, a proxy will be executed on the Linux system, while the HermitCore binary will be started on isle 0 with cpu 1.
-   To change the default behavior, the environment variable `HERMIT_ISLE` is used to specify the (memory) location of the isle, while the environment variable `HERMIT_CPUS` is used to specify the cores.
-   For instance, `HERMIT_ISLE=1 HERMIT_CPUS="3-5" /hermit/usr/tests/hello` starts a HelloWorld demo on the HermitCore isle 1, which uses the cores 3 to 5.
-   The output messages are forwarded to the Linux proxy and printed on the Linux system.
-8. HermitCore's kernel messages of `isleX` are available via `cat /sys/hermit/isleX/log`.
-9. There is a virtual IP device for the communication between the HermitCore isles and the Linux system (see output of `ifconfig`).
-   Per default, the Linux system has the IP address `192.168.28.1`.
-   The HermitCore isles starts with the IP address `192.168.28.2` for isle 0 and is increased by one for every isle.
-10. More HermitCore applications are available at `/hermit/usr/{tests,benchmarks}` which is a shared directory between the host and QEmu.
+```bash
+$ cmake -DTOOLCHAIN_BIN_DIR=/home/user/hermit/bin
+```

-## Building and testing HermitCore as multi-kernel on a real machine
+assuming that binaries like `x86_64-hermit-gcc` and friends are located in that
+directory.
+
+
+## Testing
+
+### As multi-kernel within a virtual machine
+
+```bash
+$ cd build
+$ make qemu
+$ # or 'make qemu-dep' to build HermitCore dependencies before
+```
+
+Within the QEMU session you can start HermitCore application just the same as
+traditional Linux programs:
+
+```bash
+(QEMU) $ /hermit/extra/tests/hello
+smpboot: CPU 1 is now offline
+Hello World!!!
+argv[0] = /hermit/extra/tests/hello
+Receive signal with number 30
+Hostname: hermit.localdomain
+x86: Booting SMP configuration:
+smpboot: Booting Node 0 Processor 1 APIC 0x1
+```
+
+Per default, the virtual machine has 10 cores, 2 NUMA nodes, and 8 GiB RAM.
+Inside the VM runs a small Linux system, which already includes the patches for
+HermitCore. Per NUMA node (= HermitCore isle) there is a directory called
+`isleX` under `/sys/hermit` , where `X` represents the NUMA node ID.
+
+The demo applications are located in the directories
+`/hermit/extra/{tests,benchmarks}`. A HermitCore loader is already registered.
+By starting a HermitCore application, a proxy will be executed on the Linux
+system, while the HermitCore binary will be started on isle 0 with cpu 1. To
+change the default behavior, the environment variable `HERMIT_ISLE` is used to
+specify the (memory) location of the isle, while the environment variable
+`HERMIT_CPUS` is used to specify the cores.
+
+For instance, `HERMIT_ISLE=1 HERMIT_CPUS="3-5" /hermit/extra/tests/hello` starts
+a HelloWorld demo on the HermitCore isle 1, which uses the cores 3 to 5. The
+output messages are forwarded to the Linux proxy and printed on the Linux
+system.
+
+HermitCore's kernel messages of `isleX` are available via `cat
+/sys/hermit/isleX/log`.
+
+There is a virtual IP device for the communication between the HermitCore isles
+and the Linux system (see output of `ifconfig`). Per default, the Linux system
+has the IP address `192.168.28.1`. The HermitCore isles starts with the IP
+address `192.168.28.2` for isle 0 and is increased by one for every isle.
+
+More HermitCore applications are available at `/hermit/usr/{tests,benchmarks}`
+which is a shared directory between the host and QEMU.
+
+
+### As classical standalone unikernel within a virtual machine
+
+HermitCore applications can be directly started as standalone kernel within a
+virtual machine. In this case,
+[iRCCE](http://www.lfbs.rwth-aachen.de/publications/files/iRCCE.pdf ) is not
+supported.
+
+```bash
+$ cd build
+$ make install DESTDIR=~/hermit-build
+$ cd ~/hermit-build/opt/hermit
+$ # using QEMU
+$ HERMIT_ISLE=qemu bin/proxy extra/tests/hello
+$ # using uHyve
+$ HERMIT_ISLE=uhyve bin/proxy extra/tests/hello
+```
+
+With `HERMIT_ISLE=qemu`, the application will be started within a QEMU VM.
+Please note that the loader requires QEMU and uses per default *KVM*.
+Furthermore, it expects that the executable is called `qemu-system-x86_64`.
+
+With `HERMIT_ISLE=hyve`, the application will be started within a thin
+hypervisor powered by Linux's KVM API and therefore requires *KVM* support.
+uHyve has a considerably smaller startup time than QEMU, but lacks some features
+such as GDB debugging.
+
+In this context, the environment variable `HERMIT_CPUS` specifies the number of
+cpus (and no longer a range of core ids). Furthermore, the variable `HERMIT_MEM`
+defines the memory size of the virtual machine. The suffix of *M* or *G* can be
+used to specify a value in megabytes or gigabytes respectively. Per default, the
+loader initializes a system with one core and 2 GiB RAM.
+
+The virtual machine opens two TCP/IP ports. One is used for the communication
+between HermitCore application and its proxy. The second port is used to create
+a connection via telnet to QEMU's system monitor. With the environment variable
+`HERMIT_PORT`, the default port (18766) can be changed for the communication
+between the HermitCore application and its proxy. The connection to the system
+monitor used automatically `HERMIT_PORT+1`, i.e., the default port is 18767.
+
+The following command starts the stream benchmark in a virtual machine, which
+has 4 cores and 6GB memory.
+
+```bash
+$ HERMIT_ISLE=qemu HERMIT_CPUS=4 HERMIT_MEM=6G bin/proxy extra/benchmarks/stream
+```
+
+
+### As multi-kernel on a real machine

 *Note*: to launch HermitCore applications, root privileges are required.

-1. In principle you have to follow the tutorial above.
-   After the configuration, building of the cross-compilers and all example application (Step 5 in the [above tutorial](#building-and-testing-hermitcore-within-a-virtual-machine)), a modified Linux kernel has to be installed.
-   Please clone the repository with the [modified Linux kernel](https://github.com/RWTH-OS/linux).
-   Afterwards switch to the branch `hermit` for a relative new vanilla kernel or to `centos`, which is compatible to the current CentOS 7 kernel.
-   Configure the kernel with `make menuconfig` for your system.
-   Be sure, that the option `CONFIG_HERMIT_CORE` in `Processor type and features` is enabled.
-2. Install the Linux kernel and its initial ramdisk on your system (see descriptions of your Linux distribution).
-   We recommend to disable Linux NO_HZ feature by setting the kernel parameter `nohz=off`.
-3. After a reboot of the system, register the HermitCore loader at your system with following command: `sudo -c sh 'echo ":hermit:M:7:\\x42::/path2proyxy/proxy:" > /proc/sys/fs/binfmt_misc/register'`, in which `path2proxy` defines the path to the loader.
-   You find the loader `proxy` after building the HermiCore sources in the subdirectory `tools` of the directory, which contains this *README*.
-4. The IP device between HermitCore and Linux currently does not support IPv6.
-   Consequently, disable IPv6 by adding following line to `/etc/sysctl.conf`: `net.ipv6.conf.mmnif.disable_ipv6 = 1`.
-5. Per default, the IP device uses a static IP address range.
-   Linux has to use `162.168.28.1`, where HermitCore isles start with `192.168.28.2` (isle 0).
-   The network manager must be configured accordingly and therefore the file `/etc/sysconfig/network-scripts/ifcfg-mmnif` must be created with the following content:
+A [modified Linux kernel](https://github.com/RWTH-OS/linux) has to be installed.
+Afterwards switch to the branch `hermit` for a relative new vanilla kernel or to
+`centos`, which is compatible to the current CentOS 7 kernel. Configure the
+kernel with `make menuconfig` for your system. Be sure, that the option
+`CONFIG_HERMIT_CORE` in `Processor type and features` is enabled. 
+
+```bash
+$ git clone https://github.com/RWTH-OS/linux
+$ cd linux
+$ # see comments above
+$ git checkout hermit
+$ make menuconfig
+$ make
+```
+
+Install the Linux kernel and its initial ramdisk on your system (see
+descriptions of your Linux distribution). We recommend to disable Linux NO_HZ
+feature by setting the kernel parameter `nohz=off`.
+
+Install HermitCore to your system (by default to `/opt/hermit`):
+
+```bash
+$ cd build
+$ sudo make install
+$ ls -l /opt/hermit
+```
+
+After a reboot of the system, register the HermitCore loader at your system with
+following command:
+
+```bash
+$ sudo -c sh 'echo ":hermit:M:7:\\x42::/opt/hermit/bin/proxy:" > /proc/sys/fs/binfmt_misc/register'
+```
+
+The IP device between HermitCore and Linux currently does not support IPv6.
+Consequently, disable it (might be slightly different on your distribution):
+
+```bash
+$ echo 'net.ipv6.conf.mmnif.disable_ipv6 = 1' | sudo tee /etc/sysctl.conf
+```
+
+Per default, the IP device uses a static IP address range. Linux has to use
+`162.168.28.1`, where HermitCore isles start with `192.168.28.2` (isle 0). The
+interface is `mmnif`.
+
+Please configure your network accordingly. For CentOS, you have to create the
+file `/etc/sysconfig/network-scripts/ifcfg-mmnif`:

 ```
 DEVICE=mmnif
@ -96,66 +273,72 @@ NETMASK=255.255.255.0
 IPADDR=192.168.28.1
 NM_CONTROLLED=yes
 ```
-Finally, follow the [above tutorial](#building-and-testing-hermitcore-within-a-virtual-machine) from Step 5.
-The demo applications are located in their subdirectories `usr/{tests,benchmarks}`.

-## Building and testing HermitCore as classical standalone unikernel
+You can now start applications the same way as from within a virtual machine
+(see description above).

-HermitCore applications can be directly started as standalone kernel within a virtual machine.
-In this case, [iRCCE](http://www.lfbs.rwth-aachen.de/publications/files/iRCCE.pdf) is not supported.
-Please build HermitCore and register the loader in the same way as done for the multi-kernel version (see [Building and testing HermitCore on a real machine](#building-and-testing-hermitcore-on-a-real-machine)).
-If the environment variable `HERMIT_ISLE` is set to `qemu`, the application will be started within a VM.
-Please note that the loader requires QEMU and uses per default *KVM*.
-Furthermore, it expects that the executable is called `qemu-system-x86_64`.
-You can adapt the name by setting the environment variable `HERMIT_QEMU`.

-In this context, the environment variable `HERMIT_CPUS` specifies the number of cpus (and no longer a range of core ids).
-Furthermore, the variable `HERMIT_MEM` defines the memory size of the virtual machine.
-The suffix of *M* or *G* can be used to specify a value in megabytes or gigabytes respectively.
-Per default, the loader initializes a system with one core and 2 GiB RAM.
+## Building your own HermitCore applications

-The virtual machine opens two TCP/IP ports.
-One is used for the communication between HermitCore application and its proxy.
-The second port is used to create a connection via telnet to QEMU's system monitor.
-With the environment variable `HERMIT_PORT`, the default port (18766) can be changed for the communication between the HermitCore application and its proxy.
-The connection to the system monitor used automatically `HERMIT_PORT+1`, i.e., the default port is 18767.
+You can take `usr/tests` as a starting point to build your own applications. All
+that is required is that you include
+`[...]/HermitCore/cmake/HermitCore-Application.cmake` in your application's
+`CMakeLists.txt`. It doesn't have to reside inside the HermitCore repository.
+Other than that, it should behave like normal CMake.
+
+
+## Profiling
+
+We provide profiling support via the XRay profiler. See `usr/xray/README.md` for
+more information on how to use it.
+
+
+## Debugging
+
+If the application is started via `make qemu`, debugging via GDB is enabled by
+default on port 1234. When run via proxy (`HERMIT_ISLE=qemu`), set
+`HERMIT_DEBUG=1`.

-The following example starts the stream benchmark in a virtual machine, which has 4 cores and 6GB memory.
 ```
-HERMIT_ISLE=qemu HERMIT_CPUS=4 HERMIT_MEM=6G usr/benchmarks/stream
+$ gdb extra/tests/hello
+(gdb) target extended-remote :1234
+Remote debugging using :1234
+0xffffffff8100b542 in ?? ()
 ```

-## Building HermitCore applications
-
-After successful building of HermitCore and its demo applications (see above), HermitCore’s cross toolchain (*gcc*, *g++*, *gfortran*, *gccgo*, *objdump*, etc.) is located at the subdiretory `usr/x86` of the directory, which contains this *README*.
-To use these tools, add `usr/x86/bin` to your environment variable `PATH`.
-As with any other cross toolchain, the tool names begin with the target architecture (*x86_64*) and the name of the operating system (*hermit*).
-For instance, `x86_64-hermit-gcc` stands for the GNU C compiler, which is able to build HermitCore applications.
-
-All tools can be used as the well-known GNU tools. Only the Go compiler works different to the typical workflow.
-Instead of building Go application like
-```
-go build main.go
-```
-you have to use the compiler as follows
-```
-x86_64-hermit-gccgo -pthread -Wall -o main main.go
-```
-For network support, you have to link the Go application with the flag `-lnetgo`.

 ## Tips

-1. The configuration flag `--with-mtune=name` specifies the name of the target processor for which GCC should tune the performance of the code.
-   You can use any architecture name, which is supported by GCC.
-   For instance, `--with-mtune=native` optimzes the code for the host system.
-   Please note, if the applications is started within a VM, the hypervisor has to support the specified architecture name.
-   Per default the system will be accelerated by KVM and the host architecture will be used as target processor.
-2. If Qemu is started by our proxy and the environment variable `HERMIT_KVM` is set to `0`, the virtual machine will be not accelerated by KVM.
-   In this case, the configuration flag `--with-mtune=name` should be avoided.
-   With the environment variable `HERMIT_APP_PORT`, an additional port can be open to establish an TCP/IP connection with your application.
-3. By setting the environment variable `HERMIT_VERBOSE` to `1`, the proxy prints at termination the kernel log messages onto the screen.
-4. If `HERMIT_DEBUG` is set to `1`, Qemu will establish an gdbserver, which will be listen port 1234.
-   Afterwards you are able debug HermitCore applications remotely.
-5. By setting the environment variable `HERMIT_CAPTURE_NET` to `1` and `HERMIT_ISLE` to `qemu`, Qemu captures the network traffic and
-   creates the trace file *qemu-vlan0.pcap*. For instance with [Wireshark](https://www.wireshark.org) you are able to analyze the file.
-6. If `HERMIT_MONITOR` is set to `1` and `HERMIT_ISLE` to `qemu`, Qemu establishes a monitor which is available via telnet at port 18767.
+### Optimization
+
+You can configure the `-mtune=name` compiler flag by adding `-DMTUNE=name` to
+the `cmake` command when configuring the project.
+
+Please note, if the applications is started within a VM, the hypervisor has to
+support the specified architecture name.
+
+If QEMU is started by our proxy and the environment variable `HERMIT_KVM` is set
+to `0`, the virtual machine will be not accelerated by KVM. In this case, the
+`-mtune` flag should be avoided.
+
+### TCP connections
+
+With the environment variable `HERMIT_APP_PORT`, an additional port can be open
+to establish an TCP/IP connection with your application.
+
+### Dumping the kernel log
+
+By setting the environment variable `HERMIT_VERBOSE` to `1`, the proxy prints at
+termination the kernel log messages onto the screen.
+
+### Network tracing
+
+By setting the environment variable `HERMIT_CAPTURE_NET` to `1` and
+`HERMIT_ISLE` to `qemu`, QEMU captures the network traffic and creates the trace
+file *qemu-vlan0.pcap*. For instance with [Wireshark](https://www.wireshark.org)
+you are able to analyze the file.
+
+### Monitor
+
+If `HERMIT_MONITOR` is set to `1` and `HERMIT_ISLE` to `qemu`, QEMU establishes
+a monitor which is available via telnet at port 18767.
--- a/arch/x86/CMakeLists.txt
+++ b/arch/x86/CMakeLists.txt
@ -0,0 +1,88 @@
+cmake_minimum_required(VERSION 3.7)
+include(../../cmake/HermitCore.cmake)
+
+project(arch_x86_kernel C ASM_NASM)
+
+set_parent(X86_KERNEL_TARGET		${PROJECT_NAME})
+set_parent(X86_KERNEL_ASM_TARGET	${X86_KERNEL_TARGET}_asm)
+set_parent(X86_KERNEL_C_TARGET		${X86_KERNEL_TARGET}_c)
+
+add_custom_target(${X86_KERNEL_TARGET})
+
+# compiling kernel code here
+add_definitions(-D__KERNEL__)
+
+
+### ASM sources ###
+
+add_library(${X86_KERNEL_ASM_TARGET} OBJECT
+	kernel/entry.asm
+	libkern/string.asm)
+
+# HACK: We need to post-process the objects by running elfedit on them, but
+#       there is currently no way to get the list of objects out of CMake
+#       except for $<TARGET_OBJECTS:tgt>, which only works with add_library()
+#       and add_executable().
+#       So predict path to objects and add custom commands that depend on
+#       the asm target.
+#
+#       Upstream issue: https://gitlab.kitware.com/cmake/cmake/issues/15226
+#
+set(_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}")
+set(_BUILD_DIR "${_BUILD_DIR}/${X86_KERNEL_ASM_TARGET}.dir")
+
+get_target_property(ASM_SOURCES ${X86_KERNEL_ASM_TARGET} SOURCES)
+foreach(SOURCE ${ASM_SOURCES})
+	set(OBJECT "${SOURCE}.obj")
+	set(OBJECT_PATH "${_BUILD_DIR}/${OBJECT}")
+
+	# slash (/) not allowed in target names
+	string(REPLACE "/" "-"
+		OBJECT_TARGET_NAME
+		"${OBJECT}")
+
+	add_custom_target("${OBJECT_TARGET_NAME}"
+		COMMAND
+			${CMAKE_ELFEDIT} --output-osabi HermitCore ${OBJECT_PATH}
+		DEPENDS
+			${X86_KERNEL_ASM_TARGET})
+
+	# make main target depend on this
+	add_dependencies(${PROJECT_NAME} ${OBJECT_TARGET_NAME})
+endforeach()
+
+
+### C sources ###
+
+file(GLOB KERNEL_SOURCES	"kernel/*.c")
+file(GLOB MM_SOURCES		"mm/*.c")
+
+# add boot.h as source to mark dependency boot.asm -> boot.h -> apic.c
+add_library(${X86_KERNEL_C_TARGET} OBJECT
+	${KERNEL_SOURCES} ${MM_SOURCES}
+	${GENERATED_CONFIG_DIR}/hermit/boot.h)
+
+target_include_directories(${X86_KERNEL_C_TARGET} BEFORE
+	PUBLIC ${HERMIT_KERNEL_INCLUDES}
+	PRIVATE ${GENERATED_CONFIG_DIR})
+
+target_compile_options(${X86_KERNEL_C_TARGET}
+	PRIVATE ${HERMIT_KERNEL_FLAGS})
+
+# assemble boot.asm and dump to C-array in boot.h
+add_custom_command(
+	OUTPUT
+		${GENERATED_CONFIG_DIR}/hermit/boot.h
+	DEPENDS
+		kernel/boot.asm
+	COMMAND
+		echo "static const uint8_t boot_code[] = {" > boot.h
+	COMMAND
+		nasm -f bin -o boot.bin ${CMAKE_CURRENT_LIST_DIR}/kernel/boot.asm
+	COMMAND
+		hexdump -v -e "7/1 \"0x%02X, \" 1/1 \" 0x%02X,\\n\"" boot.bin >> boot.h
+	COMMAND
+		echo "};" >> boot.h
+	WORKING_DIRECTORY
+		${GENERATED_CONFIG_DIR}/hermit/
+	VERBATIM USES_TERMINAL)
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@ -1,5 +0,0 @@
-C_source := irq.c idt.c isrs.c gdt.c processor.c timer.c tasks.c apic.c pci.c uart.c syscall.c signal.c
-ASM_source := entry.asm
-MODULE := arch_x86_kernel
-
-include $(TOPDIR)/Makefile.inc
--- a/arch/x86/kernel/apic.c
+++ b/arch/x86/kernel/apic.c
@ -42,7 +42,7 @@
 #include <asm/io.h>
 #include <asm/page.h>
 #include <asm/apic.h>
-#include "boot.h"
+#include <hermit/boot.h>

 /*
 * Note that linker symbols are not variables, they have no memory allocated for
--- a/arch/x86/kernel/entry.asm
+++ b/arch/x86/kernel/entry.asm
@ -28,7 +28,7 @@
 ; perhaps setting up the GDT and segments. Please note that interrupts
 ; are disabled at this point: More on interrupts later!

-%include "config.inc"
+%include "hermit/config.asm"

 [BITS 64]

@ -600,7 +600,7 @@ common_switch:
    call get_current_stack     ; get new rsp
    mov rsp, rax

-%ifdef SAVE_FPU
+%ifidn SAVE_FPU,ON
    ; set task switched flag
    mov rax, cr0
    or rax, 8
--- a/arch/x86/libkern/string.asm
+++ b/arch/x86/libkern/string.asm
@ -8,7 +8,7 @@
 ; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ;

-%include "config.inc"
+%include "hermit/config.asm"

 %ifdef CONFIG_X86_32
 [BITS 32]
--- a/arch/x86/loader/CMakeLists.txt
+++ b/arch/x86/loader/CMakeLists.txt
@ -0,0 +1,50 @@
+cmake_minimum_required(VERSION 3.7)
+
+project(arch_x86_loader C ASM_NASM)
+
+## ASM sources
+
+file(GLOB ASM_SOURCES *.asm)
+add_library(arch_x86_loader_asm	STATIC ${ASM_SOURCES})
+
+## C sources
+
+file(GLOB C_SOURCES *.c)
+add_executable(arch_x86_loader ${C_SOURCES})
+
+target_include_directories(arch_x86_loader
+	PRIVATE include/)
+
+target_compile_options(arch_x86_loader
+	PRIVATE -O2 -Wall -m64 -std=gnu99 -ffreestanding -mno-red-zone
+			-fstrength-reduce -fomit-frame-pointer -finline-functions)
+
+target_link_libraries(arch_x86_loader
+	arch_x86_loader_asm
+	"-T ${CMAKE_CURRENT_LIST_DIR}/link.ld"
+	"-z max-page-size=4096"
+	-Wl,--build-id=none		# required because CMake links with gcc, not ld
+	-nostdlib)
+
+# tools/proxy looks for `ldhermit.elf`
+set_target_properties(arch_x86_loader PROPERTIES
+	OUTPUT_NAME ldhermit.elf)
+
+add_custom_command(
+	TARGET arch_x86_loader POST_BUILD
+	# Split debug symbols into seperate file
+	COMMAND
+		${CMAKE_OBJCOPY} --only-keep-debug
+							$<TARGET_FILE:arch_x86_loader>
+							$<TARGET_FILE:arch_x86_loader>.sym
+	# Qemu requires 32-bit ELF
+	COMMAND
+		${CMAKE_OBJCOPY} -O elf32-i386 --strip-debug
+							$<TARGET_FILE:arch_x86_loader>)
+
+install(TARGETS arch_x86_loader
+	DESTINATION bin)
+
+# Show include files in IDE
+file(GLOB_RECURSE ARCH_X86_LOADER_INCLUDES "include/*")
+add_custom_target(arch_x86_loader_includes_ide SOURCES ${ARCH_X86_LOADER_INCLUDES})
--- a/arch/x86/loader/include/vga.h
+++ b/arch/x86/loader/include/vga.h
@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2010, Stefan Lankes, RWTH Aachen University
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *    * Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *    * Neither the name of the University nor the names of its contributors
- *      may be used to endorse or promote products derived from this
- *      software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __VGA_H__
-#define __VGA_H__
-
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @brief Initialize VGA output and clear the screen */
-void vga_init(void);
-
-/** @brief Simple string output on screen.
- *
- * If you want a new line you will have to "\\n".
- *
- * @return Length of output in bytes
- */
-int vga_puts(const char *text);
-
-/** @brief Simple character output on screen.
- *
- * @return The original input character casted to int 
- */
-int vga_putchar(unsigned char c);
-
-/** @brief Clear the screen */
-void vga_cls(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
--- a/arch/x86/mm/Makefile
+++ b/arch/x86/mm/Makefile
@ -1,4 +0,0 @@
-C_source := memory.c vma.c page.c hbmemory.c
-MODULE := arch_x86_mm
-
-include $(TOPDIR)/Makefile.inc
--- a/cmake/HermitCore-Application.cmake
+++ b/cmake/HermitCore-Application.cmake
@ -0,0 +1,9 @@
+include(${CMAKE_CURRENT_LIST_DIR}/HermitCore.cmake)
+include_guard()
+
+add_compile_options(${HERMIT_APP_FLAGS})
+
+# link against and include locally built libraries instead of the ones
+# supplied with the toolchain, if built from top-level
+link_directories(${LOCAL_PREFIX_ARCH_LIB_DIR})
+include_directories(BEFORE ${LOCAL_PREFIX_ARCH_INCLUDE_DIR})
--- a/cmake/HermitCore-Configuration.cmake
+++ b/cmake/HermitCore-Configuration.cmake
@ -0,0 +1,29 @@
+set(PACKAGE_VERSION "0.1" CACHE STRING
+	"HermitCore current version")
+
+set(MAX_CORES "512" CACHE STRING
+	"Maximum number of cores that can be managed")
+
+set(MAX_TASKS "((MAX_CORES * 2) + 2)" CACHE STRING
+	"Maximum number of tasks")
+
+set(MAX_ISLE "8" CACHE STRING
+	"Maximum number of NUMA isles")
+
+set(KERNEL_STACK_SIZE 8192 CACHE STRING
+	"Kernel stack size in bytes")
+
+set(DEFAULT_STACK_SIZE 262144 CACHE STRING
+	"Task stack size in bytes")
+
+option(DYNAMIC_TICKS
+	"Don't use a periodic timer event to keep track of time" ON)
+
+option(SAVE_FPU
+	"Save FPU registers on context switch" ON)
+
+option(HAVE_ARCH_MEMSET	 "Use machine specific version of memset"  OFF)
+option(HAVE_ARCH_MEMCPY	 "Use machine specific version of memcpy"  OFF)
+option(HAVE_ARCH_STRLEN	 "Use machine specific version of strlen"  OFF)
+option(HAVE_ARCH_STRCPY	 "Use machine specific version of strcpy"  OFF)
+option(HAVE_ARCH_STRNCPY "Use machine specific version of strncpy" OFF)
--- a/cmake/HermitCore-Paths.cmake
+++ b/cmake/HermitCore-Paths.cmake
@ -0,0 +1,35 @@
+include(${CMAKE_CURRENT_LIST_DIR}/HermitCore-Utils.cmake)
+# no include guard here because we have to include this file twice to correctly
+# set CMAKE_INSTALL_PREFIX
+
+# root of HermitCore project
+set(HERMIT_ROOT ${CMAKE_CURRENT_LIST_DIR}/..)
+
+# set default install prefix if user doesn't specify one
+if(${CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT})
+	# See CMake docs for reference:
+	# https://cmake.org/cmake/help/v3.7/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.html
+	set(CMAKE_INSTALL_PREFIX /opt/hermit CACHE PATH "..." FORCE)
+endif()
+
+# we install 3rd party libraries to an intermediate directory and relocate
+# them here later when installing the whole project
+if(NOT LOCAL_PREFIX_BASE_DIR)
+	# will be injected into external project because CMAKE_BINARY_DIR will be
+	# different there
+	set(LOCAL_PREFIX_BASE_DIR ${CMAKE_BINARY_DIR}/local_prefix)
+endif()
+
+# during build process libraries and external projects will be deployed into
+# this directory structure
+set(LOCAL_PREFIX_DIR ${LOCAL_PREFIX_BASE_DIR}/${CMAKE_INSTALL_PREFIX})
+set(LOCAL_PREFIX_ARCH_DIR ${LOCAL_PREFIX_DIR}/${TARGET_ARCH})
+set(LOCAL_PREFIX_ARCH_INCLUDE_DIR ${LOCAL_PREFIX_ARCH_DIR}/include)
+
+# when building applications within the HermitCore project (tests, ...) they
+# will link prefarably against libraries in this directory in order to test
+# changes in the kernel
+set(LOCAL_PREFIX_ARCH_LIB_DIR ${LOCAL_PREFIX_ARCH_DIR}/lib)
+
+# generated configs will be put here
+set(GENERATED_CONFIG_DIR ${CMAKE_BINARY_DIR}/include)
--- a/cmake/HermitCore-Toolchain-x86.cmake
+++ b/cmake/HermitCore-Toolchain-x86.cmake
@ -0,0 +1,25 @@
+include(${CMAKE_CURRENT_LIST_DIR}/HermitCore-Utils.cmake)
+include_guard()
+
+# let user provide a different path to the toolchain
+set_default(TOOLCHAIN_BIN_DIR /opt/hermit/bin)
+
+set(TARGET_ARCH x86_64-hermit)
+
+set(CMAKE_SYSTEM_NAME Generic)
+
+# point CMake to our toolchain, it will auto detect C++ compiler
+set(CMAKE_C_COMPILER ${TOOLCHAIN_BIN_DIR}/${TARGET_ARCH}-gcc)
+set(CMAKE_Fortran_COMPILER ${TOOLCHAIN_BIN_DIR}/${TARGET_ARCH}-gfortran)
+set(CMAKE_Go_COMPILER ${TOOLCHAIN_BIN_DIR}/${TARGET_ARCH}-gccgo)
+
+# hinting the prefix and location is needed in order to correctly detect
+# binutils
+set(_CMAKE_TOOLCHAIN_PREFIX "${TARGET_ARCH}-")
+set(_CMAKE_TOOLCHAIN_LOCATION ${TOOLCHAIN_BIN_DIR})
+
+option(HAVE_ARCH_MEMSET	 "Use machine specific version of memset" ON)
+option(HAVE_ARCH_MEMCPY	 "Use machine specific version of memcpy" ON)
+option(HAVE_ARCH_STRLEN	 "Use machine specific version of strlen" ON)
+option(HAVE_ARCH_STRCPY	 "Use machine specific version of strcpy" ON)
+option(HAVE_ARCH_STRNCPY "Use machine specific version of strncpy" ON)
--- a/cmake/HermitCore-Utils.cmake
+++ b/cmake/HermitCore-Utils.cmake
@ -0,0 +1,142 @@
+macro(include_guard)
+	if(DEFINED "_INCLUDE_GUARD_${CMAKE_CURRENT_LIST_FILE}")
+		return()
+	endif()
+	set("_INCLUDE_GUARD_${CMAKE_CURRENT_LIST_FILE}" INCLUDED)
+endmacro(include_guard)
+
+macro(add_kernel_module_sources MODULE SOURCE_GLOB)
+	file(GLOB SOURCES "${SOURCE_GLOB}")
+
+    if("${SOURCES}" STREQUAL "")
+        message(FATAL_ERROR "Module '${MODULE}' has no sources")
+    endif()
+
+    # make sure modules are unique, this is needed of multiple sources
+    # are added to the same module
+    list(APPEND _KERNEL_MODULES "${MODULE}")
+    list(REMOVE_DUPLICATES _KERNEL_MODULES)
+
+    # append sources for module
+    list(APPEND "_KERNEL_SOURCES_${MODULE}" "${SOURCES}")
+endmacro(add_kernel_module_sources)
+
+
+macro(get_kernel_module_sources VAR MODULE)
+    set(${VAR} ${_KERNEL_SOURCES_${MODULE}})
+endmacro(get_kernel_module_sources)
+
+
+macro(get_kernel_modules VAR)
+	set(${VAR} ${_KERNEL_MODULES})
+endmacro(get_kernel_modules)
+
+
+# find program in /toolchain/dir/prefix-NAME, only supply NAME
+function(find_toolchain_program NAME)
+
+    string(TOUPPER "${NAME}" NAME_UPPER)
+    string(TOLOWER "${NAME}" NAME_LOWER)
+
+    set(VARNAME "CMAKE_${NAME_UPPER}")
+
+    find_program(${VARNAME}
+        NAMES ${_CMAKE_TOOLCHAIN_PREFIX}${NAME_LOWER}
+        HINTS ${TOOLCHAIN_BIN_DIR})
+
+    if(NOT ${VARNAME})
+        message(FATAL_ERROR
+				"Cannot find ${_CMAKE_TOOLCHAIN_PREFIX}${NAME_LOWER}")
+    endif()
+endfunction(find_toolchain_program)
+
+
+macro(set_parent VAR VALUE)
+	set(${VAR} ${VALUE} PARENT_SCOPE)
+	set(${VAR} ${VALUE})
+endmacro(set_parent)
+
+function(get_cmd_variables VAR)
+	set(_OUTPUT "")
+
+	get_cmake_property(vs VARIABLES)
+
+	foreach(v ${vs})
+		get_property(_HELPSTRING
+			CACHE ${v}
+			PROPERTY HELPSTRING)
+		if("${_HELPSTRING}" STREQUAL "No help, variable specified on the command line.")
+			list(APPEND _OUTPUT "${v}")
+		endif()
+	endforeach()
+
+	set(${VAR} ${_OUTPUT} PARENT_SCOPE)
+endfunction(get_cmd_variables)
+
+# any additional parameters will be handed over to the cmake command that the
+# external project is invoked with
+function(build_external NAME PATH DEPENDS)
+	if("${NAME}" IN_LIST PROFILE_APPS)
+		set(DO_PROFILING "-DPROFILING=true")
+	endif()
+
+	# pass through all command line variables
+	get_cmd_variables(CMD_VAR_NAMES)
+	foreach(var ${CMD_VAR_NAMES})
+		set(CMD_VARS ${CMD_VARS} -D${var}=${${var}})
+	endforeach()
+
+	ExternalProject_Add(${NAME}
+		SOURCE_DIR ${PATH}
+		BUILD_ALWAYS 1
+		DEPENDS ${DEPENDS}
+		INSTALL_COMMAND
+			${CMAKE_COMMAND} --build <BINARY_DIR>
+			                 --target install --
+			                   DESTDIR=${LOCAL_PREFIX_BASE_DIR}
+		CMAKE_ARGS
+			-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
+			-DLOCAL_PREFIX_BASE_DIR=${LOCAL_PREFIX_BASE_DIR}
+			-DCMAKE_INSTALL_MESSAGE=NEVER
+			--no-warn-unused-cli
+			${DO_PROFILING}
+			${CMD_VARS}
+			${ARGN})
+
+	ExternalProject_Add_Step(${NAME} relink
+		COMMAND find . -maxdepth 1 -type f -executable -exec rm {} "\\\;"
+		DEPENDEES configure
+		DEPENDERS build
+		WORKING_DIRECTORY <BINARY_DIR>)
+
+	ExternalProject_Add_StepDependencies(${NAME} relink ${DEPENDS})
+endfunction(build_external)
+
+
+# additional arguments are be treated as targets that will be excluded
+function(install_local_targets PATH)
+	get_property(_TARGETS
+		DIRECTORY .
+		PROPERTY BUILDSYSTEM_TARGETS)
+
+	if(NOT "${ARGN}" STREQUAL "")
+		list(REMOVE_ITEM _TARGETS ${ARGN})
+	endif()
+
+	install(TARGETS ${_TARGETS}
+		DESTINATION ${PATH})
+
+	# if there are any .map files for profiling, install them too
+	foreach(TARGET ${_TARGETS})
+		install(FILES $<TARGET_FILE:${TARGET}>.map
+			DESTINATION ${PATH}
+			OPTIONAL)
+	endforeach()
+endfunction(install_local_targets)
+
+# set variable if not yet set
+macro(set_default VARNAME)
+	if(NOT ${VARNAME})
+		set(${VARNAME} ${ARGN})
+	endif()
+endmacro(set_default)
--- a/cmake/HermitCore.cmake
+++ b/cmake/HermitCore.cmake
@ -0,0 +1,84 @@
+include(${CMAKE_CURRENT_LIST_DIR}/HermitCore-Utils.cmake)
+include_guard()
+
+include(${CMAKE_CURRENT_LIST_DIR}/HermitCore-Paths.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/HermitCore-Configuration.cmake)
+
+# scripts to detect HermitCore Go compiler
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/golang/)
+
+if(NOT HERMIT_ARCH)
+	set(HERMIT_ARCH x86)
+endif()
+
+if(PROFILING)
+	# link everything against XRay
+	link_libraries(-lxray)
+
+	# generate symbol map file for XRay to resolve function names
+	link_libraries(-Wl,-Map=$<TARGET_PROPERTY:NAME>.map)
+
+	# enable profiling with XRay
+	add_compile_options(-falign-functions=32 -finstrument-functions
+		-finstrument-functions-exclude-function-list=_mm_pause,_mm_setcsr,_mm_getcsr)
+	add_definitions(-DXRAY -DXRAY_DISABLE_BROWSER_INTEGRATION
+					-DXRAY_NO_DEMANGLE -DXRAY_ANNOTATE)
+endif()
+
+# use default toolchain if not specified by user
+if(NOT CMAKE_TOOLCHAIN_FILE)
+	set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_LIST_DIR}/HermitCore-Toolchain-${HERMIT_ARCH}.cmake)
+endif()
+
+# NASM detection will change binary format depending on host system, but
+# we only want to generate elf64 for HermitCore
+# Note: Has to be set *before* ASM_NASM is enabled
+set(CMAKE_ASM_NASM_OBJECT_FORMAT elf64)
+
+enable_language(ASM_NASM)
+
+# NASM hack, because it requires include paths to have a trailing /, whereas
+# CMake explicitly will remove it when adding includes the usual way
+# Note: Has to be set *after* ASM_NASM is enabled
+set(CMAKE_ASM_NASM_FLAGS
+	"${CMAKE_ASM_NASM_FLAGS} -I ${CMAKE_BINARY_DIR}/include/")
+
+set(HERMIT_KERNEL_FLAGS
+					-m64 -Wall -O2 -mno-red-zone
+					-fno-var-tracking-assignments -fstrength-reduce
+					-fomit-frame-pointer -finline-functions -ffreestanding
+					-nostdinc -fno-stack-protector -mno-sse -mno-mmx
+					-mno-sse2 -mno-3dnow -mno-avx
+					-fno-delete-null-pointer-checks
+					-falign-jumps=1 -falign-loops=1
+					-mno-80387 -mno-fp-ret-in-387 -mskip-rax-setup
+					-fno-common -Wframe-larger-than=1024
+					-fno-strict-aliasing -fno-asynchronous-unwind-tables
+					-fno-strict-overflow -maccumulate-outgoing-args)
+
+set(HERMIT_APP_FLAGS
+					-m64 -mtls-direct-seg-refs -O3 -ftree-vectorize)
+
+if(MTUNE)
+	set(HERMIT_KERNEL_FLAGS ${HERMIT_KERNEL_FLAGS} -mtune=${MTUNE})
+	set(HERMIT_APP_FLAGS    ${HERMIT_APP_FLAGS}    -mtune=${MTUNE})
+endif()
+
+set(HERMIT_KERNEL_INCLUDES
+    ${CMAKE_BINARY_DIR}/include
+    ${HERMIT_ROOT}/include
+    ${HERMIT_ROOT}/arch/${HERMIT_ARCH}/include
+    ${HERMIT_ROOT}/lwip/src/include
+    ${HERMIT_ROOT}/drivers)
+
+# HACK: when CMake detects compilers it taints CMAKE_INSTALL_PREFIX, so in
+#       order to rely on that variable (we redefine it), enable all languages
+#       here and source pathes again.
+#
+# Furthermore this will produce a sensible error message if the toolchain cannot
+# be found.
+enable_language(C CXX Fortran Go)
+include(${CMAKE_CURRENT_LIST_DIR}/HermitCore-Paths.cmake)
+
+# find elfedit, CMake doesn't use this program, so we have to find it ourself
+find_toolchain_program(elfedit)
--- a/cmake/README.md
+++ b/cmake/README.md
@ -0,0 +1,67 @@
+HermitCore CMake build system
+=============================
+
+HermitCore requires at least CMake version `3.7`, which (at the time of
+introduction) is not yet available on most Linux distributions. We therefore
+provide a script `cmake/local-cmake.sh` that fetches precompiled binaries from
+the CMake project and installs them locally in `cmake/cmake-3.7*`. Only when
+sourced for the first time it will download CMake, on further runs it detects
+the existing download and adds it to `PATH` automatically.
+
+```bash
+$ . cmake/local-cmake.sh
+-- Downloading CMake
+cmake-3.7.2-Linux-x 100%[=================>]  29,26M   837KB/s    in 19s
+-- Unpacking CMake
+-- Local CMake v3.7.2 installed to cmake/cmake-3.7.2-Linux-x86_64
+-- Next time you source this script, no download will be neccessary
+$ which cmake
+/home/[...]/HermitCore/cmake/cmake-3.7.2-Linux-x86_64/bin/cmake
+```
+
+## Directory structure
+
+```
+cmake/
+├── golang
+│   ├── CMakeDetermineGoCompiler.cmake
+│   ├── CMakeGoCompiler.cmake.in
+│   ├── CMakeGoInformation.cmake
+│   └── CMakeTestGoCompiler.cmake
+├── HermitCore-Application.cmake
+├── HermitCore.cmake
+├── HermitCore-Paths.cmake
+├── HermitCore-Toolchain-x86.cmake
+├── HermitCore-Utils.cmake
+├── local-cmake.sh
+└── README.md
+```
+
+## Additional language support
+
+Currently, HermitCore supports `C, C++, Fortran, Go` through Cmake. While the
+former are supported and detected by CMake out-of-the-box, Go support has been
+added manually for HermitCore.
+
+Adding a new language requires you to provide CMake hints where to find the
+toolchain and then how to compile and link binaries. The Go support in
+`cmake/golang` may serve as an example on how to add a new language.
+
+To finally enable the language it has to be added to CMake's module path in
+`cmake/HermitCore.cmake`:
+
+```
+# scripts to detect HermitCore Go compiler
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/golang/)
+
+# scripts to detect new language
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/new-language/)
+```
+
+
+## User applications
+
+You just have to include `HermitCore-Application.cmake` before the `project()`
+command in your `CMakeLists.txt` in order to build applications for HermitCore.
+For configuration parameters of the project, please consult the `README.md` in
+the root of this repository.
--- a/cmake/golang/CMakeDetermineGoCompiler.cmake
+++ b/cmake/golang/CMakeDetermineGoCompiler.cmake
@ -0,0 +1,43 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# determine the compiler to use for Go programs
+# NOTE, a generator may set CMAKE_Go_COMPILER before
+# loading this file to force a compiler.
+
+if(NOT CMAKE_Go_COMPILER)
+  # prefer the environment variable CC
+  if(NOT $ENV{GO_COMPILER} STREQUAL "")
+    get_filename_component(CMAKE_Go_COMPILER_INIT $ENV{GO_COMPILER} PROGRAM PROGRAM_ARGS CMAKE_Go_FLAGS_ENV_INIT)
+    if(CMAKE_Go_FLAGS_ENV_INIT)
+      set(CMAKE_Go_COMPILER_ARG1 "${CMAKE_Go_FLAGS_ENV_INIT}" CACHE STRING "First argument to Go compiler")
+    endif()
+    if(NOT EXISTS ${CMAKE_Go_COMPILER_INIT})
+      message(SEND_ERROR "Could not find compiler set in environment variable GO_COMPILER:\n$ENV{GO_COMPILER}.")
+    endif()
+  endif()
+
+  set(Go_BIN_PATH
+    $ENV{GOPATH}
+    $ENV{GOROOT}
+    $ENV{GOROOT}/../bin
+    $ENV{GO_COMPILER}
+    /usr/bin
+    /usr/local/bin
+    )
+  # if no compiler has been specified yet, then look for one
+  if(CMAKE_Go_COMPILER_INIT)
+    set(CMAKE_Go_COMPILER ${CMAKE_Go_COMPILER_INIT} CACHE PATH "Go Compiler")
+  else()
+    find_program(CMAKE_Go_COMPILER
+      NAMES go
+      PATHS ${Go_BIN_PATH}
+    )
+  endif()
+endif()
+mark_as_advanced(CMAKE_Go_COMPILER)
+
+# configure variables set in this file for fast reload later on
+configure_file(${CMAKE_CURRENT_LIST_DIR}/CMakeGoCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeGoCompiler.cmake @ONLY)
+set(CMAKE_Go_COMPILER_ENV_VAR "GO_COMPILER")
--- a/cmake/golang/CMakeGoCompiler.cmake.in
+++ b/cmake/golang/CMakeGoCompiler.cmake.in
@ -0,0 +1,11 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+set(CMAKE_Go_COMPILER "@CMAKE_Go_COMPILER@")
+set(CMAKE_Go_COMPILER_LOADED 1)
+
+set(CMAKE_Go_SOURCE_FILE_EXTENSIONS go)
+set(CMAKE_Go_LINKER_PREFERENCE 40)
+set(CMAKE_Go_OUTPUT_EXTENSION .6)
+set(CMAKE_Go_OUTPUT_EXTENSION_REPLACE 1)
+set(CMAKE_Go_COMPILER_ENV_VAR "GO_COMPILER")
--- a/cmake/golang/CMakeGoInformation.cmake
+++ b/cmake/golang/CMakeGoInformation.cmake
@ -0,0 +1,30 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# This should be included before the _INIT variables are
+# used to initialize the cache.  Since the rule variables
+# have if blocks on them, users can still define them here.
+# But, it should still be after the platform file so changes can
+# be made to those values.
+
+if(CMAKE_USER_MAKE_RULES_OVERRIDE)
+  # Save the full path of the file so try_compile can use it.
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
+endif()
+
+if(CMAKE_USER_MAKE_RULES_OVERRIDE_Go)
+  # Save the full path of the file so try_compile can use it.
+   include(${CMAKE_USER_MAKE_RULES_OVERRIDE_Go} RESULT_VARIABLE _override)
+   set(CMAKE_USER_MAKE_RULES_OVERRIDE_Go "${_override}")
+endif()
+
+# refer: /usr/share/cmake-3.7/Modules/CMakeCInformation.cmake
+
+if(NOT CMAKE_Go_COMPILE_OBJECT)
+	set(CMAKE_Go_COMPILE_OBJECT "<CMAKE_Go_COMPILER> <FLAGS> -o <OBJECT> -c <SOURCE> ")
+endif()
+
+if(NOT CMAKE_Go_LINK_EXECUTABLE)
+	set(CMAKE_Go_LINK_EXECUTABLE "<CMAKE_Go_COMPILER> -pthread <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
+endif()
--- a/cmake/golang/CMakeTestGoCompiler.cmake
+++ b/cmake/golang/CMakeTestGoCompiler.cmake
@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+set(CMAKE_Go_COMPILER_WORKS 1 CACHE INTERNAL "")
--- a/cmake/local-cmake.sh
+++ b/cmake/local-cmake.sh
@ -0,0 +1,69 @@
+#!/bin/bash
+
+# which version to fetch
+MAJOR="3.7"
+MINOR="2"
+PLATFORM="Linux-x86_64"
+
+# assemble url for desired version
+URL="https://cmake.org/files/v${MAJOR}/cmake-${MAJOR}.${MINOR}-${PLATFORM}.tar.gz"
+
+ARCHIVE="$(basename ${URL})"
+DIR="$(basename ${ARCHIVE} .tar.gz)"
+
+
+relpath() {
+	# workaround because Ubuntu seems to use an ancient realpath version
+	# https://stackoverflow.com/questions/2564634/convert-absolute-path-into-relative-path-given-a-current-directory-using-bash#comment12808306_7305217
+	python -c "import os.path; print(os.path.relpath('${2:-$PWD}','$1'))";
+}
+
+HERMIT_TOP="$(git rev-parse --show-toplevel)"
+HERMIT_CMAKE="${HERMIT_TOP}/cmake"
+CMAKE_DIR="${HERMIT_CMAKE}/${DIR}"
+CMAKE_DIR_REL="$(relpath ${HERMIT_TOP} ${CMAKE_DIR})"
+
+# make sure we're sourced, not executed
+if [ "$0" = "$BASH_SOURCE" ]
+then
+	echo "You have to source this script:"
+	echo "\$ . $0"
+	exit
+fi
+
+# quit if already in path
+echo "$PATH" | grep "${CMAKE_DIR_REL}" &>/dev/null && return
+
+# check if already installed
+if which cmake &> /dev/null ; then
+	if cmake --version | grep "cmake version ${MAJOR}.${MINOR}" &> /dev/null;	 then
+		echo "You already have CMake ${MAJOR}.${MINOR}"
+		return
+	fi
+fi
+
+if [ ! -d "${CMAKE_DIR}" ]
+then
+	echo "-- Downloading CMake"
+	wget "${URL}" -O "${ARCHIVE}" ||
+		(echo "Cannot download CMake"; return)
+
+	echo "-- Unpacking CMake"
+	tar -C "${HERMIT_CMAKE}" -xf "${ARCHIVE}" ||
+		(echo "Cannot unpack CMake archive"; return)
+
+	# delete temporary archive again
+	rm -f "${ARCHIVE}"
+
+	# add cmake dir to gitignore
+	GITIGNORE="${HERMIT_TOP}/.gitignore"
+	if ! grep "${CMAKE_DIR_REL}" "${GITIGNORE}" &>/dev/null
+	then
+		echo "${CMAKE_DIR_REL}/*" >> "${GITIGNORE}"
+	fi
+
+	echo "-- Local CMake v${MAJOR}.${MINOR} installed to ${CMAKE_DIR_REL}"
+	echo "-- Next time you source this script, no download will be neccessary"
+fi
+
+export PATH="${CMAKE_DIR}/bin:${PATH}"
--- a/4131
+++ b/4131
--- a/configure.ac
+++ b/configure.ac
@ -1,76 +0,0 @@
-#                                               -*- Autoconf -*-
-# Process this file with autoconf to produce a configure script.
-
-AC_PREREQ(2.69)
-AC_INIT(HermitCore, 0.1, slankes@eonerc.rwth-aachen.de, HermitCore, http://www.hermitcore.org)
-AC_CHECK_PROGS(QEMU, qemu-system-x86_64)
-AC_CONFIG_SRCDIR(kernel/main.c)
-AC_CONFIG_HEADERS(include/hermit/config.h)
-
-# Checks for programs.
-AC_PROG_CC
-AC_PROG_INSTALL
-
-# Checks for libraries.
-
-# Checks for header files.
-
-# Checks for typedefs, structures, and compiler characteristics.
-
-# Checks for library functions.
-
-# define eduOS specific constants
-AC_DEFINE(HAVE_ARCH_MEMSET, 1, Define to use machine specific version of memset)
-AC_DEFINE(HAVE_ARCH_MEMCPY, 1, Define to use machine specific version of memcpy)
-AC_DEFINE(HAVE_ARCH_STRLEN, 1, Define to use machine specific version of strlen)
-AC_DEFINE(HAVE_ARCH_STRCPY, 1, Define to use machine specific version of strcpy)
-AC_DEFINE(HAVE_ARCH_STRNCPY, 1, Define to use machine specific version of strncpy)
-AC_DEFINE(MAX_ISLE, 8, Define the maximum number of isles / numa nodes)
-AC_DEFINE(MAX_FNAME, 128, Define the maximum length of a file name)
-AC_DEFINE(VIDEO_MEM_ADDR, 0xB8000, Definition of the VGA address)
-AC_DEFINE(DYNAMIC_TICKS, 1, Use a dynamic tick instead of a static)
-#AC_DEFINE(SAVE_FPU, 1, Set task switched flag during a context switch);
-
-AC_ARG_WITH([mtune],
-  [AS_HELP_STRING([--with-mtune=ARCH],
-                  [enable tuning for a specific architecture])],
-  [if test x"$withval" != x ; then
-     ARCH_OPT="-mtune=$withval -march=$withval"
-   fi],
-  [ARCH_OPT=])
-AC_SUBST(ARCH_OPT)
-
-AC_ARG_WITH([toolchain], [AS_HELP_STRING([--with-toolchain], [build also the whole HermitCore toolchain])], [TOOLCHAIN=1], [TOOLCHAIN=0])
-AC_SUBST(TOOLCHAIN)
-
-AC_ARG_WITH(max-cores, [AS_HELP_STRING([--with-max-cores=N], [specify the maximum number of cores])])
-if test "x$with_max_cores" != x; then
-AC_DEFINE_UNQUOTED(MAX_CORES, $with_max_tasks, Define the maximum number of cores)
-else
-AC_DEFINE(MAX_CORES, 512, Define the maximum number of cores)
-fi
-
-AC_ARG_WITH(max-tasks, [AS_HELP_STRING([--with-max-tasks=N], [specify the maximum number of running tasks])])
-if test "x$with_max_tasks" != x; then
-AC_DEFINE_UNQUOTED(MAX_TASKS, $with_max_tasks, Define the maximum number of running tasks)
-else
-AC_DEFINE(MAX_TASKS, (MAX_CORES*2+2), Define the maximum number of running tasks)
-fi
-
-AC_ARG_WITH(kernel-stack-size, [AS_HELP_STRING([--with-kernel-stack-size=SIZE], [specify the size of the kernel stack])])
-if test "x$with_kernel_stack_size" != x; then
-AC_DEFINE_UNQUOTED(KERNEL_STACK_SIZE, $with_stack_size, Define the size of the kernel stack)
-else
-AC_DEFINE(KERNEL_STACK_SIZE, 8192, Define the size of the kernel stack)
-fi
-
-
-AC_ARG_WITH(default-stack-size, [AS_HELP_STRING([--with-default-stack-size=SIZE], [specify the default stack size])])
-if test "x$with_default_stack_size" != x; then
-AC_DEFINE_UNQUOTED(DEFAULT_STACK_SIZE, $with_default_stack_size, Define the default stack size)
-else
-AC_DEFINE(DEFAULT_STACK_SIZE, 262144, Define the default stack size)
-fi
-
-AC_CONFIG_FILES(Makefile tools/Makefile usr/ircce/Makefile usr/xray/Makefile usr/libomp/Makefile)
-AC_OUTPUT
--- a/debian/README.Debian
+++ b/debian/README.Debian
@ -1,6 +0,0 @@
-libhermit for Debian
-------------------
-
-<possible notes regarding this package - if none, delete this file>
-
- -- Stefan Lankes <slankes@eonerc.rwth-aachen.de>  Sun, 08 Jan 2017 19:14:48 +0100
--- a/debian/README.source
+++ b/debian/README.source
@ -1,10 +0,0 @@
-libhermit for Debian
-------------------
-
-<this file describes information about the source package, see Debian policy
-manual section 4.14. You WILL either need to modify or delete this file>
-
-
-
- -- Stefan Lankes <slankes@eonerc.rwth-aachen.de>  Sun, 08 Jan 2017 19:14:48 +0100
-
--- a/debian/changelog
+++ b/debian/changelog
@ -1,5 +0,0 @@
-libhermit (0.1-1) unstable; urgency=medium
-
-  * Initial release (Closes: #nnnn)  <nnnn is the bug number of your ITP>
-
- -- Stefan Lankes <slankes@eonerc.rwth-aachen.de>  Sun, 08 Jan 2017 19:14:48 +0100
--- a/debian/compat
+++ b/debian/compat
@ -1 +0,0 @@
-9
--- a/debian/control
+++ b/debian/control
@ -1,15 +0,0 @@
-Source: libhermit
-Section: devel
-Priority: optional
-Maintainer: Stefan Lankes <slankes@eonerc.rwth-aachen.de>
-Build-Depends: debhelper (>=9),autotools-dev
-Standards-Version: 3.9.6
-Homepage: http://www.hermitcore.org
-#Vcs-Git: git://anonscm.debian.org/collab-maint/libhermit.git
-#Vcs-Browser: https://anonscm.debian.org/cgit/collab-maint/libhermit.git
-
-Package: libhermit
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: A Unikernel for Extreme-Scale Computing
- 
--- a/debian/copyright
+++ b/debian/copyright
@ -1,54 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: libhermit
-Source: http://www.hermitcore.org
-
-Files: *
-Copyright: 2010-2017 Stefan Lankes <slankes@eonerc.rwth-aachen.de>
-License: Revised BSD License
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the University nor the names of its contributors
-      may be used to endorse or promote products derived from this
-      software without specific prior written permission.
- .
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# If you want to use GPL v2 or later for the /debian/* files use 
-# the following clauses, or change it to suit. Delete these two lines
-Files: debian/*
-Copyright: 2017 Stefan Lankes <slankes@eonerc.rwth-aachen.de>
-License: GPL-2+
- This package is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- .
- This package is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- .
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <https://www.gnu.org/licenses/>
- .
- On Debian systems, the complete text of the GNU General
- Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
-
-# Please also look if there are files or directories which have a
-# different copyright/license attached and list them here.
-# Please avoid picking licenses with terms that are more restrictive than the
-# packaged work, as it may make Debian's contributions unacceptable upstream.
--- a/debian/init.d.ex
+++ b/debian/init.d.ex
@ -1,26 +0,0 @@
-#!/bin/sh
-# kFreeBSD do not accept scripts as interpreters, using #!/bin/sh and sourcing.
-if [ true != "$INIT_D_SCRIPT_SOURCED" ] ; then
-    set "$0" "$@"; INIT_D_SCRIPT_SOURCED=true . /lib/init/init-d-script
-fi
-### BEGIN INIT INFO
-# Provides:          libhermit
-# Required-Start:    $remote_fs $syslog
-# Required-Stop:     $remote_fs $syslog
-# Default-Start:     2 3 4 5
-# Default-Stop:      0 1 6
-# Short-Description: <Enter a short description of the software>
-# Description:       <Enter a long description of the software>
-#                    <...>
-#                    <...>
-### END INIT INFO
-
-# Author: Stefan Lankes <slankes@eonerc.rwth-aachen.de>
-
-DESC="libhermit"
-DAEMON=/usr/bin/libhermit
-
-# This is an example to start a single forking daemon capable of writing
-# a pid file. To get other behaviors, implement do_start(), do_stop() or
-# other functions to override the defaults in /lib/init/init-d-script.
-# See also init-d-script(5)
--- a/debian/libhermit-docs.docs
+++ b/debian/libhermit-docs.docs
@ -1,2 +0,0 @@
-README.Debian
-README.source
--- a/debian/libhermit.cron.d.ex
+++ b/debian/libhermit.cron.d.ex
@ -1,4 +0,0 @@
-#
-# Regular cron jobs for the libhermit package
-#
-0 4	* * *	root	[ -x /usr/bin/libhermit_maintenance ] && /usr/bin/libhermit_maintenance
--- a/debian/libhermit.default.ex
+++ b/debian/libhermit.default.ex
@ -1,10 +0,0 @@
-# Defaults for libhermit initscript
-# sourced by /etc/init.d/libhermit
-# installed at /etc/default/libhermit by the maintainer scripts
-
-#
-# This is a POSIX shell fragment
-#
-
-# Additional options that are passed to the Daemon.
-DAEMON_OPTS=""
--- a/debian/libhermit.doc-base.EX
+++ b/debian/libhermit.doc-base.EX
@ -1,20 +0,0 @@
-Document: libhermit
-Title: Debian libhermit Manual
-Author: <insert document author here>
-Abstract: This manual describes what libhermit is
- and how it can be used to
- manage online manuals on Debian systems.
-Section: unknown
-
-Format: debiandoc-sgml
-Files: /usr/share/doc/libhermit/libhermit.sgml.gz
-
-Format: postscript
-Files: /usr/share/doc/libhermit/libhermit.ps.gz
-
-Format: text
-Files: /usr/share/doc/libhermit/libhermit.text.gz
-
-Format: HTML
-Index: /usr/share/doc/libhermit/html/index.html
-Files: /usr/share/doc/libhermit/html/*.html
--- a/debian/manpage.1.ex
+++ b/debian/manpage.1.ex
@ -1,56 +0,0 @@
-.\"                                      Hey, EMACS: -*- nroff -*-
-.\" (C) Copyright 2017 Stefan Lankes <slankes@eonerc.rwth-aachen.de>,
-.\"
-.\" First parameter, NAME, should be all caps
-.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
-.\" other parameters are allowed: see man(7), man(1)
-.TH Libhermit SECTION "January  8 2017"
-.\" Please adjust this date whenever revising the manpage.
-.\"
-.\" Some roff macros, for reference:
-.\" .nh        disable hyphenation
-.\" .hy        enable hyphenation
-.\" .ad l      left justify
-.\" .ad b      justify to both left and right margins
-.\" .nf        disable filling
-.\" .fi        enable filling
-.\" .br        insert line break
-.\" .sp <n>    insert n+1 empty lines
-.\" for manpage-specific macros, see man(7)
-.SH NAME
-libhermit \- program to do something
-.SH SYNOPSIS
-.B libhermit
-.RI [ options ] " files" ...
-.br
-.B bar
-.RI [ options ] " files" ...
-.SH DESCRIPTION
-This manual page documents briefly the
-.B libhermit
-and
-.B bar
-commands.
-.PP
-.\" TeX users may be more comfortable with the \fB<whatever>\fP and
-.\" \fI<whatever>\fP escape sequences to invode bold face and italics,
-.\" respectively.
-\fBlibhermit\fP is a program that...
-.SH OPTIONS
-These programs follow the usual GNU command line syntax, with long
-options starting with two dashes (`-').
-A summary of options is included below.
-For a complete description, see the Info files.
-.TP
-.B \-h, \-\-help
-Show summary of options.
-.TP
-.B \-v, \-\-version
-Show version of program.
-.SH SEE ALSO
-.BR bar (1),
-.BR baz (1).
-.br
-The programs are documented fully by
-.IR "The Rise and Fall of a Fooish Bar" ,
-available via the Info system.
--- a/debian/manpage.sgml.ex
+++ b/debian/manpage.sgml.ex
@ -1,154 +0,0 @@
-<!doctype refentry PUBLIC "-//OASIS//DTD DocBook V4.1//EN" [
-
-<!-- Process this file with docbook-to-man to generate an nroff manual
-     page: `docbook-to-man manpage.sgml > manpage.1'.  You may view
-     the manual page with: `docbook-to-man manpage.sgml | nroff -man |
-     less'.  A typical entry in a Makefile or Makefile.am is:
-
-manpage.1: manpage.sgml
-	docbook-to-man $< > $@
-
-
-	The docbook-to-man binary is found in the docbook-to-man package.
-	Please remember that if you create the nroff version in one of the
-	debian/rules file targets (such as build), you will need to include
-	docbook-to-man in your Build-Depends control field.
-
-  -->
-
-  <!-- Fill in your name for FIRSTNAME and SURNAME. -->
-  <!ENTITY dhfirstname "<firstname>FIRSTNAME</firstname>">
-  <!ENTITY dhsurname   "<surname>SURNAME</surname>">
-  <!-- Please adjust the date whenever revising the manpage. -->
-  <!ENTITY dhdate      "<date>January  8 2017</date>">
-  <!-- SECTION should be 1-8, maybe w/ subsection other parameters are
-       allowed: see man(7), man(1). -->
-  <!ENTITY dhsection   "<manvolnum>SECTION</manvolnum>">
-  <!ENTITY dhemail     "<email>slankes@eonerc.rwth-aachen.de</email>">
-  <!ENTITY dhusername  "Stefan Lankes">
-  <!ENTITY dhucpackage "<refentrytitle>Libhermit</refentrytitle>">
-  <!ENTITY dhpackage   "libhermit">
-
-  <!ENTITY debian      "<productname>Debian</productname>">
-  <!ENTITY gnu         "<acronym>GNU</acronym>">
-  <!ENTITY gpl         "&gnu; <acronym>GPL</acronym>">
-]>
-
-<refentry>
-  <refentryinfo>
-    <address>
-      &dhemail;
-    </address>
-    <author>
-      &dhfirstname;
-      &dhsurname;
-    </author>
-    <copyright>
-      <year>2003</year>
-      <holder>&dhusername;</holder>
-    </copyright>
-    &dhdate;
-  </refentryinfo>
-  <refmeta>
-    &dhucpackage;
-
-    &dhsection;
-  </refmeta>
-  <refnamediv>
-    <refname>&dhpackage;</refname>
-
-    <refpurpose>program to do something</refpurpose>
-  </refnamediv>
-  <refsynopsisdiv>
-    <cmdsynopsis>
-      <command>&dhpackage;</command>
-
-      <arg><option>-e <replaceable>this</replaceable></option></arg>
-
-      <arg><option>--example <replaceable>that</replaceable></option></arg>
-    </cmdsynopsis>
-  </refsynopsisdiv>
-  <refsect1>
-    <title>DESCRIPTION</title>
-
-    <para>This manual page documents briefly the
-      <command>&dhpackage;</command> and <command>bar</command>
-      commands.</para>
-
-    <para>This manual page was written for the &debian; distribution
-      because the original program does not have a manual page.
-      Instead, it has documentation in the &gnu;
-      <application>Info</application> format; see below.</para>
-
-    <para><command>&dhpackage;</command> is a program that...</para>
-
-  </refsect1>
-  <refsect1>
-    <title>OPTIONS</title>
-
-    <para>These programs follow the usual &gnu; command line syntax,
-      with long options starting with two dashes (`-').  A summary of
-      options is included below.  For a complete description, see the
-      <application>Info</application> files.</para>
-
-    <variablelist>
-      <varlistentry>
-        <term><option>-h</option>
-          <option>--help</option>
-        </term>
-        <listitem>
-          <para>Show summary of options.</para>
-        </listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><option>-v</option>
-          <option>--version</option>
-        </term>
-        <listitem>
-          <para>Show version of program.</para>
-        </listitem>
-      </varlistentry>
-    </variablelist>
-  </refsect1>
-  <refsect1>
-    <title>SEE ALSO</title>
-
-    <para>bar (1), baz (1).</para>
-
-    <para>The programs are documented fully by <citetitle>The Rise and
-      Fall of a Fooish Bar</citetitle> available via the
-      <application>Info</application> system.</para>
-  </refsect1>
-  <refsect1>
-    <title>AUTHOR</title>
-
-    <para>This manual page was written by &dhusername; &dhemail; for
-      the &debian; system (and may be used by others).  Permission is
-      granted to copy, distribute and/or modify this document under
-      the terms of the &gnu; General Public License, Version 2 any
-      later version published by the Free Software Foundation.
-    </para>
-    <para>
-      On Debian systems, the complete text of the GNU General Public
-      License can be found in /usr/share/common-licenses/GPL.
-    </para>
-
-  </refsect1>
-</refentry>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-omittag:t
-sgml-shorttag:t
-sgml-minimize-attributes:nil
-sgml-always-quote-attributes:t
-sgml-indent-step:2
-sgml-indent-data:t
-sgml-parent-document:nil
-sgml-default-dtd-file:nil
-sgml-exposed-tags:nil
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-End:
-->
--- a/debian/manpage.xml.ex
+++ b/debian/manpage.xml.ex
@ -1,291 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
-"http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" [
-
-<!--
-
-`xsltproc -''-nonet \
-          -''-param man.charmap.use.subset "0" \
-          -''-param make.year.ranges "1" \
-          -''-param make.single.year.ranges "1" \
-          /usr/share/xml/docbook/stylesheet/docbook-xsl/manpages/docbook.xsl \
-          manpage.xml'
-
-A manual page <package>.<section> will be generated. You may view the
-manual page with: nroff -man <package>.<section> | less'. A typical entry
-in a Makefile or Makefile.am is:
-
-DB2MAN = /usr/share/sgml/docbook/stylesheet/xsl/docbook-xsl/manpages/docbook.xsl
-XP     = xsltproc -''-nonet -''-param man.charmap.use.subset "0"
-
-manpage.1: manpage.xml
-        $(XP) $(DB2MAN) $<
-
-The xsltproc binary is found in the xsltproc package. The XSL files are in
-docbook-xsl. A description of the parameters you can use can be found in the
-docbook-xsl-doc-* packages. Please remember that if you create the nroff
-version in one of the debian/rules file targets (such as build), you will need
-to include xsltproc and docbook-xsl in your Build-Depends control field.
-Alternatively use the xmlto command/package. That will also automatically
-pull in xsltproc and docbook-xsl.
-
-Notes for using docbook2x: docbook2x-man does not automatically create the
-AUTHOR(S) and COPYRIGHT sections. In this case, please add them manually as
-<refsect1> ... </refsect1>.
-
-To disable the automatic creation of the AUTHOR(S) and COPYRIGHT sections
-read /usr/share/doc/docbook-xsl/doc/manpages/authors.html. This file can be
-found in the docbook-xsl-doc-html package.
-
-Validation can be done using: `xmllint -''-noout -''-valid manpage.xml`
-
-General documentation about man-pages and man-page-formatting:
-man(1), man(7), http://www.tldp.org/HOWTO/Man-Page/
-
-->
-
-  <!-- Fill in your name for FIRSTNAME and SURNAME. -->
-  <!ENTITY dhfirstname "FIRSTNAME">
-  <!ENTITY dhsurname   "SURNAME">
-  <!-- dhusername could also be set to "&dhfirstname; &dhsurname;". -->
-  <!ENTITY dhusername  "Stefan Lankes">
-  <!ENTITY dhemail     "slankes@eonerc.rwth-aachen.de">
-  <!-- SECTION should be 1-8, maybe w/ subsection other parameters are
-       allowed: see man(7), man(1) and
-       http://www.tldp.org/HOWTO/Man-Page/q2.html. -->
-  <!ENTITY dhsection   "SECTION">
-  <!-- TITLE should be something like "User commands" or similar (see
-       http://www.tldp.org/HOWTO/Man-Page/q2.html). -->
-  <!ENTITY dhtitle     "libhermit User Manual">
-  <!ENTITY dhucpackage "Libhermit">
-  <!ENTITY dhpackage   "libhermit">
-]>
-
-<refentry>
-  <refentryinfo>
-    <title>&dhtitle;</title>
-    <productname>&dhpackage;</productname>
-    <authorgroup>
-      <author>
-       <firstname>&dhfirstname;</firstname>
-        <surname>&dhsurname;</surname>
-        <contrib>Wrote this manpage for the Debian system.</contrib>
-        <address>
-          <email>&dhemail;</email>
-        </address>
-      </author>
-    </authorgroup>
-    <copyright>
-      <year>2007</year>
-      <holder>&dhusername;</holder>
-    </copyright>
-    <legalnotice>
-      <para>This manual page was written for the Debian system
-        (and may be used by others).</para>
-      <para>Permission is granted to copy, distribute and/or modify this
-        document under the terms of the GNU General Public License,
-        Version 2 or (at your option) any later version published by
-        the Free Software Foundation.</para>
-      <para>On Debian systems, the complete text of the GNU General Public
-        License can be found in
-        <filename>/usr/share/common-licenses/GPL</filename>.</para>
-    </legalnotice>
-  </refentryinfo>
-  <refmeta>
-    <refentrytitle>&dhucpackage;</refentrytitle>
-    <manvolnum>&dhsection;</manvolnum>
-  </refmeta>
-  <refnamediv>
-    <refname>&dhpackage;</refname>
-    <refpurpose>program to do something</refpurpose>
-  </refnamediv>
-  <refsynopsisdiv>
-    <cmdsynopsis>
-      <command>&dhpackage;</command>
-      <!-- These are several examples, how syntaxes could look -->
-      <arg choice="plain"><option>-e <replaceable>this</replaceable></option></arg>
-      <arg choice="opt"><option>--example=<parameter>that</parameter></option></arg>
-      <arg choice="opt">
-        <group choice="req">
-          <arg choice="plain"><option>-e</option></arg>
-          <arg choice="plain"><option>--example</option></arg>
-        </group>
-        <replaceable class="option">this</replaceable>
-      </arg>
-      <arg choice="opt">
-        <group choice="req">
-          <arg choice="plain"><option>-e</option></arg>
-          <arg choice="plain"><option>--example</option></arg>
-        </group>
-        <group choice="req">
-          <arg choice="plain"><replaceable>this</replaceable></arg>
-          <arg choice="plain"><replaceable>that</replaceable></arg>
-        </group>
-      </arg>
-    </cmdsynopsis>
-    <cmdsynopsis>
-      <command>&dhpackage;</command>
-      <!-- Normally the help and version options make the programs stop
-           right after outputting the requested information. -->
-      <group choice="opt">
-        <arg choice="plain">
-          <group choice="req">
-            <arg choice="plain"><option>-h</option></arg>
-            <arg choice="plain"><option>--help</option></arg>
-          </group>
-        </arg>
-        <arg choice="plain">
-          <group choice="req">
-            <arg choice="plain"><option>-v</option></arg>
-            <arg choice="plain"><option>--version</option></arg>
-          </group>
-        </arg>
-      </group>
-    </cmdsynopsis>
-  </refsynopsisdiv>
-  <refsect1 id="description">
-    <title>DESCRIPTION</title>
-    <para>This manual page documents briefly the
-      <command>&dhpackage;</command> and <command>bar</command>
-      commands.</para>
-    <para>This manual page was written for the Debian distribution
-      because the original program does not have a manual page.
-      Instead, it has documentation in the GNU <citerefentry>
-        <refentrytitle>info</refentrytitle>
-        <manvolnum>1</manvolnum>
-      </citerefentry> format; see below.</para>
-    <para><command>&dhpackage;</command> is a program that...</para>
-  </refsect1>
-  <refsect1 id="options">
-    <title>OPTIONS</title>
-    <para>The program follows the usual GNU command line syntax,
-      with long options starting with two dashes (`-').  A summary of
-      options is included below.  For a complete description, see the
-      <citerefentry>
-        <refentrytitle>info</refentrytitle>
-        <manvolnum>1</manvolnum>
-      </citerefentry> files.</para>
-    <variablelist>
-      <!-- Use the variablelist.term.separator and the
-           variablelist.term.break.after parameters to
-           control the term elements. -->
-      <varlistentry>
-        <term><option>-e <replaceable>this</replaceable></option></term>
-        <term><option>--example=<replaceable>that</replaceable></option></term>
-        <listitem>
-          <para>Does this and that.</para>
-        </listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><option>-h</option></term>
-        <term><option>--help</option></term>
-        <listitem>
-          <para>Show summary of options.</para>
-        </listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><option>-v</option></term>
-        <term><option>--version</option></term>
-        <listitem>
-          <para>Show version of program.</para>
-        </listitem>
-      </varlistentry>
-    </variablelist>
-  </refsect1>
-  <refsect1 id="files">
-    <title>FILES</title>
-    <variablelist>
-      <varlistentry>
-        <term><filename>/etc/foo.conf</filename></term>
-        <listitem>
-          <para>The system-wide configuration file to control the
-            behaviour of <application>&dhpackage;</application>. See
-            <citerefentry>
-              <refentrytitle>foo.conf</refentrytitle>
-              <manvolnum>5</manvolnum>
-            </citerefentry> for further details.</para>
-        </listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><filename>${HOME}/.foo.conf</filename></term>
-        <listitem>
-          <para>The per-user configuration file to control the
-             behaviour of <application>&dhpackage;</application>. See
-             <citerefentry>
-               <refentrytitle>foo.conf</refentrytitle>
-               <manvolnum>5</manvolnum>
-             </citerefentry> for further details.</para>
-        </listitem>
-      </varlistentry>
-    </variablelist>
-  </refsect1>
-  <refsect1 id="environment">
-    <title>ENVIRONMENT</title>
-    <variablelist>
-      <varlistentry>
-        <term><envar>FOO_CONF</envar></term>
-        <listitem>
-          <para>If used, the defined file is used as configuration
-            file (see also <xref linkend="files"/>).</para>
-        </listitem>
-      </varlistentry>
-    </variablelist>
-  </refsect1>
-  <refsect1 id="diagnostics">
-    <title>DIAGNOSTICS</title>
-    <para>The following diagnostics may be issued
-      on <filename class="devicefile">stderr</filename>:</para>
-    <variablelist>
-      <varlistentry>
-        <term><errortext>Bad configuration file. Exiting.</errortext></term>
-        <listitem>
-          <para>The configuration file seems to contain a broken configuration
-            line. Use the <option>--verbose</option> option, to get more info.
-          </para>
-        </listitem>
-      </varlistentry>
-    </variablelist>
-    <para><command>&dhpackage;</command> provides some return codes, that can
-      be used in scripts:</para>
-    <segmentedlist>
-      <segtitle>Code</segtitle>
-      <segtitle>Diagnostic</segtitle>
-      <seglistitem>
-        <seg><errorcode>0</errorcode></seg>
-        <seg>Program exited successfully.</seg>
-      </seglistitem>
-      <seglistitem>
-        <seg><errorcode>1</errorcode></seg>
-        <seg>The configuration file seems to be broken.</seg>
-      </seglistitem>
-    </segmentedlist>
-  </refsect1>
-  <refsect1 id="bugs">
-    <!-- Or use this section to tell about upstream BTS. -->
-    <title>BUGS</title>
-    <para>The program is currently limited to only work
-      with the <package>foobar</package> library.</para>
-    <para>The upstreams <acronym>BTS</acronym> can be found
-      at <ulink url="http://bugzilla.foo.tld"/>.</para>
-  </refsect1>
-  <refsect1 id="see_also">
-    <title>SEE ALSO</title>
-    <!-- In alpabetical order. -->
-    <para><citerefentry>
-        <refentrytitle>bar</refentrytitle>
-        <manvolnum>1</manvolnum>
-      </citerefentry>, <citerefentry>
-        <refentrytitle>baz</refentrytitle>
-        <manvolnum>1</manvolnum>
-      </citerefentry>, <citerefentry>
-        <refentrytitle>foo.conf</refentrytitle>
-        <manvolnum>5</manvolnum>
-      </citerefentry></para>
-    <para>The programs are documented fully by <citetitle>The Rise and
-      Fall of a Fooish Bar</citetitle> available via the <citerefentry>
-        <refentrytitle>info</refentrytitle>
-        <manvolnum>1</manvolnum>
-      </citerefentry> system.</para>
-  </refsect1>
-</refentry>
-
--- a/debian/menu.ex
+++ b/debian/menu.ex
@ -1,2 +0,0 @@
-?package(libhermit):needs="X11|text|vc|wm" section="Applications/see-menu-manual"\
-  title="libhermit" command="/usr/bin/libhermit"
--- a/debian/postinst.ex
+++ b/debian/postinst.ex
@ -1,39 +0,0 @@
-#!/bin/sh
-# postinst script for libhermit
-#
-# see: dh_installdeb(1)
-
-set -e
-
-# summary of how this script can be called:
-#        * <postinst> `configure' <most-recently-configured-version>
-#        * <old-postinst> `abort-upgrade' <new version>
-#        * <conflictor's-postinst> `abort-remove' `in-favour' <package>
-#          <new-version>
-#        * <postinst> `abort-remove'
-#        * <deconfigured's-postinst> `abort-deconfigure' `in-favour'
-#          <failed-install-package> <version> `removing'
-#          <conflicting-package> <version>
-# for details, see https://www.debian.org/doc/debian-policy/ or
-# the debian-policy package
-
-
-case "$1" in
-    configure)
-    ;;
-
-    abort-upgrade|abort-remove|abort-deconfigure)
-    ;;
-
-    *)
-        echo "postinst called with unknown argument \`$1'" >&2
-        exit 1
-    ;;
-esac
-
-# dh_installdeb will replace this with shell code automatically
-# generated by other debhelper scripts.
-
-#DEBHELPER#
-
-exit 0
--- a/debian/postrm.ex
+++ b/debian/postrm.ex
@ -1,37 +0,0 @@
-#!/bin/sh
-# postrm script for libhermit
-#
-# see: dh_installdeb(1)
-
-set -e
-
-# summary of how this script can be called:
-#        * <postrm> `remove'
-#        * <postrm> `purge'
-#        * <old-postrm> `upgrade' <new-version>
-#        * <new-postrm> `failed-upgrade' <old-version>
-#        * <new-postrm> `abort-install'
-#        * <new-postrm> `abort-install' <old-version>
-#        * <new-postrm> `abort-upgrade' <old-version>
-#        * <disappearer's-postrm> `disappear' <overwriter>
-#          <overwriter-version>
-# for details, see https://www.debian.org/doc/debian-policy/ or
-# the debian-policy package
-
-
-case "$1" in
-    purge|remove|upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
-    ;;
-
-    *)
-        echo "postrm called with unknown argument \`$1'" >&2
-        exit 1
-    ;;
-esac
-
-# dh_installdeb will replace this with shell code automatically
-# generated by other debhelper scripts.
-
-#DEBHELPER#
-
-exit 0
--- a/debian/preinst.ex
+++ b/debian/preinst.ex
@ -1,35 +0,0 @@
-#!/bin/sh
-# preinst script for libhermit
-#
-# see: dh_installdeb(1)
-
-set -e
-
-# summary of how this script can be called:
-#        * <new-preinst> `install'
-#        * <new-preinst> `install' <old-version>
-#        * <new-preinst> `upgrade' <old-version>
-#        * <old-preinst> `abort-upgrade' <new-version>
-# for details, see https://www.debian.org/doc/debian-policy/ or
-# the debian-policy package
-
-
-case "$1" in
-    install|upgrade)
-    ;;
-
-    abort-upgrade)
-    ;;
-
-    *)
-        echo "preinst called with unknown argument \`$1'" >&2
-        exit 1
-    ;;
-esac
-
-# dh_installdeb will replace this with shell code automatically
-# generated by other debhelper scripts.
-
-#DEBHELPER#
-
-exit 0
--- a/debian/prerm.ex
+++ b/debian/prerm.ex
@ -1,38 +0,0 @@
-#!/bin/sh
-# prerm script for libhermit
-#
-# see: dh_installdeb(1)
-
-set -e
-
-# summary of how this script can be called:
-#        * <prerm> `remove'
-#        * <old-prerm> `upgrade' <new-version>
-#        * <new-prerm> `failed-upgrade' <old-version>
-#        * <conflictor's-prerm> `remove' `in-favour' <package> <new-version>
-#        * <deconfigured's-prerm> `deconfigure' `in-favour'
-#          <package-being-installed> <version> `removing'
-#          <conflicting-package> <version>
-# for details, see https://www.debian.org/doc/debian-policy/ or
-# the debian-policy package
-
-
-case "$1" in
-    remove|upgrade|deconfigure)
-    ;;
-
-    failed-upgrade)
-    ;;
-
-    *)
-        echo "prerm called with unknown argument \`$1'" >&2
-        exit 1
-    ;;
-esac
-
-# dh_installdeb will replace this with shell code automatically
-# generated by other debhelper scripts.
-
-#DEBHELPER#
-
-exit 0
--- a/debian/rules
+++ b/debian/rules
@ -1,36 +0,0 @@
-#!/usr/bin/make -f
-# See debhelper(7) (uncomment to enable)
-# output every command that modifies files on the build system.
-#export DH_VERBOSE = 1
-
-# see FEATURE AREAS in dpkg-buildflags(1)
-#export DEB_BUILD_MAINT_OPTIONS = hardening=+all
-export DEB_BUILD_OPTS = nocheck
-
-%:
-	dh $@ #--parallel
-
-override_dh_auto_configure:
-	./configure --prefix=`pwd`/debian/libhermit/opt/hermit
-
-override_dh_auto_build:
-	# this target is somehow not executed by dh_auto_build and thus the build fails
-	make arch/x86/kernel/boot.h
-
-	dh_auto_build
-	make libs
-
-override_dh_auto_test:
-	@echo "tests are disabled"
-
-override_dh_auto_install:
-	#make install_libhermit
-	make install
-
-	# delete unneded files that would cause conflicts
-	rm -rf `-pwd`/debian/libhermit/opt/hermit/share/info/dir
-
-override_dh_strip:
-	# stripping will incorrectly use system tools for stripping, generating
-	# wrong binary format, i.e. not for HermitCore
-	@echo "No stripping"
--- a/debian/source/format
+++ b/debian/source/format
@ -1 +0,0 @@
-3.0 (quilt)
--- a/debian/watch.ex
+++ b/debian/watch.ex
@ -1,39 +0,0 @@
-# Example watch control file for uscan
-# Rename this file to "watch" and then you can run the "uscan" command
-# to check for upstream updates and more.
-# See uscan(1) for format
-
-# Compulsory line, this is a version 4 file
-version=4
-
-# PGP signature mangle, so foo.tar.gz has foo.tar.gz.sig
-#opts="pgpsigurlmangle=s%$%.sig%"
-
-# HTTP site (basic)
-#http://example.com/downloads.html \
-#  files/libhermit-([\d\.]+)\.tar\.gz debian uupdate
-
-# Uncommment to examine a FTP server
-#ftp://ftp.example.com/pub/libhermit-(.*)\.tar\.gz debian uupdate
-
-# SourceForge hosted projects
-# http://sf.net/libhermit/ libhermit-(.*)\.tar\.gz debian uupdate
-
-# GitHub hosted projects
-#opts="filenamemangle="s%(?:.*?)?v?(\d[\d.]*)\.tar\.gz%<project>-$1.tar.gz%" \
-#   https://github.com/<user>/libhermit/tags \
-#   (?:.*?/)?v?(\d[\d.]*)\.tar\.gz debian uupdate
-
-# PyPI
-# https://pypi.python.org/packages/source/<initial>/libhermit/ \
-#   libhermit-(.+)\.tar\.gz debian uupdate
-
-# Direct Git
-# opts="mode=git" http://git.example.com/libhermit.git \
-#   refs/tags/v([\d\.]+) debian uupdate
-
-
-
-
-# Uncomment to find new files on GooglePages
-# http://example.googlepages.com/foo.html libhermit-(.*)\.tar\.gz
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@ -1,4 +0,0 @@
-C_source := mmnif.c util.c e1000.c rtl8139.c
-MODULE := drivers_net
-
-include $(TOPDIR)/Makefile.inc
--- a/include/hermit/CMakeLists.txt
+++ b/include/hermit/CMakeLists.txt
@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.7)
+
+configure_file(config.h.in config.h)
+configure_file(config.asm.in config.asm)
+
+# Show include files in IDE
+file(GLOB_RECURSE HERMIT_INCLUDES "*")
+add_custom_target(hermit_includes_ide SOURCES ${HERMIT_INCLUDES})
--- a/include/hermit/config.asm.in
+++ b/include/hermit/config.asm.in
@ -0,0 +1,3 @@
+%define MAX_CORES			@MAX_CORES@
+%define KERNEL_STACK_SIZE	@KERNEL_STACK_SIZE@
+%define SAVE_FPU			@SAVE_FPU@
--- a/include/hermit/config.h.in
+++ b/include/hermit/config.h.in
@ -1,50 +1,25 @@
-/* include/hermit/config.h.in.  Generated from configure.ac by autoheader.  */
+#cmakedefine MAX_CORES			(@MAX_CORES@)
+#cmakedefine MAX_TASKS			(@MAX_TASKS@)
+#cmakedefine MAX_ISLE			(@MAX_ISLE@)
+#cmakedefine KERNEL_STACK_SIZE	(@KERNEL_STACK_SIZE@)
+#cmakedefine DEFAULT_STACK_SIZE	(@DEFAULT_STACK_SIZE@)
+#cmakedefine PACKAGE_VERSION 	"@PACKAGE_VERSION@"

-#undef MAX_CORES
-#undef MAX_TASKS
-#undef MAX_ISLE
-#undef MAX_FNAME
-#undef SAVE_FPU
-#undef VIDEO_MEM_ADDR
+#cmakedefine SAVE_FPU
+
+#cmakedefine DYNAMIC_TICKS

 /* Define to use machine specific version of memcpy */
-#undef HAVE_ARCH_MEMCPY
+#cmakedefine HAVE_ARCH_MEMCPY

 /* Define to use machine specific version of memset */
-#undef HAVE_ARCH_MEMSET
+#cmakedefine HAVE_ARCH_MEMSET

 /* Define to use machine specific version of strcpy */
-#undef HAVE_ARCH_STRCPY
+#cmakedefine HAVE_ARCH_STRCPY

 /* Define to use machine specific version of strlen */
-#undef HAVE_ARCH_STRLEN
+#cmakedefine HAVE_ARCH_STRLEN

 /* Define to use machine specific version of strncpy */
-#undef HAVE_ARCH_STRNCPY
-
-/* Define the stack size of the idle task */
-#undef KERNEL_STACK_SIZE
-
-/* Define the default stack size */
-#undef DEFAULT_STACK_SIZE
-
-/* Define the maximum number of running tasks */
-#undef MAX_TASKS
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
+#cmakedefine HAVE_ARCH_STRNCPY
--- a/501
+++ b/501
@ -1,501 +0,0 @@
-#!/bin/sh
-# install - install a program, script, or datafile
-
-scriptversion=2013-12-25.23; # UTC
-
-# This originates from X11R5 (mit/util/scripts/install.sh), which was
-# later released in X11R6 (xc/config/util/install.sh) with the
-# following copyright and license.
-#
-# Copyright (C) 1994 X Consortium
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
-# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Except as contained in this notice, the name of the X Consortium shall not
-# be used in advertising or otherwise to promote the sale, use or other deal-
-# ings in this Software without prior written authorization from the X Consor-
-# tium.
-#
-#
-# FSF changes to this file are in the public domain.
-#
-# Calling this script install-sh is preferred over install.sh, to prevent
-# 'make' implicit rules from creating a file called install from it
-# when there is no Makefile.
-#
-# This script is compatible with the BSD install script, but was written
-# from scratch.
-
-tab='	'
-nl='
-'
-IFS=" $tab$nl"
-
-# Set DOITPROG to "echo" to test this script.
-
-doit=${DOITPROG-}
-doit_exec=${doit:-exec}
-
-# Put in absolute file names if you don't have them in your path;
-# or use environment vars.
-
-chgrpprog=${CHGRPPROG-chgrp}
-chmodprog=${CHMODPROG-chmod}
-chownprog=${CHOWNPROG-chown}
-cmpprog=${CMPPROG-cmp}
-cpprog=${CPPROG-cp}
-mkdirprog=${MKDIRPROG-mkdir}
-mvprog=${MVPROG-mv}
-rmprog=${RMPROG-rm}
-stripprog=${STRIPPROG-strip}
-
-posix_mkdir=
-
-# Desired mode of installed file.
-mode=0755
-
-chgrpcmd=
-chmodcmd=$chmodprog
-chowncmd=
-mvcmd=$mvprog
-rmcmd="$rmprog -f"
-stripcmd=
-
-src=
-dst=
-dir_arg=
-dst_arg=
-
-copy_on_change=false
-is_target_a_directory=possibly
-
-usage="\
-Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
-   or: $0 [OPTION]... SRCFILES... DIRECTORY
-   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
-   or: $0 [OPTION]... -d DIRECTORIES...
-
-In the 1st form, copy SRCFILE to DSTFILE.
-In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
-In the 4th, create DIRECTORIES.
-
-Options:
-     --help     display this help and exit.
-     --version  display version info and exit.
-
-  -c            (ignored)
-  -C            install only if different (preserve the last data modification time)
-  -d            create directories instead of installing files.
-  -g GROUP      $chgrpprog installed files to GROUP.
-  -m MODE       $chmodprog installed files to MODE.
-  -o USER       $chownprog installed files to USER.
-  -s            $stripprog installed files.
-  -t DIRECTORY  install into DIRECTORY.
-  -T            report an error if DSTFILE is a directory.
-
-Environment variables override the default commands:
-  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
-  RMPROG STRIPPROG
-"
-
-while test $# -ne 0; do
-  case $1 in
-    -c) ;;
-
-    -C) copy_on_change=true;;
-
-    -d) dir_arg=true;;
-
-    -g) chgrpcmd="$chgrpprog $2"
-        shift;;
-
-    --help) echo "$usage"; exit $?;;
-
-    -m) mode=$2
-        case $mode in
-          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
-            echo "$0: invalid mode: $mode" >&2
-            exit 1;;
-        esac
-        shift;;
-
-    -o) chowncmd="$chownprog $2"
-        shift;;
-
-    -s) stripcmd=$stripprog;;
-
-    -t)
-        is_target_a_directory=always
-        dst_arg=$2
-        # Protect names problematic for 'test' and other utilities.
-        case $dst_arg in
-          -* | [=\(\)!]) dst_arg=./$dst_arg;;
-        esac
-        shift;;
-
-    -T) is_target_a_directory=never;;
-
-    --version) echo "$0 $scriptversion"; exit $?;;
-
-    --) shift
-        break;;
-
-    -*) echo "$0: invalid option: $1" >&2
-        exit 1;;
-
-    *)  break;;
-  esac
-  shift
-done
-
-# We allow the use of options -d and -T together, by making -d
-# take the precedence; this is for compatibility with GNU install.
-
-if test -n "$dir_arg"; then
-  if test -n "$dst_arg"; then
-    echo "$0: target directory not allowed when installing a directory." >&2
-    exit 1
-  fi
-fi
-
-if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
-  # When -d is used, all remaining arguments are directories to create.
-  # When -t is used, the destination is already specified.
-  # Otherwise, the last argument is the destination.  Remove it from $@.
-  for arg
-  do
-    if test -n "$dst_arg"; then
-      # $@ is not empty: it contains at least $arg.
-      set fnord "$@" "$dst_arg"
-      shift # fnord
-    fi
-    shift # arg
-    dst_arg=$arg
-    # Protect names problematic for 'test' and other utilities.
-    case $dst_arg in
-      -* | [=\(\)!]) dst_arg=./$dst_arg;;
-    esac
-  done
-fi
-
-if test $# -eq 0; then
-  if test -z "$dir_arg"; then
-    echo "$0: no input file specified." >&2
-    exit 1
-  fi
-  # It's OK to call 'install-sh -d' without argument.
-  # This can happen when creating conditional directories.
-  exit 0
-fi
-
-if test -z "$dir_arg"; then
-  if test $# -gt 1 || test "$is_target_a_directory" = always; then
-    if test ! -d "$dst_arg"; then
-      echo "$0: $dst_arg: Is not a directory." >&2
-      exit 1
-    fi
-  fi
-fi
-
-if test -z "$dir_arg"; then
-  do_exit='(exit $ret); exit $ret'
-  trap "ret=129; $do_exit" 1
-  trap "ret=130; $do_exit" 2
-  trap "ret=141; $do_exit" 13
-  trap "ret=143; $do_exit" 15
-
-  # Set umask so as not to create temps with too-generous modes.
-  # However, 'strip' requires both read and write access to temps.
-  case $mode in
-    # Optimize common cases.
-    *644) cp_umask=133;;
-    *755) cp_umask=22;;
-
-    *[0-7])
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw='% 200'
-      fi
-      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
-    *)
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw=,u+rw
-      fi
-      cp_umask=$mode$u_plus_rw;;
-  esac
-fi
-
-for src
-do
-  # Protect names problematic for 'test' and other utilities.
-  case $src in
-    -* | [=\(\)!]) src=./$src;;
-  esac
-
-  if test -n "$dir_arg"; then
-    dst=$src
-    dstdir=$dst
-    test -d "$dstdir"
-    dstdir_status=$?
-  else
-
-    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
-    # might cause directories to be created, which would be especially bad
-    # if $src (and thus $dsttmp) contains '*'.
-    if test ! -f "$src" && test ! -d "$src"; then
-      echo "$0: $src does not exist." >&2
-      exit 1
-    fi
-
-    if test -z "$dst_arg"; then
-      echo "$0: no destination specified." >&2
-      exit 1
-    fi
-    dst=$dst_arg
-
-    # If destination is a directory, append the input filename; won't work
-    # if double slashes aren't ignored.
-    if test -d "$dst"; then
-      if test "$is_target_a_directory" = never; then
-        echo "$0: $dst_arg: Is a directory" >&2
-        exit 1
-      fi
-      dstdir=$dst
-      dst=$dstdir/`basename "$src"`
-      dstdir_status=0
-    else
-      dstdir=`dirname "$dst"`
-      test -d "$dstdir"
-      dstdir_status=$?
-    fi
-  fi
-
-  obsolete_mkdir_used=false
-
-  if test $dstdir_status != 0; then
-    case $posix_mkdir in
-      '')
-        # Create intermediate dirs using mode 755 as modified by the umask.
-        # This is like FreeBSD 'install' as of 1997-10-28.
-        umask=`umask`
-        case $stripcmd.$umask in
-          # Optimize common cases.
-          *[2367][2367]) mkdir_umask=$umask;;
-          .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
-
-          *[0-7])
-            mkdir_umask=`expr $umask + 22 \
-              - $umask % 100 % 40 + $umask % 20 \
-              - $umask % 10 % 4 + $umask % 2
-            `;;
-          *) mkdir_umask=$umask,go-w;;
-        esac
-
-        # With -d, create the new directory with the user-specified mode.
-        # Otherwise, rely on $mkdir_umask.
-        if test -n "$dir_arg"; then
-          mkdir_mode=-m$mode
-        else
-          mkdir_mode=
-        fi
-
-        posix_mkdir=false
-        case $umask in
-          *[123567][0-7][0-7])
-            # POSIX mkdir -p sets u+wx bits regardless of umask, which
-            # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
-            ;;
-          *)
-            tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-            trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
-
-            if (umask $mkdir_umask &&
-                exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
-            then
-              if test -z "$dir_arg" || {
-                   # Check for POSIX incompatibilities with -m.
-                   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-                   # other-writable bit of parent directory when it shouldn't.
-                   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-                   ls_ld_tmpdir=`ls -ld "$tmpdir"`
-                   case $ls_ld_tmpdir in
-                     d????-?r-*) different_mode=700;;
-                     d????-?--*) different_mode=755;;
-                     *) false;;
-                   esac &&
-                   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
-                     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
-                     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-                   }
-                 }
-              then posix_mkdir=:
-              fi
-              rmdir "$tmpdir/d" "$tmpdir"
-            else
-              # Remove any dirs left behind by ancient mkdir implementations.
-              rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
-            fi
-            trap '' 0;;
-        esac;;
-    esac
-
-    if
-      $posix_mkdir && (
-        umask $mkdir_umask &&
-        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
-      )
-    then :
-    else
-
-      # The umask is ridiculous, or mkdir does not conform to POSIX,
-      # or it failed possibly due to a race condition.  Create the
-      # directory the slow way, step by step, checking for races as we go.
-
-      case $dstdir in
-        /*) prefix='/';;
-        [-=\(\)!]*) prefix='./';;
-        *)  prefix='';;
-      esac
-
-      oIFS=$IFS
-      IFS=/
-      set -f
-      set fnord $dstdir
-      shift
-      set +f
-      IFS=$oIFS
-
-      prefixes=
-
-      for d
-      do
-        test X"$d" = X && continue
-
-        prefix=$prefix$d
-        if test -d "$prefix"; then
-          prefixes=
-        else
-          if $posix_mkdir; then
-            (umask=$mkdir_umask &&
-             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-            # Don't fail if two instances are running concurrently.
-            test -d "$prefix" || exit 1
-          else
-            case $prefix in
-              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-              *) qprefix=$prefix;;
-            esac
-            prefixes="$prefixes '$qprefix'"
-          fi
-        fi
-        prefix=$prefix/
-      done
-
-      if test -n "$prefixes"; then
-        # Don't fail if two instances are running concurrently.
-        (umask $mkdir_umask &&
-         eval "\$doit_exec \$mkdirprog $prefixes") ||
-          test -d "$dstdir" || exit 1
-        obsolete_mkdir_used=true
-      fi
-    fi
-  fi
-
-  if test -n "$dir_arg"; then
-    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
-    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
-      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
-  else
-
-    # Make a couple of temp file names in the proper directory.
-    dsttmp=$dstdir/_inst.$$_
-    rmtmp=$dstdir/_rm.$$_
-
-    # Trap to clean up those temp files at exit.
-    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
-
-    # Copy the file name to the temp name.
-    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
-
-    # and set any options; do chmod last to preserve setuid bits.
-    #
-    # If any of these fail, we abort the whole thing.  If we want to
-    # ignore errors from any of these, just make sure not to ignore
-    # errors from the above "$doit $cpprog $src $dsttmp" command.
-    #
-    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
-    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
-    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
-
-    # If -C, don't bother to copy if it wouldn't change the file.
-    if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
-       set -f &&
-       set X $old && old=:$2:$4:$5:$6 &&
-       set X $new && new=:$2:$4:$5:$6 &&
-       set +f &&
-       test "$old" = "$new" &&
-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
-    then
-      rm -f "$dsttmp"
-    else
-      # Rename the file to the real destination.
-      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
-
-      # The rename failed, perhaps because mv can't rename something else
-      # to itself, or perhaps because mv is so ancient that it does not
-      # support -f.
-      {
-        # Now remove or move aside any old file at destination location.
-        # We try this two ways since rm can't unlink itself on some
-        # systems and the destination file might be busy for other
-        # reasons.  In this case, the final cleanup might fail but the new
-        # file should still install successfully.
-        {
-          test ! -f "$dst" ||
-          $doit $rmcmd -f "$dst" 2>/dev/null ||
-          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-            { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
-          } ||
-          { echo "$0: cannot unlink or rename $dst" >&2
-            (exit 1); exit 1
-          }
-        } &&
-
-        # Now rename the file to the real destination.
-        $doit $mvcmd "$dsttmp" "$dst"
-      }
-    fi || exit 1
-
-    trap '' 0
-  fi
-done
-
-# Local variables:
-# eval: (add-hook 'write-file-hooks 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
-# time-stamp-end: "; # UTC"
-# End:
--- a/kernel/Makefile
+++ b/kernel/Makefile
@ -1,4 +0,0 @@
-C_source := main.c tasks.c syscall.c timer.c
-MODULE := kernel
-
-include $(TOPDIR)/Makefile.inc
--- a/libkern/Makefile
+++ b/libkern/Makefile
@ -1,4 +0,0 @@
-C_source := string.c stdio.c printf.c sprintf.c strtol.c strtoul.c strstr.c
-MODULE := libkern
-
-include $(TOPDIR)/Makefile.inc
--- a/mm/Makefile
+++ b/mm/Makefile
@ -1,4 +0,0 @@
-C_source := malloc.c vma.c
-MODULE := mm
-
-include $(TOPDIR)/Makefile.inc
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.7)
+project(hermit_tools)
+
+include(../cmake/HermitCore-Paths.cmake)
+
+add_compile_options(-std=c99)
+
+add_executable(proxy proxy.c uhyve.c)
+target_link_libraries(proxy -pthread)
+
+install(TARGETS proxy
+	DESTINATION bin)
+
+install(FILES init.sh
+	DESTINATION tools)
+
+# Show include files in IDE
+file(GLOB_RECURSE TOOLS_INCLUDES "*.h")
+add_custom_target(tools_includes_ide SOURCES ${TOOLS_INCLUDES})
--- a/tools/Makefile.in
+++ b/tools/Makefile.in
@ -1,47 +0,0 @@
-MAKE = make
-CC = gcc
-CP = cp
-CFLAGS = -O2 -Wall -std=gnu99 $(ARCH_OPT)
-PROXYFILES = proxy init.sh $(shell find ../usr/tests ../usr/benchmarks ../usr/openmpbench -type f -executable)
-
-prefix = @prefix@
-INSTALL = @INSTALL@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_DATA = @INSTALL_DATA@
-
-# Prettify output
-V = 0
-ifeq ($V,0)
-	Q = @
-	P = > /dev/null
-endif
-
-# other implicit rules
-%.o : %.c
-	@echo [CC] $@
-	$Q$(CC) -c $(CFLAGS) -pthread -o $@ $<
-
-all: proxy
-
-proxy: proxy.o uhyve.o
-	@echo [LD] $@
-	$Q$(CC) $(CFLAGS) -pthread -o $@ $< uhyve.o
-
-clean:
-	@echo Cleaning tools
-	$Q$(RM) -rf *.o *~ *.bin *.obj
-
-install: proxy
-	@echo Install tools
-	$Q$(INSTALL_PROGRAM) -d $(prefix)/bin
-	$Q$(INSTALL_PROGRAM) proxy $(prefix)/bin
-	$Q$(INSTALL_DATA) ../arch/x86/loader/ldhermit.elf $(prefix)/bin
-
-veryclean: clean
-
-depend:
-	$(CC) -MM $(CFLAGS) *.c > Makefile.dep
-
-include Makefile.dep
-# DO NOT DELETE
--- a/tools/init.sh
+++ b/tools/init.sh
@ -1,6 +1,6 @@
 #!/bin/sh

-PROXY=/hermit/tools/proxy
+PROXY=/hermit/bin/proxy

 ELF_OSABI_OFFSET=7
 ELF_OSABI="\\x42"
--- a/usr/benchmarks/CMakeLists.txt
+++ b/usr/benchmarks/CMakeLists.txt
@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.7)
+include(../../cmake/HermitCore-Application.cmake)
+
+project(hermit_benchmarks C)
+
+add_executable(basic basic.c)
+target_link_libraries(basic pthread)
+
+add_executable(hg hg.c hist.c rdtsc.c run.c init.c opt.c report.c setup.c)
+
+add_executable(netio netio.c)
+
+add_executable(RCCE_pingpong RCCE_pingpong.c)
+target_link_libraries(RCCE_pingpong ircce)
+
+add_executable(stream stream.c)
+target_compile_options(stream PRIVATE -fopenmp)
+target_link_libraries(stream -fopenmp)
+
+# deployment
+install_local_targets(extra/benchmarks)
--- a/usr/benchmarks/Makefile
+++ b/usr/benchmarks/Makefile
@ -1,126 +0,0 @@
-ARCH = x86
-TARGET=x86_64-hermit
-MAKE = make
-override STRIP_DEBUG = --strip-debug #--strip-unneeded
-KEEP_DEBUG = --only-keep-debug
-
-# Set your own cross compiler tool chain prefix here
-CROSSCOMPREFIX = x86_64-hermit-
-
-CC_FOR_TARGET = $(CROSSCOMPREFIX)gcc
-CXX_FOR_TARGET = $(CROSSCOMPREFIX)g++
-GCC_FOR_TARGET = $(CROSSCOMPREFIX)gcc
-CPP_FOR_TARGET = $(CROSSCOMPREFIX)cpp
-AR_FOR_TARGET = $(CROSSCOMPREFIX)ar
-AS_FOR_TARGET = $(CROSSCOMPREFIX)as
-LD_FOR_TARGET = $(CROSSCOMPREFIX)ld
-NM_FOR_TARGET = $(CROSSCOMPREFIX)nm
-OBJDUMP_FOR_TARGET = $(CROSSCOMPREFIX)objdump
-OBJCOPY_FOR_TARGET = $(CROSSCOMPREFIX)objcopy
-RANLIB_FOR_TARGET = $(CROSSCOMPREFIX)ranlib
-STRIP_FOR_TARGET = $(CROSSCOMPREFIX)strip
-READELF_FOR_TARGET = $(CROSSCOMPREFIX)readelf
-ELFEDIT_FOR_TARGET = $(CROSSCOMPREFIX)elfedit
-
-# Prettify output
-V = 0
-ifeq ($V,0)
-	Q = @
-	P = > /dev/null
-endif
-
-ICC_EXE =
-#ICC_EXE = stream_icc
-
-# other implicit rules
-%.o : %.c
-	@echo [CC] $@
-	$Q$(CC_FOR_TARGET) -c $(CFLAGS_FOR_TARGET) -o $@ $< 
-
-%.o: %.cpp
-	@echo [CXX] $@
-	$Q$(CXX_FOR_TARGET) -c $(CXXFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -o $@ $<
-
-%.o: %.f90
-	@echo [F90] $@
-	$Q$(FC_FOR_TARGET) -c $(FFLAGS_FOR_TARGET) -o $@ $<
-
-default: all
-
-all: stream hg netio RCCE_pingping RCCE_pingpong basic $(ICC_EXE)
-
-stream.o: stream.c
-	@echo [CC] $@
-	$Q$(CC_FOR_TARGET) -c $(CFLAGS_FOR_TARGET) -fopenmp -o $@ $<
-
-stream: stream.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -fopenmp
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-stream_icc.o: stream.c
-	@echo [ICC] $@
-	icc -m64 -c -o $@ -O3 -xHost -I$(TOPDIR)/hermit/usr/x86/x86_64-hermit/include/ -openmp -ffreestanding $<
-	$Q$(ELFEDIT_FOR_TARGET) --output-osabi HermitCore $@
-
-stream_icc: stream_icc.o
-	@echo [LD]
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -fopenmp
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-basic.o: basic.c
-	@echo [CC] $@
-	$Q$(CC_FOR_TARGET) -c $(CFLAGS_FOR_TARGET) -pthread -o $@ $<
-
-basic: basic.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -pthread
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-RCCE_pingping: RCCE_pingping.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -lircce
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-RCCE_pingpong: RCCE_pingpong.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -lircce
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-netio: netio.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET)
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-hg: hg.o hist.o rdtsc.o run.o init.o opt.o report.o setup.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) hist.o rdtsc.o run.o init.o opt.o report.o setup.o
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-clean:
-	@echo Cleaning benchmarks
-	$Q$(RM) stream hg netio RCCE_pingping RCCE_pingpong *.sym *.o *~
-
-veryclean:
-	@echo Propper cleaning benchmarks
-	$Q$(RM)  stream hg RCCE_pingping RCCE_pingpong *.sym *.o *~
-
-depend:
-	$Q$(CC_FOR_TARGET) -MM $(CFLAGS_FOR_TARGET) *.c > Makefile.dep
-
-include Makefile.dep
-# DO NOT DELETE
--- a/usr/ircce/CMakeLists.txt
+++ b/usr/ircce/CMakeLists.txt
@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.7)
+include(../../cmake/HermitCore.cmake)
+
+project(hermit_ircce C)
+
+add_compile_options(${HERMIT_APP_FLAGS})
+
+file(GLOB SOURCES *.c)
+
+add_library(ircce STATIC ${SOURCES})
+
+# deployment
+install(TARGETS ircce
+	DESTINATION ${TARGET_ARCH}/lib)
+install(FILES
+			iRCCE.h iRCCE_lib.h RCCE_debug.h RCCE.h RCCE_lib.h rte_memcpy.h
+		DESTINATION
+			${TARGET_ARCH}/include)
--- a/usr/ircce/Makefile.in
+++ b/usr/ircce/Makefile.in
@ -1,56 +0,0 @@
-CROSSPREFIX = x86_64-hermit
-MAKE = make
-ARFLAGS_FOR_TARGET = rsv
-CP = cp
-C_source =  $(wildcard *.c)
-NAME = libircce.a
-OBJS = $(C_source:.c=.o)
-
-prefix = @prefix@
-INSTALL = @INSTALL@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_DATA = @INSTALL_DATA@
-
-#
-# Prettify output
-V = 0
-ifeq ($V,0)
-	Q = @
-	P = > /dev/null
-endif
-
-# other implicit rules
-%.o : %.c
-	@echo [CC] $@
-	$Q$(CC_FOR_TARGET) -c $(CFLAGS_FOR_TARGET) -o $@ $<
-
-default: all
-
-all: $(NAME)
-
-$(NAME): $(OBJS)
-	$Q$(AR_FOR_TARGET) $(ARFLAGS_FOR_TARGET) $@ $(OBJS)
-
-install:
-	$Q$(INSTALL_DATA) $(NAME) $(prefix)/$(CROSSPREFIX)/lib
-	$Q$(INSTALL_DATA) iRCCE.h $(prefix)/$(CROSSPREFIX)/include
-	$Q$(INSTALL_DATA) iRCCE_lib.h $(prefix)/$(CROSSPREFIX)/include
-	$Q$(INSTALL_DATA) RCCE_debug.h $(prefix)/$(CROSSPREFIX)/include
-	$Q$(INSTALL_DATA) RCCE.h $(prefix)/$(CROSSPREFIX)/include
-	$Q$(INSTALL_DATA) RCCE_lib.h $(prefix)/$(CROSSPREFIX)/include
-	$Q$(INSTALL_DATA) rte_memcpy.h $(prefix)/$(CROSSPREFIX)/include
-	
-clean:
-	@echo Cleaning examples
-	$Q$(RM) $(NAME) *.o *~ 
-
-veryclean:
-	@echo Propper cleaning examples
-	$Q$(RM) $(NAME) *.o *~
-
-depend:
-	$Q$(CC_FOR_TARGET) -MM $(CFLAGS_FOR_TARGET) *.c > Makefile.dep
-
-include Makefile.dep
-# DO NOT DELETE
--- a/usr/openmpbench/CMakeLists.txt
+++ b/usr/openmpbench/CMakeLists.txt
@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.7)
+include(../../cmake/HermitCore-Application.cmake)
+
+project(hermit_openmpbench C)
+
+add_executable(syncbench syncbench.c common.c)
+target_link_libraries(syncbench PUBLIC -fopenmp)
+
+add_executable(taskbench taskbench.c common.c)
+target_link_libraries(taskbench PUBLIC -fopenmp)
+
+add_library(common_sched STATIC common.c)
+target_compile_definitions(common_sched PUBLIC -DSCHEDBENCH)
+target_compile_options(common_sched PUBLIC -fopenmp)
+target_link_libraries(common_sched PUBLIC -fopenmp)
+
+add_executable(schedbench schedbench.c)
+target_link_libraries(schedbench common_sched)
+
+# deployment: exclude common_sched
+install_local_targets(extra/benchmarks common_sched)
--- a/usr/openmpbench/Makefile
+++ b/usr/openmpbench/Makefile
@ -1,59 +0,0 @@
-include Makefile.defs
-
-# If CFLAGS_CRAY is empty set it to CFLAGS
-ifeq ($(CFLAGS_CRAY),)
-CFLAGS_CRAY = ${CFLAGS}
-endif
-
-.c.o:
-	${CC} ${CFLAGS} $(OMPFLAG) -c $*.c
-
-SYNCOBJS =  syncbench.o common.o
-SCHEDOBJS = schedbench.o common_sched.o
-ARRAYOBJS = arraybench_$(IDA).o common.o
-TASKOBJS =  taskbench.o common.o
-SCHEDFLAGS = -DSCHEDBENCH
-
-all:	syncbench schedbench taskbench
-
-prog: arraybench_$(IDA)
-
-# We need to generate a linker map file so that Xray can resolve function names
-LDFLAGS += -Wl,-Map=$@.map
-
-syncbench: $(SYNCOBJS)
-	$(CC) -o syncbench $(SYNCOBJS) $(LDFLAGS) $(CLOCKOBJS) $(LIBS) -lm
-
-# Rule to ensure the lower optimisation level is picked up for common.c
-# with the Cray compiler
-common.o:
-	${CC} ${CFLAGS_CRAY} $(OMPFLAG) -c $*.c
-
-# Separate rule to build common_sched.o as we need to ensure the correct
-# DEFAULT_DELAY_TIME is used.
-common_sched.o:
-	${CC} ${CFLAGS_CRAY} $(SCHEDFLAGS) $(OMPFLAG) -o common_sched.o -c common.c
-
-schedbench: $(SCHEDOBJS)
-	$(CC) -o schedbench $(SCHEDOBJS) $(LDFLAGS) $(CLOCKOBJS) $(LIBS) -lm
-
-# Multiple header files due to multiple array sizes, makes header file arraybench_*.h
-arraybench_$(IDA).h: arraybench.h
-	$(CPP) -DIDA=$(IDA) $(OMPFLAG) -P arraybench.h -o $@
-
-# Multiple object files due to multiple array sizes, makes object file arraybench_*.o
-arraybench_$(IDA).o: arraybench_$(IDA).h arraybench.c
-	$(CC) $(CFLAGS) -DIDA=$(IDA) $(OMPFLAG) arraybench.c -c -o $@
-
-# Multiple executables due to multiple array sizes, makes exe file arraybench_*
-arraybench_$(IDA): $(ARRAYOBJS) $(CLOCKOBJS) arraybench.c
-	$(CC) -o $@ $(LDFLAGS) $(ARRAYOBJS) $(CLOCKOBJS) $(LIBS) -lm
-
-taskbench: $(TASKOBJS)
-	$(CC) -o taskbench $(TASKOBJS) $(LDFLAGS) $(OMPFLAG) $(CLOCKOBJS) $(LIBS) -lm
-
-clean:
-	-rm -rf *.o *.xray *.map syncbench schedbench arraybench_* taskbench
-
-veryclean: clean
-	-rm -rf OpenMPBench.* *.all
--- a/usr/openmpbench/Makefile.defs
+++ b/usr/openmpbench/Makefile.defs
@ -1,14 +0,0 @@
-# Uncomment the following line to use OpenMP 2.0 features
-OMPFLAG = -DOMPVER2
-# Uncomment the following line to use OpenMP 3.0 features
-#OMPFLAG = -DOMPVER2 -DOMPVER3
-
-CC = $(CC_FOR_TARGET)
-CFLAGS = -fopenmp $(CFLAGS_FOR_TARGET) -lm
-LDFLAGS = -fopenmp $(LDFLAGS_FOR_TARGET) -lm
-CPP = $(CPP_FOR_TARGET)
-ELFEDIT = $(ELFEDIT_FOR_TARGET)
-LIBS =
-
-override STRIP_DEBUG = --strip-debug #--strip-unneeded
-KEEP_DEBUG = --only-keep-debug
--- a/usr/openmpbench/Makefile.defs.hector.cray
+++ b/usr/openmpbench/Makefile.defs.hector.cray
@ -1,10 +0,0 @@
-# Uncomment the following line to use OpenMP 2.0 features
-#OMPFLAG = -DOMPVER2
-# Uncomment the following line to use OpenMP 3.0 features
-OMPFLAG = -DOMPVER2 -DOMPVER3
-
-CC=cc 
-CFLAGS = -O1 -lm
-LDFLAGS = -O0 -lm
-CPP = /usr/bin/cpp
-LIBS = 
--- a/usr/openmpbench/Makefile.defs.hector.pgi
+++ b/usr/openmpbench/Makefile.defs.hector.pgi
@ -1,12 +0,0 @@
-# Uncomment the following line to use OpenMP 2.0 features
-#OMPFLAG = -DOMPVER2
-# Uncomment the following line to use OpenMP 3.0 features
-# Nested tasks don't work on HECToR Phase 3 for the PGI compiler
-# and thus are disabled. 
-OMPFLAG = -DOMPVER2 -DOMPVER3 -DDISABLE_NESTED_TASKS_TESTS
-
-CC =cc 
-CFLAGS = -fast -mp=nonuma -lm
-LDFLAGS = -fast -mp=nonuma -lm
-CPP = /usr/bin/cpp
-LIBS = 
--- a/usr/openmpbench/Makefile.defs.magny0.gnu
+++ b/usr/openmpbench/Makefile.defs.magny0.gnu
@ -1,10 +0,0 @@
-# Uncomment the following line to use OpenMP 2.0 features
-#OMPFLAG = -DOMPVER2
-# Uncomment the following line to use OpenMP 3.0 features
-OMPFLAG = -DDISABLE_BARRIER_TEST -DOMPVER2 -DOMPVER3
-
-CC = /usr/local/bin/gcc-4.6 
-CFLAGS = -fopenmp -O1 -lm
-LDFLAGS = -fopenmp -O1 -lm
-CPP = /usr/bin/cpp
-LIBS = 
--- a/usr/openmpbench/Makefile.defs.magny0.sun
+++ b/usr/openmpbench/Makefile.defs.magny0.sun
@ -1,10 +0,0 @@
-# Uncomment the following line to use OpenMP 2.0 features
-#OMPFLAG = -DOMPVER2
-# Uncomment the following line to use OpenMP 3.0 features
-OMPFLAG = -DOMPVER2 -DOMPVER3
-
-CC = /home/h012/fiona/SolarisStudio12.2-linux-x86-tar-ML/solstudio12.2/bin/suncc
-CFLAGS = -xopenmp -xO3 -lm
-LDFLAGS = -xopenmp -xO3 -lm
-CPP = /usr/bin/cpp
-LIBS = 
--- a/usr/openmpbench/Makefile.defs.stokes.gnu
+++ b/usr/openmpbench/Makefile.defs.stokes.gnu
@ -1,10 +0,0 @@
-# Uncomment the following line to use OpenMP 2.0 features
-#OMPFLAG = -DOMPVER2
-# Uncomment the following line to use OpenMP 3.0 features
-OMPFLAG = -DDISABLE_BARRIER_TEST -DOMPVER2 -DOMPVER3
-
-CC = gcc
-CFLAGS = -fopenmp -O1 -lm
-LDFLAGS = -fopenmp -O1 -lm
-CPP = /usr/bin/cpp
-LIBS = 
--- a/usr/openmpbench/Makefile.defs.stokes.intel
+++ b/usr/openmpbench/Makefile.defs.stokes.intel
@ -1,10 +0,0 @@
-# Uncomment the following line to use OpenMP 2.0 features
-#OMPFLAG = -DOMPVER2
-# Uncomment the following line to use OpenMP 3.0 features
-OMPFLAG = -DDISABLE_BARRIER_TEST -DOMPVER2 -DOMPVER3
-
-CC = icc
-CFLAGS = -openmp -O1 -lm
-LDFLAGS = -openmp -O1 -lm
-CPP = /usr/bin/cpp
-LIBS = 
--- a/usr/openmpbench/syncbench.c
+++ b/usr/openmpbench/syncbench.c
@ -45,9 +45,9 @@ int main(int argc, char **argv) {

 	struct XRayTraceCapture* trace = XRayInit(
 				20,					// max. call depth
-				32 * 1000 * 1000,	// memory for report
+				16 * 1000 * 1000,	// memory for report
 				13,					// frame count
-				"/hermit/usr/openmpbench/syncbench.map");
+				"syncbench.map");

    // Start Paraver tracing
 #ifdef PARAVERTRACE
@ -128,7 +128,7 @@ int main(int argc, char **argv) {
 #endif

 	XRaySaveReport(trace,
-				   "/hermit/usr/openmpbench/syncbench.xray", // report file
+				   "syncbench.xray", // report file
 				   0.05f, // Only output funcs that have higher runtime [%]
 				   1000); // Only output funcs that have higher runtime [cycles]
 	XRayShutdown(trace);
--- a/usr/tests/CMakeLists.txt
+++ b/usr/tests/CMakeLists.txt
@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.7)
+include(../../cmake/HermitCore-Application.cmake)
+
+project(hermit_tests C CXX Fortran Go)
+
+add_executable(hello hello.c)
+add_executable(jacobi jacobi.c)
+add_executable(hello++ hello++.cpp)
+add_executable(hellof hellof.f90)
+add_executable(pi pi.go)
+
+add_executable(server server.go)
+target_link_libraries(server netgo)
+
+add_executable(RCCE_minimum RCCE_minimum.c)
+target_link_libraries(RCCE_minimum ircce)
+
+add_executable(thr_hello thr_hello.c)
+target_link_libraries(thr_hello pthread)
+
+add_executable(signals signals.c)
+target_link_libraries(signals pthread)
+
+# deployment
+install_local_targets(extra/tests)
--- a/usr/tests/Makefile
+++ b/usr/tests/Makefile
@ -1,138 +0,0 @@
-ARCH = x86
-TARGET=x86_64-hermit
-MAKE = make
-override STRIP_DEBUG = --strip-debug #--strip-unneeded
-KEEP_DEBUG = --only-keep-debug
-
-# Set your own cross compiler tool chain prefix here
-CROSSCOMPREFIX = x86_64-hermit-
-
-CC_FOR_TARGET = $(CROSSCOMPREFIX)gcc
-GO_FOR_TARGET = $(CROSSCOMPREFIX)gccgo
-FC_FOR_TARGET = $(CROSSCOMPREFIX)gfortran
-CXX_FOR_TARGET = $(CROSSCOMPREFIX)g++
-GCC_FOR_TARGET = $(CROSSCOMPREFIX)gcc
-CPP_FOR_TARGET = $(CROSSCOMPREFIX)cpp
-AR_FOR_TARGET = $(CROSSCOMPREFIX)ar
-AS_FOR_TARGET = $(CROSSCOMPREFIX)as
-LD_FOR_TARGET = $(CROSSCOMPREFIX)ld
-NM_FOR_TARGET = $(CROSSCOMPREFIX)nm
-OBJDUMP_FOR_TARGET = $(CROSSCOMPREFIX)objdump
-OBJCOPY_FOR_TARGET = $(CROSSCOMPREFIX)objcopy
-RANLIB_FOR_TARGET = $(CROSSCOMPREFIX)ranlib
-STRIP_FOR_TARGET = $(CROSSCOMPREFIX)strip
-READELF_FOR_TARGET = $(CROSSCOMPREFIX)readelf
-ELFEDIT_FOR_TARGET = $(CROSSCOMPREFIX)elfedit
-
-# Prettify output
-V = 0
-ifeq ($V,0)
-	Q = @
-	P = > /dev/null
-endif
-
-# other implicit rules
-%.o : %.c
-	@echo [CC] $@
-	$Q$(CC_FOR_TARGET) -c $(CFLAGS_FOR_TARGET) -o $@ $<
-
-%.o : %.go
-	@echo [GO] $@
-	$Q$(GO_FOR_TARGET) -c $(GOFLAGS_FOR_TARGET) -o $@ $<
-
-%.o: %.cpp
-	@echo [CXX] $@
-	$Q$(CXX_FOR_TARGET) -c $(CXXFLAGS_FOR_TARGET) -o $@ $<
-
-%.o: %.f90
-	@echo [F90] $@
-	$Q$(FC_FOR_TARGET) -c $(FCLAGS_FOR_TARGET) -o $@ $<
-
-default: all
-
-all: hello hello++ thr_hello jacobi hellof RCCE_minimum signals pi server
-
-hello++: hello++.o
-	@echo [LD] $@
-	$Q$(CXX_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CXXFLAGS_FOR_TARGET)
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-hello: hello.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET)
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-hellof: hellof.o
-	@echo [LD] $@
-	$Q$(FC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(FFLAGS_FOR_TARGET)
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-pi: pi.o
-	@echo [LD] $@
-	$Q$(GO_FOR_TARGET) -pthread -o $@ $< $(LDFLAGS_FOR_TARGET) $(GOFLAGS_FOR_TARGET)
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-server: server.o
-	@echo [LD] $@
-	$Q$(GO_FOR_TARGET) -pthread -o $@ $< $(LDFLAGS_FOR_TARGET) $(GOFLAGS_FOR_TARGET) -lnetgo
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-jacobi: jacobi.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET)
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-thr_hello.o: thr_hello.c
-	@echo [CC] $@
-	$Q$(CC_FOR_TARGET) -c $(CFLAGS_FOR_TARGET) -pthread -o $@ $<
-
-thr_hello: thr_hello.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -pthread
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-signals.o: signals.c
-	@echo [CC] $@
-	$Q$(CC_FOR_TARGET) -c $(CFLAGS_FOR_TARGET) -pthread -o $@ $<
-
-signals: signals.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -pthread
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-RCCE_minimum: RCCE_minimum.o
-	@echo [LD] $@
-	$Q$(CC_FOR_TARGET) -o $@ $< $(LDFLAGS_FOR_TARGET) $(CFLAGS_FOR_TARGET) -lircce
-	$Q$(OBJCOPY_FOR_TARGET) $(KEEP_DEBUG) $@ $@.sym
-	$Q$(OBJCOPY_FOR_TARGET) $(STRIP_DEBUG) $@
-	$Qchmod a-x $@.sym
-
-clean:
-	@echo Cleaning tests
-	$Q$(RM) hello hello++ hellof jacobi thr_hello RCCE_minimum signals pi server *.sym *.o *~
-
-veryclean:
-	@echo Propper cleaning tests
-	$Q$(RM) hello hello++ hellof jacobi thr_hello RCCE_minimum pi server *.sym *.o *~
-
-depend:
-	$Q$(CC_FOR_TARGET) -MM $(CFLAGS_FOR_TARGET) *.c > Makefile.dep
-
-include Makefile.dep
-# DO NOT DELETE
--- a/usr/xray/CMakeLists.txt
+++ b/usr/xray/CMakeLists.txt
@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.7)
+include(../../cmake/HermitCore.cmake)
+
+project(hermit_xray C)
+
+add_compile_options(${HERMIT_APP_FLAGS})
+
+file(GLOB SOURCES *.c)
+
+add_library(xray STATIC ${SOURCES})
+
+target_compile_definitions(xray
+	PUBLIC
+		-DXRAY -DXRAY_ANNOTATE
+		-DXRAY_NO_DEMANGLE
+		-DXRAY_DISABLE_BROWSER_INTEGRATION)
+
+# deployment
+install(TARGETS xray
+	DESTINATION ${TARGET_ARCH}/lib)
+install(FILES libxray.spec
+	DESTINATION ${TARGET_ARCH}/lib)
+install(FILES xray.h
+	DESTINATION ${TARGET_ARCH}/include)
--- a/usr/xray/Makefile.in
+++ b/usr/xray/Makefile.in
@ -1,33 +0,0 @@
-CROSSPREFIX = x86_64-hermit
-CP = cp
-NAME = libxray.a
-
-CC_FOR_TARGET ?= gcc
-AR_FOR_TARGET ?= ar
-
-CFLAGS = -DXRAY -DXRAY_DISABLE_BROWSER_INTEGRATION -DXRAY_NO_DEMANGLE -DXRAY_ANNOTATE
-
-CFLAGS += ${CFLAGS_FOR_TARGET}
-
-OBJS = xray.o stringpool.o hashtable.o symtable.o demangle.o parsesymbols.o report.o
-
-prefix = @prefix@
-INSTALL = @INSTALL@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_DATA = @INSTALL_DATA@
-
-$(NAME): $(OBJS)
-	$(AR_FOR_TARGET) rsv $@ $(OBJS)
-
-install: $(NAME)
-	$(INSTALL_DATA) $(NAME) $(prefix)/$(CROSSPREFIX)/lib
-	$(INSTALL_DATA) libxray.spec $(prefix)/$(CROSSPREFIX)/lib
-	$(INSTALL_DATA) xray.h $(prefix)/$(CROSSPREFIX)/include
-
-%.o: %.c
-	@echo [CC] $@
-	@$(CC_FOR_TARGET) $(CFLAGS) -c $< -o $@
-
-clean:
-	rm -f *.o $(NAME)
--- a/usr/xray/README.md
+++ b/usr/xray/README.md
@ -0,0 +1,138 @@
+# Profiling with XRay
+
+## Introduction
+
+You can profile your application and parts of the system runtime using the XRay
+profiler. It hooks into every function call (using GCC's
+`-finstrument-functions` option) to record the execution time and create a call
+graph.
+
+It can generate a text-file report that lists the most expensive function calls
+depending on the filtering that is configured.
+
+
+## About XRay
+
+XRay can divide the profiling into multiple "runs" called frames. In a graphical
+application this could correspond to the rendering of a graphics frame, whereas
+in a benchmark application a frame might correspond to each individual benchmark
+run.
+
+The profiling information is saved in a statically sized ring buffer so you must
+decide on the size of the buffer and the max. number of frames. Those values
+might need some fine tuning. If in doubt, increase the buffer size.
+
+In order for XRay to resolve function names, a linker map file is needed. Using
+this file, addresses can be resolved to function names.
+
+
+## Limitations
+
+If the compiler aggressively (or intendedly) inlines functions you won't see
+them in the final report since no enter and exit hooks are inserted. Keep this
+is mind if there's some function missing in the call hierarchy. Furthermore, the
+name of static functions cannot be resolved because their names are not listed
+in the linker file.
+
+
+## Profile your application
+
+To generate linker map files and inject enter and exit hooks, you have to tell
+CMake that you want your application to be profiled:
+
+```bash
+$ cd build
+$ cmake .. -DPROFILING=true
+```
+
+If you want to profile HermitCore internals or one of the example applications,
+have a look at `CMakeLists.txt` in the root of the repository. Every target that
+is built by `build_external(target_name ...)` can be profiled like this:
+
+```bash
+$ cd build
+$ cmake .. -DPROFILE_APPS='openmpbench;tests'
+```
+
+### Code
+
+You have to include the XRay header: `#include <xray.h>`.
+
+Then you must initialize XRay and already do some configuration:
+
+```c
+struct XRayTraceCapture* XRayInit(int stack_size,
+                                  int buffer_size,
+                                  int frame_count,
+                                  const char* mapfilename);
+
+struct XRayTraceCapture* trace = XRayInit(
+                5,                // max. call depth in report
+                4 * 1000 * 1000,  // ring buffer size for profiling information
+                10,               // frame count
+                "/path/to/your/application.map");
+```
+
+To find the hotspots in your code you might want to start with a relatively
+small call depth (maybe 5) and increase it to gain a better understanding of the
+detailed call hierarchy. The maximum call depth / stack size is 255. Keep the
+buffer size as small as possible and increase on demand.
+
+Now you can wrap parts of your code into frames:
+
+```c
+XRayStartFrame(trace);
+do_work();
+XRayEndFrame(trace);
+
+XRayStartFrame(trace);
+do_even_more_work();
+XRayEndFrame(trace);
+```
+
+And finally generate the report:
+
+```c
+void XRaySaveReport(struct XRayTraceCapture* capture,
+                    const char* filename,
+                    float percent_cutoff,
+                    int cycle_cutoff);
+
+XRaySaveReport(trace,
+               "/path/to/you/report/application.xray", // report file
+               10.0f, // Only output funcs that have a higher runtime [%]
+               2000); // Only output funcs that have a higher runtime [cycles]
+XRayShutdown(trace);
+```
+
+Here you can do further filtering of the output. For a function call to be added
+to the report, it's relative runtime (whole application) has be higher than
+`percent_cutoff` and it's absolute runtime must be greater than `cycle_cutoff`
+CPU cycles.
+
+
+## Example
+
+See [usr/openmpbench/syncbench.c](https://github.com/RWTH-OS/HermitCore/blob/master/usr/openmpbench/syncbench.c).
+
+
+## Analysis
+
+After tracing your code, you may want to analyse the report. While the XRay
+report is already human-readable, it's hard to get an overview of the whole
+trace. Therefore, it's possible to convert the XRay report to a format that
+[kCacheGrind](https://kcachegrind.github.io) can read. You can find the tool
+needed for conversion at `usr/xray/tools`.
+
+```bash
+$ ./conv2kcg.py libgomp_trace.xray 
+INFO:Parsing Header is done. Found 1 frames
+INFO:Found frame 'PARALLEL' data
+INFO:Frame 'PARALLEL' complete
+INFO:Report file 'libgomp_trace.xray' parsed completely.
+INFO:Create callgrind file for frame 'PARALLEL'
+INFO:Writing to: libgomp_trace_PARALLEL.callgrind
+```
+
+This will create the file `libgomp_trace_PARALLEL.callgrind` which can be opened
+using kCacheGrind (Open dialog: set Filter to 'All Files').
--- a/usr/xray/xray.h
+++ b/usr/xray/xray.h
@ -28,7 +28,7 @@ extern "C" {
 #endif

 #define XRAY_NO_INSTRUMENT  __attribute__((no_instrument_function))
-#define XRAY_INLINE __attribute__((always_inline, no_instrument_function))
+#define XRAY_INLINE __attribute__((always_inline, no_instrument_function)) inline

 #if defined(XRAY)