BranchesTags

Repository files navigation

seL4 Microkit

The purpose of the seL4 Microkit is to enable system designers to create static software systems based on the seL4 microkernel.

The seL4 Microkit consists of three parts:

  • Microkit Library
  • Microkit initial task
  • Microkit tool

The Microkit is distributed as a software development kit (SDK).

This repository is the source for the Microkit SDK.

If you are developing Microkit itself this is the repo you want!

If you are a system designer and want to use the Microkit SDK please download a pre-built SDK. Please see the manual in the SDK for instructions on using the SDK itself.

The remainder of this README is for Microkit developers.

Developer system requirements

Development of Microkit has primarily been performed on Ubuntu 18.04 LTS (x86_64).

This section attempts to list the packages or external development tools which are required during development. At this stage it may be incomplete. Please file an issue if additional packages are required.

  • git
  • make
  • python3.9
  • python3.9-venv
  • musl-1.2.2
  • ARM GCC compiler; 10.2-2020.11

On Ubuntu 18.04 there are no packages available for musl-1.2.2; it must be compiled from source. On Ubuntu 18.04 Python 3.9 is available via the deadsnakes PPA: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa To use this:

$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt update
$ sudo apt install python3.9 python3.9-venv

Additonally, a number of Python libraries are needed. These should be installed using pip.

$ python3.9 -m venv pyenv
$ ./pyenv/bin/pip install --upgrade pip setuptools wheel
$ ./pyenv/bin/pip install -r requirements.txt

Note: It is a high priority of the authors to ensure builds are self-contained and repeatable. A high value is placed on using specifically versioned tools. At this point in time this is not fully realised, however it is a high priority to enable this in the near future.

The ARM toolchain is available from:

https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11

The specific version used for development is the x86_64-aarch64-none-elf version:

https://developer.arm.com/-/media/Files/downloads/gnu-a/10.2-2020.11/binrel/gcc-arm-10.2-2020.11-x86_64-aarch64-none-elf.tar.xz?revision=79f65c42-1a1b-43f2-acb7-a795c8427085&hash=61BBFB526E785D234C5D8718D9BA8E61

Note: There are no plans to support development of Microkit on any platforms other than Linux x86_64.

seL4 Version

The SDK includes a binary of the seL4 kernel. During the SDK build process the kernel is build from source.

At this point in time there are some minor changes to the seL4 kernel required for Microkit. This is temporary, more details can be found here.

Please clone seL4 from:

https://github.com/seL4/seL4.git

The correct branch to use is microkit.

Testing has been performed using commit 92f0f3ab28f00c97851512216c855f4180534a60.

Building the SDK

$ ./pyenv/bin/python build_sdk.py --sel4=<path to sel4>

Using the SDK

After building the SDK you probably want to build a system! Please see the SDK user manual for documentation on the SDK itself.

When developing the SDK it is helpful to be able to build examples system quickly for testing purposes. The dev_build.py script can be used for this purpose. This script is not included in the SDK and is just meant for use of use of Microkit developers.

By default dev_build.py will use the example source directly from the source directory. In some cases you may want to test that the example source has been correctly included into the SDK. To test this pass --example-from-sdk to the build script.

By default dev_build.py will use the the Microkit tool directory from source (in tool/microkit). However, in some cases it is desirable to test the Microkit tool built into the SDK. In this case pass --tool-from-sdk to use the tool that is built into the SDK.

Finally, by default the dev_build.py script relies on the default Makefile dependecy resolution. However, in some cases it is useful to force a rebuild while doing SDK development. For example, the Makefile can't know about the state of the Microkit tool source code. To support this a --rebuild option is provided.

SDK Layout

The SDK is delivered as a tar.gz file.

The SDK top-level directory is microkit-sdk-$VERSION.

The directory layout underneath the top-level directory is:

bin/
bin/microkit
board/$board/$config/include/
board/$board/$config/include/microkit.h
board/$board/$config/lib/
board/$board/$config/lib/libmicrokit.a
board/$board/$config/lib/microkit.ld
board/$board/$config/elf
board/$board/$config/elf/loader.elf
board/$board/$config/elf/kernel.elf
board/$board/$config/elf/monitor.elf

The currently supported boards:

  • tqma8xqp1gb

The currently supported configurations are:

  • release
  • debug

Supported Boards

tqma8xqp-1gb

The TQMa8Xx Embedded Module from TQ Group configured with the NXP i.MX8QXP SoC and 1GiB of DDR3 ECC memory.

https://www.tq-group.com/en/products/tq-embedded/arm-architecture/tqma8xx/

All testing has been performed with the module on the MBa8Xx carrier board which is included in the starter kit.

The provided board support should be at the module level and does not make any assumptions about the carrier board.

Note: There are different configured of the TQMa8Xx board which include different NXP SoCs and different memory configurations. Such modules are not supported.

Supported Configurations

Release

In release configuration the loader, kernel and monitor do not perform any direct serial output.

Debug

The debug configuration includes basic print output form the loader, kernel and monitor.

About

Microkit - A simple operating system framework for the seL4 microkernel

Resources

Readme
License

Code of conduct

Code of conduct

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
seL4 Microkit
The purpose of the seL4 Microkit is to enable system designers to create static software systems based on the seL4 microkernel.
The seL4 Microkit consists of three parts:
  • Microkit Library
  • Microkit initial task
  • Microkit tool
The Microkit is distributed as a software development kit (SDK).
This repository is the source for the Microkit SDK.
If you are developing Microkit itself this is the repo you want!
If you are a system designer and want to use the Microkit SDK please download a pre-built SDK.
Please see the manual in the SDK for instructions on using the SDK itself.
The remainder of this README is for Microkit developers.
Developer system requirements
Development of Microkit has primarily been performed on Ubuntu 18.04 LTS (x86_64).
This section attempts to list the packages or external development tools which are required during development.
At this stage it may be incomplete.
Please file an issue if additional packages are required.
  • git
  • make
  • python3.9
  • python3.9-venv
  • musl-1.2.2
  • ARM GCC compiler; 10.2-2020.11
On Ubuntu 18.04 there are no packages available for musl-1.2.2; it must be compiled from source.
On Ubuntu 18.04 Python 3.9 is available via the deadsnakes PPA: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa
To use this:
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt update
$ sudo apt install python3.9 python3.9-venv

Additonally, a number of Python libraries are needed.
These should be installed using pip.
$ python3.9 -m venv pyenv
$ ./pyenv/bin/pip install --upgrade pip setuptools wheel
$ ./pyenv/bin/pip install -r requirements.txt

Note: It is a high priority of the authors to ensure builds are self-contained and repeatable.
A high value is placed on using specifically versioned tools.
At this point in time this is not fully realised, however it is a high priority to enable this in the near future.
The ARM toolchain is available from:
https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11
The specific version used for development is the x86_64-aarch64-none-elf version:
https://developer.arm.com/-/media/Files/downloads/gnu-a/10.2-2020.11/binrel/gcc-arm-10.2-2020.11-x86_64-aarch64-none-elf.tar.xz?revision=79f65c42-1a1b-43f2-acb7-a795c8427085&hash=61BBFB526E785D234C5D8718D9BA8E61
Note: There are no plans to support development of Microkit on any platforms other than Linux x86_64.
seL4 Version
The SDK includes a binary of the seL4 kernel.
During the SDK build process the kernel is build from source.
At this point in time there are some minor changes to the seL4 kernel required for Microkit. This is temporary, more details can be found here.
Please clone seL4 from:
https://github.com/seL4/seL4.git

The correct branch to use is microkit.
Testing has been performed using commit 92f0f3ab28f00c97851512216c855f4180534a60.
Building the SDK
$ ./pyenv/bin/python build_sdk.py --sel4=<path to sel4>

Using the SDK
After building the SDK you probably want to build a system!
Please see the SDK user manual for documentation on the SDK itself.
When developing the SDK it is helpful to be able to build examples system quickly for testing purposes.
The dev_build.py script can be used for this purpose.
This script is not included in the SDK and is just meant for use of use of Microkit developers.
By default dev_build.py will use the example source directly from the source directory.
In some cases you may want to test that the example source has been correctly included into the SDK.
To test this pass --example-from-sdk to the build script.
By default dev_build.py will use the the Microkit tool directory from source (in tool/microkit).
However, in some cases it is desirable to test the Microkit tool built into the SDK.
In this case pass --tool-from-sdk to use the tool that is built into the SDK.
Finally, by default the dev_build.py script relies on the default Makefile dependecy resolution.
However, in some cases it is useful to force a rebuild while doing SDK development.
For example, the Makefile can't know about the state of the Microkit tool source code.
To support this a --rebuild option is provided.
SDK Layout
The SDK is delivered as a tar.gz file.
The SDK top-level directory is microkit-sdk-$VERSION.
The directory layout underneath the top-level directory is:
bin/
bin/microkit
board/$board/$config/include/
board/$board/$config/include/microkit.h
board/$board/$config/lib/
board/$board/$config/lib/libmicrokit.a
board/$board/$config/lib/microkit.ld
board/$board/$config/elf
board/$board/$config/elf/loader.elf
board/$board/$config/elf/kernel.elf
board/$board/$config/elf/monitor.elf

The currently supported boards:
  • tqma8xqp1gb
The currently supported configurations are:
  • release
  • debug
Supported Boards
tqma8xqp-1gb
The TQMa8Xx Embedded Module from TQ Group configured with the NXP i.MX8QXP SoC and 1GiB of DDR3 ECC memory.
https://www.tq-group.com/en/products/tq-embedded/arm-architecture/tqma8xx/
All testing has been performed with the module on the MBa8Xx carrier board which is included in the starter kit.
The provided board support should be at the module level and does not make any assumptions about the carrier board.
Note: There are different configured of the TQMa8Xx board which include different NXP SoCs and different memory configurations.
Such modules are not supported.
Supported Configurations
Release
In release configuration the loader, kernel and monitor do not perform any direct serial output.
Debug
The debug configuration includes basic print output form the loader, kernel and monitor.
About
Microkit - A simple operating system framework for the seL4 microkernel
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
seL4 Microkit
The purpose of the seL4 Microkit is to enable system designers to create static software systems based on the seL4 microkernel.
The seL4 Microkit consists of three parts:
  • Microkit Library
  • Microkit initial task
  • Microkit tool
