Rozdział 57.
Jądro systemu

Kamran Husain i Tim Parker
W tym rozdziale:
* Uaktualnianie i instalowanie nowych składników jądra systemu
* Kompilowanie kodu źródłowego jądra systemu
* Dodawanie sterowników urządzeń
* Uaktualnianie bibliotek
* Kompilator języka C dla systemu Linux
Poza przypadkami takimi jak instalowanie nowej wersji systemu, instalowanie
nowych składników sieci (takich jak NFS czy NIS) czy nowych sterowników
urządzeń wymagających specjalnego traktowania nie ma konieczności modyfikowania
jądra systemu. Szczegółowe informacje na temat instalowania sterowników
urządzeń zwykle są rozprowadzane wraz z oprogramowaniem. Nie jest tak jednak w
każdym przypadku, dlatego w tym rozdziale przedstawimy ogólne zasady dotyczące
pracy z jądrem systemu.


Na początek powiedzmy wyraźnie, że nie powinieneś modyfikować jądra systemu,
jeśli nie wiesz, co chcesz przez to osiągnąć. Jeśli kod źródłowy lub pliki
konfiguracyjne zostaną uszkodzone, kernel może być niestabilny, co w najgorszym
przypadku może prowadzić do uszkodzenia systemu plików. Uważnie zapoznaj się z
przedstawionymi poniżej informacjami i przestrzegaj podanych wskazówek.
Modyfikowanie jądra systemu wymaga sporej wiedzy, a w tym rozdziale możemy
przedstawić tylko podstawowe informacje.
Obecnie używa się powszechnie kilku różnych wersji Linuxa, nie do końca
zgodnych pomiędzy sobą. Z tej przyczyny przedstawione poniżej instrukcje mogą
nie działać prawidłowo w Twojej wersji Linuxa. Mimo tego idea pozostaje ta
sama, różnice mogą wystąpić tylko w przypadku nazw programów użytkowych i
ścieżek dostępu do nich. Do większości wersji Linuxa dołączana jest
dokumentacja omawiająca proces kompilowania jądra i zawierająca informacje o
położeniu kodu źródłowego i skompilowanych programów.

