Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00689 010468 11036945 na godz. na dobę w sumie
Linux Kernel. Przewodnik programisty - książka
Linux Kernel. Przewodnik programisty - książka
Autor: Liczba stron: 400
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-439-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> systemy operacyjne >> linux
Porównaj ceny (książka, ebook, audiobook).

Dołącz do grona twórców popularności Linuksa

Fenomen Linuksa polega na tym, że jest on dziełem programistów z całego świata. Każdy może dopisać do niego nową funkcję lub udoskonalić istniejące. Jeśli Linux nie obsługuje urządzenia zainstalowanego w Twoim komputerze -- możesz zaimplementować jego obsługę, pisząc własny moduł jądra.

Programowanie jądra systemu Linux nie wymaga żadnych niezwykłych zdolności. Choć jest ono rozległym projektem informatycznym, w żaden sposób nie różni się od innych projektów tego typu. Oczywiście, samodzielne napisanie choćby kawałka kodu jądra wymaga nauki, ale napisany dotychczas kod nie jest w żaden sposób wyjątkowy ani niezrozumiały. Podstawowym materiałem pomocniczym, niezwykle przydatnym przy opanowywaniu tajników programowania jądra, jest istniejący już kod źródłowy, dostępny dla wszystkich. Jednakże samo poznawanie kodu nie wystarczy -- należy również zdobyć wiedzę dotyczącą zasad funkcjonowania systemu operacyjnego i pełnionych przez niego funkcji.

Książka 'Linux Kernel. Przewodnik programisty' została napisana po to, aby pomóc programistom w poznaniu zasad tworzenia kodu modułów jądra. Szczegółowo omawia podsystemy i funkcje jądra Linuksa, ich projekt i implementację. Autor książki porusza również zagadnienia związane z projektowaniem systemów operacyjnych.

Książka opiera się na wersji 2.6 jądra systemu Linux i zawiera informacje dotyczące następujących tematów:

Stwórz poprawne funkcje jądra Linuksa i zaimplementuj je w odpowiedni sposób.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Linux Kernel. Przewodnik programisty Autor: Robert Lowe T³umaczenie: Przemys³aw Szeremiota ISBN: 83-7361-439-7 Format: B5, stron: 400 Do³¹cz do grona twórców popularnoġci Linuksa Fenomen Linuksa polega na tym, ¿e jest on dzie³em programistów z ca³ego ġwiata. Ka¿dy mo¿e dopisaæ do niego now¹ funkcjê lub udoskonaliæ istniej¹ce. Jeġli Linux nie obs³uguje urz¹dzenia zainstalowanego w Twoim komputerze — mo¿esz zaimplementowaæ jego obs³ugê, pisz¹c w³asny modu³ j¹dra. Programowanie j¹dra systemu Linux nie wymaga ¿adnych niezwyk³ych zdolnoġci. Choæ jest ono rozleg³ym projektem informatycznym, w ¿adnej sposób nie ró¿ni siê od innych projektów tego typu. Oczywiġcie, samodzielne napisanie choæby kawa³ka kodu j¹dra wymaga nauki, ale napisany dotychczas kod nie jest w ¿aden sposób wyj¹tkowy ani niezrozumia³y. Podstawowym materia³em pomocniczym, niezwykle przydatnym przy opanowywaniu tajników programowania j¹dra, jest istniej¹cy ju¿ kod ĥród³owy, dostêpny dla wszystkich. Jednak¿e samo poznawanie kodu nie wystarczy — nale¿y równie¿ zdobyæ wiedzê dotycz¹c¹ zasad funkcjonowania systemu operacyjnego i pe³nionych przez niego funkcji. Ksi¹¿ka „Linux Kernel. Przewodnik programisty” zosta³a napisana po to, aby pomóc programistom w poznaniu zasad tworzenia kodu modu³ów j¹dra. Szczegó³owo omawia podsystemy i funkcje j¹dra Linuksa, ich projekt i implementacjê. Autor ksi¹¿ki porusza równie¿ zagadnienia zwi¹zane z projektowaniem systemów operacyjnych. Ksi¹¿ka opiera siê na wersji 2.6 j¹dra systemu Linux i zawiera informacje dotycz¹ce nastêpuj¹cych tematów: Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl • Podstawowe zasady programowania j¹dra • Zarz¹dzanie procesami • Algorytmy szeregowania zadañ • Wywo³ania systemowe • Przerwania • Metody synchronizacji j¹dra • Zarz¹dzanie czasem i pamiêci¹ • Operacje wejġcia-wyjġcia • Diagnostyka kodu j¹dra • Przenoġnoġæ kod Spis treści O Autorze ......................................................................................... 13 Przedmowa....................................................................................... 15 Wstęp .............................................................................................. 17 Słowo od Autora ............................................................................... 19 Rozdział 1. Jądro systemu Linux — wprowadzenie .............................................. 23 Wprowadzenie do systemu Linux ...................................................n..................................25 Przegląd systemów operacyjnych ...................................................n..................................26 Jądro Linuksa a jądro klasycznego systemu uniksowego .................................................28 Oznaczenia wersji jądra Linuksa...................................................n....................................29 Społeczność programistów jądra systemu Linux ...................................................n...........31 Odmienność jądra...................................................n...................................................n........31 Brak biblioteki libc ...................................................n..................................................32 GNU C ...................................................n...................................................n..................32 Brak mechanizmu ochrony pamięci...................................................n.........................34 Niemożność (łatwego) korzystania z operacji zmiennoprzecinkowych.....................35 Ograniczony co do rozmiaru i stały stos...................................................n..................35 Synchronizacja i współbieżność ...................................................n..............................35 Znaczenie przenośności ...................................................n...........................................36 Kompilowanie jądra ...................................................n...................................................n....36 Zanim zaczniemy ...................................................n...................................................n........38 Rozdział 2. Zarządzanie procesami...................................................................... 39 Deskryptor procesu i struktura zadania...................................................n..........................40 Alokacja deskryptora procesu...................................................n..................................41 Przechowywanie deskryptora procesu...................................................n.....................42 Stan procesu ...................................................n...................................................n..........43 Manipulowanie bieżącym stanem procesu ...................................................n..............44 Kontekst procesu...................................................n...................................................n...45 Tworzenie procesu ...................................................n...................................................n......46 Kopiowanie przy zapisie...................................................n..........................................47 Wywołanie fork()...................................................n...................................................n..47 Wywołanie vfork()...................................................n...................................................n49 6 Linux Kernel. Przewodnik programisty Wątki w systemie Linux...................................................n.................................................49 Wątki jądra...................................................n...................................................n............51 Zakończenie procesu ...................................................n...................................................n...52 Usuwanie deskryptora procesu ...................................................n................................53 Problem zadań osieroconych ...................................................n...................................54 Rozdział 3. Szeregowanie zadań.......................................................................... 57 Strategia postępowania...................................................n...................................................n58 Procesy ograniczone wejściem-wyjściem a procesy ograniczone procesorem ..........58 Priorytet procesu ...................................................n...................................................n...59 Kwant czasu ...................................................n...................................................n..........60 Wywłaszczanie procesu ...................................................n...........................................61 Strategia szeregowania w działaniu ...................................................n.........................61 Algorytm szeregujący ...................................................n...................................................n.62 Kolejka procesów gotowych do uruchomienia...................................................n........62 Tablice priorytetów...................................................n..................................................65 Przeliczanie kwantów czasu ...................................................n....................................66 Wywołanie schedule() ...................................................n.............................................67 Wyznaczanie nowego priorytetu i kwantu czasu...................................................n.....68 Zawieszanie i pobudzanie procesów...................................................n........................71 Równoważenie obciążenia...................................................n.......................................73 Wywłaszczanie i przełączanie kontekstu ...................................................n.......................75 Wywłaszczanie procesu użytkownika ...................................................n.....................76 Wywłaszczenie jądra ...................................................n...............................................76 Czas rzeczywisty ...................................................n...................................................n.........77 Wywołania systemowe związane z szeregowaniem ...................................................n......78 Wywołania wpływające na strategię szeregowania i wartości priorytetów................79 Wywołania systemowe sterujące kojarzeniem procesów z procesorami ...................80 Odstąpienie procesora...................................................n..............................................80 Rozdział 4. Wywołania systemowe ...................................................................... 81 API, POSIX i biblioteka C ...................................................n.............................................82 Wywołania systemowe...................................................n...................................................n83 Numery wywołań systemowych ...................................................n..............................84 Wydajność wywołania systemowego ...................................................n......................85 Procedura obsługi wywołań systemowych ...................................................n....................85 Oznaczanie właściwego wywołania systemowego...................................................n..86 Przekazywanie argumentów ...................................................n....................................86 Implementacja wywołania systemowego...................................................n.......................87 Weryfikacja argumentów...................................................n.........................................87 Kontekst wywołania systemowego ...................................................n................................89 Wiązanie wywołania systemowego ...................................................n.........................90 Inicjowanie wywołania systemowego z przestrzeni użytkownika .............................92 Cztery powody, aby nie implementować wywołań systemowych .............................93 Rozdział 5. Przerwania i procedury obsługi przerwań........................................... 95 Przerwania...................................................n...................................................n...................95 Procedury obsługi przerwań...................................................n...........................................96 Połówki górne i dolne ...................................................n..............................................97 Rejestrowanie procedury obsługi przerwania ...................................................n................98 Zwalnianie procedury obsługi przerwania...................................................n.............100 Tworzenie procedury obsługi przerwań...................................................n.......................100 Procedury obsługi przerwań współużytkowanych...................................................n.102 Prawdziwa procedura obsługi przerwania ...................................................n.............103 Kontekst przerwania ...................................................n..............................................104 Spis treści 7 Implementacja obsługi przerwań ...................................................n.................................105 /proc/interrupts ...................................................n...................................................n..........108 Kontrola przerwań...................................................n...................................................n.....109 Wyłączanie i włączanie przerwań...................................................n..........................110 Blokowanie konkretnej linii przerwania...................................................n................111 Stan systemu przerwań ...................................................n..........................................112 Tasklety ...................................................n...................................................n................. Rozdział 6. Dolne połówki i czynności odroczone .............................................. 115 Połówki dolne...................................................n...................................................n............116 Po co dolne połówki?...................................................n.............................................117 Świat dolnych połówek...................................................n..........................................117 Przerwania programowe...................................................n...............................................120 Implementacja przerwań programowych...................................................n...............120 Korzystanie z przerwań programowych ...................................................n................123 ....125 Implementacja taskletów ...................................................n.......................................125 Korzystanie z taskletów ...................................................n.........................................128 Wątek jądra ksoftirqd...................................................n.............................................130 Dawny mechanizm BH ...................................................n..........................................132 .133 Implementacja kolejek robót...................................................n..................................133 Korzystanie z kolejek robót ...................................................n...................................137 Dawny mechanizm kolejkowania zadań...................................................n................140 Jak wybrać implementację dolnej połówki? ...................................................n................140 Blokowanie pomiędzy dolnymi połówkami ...................................................n................142 Wyłączanie dolnych połówek ...................................................n................................142 Kolejki robót ...................................................n...................................................n............ Rozdział 7. Wprowadzenie do synchronizacji jądra ............................................ 145 Sekcje krytyczne i przeplot operacji ...................................................n............................146 Po co ta ochrona? ...................................................n...................................................n146 Blokowanie..........................................n...................................................n.........................147 Skąd się bierze współbieżność? ...................................................n.............................149 Co wymaga zabezpieczania? ...................................................n.................................150 Zakleszczenia ...................................................n...................................................n............151 Rywalizacja a skalowalność...................................................n.........................................154 Blokowanie we własnym kodzie...................................................n..................................155 Rozdział 8. Metody synchronizacji jądra ............................................................ 157 Operacje niepodzielne ...................................................n..................................................157 Niepodzielne operacje na liczbach całkowitych ...................................................n....158 Niepodzielne operacje bitowe...................................................n................................160 Rygle pętlowe...................................................n...................................................n............162 Inne metody blokowania ryglami pętlowymi ...................................................n........165 Rygle pętlowe a dolne połówki...................................................n..............................166 Rygle pętlowe R-W...................................................n...................................................n...166 Semafory ...................................................n...................................................n...................168 Tworzenie i inicjalizowanie semaforów ...................................................n................170 Korzystanie z semaforów...................................................n.......................................171 Semafory R-W...................................................n...................................................n...........172 Zmienne sygnałowe...................................................n...................................................n...174 Blokada BKL (Big Kernel Lock) ...................................................n.................................174 Blokady sekwencyjne...................................................n...................................................n176 Blokowanie wywłaszczania ...................................................n.........................................177 Bariery...................................................n...................................................n.......................178 8 Linux Kernel. Przewodnik programisty Chwilki ...................................................n...................................................n.................. Rozdział 9. Liczniki i zarządzanie czasem .......................................................... 183 Czas z punktu widzenia jądra...................................................n.......................................184 Częstotliwość taktowania — HZ...................................................n..................................185 Optymalna wartość HZ ...................................................n..........................................186 ....188 Wewnętrzna reprezentacja zmiennej jiffies ...................................................n...........190 Zawijanie zmiennej jiffies...................................................n......................................191 HZ a przestrzeń użytkownika ...................................................n................................192 Zegary i liczniki sprzętowe ...................................................n..........................................193 Zegar czasu rzeczywistego ...................................................n....................................193 Zegar systemowy ...................................................n...................................................n193 Procedura obsługi przerwania zegarowego...................................................n..................194 Data i godzina...................................................n...................................................n............196 Liczniki...........................................n...................................................n..............................198 Korzystanie z liczników...................................................n.........................................199 Liczniki i sytuacje hazardowe...................................................n................................201 Implementacja licznika ...................................................n..........................................201 Opóźnianie wykonania...................................................n.................................................202 Oczekiwanie w pętli aktywnej ...................................................n...............................202 Krótkie opóźnienia...................................................n.................................................204 Funkcja schedule_timeout()...................................................n...................................205 Rozdział 10. Zarządzanie pamięcią ..................................................................... 209 Strony ...................................................n...................................................n................... .....209 Strefy ...................................................n...................................................n.........................211 Pozyskiwanie stron pamięci ...................................................n.........................................213 Pozyskiwanie czystych stron pamięci...................................................n....................214 Zwalnianie stron...................................................n...................................................n..215 Funkcja kmalloc () ...................................................n...................................................n....216 Znaczniki gfp_mask...................................................n...............................................217 Funkcja kfree() ...................................................n...................................................n..........221 Funkcja vmalloc () ...................................................n...................................................n....222 Alokator plastrowy...................................................n...................................................n....223 Zadania alokatora plastrowego ...................................................n..............................224 Interfejs alokatora plastrowego ...................................................n....................................227 Statyczne przydziały na stosie...................................................n......................................230 Odwzorowanie pamięci wysokiej ...................................................n................................231 Odwzorowanie trwałe ...................................................n............................................231 Odwzorowania czasowe...................................................n.........................................232 Jak metodę przydziału wybrać? ...................................................n...................................233 Rozdział 11. Wirtualny system plików ................................................................. 235 Wspólny interfejs systemu plików ...................................................n...............................235 Warstwa abstrakcji systemu plików...................................................n.............................236 Uniksowy system plików ...................................................n.............................................237 Obiekty VFS i ich struktury danych...................................................n.............................238 Inne obiekty warstwy VFS...................................................n.....................................239 Obiekt bloku głównego ...................................................n................................................240 Operacje bloku głównego ...................................................n......................................241 Obiekt i-węzła ...................................................n...................................................n...........243 Operacje i-węzła ...................................................n...................................................n.245 Obiekt wpisu katalogowego ...................................................n.........................................247 Stan wpisu katalogowego ...................................................n......................................249 Bufor wpisów katalogowych ...................................................n.................................249 Operacje na wpisach katalogowych...................................................n.......................251 Spis treści 9 Obiekt pliku...................................................n...................................................n............. ..252 Operacje na plikach...................................................n................................................253 Struktury danych systemu plików ...................................................n................................256 Struktury danych procesu...................................................n.............................................257 Systemy plików w Linuksie ...................................................n.........................................259 Rozdział 12. Blokowe urządzenia wejścia-wyjścia ............................................... 261 Anatomia urządzenia blokowego ...................................................n.................................262 Bufory i nagłówki buforów ...................................................n..........................................263 Struktura bio...................................................n...................................................n............ ..266 Stare a nowe...................................................n...................................................n........268 Kolejki zleceń...................................................n...................................................n............269 Zlecenia...................................................n...................................................n...............269 Zawiadywanie operacjami wejścia-wyjścia ...................................................n.................269 Zadania planisty operacji wejścia-wyjścia...................................................n.............270 Winda Linusa ...................................................n...................................................n......271 Terminowy planista operacji wejścia-wyjścia ...................................................n.......272 Przewidujący planista operacji wejścia-wyjścia...................................................n....274 Rozdział 13. Przestrzeń adresowa procesu .......................................................... 277 Deskryptor pamięci ...................................................n...................................................n...279 Przydział deskryptora pamięci...................................................n...............................280 Zwalnianie deskryptora pamięci ...................................................n............................281 Struktura mm_struct i wątki jądra...................................................n..........................281 Obszary pamięci...................................................n...................................................n........282 Znaczniki VMA ...................................................n...................................................n..283 Operacje VMA...................................................n...................................................n....284 Obszary pamięci na listach i w drzewach ...................................................n..............285 Obszary pamięci w praktyce...................................................n..................................286 Manipulowanie obszarami pamięci...................................................n..............................288 Funkcja find_vma()...................................................n................................................288 Funkcja find_vma_prev()...................................................n.......................................289 Funkcja find_vma_intersection() ...................................................n...........................289 Tworzenie interwału adresów — wywołania mmap() i do_mmap() ..............................290 Wywołanie systemowe mmap()...................................................n.............................292 Usuwanie interwału adresów — wywołania munmap() i do_munmap() .......................292 Wywołanie systemowe munmap()...................................................n.........................292 Tablice stron...................................................n...................................................n..............293 Rozdział 14. Pamięć podręczna stron i opóźniony zapis stron w tle ..................... 295 Pamięć podręczna stron...................................................n................................................296 Obiekt address_space...................................................n.............................................297 Drzewo pozycyjne...................................................n...................................................n.....300 Tablica skrótów stron...................................................n.............................................300 Pamięć podręczna buforów ...................................................n..........................................301 Demon pdflush ...................................................n...................................................n..........301 bdflush i kupdated...................................................n..................................................303 Eliminowanie przeciążenia, czyli po co w jądrze wiele wątków?............................303 Rozdział 15. Diagnostyka ................................................................................... 305 Od czego zacząć? ...................................................n...................................................n......305 Błędy w jądrze...................................................n...................................................n...........306 Funkcja printk()...................................................n...................................................n.........307 Wszechstronność funkcji printk() ...................................................n..........................307 Ograniczenia funkcji printk()...................................................n.................................307 Poziomy rejestrowania...................................................n...........................................308 10 Linux Kernel. Przewodnik programisty Błąd oops...................................................n...................................................n................ Bufor komunikatów ...................................................n...............................................309 Demony syslogd i klogd ...................................................n........................................310 Funkcja printk() a hakerzy jądra ...................................................n............................310 ...310 Polecenie ksymoops...................................................n...............................................312 kallsyms ...................................................n...................................................n..............313 Opcje diagnostyczne jądra ...................................................n...........................................313 Diagnostyka niepodzielności operacji ...................................................n...................313 Prowokowanie błędów i wyprowadzanie informacji ...................................................n...314 Funkcja Magic SysRq Key...................................................n...........................................315 Saga debugera jądra ...................................................n...................................................n..315 gdb...................................................n...................................................n...................... .316 kgdb...................................................n...................................................n.....................317 kdb...................................................n...................................................n...................... .318 Stymulowanie i sondowanie systemu ...................................................n..........................318 Uzależnianie wykonania kodu od identyfikatora UID..............................................318 Korzystanie ze zmiennych warunkowych ...................................................n.............319 Korzystanie ze statystyk ...................................................n........................................319 Ograniczanie częstotliwości komunikatów diagnostycznych...................................319 Szukanie winowajcy — wyszukiwanie binarne...................................................n...........321 Koledzy — kiedy wszystko inne zawiedzie...................................................n.................322 Rozdział 16. Przenośność ................................................................................... 323 Historia przenośności systemu Linux ...................................................n..........................325 Rozmiar słowa i typy danych ...................................................n.......................................326 Typy nieprzejrzyste...................................................n................................................328 Typy specjalne ...................................................n...................................................n....329 Typy o zadanych rozmiarach ...................................................n.................................329 Znak typu char ...................................................n...................................................n....330 Wyrównanie danych...................................................n...................................................n..331 Unikanie problemów wyrównywania ...................................................n....................331 Wyrównanie typów niestandardowych...................................................n..................332 Dopełnienie struktury...................................................n.............................................332 Wzajemny porządek bajtów ...................................................n.........................................333 Typy wzajemnego porządku bajtów — rys historyczny...........................................335 Wzajemny porządek bajtów w jądrze ...................................................n....................335 Pomiar upływu czasu ...................................................n...................................................n336 Rozmiar strony ...................................................n...................................................n..........336 Kolejność wykonywania instrukcji ...................................................n..............................337 Tryb SMP, wywłaszczanie jądra i pamięć wysoka ...................................................n......338 Przenośność to wyzwanie...................................................n.............................................338 Rozdział 17. Łaty, haking i społeczność .............................................................. 339 Społeczność...................................................n...................................................n...............339 Obowiązujący styl kodowania ...................................................n.....................................340 Wcięcia ...................................................n...................................................n...............341 Nawiasy klamrowe...................................................n.................................................341 Nazewnictwo...................................................n...................................................n.......342 Funkcje...................................................n...................................................n................342 Komentarze ...................................................n...................................................n.........343 Definicje typów...................................................n...................................................n...344 Korzystanie z zastanego...................................................n.........................................344 Unikanie definicji ifdef w kodzie źródłowym ...................................................n.......344 Inicjalizacja struktur...................................................n...............................................345 Poprawianie złego stylu ...................................................n.........................................345 Spis treści 11 Łańcuch poleceń...................................................n...................................................n........346 Przesyłanie raportów o błędach...................................................n....................................346 Generowanie łat...................................................n...................................................n.........347 Rozsyłanie łat ...................................................n...................................................n............348 Dodatek A Korzystanie z list ............................................................................ 351 Listy cykliczne ...................................................n...................................................n..........351 Poruszanie się pomiędzy elementami listy ...................................................n............352 Implementacja listy w jądrze Linuksa...................................................n..........................353 Struktura listy...................................................n...................................................n......353 Manipulowanie listami...................................................n.................................................354 Przeglądanie list ...................................................n...................................................n........356 Dodatek B Interfejs procesora.......................................................................... 359 Nowy interfejs procesora ...................................................n.............................................360 Statyczne dane procesora...................................................n.......................................360 Dynamiczne dane procesora ...................................................n..................................361 Po co korzystać z danych procesora?...................................................n...........................362 Dodatek C Generator liczb losowych jądra ........................................................ 365 Projekt i implementacja puli entropii ...................................................n...........................366 Problem rozruchu programu ...................................................n..................................368 Interfejs wejściowy puli entropii...................................................n..................................368 Interfejs wyjściowy puli entropii...................................................n..................................369 Dodatek D Złożoność obliczeniowa................................................................... 371 .371 Algorytmy ...................................................n...................................................n................ Zapis złożoności O(x) ...................................................n..................................................372 Notacja duże theta ...................................................n...................................................n.....372 Co z tego wynika? ...................................................n...................................................n.....373 Pułapki złożoności czasowej...................................................n........................................373 Dodatek E Bibliografia i lektury dodatkowe ...................................................... 375 Książki o projektowaniu systemów operacyjnych ...................................................n.......375 Książki o jądrze systemu Unix...................................................n.....................................376 Książki o jądrze systemu Linux ...................................................n...................................377 Książki o jądrach innych systemów operacyjnych ...................................................n......377 Książki o interfejsie programowym Uniksa...................................................n.................377 Inne książki ...................................................n...................................................n...............378 Witryny WWW ...................................................n...................................................n.........378 Skorowidz ...................................................................................... 381 Rozdział 1. Jądro systemu Linux — wprowadzenie Mimo zaawansowanego już wieku (trzech dekad) system Unix wciąż jest uważany za jeden z najefektywniejszych i najlepiej pomyślanych systemów operacyjnych. Powstał w roku 1969 — od tego momentu legendarne już dzieło Dennisa Ritchie i Kena Thompso- na wciąż wytrzymuje próbę czasu, który zresztą lekko tsylko zaznacza na Uniksie swój ząb. Unix wyrósł na Mutiksie, zarzuconym przez ośrodek badawczy Bell Laboratories pro- jekcie wielodostępnego systemu operacyjnego. Po zatrzymaniu projektu pracownicy ośrodka badawczego zostali bez interaktywnego systemu operacyjnego. Dopiero la- tem roku 1969 programiści Bell Labs zakreślili zarysy plikowego systemu operacyj- nego, który ostatecznie ewoluował do postaci obecnej w systemie Unix. Projekt został zaimplementowany przez Kena Thompsona na stojącym bezczynnie po zarzuceniu Multiksa komputerze PDP-7. W roku 1971 system został zaadaptowany do specyfiki komputera PDP-7, a w roku 1973 całość została przepisana w języku C, co — choć w owym czasie było przedsięwzięciem bez precedensu — otwarło możliwość przeno- szenia systemu na dowolne niemal maszyny. Pierwszym Uniksem wykorzystywanym na szerszą skalę poza ośrodkiem Bell Labs był Unix System Sixth Edition (edycja szó- sta), znany jako wersja V6. Również inne firmy podjęły rękawicę i rozpoczęły przenoszenie systemu na nowe plat- formy. Towarzyszące tym przenosinom ulepszenia zaowocowały powstaniem szeregu odmian systemu operacyjnego. W roku 1977 ośrodek Bell Labs opublikował pod na- zwą Unix System III spójną kompilację owych rozszerzeń; w roku 1982 firma AT T udostępniła zaś słynny System V1. Prostota architektury Uniksa oraz fakt, że był on rozprowadzany wraz z kodem źródło- wym, umożliwiły rozwój systemu już poza firmą jego twórców. Największy udział w rozwoju systemu miał Uniwersytet Kalifornijski w Berkeley. Odmiany systemu Unix opracowywane na tym uniwersytecie noszą nazwę Berkeley Software Distributions 1 A co z wersją System IV? Plotka głosi, że wersja taj istniała wyłącznie jako wersja rozwojowo-badawcza.j 24 Linux Kernel. Przewodnik programisty (BSD). Pierwszą z nich była 3BSD, wydana w roku 1981. Następnymi wersjami były produkty z serii czwartej, a więc 4.0BSD, 4.1BSD, 4.2BSD oraz 4.3BSD. W tych wer- sjach system Unix został wzbogacony o obsługę pamięci wirtualnej, stronicowanie na żądanie (ang. demand paging) oraz stos TCP/IP. W roku 1993 udostępniona została ostateczna wersja systemu z serii 4BSD — 4.4BSD, zawierająca przepisany moduł zarządzania pamięcią wirtualną. Współcześnie rozwój gałęzi BSD jest kontynuowany w ramach systemów FreeBSD, NetBSD oraz OpenBSD. W latach osiemdziesiątych i dziewięćdziesiątych na rynek trafiło też wiele odmian systemu Unix autorstwa róż- nych firn produkujących systemy serwerowe i stacje robocze. Systemy te bazowały zwykle na implementacji AT T lub odmiany BSD, rozszerzając je o obsługę cech charakterystycznych dla platform, na które były przenoszone. Do takich właśnie sys- temów należą: Tru64 firmy Digital, HP-UX firmy Hewlett-Packard, IBM-owski AIX, DYNIX firmy Sequent, IRIX firmy SGI czy słynny Solaris autorstwsa Sun Corporation. Elegancja pierwotnego projektu systemu operacyjnego Unix w połączeniu z latami innowacji i ewolucji dały efekt w postaci wydajnego, niezawodnego i stabilnego sys- temu operacyjnego. Źródło takiej elastyczności systemu Unix tkwi w szeregu jego cech. Po pierwsze bowiem Unix jest systemem prostym; niektóre inne systemy operacyjne składają się z tysięcy wywołań systemowych, których przeznaczenie nie zawsze jest oczywiste. Systemy z rodziny Uniksa implementują zwykle zaledwie kilkaset wywo- łań, z których każde jest starannie przemyślane i realizuje ściśle określone funkcje. Po drugie, w systemie Unix wszystko jest plikiem2. Upraszcza to znakomicie manipulowa- nie danymi i urządzeniami — dostęp do danych i urządzeń realizowany jest za pośred- nictwem zestawu prostych wywołań systemowych: QRGP , TGCF , YTKVG , KQEVN oraz ENQUG . Po trzecie zaś, jądro systemu Unix oraz jego podstawowe elementy zo- stały napisane w języku C, co daje temu systemowi niezrównaną przenośność i przy- bliża go szerokiemu gronu programistów. Dalej, system Unix cechuje się krótkim czasem tworzenia procesu oraz unikalnym wywołaniem HQTM . Wreszcie system ten udostępnia proste acz przemyślane podsta- wy komunikacji międzyprocesowej, co w połączeniu z krótkim czasem tworzenia pro- cesów pozwala na konstruowanie prostych narzędzi systemowych, realizujących jed- ną funkcję, ale realizujących ją jak najlepiej. Z owych funkcji mogą korzystać zadania bardziej złożone. Obecnie Unix jest nowoczesnym systemem operacyjnym obsługującym wielozadanio- wość, wielowątkowość, pamięć wirtualną, stronicowanie na żądanie, biblioteki współ- użytkowane oraz stos protokołu TCP/IP. Istnieją odmiany Uniksa dające się skalować do setek procesorów, ale istnieją również wersje osadzone, przeznaczone do obsługi wyspecjalizowanych platform o minimalnych możliwościach. I choć Unix od dawna nie jest już projektem badawczym, jego kolejne implementacje nadążają za nowymi koncepcjami w dziedzinie systemów operacyjnych, co na szczęście nie odbywa się kosztem przydatności Uniksa jako systemu ogólnego psrzeznaczenia. 2 Cóż, może nie wszystko, ale znaczna liczba elementów jsystemu reprezentowana jest plikiem. W najnowocześniejszych implementacjach systemu Unix i jejgo pochodnych (jak np. Plan9) pliki reprezentują niemal wszystko. Rozdział 1. ♦ Jądro systemu Linux — wprowadzenie 25 Unix zawdzięcza swój sukces elegancji i prostocie pierwotnego projektu. Jego dzisiej- szą siła tkwi w pierwszych decyzjach podejmowanych przez Dennisa Ritchie, Kena Thompsona oraz innych współtwórców pierwotnych wierszy kodu systemu. To wła- śnie te decyzje są źródłem zdolności systemu operacyjsnego Unix do ciągłej ewolucji. Wprowadzenie do systemu Linux Linix został opracowany przez Linusa Torvaldsa w roku 1991. Z założenia miał to być system operacyjny dla komputerów wykorzystujących procesor Intel 80386, będący ów- cześnie procesorem stosunkowo nowym i niewątpliwie nowoczesnym. Dziś Linux jest systemem operacyjnym działającym na szeregu platform, w tym AMD x86064, ARM, Compaq Alpha, CRIS, DEC VAX, H8/300, Hitachi SuperH, HP PA-RISC, IBM S/390, Intel IA-64, MIPS, Motorola 68000, PowerPC, SPARC, UltraSparc oraz v850. Linux obsługuje zarówno zegarki, jak i klastry superkomputerów. Zwiększyło się też komercyj- ne zainteresowanie Linuksem. Dziś zarówno firmy związane z Linuksem, jak i pozostali gracze rynkowi, oferują wykorzystujące ten system rozwiązania programowe dla urzą- dzeń wyspecjalizowanych, komputerów biurkowych oraz systemów serwerowych. Linux jest klonem systemu Unix, ale nie jest Uniksem. Znaczy to, że choć Linux wyko- rzystuje szereg koncepcji opracowanych pierwotnie na potrzeby Uniksa i implementuje interfejs programowy tego systemu (zdefiniowany specyfikacjami POSIX oraz Single Unix Specification), nie jest bezpośrednią pochodną kodu źródłowego systemu Unix, jak to ma miejsce w przypadku innych systemów uniksopodobnych. Tam, gdzie to potrzebne, Linux jest inny od pozostałych systemów uniksowych, ale odmienność ta nigdy nie naru- szała ani podstawowych cech projektowych, ani interfsejsu programowego pierwowzoru. Jedną z najciekawszych cech Linuksa jest fakt, że nie jest to produkt komercyjny — Li- nux jest owocem współpracy wielu programistów, możliwej dzięki medium, jakim jest internet. I choć Linus Torvalds nigdy nie utraci miana twórcy systemu Linux i wciąż jest opiekunem jądra systemu, jego dzieło jest kontynuowane przez niezliczoną rzeszę programistów. Do rozwoju Linuksa może zresztą przyczynić się dosłownie każdy, kto ma na to ochotę. Jądro systemu Linux, podobnie jak większość jego pozostałej imple- mentacji, jest oprogramowaniem darmowym albo inaczej wolnym3. W szczególności jądro systemu Linux objęte jest Powszechną Licencją Publiczną GNU (ang. GNU Ge- neral Public Licence, GPL) w wersji 2.0. Licencja ta gwarantuje możliwość nieod- płatnego pobierania kodu źródłowego i wprowadzania do niego dowolnych modyfi- kacji. Jedynym wymaganiem jest redystrybucja wersji zmodyfikowanych na tych samych, otwartych zasadach GNU GPL, co oznacza między innymi konieczność dystrybuowania kodu źródłowego wersji zmodyfikowanej4. 3 4 Szkoda tu miejsca na szczegółowe omawianie różnicy pomjiędzy oprogramowaniem darmowym i wolnym. Czytelnicy zainteresowani tym tematem powinjni zajrzeć pod adresy http://www.fsf.org oraz http://www.opensource.org. Warto zapoznać się z treścią licencji GNU GPL. Można ją znajleźć w pliku COPYING w drzewie katalogów kodu źródłowego jądra Linuksa oraz na stroniej http://www.fsf.org (przekład treści licencji na język polski można znaleźć pod adresem http://www.linux.org.pl/gpl.php — przyp. tłum.). 26 Linux Kernel. Przewodnik programisty Linux dla różnych osób oznacza zupełnie coś innego. Podstawą systemu Linux są ją- dro, biblioteka języka C, kompilator, system kompilacji s(ang. toolchain, czyli komplet narzędzi programistycznych, takich jak asembler, konsolidator i inne). Ale system Li- nux może zawierać również implementację nowoczesnego środowiska graficznego X Window System wraz z kompletnym graficznym interfejsem użytkownika, jakim jest choćby GNOME. Linux ma tysiące komercyjnych i niekomercyjnych zastosowań. W tej książce słowo Linux będzie jednak najczęściej oznaczać jądro systemu Linux. Tam, gdzie nie będzie to oczywiste, znaczenie tego słowa będzie wskazywane jawnie. Na- wiasem mówiąc, termin Linux odnosi się właśnie do samego jądra systemu. Powszechna dostępność kodu źródłowego systemu Linux oznacza możliwość dowol- nej konfiguracji jądra przed jego kompilacją. Można więc wybrać do kompilacji jądro zawierające wyłącznie te sterowniki i moduły, które są dla danego zastosowania nie- zbędne. Elastyczność taka jest zapewniana wielością opcji konfiguracji o nazwach po- staci 10(+)A *#. Przykładowo, aby w jądrze włączyć obsługę symetrycznego prze- twarzania współbieżnego (ang. symmetrical multiprocessing, SMP), należy do opcji kompilacji dołączyć opcję 10(+)A5/2. Jeżeli opcji tej zabraknie, tryb SMP zostanie z jądra usunięty. Opcje kompilacji przechowywane są w pliku .config w katalogu głów- nym drzewa katalogów kodu źródłowego jądra. Plik ów można wypełniać za pośred- nictwem jednego z programów konfigurujących proces kompilacji, jak np. OCMGZEQPHKI. Opcje konfiguracyjne służą zarówno do włączania do kompilacji kolejnych plików im- plementacji, jak i do sterowania kompilacją za pośrednictwem dyrektyw preprocesora. Przegląd systemów operacyjnych Dzięki niektórym współczesnym systemom operacyjnym pojęcie systemu operacyjnego nie jest już dziś precyzyjne. Użytkownicy często uważają za system operacyjny to, co widzą po uruchomieniu komputera. Zgodnie z ogólnym i wykorzystywanym w tej książce rozumieniem tego pojęcia system operacyjny obejmuje te fragmenty systemu kompute- rowego, które służą do podstawowej administracji i umożliwiają wykorzystanie syste- mu. System operacyjny obejmuje więc jądro wraz ze sterownikami urządzeń, moduł ładowania systemu operacyjnego, powłokę (ewentualnie inny interfejs użytkownika) oraz podstawowe pliki konfiguracyjne i narzędzia systemowe. A więc wszystko, co nie- zbędne do działania systemu. Termin system odnosi się przy tym do systemu operacyj- nego oraz wszystkich aplikacji, które da się w nim uruchomić. Książka ta jest rzecz jasna poświęcona jądru systemu operacyjnego. Tak jak interfejs użytkownika jest najbardziej zewnętrzną warstwą systemu operacyjnego, tak jego jądro stanowi część najbardziej integralną. Jądro to „samo sedno” systemu — zawiera opro- gramowanie implementujące podstawowe usługi dla wszelkich innych elementów sys- temu, zarządzające sprzętem oraz dystrybuujące zasoby systemowe. Jądro określane jest niekiedy mianem modułu nadzorczego (ang. supervisor) albo rdzenia (ang. core) systemu operacyjnego. Najbardziej typowe składniki jądra to: procedury obsługi prze- rwań, planista (ang. scheduler) sterujący podziałem czasu procesora pomiędzy urucho- mione w systemie procesy, moduł zarządzania pamięcią zarządzający przestrzeniami adresowymi procesów oraz usługi systemowe, w rodzaju obsługi sieci czy komunikacji Rozdział 1. ♦ Jądro systemu Linux — wprowadzenie 27 międzyprocesowej. W nowocześniejszych systemach wyposażonych w jednostkę za- rządzania pamięcią z jej ochroną jądro działa zazwyczaj w wyodrębnionym od stanu zwykłych aplikacji użytkowych stanie; stan ten obejmuje ochronę pamięci oraz pełen dostęp do zasobów sprzętowych. Ów stan wraz z obszarem pamięci jądra zwany jest przestrzenią jądra. Z drugiej strony programy użytkowe wykonywane są w przestrze- ni użytkownika. W tej przestrzeni widoczny jest tylko fragment zasobów komputera; z przestrzeni użytkownika nie można też inicjować niektórych funkcji systemowych ani odwoływać się bezpośrednio do sprzętu. W trakcie wykonywania kodu jądra sys- tem znajduje się w przestrzeni jądra — aplikacje użytkowe wykonywane są zaś w prze- strzeni użytkownika. Aplikacje działające w systemie mogą jednak komunikować się z jądrem za pośred- nictwem zestawu wywołań systemowych (patrz rysunek 1.1). Aplikacja inicjuje te wywołania zwykle z poziomu pewnej biblioteki (np. biblioteki języka C), która z ko- lei, wykorzystując interfejs wywołań systemowych, instruuje jądro o potrzebie wyko- nania funkcji systemowej na rzecz aplikacji. Niektóre wywołania biblioteczne oferują wiele cech, których próżno szukać w implementacji wywołań systemowych — w ta- kim przypadku wywołanie systemowe stanowi zaledwie ułamek operacji realizowanych przez funkcję biblioteczną. Przykładem takiej funkcji jest znana z pewnością Czytel- nikowi funkcja RTKPVH . Obsługuje ona formatowanie i buforowanie danych znako- wych, inicjując wywołanie systemowe YTKVG jedynie w celu ostatecznego wyprowa- dzenia danych na urządzenie zewnętrzne. Z drugiej strony, niektóre funkcje biblioteczne są bezpośrednio odwzorowywane do wywołania systemowego. Przykładem takiej funk- cji bibliotecznej jest funkcja QRGP , której działanie sprowadza się do zainicjowania wywołania systemowego QRGP . Istnieje też kategoria funkcji bibliotecznych, jak UVTEQR[ , które w ogóle nie korzystają z wywołań systemowych (a przynajmniej nie powinny). Kiedy aplikacja inicjuje wywołanie systemowe, mówi się, że na rzecz tej aplikacji wykonywana jest funkcja jądra. Aplikacje mogą bowiem wykonywać wywo- łania systemowe w przestrzeni jądra — wtedy jądro działa w kontekście procesu. Ten związek pomiędzy aplikacją a jądrem, umożliwiający wywoływanie kodu jądra za po- średnictwem wywołania systemowego, jest podstawą dzisałania wszystkich aplikacji. Jądro zarządza sprzętem zainstalowanym w systemie komputerowym. Niemal wszyst- kie znane architektury, włącznie z tymi obsługiwanymi przez system Linux, wykorzy- stują pojęcie przerwań. Przerwanie służy urządzeniu sprzętowemu komunikacji z sys- temem za pośrednictwem asynchronicznej ingerencji w wykonywanie kodu jądra. Do poszczególnych przerwań przypisane są numery. Na podstawie tych numerów jądro wybiera do wykonania w obliczu przerwania odpowiednią procedurę obsługi przerwa- nia. Na przykład, kiedy użytkownik naciśnie klawisz na klawiaturze, kontroler klawia- tury inicjuje przerwanie powiadamiające system o obecności nowych danych w bu- forze klawiatury. Jądro odnotowuje fakt wystąpienia przerwania i uruchamia odpowiednią procedurę obsługi. Procedura ta przetwarza dane i sygnalizuje kontrolerowi gotowość do przyjmowania kolejnych danych z klawiatury. Aby zapewnić odpowiednią synchro- nizację, jądro ma zwykle możliwość blokowania przerwań (zarówno wszystkich prze- rwań, jak i przerwań o wybranych numerach). W rzadko którym systemie operacyjnym procedury obsługi przerwań uruchamiane są w kontekście procesu — przeważnie procedury te wykonywane są w kontekście przerwania nieskojarzonym z żadnym kon- kretnym procesem. Kontekst ten istnieje wyłącznie w celu umożliwienia maksymalnie szybkiej reakcji na przerwanie. 28 Linux Kernel. Przewodnik programisty Rysunek 1.1. Zależności pomiędzy aplikacjami, jądrem i sprzętem Wymienione konteksty obejmują całość działalności jądra. W rzeczy samej, w przy- padku Linuksa można uogólnić to omówienie i stwierdzić, że procesor może w dowol- nym momencie realizować jedną z trzech czynności:  wykonywać kod jądra w kontekście procesu (na rzecz sprocesu aplikacji użytkowej) w przestrzeni jądra;  wykonywać kod procedury obsługi przerwania w przestrzseni jądra (w kontekście przerwania);  wykonywać kod procesu aplikacji użytkowej w przestrszeni użytkownika. Jądro Linuksa a jądro klasycznego systemu uniksowego W wyniku wspólnego korzenia i implementowania identycznego interfejsu systemowe- go jądra współczesnych systemów uniksowych charakteryzują się one podobnymi ce- chami projektowymi. Z nielicznymi wyjątkami jądra systemów uniksowych to pakiety monolityczne i statyczne. Oznacza to istnienie sporych rozmiarów wykonywalnego obrazu jądra działającego w pojedynczej przestrzeni adresowej. Podstawowym wyma- ganiem systemów operacyjnych z rodziny Unix jest obecność w komputerze jednostki zarządzania pamięcią ze stronicowaniem; urządzenie to pozwala na wymuszenie przez system operacyjny ochrony systemowego obszaru pamięci i udostępnienie wirtualnej przestrzeni adresowej dla każdego z procesów systemu. Zagadnieniu projektu klasycz- nych jąder systemów z rodziny Unix poświęcono zresztą wiele osobnych książek. Rozdział 1. ♦ Jądro systemu Linux — wprowadzenie 29 Wysiłki Linusa Torvaldsa oraz innych programistów uczestniczących w rozwoju ją- dra systemu Linux skierowane były na umożliwienie ulepszenia architektury Linuksa bez odrzucania jego uniksowych korzeni (i, co ważniejsze, bez odrzucenia interfejsu programowego systemu Unix). W efekcie, ponieważ Linux nie opiera się na żadnym z istniejących Uniksów, Linus i inni mogli w dowolny sposób kształtować rozwiąza- nia poszczególnych zadań projektowych, a w szczególności implementować w jądrze rozwiązania całkiem nowe. Powstałe tak różnice pomiędzy Linuksem a tradycyjnymi odmianami Uniksa to między innymi:  Linux obsługuje dynamiczne ładowanie modułów jądra. Choć sjądro systemu jest monolityczne, ma możliwość dynamicznego ładowanisa i usuwania z pamięci modułów kodu jądra.  Linux obsługuje symetryczne przetwarzanie współbieżne (sSMP). Współcześnie w obsługę tego trybu wyposażono również wiele komercyjsnych odmian Uniksa, ale większość tradycyjnych implementacji systemu Unisx jest go pozbawiona.  Jądro systemu Linux obsługuje wywłaszczanie. W przeciwiesństwie do tradycyjnych odmian systemu Unix jądro systemu Linux może wywłaszczyć zadanie, jeżeli działa ono w przestrzeni jsądra. Z komercyjnych odmian systemu Unix wywłaszczanie zaimplementowano smiędzy innymi w systemach Solaris i IRIX.  Linux w ciekawy sposób obsługuje wątki — planista nie rsozróżnia wątków i procesów. Dla jądra wszystkie procesy są takie sames — fakt współużytkowania przez niektóre z nich przestrzeni adresowej nie ma sznaczenia.  Implementacja Linuksa ignoruje te cechy systemu Unixs, których implementacja jest powszechnie uznawana za niedomagającą, jak impslementacja interfejsu STREAMS; Linux ignoruje też „martwe” standardy.  Linux jest wolny w każdym znaczeniu tego słowa5. Zestaw funkcji zaimplementowany w systemie Linux jest owocem wolnosści Linuksa i wolnego modelu rozwoju oprogramowania. Funkcje nadsmiarowe czy nieprzemyślane nie są implementowane w ogóle. Z drugisej strony wszystkie funkcje umieszczane w jądrze pojawiają się w nim w swyniku opracowywania rozwiązań konkretnych problemów, są rozważnie projektoswane i elegancko implementowane. W wyniku takiego modelu rozwoju systsem operacyjny nie implementuje na przykład obecnego w innych odmianachs Uniksa stronicowania pamięci jądra. Mimo to system Linux pozsostaje spadkobiercą wszystkich najlepszych cech systemu Unix. Oznaczenia wersji jądra Linuksa Jądra systemu Linux można podzielić na dwie kategorie — jądra stabilne i rozwojowe. Jądra stabilne to wydania przystosowane do szerokich zastosowań ogólnych. Nowe jądra stabilne publikowane są zwykle wyłącznie w obliczu pojawienia się w jądrze poprawek błędów lub sterowników nowych urządzeń. Tymczasem wersje rozwojowe Ale nie powolny — przyp. tłum. 5 30 Linux Kernel. Przewodnik programisty podlegają niekiedy gwałtownym zmianom — są one wynikiem eksperymentów i no- wych pomysłów programistów pracujących nad rozwojem jądra i bywają niekiedy bardzo drastyczne. Do rozróżniania wersji jądra systemu Linux przyjęto prosty schemat nazewniczy (patrz rysunek 1.2). Mianowicie nazwa (numer) wersji jądra składa się z trzech liczb rozdzie- lanych kropkami. Pierwsza z tych liczb to główny numer wersji (ang. major release), liczba druga to numer podwersji (ang. minor release), a liczba trzecia to numer rewizji (ang. revision number). Rozróżnienie pomiędzy wersją stabilną a rozwojową możliwe jest na podstawie wartości numeru podwersji: liczby parzyste przypisywane są wersjom stabilnym, numery nieparzyste — wersjom rozwojowym. Na przykład, jądrem stabil- nym może być jądro o numerze 2.6.0. Jądro to ma numer wersji dwa, numer podwersji równy sześć, a numer rewizji równy 0. Pierwsze dwie liczby w numerze wersji jądra opisują równocześnie rodzinę jąder — w tym przypadku schodzi o jądro z rodziny 2.6. Rysunek 1.2. Numeracja wydań jądra systemu Linux Jądra rozwojowe przechodzą szereg faz rozwoju. Początkowo, w wyniku ścierania się różnych pomysłów i koncepcji powstaje swego rodzaju chaos. Z czasem jądro dojrzewa i ostatecznie jest zamrażane — od momentu zamrożenia do jądra nie są dodawane żad- ne nowe funkcje. Od tej chwili prace mają na celu dopracowanie wprowadzonych funk- cji. Kiedy jądro zostanie uznane za wystarczająco stabilne, ogłaszane
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Linux Kernel. Przewodnik programisty
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: