Segmentacja – nielubiana siostra stronicowania

Co to?

Segmentacja, to obok stronicowania, popularny sposób organizacji pamięci. W kwestii samej pamięci nic się nie zmieniło – nadal rozważamy liniową przestrzeń, której komórki posiadają adresy (dla przypomnienia – adres do konkretnej komórki pamięci nazywamy adresem fizycznym). Mechanizm segentacji dzieli liniową pamięć na segmenty – segmentem, mówiąc najprościej, jest pewien (najczęściej ciągły) obszar pamięci. W taki sposób do odwołania się do naszej „płaskiej”, jednowymiarowej pamięci potrzebujemy dwuwymiarowego adresu (adres logicznego – czyli pewnego, jednoznacznego odpowiednika adresu fizycznego) – jest to nazwa (najczęściej numer) segmentu, oraz pozycja wewnątrz tego segmentu. Przeanalizujmy poniższy rysunek:

Pamięć adresowana jest od 0x0000 do 0xFFFF. Zawiera ona 3 segmenty o numerach (nazwach) 0, 1 i 2. Jak widzimy w każdym segmencie adresowanie zaczyna się od 0x0000, a kończy się na pewnym adresie, nazywanym popularnie limitem, który jednocześnie wyznacza rozmiar segmentu. Teraz, aby odwołać się do elementu 1 o adresie 0x3000 należy podać adres segmentu czyli 1 oraz odpowiednie przesunięcie wewnątrz tego segmentu, czyli 0x3000 (takie samo jak adres fizyczny, gdyż segment zaczyna się na adresie 0x0000) – ostatecznie otrzymujemy adres (1, 0x3000) (notacja: (segment, przesunięcie wewnątrzsegmentowe)), dla elementu 2 o adresie fizycznym 0xA123 otrzymujemy w posegmentowanej pamięci adres (0, 0x2124), natomiast element 3 o adresie fizycznym 0xFFFF ma adres logiczny (2, 0x1FFF). Wszystko powinno być już teraz jasne. Trzeba przyznać, że dosyć to udziwnione – liniowa pamięć jest wygodna, po co więc używać dwuwymiarowego odpowiednika i w ogóle skąd się te segmenty biorą?

Zalety

Segmentację opracowano w celu umożliwienia podziału programu i danych na logicznie niezależne przestrzenie adresowe oraz aby wprowadzić łatwy mechanizm bezpieczeństwa i współdzielenia.

Segmentacja jest widoczna w modelu programowym – programista może swodobnie definiować nowe, własne segmenty – w ten sposób dostajemy logiczny, elegancki podział informacji. Przykładowe segmenty to: kod, dane, stałe, bss (statycznie alokowane dane), stos itd. To, co się w nich znajdzie zależy tak naprawdę od inwencji programisty.

Segmentacja wprowadza sprytne zabezpiecznie programów przed niebezpiecznymi błędami typu przepełnienie bufora, gdyż poszczególne segmenty mogą być oznaczone jako kod lub jako dane. Próba „wykonania” segmentu z danymi lub nadpisania załadowanego kodu zakończy się błędem. Ponadto segmenty mogą posiadać zabezpiecznia ze względu na poziom uprawnień – tj. czy to kod/dane systemu operacyjnego, sterowników, czy użytkownika.

Kolejną zaletą jest łatwość relokacji danych. Wyobraźmy sobie, że chcemy mieć tablicę o zmiennym rozmiarze – taką do której możemy „doalokować” pewną liczbę bajtów. W pewnym momencie, przy zmianie długości może się okazać, że bezpośrednio po naszej tablicy znajdują się inne, potrzebne dane. Musimy wtedy zaalokować naszą nową, większą tablicę w innym, odpowiednio dużym miejscu – a co się z tym wiąże – zmienić jej adres. Korzystając z segmentacji możemy umieścić taką dynamiczną tablicę w odpowiednim segmencie i w miarę potrzeb zwiększać jego limit. Gdy okaże się, że rozszerzający się segment zacznie zachodzić na inny, możemy go wtedy relokować w inne miejsce, ale tym razem adres się nie zmieni, gdyż segment nadal będzie miał ten sam numer, a elementy w jego wnętrzu to samo przesunięcie (choć oczywiście wiąże się to z kopiowaniem danych).

Ostatnią zaletą, o której warto wspomnieć to możliwość łatwego współdzielenia kodu oraz danych. Wystarczy w tym celu utworzyć odpowiednie, współdzielone segmenty i pozwolić na korzystanie z nich odpowiednim procesom. W taki sposób uruchomienie kilku instancji danego programu nie powoduje zapełnienia dostępnej pamięci wieloma identycznymi wersjami kodu.

Wady

Wady mechanizmu segmentacji są oczywiste. Segmentacja wymusza na programiście używania nieliniowej przestrzeni adresowej co może być kłopotliwe. Ponadto, tworzenie wielu segmentów, a nastepnie ich usuwanie może doprowadzić do powstawania „dziur” pomiędzy kolejnymi segmentami, które będą zbyt małe, aby pomieścić nowe segmenty. Takie zjawisko nazywamy szachownicowaniem lub (popularniej) zewnętrzną fragmentacją. Problem ten można rozwiązać za pomocą bardzo kosztownego kompaktowania – czyli upychania segmentów tak, aby następowały po sobie.

Realia

Architektura x86 posiada wsparcie dla segmentacji. Można powiedzieć nawet więcej – segmentacja działa zawsze i nie da się jej wyłączyć (w przeciwieństwie do stronicowania), czego większość informatyków jest nieświadoma. Sprytnym, programowym obejściem tego faktu jest utworzenie dwóch segmentów, rozciągających się na całą pamięć – kodu i danych. Będą one wtedy oczywiście na siebie zachodzić, ale niczemu to nie szkodzi. Tej techniki używają wszystkie nowoczesne systemy operacyjne w tym Linux, Windows oraz Mac OS X. Dlaczego segmentacja jest tak nielubiana? Cóż, widocznie wszyscy programiści kochają liniową przestrzeń adresową ;). Warto jednak zauważyć, że we wspomnianych systemach operacyjnych segmentacja realizowana jest niejako programowo – tj. istnieje możliwość tworzenia własnych segmentów (słówka kluczowe segment albo section w NASM) w assemblerze. Nie istnieje jednak szczególny powód aby to robić, dlatego z tej możliwości korzystają tylko kompilatory języków wyższego poziomu tak, aby ułożyć logicznie kod (w sekcje code, data, bss).

Jeśli interesują Was systemy korzystające z segmentacji, polecam poczytać o systemie MULTICS (z którego wywodzi się UNIX),  w którym mechanizmu tego użyto.

A20 – historia nieodpowiedzialności

A20?

W mojej serii postów zbliżam się coraz bardziej do momentu, w którym opuszczę tryb rzeczywisty i przejdę do trybu chronionego. Wspominałem, że w trybie rzeczywistym jesteśmy w stanie zaadresować do 1MiB pamięci RAM, a tryb chroniony daje nam dostęp do całej 4GiB przestrzeni. Jak się jednak okazuje, samo fizyczne przejście (o którym niebawem) nie wystarcza – trzeba wcześniej „odblokować” linię A20, czyli 21 linię adresową (A20 – od address line 20 – numeracja od 0 ;)) dostępu do pamięci. Przypomnijmy – 1 MiB = 2^20, a więc potrzebujemy 20 fizycznych linii, które wyznaczają adres. Odblokowanie 21 linii powoduje również aktywowanie pozostałych – ile ich jest, zależy tak naprawdę od konkretnego sprzętu. Dla sprzętu obsługującego 4GiB pamięci RAM będzie ich oczywiście 32.

Zgodność wsteczna…

Dociekliwi mogą zastanawiać się, dlaczego 21 linia adresowa jest domyślnie nieaktywna. Odpowiedź na to pytanie jest śmieszna i jednocześnie przykra – mówiąc najkrócej – zgodność wsteczna. W dawnych czasach procesora 8086 nie było potrzebnych więcej niż 20 linii – 1MiB było szczytem technologicznych marzeń. Powstało wtedy bardzo wiele programów współpracujących z tą architekturą, które tworzone były przez bardziej albo mniej rozgarniętych i odpowiedzialnych informatyków. Ci drudzy wykorzystywali fakt, iż przekroczenie granicy 1MiB (co było możliwe w związku z podziałem na segmenty – patrz tryb rzeczywisty) powodowało dostęp do początkowych bajtów pamięci. Mówiąc obrazowo – pamięć „zawijała się” – z końca do początku. Czujecie już jak bardzo bezmyślnym pomysłem było wykorzystanie tego „bugo-ficzera”? W końcu nastały piękne czasy IBM PC/AT wraz z Intelem 286, który umożliwiał zaadresowanie do 16 MiB pamięci. Rewolucja, prawda? Nie jest dziwnym, iż twórcy nowoczesnej technologii chcieli zachować 100% zgodności wstecznej z poprzednią architekturą, tak aby klienci wraz z wymianą sprzętu nie musieli wymieniać oprogramowania. Wszystko było pięknie do czasu, aż testrzy zaczęli zgłaszać bugi w pewnym oprogramowaniu – wykorzystujący zawijającą się pamięć! Prawa rynku są brutalne, więc zmartwieni, ważni ludzie pracujący nad 286 postanowili zaimplementować tego „buga” w swoim nowym procesorze blokując linię A20 i uzyskując pełną zgodność wsteczną :) Najwidoczniej poprawianie starych błędów mogło okazać się zbyt kosztowne i lepiej było je „obejść”. Z resztą, takie decyzje są w naszej branży bardzo powszechne. W taki sposób do dzisiejszego dnia, komputery architektury x86 mają (a raczej miewają) zablokowaną linię A20. Niestety, to nie koniec problemów.

Standardy, eee?

Okej, skoro już mamy tę linię zablokowaną, to warto by było ją aktywować, gdy już przekonamy się do nie-16bitowych aplikacji. Niestety w czasach 286 standardy nie były tak trendy jak teraz, więc nie opracowano ustandaryzowanego sposobu na dokonanie aktywacji. Koncepcji było wiele. Najpopularniejsą stała się koncepcja, aby do odblokowania A20 używać wolnego pina… w kontrolerze klawiatury! Czujecie zapach absurdu? Klawiatura, pamięć – gdzie tu związek? Wśród innych koncepcji warto wspomnieć o tzw. FAST A20 Gate pozwalającej na odblokowanie za pomocą portów, czy odpowiednich przerwaniach BIOS-u. Oczywiście różne sposoby działają lub nie na różnych płytach głównych różnych producentów, a jedyny sposób aby mieć jako taką pewność, iż udało się nam aktywować A20 to spróbować kilku sposobów. Jakby mało było złego, niektórzy producenci postanowili być na tyle dobroczynni, że dostarczają nam środowisko z już odblokowaną A20. Miło z ich strony, prawda? Dzięki temu, zanim przystąpimy do aktywowania A20, należy dodatkowo sprawdzić, czy ktoś nie zrobił tego za nas. Wspaniale!

Bolesna lekcja

Wnioski z powyższej historii są banalne. Nie bądźmy krótkowzroczni. Czasem nasze decyzje mogą mieć wpływ na rozwój spraw wiele lat później – w szczególności mogą go zahamować. Nie starajmy się również pomagać na siłę – czasem łatwo tym zaszkodzić. Przede wszystkim jednak, pamiętajmy o standardach – o tworzeniu ich i pielęgnowaniu.

W którymś z następnych postów zaimplementujemy sprawdzanie czy linia A20 jest aktywna oraz w razie potrzeby spróbujemy ją aktywować którymś z popularnych sposobów. Tymczasem zachęcam do poczytania na temat tu i tu.

Systemy operacyjne – książki

Wiedza, wiedza, wiedza…

Tworzenie systemów operacyjnych to niszowa dziedzina informatyki. Zajmują się nią nieliczni. Osobiście uważam jednak, że posiadanie wiadomości z zakresu systemów operacyjnych, to absolutny obowiązek każdego szanującego się informatyka. Nie myślę tu oczywiście o umiejętności obsługi Linuksa, czy też administracji Windowsem, tylko o zagadnieniach typu wieloprocesowość i wielowątkowość, synchronizacja procesów i wątków, szeregowanie, zarządzanie pamięcią, czy choćby znajomość zarysu historycznego początków informatyki. Wielu osobom może się wydawać, iż wiedza ta jest całkowicie zbędna „bo przecież ja programuję w .NET i nie robię żadnych wywołań systemowych i nie zarządzam pamięcią, tylko tworzę aplikacje webowe!”. Jasne, tak może być, tylko kompletna nieświadomość tego, co dzieje się „pod spodem”, może doprowadzić niejednokrotnie do katastrofy, a w innych sytuacjach wyjaśnienie takiego, a nie innego zachowania naszej aplikacji leży właśnie w systemie operacyjnym i jego „bebechach”. Jeśli to mimo wszystko nie przemawia, to po prostu powiem, że temat jest bardzo ciekawy i warto go zgłębić, choćby dla przyjemności :)

W dobie internetu, w którym wszystko można znaleźć, może się wydawać, że książki to przeżytek. Sam preferuję uczyć się nowych technologii z tutoriali i dokumentacji, gdyż zapewniają one absolutną aktualność zawartych informacji. Systemy operacyjne, jak już wspominałem wielokrotnie, to inna działka. Wiele wiadomości w tym zakresie to niezmienne od lat fundamenty, pozostałe natomiast zmieniają się bardzo powoli. Książki sprawdzają się tu bardzo dobrze, bo zapewniają całościowe i wyczerpujące podejście. Poza tym, kto nie lubi zapachu farby drukarskiej ponad świecący monitor?

Niekwestionowani liderzy

Rynek książek na temat systemów operacyjnych jest bardzo mały – tak jak mówiłem – nisza. Jak to się jednak mówi – nie ilość, ale jakość! Na polskim rynku niepodzielnie królują dwa tytuły i są to „Systemy operacyjne”, której autorem jest Andrew Stuart Tanenbaum, twórca kultowego systemu MINIX, od którego wiele się zaczeło oraz „Podstawy systemów operacyjnych” autorstwa Abrahama Silberschatza, Petera Baera Galvina oraz Grega Gagne’a. Najnowsze wydanie (trzecie) pierwszej z nich ukazało się w tym roku za sprawą wydawnictwa helion i pokrywa się z najnowszą, angielską wersją, natomiast druga z wymienionych książek wydawana jest przez WNT – najnowsze wydanie z 2005 roku, to wydanie szóste, podczas gdy na świecie mamy już wydanie ósme. Dodatkowo niepokojącym jest fakt, że już od długiego czasu na stronie wydawnictwa widnieje napis „Książka czasowo niedostępna”. Może to oznaczać, że nowe wydanie jest w drodze, albo niestety – jakieś problemy. Dość już jednak suchych faktów, przejdźmy do tego, co książki te oferują i która z nich jest lepsza.

Obie książki oferują całościowe ujęcie tematu. Znajdziemy w nich dużo wyczerpujących informacji na tematy takie jak historia systemów operacyjnych; podstawowe pojęcia; procesy i wątki – IPC, szeregowanie, synchronizacja; zarządzanie pamięcią – stronicowanie i segmentacja, algorytmy alokacji pamięci; system plików; wejście-wyjście; bezpieczeństwo. Dodatkowo „Podstawy systemów operacyjnych” zawierają obszerny rozdział poświęcony rozproszonym systemom operacyjnym, natomiast w ramach rekompensaty „Systemy operacyjne” posiadają duży rozdział o implementacji systemu operacyjnego. Na uwagę zasługują też rozdziały opisujące konkretne systemy operacyjne – co i jak zostało w nich zrealizowane. Oczywiście w książce Tanenbauma informacje dotyczą nowszych wydań konkretnych systemów.

