106 lines
5.0 KiB
Markdown
106 lines
5.0 KiB
Markdown
|
|
# 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](LICENSE) for details.
|
|
|
|
## Navigating
|
|
|
|
- [kernel/](src/kernel/): Kernel-specific code.
|
|
- [arch/](src/kernel/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/kernel/boot.rs): Handles bootloader-managed data structures. Gila uses Limine. Other bootloaders are NOT supported.
|
|
- [log.rs](src/kernel/log.rs): Logging structures and singletons for logging to serial or the display.
|
|
- [main.rs](src/kernel/main.rs): The entry point that gets called by the bootloader.
|
|
- [memory.rs](src/kernel/memory.rs): Types relating to memory regions and allocation.
|
|
- [panic.rs](src/kernel/panic.rs): The panic handler and associated functionality.
|
|
- [params.rs](src/kernel/params.rs): Kernel parameter handler code.
|
|
- [process.rs](src/kernel/process.rs): Process types and functions.
|
|
- [resources.rs](src/kernel/resources.rs): Resources that are accessible from multiple parts of the code.
|
|
- [syscall_runner.rs](src/kernel/syscall_runner.rs): Chooses a system call by its ID and defers actual syscall execution to code in `src/lib/`.
|
|
- [lib/](src/lib/): Library that all Gila's binary programs will be built against. Some of this code is shared with the kernel.
|
|
- [arch/](src/lib/arch/): Architecture specific functionality like system call register storing/loading.
|
|
- [syscall.rs](src/lib/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
|
|
- `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 kernel`: Builds the kernel ELF file.
|
|
- `make iso`: Builds the bootable ISO with Limine installed.
|
|
- `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}` either as an argument to `make` or as an environment variable. The default is `x86_64-unknown-none`.
|
|
|
|
To change the search path for limine's binaries, supply `LIMINEDIR=/some/valid/path/no/trailing/slash` either as an argument to `make` or as an environment variable. The default is `/usr/share/limine`.
|
|
|
|
If you use Nix, you can install all these dependencies automatically by running `nix-shell`. This will also automatically set the correct directory for the limine BIOS files.
|
|
|
|
> [!IMPORTANT]
|
|
> **I do not, and cannot, currently recommend using `nix` for dependency management.** `nixpkgs` does not ship all of the necessary files in its packaging of limine.
|
|
|
|
## 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.
|