Zanim podejmiesz jakiekolwiek kroki upewnij się, że posiadasz odpowiedni zestaw
dyskietek startowych. Warto również wykonać pełną kopię zapasową systemu
plików. Choć proces modyfikowania jądra nie jest trudny, jeśli coś pójdzie nie
tak, może okazać się, że nie da się ponownie uruchomić systemu. W takiej
sytuacji najprostszym rozwiązaniem jest użycie dyskietek startowych, warto więc
posiadać przynajmniej jeden zapasowy ich zestaw.
Ponieważ jądro systemu jest kompilowane za pomocą kompilatora języka C
wchodzącego w skład każdej dystrybucji Linuxa, to właśnie na nim skoncentrujemy
się w dalszej części tego rozdziału, omawiając jego znaczniki i sposoby
stosowania. Nie będzie to oczywiście kompletny opis kompilatora języka C, ale
powinien być wystarczający przy podstawowych czynnościach związanych z
modyfikowaniem jądra systemu (i kompilowaniem dowolnych programów napisanych w
języku C).
Uaktualnianie i instalowanie nowych składników jądra systemu
Linux jest systemem rozwijającym się bardzo dynamicznie. Nowe wersje jądra
systemu bądź też innych komponentów dołączanych do jądra są co jakiś czas
udostępniane dla użytkowników. Decyzję o tym, czy należy uaktualnić wersję
jądra systemu, musisz podjąć sam
zwykle opiera się ona na danych dotyczących
błędów usuniętych w nowej wersji czy też oferowanych przez nią nowych
możliwościach. Po dołączeniu nowego oprogramowania prawdopodobnie będzie trzeba
odnowić wszystkie dowiązania do jądra systemu, chyba że nowe komponenty są
sterownikami urządzeń czy niezależnymi programami użytkowymi.
Mimo wszystko, należy jednak zdecydowanie unikać uaktualniania systemu wraz z
każdą nową wersją, i to z kilku powodów. Może na przykład zdarzyć się, że
zainstalowane oprogramowanie nie jest zgodne z nową wersją programów użytkowych
czy jądra systemu. Może również okazać się, że nowa wersja posiada poważny
błąd. Tego typu sytuacje mogą powodować nie kończące się problemy. Większość
nowych wersji programów nie zachowuje istniejących informacji konfiguracyjnych,
więc konieczna jest także ponowna konfiguracja wszystkich pakietów, które
zostały zainstalowane na nowo.
Poza tym, nowe wersje programów pojawiają się na tyle często, iż nie jest
wykluczone, że więcej czasu spędziłbyś na ich ładowaniu i instalowaniu niż na
faktycznym korzystaniu z systemu. Taka sytuacja może być bardzo męcząca. Liczba
zmian wprowadzanych w kolejnych wersjach systemu różniących się tylko numerem
pobocznym jest zwykle niewielka, dlatego należy przejrzeć dołączone do niej
informacje i upewnić się, że faktycznie warto poświęcić czas na jej
instalację.
Z praktycznego punktu widzenia dobrze jest aktualizować system raz lub dwa razy
do roku, tylko wtedy, gdy nowa wersja zawiera rozwiązania, które znacznie
zmienią sposób, w jaki używasz system. Posiadanie zawsze najnowszej wersji
systemu jest kuszące, ale trzeba również brać pod uwagę korzyści wynikające z
utrzymywania stabilnego i funkcjonalnego systemu operacyjnego.
Jeśli uaktualniasz wersję oprogramowania, powinieneś zdawać sobie sprawę z
faktu, że nie musisz uaktualniać wszystkiego. W kilku ostatnich wersjach Linuxa
zmieniało się co najwyżej 5% systemu operacyjnego. Zamiast wymiany całego
oprogramowania warto więc rozważyć zainstalowanie tylko tych fragmentów, które
faktycznie uległy znaczącym zmianom, czyli zwykle jądra systemu, kompilatora,
bibliotek i często wykorzystywanych programów użytkowych. Takie rozwiązanie
pozwoli uniknąć konieczności ponownego konfigurowania pozostałych części
systemu.
Kompilowanie kodu źródłowego jądra systemu
Uaktualnienie, wymiana czy dodanie nowego kodu do jądra systemu jest zwykle
procesem dość prostym. Sprowadza się do zdobycia odpowiedniego kodu źródłowego,
dostosowania informacji konfiguracyjnych, skompilowania a następnie
umieszczenia skompilowanych programów w odpowiednim miejscu tak, by system mógł
działać prawidłowo. Proces ten zwykle jest zautomatyzowany za pomocą skryptu
powłoki lub programu instalacyjnego
w niektórych przypadkach wszystko
sprowadza się do wydania jednego polecenia.
Kod źródłowy nowych wersji jądra systemu dostępny jest zwykle z dystrybucjami
rozprowadzanymi na płytach CD-ROM, w węzłach FTP, grupach dyskusyjnych i w
wielu innych miejscach. Większość wersji jądra posiada numer składający się z
głównego i pobocznego numeru wersji (dwie pierwsze liczby) oraz numeru poprawki
(trzecia liczba), na przykład 1.12.123. W większości węzłów FTP czy BBS
równocześnie udostępnianych jest kilka wersji jądra
musisz wziąć to pod
uwagę, jeśli chcesz załadować jego najnowszą wersję.
Poprawki do kodu źródłowego jądra systemu zwykle nie zawierają całego kodu. Ich
instalacja powoduje nadpisanie fragmentów istniejącego kodu źródłowego. Po jego
ponownym skompilowaniu poprawka jest już zainstalowana. Tego typu poprawki
udostępniane są dość często.


