Mirrors/libhermit
1
0
Fork 0
mirror of https://github.com/hermitcore/libhermit.git synced 2025-03-09 00:00:03 +01:00
Code Issues Releases Wiki Activity

Merge remote-tracking branch 'upstream/devel' into devel

Browse source
This commit is contained in:
bytesnake 2017-05-12 11:15:29 +02:00
commit 807c7498de
104 changed files with 2442 additions and 22995 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
.bintray_descriptor.json
View file

@ -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
}

53
.gitignore vendored
View file

@ -1,58 +1,15 @@
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
*.ko
**/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/
cmake/cmake-3.7.2-Linux-x86_64/*

31
.travis.yml
View file

@ -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"

220
CMakeLists.txt Normal file
View file

@ -0,0 +1,220 @@
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-bootstrap STATIC ${KERNEL_OBJECTS})
set_target_properties(hermit-bootstrap PROPERTIES
ARCHIVE_OUTPUT_NAME hermit)
# 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-bootstrap ${X86_KERNEL_TARGET})
add_custom_command(
TARGET
hermit-bootstrap 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-bootstrap>
# 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-bootstrap>
${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-bootstrap
DESTINATION ${TARGET_ARCH}/lib
COMPONENT bootstrap)
install(DIRECTORY include/hermit
DESTINATION ${TARGET_ARCH}/include/
COMPONENT bootstrap
FILES_MATCHING
PATTERN *.h)
# provide custom target to only install libhermit without its runtimes which is
# needed during the compilation of the cross toolchain
add_custom_target(hermit-bootstrap-install
DEPENDS
hermit-bootstrap
COMMAND
${CMAKE_COMMAND}
-DCMAKE_INSTALL_COMPONENT=bootstrap
-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
-P cmake_install.cmake)
# The target 'hermit' includes the HermitCore kernel and several runtimes.
# Applications should depend on this target if they link against HermitCore.
add_custom_target(hermit
DEPENDS hermit-bootstrap)
### 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)

29
LICENSE Normal file
View file

@ -0,0 +1,29 @@
BSD 3-Clause License
Copyright (c) 2010-2017, RWTH Aachen University, Germany
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 copyright holder 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 COPYRIGHT HOLDER 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.

278
Makefile.in
View file

@ -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))

20
Makefile.inc
View file

@ -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)

429
README.md
View file

@ -1,91 +1,272 @@
# 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.
[![Join the chat at https://gitter.im/RWTH-OS/HermitCore](https://badges.gitter.im/RWTH-OS/HermitCore.svg)](https://gitter.im/RWTH-OS/HermitCore?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Build Status](https://travis-ci.org/RWTH-OS/HermitCore.svg?branch=devel)](https://travis-ci.org/RWTH-OS/HermitCore)
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.
![HermitCore Demo](img/demo.gif)
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
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 repository [hermit-toolchain](https://github.com/RWTH-OS/hermit-toolchain), which contains scripts to build the whole toolchain.
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:
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. To install your new version in the same directory, you have to set the installation path and to install HermitCore as follows:
```bash
$ cmake -DTOOLCHAIN_BIN_DIR=/home/user/hermit/bin -DCMAKE_INSTALL_PREFIX=/home/user/hermit ..
$ make
$ make install
```
**Note:** If you use the cross compiler outside of this repository, the compiler uses per default the library operating systems located by the toolchain (e.g. `/opt/hermit/x86_64-hermit/lib/libhermit.a`).
## 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/x86_64-hermit/extra/tests/hello
smpboot: CPU 1 is now offline
Hello World!!!
argv[0] = /hermit/x86_64-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/x86_64-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/x86_64-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 x86_64-hermit/extra/tests/hello
$ # using uHyve
$ HERMIT_ISLE=uhyve bin/proxy x86_64-hermit/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 x86_64-hermit/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 +277,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 x86_64-hermit/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.

88
arch/x86/CMakeLists.txt Normal file
View file

@ -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)

5
arch/x86/kernel/Makefile
View file

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

12
arch/x86/kernel/apic.c
View file

@ -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
@ -481,7 +481,7 @@ static int wakeup_ap(uint32_t start_eip, uint32_t id)
reset_vector = (char*) vma_alloc(PAGE_SIZE, VMA_READ|VMA_WRITE);
page_map((size_t)reset_vector, 0x00, 1, PG_RW|PG_GLOBAL|PG_PCD);
reset_vector += 0x467; // add base address of the reset vector
LOG_INFO("Map reset vector to %p\n", reset_vector);
LOG_DEBUG("Map reset vector to %p\n", reset_vector);
}
*((volatile unsigned short *) (reset_vector+2)) = start_eip >> 4;
@ -570,7 +570,7 @@ int smp_init(void)
if (ncores <= 1)
return -EINVAL;
LOG_INFO("CR0 of core %u: 0x%x\n", apic_cpu_id(), read_cr0());
LOG_DEBUG("CR0 of core %u: 0x%x\n", apic_cpu_id(), read_cr0());
/*
* dirty hack: Reserve memory for the bootup code.
@ -611,7 +611,7 @@ int smp_init(void)
}
}
LOG_INFO("%d cores online\n", atomic_int32_read(&cpu_online));
LOG_DEBUG("%d cores online\n", atomic_int32_read(&cpu_online));
return 0;
}
@ -666,7 +666,7 @@ int apic_calibration(void)
apic_initialized = 1;
atomic_int32_inc(&cpu_online);
if(is_single_kernel()) {
if (is_single_kernel()) {
// Now, HermitCore is able to use the APIC => Therefore, we disable the PIC
outportb(0xA1, 0xFF);
outportb(0x21, 0xFF);
@ -908,7 +908,7 @@ int smp_start(void)
// reset APIC and set id
lapic_reset();
LOG_INFO("Processor %d (local id %d) is entering its idle task\n", apic_cpu_id(), atomic_int32_read(&current_boot_id));
LOG_DEBUG("Processor %d (local id %d) is entering its idle task\n", apic_cpu_id(), atomic_int32_read(&current_boot_id));
// use the same gdt like the boot processors
gdt_flush();

20
arch/x86/kernel/entry.asm
View file

@ -28,12 +28,11 @@
; 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]
extern kernel_start ; defined in linker script
extern kernel_end
MSR_FS_BASE equ 0xc0000100
MSR_GS_BASE equ 0xc0000101
@ -69,6 +68,7 @@ align 4
global hbmem_base
global hbmem_size
global uhyve
global image_size
base dq 0
limit dq 0
cpu_freq dd 0
@ -134,11 +134,6 @@ start64:
cmp eax, 0
jne Lno_pml4_init
; determine full image size
mov rax, kernel_end
sub rax, kernel_start
mov QWORD [image_size], rax
; relocate page tables
mov rdi, boot_pml4
mov rax, QWORD [rdi]
@ -181,7 +176,7 @@ start64:
mov rdi, rax
shr rdi, 9 ; (edi >> 12) * 8 (index for boot_pgt)
add rdi, boot_pgt
or rax, 0x103 ; set present, global and writable bits
or rax, 0x23 ; set present, accessed and writable bits
mov QWORD [rdi], rax
Lno_mbinfo:
; remap kernel
@ -189,13 +184,18 @@ Lno_mbinfo:
shr rdi, 18 ; (edi >> 21) * 8 (index for boot_pgd)
add rdi, boot_pgd
mov rax, [base]
or rax, 0x83 ; PG_GLOBAL isn't required because HermitCore is a single-address space OS
or rax, 0xA3 ; PG_GLOBAL isn't required because HermitCore is a single-address space OS
xor rcx, rcx
mov rsi, 510*0x200000
sub rsi, kernel_start
Lremap:
mov QWORD [rdi], rax
add rax, 0x200000
add rcx, 0x200000
add rdi, 8
; note: the whole code segement muust fit in the first pgd
cmp rcx, rsi
jnb Lno_pml4_init
cmp rcx, QWORD [image_size]
jb Lremap
@ -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

8
arch/x86/kernel/tasks.c
View file

@ -39,7 +39,7 @@
#include <asm/page.h>
#include <asm/multiboot.h>
#define TLS_OFFSET 8
#define TLS_OFFSET 0
/*
* Note that linker symbols are not variables, they have no memory allocated for
@ -105,9 +105,9 @@ int is_proxy(void)
return 1;
if (mb_info && (mb_info->flags & MULTIBOOT_INFO_CMDLINE))
{
// search in the command line for cpu frequency
char* found = strstr((char*) (size_t)mb_info->cmdline, "-proxy");
if (!found)
// search in the command line for the "proxy" hint
char* found = strstr((char*) (size_t) mb_info->cmdline, "-proxy");
if (found)
return 1;
}
return 0;

5
arch/x86/libkern/Makefile
View file

@ -1,5 +0,0 @@
C_source :=
ASM_source := string.asm
MODULE := arch_x86_libkern
include $(TOPDIR)/Makefile.inc

2
arch/x86/libkern/string.asm
View file

@ -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]

50
arch/x86/loader/CMakeLists.txt Normal file
View file

@ -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})

69
arch/x86/loader/Makefile
View file

@ -1,69 +0,0 @@
MAKE = make
QEMU = qemu-system-x86_64 -machine accel=kvm -cpu host
OBJDUMP = objdump
OBJCOPY = objcopy
CC = gcc
CFLAGS = -O2 -Wall -m64 -std=gnu99 -ffreestanding -mno-red-zone -fstrength-reduce -fomit-frame-pointer -finline-functions -Iinclude
NASM = nasm
NASMFLAGS = -felf64 -g
LD = ld
LDFLAGS = -T link.ld -z max-page-size=4096
STRIP_DEBUG = --strip-debug
KEEP_DEBUG = --only-keep-debug
OUTPUT_FORMAT = -O elf32-i386
NAME = ldhermit
TTY := $(shell tty)
C_source := main.c printf.c string.c stdio.c uart.c page.c
ASM_source := entry.asm
OBJS := $(C_source:.c=.o)
OBJS += $(ASM_source:.asm=.o)
# Prettify output
V = 0
ifeq ($V,0)
Q = @
P = > /dev/null
endif
# other implicit rules
%.o : %.c
@echo [CC] $@
$Q$(CC) -c $(CFLAGS) -o $@ $<
@echo [DEP] $*.dep
$Q$(CC) -MF $*.dep -MT $*.o -MM $(CFLAGS) $<
%.o : %.asm
@echo [ASM] $@
$Q$(NASM) $(NASMFLAGS) -o $@ $<
all: ldhermit.elf
$(NAME).elf: $(OBJS)
@echo [LD] $@
$Q$(LD) $(LDFLAGS) -o $@ $(OBJS)
@echo [OBJCOPY] $(NAME).sym
$Q$(OBJCOPY) $(KEEP_DEBUG) $(NAME).elf $(NAME).sym
@echo [OBJCOPY] $(NAME).elf
$Q$(OBJCOPY) $(STRIP_DEBUG) $(OUTPUT_FORMAT) $(NAME).elf
#qemu:
# @echo "Do you already start netcat (nc -l 4555)?"
# $(QEMU) -smp 4 -m 4G -kernel $(NAME).elf -initrd ../../../usr/benchmarks/stream \
-net nic,model=rtl8139 -net user -net dump \
-chardev socket,host=127.0.0.1,port=4555,id=gnc0 \
-device pci-serial,chardev=gnc0 \
-monitor telnet:127.0.0.1:1235,server,nowait -nographic
clean:
@echo Cleaning loader
$Q$(RM) -rf *.o *~ *.bin *.obj
veryclean: clean
depend:
$(CC) -MM $(CFLAGS) *.c > Makefile.dep
-include -include $(C_source:.c=.dep)
# DO NOT DELETE

61
arch/x86/loader/include/vga.h
View file

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

8
arch/x86/loader/main.c
View file

@ -43,7 +43,7 @@ extern const void kernel_end;
extern const void bss_start;
extern const void bss_end;
static int load_code(size_t viraddr, size_t phyaddr, size_t limit, uint32_t file_size)
static int load_code(size_t viraddr, size_t phyaddr, size_t limit, uint32_t file_size, size_t mem_size)
{
const size_t displacement = 0x200000ULL - (phyaddr & 0x1FFFFFULL);
@ -63,7 +63,7 @@ static int load_code(size_t viraddr, size_t phyaddr, size_t limit, uint32_t file
*((uint64_t*) (viraddr + 0x10)) = limit; // physical limit
*((uint32_t*) (viraddr + 0x24)) = 1; // number of used cpus
*((uint32_t*) (viraddr + 0x30)) = 0; // apicid
*((uint64_t*) (viraddr + 0x38)) = file_size;
*((uint64_t*) (viraddr + 0x38)) = mem_size;
*((uint32_t*) (viraddr + 0x60)) = 1; // numa nodes
// move file to a 2 MB boundary
@ -85,6 +85,7 @@ void main(void)
size_t phyaddr = 0;
elf_header_t* header = NULL;
uint32_t file_size = 0;
size_t mem_size = 0;
// initialize .bss section
memset((void*)&bss_start, 0x00, ((size_t) &bss_end - (size_t) &bss_start));
@ -171,6 +172,7 @@ void main(void)
if (!phyaddr)
phyaddr = prog_header->offset + (size_t)header;
file_size = prog_header->virt_addr + PAGE_FLOOR(prog_header->file_size) - viraddr;
mem_size += prog_header->mem_size;
}
break;
case ELF_PT_GNU_STACK: // Indicates stack executability => nothing to do
@ -182,7 +184,7 @@ void main(void)
}
}
if (BUILTIN_EXPECT(load_code(viraddr, phyaddr, limit, file_size), 0))
if (BUILTIN_EXPECT(load_code(viraddr, phyaddr, limit, file_size, mem_size), 0))
goto failed;
kprintf("Entry point: 0x%zx\n", header->entry);

4
arch/x86/mm/Makefile
View file

@ -1,4 +0,0 @@
C_source := memory.c vma.c page.c hbmemory.c
MODULE := arch_x86_mm
include $(TOPDIR)/Makefile.inc

25
arch/x86/mm/memory.c
View file

@ -37,6 +37,8 @@
#include <asm/page.h>
#include <asm/multiboot.h>
#define GAP_BELOW 0x100000ULL
extern uint64_t base;
extern uint64_t limit;
@ -51,7 +53,6 @@ typedef struct free_list {
* maintaining a value, rather their address is their value.
*/
extern const void kernel_start;
extern const void kernel_end;
static spinlock_t list_lock = SPINLOCK_INIT;
@ -245,7 +246,6 @@ void page_free(void* viraddr, size_t sz)
int memory_init(void)
{
size_t image_size = (size_t) &kernel_end - (size_t) &kernel_start;
int ret = 0;
// enable paging and map Multiboot modules etc.
@ -272,8 +272,8 @@ int memory_init(void)
LOG_INFO("Free region 0x%zx - 0x%zx\n", start_addr, end_addr);
if ((start_addr <= base) && (end_addr >= PAGE_2M_FLOOR((size_t) &kernel_end))) {
init_list.start = PAGE_2M_FLOOR((size_t) &kernel_end);
if ((start_addr <= base) && (end_addr >= PAGE_2M_FLOOR((size_t) &kernel_start + image_size))) {
init_list.start = PAGE_2M_FLOOR((size_t) &kernel_start + image_size);
init_list.end = end_addr;
LOG_INFO("Add region 0x%zx - 0x%zx\n", init_list.start, init_list.end);
@ -295,8 +295,7 @@ int memory_init(void)
atomic_int64_add(&total_pages, (limit-base) >> PAGE_BITS);
atomic_int64_add(&total_available_pages, (limit-base) >> PAGE_BITS);
//initialize free list
init_list.start = PAGE_2M_FLOOR((size_t) &kernel_end);
init_list.start = PAGE_2M_FLOOR(base + image_size);
init_list.end = limit;
}
@ -332,8 +331,16 @@ int memory_init(void)
end_addr = base;
// ignore everything below 1M => reserve for I/O devices
if ((start_addr < (size_t) 0x100000))
start_addr = 0x100000;
if ((start_addr < GAP_BELOW))
start_addr = GAP_BELOW;
if (start_addr < (size_t)mb_info)
start_addr = PAGE_FLOOR((size_t)mb_info);
if (mb_info->flags & MULTIBOOT_INFO_CMDLINE) {
if (start_addr < (size_t) mb_info->cmdline+2*PAGE_SIZE)
start_addr = PAGE_FLOOR((size_t) mb_info->cmdline+2*PAGE_SIZE);
}
if (start_addr >= end_addr)
continue;
@ -351,8 +358,6 @@ int memory_init(void)
last->end = end_addr;
}
}
//TODO: mb_info and mb_info->cmdline should be marked as reserevd
}
}

