Operativsystem hör till den mest komplexa programvara som någonsin byggts. De hanterar minne, schemalägger beräkning, styr hårdvara och upprätthåller säkerhetsgränser som skyddar varje program som körs på en maskin.

Ändå bygger många operativsystem vi förlitar oss på i dag på arkitekturidéer som går flera decennier tillbaka. Även om dessa system är extraordinärt kraftfulla och väl beprövade, bär de också på decennier av ackumulerad komplexitet.

Detta projekt utforskar en annan riktning: att bygga ett modernt, kapabilitetsbaserat operativsystem med mikrokärna från grunden, med starkt fokus på explicit auktoritet, minimal betrodd beräkningsbas (TCB), och strikt separation mellan kärna och användarrymd.

Detta operativsystem heter EriX.

Varför bygga ännu ett operativsystem?⌗

Vid första anblick verkar det onödigt att bygga ett nytt operativsystem. Mogna system som Linux, Windows och BSD finns redan och driver miljarder enheter.

Men dessa system utvecklades under historiska begränsningar. Med tiden har de samlat lager av abstraktioner, kompatibilitetsmekanismer och äldre gränssnitt. Även om dessa funktioner ofta är nödvändiga i verklig programvara, gör de det också svårt att experimentera med fundamentalt annorlunda arkitekturidéer.

Forskningsoperativsystem har länge utforskat alternativa angreppssätt för operativsystemsdesign. Mikrokärnor, kapabilitetssystem och formellt verifierade kärnor har visat att det är möjligt att bygga system som är mindre, säkrare och lättare att resonera om.

Målet med EriX är inte att ersätta befintliga operativsystem. I stället är det en utforskning av hur ett modernt operativsystem kan designas om vi börjar från första principer.

Mikrokärnor och betrodd beräkningsbas⌗

En av de centrala idéerna bakom EriX är mikrokärnarkitekturen.

Traditionella monolitiska kärnor inkluderar många tjänster direkt i kärnan. Dessa omfattar ofta:

  • drivrutiner
  • filsystem
  • nätverksstackar
  • delsystem för processhantering

Även om detta angreppssätt kan vara effektivt, ökar det också storleken på betrodd beräkningsbas (TCB). TCB omfattar all kod som måste bete sig korrekt för att systemet ska förbli säkert och tillförlitligt.

Mikrokärnor tar en annan väg.

En mikrokärna behåller bara de mest grundläggande mekanismerna i kärnan, vanligtvis:

  • trådschemaläggning
  • hantering av adressrymder
  • interprocesskommunikation (IPC)
  • kapabilitetshantering
  • hantering av avbrott och undantag

Allt annat körs i användarrymden, inklusive drivrutiner, filsystem och högre tjänster.

Denna utformning minskar drastiskt mängden kod som måste vara betrodd. Fel i komponenter i användarrymden är mindre benägna att kompromettera hela systemet, och enskilda komponenter kan startas om eller bytas ut utan att kärnan fälls.

Kapabilitetsbaserad säkerhet⌗

En annan central designprincip i EriX är kapabilitetsbaserad säkerhet.

De flesta operativsystem förlitar sig tungt på omgivande auktoritet. I dessa system har processer ofta implicit åtkomst till resurser baserat på globala namnrymder, användaridentiteter eller ärvda privilegier.

Till exempel kan en process öppna en fil bara för att den känner till filens sökväg och operativsystemet bedömer att processen har rättighet att nå den.

Kapabilitetssystem tar ett annat grepp.

En kapabilitet är en oförfalskbar token som ger åtkomst till ett specifikt objekt med specifika rättigheter. En process kan bara nå ett objekt om den innehar en kapabilitet som auktoriserar den åtkomsten.

Kapabiliteter har flera viktiga egenskaper:

  • De representerar auktoritet explicit.
  • De kan överföras mellan processer.
  • De kan begränsa operationer till en exakt uppsättning rättigheter.

I ett kapabilitetsbaserat system flödar auktoritet via explicita överföringar snarare än via globala namnrymder. Detta gör systemet lättare att resonera om och hjälper till att eliminera hela klasser av säkerhetssårbarheter.

Varför Rust?⌗

Operativsystem skrivs traditionellt i C eller assembler. Dessa språk ger exakt kontroll över hårdvara och minne men gör det också lätt att införa subtila fel.

Minnessäkerhetsfel, som användning efter frigöring, buffertöverflöden och datakapplöpningar, har historiskt varit en av de största källorna till sårbarheter i systemprogramvara.

EriX skrivs främst i Rust.

Rust ger starka garantier för minnessäkerhet samtidigt som låg nivå-kontroll över hårdvara behålls. Språkets ägarmodell hjälper till att förhindra många felklasser vid kompilering, medan explicita unsafe-block gör potentiellt farliga operationer synliga och granskningsbara.

Att använda Rust eliminerar inte alla möjliga fel, men höjer säkerhetsbaslinjen i systemprogrammering avsevärt.

Ett renrumsoperativsystem⌗

En ovanlig aspekt av EriX-projektet är dess renrumsutvecklingsmodell.

Alla systemkomponenter implementeras inom projektet självt. Ingen extern källkod kopieras eller införlivas, och inga bibliotek från tredje part används.

Denna begränsning tjänar flera syften:

  • Den säkerställer att hela systemet kan förstås och granskas.
  • Den undviker dolda beroenden och oväntade beteenden.
  • Den tvingar arkitekturbeslut att vara explicita i stället för ärvda.

Renrumsutveckling gör också projektet till en pedagogisk övning. Varje delsystem, från starthanterare till minneshanterare, måste utformas och implementeras medvetet.

Ett långsiktigt mål: självvärdskap⌗

Ett av de långsiktiga målen för EriX är självvärdskap.

Ett system anses självvärdande när det kan bygga sin egen källkod med verktyg som körs på systemet självt.

För EriX innebär detta att så småningom:

  • Rust-kompilatorn körs på EriX
  • byggverktygen körs på EriX
  • hela operativsystemet kan kompileras nativt i EriX

Att nå denna milstolpe kräver implementation av många lager infrastruktur, inklusive filsystem, processhantering och en POSIX-kompatibel användarrymdsmiljö.

Varför dokumentera resan?⌗

Att bygga ett operativsystem är en lång och komplex process. Många av de mest intressanta insikterna syns inte i det färdiga systemet, utan i besluten, avvägningarna och misstagen längs vägen.

Denna blogg dokumenterar utvecklingen av EriX medan den fortskrider. Framtida inlägg kommer att täcka ämnen som:

  • utformning av ett uppstartsbildformat
  • implementation av kapabilitetsrymder
  • byggande av ett IPC-system
  • hantering av minnesauktoritet
  • konstruktion av servrar i användarrymden

Målet är att göra utvecklingsprocessen transparent och lärorik.

Blick framåt⌗

EriX är fortfarande i ett tidigt skede. Mycket av systemet återstår att bygga, och många designbeslut kommer utan tvekan att utvecklas över tid.

Men de vägledande principerna är redan tydliga:

  • minimal kärna
  • explicit auktoritet
  • kapabilitetsbaserad säkerhet
  • strikt modularitet
  • renrumsimplementation

I nästa inlägg utforskar vi en av systemets kärnidéer:

vad kapabilitetsbaserade operativsystem är, och varför de spelar roll.