seL4

https://docs.sel4.systems
Admin
The seL4 documentation site provides resources for cooperatively developing and sharing information...
Tokens:305,191
Snippets:3,851
Trust Score:9.9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Setup Docker Environment

Source: https://docs.sel4.systems/projects/microkit/tutorial/part0.html

Commands to initialize the tutorial directory and start the Docker container environment.

```bash
# First make a directory for the tutorial
mkdir microkit_tutorial
cd microkit_tutorial
# Then start the Docker container
container
# Then download and extract the SDK
curl -L https://github.com/seL4/microkit/releases/download/2.2.0/microkit-sdk-2.2.0-linux-x86-64.tar.gz -o sdk.tar.gz
tar xf sdk.tar.gz
```

--------------------------------

### Run the hello world example

Source: https://docs.sel4.systems/projects/rust/tutorial/root-task/hello-world.html

Commands to navigate to the project directory and simulate the hello world example.

```bash
cd workspaces/root-task/hello-world
make simulate
```

--------------------------------

### Run the Microkit Hello World example

Source: https://docs.sel4.systems/projects/rust/tutorial/microkit/hello-world.html

Commands to navigate to the example directory and execute the simulation.

```bash
cd workspaces/microkit/hello-world
make simulate
```

--------------------------------

### Configure simple example for IA32

Source: https://docs.sel4.systems/projects/camkes/manual.html

Alternative configuration command for running the simple example on the IA32 platform.

```bash
../init-build.sh -DPLATFORM=ia32 -DCAMKES_APP=simple -DSIMULATION=1
```

--------------------------------

### Install Tutorial Dependencies on Linux

Source: https://docs.sel4.systems/projects/microkit/tutorial/part0.html

Commands to install necessary build and simulation tools for various Linux distributions.

```bash
sudo apt update && sudo apt install -y make gcc-aarch64-linux-gnu qemu-system-arm
```

```bash
sudo pacman -Sy make aarch64-linux-gnu-gcc qemu-system-aarch64
```

```bash
sudo dnf install -y make qemu-system-aarch64 gcc-aarch64-linux-gnu
```

--------------------------------

### Start QEMU with GDB Server

Source: https://docs.sel4.systems/projects/sel4-tutorials/debugging-guide.html

Launch QEMU with flags to pause execution on start and enable a GDB server on port 1234.

```bash
./simulate --extra-qemu-args="-S -s"
```

--------------------------------

### Install QEMU for simulation

Source: https://docs.sel4.systems/projects/buildsystem/host-dependencies.html

Installs QEMU system emulators for ARM and x86 architectures to run seL4 projects.

```bash
sudo apt-get install qemu-system-arm qemu-system-x86 qemu-system-misc
```

--------------------------------

### VSpace Bootstrap Solution

Source: https://docs.sel4.systems/Tutorials/libraries-3.html

Example implementation for bootstrapping the vspace.

```c
    error = sel4utils_bootstrap_vspace_with_bootinfo_leaky(&vspace,
                                                           &data, simple_get_pd(&simple), &vka, info);
```

--------------------------------

### Run the IPC example

Source: https://docs.sel4.systems/projects/rust/tutorial/microkit/ipc.html

Commands to navigate to the IPC workspace and simulate the system.

```bash
cd workspaces/microkit/ipc
make simulate
```

--------------------------------

### View tutorial steps

Source: https://docs.sel4.systems/projects/rust/tutorial/setup.html

Lists the commit history between the starting and ending points of the tutorial.

```bash
git log 6c27c451d991..74198364fb44
```

--------------------------------

### Run the thread spawning example

Source: https://docs.sel4.systems/projects/rust/tutorial/root-task/spawn-thread.html

Commands to navigate to the project directory and execute the simulation.

```bash
cd workspaces/root-task/spawn-thread
make simulate
```

--------------------------------

### Start VisualCAmkES

Source: https://docs.sel4.systems/projects/camkes/visual-camkes

Execute this command from the root of the repository collection to launch the application.

```bash
python projects/camkes-tool/camkes/visualCAmkES/visualCAmkES
```

--------------------------------

### Run the serial device example

