Gila v0.2.3 - 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

• kernel/: Kernel-specific code.
  • 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.
  • syscall_runner.rs: Chooses a system call by its ID and defers actual syscall execution to code in src/lib/.
• lib/: Library that all Gila's binary programs will be built against. Some of this code is shared with the kernel.
  • arch/: Architecture specific functionality like system call register storing/loading.
  • syscall.rs: System call types common to apps and the kernel.

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
• cargo-make command installed (cargo install cargo-make)
• qemu-system-{your target architecture} command installed (for running)

Then run cargo make to invoke the Makefile.toml.

• cargo make prepare: Installs needed Rust toolchain.
• cargo make clean: Cleans all built binaries, libraries, and ISOs.
• cargo make cleaniso: Clean only files involved in building the ISO.
• cargo make kernel: Builds the kernel ELF file.
• cargo make iso: Builds the bootable ISO with Limine installed.
• cargo make run: Builds the ISO and boots it in QEMU.

To change the target gila will be compiled or run for, supply TARGET={valid-rustc-targettriple} as an environment variable to cargo make. The default is x86_64-unknown-none.

To change the search path for limine's binaries, supply LIMINEDIR={/abs/path/no/trailing/slash} as an environment variable to cargo make. The default is /usr/share/limine.

To change the development profile from dev to release, supply -p {profile} as an argument to cargo make BEFORE the task name.

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.