Wstęp
UWAGA TEN ARTYKUŁ ZAKŁADA ŻE :
- Znasz język programowania C.
- W razie ewentualnych problemów będziesz umiał sobie z nimi poradzić.
Pisanie OSa jest sprawą dość skomplikowaną. Nie wystarczy wiedza o programowaniu, trzeba także rozumieć, w jaki sposób działa procesor, przerwania, karta graficzna, itp. W tym kursie postaram się pokazać, jak napisać prostego OSa oraz wytłumaczę, w jaki sposób programować sprzęt i jak on działa. Co będzie nam potrzebne? GCC, czyli kompilator C(i nie tylko) Netwide Assembler (NASM) >=0.98 (http://nasm.sourceforge.net/), czyli kompilator asemblera bootloader GRUB, uruchomi nam nasz system emulator PC, np. VirtualBox, Bochs (opisany w podręczniku Think inside Bochs), VMWare, VirtualPC (opcjonalnie)
Zestaw GCC+NASM+GRUB w zupełności wystarczy i jest niezbędny do pisania OSa. Emulator PC jest opcjonalny. Pozwoli to pisać np. pod Windows czy Linuksem bez ciągłego restartowania komputera, aby spróbować, czy to, co piszemy działa. Jeszcze zaznaczam, że kod tutaj prezentowany będzie wyłącznie w C i asemblerze. Dobra, dosyć wstępu, zabieramy się do roboty. Na początku jednak trzeba będzie niestety opisać trochę sprzętu, aby wiedzieć co się robi. Dla chcących więcej polecam dokumentację Intela do procesora 386 ;) (ja przeczytałem).
Sprawy organizacyjne
Jeśli chcesz pisać OSa, musisz sobie zadać kilka ważnych pytań:
Po co piszę system operacyjny? aby nauczyć się, jak programować wielozadaniowość, pamięć wirtualną, drivery, system plików, itp. dostępne systemy mi nie wystarczają aby napisać OSa, który próbuje nauczyć projektowania OSów sława i chwała, władza nad światem :) Decyzje dotyczące budowy OS przenośny czy tylko dla architektury x86: 4 poziomy uprzywilejowania segmentów, ochrona pamięci, przełączanie zadań przy użyciu TSS (lub zamianę stosów) architektura: kernel monolityczny, mikrojądro, inne wielozadaniowość: brak, "udawana", prawdziwa wątki wieloprocesorowość: jeden procesor, SMP lub clustering wieloużytkowość: wielozadaniowość+zabezpieczenia OS używany do pisania naszego OSa: DOS, Windows, Linux, BeOS, inne język użyty do implementacji: C, C++, Pascal, assembler format plików wykonywalnych: czy ma obsługiwać biblioteki dynamiczne biblioteki dla języków wysokiego poziomu: GNU glibc, własna biblioteka, inne kompatybilność: te same wywołania, co inne OSy, emulacja innego OSa
Tryby pracy procesorów
Tryb rzeczywisty
Jest to tryb bardzo "okrojony". Pamięć jest podzielona na segmenty. Każdy segment ma wielkość 64kB. W trybie rzeczywistym mamy dostępny tylko 1MB pamięci, ale i tak jest mniej, bo pamięć od 0xA0000-0xFFFFF jest zarezerwowana dla pamięci video i BIOSu. Mamy więc tylko ok. 640kB wolnych. Tryb ten pozostał nawet w najnowszych procesorach Athlon XP ze względu na kompatybilność ze starymi programami pisanymi dla procesora 8086. Do pisania prawdziwego, dobrego OSa tryb rzeczywisty nas w ogóle nie obchodzi.
Tryb chroniony
Tryb ten został wprowadzony dopiero w procesorze 286. Jest to specjalny tryb pracy procesora. Pamięć jest podzielona na segmenty, ale to ty decydujesz gdzie się segment zaczyna i jaką ma wielkość. Dla procesora 286 wynosiła ona max. 16MB, a dla procesorów od 386 wzwyż do 4GB (!). W opisach będziemy się opierać tylko na architekturze procesorów od 386 w górę. Nie ma sensu opisywać 286, bo nikt już go dziś nie używa.
Tryb długi(Long mode) Tryb ten jest podstawowym trybem działania procesora w architekturze AMD64, jest kombinacją 64-bitowego trybu pracy i trybu zgodności wstecz (kompatybilności) pozwalającego na uruchamianie 16- i 32-bitowego kodu w trybie chronionym. Nie posiada on obsługi dla trybu rzeczywistego ani dla trybu wirtualnego 8086. W trybie long pracują 64-bitowe systemy operacyjne. Dla szerszego grona odbiorców został wprowadzony dopiero z procesorem AMD Opteron. Umożliwia on teorytyczny dostęp aż do 256 TB pamięci RAM, ale obecnie zwykle nie można użyć więcej niż 1TB. Tryb ten ze względu na skomplikowanie nie zostanie opisany.
Opis trybu rzeczywistego
Chcąc, nie chcąc, trzeba wiedzieć jak programować w trybie rzeczywistym. Potrzebne nam to będzie m.in. do napisania bootloadera oraz kodu inicjalizującego nasz OS.
Inicjalizacja komputera
Po włączeniu komputera procesor "budzi się" w trybie rzeczywistym. Jest to potrzebne, aby załadować BIOS, który jest przecież kodem 16-bitowym i używa specyficznych właściwości trybu rzeczywistego. Procesor skacze do specjalnego adresu w pamięci, gdzie znajduje się procedura skoku do właściwego punktu wejścia BIOSu.
Pamięć w trybie rzeczywistym
Jak już wspomniałem pamięć w RMODE (skrót od real mode - tryb rzeczywisty) jest podzielona na segmenty. Każdy segment ma limit 64kB. W trybie rzeczywistym jest tylko szesnaście segmentów: 0x0000,0x1000,0x2000,0x3000,...,0xF000. Segment 0x0000 jest zarezerwowany dla tablicy przerwań oraz niektórych danych komputera. Aby obliczyć fizyczne położenie takiego segmentu w pamięci, wystarczy wymnożyć numer segmentu przez 16, czyli w zapisie szesnastkowym dodać jedno 0 na koniec. Np. segment 0x4000 ma adres fizyczny 0x40000. Aby obliczyć adres fizyczny pary segment: offset wystarczy wykonać działanie:
adres_liniowy = (segment*16)|offset
Czasami widzisz numer segmentu, np. 0x5188. W rzeczywistości jest to segment 0x5000, tylko po przeliczeniu adresu segmentu segment: offset z powyższego równania wychodzi, że np. adres 0x5100:0x0010 to to samo, co 0x5000:0x1010.
Poniżej przedstawiam skróconą mapę pamięci w RMODE.
0x0000:0x0000 - tablica wektorów przerwań 0x0000:0x7C00 - tu zostaje załadowany boot-sector przez BIOS 0x1000:0x0000-0x9000:0xFFFF - pamięć użytkownika (najlepiej używać z tego przedziału) 0xA000:0x0000 - pamięć video karty VGA (tylko dla trybu graficznego) 0xB000:0x0000 - pamięć video karty Hercules Monochrome 0xB800:0x0000 - pamięć trybu tekstowego karty VGA 0xC000:0x0000-0xF000:0xFFFF - pamięć BIOSu i inne
Na samym początku pamięci RAM (adres 0x0000:0x0000) znajduje się tablica wektorów przerwań. Zostaje zainicjalizowana przez BIOS. Zawiera ona punkty wejścia do różnych procedur systemowych. Np. przerwanie 0x10 służy do obsługi karty graficznej, przerwanie 0x13 do obsługi dysków. Tablica wektorów przerwań to po prostu tablica par offset: segment. Przerwań może być tylko 256. Przerwania dzielą się na programowe i sprzętowe. Programowe są wywoływane jedynie przez użytkownika, a sprzętowe może wywołać procesor. W dokumentacji Intela do procesora 386 jest jak byk napisane, że przerwania od 0x00 do 0x2F są zarezerwowane na wyjątki procesora oraz przerwania sprzętowe to i tak jakiś matoł projektujący BIOS umieścił tam przerwania użytkownika, przekierowując przerwania sprzętowe pod inne numery. I teraz jeśli w trybie chronionym chcesz obsługiwać przerwania sprzętowe i wyjątki procesora to musisz wysłać do PICa (Programmable Interrupt Controller) żądanie, aby przekierował przerwania na właściwe miejsce (ok. 15 linijek w C używając outportb).
Kiedy procesor wykonuje przerwanie (sprzętowe, lub przy użyciu intrukcji int) na stos kładzione są następujące rejestry (w kolejności): ss, sp, flags, cs, ip. Znaczenie rejestrów: SS - segment stosu SP - aktualna pozycja stosu FLAGS - tu zawarte są flagi procesora CS - segment kodu IP - licznik programu (pozycja aktualnie wykonywanej instrukcji)
Gdy procesor otrzyma żądanie przerwania, liczy sobie (w RMODE) adres przerwania w następujący sposób: Segment = wartość przy 0x0000:numer_przerwania*4 Offset = wartość przy 0x0000:(numer_przerwania*4)+2 Potem zapisuje stan ww. rejestrów i skacze do procedury obsługi przerwania.
Opis trybu chronionego
O trybie rzeczywistym już wystarczy. Teraz zajmijmy się trybem chronionym, ponieważ jego opis będzie trochę dłuższy. Na początek trochę nudnych rzeczy.
Rejestry
W trybie chronionym wszystkie rejestry procesora są rejestrami 32-bitowymi. Mamy więc rejestry: eax, ebx, ecx, edx, esi, edi, ebp, esp oraz cs, ds, es, fs, gs. W trybie rzeczywistym raczej nie używa się rejestrów fs i gs. Mimo, że rejestry segmentowe są 32-bitowe, to i tak procesor używa tylko ich "dolną" połowę.
Stos
Tutaj stos jest 32-bitowy. Jest to rozmiar domyślny elementu kładzionego na stos. Jeśli chcesz położyć element 16-bitowy, to musisz użyć rejestru 16-bitowego, lub wartości 16-bitowej (np. push word 1 lub push word [wartosc]), jednak prawie nigdy nie używa się argumentów 16-bitowych.
Rejestry dodatkowe
W trybie chronionym dostępne są także rejestry do kontroli procesora (są 32-bitowe). Są to rejestry: CR0 - podstawowy rejestr kontroli procesora. Można go używać także w RMODE, ale to on właśnie służy do przełączania CPU w tryb chroniony i do kilku innych rzeczy CR1 - rejestr zarezerwowany CR2 - tutaj jest zapisany fizyczny adres, w którym wystąpił ostatni błąd strony (ang. Page Fault), ale o tym będzie później CR3 - tutaj zapisany jest fizyczny adres katalogu stron (o tym też później) CR4 - rejestr sterowania dostępny tylko dla nowych procesorów (o ile się nie mylę, jest on dostępny dla procesorów o architekturze 80686 i lepszych). Na razie nie będziemy o nim mówić, gdyż nie jest on nam potrzebny.
Pominąłem tutaj m.in. rejestry debugowania, ale na razie to się nam i tak nie przyda.
Poziomy uprzywilejowania
W trybie chronionym istnieją tzw. poziomy uprzywilejowania (DPL). Dla architektury x86 są 4 poziomy uprzywilejowania od 0 do 3. Poziom 0 jest przewidziany dla jądra systemu, na tym poziomie można robić wszystko. Poziom 3 jest dla aplikacji użytkownika, ponieważ ma duże ograniczenia, np. nie można dokonywać operacji na portach czy na rejestrach sterowania procesora.
Pamięć w trybie chronionym
Tutaj jest znacznie lepiej niż w trybie rzeczywistym, gdzie wszystko było ustalone na "sztywno" (jednak są sposoby, aby to ominąć). Najważniejsze jest to, że TY decydujesz, jakie segment ma położenie (mówimy: bazę) i rozmiar (mówimy: limit). W trybie chronionym bazę i limit segmentu definiujemy w Globalnej Tablicy Deskryptorów (GDT - Global Descriptor Table). Jest to tablica o 64-bitowych wpisach. Wpisów tych może być max. 8192, jednak zazwyczaj używa się tylko kilku. GDT składa się z 2 części: nagłówka tablica właściwa
Nagłówek ma format: word - 8*ilosc_wpisow-1 dword - fizyczne położenie GDT w pamięci
Tablica właściwa jest po prostu listą wartości. Uwaga: pierwszy wpis musi być 0, ponieważ jest on zarezerwowany, tzw. NULL descriptor. Nie można go używać. Format GDT jest trochę skomplikowany. Każdy wpis ma po 64 bity. Najpierw jednak wyjaśnię format selektora. Selektor jest to po prostu numer segmentu w GDT lub LDT (wyjaśnię później) zawierający dodatkowe informacje. Numer selektora liczy się następująco: selektor = (numer_w_GDT*8)+poziom_uprzywilejowania+(4 jeśli to selektor z LDT) Więc np. nasz segment kodu ma poziom uprzywilejowania 3 a numer deskryptora w tablicy GDT to selektor=2*8+3=19=0x13. Gdyby to był selektor w LDT, to jego wartość wynosiłaby 0x17. Adres tablicy GDT jest pamiętany w specjalnym rejestrze procesora GDTR. Rejestr ten nie jest dostępny bezpośrednio. Można go załadować rozkazem asemblerowym: lgdt rejestr lub adres w pamięci np.:
lgdt [eax] lgdt [tablica_gdt]
Aby zapamiętać wartość GDTR, należy użyć rozkazu sgdt, np.: sgdt edi sgdt [stara_tablica_gdt]
Teraz pora na format wpisu do GDT. Pokażę wpis jako parę liczb 32-bitowych. Format dla segmentów KODU i DANYCH
Kod: 31 0
| Baza 31..24 | G | X | O | A | Limit | P | DPL | 1 | TYP | A | BAZA 23..16 | | | | | | V | 19..16| | | | | | | | | | | | L | | | | | | | |
| Baza | Limit | | 15..0 | 15..0 |
Format dla specjalnych segmentów systemowych
Kod: 31 0
| Baza 31..24 | G | X | O | A | Limit | P | DPL | 0 | TYP | A | BAZA 23..16 | | | | | | V | 19..16| | | | | | | | | | | | L | | | | | | | |
| Baza | Limit | | 15..0 | 15..0 |
A - czy odwołano się do segmentu AVL - czy segment jest dostępny dla programisty DPL - poziom uprzywilejowania deskryptora G - granularność P - segment dostępny