Source: https://docs.sel4.systems/projects/rust/tutorial/root-task/serial-device.html

Commands to navigate to the project directory and execute the simulation.

```bash
cd workspaces/root-task/serial-device
make simulate
```

--------------------------------

### System fault output

Source: https://docs.sel4.systems/projects/microkit/tutorial/part1.html

Example output showing a virtual memory fault when the system starts.

```text
MON|ERROR: received message 0x00000006  badge: 0x0000000000000001  tcb cap: 0x8000000000000006
MON|ERROR: faulting PD: serial_server
MON|ERROR: Registers:
MON|ERROR: pc : 0x00000000002000e8
MON|ERROR: spsr : 0x0000000000000040
MON|ERROR: x0 : 0x0000000000000050
MON|ERROR: x1 : 0x0000000000000038
MON|ERROR: x2 : 0x0000000000000000
MON|ERROR: x3 : 0x0000000000000000
MON|ERROR: x4 : 0x0000000000000000
MON|ERROR: x5 : 0x0000000000000000
MON|ERROR: x6 : 0x0000000000000000
MON|ERROR: x7 : 0x0000000000000000
MON|ERROR: VMFault: ip=0x00000000002000e8  fault_addr=0x0000000000000038  fsr=0x0000000092000046  (data fault)
MON|ERROR:    ec: 0x00000024  Data Abort from a lower Exception level   il: 1   iss: 0x00000046
MON|ERROR:    dfsc = translation fault, level 2 (0x00000006) -- write not read
```

--------------------------------

### Initialize the tutorial exercise

Source: https://docs.sel4.systems/Tutorials/notifications.html

Commands to set up the build directory for the notifications tutorial.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut notifications
# building the tutorial exercise
cd notifications_build
ninja
```

--------------------------------

### Initialize and sync tutorial repository

Source: https://docs.sel4.systems/Tutorials/get-the-tutorials.html

Creates a directory and uses the repo tool to download the necessary tutorial source code.

```bash
mkdir tutorials
cd tutorials
repo init -u https://github.com/seL4/sel4-tutorials-manifest
repo sync
```

--------------------------------

### Start the timer

Source: https://docs.sel4.systems/Tutorials/hello-camkes-timer.html

Start the timer driver after successful initialization.

```c
    /* Part 1, TASK 8: start the timer */
    /* hint: timer_start
     */
```

```c
    /* Part 1, TASK 8: start the timer */
    error = timer_start(&timer_drv);
    assert(error == 0);
```

--------------------------------

### Initialize and build the tutorial solution

Source: https://docs.sel4.systems/Tutorials/camkes-vm-linux.html

Commands to initialize the build directory using the provided solution and then build the project.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut camkes-vm-linux
# building the tutorial exercise
cd camkes-vm-linux_build
ninja
```

--------------------------------

### Install ARM cross-compilers

Source: https://docs.sel4.systems/projects/buildsystem/host-dependencies.html

Installs cross-compilation toolchains for ARM targets.

```bash
sudo apt-get install gcc-arm-linux-gnueabi g++-arm-linux-gnueabi
sudo apt-get install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
```

```bash
sudo apt-get install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf
```

--------------------------------

### Initialize the tutorial solution

Source: https://docs.sel4.systems/Tutorials/interrupts.html?tut_expand=

Commands to initialize the build directory with the complete tutorial solution.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut interrupts
# building the tutorial exercise
cd interrupts_build
ninja
```

--------------------------------

### Install additional dependencies

Source: https://docs.sel4.systems/projects/camkes/visual-camkes

Install the ansi2html package required for tool functionality.

```bash
sudo pip install ansi2html
```

--------------------------------

### Initialize the threads tutorial solution

Source: https://docs.sel4.systems/Tutorials/threads.html?tut_expand=

Commands to set up the build environment using the provided tutorial solution.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut threads
# building the tutorial exercise
cd threads_build
ninja
```

--------------------------------

### Install Minicom

Source: https://docs.sel4.systems/Hardware/BeagleBoard.html

Installs the Minicom serial communication tool on Debian-based systems.

```bash
sudo apt-get install minicom
```

--------------------------------

### Install Python dependencies