11
arch/x86/mm/page.c
View file

@ -49,7 +49,6 @@
/* Note that linker symbols are not variables, they have no memory
* allocated for maintaining a value, rather their address is their value. */
extern const void kernel_start;
extern const void kernel_end;
/// This page is reserved for copying
#define PAGE_TMP (PAGE_FLOOR((size_t) &kernel_start) - PAGE_SIZE)
@ -97,7 +96,7 @@ static uint8_t expect_zeroed_pages = 0;
size_t virt_to_phys(size_t addr)
{
if ((addr > (size_t) &kernel_start) &&
(addr <= PAGE_2M_FLOOR((size_t) &kernel_end)))
(addr <= PAGE_2M_FLOOR((size_t) &kernel_start + image_size)))
{
size_t vpn = addr >> (PAGE_2M_BITS); // virtual page number
size_t entry = self[1][vpn]; // page table entry
@ -161,9 +160,9 @@ int __page_map(size_t viraddr, size_t phyaddr, size_t npages, size_t bits, uint8
/* Reference the new table within its parent */
#if 0
self[lvl][vpn] = paddr | bits | PG_PRESENT | PG_USER | PG_RW | PG_ACCESSED;
self[lvl][vpn] = paddr | bits | PG_PRESENT | PG_USER | PG_RW | PG_ACCESSED | PG_DIRTY;
#else
self[lvl][vpn] = (paddr | bits | PG_PRESENT | PG_USER | PG_RW | PG_ACCESSED) & ~PG_XD;
self[lvl][vpn] = (paddr | bits | PG_PRESENT | PG_USER | PG_RW | PG_ACCESSED | PG_DIRTY) & ~PG_XD;
#endif
/* Fill new table with zeros */
@ -179,7 +178,7 @@ int __page_map(size_t viraddr, size_t phyaddr, size_t npages, size_t bits, uint8
send_ipi = flush = 1;
}
self[lvl][vpn] = phyaddr | bits | PG_PRESENT | PG_ACCESSED;
self[lvl][vpn] = phyaddr | bits | PG_PRESENT | PG_ACCESSED | PG_DIRTY;
if (flush)
/* There's already a page mapped at this address.
@ -329,7 +328,7 @@ int page_init(void)
if (mb_info && ((mb_info->cmdline & PAGE_MASK) != ((size_t) mb_info & PAGE_MASK))) {
LOG_INFO("Map multiboot cmdline 0x%x into the virtual address space\n", mb_info->cmdline);
// reserve 2 pages for long cmdline strings
page_map((size_t) mb_info->cmdline & PAGE_MASK, mb_info->cmdline & PAGE_MASK, 2, PG_GLOBAL|PG_RW|PG_PRESENT);
page_map(((size_t) mb_info->cmdline) & PAGE_MASK, ((size_t) mb_info->cmdline) & PAGE_MASK, 2, PG_GLOBAL|PG_RW|PG_PRESENT);
}
/* Replace default pagefault handler */

9
cmake/HermitCore-Application.cmake Normal file
View file

@ -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})

