Gila v0.2.2 - a Rust Microkernel

Gila is a Rust microkernel OS, inspired by the Xinu embedded OS, as well as Linux. I aim to implement multitasking and different users for processes, and eventually a filesystem. I do not aim to make it POSIX-compatible, but it will likely end up sharing many features with POSIX operating systems.

Features

Complete

Builds for multiple architectures
Valid Limine kernel
Boots on x86_64
Kernel command line parameters
Logging

In-Progress

Multi-architecture feature support
Display console
Serial console

Future/Desired

Code execution
Interrupts and timers
Context switching
Process scheduling
Shell and CLI
System calls (multi-convention?)
Multi-user support and access control
Simultaneous multiprocessing support
ACPI, USB, PCI(e), SATA
Filesystem support (FAT32)
Application sandboxing/permissions control
Graphical desktop environment
Networking support

Licensing

Licensed under the GNU Public License v3. See LICENSE for details.

Navigating

arch/: Architecture specific features like the display, serial, and interrupts. Each architecture is a subfolder, containing a file or module for each feature.
boot.rs: Handles bootloader-managed data structures. Gila uses Limine. Other bootloaders are NOT supported.
log.rs: Logging structures and singletons for logging to serial or the display.
main.rs: The entry point that gets called by the bootloader.
memory.rs: Types relating to memory regions and allocation.
panic.rs: The panic handler and associated functionality.
params.rs: Kernel parameter handler code.
process.rs: Process types and functions.
resources.rs: Resources that are accessible from multiple parts of the code.

Building and running

Building a bootable kernel is easy. All you need to do is run cargo build gila, and a valid, bootable Limine executable will be generated. However, it cannot be booted without installing it in a bootable Limine filesystem.

To build an ISO image that you can boot, there are several prerequisites:

rustup command installed
limine command installed
xorriso command installed
make command installed
qemu-system-(your target architecture) command installed (for running)

Then run make to invoke the Makefile.

make checkenv: Asserts all needed commands and resources are accessible.
make prepare: Installs needed Rust toolchain.
make clean: Cleans all built binaries, libraries, and ISOs.
make gila: Builds the kernel ELF file.
make iso: Builds the bootable ISO with Limine installed.
make run: Builds the ISO and boots it in QEMU.

By supplying TARGET=(rustc target triple) as an additional argument, you can change the architecture that gila will be compiled & run for. The default is x86_64-unknown-none.

The default limine BIOS file search directory is /usr/share/limine. You can change this by supplying a path (no trailing slash) like so: LIMINE-DIR=/home/user/Downloads/limine.

You can install all these dependencies automatically by using nix-shell and supplying shell.nix as an argument.

Kernel Parameters

Kernel parameters are passed as part of the cmdline through limine.conf. The parameters are passed as a space-delimited list of keys and values. Keys begin with a hyphen (-), and keys are separated from their values with equals signs (=). Keys can have a set of multiple values, separated by a comma (,). Gila does not currently support parameter values with spaces. That would require an actual parser.

List of current extant kernel parameters:

-loglevel: Can be a number or string corresponding to a log level. Only one value supported.
-logdev: A sequence of one or more values representing devices to log to. Current options are display and serial.

The default cmdline is:

-loglevel=INFO -logdev=display,serial

Credits

The linker script stuff is from limine-rust-template, which is available under the BSD 0-Clause License.

4.2 KiB Raw Blame History