The Microkit is distributed as a software development kit (SDK).
This repository is the source for the Microkit SDK.
If you are developing Microkit itself this is the repo you want!
If you are a system designer and want to use the Microkit SDK please download a pre-built SDK.
Please see the manual in the SDK for instructions on using the SDK itself.
The remainder of this README is for Microkit developers.
Developer system requirements
Development of Microkit has primarily been performed on Ubuntu 18.04 LTS (x86_64).
This section attempts to list the packages or external development tools which are required during development.
At this stage it may be incomplete.
Please file an issue if additional packages are required.
  • git
  • make
  • python3.9
  • python3.9-venv
  • musl-1.2.2
  • ARM GCC compiler; 10.2-2020.11
On Ubuntu 18.04 there are no packages available for musl-1.2.2; it must be compiled from source.
On Ubuntu 18.04 Python 3.9 is available via the deadsnakes PPA: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa
To use this:
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt update
$ sudo apt install python3.9 python3.9-venv

Additonally, a number of Python libraries are needed.
These should be installed using pip.
$ python3.9 -m venv pyenv
$ ./pyenv/bin/pip install --upgrade pip setuptools wheel
$ ./pyenv/bin/pip install -r requirements.txt

Note: It is a high priority of the authors to ensure builds are self-contained and repeatable.
A high value is placed on using specifically versioned tools.
At this point in time this is not fully realised, however it is a high priority to enable this in the near future.
The ARM toolchain is available from:
https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11
The specific version used for development is the x86_64-aarch64-none-elf version:
https://developer.arm.com/-/media/Files/downloads/gnu-a/10.2-2020.11/binrel/gcc-arm-10.2-2020.11-x86_64-aarch64-none-elf.tar.xz?revision=79f65c42-1a1b-43f2-acb7-a795c8427085&hash=61BBFB526E785D234C5D8718D9BA8E61
Note: There are no plans to support development of Microkit on any platforms other than Linux x86_64.
seL4 Version
The SDK includes a binary of the seL4 kernel.
During the SDK build process the kernel is build from source.
At this point in time there are some minor changes to the seL4 kernel required for Microkit. This is temporary, more details can be found here.
Please clone seL4 from:
https://github.com/seL4/seL4.git

The correct branch to use is microkit.
Testing has been performed using commit 92f0f3ab28f00c97851512216c855f4180534a60.
Building the SDK
$ ./pyenv/bin/python build_sdk.py --sel4=<path to sel4>

Using the SDK
After building the SDK you probably want to build a system!
Please see the SDK user manual for documentation on the SDK itself.
When developing the SDK it is helpful to be able to build examples system quickly for testing purposes.
The dev_build.py script can be used for this purpose.
This script is not included in the SDK and is just meant for use of use of Microkit developers.
By default dev_build.py will use the example source directly from the source directory.
In some cases you may want to test that the example source has been correctly included into the SDK.
To test this pass --example-from-sdk to the build script.
By default dev_build.py will use the the Microkit tool directory from source (in tool/microkit).
However, in some cases it is desirable to test the Microkit tool built into the SDK.
In this case pass --tool-from-sdk to use the tool that is built into the SDK.
Finally, by default the dev_build.py script relies on the default Makefile dependecy resolution.
However, in some cases it is useful to force a rebuild while doing SDK development.
For example, the Makefile can't know about the state of the Microkit tool source code.
To support this a --rebuild option is provided.
SDK Layout
The SDK is delivered as a tar.gz file.
The SDK top-level directory is microkit-sdk-$VERSION.
The directory layout underneath the top-level directory is:
bin/
bin/microkit
board/$board/$config/include/
board/$board/$config/include/microkit.h
board/$board/$config/lib/
board/$board/$config/lib/libmicrokit.a
board/$board/$config/lib/microkit.ld
board/$board/$config/elf
board/$board/$config/elf/loader.elf
board/$board/$config/elf/kernel.elf
board/$board/$config/elf/monitor.elf

The currently supported boards:
  • tqma8xqp1gb
The currently supported configurations are:
  • release
  • debug
Supported Boards
tqma8xqp-1gb
The TQMa8Xx Embedded Module from TQ Group configured with the NXP i.MX8QXP SoC and 1GiB of DDR3 ECC memory.
https://www.tq-group.com/en/products/tq-embedded/arm-architecture/tqma8xx/
All testing has been performed with the module on the MBa8Xx carrier board which is included in the starter kit.
The provided board support should be at the module level and does not make any assumptions about the carrier board.
Note: There are different configured of the TQMa8Xx board which include different NXP SoCs and different memory configurations.
Such modules are not supported.
Supported Configurations
Release
In release configuration the loader, kernel and monitor do not perform any direct serial output.
Debug
The debug configuration includes basic print output form the loader, kernel and monitor.
About
Microkit - A simple operating system framework for the seL4 microkernel
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
seL4 Microkit
The purpose of the seL4 Microkit is to enable system designers to create static software systems based on the seL4 microkernel.
The seL4 Microkit consists of three parts:
  • Microkit Library
  • Microkit initial task
  • Microkit tool
The Microkit is distributed as a software development kit (SDK).
This repository is the source for the Microkit SDK.
If you are developing Microkit itself this is the repo you want!
If you are a system designer and want to use the Microkit SDK please download a pre-built SDK.
Please see the manual in the SDK for instructions on using the SDK itself.
The remainder of this README is for Microkit developers.
Developer system requirements
Development of Microkit has primarily been performed on Ubuntu 18.04 LTS (x86_64).
This section attempts to list the packages or external development tools which are required during development.
At this stage it may be incomplete.
Please file an issue if additional packages are required.
  • git
  • make
  • python3.9
  • python3.9-venv
  • musl-1.2.2
  • ARM GCC compiler; 10.2-2020.11
On Ubuntu 18.04 there are no packages available for musl-1.2.2; it must be compiled from source.
On Ubuntu 18.04 Python 3.9 is available via the deadsnakes PPA: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa
To use this:
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt update
$ sudo apt install python3.9 python3.9-venv

Additonally, a number of Python libraries are needed.
These should be installed using pip.
$ python3.9 -m venv pyenv
$ ./pyenv/bin/pip install --upgrade pip setuptools wheel
$ ./pyenv/bin/pip install -r requirements.txt

Note: It is a high priority of the authors to ensure builds are self-contained and repeatable.
A high value is placed on using specifically versioned tools.
At this point in time this is not fully realised, however it is a high priority to enable this in the near future.
The ARM toolchain is available from:
https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11
The specific version used for development is the x86_64-aarch64-none-elf version:
https://developer.arm.com/-/media/Files/downloads/gnu-a/10.2-2020.11/binrel/gcc-arm-10.2-2020.11-x86_64-aarch64-none-elf.tar.xz?revision=79f65c42-1a1b-43f2-acb7-a795c8427085&hash=61BBFB526E785D234C5D8718D9BA8E61
Note: There are no plans to support development of Microkit on any platforms other than Linux x86_64.
seL4 Version
The SDK includes a binary of the seL4 kernel.
During the SDK build process the kernel is build from source.
At this point in time there are some minor changes to the seL4 kernel required for Microkit. This is temporary, more details can be found here.
Please clone seL4 from:
https://github.com/seL4/seL4.git

The correct branch to use is microkit.
Testing has been performed using commit 92f0f3ab28f00c97851512216c855f4180534a60.
Building the SDK
$ ./pyenv/bin/python build_sdk.py --sel4=<path to sel4>

Using the SDK
After building the SDK you probably want to build a system!
Please see the SDK user manual for documentation on the SDK itself.
When developing the SDK it is helpful to be able to build examples system quickly for testing purposes.
The dev_build.py script can be used for this purpose.
This script is not included in the SDK and is just meant for use of use of Microkit developers.
By default dev_build.py will use the example source directly from the source directory.
In some cases you may want to test that the example source has been correctly included into the SDK.
To test this pass --example-from-sdk to the build script.
By default dev_build.py will use the the Microkit tool directory from source (in tool/microkit).
However, in some cases it is desirable to test the Microkit tool built into the SDK.
In this case pass --tool-from-sdk to use the tool that is built into the SDK.
Finally, by default the dev_build.py script relies on the default Makefile dependecy resolution.
However, in some cases it is useful to force a rebuild while doing SDK development.
For example, the Makefile can't know about the state of the Microkit tool source code.
To support this a --rebuild option is provided.
SDK Layout
The SDK is delivered as a tar.gz file.
The SDK top-level directory is microkit-sdk-$VERSION.
The directory layout underneath the top-level directory is:
bin/
bin/microkit
board/$board/$config/include/
board/$board/$config/include/microkit.h
board/$board/$config/lib/
board/$board/$config/lib/libmicrokit.a
board/$board/$config/lib/microkit.ld
board/$board/$config/elf
board/$board/$config/elf/loader.elf
board/$board/$config/elf/kernel.elf
board/$board/$config/elf/monitor.elf

The currently supported boards:
  • tqma8xqp1gb
The currently supported configurations are:
  • release
  • debug
Supported Boards
tqma8xqp-1gb
The TQMa8Xx Embedded Module from TQ Group configured with the NXP i.MX8QXP SoC and 1GiB of DDR3 ECC memory.
https://www.tq-group.com/en/products/tq-embedded/arm-architecture/tqma8xx/
All testing has been performed with the module on the MBa8Xx carrier board which is included in the starter kit.
The provided board support should be at the module level and does not make any assumptions about the carrier board.
Note: There are different configured of the TQMa8Xx board which include different NXP SoCs and different memory configurations.
Such modules are not supported.
Supported Configurations
Release
In release configuration the loader, kernel and monitor do not perform any direct serial output.
Debug
The debug configuration includes basic print output form the loader, kernel and monitor.
About
Microkit - A simple operating system framework for the seL4 microkernel
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
seL4 Microkit
The purpose of the seL4 Microkit is to enable system designers to create static software systems based on the seL4 microkernel.
The seL4 Microkit consists of three parts:
  • Microkit Library
  • Microkit initial task
  • Microkit tool