Source: https://docs.sel4.systems/projects/buildsystem/host-dependencies.html

Installs required Python packages for building seL4 and its documentation.

```bash
pip3 install --user setuptools sel4-deps
```

--------------------------------

### Initialize and build the timer tutorial

Source: https://docs.sel4.systems/Tutorials/libraries-4.html?tut_expand=

Commands to set up the build directory and compile the tutorial exercise.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut libraries-4
# building the tutorial exercise
cd libraries-4_build
ninja
```

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut libraries-4
# building the tutorial exercise
cd libraries-4_build
ninja
```

--------------------------------

### Install macOS Dependencies

Source: https://docs.sel4.systems/projects/microkit/tutorial/part0.html

Use Homebrew to install the required cross-compilation and simulation tools on macOS.

```bash
brew tap messense/macos-cross-toolchains
brew install make qemu aarch64-unknown-linux-gnu
```

--------------------------------

### Initialize the untyped tutorial solution

Source: https://docs.sel4.systems/Tutorials/untyped.html

Commands to set up the build directory and compile the complete solution for the untyped tutorial.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut untyped
# building the tutorial exercise
cd untyped_build
ninja
```

--------------------------------

### Install Graphviz dependencies

Source: https://docs.sel4.systems/projects/camkes/visual-camkes

Install Graphviz and related Python packages for Linux or macOS environments.

```bash
sudo apt-get install graphviz
sudo pip install graphviz
sudo pip install pydotplus
```

```bash
brew install graphviz
```

--------------------------------

### Install Haskell stack

Source: https://docs.sel4.systems/projects/camkes/setting-up.html

Install the Haskell stack via script or system package manager.

```bash
curl -sSL https://get.haskellstack.org/ | sh
```

```bash
sudo apt-get install haskell-stack
```

--------------------------------

### Initialize and build the tutorial

Source: https://docs.sel4.systems/Tutorials/camkes-vm-crossvm.html

Commands to initialize the build directory for the cross-VM tutorial and compile the project.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut camkes-vm-crossvm
# building the tutorial exercise
cd camkes-vm-crossvm_build
ninja
```

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut camkes-vm-crossvm
# building the tutorial exercise
cd camkes-vm-crossvm_build
ninja
```

--------------------------------

### Install Google Repo tool

Source: https://docs.sel4.systems/Tutorials/setting-up.html

Use these commands to install the Repo tool on Debian-based systems.

```bash
  sudo apt-get update
  sudo apt-get install repo
```

--------------------------------

### Initialize and build the mapping tutorial solution

Source: https://docs.sel4.systems/Tutorials/mapping.html

Commands to set up the build directory and compile the complete solution for the mapping tutorial.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut mapping
# building the tutorial exercise
cd mapping_build
ninja
```

--------------------------------

### Install CAmkES Python dependencies

Source: https://docs.sel4.systems/Tutorials/get-the-tutorials.html

Installs required Python packages for building seL4 tutorials.

```bash
pip3 install --user camkes-deps
```

--------------------------------

### Initialize and build the mapping tutorial

Source: https://docs.sel4.systems/Tutorials/mapping.html

Commands to set up the build directory and compile the mapping tutorial exercise.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut mapping
# building the tutorial exercise
cd mapping_build
ninja
```

--------------------------------

### Initialize the untyped tutorial

Source: https://docs.sel4.systems/Tutorials/untyped.html

Commands to set up the build directory and compile the untyped tutorial exercise.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut untpted
# building the tutorial exercise
cd untyped_build
ninja
```

--------------------------------

### Install Ubuntu build dependencies

Source: https://docs.sel4.systems/projects/camkes/setting-up.html

Install necessary system packages for building CAmkES on Ubuntu 22.04.

```bash
sudo apt-get install clang gdb
sudo apt-get install libssl-dev libclang-dev libcunit1-dev libsqlite3-dev
sudo apt-get install qemu-kvm
```

--------------------------------

### Clone and checkout the tutorial repository

Source: https://docs.sel4.systems/projects/rust/tutorial/setup.html

Initializes the local environment by cloning the tutorial repository and checking out the starting commit.