Podczas instalowania poprawki należy ograniczyć do minimum liczbę otwartych
plików i działających procesów oraz aplikacji. Pozwoli to uniknąć problemów
związanych z pozostawieniem otwartych plików, co może prowadzić nawet do
uszkodzenia tablicy I-node. Ponieważ aby zainstalować poprawkę i tak musisz być
zalogowany jako root, możesz zakończyć wszystkie niepotrzebne procesy i
aplikacje.
W większości przypadków kod źródłowy jest rozprowadzany w postaci
skompresowanego (zwykle programem gzip) archiwum programu tar. Taki plik należy
rozpakować do katalogu /usr/src, w którym zwykle przechowywany jest kod
źródłowy programów. W niektórych wersjach Linuxa do tego celu przeznaczony jest
inny katalog
powinieneś więc przejrzeć dokumentację rozprowadzaną z posiadaną
przez Ciebie wersją Linuxa lub poszukać w katalogu /usr/src pliku README, w
którym powinny znajdować się dokładniejsze informacje.
Często zdarza się, że rozpakowanie pliku do katalogu /usr/src powoduje
utworzenie podkatalogu /usr/src/linux, co może prowadzić do nadpisania obecnej
w systemie wersji kodu źródłowego jądra. Przed rozpoczęciem rozpakowywania
warto więc zmienić nazwę istniejącego katalogu lub skopiować jego zawartość w
bezpieczne miejsce, dzięki czemu w przypadku problemów łatwo będzie wrócić do
wersji poprzedniej.
Po rozpakowaniu kodu źródłowego należy utworzyć dwa dowiązania symboliczne (o
ile nie zostały one utworzone przez program instalacyjny) do katalogu
/usr/include. Można to zrobić wydając polecenia:

ln -sf /usr/src/linux/include/linux /usr/include/linux
ln -sf /usr/src/linux/include/asm /usr/include/asm
Jeśli w Twoim systemie używane są inne ścieżki dostępu, podstaw zamiast
/usr/src/linux odpowiednią wartość. Jeśli takie dowiązania nie istnieją,
poprawne uaktualnienie jądra systemu nie będzie możliwe.
Po rozpakowaniu kodu źródłowego i utworzeniu odpowiednich dowiązań można
rozpocząć proces kompilacji. W tym celu niezbędny będzie kompilator gcc lub g++
(kompilator GNU języka C i C++) lub inny zgodny z nimi kompilator. Należy
sprawdzić w dokumentacji dołączonej do nowej wersji kodu źródłowego czy używana
wersja kompilatora jest odpowiednia, ponieważ zdarza się, że nowe wersje jądra
nie dają się skompilować za pomocą starszych wersji kompilatorów.
Następnie należy przejrzeć plik /usr/src/linux/Makefile (w niektórych
dystrybucjach może on znajdować się w innym katalogu). Znajdź w nim wiersz
definiujący zmienną ROOT_DEV, określającą urządzenie, na którym zapisany jest
główny system plików. Zwykle definicja ta ma postać

ROOT_DEV = CURRENT
Jeśli wartość zmiennej ROOT_DEV jest inna, upewnij się, że jest ona odpowiednia
dla Twojego systemu. Jeżeli w pliku Makefile nie ma takiej definicji, należy ją
dodać.
Proces kompilacji rozpoczyna się po przejściu do katalogu /usr/src/linux i
wydaniu polecenia

make config
uruchamiającego program make, generujący odpowiednie polecenia kompilujące
pliki źródłowe. W niektórych wersjach Linuxa proces ten może wyglądać nieco
inaczej
odpowiednich informacji należy szukać w dokumentacji dołączonej do
plików źródłowych.
W następnym kroku program config zadaje serię pytań dotyczących różnych
aspektów konfiguracji jądra, na które należy odpowiedzieć przed rozpoczęciem
właściwej kompilacji. Pytania te dotyczą między innymi typu dysku twardego,
procesora, typów używanych partycji czy innych urządzeń dołączonych do
komputera, na przykład napędów CD-ROM. Powinieneś odpowiedzieć na nie
najlepiej, jak potrafisz. Jeśli masz wątpliwości co do którejś z odpowiedzi,
wybierz odpowiedź domyślną albo tę, która wydaje się być najodpowiedniejsza. W
najgorszym przypadku
jeśli system nie będzie działał prawidłowo
będzie
trzeba powtórzyć cały proces od początku (oczywiście pod warunkiem, że
przygotowałeś dyskietki startowe).
Następnie należy ustalić wszystkie zależności pomiędzy plikami kodu źródłowego.
Ten etap często jest pomijany, ale takie postępowanie może powodować mnóstwo
problemów. Aby ustalić zależności dla zainstalowanej wersji kodu źródłowego
jądra systemu, wydaj polecenie:

make dep
Jeśli w skład instalowanego oprogramowania nie wchodzi plik zależności (o
nazwie dep), powinieneś upewnić się, że odpowiednie czynności podejmowane są w
czasie wykonywania innych etapów konfiguracji oprogramowania (informacje takie
znajdują się w dokumentacji dołączonej do plików źródłowych).
Na koniec pora rozpocząć kompilację nowego jądra
w tym celu należy wydać
polecenie

make Image
które spowoduje skompilowanie jądra i pozostawienie go w katalogu bieżącym
(zwykle /usr/src/linux). Jeśli chcesz utworzyć skompresowaną wersję jądra
systemu, wydaj polecenie

make zImage
Nie wszystkie dystrybucje Linuxa pozwalają na kompresowanie jądra systemu w
trakcie jego kompilacji.
Ostatnim krokiem jest skopiowanie nowej wersji jądra systemu na dysk, z którego
uruchamiany jest system, lub też na dyskietkę startową. Polecenie

cp Image /dev/fd0
spowoduje umieszczenie kopii jądra systemu na dyskietce. Jeśli chcesz umieścić
ją gdzieś indziej, podstaw odpowiednią nazwę urządzenia. Jeżeli natomiast do
uruchamiania systemu używany jest program LILO, wówczas aby zainstalować nowe
jądro, należy uruchomić program instalacyjny lub program /usr/lilo/lilo

dokładniejsze informacje na ten temat przedstawiliśmy w rozdziale 4. "Program
LILO".
Teraz pozostaje tylko uruchomić ponownie system i sprawdzić, czy nowe jądro
prawidłowo ładuje się do pamięci. Jeśli wystąpią jakieś problemy, należy
uruchomić system z dyskietki startowej i powtórzyć cały proces. W dołączonej do
kodu źródłowego dokumentacji znajdziesz wskazówki dotyczące rozwiązywania
niektórych problemów oraz informacje o ewentualnych zmianach w procesie
kompilacji jądra.
Dodawanie sterowników urządzeń
Nowe sterowniki urządzeń można również dołączać do istniejącej wersji jądra bez
konieczności jego konfiguracji i kompilowania. Z taką sytuacją można często
zetknąć się w przypadkach, gdy do systemu dodane zostanie takie urządzenie, jak
karta multiport czy dysk optyczny, do których obsługi niezbędne jest
załadowanie odpowiednich sterowników podczas uruchamiania systemu. Może również
zdarzyć się, że będziesz chciał zainstalować jakiś rodzaj oprogramowania
podnoszącego poziom bezpieczeństwa systemu i wymagającego modyfikacji samego
jądra systemu.
Sterowniki wymagające kompilacji jądra przeważnie rozprowadzane są wraz z
odpowiednią dokumentacją. Zwykle otrzymany kod źródłowy należy umieścić w tym
samym katalogu, w którym znajduje się kod źródłowy jądra systemu (na przykład
/usr/src). Aby dodać do jądra systemu nowy fragment kodu, trzeba zmodyfikować
plik Makefile
ręcznie bądź też za pomocą odpowiedniego skryptu
instalacyjnego. W niektórych przypadkach do kodu źródłowego sterowników
dodawany jest osobny plik Makefile.
Następnym krokiem jest skompilowanie jądra wraz z nowymi sterownikami. Proces
ten nie różni się od opisanego w poprzednim podrozdziale
skompilowane jądro
należy skopiować na dyskietkę startową lub zainstalować za pomocą programu
LILO. Zwykle cały proces nie zabiera więcej niż dziesięć minut i raczej nie
sprawia kłopotów, chyba że dostawca oprogramowania kiepsko wywiązał się ze
swych obowiązków. Przed instalacją upewnij się, że nowe sterowniki będą działać
z Twoją wersją jądra systemu
odpowiednie informacje znajdziesz w plikach
tekstowych dołączonych do kodu źródłowego oraz w plikach dotyczących zgodności
z różnego typu oprogramowaniem, rozprowadzanych z większością wersji Linuxa.
Uaktualnianie bibliotek
Większość programów przeznaczonych dla systemów linuxowych korzysta z bibliotek
współużytkowanych (ang. shared libraries; jest to zestaw podprogramów, które
mogą być wykorzystywane przez różne aplikacje). Jeśli po uaktualnieniu jądra
systemu przy uruchomianiu programów wyświetlany jest komunikat

Incompatible library version
oznacza to, że biblioteki również wymagają uaktualnienia. Większość bibliotek
jest kompatybilna wstecz, co oznacza, że programy wykorzystujące starsze wersje
bibliotek będą działać poprawnie również po zainstalowaniu nowych wersji
bibliotek.
Nowe wersje bibliotek pojawiają się rzadziej niż nowe wersje jądra systemu i są
rozprowadzane w ten sam sposób. Zwykle do nowych wersji jądra dołączane są
pliki tekstowe zawierające informacje o wymaganych bibliotekach i wskazujące
miejsca, w których można zaopatrzyć się w ich najnowsze wersje.
Nowe wersje bibliotek rozprowadzane są najczęściej w postaci skompresowanego
archiwum programu tar, więc proces ich rozpakowywania jest taki sam, jak plików
zawierających kod źródłowy jądra systemu, z tym że katalogami docelowymi są
zwykle katalogi /lib, /usr/lib i /usr/include. Pliki z rozszerzeniami .a i .aa
trafiają przeważnie do katalogu /usr/lib, natomiast pliki obrazów bibliotek
współużytkowanych, których nazwy mają postać libc.so.wersja, do katalogu /lib.
Po zainstalowaniu nowych wersji bibliotek czasem zachodzi konieczność ręcznej
modyfikacji dowiązań symbolicznych, tak by prowadziły do najnowszych wersji
bibliotek. Przykładowo, jeśli używasz biblioteki libc.so w wersji 4.4.1 i
uaktualniłeś jej wersję do 4.4.2, powinieneś zmodyfikować odpowiednie
dowiązanie, wydając polecenie:

ln
sf /lib/libc.so.4.4.1 /lib/libc.so.4
Ostatni argument jest nazwą uaktualnianej biblioteki
nazwy te mogą być różne
w zależności od dystrybucji
należy to sprawdzić w dokumentacji.
W taki sam sposób należy zmodyfikować również dowiązanie dla biblioteki
libm.so. Dowiązań symbolicznych nie należy usuwać, ponieważ programy
korzystające z bibliotek współużytkowanych (m.in. program ls) nie będą działać
poprawnie.
Kompilator języka C dla systemu Linux
W systemie Linux kompilator języka C jest wykorzystywany do kompilowania
wszystkich wersji jądra systemu i znacznej większości programów użytkowych. Dla
wszystkich wersji Linuxa dostępny jest kompilator GNU C, o nazwie gcc. Powstał
on w ramach projektu Free Software Foundation, w związku z czym jest darmowy.
Kompilator GNU C rozprowadzany wraz z dystrybucją Slackware jest w pełni
funkcjonalnym kompilatorem spełniającym standardy ANSI C. Jeśli znasz już jakiś
kompilator języka C z innej platformy, będziesz w stanie opanować gcc w bardzo
krótkim czasie.
Przy wywoływaniu kompilatora GCC należy podać szereg argumentów, na które
składają się różne opcje i przynajmniej jedna nazwa pliku. Najogólniej rzecz
ujmując, składnia polecenia uruchamiającego kompilator gcc jest następująca:

gcc [opcje] [nazwy_plików]
Działania określone przez opcje podane w wierszu poleceń zostaną wykonane w
odniesieniu do każdego z wyszczególnionych plików. Opcji rozpoznawanych przez
kompilator gcc jest ponad setka. Większości z nich prawdopodobnie nigdy nie
będziesz musiał użyć, ale kilka jest niezbędnych nawet przy najprostszych
czynnościach.
Wiele nazw opcji programu gcc składa się z więcej niż jednego znaku. Z tego
powodu każda z opcji musi zostać poprzedzona oddzielnym myślnikiem. Nie można
grupować opcji po wspólnym myślniku, jak ma to miejsce w przypadku większości
poleceń systemu Linux. Podane poniżej dwa przykładowe polecenia mają różne
znaczenie:

gcc
p
g test.c
gcc
pg test.c
Pierwsze z nich nakazuje programowi gcc skompilować plik test.c, dołączając do
pliku wykonywalnego kod pozwalający na wykonanie profilu dynamicznego programu
(-p) oraz informacje pozwalające na współpracę z debugerem (-g), natomiast
drugie polecenie (z opcją
pg) powoduje skompilowanie pliku test.c i dołączenie
do niego informacji pozwalających na profilowanie za pomocą polecenia gprof.
Kiedy kompilujesz program nie używając żadnych opcji, w bieżącym katalogu
tworzony jest plik wykonywalny (o ile kompilacja zakończy się bez błędów) o
nazwie a.out. Jeśli chcesz, by nazwa tworzonego pliku wykonywalnego była inna,
powinieneś użyć opcji
o. Przykładowo, aby skompilować program zapisany w pliku
licznik.c do pliku wykonywalnego o nazwie licznik należy wydać polecenie:

gcc
olicznik licznik.c


Nazwa pliku wyjściowego musi pojawić się bezpośrednio po opcji
o. Nie należy
wstawiać pomiędzy nie innych opcji.
Inne opcje kompilatora decydują o tym, na jakim etapie należy zakończyć proces
kompilacji. Opcja
c powoduje zakończenie procesu po utworzeniu pliku
pośredniego (domyślnie z rozszerzeniem .o), z pominięciem asemblacji i
konsolidacji. Jest ona używana dość często, ponieważ umożliwia przyśpieszenie
kompilacji złożonych, wieloplikowych programów.
Opcja
S powoduje zakończenie kompilacji po wygenerowaniu plików asemblera
(domyślnie z rozszerzeniem .s). Opcja
E powoduje, że kompilator tylko wstępnie
przetworzy pliki wejściowe, wykonując zawarte w nich dyrektywy preprocesora. W
takim przypadku dane wyjściowe wysyłane są na ekran, a nie do pliku.
Kompilator GCC stara się utworzyć kod wynikowy w możliwie najkrótszym czasie w
taki sposób, by łatwo było znaleźć w nim ewentualne błędy. Oznacza to, że
kolejność operacji pozostaje taka sama jak w pliku źródłowym i nie jest
dokonywana żadna optymalizacja. Istnieje wiele opcji, dzięki którym możesz
nakazać tworzenie mniejszych czy szybszych wersji programów, kosztem czasu ich
kompilacji oraz łatwości wyszukiwania błędów. Najczęściej używa się opcji
O
oraz
O2.
Opcja
O powoduje zastosowanie podstawowych technik optymalizacyjnych. Owocuje
to zwykle powstaniem szybciej działających wersji programów. Opcja
O2
powoduje, że wygenerowany zostanie możliwie krótki oraz szybki kod. Czas
kompilacji w tym przypadku jest dłuższy, ale za to program wynikowy działa
szybciej.
Poza tymi opcjami istnieje jeszcze wiele opcji niskiego poziomu, których można
użyć do dalszego przyspieszania działania programu. Są one jednak bardzo
specyficzne i powinieneś używać ich tylko wtedy, gdy dokładnie zdajesz sobie
sprawę z tego, co powodują, i jakie mogą być ich konsekwencje. Bardziej
szczegółowe informacje o tych opcjach znajdziesz na stronach man.
Opcje współpracy z debugerem
i programem profilującym
Spośród kilku opcji dotyczących wstawiania dodatkowego kodu służącego do
określania szybkości wykonywania programu i ułatwiającego uruchamianie i
testowanie, najczęściej używane są dwie: -g oraz
pg.
Opcja
g powoduje dołączenie do pliku wykonywalnego informacji dla debugera
gdb, który często okazuje się niezbędny w procesie wyszukiwania błędów. GCC
oferuje coś, czego nie daje większość innych kompilatorów: możliwość łącznego
użycia opcji
g oraz
O (która powoduje wygenerowanie zoptymalizowanej wersji
programu). Jest to bardzo przydatne, szczególnie jeśli chcesz testować produkt
jak najbardziej zbliżony do wersji końcowej. Powinieneś jednak zdawać sobie
sprawę, że część kodu zostanie przez kompilator nieco zmodyfikowana.
Opcja
pg pozwala na dołączenie do programu wykonywalnego dodatkowego kodu,
który, po uruchomieniu programu, wygeneruje informacje o czasie wykonania
poszczególnych sekcji programu. Dane te mogą być przeglądane za pomocą programu
gprof. Więcej informacji na jego temat znajdziesz w podrozdziale "gprof".
Wyszukiwanie błędów
debuger gdb
Wraz z Linuxem rozprowadzany jest program gdb, który jest bardzo potężnym
debugerem, służącym do wyszukiwania błędów w programach napisanych w językach C
i C++. Umożliwia dostęp do struktur danych i pamięci wykorzystywanej przez
program podczas jego działania. Oto jego podstawowe zalety:
* pozwala śledzić wartości zmiennych podczas wykonywania programu,
* pozwala ustawiać pułapki, które zatrzymują program po osiągnięciu danego
wiersza kodu,
* pozwala wykonywać program krokowo, wiersz po wierszu.
Przy uruchamianiu programu gdb można również podać różne parametry w wierszu
poleceń. Zwykle program ten uruchamia się podając nazwę pliku wykonywalnego, w
którym chcemy szukać błędów:

gdb
W takim przypadku plik wykonywalny zostanie załadowany automatycznie. Można
również uruchomić gdb w taki sposób, by możliwe było oglądanie zawartości pliku
ze zrzutem pamięci (ang. core dump) wygenerowanego przez program; można też
dołączyć gdb do działającego już procesu. Aby obejrzeć listę dostępnych opcji z
ich krótkim opisem, zajrzyj na stronę man lub uruchom gdb z opcją
h.
Aby program gdb mógł działać poprawnie, do pliku wykonywalnego muszą zostać
dołączone przez kompilator informacje o typach i nazwach zmiennych, o mapowaniu
kodu na linie programu źródłowego itd., które pozwolą na powiązanie kodu
źródłowego i skompilowanego kodu programu. W tym celu w poleceniu kompilującym
plik źródłowy należy podać również opcję
g.
Podsumowanie
Kompilacja jądra systemu i uaktualnianie jego wersji przebiega zwykle
bezproblemowo, o ile zdajesz sobie sprawę z tego, co robisz. Nie powinieneś
obawiać się tego procesu, ale zawsze należy mieć pod ręką zestaw dyskietek
startowych. Jeśli tylko dostępne są odpowiednie instrukcje, należy ich ściśle
przestrzegać, ponieważ nowe oprogramowanie ma często specjalne wymagania
dotyczące dołączania do jądra systemu czy zastępowania istniejących fragmentów
kodu.
Jeśli chcesz dowiedzieć się czegoś więcej o kompilatorze języka C
rozprowadzanym z większością dystrybucji Linuxa, przejdź do rozdziału 26.
"Programowanie w języku C".
W części czwartej, w rozdziale 32. "Podstawy administrowania systemem" i kilku
następnych, zamieściliśmy informacje pozwalające na prawidłowe skonfigurowanie
jądra systemu.
O tym, w jaki sposób korzystać z systemów zarządzania kodem źródłowym,
pozwalających na zmniejszenie liczby przechowywanych plików zajmujących
niepotrzebnie miejsce na dysku twardym, możesz dowiedzieć się z rozdziału 56.
"Zarządzanie kodem źródłowym".