The Microkit is distributed as a software development kit (SDK).
This repository is the source for the Microkit SDK.
If you are developing Microkit itself this is the repo you want!
If you are a system designer and want to use the Microkit SDK please download a pre-built SDK.
Please see the manual in the SDK for instructions on using the SDK itself.
The remainder of this README is for Microkit developers.
Developer system requirements
Development of Microkit has primarily been performed on Ubuntu 18.04 LTS (x86_64).
This section attempts to list the packages or external development tools which are required during development.
At this stage it may be incomplete.
Please file an issue if additional packages are required.
  • git
  • make
  • python3.9
  • python3.9-venv
  • musl-1.2.2
  • ARM GCC compiler; 10.2-2020.11
On Ubuntu 18.04 there are no packages available for musl-1.2.2; it must be compiled from source.
On Ubuntu 18.04 Python 3.9 is available via the deadsnakes PPA: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa
To use this:
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt update
$ sudo apt install python3.9 python3.9-venv

Additonally, a number of Python libraries are needed.
These should be installed using pip.
$ python3.9 -m venv pyenv
$ ./pyenv/bin/pip install --upgrade pip setuptools wheel
$ ./pyenv/bin/pip install -r requirements.txt

Note: It is a high priority of the authors to ensure builds are self-contained and repeatable.
A high value is placed on using specifically versioned tools.
At this point in time this is not fully realised, however it is a high priority to enable this in the near future.
The ARM toolchain is available from:
https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11
The specific version used for development is the x86_64-aarch64-none-elf version:
https://developer.arm.com/-/media/Files/downloads/gnu-a/10.2-2020.11/binrel/gcc-arm-10.2-2020.11-x86_64-aarch64-none-elf.tar.xz?revision=79f65c42-1a1b-43f2-acb7-a795c8427085&hash=61BBFB526E785D234C5D8718D9BA8E61
Note: There are no plans to support development of Microkit on any platforms other than Linux x86_64.
seL4 Version
The SDK includes a binary of the seL4 kernel.
During the SDK build process the kernel is build from source.
At this point in time there are some minor changes to the seL4 kernel required for Microkit. This is temporary, more details can be found here.
Please clone seL4 from:
https://github.com/seL4/seL4.git

The correct branch to use is microkit.
Testing has been performed using commit 92f0f3ab28f00c97851512216c855f4180534a60.
Building the SDK
$ ./pyenv/bin/python build_sdk.py --sel4=<path to sel4>

Using the SDK
After building the SDK you probably want to build a system!
Please see the SDK user manual for documentation on the SDK itself.
When developing the SDK it is helpful to be able to build examples system quickly for testing purposes.
The dev_build.py script can be used for this purpose.
This script is not included in the SDK and is just meant for use of use of Microkit developers.
By default dev_build.py will use the example source directly from the source directory.
In some cases you may want to test that the example source has been correctly included into the SDK.
To test this pass --example-from-sdk to the build script.
By default dev_build.py will use the the Microkit tool directory from source (in tool/microkit).
However, in some cases it is desirable to test the Microkit tool built into the SDK.
In this case pass --tool-from-sdk to use the tool that is built into the SDK.
Finally, by default the dev_build.py script relies on the default Makefile dependecy resolution.
However, in some cases it is useful to force a rebuild while doing SDK development.
For example, the Makefile can't know about the state of the Microkit tool source code.
To support this a --rebuild option is provided.
SDK Layout
The SDK is delivered as a tar.gz file.
The SDK top-level directory is microkit-sdk-$VERSION.
The directory layout underneath the top-level directory is:
bin/
bin/microkit
board/$board/$config/include/
board/$board/$config/include/microkit.h
board/$board/$config/lib/
board/$board/$config/lib/libmicrokit.a
board/$board/$config/lib/microkit.ld
board/$board/$config/elf
board/$board/$config/elf/loader.elf
board/$board/$config/elf/kernel.elf
board/$board/$config/elf/monitor.elf

The currently supported boards:
  • tqma8xqp1gb
The currently supported configurations are:
  • release
  • debug
Supported Boards
tqma8xqp-1gb
The TQMa8Xx Embedded Module from TQ Group configured with the NXP i.MX8QXP SoC and 1GiB of DDR3 ECC memory.
https://www.tq-group.com/en/products/tq-embedded/arm-architecture/tqma8xx/
All testing has been performed with the module on the MBa8Xx carrier board which is included in the starter kit.
The provided board support should be at the module level and does not make any assumptions about the carrier board.
Note: There are different configured of the TQMa8Xx board which include different NXP SoCs and different memory configurations.
Such modules are not supported.
Supported Configurations
Release
In release configuration the loader, kernel and monitor do not perform any direct serial output.
Debug
The debug configuration includes basic print output form the loader, kernel and monitor.
About
Microkit - A simple operating system framework for the seL4 microkernel
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
seL4 Microkit
The purpose of the seL4 Microkit is to enable system designers to create static software systems based on the seL4 microkernel.
The seL4 Microkit consists of three parts:
  • Microkit Library
  • Microkit initial task
  • Microkit tool