```bash
git clone https://github.com/seL4/seL4-rust-tutorial-code
cd seL4-rust-tutorial-code
git checkout 6c27c451d991
```

--------------------------------

### Initialize Tutorial Build

Source: https://docs.sel4.systems/Tutorials/libraries-1.html

Commands to initialize and build the tutorial exercise.

```bash
./init --tut libraries-1
cd libraries-1_build
ninja
```

```bash
./init --solution --tut libraries-1
cd libraries-1_build
ninja
```

--------------------------------

### Install CAmkES dependencies on Archlinux

Source: https://docs.sel4.systems/projects/camkes/next.html

Installs required packages via pacman and yaourt for Archlinux environments.

```bash
pacman -S binutils gcc-multilib arm-none-eabi-binutils arm-none-eabi-gcc ccache clang moreutils cpio python python-pip expect \
cmake ninja m4 automake autoconf pkg-config valgrind cppcheck python-pylint qemu qemu-arch-extra openssl bcunit

yaourt -S bcunit-cunit-compat spin

pip install camkes-deps

curl -sSL https://get.haskellstack.org/ | sh
```

--------------------------------

### Install LaTeX packages for manual

Source: https://docs.sel4.systems/projects/buildsystem/host-dependencies.html

Installs TeX Live packages required to build the seL4 manual.

```bash
sudo apt-get install texlive texlive-latex-extra texlive-fonts-extra
```

--------------------------------

### Build the tutorial exercise

Source: https://docs.sel4.systems/Tutorials/camkes-vm-linux.html

Standard commands to navigate to the build directory and execute the build process.

```bash
cd camkes-vm-linux_build
ninja
```

--------------------------------

### Install base build-essential package

Source: https://docs.sel4.systems/projects/buildsystem/host-dependencies.html

Installs the fundamental build tools required for compiling seL4 on Ubuntu.

```bash
sudo apt-get update
sudo apt-get install build-essential
```

--------------------------------

### Initialize the capabilities tutorial solution

Source: https://docs.sel4.systems/Tutorials/capabilities.html

Commands to initialize the build directory with the complete solution for the capabilities tutorial.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut capabilities
# building the tutorial exercise
cd capabilities_build
ninja
```

--------------------------------

### Install Build Dependencies

Source: https://docs.sel4.systems/Hardware/jetsontk1.html

Installs required packages for building the U-Boot flasher on Debian or Ubuntu systems.

```bash
sudo apt-get update
sudo apt-get install build-essential autoconf pkg-config flex bison libcrypto++-dev libusb-1.0.0-dev gcc-arm-linux-gnueabi
```

--------------------------------

### Build the tutorial project

Source: https://docs.sel4.systems/projects/microkit/tutorial/part1.html

Commands to navigate to the tutorial directory, build the project, and verify the generated files.

```bash
# Run these commands inside the "microkit_tutorial" directory
$ cd tutorial
# If you are working on native macOS, `make` may be installed as `gmake` instead.
$ make part1
$ ls build
serial_server.elf serial_server.o loader.img report.txt
```

--------------------------------

### Example tutorial output

Source: https://docs.sel4.systems/Tutorials/capabilities.html?tut_expand=

Sample console output showing boot status and a failed invocation error.

```text
Booting all finished, dropped to user space
Initial CNode is 65536 slots in size
The CNode is 0 bytes in size
<<seL4(CPU 0) [decodeInvocation/530 T0xffffff801ffb5400 "rootserver" @401397]: Attempted to invoke a null cap #4095.>>
main@main.c:33 [Cond failed: error]
    Failed to set priority
```

--------------------------------

### Install Android Bootimg Tool

Source: https://docs.sel4.systems/Hardware/IF6410.html

Install the required tool for creating bootable images on Debian-based systems.

```bash
apt-get install android-mkbootimg
```

--------------------------------

### Initialize and build the threads tutorial

Source: https://docs.sel4.systems/Tutorials/threads.html

Commands to set up the build directory and compile the threads tutorial exercise.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut threads
# building the tutorial exercise
cd threads_build
ninja
```

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut threads
# building the tutorial exercise
cd threads_build
ninja
```

--------------------------------

### Initialize and Build Tutorial

Source: https://docs.sel4.systems/Tutorials/capabilities.html?tut_expand=

Commands to initialize the build directory for the capabilities tutorial and compile the project.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut capabilities
# building the tutorial exercise
cd capabilities_build
ninja
```

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut capabilities
# building the tutorial exercise
cd capabilities_build
ninja
```

--------------------------------

### Initialize the capabilities tutorial

Source: https://docs.sel4.systems/Tutorials/capabilities.html

Commands to initialize the build directory for the capabilities tutorial exercise.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut capabilities
# building the tutorial exercise
cd capabilities_build
ninja
```

--------------------------------

### Install PyQt5 via apt-get

Source: https://docs.sel4.systems/projects/camkes/visual-camkes

Use this command to install the necessary PyQt5 packages on Debian or Ubuntu systems.

```bash
sudo apt-get install python-pyqt5
sudo apt-get install python-pyqt5.qtsvg
```

--------------------------------

### Initialize the tutorial build environment

Source: https://docs.sel4.systems/Tutorials/libraries-4.html

Commands to initialize the build directory for the libraries-4 tutorial exercise.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut libraries-4
# building the tutorial exercise
cd libraries-4_build
ninja
```

--------------------------------

### Initialize and build the tutorial

Source: https://docs.sel4.systems/Tutorials/hello-world.html

Commands to initialize the tutorial source and build the project using ninja.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut hello-world
# building the tutorial exercise
cd hello-world_build
ninja
```

--------------------------------

### Install Vivado Cable Drivers

Source: https://docs.sel4.systems/Hardware/ZC706.html

Script to detect system architecture and execute the Xilinx cable driver installation.

```bash
uname -a | grep "x86_64" && LIN=lin64 || LIN=lin
cd /opt/Xilinx/SDK/2014.4/data/xicom/cable_drivers/$LIN/install_script/install_drivers
sudo ./install_drivers
```

--------------------------------

### Initialize and Build Tutorial

Source: https://docs.sel4.systems/Tutorials/hello-world.html

Commands to initialize the tutorial environment and build the project using ninja.

```bash
./init --solution --tut hello-world
cd hello-world_build
ninja
```

--------------------------------

### MCP251X Device Tree Binding Example

Source: https://docs.sel4.systems/Hardware/CEI_TK1_SOM/L4TCan

Example configuration for the MCP2515 CAN controller within a device tree file.

```dts
  can0: <can@1> {

      compatible = "microchip,mcp2515";
      reg = <1>;
      clocks = <&clk24m>;
      interrupt-parent = <&gpio4>;
      interrupts = <13 0x2>;
      vdd-supply = <&reg5v0>;
      xceiver-supply = <&reg5v0>;
  };
```

--------------------------------

### Example GNU Assembler error output

Source: https://docs.sel4.systems/projects/camkes/manual.html

Example of an error message encountered on older binutils versions when using large frames.

```text
/tmp/ccfGhK5Z.s: Assembler messages:
/tmp/ccfGhK5Z.s:1483: Error: alignment too large: 15 assumed
```

--------------------------------

### Initialize and Simulate seL4 Project

Source: https://docs.sel4.systems/projects/sel4-tutorials/debugging-guide.html

Commands to create a build directory, configure for simulation, and start the QEMU simulation.

```bash
mkdir build_dir
cd build_dir
../init-build.sh -DSIMULATION=1
./simulate
```

--------------------------------

### Initialize the tutorial build environment

Source: https://docs.sel4.systems/Tutorials/libraries-3.html?tut_expand=

Commands to initialize the build directory for the libraries-3 tutorial.

```bash
./init --tut libraries-3
cd libraries-3_build
ninja
```

--------------------------------

### Kernel Fault Output Example

Source: https://docs.sel4.systems/Tutorials/threads.html

Example of a cap fault output generated by the kernel when a thread accesses an invalid memory address.

