Co oznacza stworzenie własnego systemu operacyjnego?
System operacyjny, czyli OS, zarządza sprzętem i udostępnia usługi programom. Jego centralnym elementem jest jądro, nazywane kernelem, które kontroluje procesor, pamięć oraz urządzenia i koordynuje wykonywanie zadań. System operacyjny to jednak znacznie więcej niż sam kernel. W miarę rozwoju projektu dochodzą między innymi sterowniki, system plików, mechanizmy ochrony i interfejs programowania, przez który aplikacje proszą o dostęp do zasobów.
Budowa OS wymaga znajomości architektury komputera, programowania niskopoziomowego i narzędzi kompilacji. Nie trzeba jednak od razu tworzyć środowiska gotowego do codziennego użytku. Rozsądny pierwszy cel to uruchomić małe jądro i wyświetlić komunikat. Taki demonstrator pozwala sprawdzić, czy rozumiesz proces startu, kompilację i przekazywanie sterowania, zanim projekt rozrośnie się o trudniejsze komponenty.
Własny system może być projektem edukacyjnym, badawczym albo próbą stworzenia użytecznego środowiska. Każdy z tych celów oznacza inny zakres pracy. System wyświetlający tekst nie potrzebuje tych samych funkcji co OS obsługujący wiele procesów, pliki i urządzenia. Dlatego pierwszą decyzją powinno być określenie, co konkretnie ma działać na końcu danego etapu.
Jak zaplanować zakres i wybrać architekturę?
Na początku wybierz architekturę procesora, na przykład x86-64, oraz zdecyduj, gdzie będziesz uruchamiać system. Emulator ułatwia powtarzanie testów i ogranicza ryzyko związane z eksperymentowaniem na fizycznym komputerze. Dopiero gdy podstawowe funkcje działają stabilnie, warto rozważyć testy na sprzęcie. Trzeba też ustalić, czy tworzysz demonstrator, system badawczy, czy środowisko, które ma obsługiwać realne zadania.
Warto od razu zapisać mierzalne kryterium pierwszego sukcesu. Może nim być obraz systemu, który uruchamia się w emulatorze, kernel wypisuje komunikat, a błąd rozruchu da się rozpoznać w logu lub debuggerze. Jasny cel pomaga uniknąć sytuacji, w której projekt szybko zyskuje nowe pomysły, ale nie ma działającego, sprawdzalnego rezultatu.
Przed rozpoczęciem pracy wybierz również model jądra. Jądro monolityczne skupia wiele usług, na przykład sterowniki i system plików, w przestrzeni jądra. Może ułatwić bezpośrednią współpracę komponentów, ale zwiększa zakres kodu działającego z wysokimi uprawnieniami. Mikrojądro ogranicza część jądrową i przenosi więcej usług do procesów użytkownika. Taki podział zmienia sposób izolacji i komunikacji między elementami. Żadne z tych podejść nie jest uniwersalnie najlepsze, a na wczesnym etapie ważniejsze od wyboru modelu jest utrzymanie projektu w możliwym do opanowania zakresie.
Jak przygotować narzędzia i uruchomić jądro?
Do pracy przydadzą się kompilator krzyżowy, asembler, linker, emulator, debugger oraz system kontroli wersji. Kompilator krzyżowy tworzy kod dla wybranej architektury docelowej niezależnie od platformy, na której pracujesz. Dzięki temu łatwiej kontrolować, dla jakiego środowiska powstaje kernel, zamiast polegać na domyślnych ustawieniach kompilatora systemowego.
Jądro można pisać w C lub Rust, uzupełniając kod niewielką ilością asemblera potrzebną do niskopoziomowego startu i obsługi architektury. Sam wybór języka nie rozwiązuje jednak problemów związanych z pamięcią, przerwaniami czy konwencjami wywołań. Te zagadnienia trzeba rozumieć, ponieważ wpływają na to, jak kernel komunikuje się ze sprzętem i jak bezpiecznie przekazuje wykonanie między fragmentami kodu.
Rozruch składa się z trzech głównych elementów: firmware komputera, programu ładującego, czyli bootloadera, oraz jądra. Firmware wybiera program startowy, bootloader umieszcza kernel w pamięci, przekazuje mu informacje o środowisku i oddaje mu sterowanie. Zamiast od razu pisać własny bootloader, zwykle rozsądniej jest użyć gotowego rozwiązania zgodnego z określonym protokołem. Pozwala to skupić się na jądrze i ograniczyć liczbę problemów, które trzeba diagnozować jednocześnie. Jednym z punktów wejścia dla 64-bitowego jądra jest konfiguracja oparta na Limine Bare Bones.
We współczesnych komputerach rolę interfejsu między firmware a programami rozruchowymi pełni UEFI. Loader może korzystać z usług rozruchowych firmware, na przykład przy alokacji pamięci i dostępie do urządzeń. Przed zakończeniem tych usług powinien zebrać potrzebne informacje, w tym mapę pamięci. Po pomyślnym wywołaniu ExitBootServices() nie może zakładać, że usługi rozruchowe nadal będą dostępne. Dalsze zarządzanie zasobami musi przejąć loader lub system.
Jak rozwijać kernel i kolejne funkcje?
Po uruchomieniu jądra kolejne prace warto prowadzić etapami: skompilować kod, uruchomić go, przetestować jedną funkcję, zapisać diagnostykę i dopiero wtedy przejść dalej. Taki rytm ułatwia ustalenie, która zmiana spowodowała błąd. Emulator pozwala szybko powtarzać testy, a logi i debugger pomagają odróżnić problem z rozruchem od błędu w samym jądrze.
Po komunikacie tekstowym możesz dodać obsługę wyjątków i przerwań. Wyjątki informują o sytuacjach takich jak nieprawidłowa operacja procesora, a przerwania pozwalają reagować na zdarzenia sprzętowe. Następnie przychodzi czas na zarządzanie pamięcią fizyczną i wirtualną oraz mechanizmy ochrony. Bez tych elementów trudno bezpiecznie uruchamiać bardziej złożony kod i przydzielać zasoby różnym zadaniom.
Kolejnym komponentem może być prosty harmonogram, który decyduje, jaki wątek lub proces otrzymuje czas procesora. Sterowniki pośredniczą między jądrem a urządzeniami, a system plików organizuje dane na nośniku. API systemowe pozwala programom prosić o usługi, takie jak otwarcie pliku lub utworzenie procesu. Elementy te są od siebie zależne: programy potrzebują działającego API i wejścia-wyjścia, sterowniki korzystają z mechanizmów pamięci, a bootloader musi przekazać kernelowi informacje zgodne z jego oczekiwaniami.
Jak sprawdzać postępy i unikać typowych problemów?
Własny system najlepiej rozwijać przez małe, weryfikowalne cele. Po uruchomieniu komunikatu możesz sprawdzić obsługę przerwania zegara, przydzielanie i zwalnianie stron pamięci, przełączanie między dwoma zadaniami albo odczyt pliku z obrazu dysku. Nie ma jednej obowiązkowej liczby etapów. Ich zakres zależy od architektury oraz tego, czy tworzysz demonstrator, projekt badawczy czy bardziej rozbudowane środowisko.
Nie dodawaj wielu komponentów naraz. Jeśli jednocześnie zmienisz sposób rozruchu, zarządzanie pamięcią i obsługę urządzeń, znalezienie źródła awarii będzie trudniejsze. Zapisuj istotne informacje diagnostyczne i sprawdzaj każdą funkcję osobno. Kontrola wersji pozwoli wrócić do wcześniejszego działającego stanu, gdy nowa zmiana przyniesie nieoczekiwany problem.
Najczęstszym błędem na starcie jest traktowanie własnego OS jak aplikacji, którą wystarczy skompilować i uruchomić. System musi sam przygotować podstawowe mechanizmy działania, a jego komponenty wymagają zgodnych interfejsów. Dlatego najpierw doprowadź do powtarzalnego startu jądra w emulatorze, potem rozwijaj pamięć, przerwania i zadania, a dopiero później zajmuj się plikami oraz szerszą obsługą sprzętu. Mały, działający kernel jest lepszym początkiem niż rozbudowany projekt bez sprawdzonych podstaw.
Wykorzystane materiały
- https://uefi.org/specs/UEFI/2.9_A/07_Services_Boot_Services.html
- https://uefi.org/specs/UEFI/2.10/
- https://wiki.osdev.org/Bootloader_FAQ