Język obu książek nie jest szczególnie lekki, ale nie powiedziałbym, że czyta się je ciężko – tematyka wymaga (niestety, bądź stety) używania języka formalnego, jednak wszystko daje się zrozumieć. Ciężko też znaleźć fragmenty, w których autorzy „laliby wodę”. Moim zdaniem, udało się im zachować równowagę pomiędzy niejasną zwięzłością, a przesadną obszernością.

Żadna z książek nie wyczerpuje tematu, bo jest to raczej niemożliwe. Obie natomiast prezentują bardzo obszerny kawałek tematu na swoich ponad 1000 stronach. Która z nich jest zatem trafniejszym zakupem? Na dzień dzisiejszy odpowiedź jest prosta – jest to książka „Systemy operacyjne”, ze względu na łatwą dostępność (księgarnia helion 99 zł (!) na dzień dzisiejszy) i większą aktualność (mimo wszystko). „Podstawy systemów operacyjnych” daje się czasem trafić w antykwariatach, na kiermaszach, bądź na allegro, jednak jej cena sięga nierzadko… 300 zł ze względu na swoistą unikalność. Cena zabójcza. Aha, muszę jeszcze wspomnieć, iż obie książki posiadają niebanalne okładki :) Powiedziałbym nawet, że okładka „Systemów operacyjnych” to najciekawiej zaprojektowana okładka, jaką w życiu widziałem. Polecam zobaczyć ;>

Na zakończenie

Naprawdę gorąco zachęcam do przeczytania jednego z tych tytułów – i nieważne czy jesteś programistą, administratorem, architektem, serwisantem, czy reinstalatorem Windowsów – zawsze znajdziesz tam wiele ciekawych informacji, które – nóż, widelec – mogą się kiedyś przydać. A nawet jeśli nie – wiedza jest zawsze sexy i w modzie :)

EDIT 11.10.2010:

Na rynku brak książek rodzimych autorów o tematyce tworzenia czy budowy systemów operacyjnych, jednak właśnie dostałem informację, o pozycji, która niebawem się ukaże – Programowanie systemowe mikroprocesorów rodziny x86 autorstwa Włodzimierza Stanisławskiego i Damiana Raczyńskiego. Myślę, że warto spróbować!

Dostęp do sprzętu peryferyjnego – podstawy

Zarys

W życiu każdego projektanta systemów operacyjnych nadchodzi moment, w którym chciałby się on skontaktować z urządzeniami zewnętrznymi, gdyż samotny procesor przestaje spełniać jego wygórowane oczekiwania :) Jak to bywa prawie ze wszystkim, istnieje kilka sposobów dostępu do sprzętu peryferyjnego, co wynika oczywiście z naturalnej ewolucji hardware’u – w tym poście zajmę się jednak tylko dwoma, najprostszymi metodami – port I/O oraz memory-mapped I/O, co dałoby się przetłumaczyć jako odpowiednio – wejście/wyjście za pomocą portów oraz wejście wyjście odwzorowane w pamięci. Wśród bardziej zaawansowanych metod, na które jeszcze przyjdzie czas, warto wspomnieć o DMA oraz dostępie przez przerwania.

Memory-mapped I/O

Memory-mapped I/O to bardzo prosty sposób na dostęp do urządzeń zewnętrznych polegających na tym, iż w dostępnej pamięci operacyjnej – a dokładniej w dostępnej przestrzeni adresowej – posiadamy zarezerwowany zakres adresów pozwalających na odwoływanie się do urządzeń. Rezerwacja może być zarówno stała, jak i tymczasowa. Technicznie, w uproszczeniu rzecz ujmując, realizacja wygląda tak, iż każde z urządzeń monitoruje szynę adresową procesora i reaguje na każdy jego dostęp do odpowiedniego zakresu. Zaletami takiego podejścia są oczywiście – prostota i jasność w korzystaniu (łatwo programuje się to w C), gdyż dostęp do pamięci jest prosty; procesor oparty o memory-mapped I/O jest tańszy, mniejszy, prostszy i mniej energochłonny; dostęp do pamięci jest szybki, a więc dostęp do urządzeń poprzez szynę adresową też – również dzięki możliwości wykorzystania różnych trybów adresowania. Wady? Takie podejście „przerywa” ciągłość pamięci w konwencjonalnym ujęciu, a więc zmniejsza też ilość dostępnej pamięci. Dla formalności, przykładowy kod:

unsigned char *videoram = (unsigned char *) 0xB8000;
videoram[0] = 65; /* character 'A' */
videoram[1] = 0x07; /* forground, background color */

W ten sposób wypiszemy literkę ‚A’ na ekranie, odwołując się do karty graficznej. Wygląda prosto, prawda? I o to właśnie chodzi :) Pozostaje jeszcze pytanie, na które nie ma odpowiedzi – skąd wiedzieć która cześć pamięci za co odpowiada? Rozwiązania należy szukać w mapie pamięci, która dla każdej architektury może być inna. Warto też pamiętać, że istnieje możliwość dynamicznego przydzielania adresów dla urządzeń.

Port I/O

Port I/O to kolejna, starsza i generalnie gorsza metoda dostępu do urządzeń, która ciągle jest obecna w architekturze x86 z powodu.. tak tak, zgodności wstecznej. Sposób ten polega na istnieniu dodatkowej, obok RAM-u, przestrzeni adresowej, w której każde urządzenie ma swój adres. Dostęp do portów odbywa się za pomocą specjalnych instrukcji, charakterystycznych dla architektury, które nie mają swojego odpowiednika w języku C. W assemblerze x86 są to: IN, INS/INSB/INSW/INSD, OUT, OUTS/OUTSB/OUTSW/OUTSD pozwalające wczytać/pisać odpowiednią porcję danych z/do wskazanego portu. Technicznie, transfer danych odbywa się za pomocą specjalnego I/O pina w CPU lub za pomocą przeznaczonej do tego szyny adresowej, która nieco przyspiesza ten proces. Zaletami tego rozwiązania jest oszczędność przestrzeni adresowej,  a więc i samej pamięci oraz fakt, iż dostęp przez odpowiednie instrukcje, w jasny sposób wskazuje czytającemu kod programiście, kiedy odbywa się komunikacja ze sprzętem. Wadą, jak już wspomniałem, jest powolność oraz brak wsparcia dla operacji 64 bitowych. Przykładowy kod:

a20wait:
        in      al, 0x64
        test    al, 2
        jnz     a20wait
        ret

Kod ten, jak widać, wczytuje do rejestru al (ax) bajt z urządzenia o adresie 0x64, o którym będzie jeszcze mowa ;) Warto zwrócić uwagę, że używany jest tu rejestr (e)ax, gdyż… jest to jedyny rejestr dostępny do użycia z portami w architekturze x86 – niestety. Podobnie – adres może być stałą natychmiastową lub wartością wyłącznie z rejstru DX. Pozostaje nam jeszcze odpowiedź na pytanie zadane dla dostępu przez memory-mapped I/O – czyli skąd wiedzieć, który port połączony jest z którym urządzeniem. Odpowiedź i tym razem jest niełatwa. Niektóre urządzenia takie jak timery, kontrolery przerwań, porty PS/2, serial, parallel, dyskietka, dysk twardy, karta graficzna mają przypisane konkretne adresy z powodów kompatybilności. Pozostałe urządzenia typu plug-and-play mają adresy przypisane przez BIOS i aby je otrzymać, należy poprosić o to szynę PCI :) Inne urządzenia (np. karty ISA) posiadają zworki, którymi da się ustawić konkretny port. Pamiętacie ustawianie portów Soundblastera w grach za czasów DOS-a? Tak – to właśnie dlatego :)

Podsumowanie

Nowoczesne architektury – 32 i 64 bitowe odchodzą od modelu z portami na rzecz zunifikowanej przestrzeni adresowej – ze względu na wysoką wydajność i elegancję takiego rozwiązania. W obecnych czasach, mała ilość pamięci nie jest już przeszkodą. Są jednak chwile, w których dostęp za pomocą portów jest słuszną (lub jedyną ;>) metodą dostępu do urządzeń – należy więc o niej pamiętać. Konkretne przykłady użycia – już wkrótce.

Tworzenie systemu operacyjnego – część 0×02: Dobrodziejstwa BIOS-u

512 bajtów (tak samo jak 640K) nie wystarczy każdemu

W poprzednim odcinku załadowaliśmy 512 bajtów zawartości dysku do pamięci. W taki sposób uruchomiliśmy nasz bootloader, który niestety nic nie robił. Teraz wypadałoby, aby zmienił on tryb operacyjny, wyświetlił kilka diagnostycznych komunikatów no i załadował jądro za pomocą sterownika ATA… tylko to wszystko nie zmieści się w 512 bajtach! Jeśli postawimy na minimum, tj. załadowanie jądra z dysku – również może być ciężko, sterownik jednak swoje waży. Z pomocą przychodzi nam jednak BIOS!

Funkcje BIOS-a – przerwania

BIOS udostępnia nam bardzo wiele funkcji poprzez przerwania. Wśród oferowanego asortymentu są np.: pisanie na ekran, wczytywanie z dysku, sprawdzanie stanu sprzętu, uzyskiwanie mapy pamięci, aktywowanie dodatkowej pamięci i wiele, wiele innych. My zajmiemy się dla przykładu tylko dwoma. Pełna ich lista znajduje się tutaj i tutaj. Widzicie funkcje opisane jako „???”? Uważajcie na nie! Skoro nikt, nawet twórcy BIOS-ów nie wiedzą do czego służą, to możecie nimi przez przypadek przejąć władzę nad światem lub wyłączyć prąd u sąsiada w domu.. :)

Dla niezaznajomionych z programowaniem systemowym: przerwanie wywołuje się poleceniem int numer_przerwania, natomiast argumenty przekazuje się za pomocą odpowiednich rejestrów.

int 0x10

Na początek postaramy się wypisać coś na ekran. W tym celu skorzystamy z przerwania 0x10, którego dokładny opis jest tutaj. Oto kod:

	mov	ax, 0x0000
	mov	ds, ax		; round way to do that...
	mov	si, msg

	mov	ah, 0x0E	; mode - teletype (advance and scroll)
	mov	bh, 0x00	; page number
	mov	bl, 0x07	; colors

.next_char:
	lodsb
	or	al, al		; letter here
	jz	.continue
	int	0x10		; BIOS video interrupt
	jmp	.next_char

msg:
	db	'Hello from bootloader!', 13, 10, 0

Idąc od początku, warto zwrócić uwagę na linie 5 i 6 i na dziwną, okrężną drogę ładowania rejestru DS (data segment). Niestety – takie są ograniczenia architektury – nie można bezpośrednio ładować rejestrów segmentowych. Do rejestru SI ładujemy adres pamięci pierwszej litery (czyli mówiąc najprościej – napisu) i tak uzyskana para (DS:SI) wskazuje nam jednoznacznie, gdzie jest napis. Pora na kolejne ustawienia. W rejestrze AH, zgodnie z opisem musi znaleźć się wartość 0xE, która definiuje tryb wyświetlania liter – jest to przewijanie i przeskakiwanie na następną pozycję (w dokumentacji nazwany teletype). W rejestrze BH przechowujemy numer strony – u nas jest to strona zerowa. Rejestr BL zawiera natomiast kolory (tła i liter) – białe litery na czarnym tle.

Możemy teraz przejść do pętli wypisującej literę po literze. Instrukcja lodsb ładuje literę wskazywaną przez DS:SI do rejestru AL, a następnie przesuwa wskaźnik do następnej litery. Polecenie o tyle przydatne,  gdyż oszczędzamy w ten sposób cenne miejsce w naszych 512 bajtach. Kolejnym krokiem jest sprawdzenie, czy przypadkiem nie dotarliśmy do końca napisu i jeśli tak, to opuszczenie pętli (linie 15 i 16), następnie wywołanie samego przerwania (linia 17) oraz skok zamykający pętle. Bajecznie proste prawda? Po wykonaniu tego kawałka kodu powinniśmy ujrzeć na ekranie napis „Hello from bootloader!”. Czas na trochę bardziej przydatne i skomplikowane przerwanie.

int 0x13

Szczęśliwa „trzynastka” ;) pozwala nam na wczytywanie danych z dysku za pomocą adresowania typu LBA (jeśli nie wiesz co to, przeczytaj koniecznie podlinkowaną stronę Wikipedii). Rzut oka na kod:

	mov	si, read_pocket
	mov	ah, 0x42	; extension
	mov	dl, 0x80	; drive number (0x80 should be drive #0)
	int	0x13

read_pocket:
	db	0x10		; size of pocket
	db	0		; const 0
	dw	1		; number of sectors to transfer
	dw	0x7E00, 0x0000	; address to write
	dd	1		; LBA
	dd	0		; upper LBA

Tym razem w rejestrze SI znajduje się adres „kieszeni” (o której szerzej – zaraz) zawierającej informacje o tym co i gdzie wczytać. Rejestr AH zawiera numer identyfikujący tę właśnie funkcję (wśród dostępnych funkcji znajdują się również takie, które pozwalają na dostęp CHS). Natomiast rejestr DL zawiera numer dysku z którego chcemy czytać… zupełnie spodziewanie, dysk numer 0 znajduje się pod numerem 0x80 ;> Przerwanie wywołujemy w linii 24 i o ile wszystko poszło gładko, powinniśmy mieć dane załadowane pod wskazany adres. Co do samej kieszeni, to komentarze chyba mówią wszystko. Pierwszy bajt zawiera rozmiar kieszeni, drugim powinno być zawsze 0, kolejne dwa to liczba sektorów do wczytania, następne dwa słowa to człony adresu (u nas to 0x0000:0x7E00), potem następuje adres sektora startowego na dysku (zaczynamy od sektora numer 1, czyli efektywnie od drugiego) i jego „górna” część. Prosto, łatwo i przyjemnie! :) W prawdziwym, profesjonalnym systemie powinniśmy jakoś obsłużyć błędy wczytywania, których kody zwracane są w odpowiednich rejestrach (opis tu).

Wszystko do kupy

Finalnie nasz kod wygląda tak:

[ORG 0x7C00]			; here is where our code will be loaded by BIOS
[BITS 16]

bootloader:
	mov	ax, 0x0000
	mov	ds, ax		; round way to do that...
	mov	si, msg

	mov	ah, 0x0E	; mode -> teletype (advance and scroll)
	mov	bh, 0x00	; page number
	mov	bl, 0x07	; colors

.next_char:
	lodsb
	or	al, al		; letter here
	jz	.continue
	int	0x10		; BIOS video interrupt
	jmp	.next_char

.continue:
	mov	si, read_pocket
	mov	ah, 0x42	; extension
	mov	dl, 0x80	; drive number (0x80 should be drive #0)
	int	0x13
	cli			; turn off maskable interrupts, we don't need them now
	hlt
.halt:	jmp	.halt

msg:
	db	'Hello from bootloader!', 13, 10, 0
read_pocket:
	db	0x10		; size of pocket
	db	0		; const 0
	dw	1		; number of sectors to transfer
	dw	0x7E00, 0x0000	; address to write
	dd	1		; LBA
	dd	0		; upper LBA 

times 510-($-$$) db 0		; fill rest with zeros
dw 0xAA55			; bootloader indicator, used by BIOS

Do celów testowych musimy stworzyć dalszą część naszego wirtualnego dysku, jako że ma on tylko 512 bajtów i wczytanie kolejnego sektora zaowocuje błędem. Proponuję zrobić to tak:

echo 'Ala ma kota' > ./bin/text
dd if=/dev/zero of=./bin/zeros bs=1  count=500
cat ./bin/boot.bin ./bin/text ./bin/zeros > ./bin/hda.img

Kolejno: tworzę plik z zawartością „Ala ma kota” (plus nowa linia!), tworzę plik 500 bajtowy z samymi zerami, a następnie wszystko łącze w kolejności: kod + tekst + zera, co nam daje 1024 bajty.

Po uruchomieniu naszego bootloadera w QEMU zobaczymy na ekranie „Hello from bootloader!”, natomiast w pamięci pod adresem 0x7E00 powinien być napis „Ala ma kota”. Dla pewności, w trybie monitora sprawdźmy to komendą xp /12bc 0x7E00. Wspaniale!

Single stage

Nasz bootloader aktualnie posiada tylko jeden etap (ang. stage) działania. Bardziej złożone bootloadery, jak np. GNU GRUB posiadają kilka etapów działania (najczęściej 2) ze względu na wspomniane ograniczenie 512 bajtów. W kolejnej części cyklu spróbujemy napisać stage 2 dla naszego bootloadera, który odpowiednio skonfiguruje środowisko pracy dla naszego jądra. Tymczasem zachęcam do zapoznania się z pełnymi źródłami części 0x02:

git clone git://github.com/luksow/OS.git --branch 0x02

Jeśli chcesz go tylko przejrzeć, wejdź tutaj.

Tworzenie systemu operacyjnego – część 0×01: Włączam komputer i…, bootloader

Power on!

W życiu każdego młodego informatyka nastaje moment, gdy zaczyna się zastanawiać, co tak właściwie się dzieje, gdy włącza komputer. Na ten temat można by mówić długo i na różnym poziomie szczegółowości. Ja nie będę zajmował się jednak skaczącymi elektronami i zmieniającymi się poziomami energetycznymi w krzemie, a tym co interesuje programistę systemów operacyjnych – poziomem oprogramowania.

Włączenie komputera rozpoczyna się od naciśnięcia przycisku (genialne spostrzeżenie, prawda?), który włącza zasilanie komputera, a konkretniej – zasila płytę główną. Ta z kolei, w pierwszej chwili uruchamia swój własny firmware. Ciężko określić jak dokładnie proces ten przebiega, gdyż dla każdej płyty głównej może być to trochę inne. Tak naprawdę chodzi o to, że płyta główna potrzebuje programu, który uruchomi procesor. Jeśli w tym momencie coś pójdzie nie tak, będziemy oglądać ciemny ekran, słyszeć kręcące się wiatraczki i piski z głośniczka na płycie głównej. Załóżmy jednak, że udało się uruchomić procesor. Co ciekawsi zastanawiają się pewnie – „a co jeśli komputer posiada dwa lub więcej procesorów?”. Otóż w systemach wieloprocesorowych jeden z procesorów jest tzw. bootstrap processor (BSP), który odpowiedzialny jest za uruchomienie BIOS-u oraz zainicjowanie jądra. Drugi z procesorów pozostaje w stanie zatrzymania (halt), aż do momentu kiedy explicite zostanie obudzony przez jądro systemu operacyjnego. Wracając jednak do naszej sekwencji – nasz świeżo uruchomiony procesor znajduje się w dobrze zdefiniowanym stanie – tj. znane są zawartości części jego rejestrów, w szczególności rejestru wskaźnika instrukcji CS:IP. Rejestr ten przechowuje magiczny adres nazwany reset vector. W tym momencie płyta główna musi się upewnić, że instrukcja znajdująca się pod tym adresem, to skok do miejsca w pamięci, w którym znajduje się zmapowany BIOS – jest to obszar adresów nieco poniżej magicznej granicy 1MB (np. 0x9FC00 – 0xFFFFF). Warto zwrócić uwagę na słowo zmapowany – tzn. dokładnie w tym miejscu w pamięci RAM znajdują się śmiecie, a płyta główna tworzy iluzję, jakoby znajdował się tam BIOS (wie jak to zrobić dzięki przechowywanej przez nią mapy pamięci). Od momentu gdy zacznie wykonywać się BIOS, ciężko powiedzieć co dzieje się dalej, gdyż to zależy od konkretnego BIOS-u – a więc od producenta płyty głównej. Standardowo jest to wykonanie „Power-on self-test”, czyli tzw. POST-u, który testuje – integralność samego BIOS-u, niektóre podzespoły, pamięć itp. Kolejnym krokiem po POST jest przejście do sekwencji bootowania. Pierwszym krokiem bootowania jest przejrzenie (predefiniowanej przez użytkownika w ustawieniach BIOS-u) listy urządzeń do wystartowania i odszukaniu urządzenia (np. dysku), którego pierwszy (a w zasadzie zerowy) sektor, czyli 512 bajtów, kończy się bajtami 0x55 oraz 0xAA. Bajty te oznaczają, iż urządzenie jest bootowalne – zawiera bootloader. Następnie, wspomniane 512 bajtów jest kopiowane pod adres 0x7C00, a procesor zaczyna wykonywać instrukcje spod tegoż adresu. Warto wspomnieć, że istnieje pewien standard, jak owe 512 bajtów powinno wyglądać – tzn. powinien być tam MBR. Nie jest to jednak istotne, gdyż w tym momencie pełną władzę przejmujemy my – programiści! :)

Przed dalszą lekturą upewnij się, że zapoznałeś się informacjami zawartymi w:

QEMU – podstawy

Tryby operacyjne – tryb rzeczywisty

Bootloader

Pierwsza wersja naszego bootloadera będzie robiła.. nic :) a dokładniej nasz bootloader „zatrzyma” procesor. W kolejnej części nieco go rozbudujemy. W tym miejscu trzeba zaznaczyć, że komputer pracuje w trybie rzeczywistym. Spójrzmy na kod naszego bootloadera:

[ORG 0x7C00]			; here is where our code will be loaded by BIOS
[BITS 16]

bootloader:
	cli			; turn off maskable interrupts, we don't need them now
	hlt			; halt CPU
	jmp	bootloader	; this should not happen, but.. ;)

times 510-($-$$) db 0		; fill rest with zeros
dw 0xAA55			; bootloader indicator, used by BIOS

Teraz będą objaśnienia. Pierwsza linia to wskazówka dla naszego kompilatora, żeby przyjął odpowiednie przesunięcie w adresach. Gdyby tej linii nie było (co możecie sprawdzić) kompilator „myślałby”,  że kod wskazywany przez etykietę bootloader znajduje się pod adresem 0x0000, a co za tym idzie skok z linii 7 by się nie powiódł.

Druga linia, to kolejna wskazówka, mówiąca tym razem, że chcemy kod wynikowy 16 bitowy – pamiętacie o trybie rzeczywistym?

Linie 5, 6 i 7 należy rozpatrywać razem. Instrukcja cli wyłącza maskowalne przerwania. O tym co to dokładniej znaczy będzie innym razem, ważne żeby zapamiętać iż przerwania wybudzają procesor, ze stanu halt, aktywowanego poleceniem hlt. W stanie halt procesor zatrzymuje się i nie wykonuje następującej instrukcji, aż do wznowienia. Tak więc brak instrukcji cli spowodowałby chwilowe wstrzymanie procesora, a następnie (gdyż przerwań w tle dzieje się dużo!) wykonanie instrukcji z linii 7, która jest swoistą „ostatnią deską ratunku” :) Polecam poeksperymentować usuwając linie 5 i 7 i zobaczyć dokąd zabrnie nasz IP i czy nie skończy się to restartem.

Linia 9 to makro NASM-a mówiące, aby wypełnić następujące bajty, aż do 510, zerami.

Linia 10 to wspomniany indykator świadczący o tym, iż jest to kod bootloadera.

W ten sposób otrzymujemy 512 bajtów bootloadera.

Nasz kod kompilujemy poleceniem:

nasm boot.asm -f bin -o ./bin/boot.bin

Przełącznik -f bin mówi, iż chcemy, aby wynikowy kod był tzw. płaską binarką (ang. flat binary), czyli ma nie zawierać żadnych nagłówków, ani informacji pomocniczych, a całość kodu źródłowego jest bezpośrednio zamieniana na kod. Możemy to sprawdzić używając narzędzia hexdump – zobaczymy, iż pierwszym bajtem wynikowego pliku boot.bin jest 0xFA, które jest kodem operacji cli :)

Pozostaje nam teraz uruchomienie naszego bootloadera za pomocą polecenia:

qemu -hda ./bin/boot.bin

I voila! Nasz bootloader działa i nic nie robi :) Będąc w QEMU polecam pobawić się trybem monitora, w szczególności wyświetlić fragmenty pamięci.

Końcowe słowa

To tyle w dzisiejszym odcinku. W następnym postaramy się rozbudować nasz bootloader w sposób, który pozwoli załadować nam nasz przyszły kernel. W repozytorium znajduje się pełen kod wraz z plikiem Makefile (niezbyt pięknym, swoją drogą), który pozwala na automatyzację kompilacji i uruchamiania kodu.

Aby ściągnąć kod części 0x01 wykonaj:

git clone git://github.com/luksow/OS.git --branch 0x01

Jeśli chcesz go tylko przejrzeć, wejdź tutaj.

Tryby operacyjne – tryb rzeczywisty

Tryby operacyjne

Tryb operacyjny (ang. operating mode) procesora to po prostu pewien dobrze zdefiniowany tryb, w którym procesor zachowuje się w ściśle określony, charakterystyczny dla danego trybu sposób. Ciężko o formalną definicję tego pojęcia, ale myślę że zamieszczone niżej opisy trybów operacyjnych IA-32 (architektura potocznie zwana x86) i Intel 64 (architektura x86-64) rozwieją wszystkie wątpliwości.

Intel Architecture 32 bit (x86)

Architektura ta posiada 3 tryby operacyjne plus jeden quasi-tryb:

  • Real mode (tryb rzeczywisty) – inicjalny tryb pracy procesora, posiada interfejs programistyczny procesora Intel 8086 wraz z kilkoma rozszerzeniami – między innymi z możliwością przejścia do trybu chronionego. Dużo szczegółów poniżej.
  • Protected mode (tryb chroniony) – natywny tryb procesora, jeśli czytasz tę notkę z komputera PC, to bardzo prawdopodobne, że Twój procesor właśnie używa tego trybu. Tryb ten pozwala na użycie pełnego potencjału nowoczesnego procesora i to on będzie nam towarzyszył przez znacznie większą część programowania systemu operacyjnego. Dużo szczegółów wkrótce.
  • System management mode (tryb zarządzania) – bardzo nietypowy tryb, w którym mamy wysoko uprzywilejowane środowisko, pozwalające na zarządzanie energią, obsługiwanie krytycznych błędów itp. Na razie tryb ten nie będzie nas interesował.
  • Virtual-8086 mode – wspomniany quasi-tryb, który pozwala na uruchamianie programów przeznaczonych na procesor 8086 w trybie chronionym.

Intel 64 (x86-64)

Architektura ta posiada wszystkie tryby, które posiada IA-32 plus:

  • IA-32e mode, który posiada dwa podtryby:
    • Compatibility mode (tryb zgodności) – podtryb pozwalający uruchamiać aplikacje 16 i 32-bitowe bez potrzeby rekompilacji ich dla procesora 64-bitowego. Co ciekawe, aplikacje działające w trybie Virtual 8086 nie będą działały w tym trybie.
    • 64-bit mode – natywny dla 64-bitowego procesora tryb, który pozwala na korzystanie z dobrodziejstw architektury x86-64. Jeśli Twój system jest 64-bitowy, to najprawdopodobniej Twój procesor pracuje właśnie w tym trybie.

Warto wspomnieć, iż niektórzy wyróżniają tryb nazywany potocznie Unreal mode (tryb nierzeczywisty), jednak nie będę go opisywał.

Tryb rzeczywisty

Wady i zalety

Tryb rzeczywisty to inicjalny tryb procesora, który istnieje do dziś ze względu na inżynierów procesorów, którzy chcą zachować wsteczną zgodność z procesorami sprzed ery 80386. Jakie są tego konsekwencje? Niestety bardzo dotkliwe.

  • Nieco ponad 1 MiB adresowalnej pamięci, a faktycznie nieco poniżej 1 MiB pamięci do użycia
  • Brak zdecydowanej większości ficzerów architektury IA-32, w tym m. in.:
    • Brak jakiejkolwiek ochrony pamięci, co za tym idzie – brak pamięci wirtualnej
    • Brak wielowątkowośći/wieloprocesowości (nikłe możliwości emulacji)
    • Każdy „proces” może wszystko – np. mazać dowolny fragment pamięci, wykonywać instrukcje systemowe itp.
    • Niemożność użycia wszystkich rejestrów, które w trybie chronionym są ogólnodostępne
    • Ograniczone i skomplikowane możliwości adresowania pamięci

Jedyne zalety trybu rzeczywistego, to dość bogate funkcje oferowane przez BIOS, z których będziemy mieli okazję skorzystać.

Adresowanie

Adresowanie w trybie rzeczywistym nie odbywa się w typowy, liniowy sposób. Pamięć adresowana jest w następujący sposób:

Segment : Przesunięcie

Tak zaadresowana pamięć mapowana jest na fizyczny adres o postaci:

16 * Segment + Przesunięcie

Dziwne, prawda? Jeszcze dziwniejsze jest to, że pojedynczy adres fizyczny ma wiele reprezentacji w formacie „rzeczywistotrybowym”, gdyż segmenty zachodzą na siebie. I tak np. 0x12B1 : 0x0069 odpowiada adresowi 0x12B79 (0x10 * 0x12B1 + 0x0069 = 0x12B79), natomiast 0x1000 : 0x2B79 odpowiada adresowi… 0x12B79! (0x10 * 0x1000 + 0x2B79 = 0x12B79).

Do dyspozycji mamy 6 16-bitowych rejestrów segmentowych: CS, DS, ES, FS, GS oraz SS. Stos obsługuje się używając pary rejestrów SS : SP.

Dostępne tryby adresowania to:

  • [BX + offset]
  • [SI + offset]
  • [DI + offset]
  • [BP + offset]
  • [BX + SI + offset]
  • [BX + DI + offset]
  • [BP + SI + offset]
  • [BP + DI + offset]
  • [offset]

Gdzie offset zawiera się pomiędzy -32768 oraz 32767.

Z adresowaniem związane jest jeszcze jedno ciekawe zjawisko, mianowicie, gdy segment ustawimy na 0xFFFF, natomiast przesunięcie na wartość pomiędzy 0x10, a 0xFFFF, to zaadresujemy 64 KiB powyżej granicy 1 MiB, co najprawdopodobniej zaowocuje „zawinięciem” pamięci. Dokładniej zjawisko to potraktujemy przy okazji omawiania linii A20.

Funkcje oferowane przez BIOS

BIOS oferuje do użycia w trybie rzeczywistym szereg funkcji dostępnych poprzez przerwania (o przerwaniach będzie jeszcze rozlegle w kolejnych odcinkach). Opis niektórych funkcji można znaleźć tu. Przykład użycia funkcji BIOS będzie można prześledzić w następnych częściach cyklu.

Podsumowanie

Jak widać, tryb rzeczywisty ma bardzo niewiele do zaoferowania programiście systemów operacyjnych. Tryb rzeczywisty powinien nam zatem posłużyć do szybkiego przejścia do trybu chronionego i ewentualnego wykonania niezbędnych czynności poprzedzających. Aha i tak, system operacyjny DOS działał w całości w trybie rzeczywistym :)

QEMU – podstawy