The Microkit is distributed as a software development kit (SDK).
This repository is the source for the Microkit SDK.
If you are developing Microkit itself this is the repo you want!
If you are a system designer and want to use the Microkit SDK please download a pre-built SDK.
Please see the manual in the SDK for instructions on using the SDK itself.
The remainder of this README is for Microkit developers.
Developer system requirements
Development of Microkit has primarily been performed on Ubuntu 18.04 LTS (x86_64).
This section attempts to list the packages or external development tools which are required during development.
At this stage it may be incomplete.
Please file an issue if additional packages are required.
  • git
  • make
  • python3.9
  • python3.9-venv
  • musl-1.2.2
  • ARM GCC compiler; 10.2-2020.11
On Ubuntu 18.04 there are no packages available for musl-1.2.2; it must be compiled from source.
On Ubuntu 18.04 Python 3.9 is available via the deadsnakes PPA: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa
To use this:
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt update
$ sudo apt install python3.9 python3.9-venv

Additonally, a number of Python libraries are needed.
These should be installed using pip.
$ python3.9 -m venv pyenv
$ ./pyenv/bin/pip install --upgrade pip setuptools wheel
$ ./pyenv/bin/pip install -r requirements.txt

Note: It is a high priority of the authors to ensure builds are self-contained and repeatable.
A high value is placed on using specifically versioned tools.
At this point in time this is not fully realised, however it is a high priority to enable this in the near future.
The ARM toolchain is available from:
https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11
The specific version used for development is the x86_64-aarch64-none-elf version:
https://developer.arm.com/-/media/Files/downloads/gnu-a/10.2-2020.11/binrel/gcc-arm-10.2-2020.11-x86_64-aarch64-none-elf.tar.xz?revision=79f65c42-1a1b-43f2-acb7-a795c8427085&hash=61BBFB526E785D234C5D8718D9BA8E61
Note: There are no plans to support development of Microkit on any platforms other than Linux x86_64.
seL4 Version
The SDK includes a binary of the seL4 kernel.
During the SDK build process the kernel is build from source.
At this point in time there are some minor changes to the seL4 kernel required for Microkit. This is temporary, more details can be found here.
Please clone seL4 from:
https://github.com/seL4/seL4.git

The correct branch to use is microkit.
Testing has been performed using commit 92f0f3ab28f00c97851512216c855f4180534a60.
Building the SDK
$ ./pyenv/bin/python build_sdk.py --sel4=<path to sel4>

Using the SDK
After building the SDK you probably want to build a system!
Please see the SDK user manual for documentation on the SDK itself.
When developing the SDK it is helpful to be able to build examples system quickly for testing purposes.
The dev_build.py script can be used for this purpose.
This script is not included in the SDK and is just meant for use of use of Microkit developers.
By default dev_build.py will use the example source directly from the source directory.
In some cases you may want to test that the example source has been correctly included into the SDK.
To test this pass --example-from-sdk to the build script.
By default dev_build.py will use the the Microkit tool directory from source (in tool/microkit).
However, in some cases it is desirable to test the Microkit tool built into the SDK.
In this case pass --tool-from-sdk to use the tool that is built into the SDK.
Finally, by default the dev_build.py script relies on the default Makefile dependecy resolution.
However, in some cases it is useful to force a rebuild while doing SDK development.
For example, the Makefile can't know about the state of the Microkit tool source code.
To support this a --rebuild option is provided.
SDK Layout
The SDK is delivered as a tar.gz file.
The SDK top-level directory is microkit-sdk-$VERSION.
The directory layout underneath the top-level directory is:
bin/
bin/microkit
board/$board/$config/include/
board/$board/$config/include/microkit.h
board/$board/$config/lib/
board/$board/$config/lib/libmicrokit.a
board/$board/$config/lib/microkit.ld
board/$board/$config/elf
board/$board/$config/elf/loader.elf
board/$board/$config/elf/kernel.elf
board/$board/$config/elf/monitor.elf

The currently supported boards:
  • tqma8xqp1gb
The currently supported configurations are:
  • release
  • debug
Supported Boards
tqma8xqp-1gb
The TQMa8Xx Embedded Module from TQ Group configured with the NXP i.MX8QXP SoC and 1GiB of DDR3 ECC memory.
https://www.tq-group.com/en/products/tq-embedded/arm-architecture/tqma8xx/
All testing has been performed with the module on the MBa8Xx carrier board which is included in the starter kit.
The provided board support should be at the module level and does not make any assumptions about the carrier board.
Note: There are different configured of the TQMa8Xx board which include different NXP SoCs and different memory configurations.
Such modules are not supported.
Supported Configurations
Release
In release configuration the loader, kernel and monitor do not perform any direct serial output.
Debug
The debug configuration includes basic print output form the loader, kernel and monitor.
About
Microkit - A simple operating system framework for the seL4 microkernel
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
seL4 Microkit
The purpose of the seL4 Microkit is to enable system designers to create static software systems based on the seL4 microkernel.
The seL4 Microkit consists of three parts:
  • Microkit Library
  • Microkit initial task
  • Microkit tool
