ISO downloads can be found here
The Bleed Kernel is a hobbyist Operating System written by Mellurboo. It is one of the very few Operating Systems in (hobbyist) OSDev that has proper exFAT support. The Bleed Kernel is also recognized by the Open Innovation Network. Bleed is while a Unix like has many unique features such as the power state device allowing power control making deveopment of specialized programs easier.
The Bleed Kernel (despite being in early development) has many impressive ports which includes:
Quake2, DOOM. It can run on a device with 256MB of RAM and 2MB of VRAM (though DOOM and Quake2 may not run) as its minimum, though 512MB of RAM and 16MB of VRAM is considered recommended.
Unlike some hobbyist Operating Systems which rely on things like ports of GNU Coreutils or Busybox the Bleed Kernel (and Bleed OS by extension) use a custom shell called the Verdict Shell, a custom libc (blibc) instead of a port of PDCLib or Newlib or god forbid GLibc (honestly if you have Glibc you are no longer in the realm of hobbyist OS). And of course a custom Coreutils.
When I downloaded the Bleed 0.3.5 image (latest at the time of writing), and launched it in QEMU I encountered this as the serial log output.
qemu-system-x86_64 -cdrom bleed-kernel-0-3-5.iso -serial stdio -m 4G
[OK ] Global Descriptor Table Loaded (GDTR=0xffffffff80e441e0)
[OK ] Interrupt Descriptor Table Loaded (IDTR=0xffffffff80e431d0)
[OK ] TSS Ready
[INFO] PMM: region 0x53000-0x9f000 header=1 usable=74 pages
[INFO] PMM: region 0x100000-0xbe0d1000 header=24 usable=778145 pages
[INFO] PMM: region 0xbef28000-0xbfc63000 header=1 usable=3385 pages
[INFO] PMM: region 0xbfc6c000-0xbfd32000 header=1 usable=196 pages
[INFO] PMM: region 0x100000000-0x13ca4b000 header=8 usable=248379 pages
[OK ] PMM: initialized, 4024 MB free
[OK ] Physical Memory Manager Ready
[OK ] Paging Ready
[OK ] SSE3 Ready
[OK ] VFS Root Mounted
[INFO] ACPI Version: 1.0
[INFO] ACPI: Enabling via SMI_CMD=0xb2
[INFO] ACPI: LAPIC @ 0x0x00000000fee00000
[INFO] ACPI: IOAPIC @ 0x0x00000000fec00000 (GSI base 0)
[INFO] LAPIC ID: 0
[OK ] HPET Found
[OK ] HPET is at 10000000 femtoseconds per tick
[INFO] ide: slot 0 - not present
[INFO] ide: slot 1 - not present
[INFO] ide: slot 2 - not present
[INFO] ide: slot 3 - not present
[INFO] ahci: no AHCI controller found
[INFO] nvme: no NVMe controller found
[OK ] Kernel Task Created, tid:0
[OK ] CPU SMEP Not Supported
[OK ] CPU SMAP Not Supported
[PANIC] Vec:0x0000000000000006 RIP:0xFFFFFFFF80009DE0
[NESTED PANIC] Vector:0x0000000000000006 RIP:0xFFFFFFFF8001A066
System halted.
On the screen I got a bit more context as to what was going on. It stated that there was a CPU Exception, an Invalid Opcode. Said taht it was still in the kernel, it happened when it was attempting to start the init.
Overall the actual user experience on at least Bleed Kernel 0.3.5 is not the best, though as it is an alpha build these things are to be expected with a hobbyist OS.
Though the Bleed Kernel did not work in my QEMU environment I have quite high expectations for Bleed as it does in fact have a functional DOOM and Quake2 port. Though it does have some oddities, for example its website has a Kernel Panic decoder which I believe is now depricated as it only applies to older kernels (I think) which didnt give the full info on the display. Though most importantly it does attempt to enable protections such as SMAP (which stops the kernel from touching userland memory unless explicitly disabled via a special instruction). And of course SMEP which stops the kernel from trying to run userland code (or any page that is !NX and is PRESENT and USER) in Ring 0.
]]>TacOS is a hobbyist kernel and OS by UnmappedStack which has an O(1) SMP ULE-inspired scheduler in the rewrite which is mostly lockless. Before the rewrite it ran Doom and other userspace utilities. UnmappedStack is currently doing a rewrite (you can see the rewrite branch on the GitHub repo) but it isn’t very far yet (though it has better kernel architecture and code than before the rewrite according to Unmapped). The pre-rewrite kernel has more features but internally it is much worse.
The kernel rewrite has a quite unique architecture. Featuring a (somewhat) custom build system built around nob. The entire kernel was written from scratch in C and assembly, using the Limine boot protocol.
The rewrite features a considerably cleaner implementation and cleaner code than the original TacOS. Though the photo of TacOS shown is of it running Doom before the rewrite. The code and architecture pre-rewrite were far less clean and collected a very high code debt before UnmappedStack decided to rewrite it.
A ULE scheduler is one of the most impressive scheduler designs out there. Each CPU/Processor has a ProcessorQueue which contains 4 Queues:
Then realtime and timeshare threads are organised into a calendar queue with:
Where the actual priority within the range is based on nice values. The queue is always checked for the highest priority task on a task select, then idle threads are picked when there are no threads on any other queues. To determine if a timeshare thread gets to be in the interactive queue or not it is based on the following algo:
scaling_score = threshold/2
if (sleeptime > runtime) score = scaling_score / (sleeptime/runtime)
else score = scaling_score / (runtime/sleeptime)
Where if score > threshold then the thread is considered interactive. When sleeptime + runtime hit 100, they are both halved. Though the major difference between the TacOS ULE scheduler and a typical ULE scheduler is that the TacOS kernel scheduler currently does not have kernel threads, though at the moment they remain unimplemented. Processor affinity is also supported, where a thread can simply be flagged as affinitive so it will have immunity from the load balancer.
Load balancing occurs in two ways: Pull migration: when a processor is out of threads it just takes the highest priority thread from the processor queue with the highest load (calculated as a number of ticks in a sliding window) Push migration: twice a second the highest and lowest loaded queues are selected, and some threads are transferred between them.
The scheduler is highly inspired by the original ULE scheduler, though the calendar queue design is from the modern ULE implementation. The scheduler does lack Interactiveness determination currently though which is considered a minor issue but seemingly is on UnmappedStack’s TODO list.
SMP is supported by using the limine_mp_request. Each one is sent to void ap_entry(struct limine_mp_info *this_cpu), which will then disable interrupts (on said CPU), acquire the init_lock, set up the CPU’s GDT, and after that, it will create its own CR3, switch to said CR3, and switch the stack to said CR3. It will then run stage 2, which maps in the LAPIC, sets up the LAPIC and the timer, locks the timer, disables interrupts (on said core), releases the init_lock, and increases the count of initialized cores. It will then wait until the kernel scheduler is ready. Once that is ready, it will initialize the processor’s scheduler, unlock the timer, and enable interrupts. From there, the core/thread will start running processes.