# 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](LICENSE) for details.

## Navigating

- [arch/](src/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](src/boot.rs): Handles bootloader-managed data structures. Gila uses Limine. Other bootloaders are NOT supported.
- [log.rs](src/log.rs): Logging structures and singletons for logging to serial or the display.
- [main.rs](src/main.rs): The entry point that gets called by the bootloader.
- [memory.rs](src/memory.rs): Types relating to memory regions and allocation.
- [panic.rs](src/panic.rs): The panic handler and associated functionality.
- [params.rs](src/params.rs): Kernel parameter handler code.
- [process.rs](src/process.rs): Process types and functions.
- [resources.rs](src/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](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](shell.nix) as an argument.

## Kernel Parameters

Kernel parameters are passed as part of the `cmdline` through [limine.conf](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](https://github.com/jasondyoungberg/limine-rust-template),
which is available under the BSD 0-Clause License.