The Microkit is distributed as a software development kit (SDK).
This repository is the source for the Microkit SDK.
If you are developing Microkit itself this is the repo you want!
If you are a system designer and want to use the Microkit SDK please download a pre-built SDK.
Please see the manual in the SDK for instructions on using the SDK itself.
The remainder of this README is for Microkit developers.
Developer system requirements
Development of Microkit has primarily been performed on Ubuntu 18.04 LTS (x86_64).
This section attempts to list the packages or external development tools which are required during development.
At this stage it may be incomplete.
Please file an issue if additional packages are required.
  • git
  • make
  • python3.9
  • python3.9-venv
  • musl-1.2.2
  • ARM GCC compiler; 10.2-2020.11
On Ubuntu 18.04 there are no packages available for musl-1.2.2; it must be compiled from source.
On Ubuntu 18.04 Python 3.9 is available via the deadsnakes PPA: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa
To use this:
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt update
$ sudo apt install python3.9 python3.9-venv

Additonally, a number of Python libraries are needed.
These should be installed using pip.
$ python3.9 -m venv pyenv
$ ./pyenv/bin/pip install --upgrade pip setuptools wheel
$ ./pyenv/bin/pip install -r requirements.txt

Note: It is a high priority of the authors to ensure builds are self-contained and repeatable.
A high value is placed on using specifically versioned tools.
At this point in time this is not fully realised, however it is a high priority to enable this in the near future.
The ARM toolchain is available from:
https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11
The specific version used for development is the x86_64-aarch64-none-elf version:
https://developer.arm.com/-/media/Files/downloads/gnu-a/10.2-2020.11/binrel/gcc-arm-10.2-2020.11-x86_64-aarch64-none-elf.tar.xz?revision=79f65c42-1a1b-43f2-acb7-a795c8427085&hash=61BBFB526E785D234C5D8718D9BA8E61
Note: There are no plans to support development of Microkit on any platforms other than Linux x86_64.
seL4 Version
The SDK includes a binary of the seL4 kernel.
During the SDK build process the kernel is build from source.
At this point in time there are some minor changes to the seL4 kernel required for Microkit. This is temporary, more details can be found here.
Please clone seL4 from:
https://github.com/seL4/seL4.git

The correct branch to use is microkit.
Testing has been performed using commit 92f0f3ab28f00c97851512216c855f4180534a60.
Building the SDK
$ ./pyenv/bin/python build_sdk.py --sel4=<path to sel4>

Using the SDK
After building the SDK you probably want to build a system!
Please see the SDK user manual for documentation on the SDK itself.
When developing the SDK it is helpful to be able to build examples system quickly for testing purposes.
The dev_build.py script can be used for this purpose.
This script is not included in the SDK and is just meant for use of use of Microkit developers.
By default dev_build.py will use the example source directly from the source directory.
In some cases you may want to test that the example source has been correctly included into the SDK.
To test this pass --example-from-sdk to the build script.
By default dev_build.py will use the the Microkit tool directory from source (in tool/microkit).
However, in some cases it is desirable to test the Microkit tool built into the SDK.
In this case pass --tool-from-sdk to use the tool that is built into the SDK.
Finally, by default the dev_build.py script relies on the default Makefile dependecy resolution.
However, in some cases it is useful to force a rebuild while doing SDK development.
For example, the Makefile can't know about the state of the Microkit tool source code.
To support this a --rebuild option is provided.
SDK Layout
The SDK is delivered as a tar.gz file.
The SDK top-level directory is microkit-sdk-$VERSION.
The directory layout underneath the top-level directory is:
bin/
bin/microkit
board/$board/$config/include/
board/$board/$config/include/microkit.h
board/$board/$config/lib/
board/$board/$config/lib/libmicrokit.a
board/$board/$config/lib/microkit.ld
board/$board/$config/elf
board/$board/$config/elf/loader.elf
board/$board/$config/elf/kernel.elf
board/$board/$config/elf/monitor.elf

The currently supported boards:
  • tqma8xqp1gb
The currently supported configurations are:
  • release
  • debug
Supported Boards
tqma8xqp-1gb
The TQMa8Xx Embedded Module from TQ Group configured with the NXP i.MX8QXP SoC and 1GiB of DDR3 ECC memory.
https://www.tq-group.com/en/products/tq-embedded/arm-architecture/tqma8xx/
All testing has been performed with the module on the MBa8Xx carrier board which is included in the starter kit.
The provided board support should be at the module level and does not make any assumptions about the carrier board.
Note: There are different configured of the TQMa8Xx board which include different NXP SoCs and different memory configurations.
Such modules are not supported.
Supported Configurations
Release
In release configuration the loader, kernel and monitor do not perform any direct serial output.
Debug
The debug configuration includes basic print output form the loader, kernel and monitor.
About
Microkit - A simple operating system framework for the seL4 microkernel
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
seL4 Microkit
The purpose of the seL4 Microkit is to enable system designers to create static software systems based on the seL4 microkernel.
The seL4 Microkit consists of three parts:
  • Microkit Library
  • Microkit initial task
  • Microkit tool
