apio/Luna

A simple POSIX-based operating system for 64-bit computers

Go to file

apio 266fa4a0d4 All checks were successful continuous-integration/drone/push Build is passing Details kernel: Start counting partition numbers at 1 This makes more sense for the end user.		2023-06-17 19:50:58 +02:00
.vscode	libos: Document it entirely using Doxygen comments =D	2023-06-09 22:45:06 +02:00
apps	kernel: Make the root inode be a mountpoint as well + add pivot_root()	2023-06-17 17:27:22 +02:00
initrd	sh: Skip comments (and shebangs!)	2023-06-03 16:59:18 +02:00
kernel	kernel: Start counting partition numbers at 1	2023-06-17 19:50:58 +02:00
libc	libc: Add the internal TRY_OR_SET_ERRNO macro	2023-06-03 20:20:01 +02:00
libluna	kernel: Make the root inode be a mountpoint as well + add pivot_root()	2023-06-17 17:27:22 +02:00
libos	libos: Correct wrong manpage section for execve()	2023-06-09 23:35:23 +02:00
tests	libluna: Add a so very basic HashMap	2023-06-17 00:07:43 +02:00
tools	kernel+init: Add a VFS mount system and auto-populate the devfs	2023-05-17 19:40:37 +02:00
.clang-format	Update .clang-format	2022-12-21 20:22:44 +01:00
.drone.yml	Remove restart from CI configuration	2023-01-08 15:55:26 +01:00
.gdbconf	Make GDB use the correct kernel file	2022-12-03 17:34:14 +01:00
.gitignore	kernel+tools: Allow loading files with different owners + add a more dynamic install script	2023-05-06 12:11:35 +02:00
CMakeLists.txt	all: Minor version bump up to 0.2.0	2023-05-27 19:32:59 +02:00
LICENSE	Update year range in LICENSE :)	2023-01-02 13:08:42 +01:00
luna.json	tools: Create an ext2 partition with the sysroot data in the disk image	2023-06-17 19:49:04 +02:00
README.md	Update README to match repository description	2023-05-20 22:00:52 +02:00

README.md

Luna

A very basic POSIX-based operating system for personal computers, written in C++.

Another UNIX clone?

Yes, another UNIX clone.

Features

x86_64-compatible lightweight kernel.
Preemptive multitasking, with a round-robin scheduler that can switch between tasks.
Virtual file system with a simple but working tmpfs populated from the initial ramdisk.
Can load ELF programs from the file system as userspace tasks.
System call interface and C Library, aiming to be mostly POSIX-compatible.
Designed to be portable, no need to be restricted to x86_64.
Fully UTF-8 aware, everywhere.
Thread safety (supposedly).
Environment-agnostic utility library, which can be used in both kernel and userspace.
Return-oriented error propagation, inspired by Rust and SerenityOS.
Build system uses CMake.

Setup

To build and run Luna, you will need to build a GCC Cross-Compiler and cross-binutils for x86_64-luna. (Yes, Luna is advanced enough that it can use its own OS-Specific Toolchain, instead of a bare metal target like x86_64-elf. It is the first of my OS projects to be able to do so. The patches for Binutils and GCC are binutils.patch and gcc.patch).

You should start by installing the required dependencies.

Then, run tools/setup.sh to build the toolchain.

This script will check whether you have the required versions of the toolchain already setup, and will skip building them if so. (This means that it is used by the build scripts to install the toolchain if it is missing before building, so you could skip running it manually.)

Please beware that building GCC and Binutils can take some time, depending on your machine.

Building

There are a variety of scripts for building Luna.

tools/build.sh will build the kernel, libc and binaries.

tools/rebuild.sh will do a full rebuild of the kernel, libc and binaries.

tools/install.sh will install those to the system root and initial ramdisk.

tools/sync-libc.sh will install the libc headers to the system root, build libc and install it.

tools/build-iso.sh will build, install, and make an ISO disk image named Luna.iso.

tools/build-stable-iso.sh does the same thing as build-iso.sh, but configures the kernel so that the version does not show the commit hash (used for stable versions).

tools/rebuild-iso.sh will do a clean rebuild, install, and make an ISO disk image.

In most cases, you should just use run.sh, but if you want to build without running, build-iso.sh.

Running

You should have QEMU installed.

You can choose between 3 run scripts:

tools/run.sh is the one you should use in most cases. It will build changed files, install, make an ISO image, and run Luna in QEMU.

tools/rebuild-and-run.sh will rebuild, install, make an ISO, and run Luna in QEMU.

tools/debug.sh will run Luna in QEMU with a port open for GDB to connect to. (run tools/build-debug.sh, tools/gdb.sh, and then tools/debug.sh in a separate terminal for an optimal debugging experience)

Essentially, since run.sh builds the toolchain if it hasn't been built, builds Luna if it hasn't been built, and runs it, you could just checkout this repo, run run.sh, and you're done. No need for the other scripts. Those are included for more fine-grained control/building step-by-step.

You can pass any arguments you want to the run scripts, and those will be forwarded to QEMU. Example: tools/run.sh -m 512M -net none -machine q35.

Prebuilt images

Prebuilt ISO images (numbered) for every version can be found at pub.cloudapio.eu.

These images are built manually whenever I decide to make a new version, and thus don't reflect the latest changes on the main branch.

Every hour, my server pulls the latest commits on main and builds an hourly ISO image. The ten most recent ones can be found in the hourly directory, and Luna-latest.iso should always be symlinked to the newest one.

These images do reflect the latest changes on the main branch, but are obviously less stable. Additionally, an hourly image will be skipped if building the latest commit of the project fails.

Is there third-party software I can use on Luna?

Not right now, but hopefully we can start porting some software soon!

License

Luna is open-source and free software under the BSD-2 License.