32
cmake/HermitCore-Configuration.cmake Normal file
View file

@ -0,0 +1,32 @@
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(MAX_FNAME "128" CACHE STRING
"Define the maximum length of a file name")
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)

35
cmake/HermitCore-Paths.cmake Normal file
View file

@ -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)

9
cmake/HermitCore-Toolchain-x86-bootstrap.cmake Normal file
View file

@ -0,0 +1,9 @@
include(${CMAKE_CURRENT_LIST_DIR}/HermitCore-Toolchain-x86.cmake)
include_guard()
set(CMAKE_C_COMPILER_WORKS 1 CACHE INTERNAL "")
set(CMAKE_CXX_COMPILER_WORKS 1 CACHE INTERNAL "")
# bootstrap toolchain cannot compile neither Go nor Fortran
unset(CMAKE_Go_COMPILER)
unset(CMAKE_Fortran_COMPILER)

26
cmake/HermitCore-Toolchain-x86.cmake Normal file
View file

@ -0,0 +1,26 @@
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
set(CMAKE_C_COMPILER ${TOOLCHAIN_BIN_DIR}/${TARGET_ARCH}-gcc)
set(CMAKE_CXX_COMPILER ${TOOLCHAIN_BIN_DIR}/${TARGET_ARCH}-g++)
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)

142
cmake/HermitCore-Utils.cmake Normal file
View file

@ -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 ${TARGET_ARCH}/${PATH})
# if there are any .map files for profiling, install them too
foreach(TARGET ${_TARGETS})
install(FILES $<TARGET_FILE:${TARGET}>.map
DESTINATION ${TARGET_ARCH}/${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)

90
cmake/HermitCore.cmake Normal file
View file

@ -0,0 +1,90 @@
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)
if(BOOTSTRAP)
# use bootstrap toolchain if requested
set(_BOOTSTRAP_ARCH_SUFFIX -bootstrap)
endif()
set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_LIST_DIR}/HermitCore-Toolchain-${HERMIT_ARCH}${_BOOTSTRAP_ARCH_SUFFIX}.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.
if(NOT BOOTSTRAP)
enable_language(C CXX Fortran Go)
include(${CMAKE_CURRENT_LIST_DIR}/HermitCore-Paths.cmake)
endif()
# find elfedit, CMake doesn't use this program, so we have to find it ourself
find_toolchain_program(elfedit)

67
cmake/README.md Normal file
View file

@ -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.

43
cmake/golang/CMakeDetermineGoCompiler.cmake Normal file
View file

@ -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")

11
cmake/golang/CMakeGoCompiler.cmake.in Normal file
View file

@ -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")

30
cmake/golang/CMakeGoInformation.cmake Normal file
View file

@ -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()

4
cmake/golang/CMakeTestGoCompiler.cmake Normal file
View file

@ -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 "")

69
cmake/local-cmake.sh Normal file
View file

@ -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}"

BIN
config/bzImage
View file

Binary file not shown.

4131
configure vendored
View file

File diff suppressed because it is too large Load diff

76
configure.ac
View file

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

6
debian/README.Debian vendored
View file

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

10
debian/README.source vendored
View file

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

5
debian/changelog vendored
View file

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

1
debian/compat vendored
View file

@ -1 +0,0 @@
9

15
debian/control vendored
View file

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

54
debian/copyright vendored
View file

@ -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.

26
debian/init.d.ex vendored
View file

@ -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)

2
debian/libhermit-docs.docs vendored
View file

@ -1,2 +0,0 @@
README.Debian
README.source

4
debian/libhermit.cron.d.ex vendored
View file

@ -1,4 +0,0 @@
#
# Regular cron jobs for the libhermit package
#
0 4 * * * root [ -x /usr/bin/libhermit_maintenance ] && /usr/bin/libhermit_maintenance

10
debian/libhermit.default.ex vendored
View file

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

20
debian/libhermit.doc-base.EX vendored
View file

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

56
debian/manpage.1.ex vendored
View file

@ -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.

154
debian/manpage.sgml.ex vendored
View file

@ -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:
-->

291
debian/manpage.xml.ex vendored
View file

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

2
debian/menu.ex vendored
View file

@ -1,2 +0,0 @@
?package(libhermit):needs="X11|text|vc|wm" section="Applications/see-menu-manual"\
title="libhermit" command="/usr/bin/libhermit"

39
debian/postinst.ex vendored
View file

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

37
debian/postrm.ex vendored
View file

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

35
debian/preinst.ex vendored
View file

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

38
debian/prerm.ex vendored
View file

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

36
debian/rules vendored
View file

@ -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"

1
debian/source/format vendored
View file

@ -1 +0,0 @@
3.0 (quilt)

39
debian/watch.ex vendored
View file

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

4
drivers/net/Makefile
View file

@ -1,4 +0,0 @@
C_source := mmnif.c util.c e1000.c rtl8139.c
MODULE := drivers_net
include $(TOPDIR)/Makefile.inc

BIN
img/demo.gif Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 12 MiB

15
include/hermit/CMakeLists.txt Normal file
View file

@ -0,0 +1,15 @@
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})
# install generated config files when building libhermit for bootstrapping
install(FILES
${GENERATED_CONFIG_DIR}/hermit/config.h
${GENERATED_CONFIG_DIR}/hermit/config.asm
DESTINATION ${TARGET_ARCH}/include/hermit/
COMPONENT bootstrap)

3
include/hermit/config.asm.in Normal file
View file

@ -0,0 +1,3 @@
%define MAX_CORES @MAX_CORES@
%define KERNEL_STACK_SIZE @KERNEL_STACK_SIZE@
%define SAVE_FPU @SAVE_FPU@

54
include/hermit/config.h.in Executable file → Normal file
View file

@ -1,50 +1,26 @@
/* 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@"
#cmakedefine MAX_FNAME (@MAX_FNAME@)
#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

2
include/hermit/malloc.h
View file

@ -71,6 +71,8 @@ typedef union buddy {
uint8_t exponent;
/// Must be equal to BUDDY_MAGIC for a valid memory block
uint16_t magic;
/// padding to gurantee a sizeof 32Byte
uint8_t padding[28];
} prefix;
} buddy_t;

5
include/hermit/stddef.h
View file

@ -42,10 +42,13 @@
extern "C" {
#endif
// size of the whole application
extern const size_t image_size;
#define TIMER_FREQ 100 /* in HZ */
#define CLOCK_TICK_RATE 1193182 /* 8254 chip's internal oscillator frequency */
#define CACHE_LINE 64
#define HEAP_START (PAGE_2M_FLOOR((size_t)&kernel_end) + 4*PAGE_SIZE)
#define HEAP_START (PAGE_2M_FLOOR((size_t)&kernel_start + image_size) + 4*PAGE_SIZE)
#define HEAP_SIZE (1ULL << 32)
#define KMSG_SIZE 0x1000
#define INT_SYSCALL 0x80

2
include/hermit/vma.h
View file

@ -87,7 +87,7 @@ typedef struct vma {
/** @brief Initalize the kernelspace VMA list
*
* Reserves several system-relevant virtual memory regions:
* - The kernel (kernel_start - kernel_end)
* - The kernel (image_size)
* - Init Ramdisk
*
* @return

501
install-sh
View file

@ -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:

4
kernel/Makefile
View file

@ -1,4 +0,0 @@
C_source := main.c tasks.c syscall.c timer.c
MODULE := kernel
include $(TOPDIR)/Makefile.inc

18
kernel/main.c
View file

@ -70,7 +70,6 @@ static const int sobufsize = 131072;
* maintaining a value, rather their address is their value.
*/
extern const void kernel_start;
extern const void kernel_end;
extern const void hbss_start;
extern const void tls_start;
extern const void tls_end;
@ -119,7 +118,7 @@ static int hermit_init(void)
size_t sz = (size_t) &percore_end0 - (size_t) &percore_start;
// initialize .kbss sections
memset((void*)&hbss_start, 0x00, ((size_t) &kernel_end - (size_t) &hbss_start));
memset((void*)&hbss_start, 0x00, (size_t) &__bss_start - (size_t) &hbss_start);
// initialize .percore section => copy first section to all other sections
for(i=1; i<MAX_CORES; i++)
@ -254,10 +253,10 @@ success:
ip_counter++;
}
}
if (!ip_2_ip4(&default_netif.ip_addr)->addr)
return -ENODEV;
if (!ip_2_ip4(&default_netif.ip_addr)->addr)
return -ENODEV;
}
return 0;
}
@ -380,6 +379,9 @@ static int initd(void* arg)
LOG_INFO("Initd is running\n");
// initialized bss section
memset((void*)&__bss_start, 0x00, (size_t) &kernel_start + image_size - (size_t) &__bss_start);
// setup heap
if (!curr_task->heap)
curr_task->heap = (vma_t*) kmalloc(sizeof(vma_t));
@ -404,7 +406,7 @@ static int initd(void* arg)
// initialize network
err = init_netifs();
if ((err != 0) || is_proxy())
if ((err != 0) || !is_proxy())
{
char* dummy[] = {"app_name", NULL};
@ -573,9 +575,9 @@ int hermit_main(void)
LOG_INFO("This is Hermit %s, build date %u\n", PACKAGE_VERSION, &__DATE__);
LOG_INFO("Isle %d of %d possible isles\n", isle, possible_isles);
LOG_INFO("Kernel starts at %p and ends at %p\n", &kernel_start, &kernel_end);
LOG_INFO("Kernel starts at %p and ends at %p\n", &kernel_start, (size_t)&kernel_start + image_size);
LOG_INFO("TLS image starts at %p and ends at %p (size 0x%zx)\n", &tls_start, &tls_end, ((size_t) &tls_end) - ((size_t) &tls_start));
LOG_INFO("BBS starts at %p and ends at %p\n", &hbss_start, &kernel_end);
LOG_INFO("BBS starts at %p and ends at %p\n", &hbss_start, (size_t)&kernel_start + image_size);
LOG_INFO("Per core data starts at %p and ends at %p\n", &percore_start, &percore_end);
LOG_INFO("Per core size 0x%zx\n", (size_t) &percore_end0 - (size_t) &percore_start);
LOG_INFO("Processor frequency: %u MHz\n", get_cpu_frequency());

1
kernel/syscall.c
View file

@ -49,7 +49,6 @@
* maintaining a value, rather their address is their value.
*/
extern const void kernel_start;
extern const void kernel_end;
//TODO: don't use one big kernel lock to comminicate with all proxies
static spinlock_irqsave_t lwip_lock = SPINLOCK_IRQSAVE_INIT;

5
kernel/tasks.c
View file

@ -520,8 +520,9 @@ int clone_task(tid_t* id, entry_point_t ep, void* arg, uint8_t prio)
spinlock_irqsave_unlock(&table_lock);
if (!ret)
LOG_INFO("start new thread %d on core %d with stack address %p\n", i, core_id, stack);
if (!ret) {
LOG_DEBUG("start new thread %d on core %d with stack address %p\n", i, core_id, stack);
}
out:
if (ret) {

4
libkern/Makefile
View file

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

4
mm/Makefile
View file

@ -1,4 +0,0 @@
C_source := malloc.c vma.c
MODULE := mm
include $(TOPDIR)/Makefile.inc

5
mm/vma.c
View file

@ -38,7 +38,6 @@
* maintaining a value, rather their address is their value.
*/
extern const void kernel_start;
extern const void kernel_end;
/*
* Kernel space VMA list and lock
@ -56,11 +55,11 @@ int vma_init(void)
LOG_INFO("vma_init: reserve vma region 0x%llx - 0x%llx\n",
PAGE_2M_CEIL((size_t) &kernel_start),
PAGE_2M_FLOOR((size_t) &kernel_end));
PAGE_2M_FLOOR((size_t) &kernel_start + image_size));
// add Kernel
ret = vma_add(PAGE_2M_CEIL((size_t) &kernel_start),
PAGE_2M_FLOOR((size_t) &kernel_end),
PAGE_2M_FLOOR((size_t) &kernel_start + image_size),
VMA_READ|VMA_WRITE|VMA_EXECUTE|VMA_CACHEABLE);
if (BUILTIN_EXPECT(ret, 0))
goto out;

20
tools/CMakeLists.txt Normal file
View file

@ -0,0 +1,20 @@
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_compile_options(proxy PUBLIC -pthread)
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})

47
tools/Makefile.in
View file

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

5846
tools/hermit_ircce.json
View file

File diff suppressed because it is too large Load diff

3942
tools/hermit_kvm.json
View file

File diff suppressed because it is too large Load diff

6126
tools/hermit_openmp.json
View file

File diff suppressed because it is too large Load diff

2
tools/init.sh
View file

@ -1,6 +1,6 @@
#!/bin/sh
PROXY=/hermit/tools/proxy
PROXY=/hermit/bin/proxy
ELF_OSABI_OFFSET=7
ELF_OSABI="\\x42"

873
tools/uhyve.c
View file

File diff suppressed because it is too large Load diff

116
usr/Makefile
View file

@ -1,116 +0,0 @@
override TOPDIR = $(shell pwd)
ARCH = x86
TARGET=x86_64-hermit
NJOBS=-j$(shell nproc)
#OMPRT=libgomp
OMPRT=libomp
CROSSCOMPREFIX = x86_64-hermit
PREFIX = /opt/hermit
RM = rm -rf
CD = cd
CP = cp
MKDIR = mkdir -p
TMP = $(TOPDIR)/tmp
OPT = --disable-shared --disable-multilib --enable-lto --enable-newlib-hw-fp --enable-newlib-io-c99-formats --enable-newlib-multithread #--enable-newlib-reent-small
CLONE_DEPTH = --depth=50
#CLONE_DEPTH =
# Prettify output
V = 0
ifeq ($V,0)
Q = @
P = > /dev/null
endif
default:
@echo Do not use default rule!
examples:
@echo Build demo applications
$Q$(MAKE) ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) CXX_FOR_TARGET=$(CXX_FOR_TARGET) CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET) $(PROFILING_CFLAGS)" LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_TARGET) $(PROFILING_LDFLAGS)" OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) GO_FOR_TARGET="$(GO_FOR_TARGET)" GOFLAGS_FOR_TARGET="$(GOFLAGS_FOR_TARGET)" -C tests depend
$Q$(MAKE) ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) CXX_FOR_TARGET=$(CXX_FOR_TARGET) CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET) $(PROFILING_CFLAGS)" LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_TARGET) $(PROFILING_LDFLAGS)" OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) GO_FOR_TARGET="$(GO_FOR_TARGET)" GOFLAGS_FOR_TARGET="$(GOFLAGS_FOR_TARGET)" -C tests
$Q$(MAKE) ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) CXX_FOR_TARGET=$(CXX_FOR_TARGET) CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET) $(PROFILING_CFLAGS)" LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_TARGET) $(PROFILING_LDFLAGS)" OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) -C benchmarks depend
$Q$(MAKE) ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) CXX_FOR_TARGET=$(CXX_FOR_TARGET) CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET) $(PROFILING_CFLAGS)" LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_TARGET) $(PROFILING_LDFLAGS)" OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) -C benchmarks
#$Q$(MAKE) ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) CXX_FOR_TARGET=$(CXX_FOR_TARGET) CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_TARGET)" OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) -C openmpbench depend
$Q$(MAKE) ELFEDIT_FOR_TARGET=$(ELFEDIT_FOR_TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) CXX_FOR_TARGET=$(CXX_FOR_TARGET) CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET) $(PROFILING_CFLAGS)" LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_TARGET) $(PROFILING_LDFLAGS)" OBJCOPY_FOR_TARGET=$(OBJCOPY_FOR_TARGET) -C openmpbench
bootstrap: binutils gcc newlib pte $(TMP)/binutils $(TMP)/bootstrap
binutils:
git clone $(CLONE_DEPTH) https://github.com/RWTH-OS/binutils.git
gcc:
git clone $(CLONE_DEPTH) https://github.com/RWTH-OS/gcc.git
pte:
git clone $(CLONE_DEPTH) https://github.com/RWTH-OS/pthread-embedded.git pte
$Q$(CD) pte; ./configure --prefix=$(PREFIX)
newlib:
git clone $(CLONE_DEPTH) https://github.com/RWTH-OS/newlib.git
$(TMP)/binutils:
@echo Build binutils
$Q$(MKDIR) $(TMP)/binutils
$Q$(CD) $(TMP)/binutils; $(TOPDIR)/binutils/configure --target=$(TARGET) --prefix=$(PREFIX) --with-sysroot --disable-multilib --disable-shared --disable-nls --disable-gdb --disable-libdecnumber --disable-readline --disable-sim --disable-libssp --enable-tls --enable-lto --enable-plugin && $(MAKE) $(NJOBS) && $(MAKE) install
$(TMP)/bootstrap:
@echo Build bootstrap compiler
$Q$(MKDIR) $(TMP)/bootstrap
$Q$(CD) $(TMP)/bootstrap; $(TOPDIR)/gcc/configure --target=$(TARGET) --prefix=$(PREFIX) --without-headers --disable-multilib --with-isl --enable-languages=c,lto --disable-nls --disable-shared --disable-libssp --disable-libgomp --enable-threads=posix --enable-tls --enable-lto --disable-symvers && $(MAKE) $(NJOBS) all-gcc && $(MAKE) install-gcc
toolchain: $(TMP)/newlib libpthread $(TMP)/gcc libs
$(TMP)/newlib:
@echo Build newlib
$Q$(MKDIR) $(TMP)/newlib
$Q$(CD) $(TMP)/newlib; $(TOPDIR)/newlib/configure --target=$(TARGET) --prefix=$(PREFIX) $(OPT) && $(MAKE) $(NJOBS) && $(MAKE) install
libpthread:
@echo Build libpthread
$Q$(MAKE) TARGET=$(TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) AR_FOR_TARGET=$(AR_FOR_TARGET) CFLAGS_FOR_TARGET+="-I. -Iplatform/hermit -Iplatform/helper -Wall $(PROFILING_CFLAGS)" -C pte depend
$Q$(MAKE) TARGET=$(TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) AR_FOR_TARGET=$(AR_FOR_TARGET) CFLAGS_FOR_TARGET+="-I. -Iplatform/hermit -Iplatform/helper -Wall $(PROFILING_CFLAGS)" -C pte
$Q$(MAKE) TARGET=$(TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) AR_FOR_TARGET=$(AR_FOR_TARGET) CFLAGS_FOR_TARGET+="-I. -Iplatform/hermit -Iplatform/helper -Wall $(PROFILING_CFLAGS)" -C pte install
$Q$(MAKE) TARGET=$(TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) AR_FOR_TARGET=$(AR_FOR_TARGET) CFLAGS_FOR_TARGET+="-I. -Iplatform/hermit -Iplatform/helper -Wall $(PROFILING_CFLAGS)" -C pte headers
libs:
@echo Build Xray profiler
$Q$(MAKE) TARGET=$(TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) CFLAGS_FOR_TARGET="$(CFLAGS_FOR_TARGET)" LDFLAGS_FOR_TARGET="$(LDFLAGS_FOR_TARGET)" PREFIX=$(PREFIX) -C xray
@echo Build OpenMP Runtime and iRCCE
$Q$(MAKE) TARGET=$(TARGET) CXX_FOR_TARGET=$(CXX_FOR_TARGET) CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" CC_FOR_TARGET=$(CC_FOR_TARGET) AR_FOR_TARGET=$(AR_FOR_TARGET) CFLAGS_FOR_TARGET+="-I. -Wall -pthread $(PROFILING_CFLAGS)" PREFIX=$(PREFIX) -C $(OMPRT) depend
$Q$(MAKE) TARGET=$(TARGET) CXX_FOR_TARGET=$(CXX_FOR_TARGET) CXXFLAGS_FOR_TARGET="$(CXXFLAGS_FOR_TARGET)" CC_FOR_TARGET=$(CC_FOR_TARGET) AR_FOR_TARGET=$(AR_FOR_TARGET) CFLAGS_FOR_TARGET+="-I. -Wall -pthread $(PROFILING_CFLAGS)" PREFIX=$(PREFIX) -C $(OMPRT)
$Q$(MAKE) TARGET=$(TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) AR_FOR_TARGET=$(AR_FOR_TARGET) CFLAGS_FOR_TARGET+="-I. -Wall" PREFIX=$(PREFIX) -C ircce depend
$Q$(MAKE) TARGET=$(TARGET) CC_FOR_TARGET=$(CC_FOR_TARGET) AR_FOR_TARGET=$(AR_FOR_TARGET) CFLAGS_FOR_TARGET+="-I. -Wall" PREFIX=$(PREFIX) -C ircce
install:
$Q$(MAKE) PREFIX=$(PREFIX) -C xray install
$Q$(MAKE) PREFIX=$(PREFIX) -C ircce install
$Q$(MAKE) PREFIX=$(PREFIX) -C $(OMPRT) install
$(TMP)/gcc:
@echo Build final gcc
$Q$(MKDIR) $(TMP)/gcc
$Q$(CD) $(TMP)/gcc; $(TOPDIR)/gcc/configure --target=$(TARGET) --prefix=$(PREFIX) --with-newlib --with-isl --disable-multilib --without-libatomic --enable-languages=c,c++,go,fortran,lto --disable-nls --disable-shared --disable-libssp --enable-threads=posix --disable-libgomp --enable-tls --enable-lto --disable-symvers && $(MAKE) $(NJOBS) all-gcc; $(MAKE) install-all-gcc; $(MAKE) $(NJOBS) all-target-libgcc && $(MAKE) install-target-libgcc && $(MAKE) $(NJOBS) && $(MAKE) install
clean:
@echo Cleaning toolchain
$Q$(MAKE) -C $(OMPRT) clean
$Q$(MAKE) -C ircce clean
$Q$(MAKE) -C tests clean
$Q$(MAKE) -C benchmarks clean
$Q$(MAKE) -C openmpbench clean
$Q$(MAKE) -C xray clean
veryclean:
@echo Propper cleaning of the toolchain
$Q$(MAKE) -C $(OMPRT) veryclean
$Q$(MAKE) -C ircce veryclean
$Q$(MAKE) -C tests veryclean
$Q$(MAKE) -C benchmarks veryclean
$Q$(MAKE) -C openmpbench veryclean
$Q$(RM) binutils gcc newlib pte
$Q$(RM) $(TMP)
.PHONY: default all clean veryclean headers libpthread libs

21
usr/benchmarks/CMakeLists.txt Normal file
View file

@ -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)

126
usr/benchmarks/Makefile
View file

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

18
usr/ircce/CMakeLists.txt Normal file
View file

@ -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)

56
usr/ircce/Makefile.in
View file

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

21
usr/openmpbench/CMakeLists.txt Normal file
View file

@ -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)

59
usr/openmpbench/Makefile
View file

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

14
usr/openmpbench/Makefile.defs
View file

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

10
usr/openmpbench/Makefile.defs.hector.cray
View file

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

12
usr/openmpbench/Makefile.defs.hector.pgi
View file

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

10
usr/openmpbench/Makefile.defs.magny0.gnu
View file

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

10
usr/openmpbench/Makefile.defs.magny0.sun
View file

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

10
usr/openmpbench/Makefile.defs.stokes.gnu
View file

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

10
usr/openmpbench/Makefile.defs.stokes.intel
View file

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

6
usr/openmpbench/syncbench.c
View file

@ -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);

25
usr/tests/CMakeLists.txt Normal file
View file

@ -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)

138
usr/tests/Makefile
View file

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

Some files were not shown because too many files have changed in this diff Show more