Emulator, maszyna wirtualna?

QEMU to zarówno maszyna wirtualna jak i emulator, ale co to tak właściwie znaczy?

QEMU jest emulatorem, gdyż potrafi uruchamiać pojedyncze programy jak i całe systemy operacyjne napisane dla procesora innego, od tego na którym aktualnie pracuje. Jest to możliwe dzięki szybkiej translacji rozkazów procesora docelowego na rozkazy procesora na którym działa QEMU.

QEMU w trybie wirtualizacji (potrzebny Xen lub moduł KVM) działa natomiast bezpośrednio na procesorze gospodarza.

Obsługiwane przez QEMU procesory to m. in.: x86, x86-64, PowerPC, MIPS, ARM, SPARC. Pełna lista tutaj.

Podstawowa obsługa – uruchamianie

QEMU to narzędzie konsolowe, podstawowy schemat uruchamiania to:

qemu [options] [image]

Wśród opcji możemy podać m. in.:

-M machine – wybór konkretnej architektury do emulacji (-M ? wyświetla listę dostępnych)

-cpu model – wybiera konkretny procesor (-cpu ? wyświetla listę dostępnych)

-fda file, -fdb file, -hda file, -hdb file, -hdc file, -hdd file, -cdrom file – włącza do naszego emulowanego systemu urządzenia: dystkietkę (przedrostki f), dyski (przedrostki h), cdrom z zwaratością taką jak zawiera file. Uwaga: nie można używać jednocześnie hdc i cdrom.

-boot x – ustala kolejność bootowania: a, b – pierszeństwo dyskietek, c – dysk twardy, d – cdrom.

-m megs – ustala ilość wirtualnego ramu na megs MiB, domyślnie jest to 128 MiB

-kernel file – bezpośrednio uruchamia podany plik zawierający jądro naszego systemu operacyjnego zgodnie ze specyfikacją Multiboot (będzie o tym, w którymś z najbliższych wpisów)

Istnieje jeszcze wiele przełączników pozwalających ustawiać sieć, bluetooth oraz różne inne urządzenia, ale tyle co tu opisałem, w zupełności wystarczy początkującemu osdevcowi :)

Spójrzmy na parę przykładów:

qemu linux.img

Uruchamia system z podanego obrazu linux.img, wszystkie opcje pozostają domyślne.

qemu -hda hda.img -m 128

Uruchamia emulator z podłączonym dyskiem o zawartości hda.img ze 128 MiB ramu. To co się dalej stanie, zależy od zawartości hda.img, gdyż wirtualny BIOS będzie próbował bootować system właśnie z owego dysku. Różnica między tym a poprzedni przykładem jest taka, iż poprzednia komenda mówiła explicite: „bootuj linux.img”, w tym przypadku dajemy QEMU informację o stanie: „Jest dysk, rób co chcesz” ;)

qemu -kernel kernel.bin

Uruchomi nasz kernel według specyfikacji Multiboot, inaczej mówiąc – nie potrzebujemy żadnego bootloadera, a nasz kernel powinien być w jakimś dobrze zdefiniowanym formacie wykonywalnym, np. ELF (o tym też innym razem).

Ficzery QEMU

W QEMU lubię szybkość działania i łatwość obsługi, ale to nie jedyne jego, oprócz wspomnianej już wieloarchitekturowości i bogatych możliwości konfiguracji,  zalety. Istotną cechą QEMU jest to, iż wspiera VBE 2.0 oraz posiada natywne wsparcie dla GDB. Moim ulubionym „ficzerem” jest natomiast QEMU monitor.

QEMU monitor

QEMU monitor, to diagnostyczny tryb emulatora pozwalający podglądać interesujące rzeczy. Po uruchomieniu systemu w QEMU wciskamy CTRL+ALT+2 i już jesteśmy w trybie monitora (CTRL+ALT+1 wraca z powrotem na ekran systemu, natomiast CTRL+ALT pozwala „odzyskać” z powrotem myszkę). W trybie monitora mamy dostępny szereg komend:

info cpus – podaje aktualny stan procesorów

info registers – wyświetla zawartość wszystkich rejestrów dostępnych dla danej architektury. Polecenie to jest szalenie przydatne, szczególnie na początkowych etapach osdevu – np. gdy chcemy sprawdzić czy stronicowanie jest już aktywne, gdzie właśnie utknął EIP naszego procesora i w wielu, wielu innych przypadkach.

Komenda info potrafi jeszcze co nieco, ale na razie tyle nam wystarczy. Kolejne przydatne polecenia to:

x /fmt addr oraz xp /fmt addr – pierwsza z nich wyświetla zawartość wirtualnej pamięci pod adresem addr w formacie fmt, natomiast druga robi to samo, tyle że dla pamięci fizycznej. Format jest natomiast następujący: count – ilość elementów do wyświetlenia (liczba dziesiętna), format – format wyświetlenia zawartości pamięci, tj. x – hex, d – dziesiętny, u – dziesiętny bez znaku, o – oktalny, c – char lub (uwaga!) i – instrukcja!, size – rozmiar, tj. b – 8 bitów, h – 16 bitów, w – 32 bity, g – 64 bity. Przykłady:

xp /40db 0x7C00

Wyświetli dziesiętnie 40 elementów bajtowych spod adres 0x7C00.

xp /40xh 0x7C00

Wyświetli heksadecymalnie 40 elementów dwubajtowcyh spod adresu 0x7C00.

xp /10i $eip

Wyświetli 10 kolejnych instrukcji po aktualnej pozycji EIP. Widzimy, że nie musimy tu podawać rozmiaru, gdyż jak wiadomo w x86 instrukcje mają zmienny rozmiar. Takie wyświetlenie jest szczególnie przydatne, gdy zastanawiamy się gdzie właśnie utknął nasz kernel :)

QEMU monitor posiada jeszcze wiele przydatnych opcji jak np. zrobienie screena, czy nagranie dźwięku jednak nie widzę sensu opisywania ich na obecnym etapie. Kompletny spis można znaleźć tu.

Na zakończenie

QEMU będzie nam bardzo pomocne w całej serii artykułów Tworzenie systemu operacyjnego. Będzie więc wiele okazji aby przećwiczyć zdobytą tutaj wiedzę na temat obsługi tego niezwykle zgrabnego narzędzia. Tymczasem zapraszam do ściągnięcia QEMU stąd, zapoznania się z dokumentacją tu oraz do spojrzenia na inne emulatory, np. bochs. Aha, jeśli ktoś naprawdę nie znosi konsolowych aplikacji, to istnieje parę graficznych nakładek na QEMU, jak np. qtemu czy qemulator, jednak żadnej z nich nie testowałem.

Tworzenie systemu operacyjnego – część 0x00: Wstęp i formalizmy

Skąd pomysł?

Po ponad 6 miesiącach od powstania idei serii postów, pierwsza część ujrzała właśnie światło dzienne. Pomysł na cykl notek zrodził mi się zaraz po ukończeniu kursu „Systemy operacyjne” na mojej ulubionej uczelni. Według (genialnego!) Prowadzącego, około 15% studentów po tym kursie przystępuje do napisania własnego systemu operacyjnego i wygląda na to, że ja jestem w grupie tych ~19 osób. Zapowiada się świetna zabawa :)

Co to będzie?

Seria będzie dokumentować i opowiadać o moich zmaganiach z próbą napisania (od zera) systemu operacyjnego o pewnej funkcjonalności. W postach postaram się zawrzeć wiedzę i kod, który krok po kroku będzie układał się w pełnowartościowy system operacyjny.

Po co to?

Cykl postów o tematyce programowania systemu operacyjnego będzie dokumentacją moich poczynań. Posty będą zdecydowanie miały charakter poznawczy, gdyż w żadnym przypadku nie jestem autorytetem w tej dziedzinie, a (na razie!) tylko początkującym amatorem. Proponuję więc nie polegać na zawartej tu wiedzy podczas kolokwiów z architektury komputerów ;) Proszę też o regularne komentarze z poprawkami do prezentowanych przeze mnie zagadnień – z pewnością będę je wtedy poprawiał. Przy okazji serii mam nadzieję zachęcić czytelników do zagłębienia się w fascynujący świat programowania systemowego, odkryć go nieco, a może nawet skłonić do napisania własnego systemu operacyjnego? Ponadto, nie znalazłem w internecie publikacji w języku polskim, które prowadziłyby krok po kroku (no dobrze, kilka by się znalazło, jednak kroki kończyły się zwykle na 3 odcinkach) po niezwykle zawiłej tematyce tworzenia systemu operacyjnego – będę więc pionierem ;> Przypominam również, że powstający system operacyjny nie ma za zadanie przewyższyć udziału rynkowego takich świetnych systemów jak Microsoft Windows, GNU/Linux czy Mac OS X, gdyż byłoby to niedorzeczne. To po prostu zwykły projekt eksperymentalny.

Co będzie potrzebne?

Najważniejszą rzeczą jest wytrwałość i chęć zdobywania wiedzy :) Posiadając te dwie cechy, nawet całkowity nowicjusz sporo może wynieść z tego cyklu. W swoich wypocinach postaram się zgrabnie balansować między nadmierną gęstością tekstu, a przesadną zwięzłością. Trudniejsze rzeczy postaram się dokładnie objaśniać, łatwiejsze będę traktował po macoszemu, dodając odnośniki, z których będzie można doczytać więcej. Zachęcam do komentowania rzeczy niejasnych i skomplikowanych tak, abym z czasem mógł dostosować poziom.

System operacyjny, przynajmniej z początku, będzie napisany w języku C z małym dodatkiem assemblera x86 (będę używał „dialektu” NASM-a), zatem znajomość C, jak również nieco assemblera zdecydowanie się przyda.

Z całą pewnością potrzebny będzie jakiś działający system operacyjny z dostępnymi narzędziami programistycznymi. W swoich postach będę opisywał tworzenie systemu operacyjnego w środowisku GNU/Linux w połączeniu z typowymi dla tej platformy narzędziami takimi jak gcc czy binutils. Przedstawione przykłady, da się jednak bez problemu skompilować pod Windowsem, czy Mac OS X, wymagałoby to jednak nieco więcej pracy (jeśli będzie taka potrzeba, mogę opisać techniki w oddzielnym poście). Zwolenników systemów innych niż Linux zachęcam do zainstalowania jakiejś łatwej i przyjemnej dystrybucji, choćby na maszynie wirtualnej i programowania w takim środowisku. Gwarantuję, że inicjalny trud się opłaci.

Kolejna rzeczą, która nie jest konieczna, ale znacząco ułatwi nam programowanie i testowanie naszego systemu będzie emulator platformy x86 (gdyż na tą platformę będzie powstawał nasz system). Mój wybór padł na qemu. Emulator przyda się, aby uruchamiać świeżo skompilowany system – choć oczywiście dla wytrwałych pozostaje opcja odpalania systemu na prawdziwej maszynie.

Formalizmy

Koniec gadania, przystępujmy do rzeczy. Chcemy napisać system operacyjny, no dobrze… tylko co to tak właściwie jest? W literaturze dałoby się znaleźć setki mniej lub bardziej zmyślnych/złożonych/obszernych definicji, wymyślić nowych można by było kilka kolejnych, a więc… która jest dobra? Odpowiedzi na to pytanie nie ma, gdyż brakuje obiektywnych kryteriów oceny, czy dana definicja jest poprawna, zła, ładna, zgrabna itd. Mi najbardziej do gustu przypadła następująca:

System operacyjny jest to zbiór programów i procedur spełniających dwie podstawowe funkcje:

– zarządzanie zasobami systemu komputerowego,

– tworzenie maszyny wirtualnej.

Natomiast najtrafniejsza definicja zasobu systemu to wg mnie:

Zasobem systemu jest każdy jego element sprzętowy lub programowy, który może być przydzielony danemu procesowi.

Definicją procesu zajmiemy się przy innej okazji.

Teraz kilka słów wyjaśnień. Jak widać z definicji systemu operacyjnego – nie jest on sam w sobie programem, a zbiorem programów i procedur. System, który będziemy implementować za jakiś czas będzie wyglądał z punktu widzenia czysto technicznego jakby był jednym programem, jednak to tylko decyzja implementacyjna – w ogólności tak być nie musi. Pierwsza funkcja, którą pełni system operacyjny wydaje się być jasna – zarządza on zasobami, które oferuje. Zarządza, czyli udziela dostępu użytkownikowi, czy też raczej programowi użytkowemu. Zasoby sprzętowe to na przykład dysk twardy, pamięć, czy też komputery podłączone w sieci, do stacji na której działa system operacyjny. Zasoby programowe to natomiast wszelkiego rodzaju tablice, czy też semafory. Druga funkcja, czyli tworzenie maszyny wirtualnej może brzmieć nieco tajemniczo. Sama maszyna wirtualna jest raczej kojarzona z procesem wirtualizacji, stawianiem odseparowanych serwerów itp., tym razem chodzi jednak po prostu o tworzenie warstwy abstrakcji łatwej do oprogramowania, użytkowania i tę właśnie warstwę nazywamy maszyną wirtualną. Nieformalnie reasumując: system operacyjny ma za zadanie oferować to, co posiada, w przystępnej formie ;)

Rozważmy teraz takie pytanie: Czy program działający na mikrokontrolerze np. mikrofalówki, lodówki, czy pralki jest systemem operacyjnym? Odpowiedź na to pytanie (według podanej wyżej definicji) to: nie. Program ten jest zadany odgórnie, nie ma możliwości oprogramowywania go – nie posiada żadnej warstwy abstrakcji i o zasobach tutaj też trudno mówić. Z kolei, zastanówmy się nad takim telewizorem, który działa w oparciu o jądro Linux. Tu sprawa nie jest już taka prosta. W końcu wiadomo, że Linux to system operacyjny (puryści mogliby się doczepić do tego stwierdzenia.. ;)), tylko że ten system dla użytkownika końcowego jest całkowicie przezroczysty – nie ma on bezpośredniego dostępu do zasobów, szczególnej maszyny wirtualnej też tu nie widać. Zatem, czy patrząc na telewizor w kontekście pudełka,  w którego środku coś się dzieje i otrzymujemy obraz, należy mówić o systemie operacyjnym? Tak jak już mówiłem, z definicjami nie jest łatwo.

Na koniec

To tyle na pierwszy odcinek serii. W kolejnym odcinku zajmiemy się już konkretami, czyli własnościami architektury x86. Poniżej załączam listę stron z materiałami, które zdecydowanie będą się przydawać.

OSDev.org – bardzo aktywny serwis typu wiki, traktujący o tematyce programowania systemów operacyjnych. Polecam od niego zaczynać szukanie odpowiedzi na pojawiające się wątpliwości.

Bona Fide OS Developer – strona zawiera pokaźną ilość przydatnych tutoriali, niestety nie jest zbyt często uaktualniana

Operating System Resource Center – skarbnica wiedzy o wszelakich zasobach systemów operacyjnych. Panuje tam trochę bałaganu, nie mniej jednak, można tam znaleźć masę przydatnych informacji.

Intel® 64 and IA-32 Architectures Software Developer’s Manuals – darmowe (!) podręczniki Intela do architektury x86 (i x86-64), zawierające 2 grube tomy na temat programowania systemowego. Przystępnie napisane, zwięźle objaśniają subtelności architektoniczne. Da się tam chyba znaleźć odpowiedź na każde pytanie, choć tego nikt nie jest pewien, bo nikt nie dał rady ich przeczytać ;)

Into the Void – skrócony (jakby ten intelowski okazał się za długi, ciężko dostępny) opis instrukcji architektury x86

W porządku, to tyle. Do usłyszenia w następnej części!