```text
Caught cap fault in send phase at address 0
while trying to handle:
vm fault on data at address 0x2 with status 0x4
in thread 0xffffff8008140400 "child of: 'tcb_threads'" at address 0x401e66
With stack:
0x439fc0: 0x0
0x439fc8: 0x3
0x439fd0: 0x2
0x439fd8: 0x1
0x439fe0: 0x0
0x439fe8: 0x1
0x439ff0: 0x0
0x439ff8: 0x0
0x43a000: 0x404fb3
0x43a008: 0x0
0x43a010: 0x0
0x43a018: 0x0
0x43a020: 0x0
0x43a028: 0x0
0x43a030: 0x0
0x43a038: 0x0
```

--------------------------------

### Initialize MCS Tutorial Solutions

Source: https://docs.sel4.systems/Tutorials/mcs.html

Commands to initialize the build directory with the provided tutorial solutions.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut mcs
# building the tutorial exercise
cd mcs_build
ninja
```

--------------------------------

### Install CAmkES dependencies on Ubuntu 16.04

Source: https://docs.sel4.systems/projects/camkes/next.html

Installs required system packages and Python dependencies for building seL4 and CAmkES Next on Ubuntu 16.04.

```bash
apt-get install git repo libncurses-dev python-pip libxml2-utils cmake ninja-build clang libssl-dev libsqlite3-dev \
libcunit1-dev gcc-multilib expect qemu-system-x86 qemu-system-arm gcc-arm-none-eabi binutils-arm-none-eabi

pip install six plyplus pyelftools orderedset jinja2

curl -sSL https://get.haskellstack.org/ | sh
```

--------------------------------

### Build tutorial solutions

Source: https://docs.sel4.systems/projects/microkit/tutorial/end.html

Navigates to the solutions directory and builds the specified part.

```bash
cd solutions
make part4
```

--------------------------------

### Install additional build dependencies

Source: https://docs.sel4.systems/projects/buildsystem/host-dependencies.html

Installs necessary libraries and tools for building seL4 projects, including CMake, Git, and Python development headers.

```bash
sudo apt-get install cmake ccache ninja-build cmake-curses-gui
sudo apt-get install libxml2-utils ncurses-dev
sudo apt-get install curl git doxygen device-tree-compiler xxd
sudo apt-get install u-boot-tools
sudo apt-get install python3-dev python3-pip python-is-python3
sudo apt-get install protobuf-compiler python3-protobuf
```

--------------------------------

### Install CAmkES dependencies on Ubuntu 14.04

Source: https://docs.sel4.systems/projects/camkes/next.html

Configures the environment for Ubuntu 14.04 by adding a PPA for newer GCC versions and installing necessary build tools.

```bash
add-apt-repository ppa:ubuntu-toolchain-r/test
apt-get update
apt-get install git phablet-tools libncurses-dev python-dev python-pip libxml2-utils cmake ninja-build clang libssl-dev \
libsqlite3-dev libcunit1-dev gcc-multilib expect qemu-system-x86 qemu-system-arm gcc-arm-none-eabi binutils-arm-none-eabi \
gcc-5 gcc-5-multilib
update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 60

pip install camkes-deps

curl -sSL https://get.haskellstack.org/ | sh
```

--------------------------------

### Initialize and build the tutorial

Source: https://docs.sel4.systems/Tutorials/hello-camkes-2.html

Commands to initialize the build directory for the hello-camkes-2 exercise and compile it using ninja.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut hello-camkes-2
# building the tutorial exercise
cd hello-camkes-2_build
ninja
```

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --solution --tut hello-camkes-2
# building the tutorial exercise
cd hello-camkes-2_build
ninja
```

--------------------------------

### microkit_mr_get

Source: https://docs.sel4.systems/projects/microkit/manual/2.1.0

Get a message register.

```APIDOC
## uint64_t microkit_mr_get(uint8_t mr)

### Description
Get a message register.
```

--------------------------------

### Initialize the threads tutorial

Source: https://docs.sel4.systems/Tutorials/threads.html?tut_expand=

Commands to set up the build environment for the threads tutorial exercise.

```bash
# For instructions about obtaining the tutorial sources see /Tutorials/get-the-tutorials
#
# Follow these instructions to initialise the tutorial
# initialising the build directory with a tutorial exercise
./init --tut threads
# building the tutorial exercise
cd threads_build
ninja
```
Tokens:
Raw