The Microkit is distributed as a software development kit (SDK).
This repository is the source for the Microkit SDK.
If you are developing Microkit itself this is the repo you want!
If you are a system designer and want to use the Microkit SDK please download a pre-built SDK.
Please see the manual in the SDK for instructions on using the SDK itself.
The remainder of this README is for Microkit developers.
Developer system requirements
Development of Microkit has primarily been performed on Ubuntu 18.04 LTS (x86_64).
This section attempts to list the packages or external development tools which are required during development.
At this stage it may be incomplete.
Please file an issue if additional packages are required.
  • git
  • make
  • python3.9
  • python3.9-venv
  • musl-1.2.2
  • ARM GCC compiler; 10.2-2020.11
On Ubuntu 18.04 there are no packages available for musl-1.2.2; it must be compiled from source.
On Ubuntu 18.04 Python 3.9 is available via the deadsnakes PPA: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa
To use this:
$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt update
$ sudo apt install python3.9 python3.9-venv

Additonally, a number of Python libraries are needed.
These should be installed using pip.
$ python3.9 -m venv pyenv
$ ./pyenv/bin/pip install --upgrade pip setuptools wheel
$ ./pyenv/bin/pip install -r requirements.txt

Note: It is a high priority of the authors to ensure builds are self-contained and repeatable.
A high value is placed on using specifically versioned tools.
At this point in time this is not fully realised, however it is a high priority to enable this in the near future.
The ARM toolchain is available from:
https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11
The specific version used for development is the x86_64-aarch64-none-elf version:
https://developer.arm.com/-/media/Files/downloads/gnu-a/10.2-2020.11/binrel/gcc-arm-10.2-2020.11-x86_64-aarch64-none-elf.tar.xz?revision=79f65c42-1a1b-43f2-acb7-a795c8427085&hash=61BBFB526E785D234C5D8718D9BA8E61
Note: There are no plans to support development of Microkit on any platforms other than Linux x86_64.
seL4 Version
The SDK includes a binary of the seL4 kernel.
During the SDK build process the kernel is build from source.
At this point in time there are some minor changes to the seL4 kernel required for Microkit. This is temporary, more details can be found here.
Please clone seL4 from:
https://github.com/seL4/seL4.git

The correct branch to use is microkit.
Testing has been performed using commit 92f0f3ab28f00c97851512216c855f4180534a60.
Building the SDK
$ ./pyenv/bin/python build_sdk.py --sel4=<path to sel4>

Using the SDK
After building the SDK you probably want to build a system!
Please see the SDK user manual for documentation on the SDK itself.
When developing the SDK it is helpful to be able to build examples system quickly for testing purposes.
The dev_build.py script can be used for this purpose.
This script is not included in the SDK and is just meant for use of use of Microkit developers.
By default dev_build.py will use the example source directly from the source directory.
In some cases you may want to test that the example source has been correctly included into the SDK.
To test this pass --example-from-sdk to the build script.
By default dev_build.py will use the the Microkit tool directory from source (in tool/microkit).
However, in some cases it is desirable to test the Microkit tool built into the SDK.
In this case pass --tool-from-sdk to use the tool that is built into the SDK.
Finally, by default the dev_build.py script relies on the default Makefile dependecy resolution.
However, in some cases it is useful to force a rebuild while doing SDK development.
For example, the Makefile can't know about the state of the Microkit tool source code.
To support this a --rebuild option is provided.
SDK Layout
The SDK is delivered as a tar.gz file.
The SDK top-level directory is microkit-sdk-$VERSION.
The directory layout underneath the top-level directory is:
bin/
bin/microkit
board/$board/$config/include/
board/$board/$config/include/microkit.h
board/$board/$config/lib/
board/$board/$config/lib/libmicrokit.a
board/$board/$config/lib/microkit.ld
board/$board/$config/elf
board/$board/$config/elf/loader.elf
board/$board/$config/elf/kernel.elf
board/$board/$config/elf/monitor.elf

The currently supported boards:
  • tqma8xqp1gb
The currently supported configurations are:
  • release
  • debug
Supported Boards
tqma8xqp-1gb
The TQMa8Xx Embedded Module from TQ Group configured with the NXP i.MX8QXP SoC and 1GiB of DDR3 ECC memory.
https://www.tq-group.com/en/products/tq-embedded/arm-architecture/tqma8xx/
All testing has been performed with the module on the MBa8Xx carrier board which is included in the starter kit.
The provided board support should be at the module level and does not make any assumptions about the carrier board.
Note: There are different configured of the TQMa8Xx board which include different NXP SoCs and different memory configurations.
Such modules are not supported.
Supported Configurations
Release
In release configuration the loader, kernel and monitor do not perform any direct serial output.
Debug
The debug configuration includes basic print output form the loader, kernel and monitor.
About
Microkit - A simple operating system framework for the seL4 microkernel
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages