Излишно е да казвам, че ядрото на една
операционна система е най-важната и част.
Това обаче не означава, че то трябва да е
забулено в мистерия - поне в света на
отворения код това съвсем не е така. Ядрото (често
наричано кърнъл от английската дума kernel) е просто софтуер като всеки друг, който
предоставя основния интерфейс между
хардуера на машината и приложенията, които
стартирате върху нея.
Възможно е никога да не ви се наложи да
компилирате Linux ядро, но
обикновено на някакъв етап от работата ви с Linux
(а и други UNIX-и) това
се случва. Понякога това се прави веднага
след самата инсталация. Ядрата, които идват
с дистрибутивите са вече доста големи и
натруфени заради идеята да са способни да
поддържат възможно най-много различен
хардуер, а вие едва ли се нуждаете от всичко
това. Много по-добре е да прекомпилирате
ядрото с поддръжка само на вашия хардуер и
да изхвърлите излишното от него , особено ако не променяте често
компонентите на компютъра си. Така ще имате
малко ядро, което ще се зарежда по-бързо и ще
заема по-малко памет.
Компилирането на ново ядро съвсем не
изисква да познавате изходния му код и може
да бъде едно от най-лесните рутинни неща,
които правите след инсталация, ако
съобразите няколко важни неща, които ще
дискутираме в тази статия, в която
предполагаме, че дистрибуцията е Red
Hat Linux - при другите дистрибуции нещата
са подобни или направо същите, но все пак е
нужно да направя това уточнение и в случай,
че ползвате друг Linux е
възможно да ви се наложи да съобразите сами
някои дребни различия.
Няколко общи думи за ядрото
Ново ядро можете да получите от FTP сървърите на
kernel.org, sunsite.unc.edu,
техните mirror-и,
както и от много други места, разбира се
също и от FTP сървърите на
вашата предпочитана дистрибуция.
Обикновено ядрото е архив във формат tar.gz и името на файла съдържа и номера на
версията му linux-x.y.p, където
x е версията, y е номера на конкретната реализация, а p
е номер на patch. Patch се
наричат малки промени в ядрото, които се
правят непрекъснато с цел включване на нови
функции или подобряване на предишния код.
Когато номера на реализацията ( y) е четно число ядрото се нарича стабилно,
а когато е нечетно това е ядро, което е в
стадий на разработка - нещо като бета-версия,
когато едно такова ядро премине достатъчно
тестове, то излиза като стабилно с четен
номер. Например ядрата 2.0.36 и 2.2.13 са стабилни,
а ядро версия 2.3.74 е развойно. Всяка
дистрибуция по правило инсталира стабилно
ядро.
Конфигуриране и компилиране
Всички действия по конфигурирането,
компилирането и донастройката на новото
ядро трябва да извършите като root. Няма да ви е излишно да имате boot-дискета
в случай, че нещо се обърка. Командата mkbootdisk
в някои дистрибуции ще ви е от полза за
целта иначе ще трябва да прочетете някъде
как да си направите такава дискета.
Вероятността да попаднете на непредвиден
проблем не е голяма, но все пак се случва,
особено ако компилирате много ново и
недостатъчно тествано ядро или преминавате
от версия 2.0 към 2.2.
И едно уточнение - от тук нататък
предполагаме, че имаме Linux с
ядро 2.2.9 и искаме да компилираме ново с
версия 2.2.14.
Трябва да копирате архива с новото ядро в
директория /usr/src. Погледнете
какво се съдържа там - би трябвало да видите
архива, който току-що сте копирали, една
директория с вашето старо ядро linux-2.2.9 и вероятно една символична връзка linux,
която сочи към старото ви ядро. В някои
дистрибуции нямате директория и връзка към
нея, а само директория, която се нарича linux. Ако е така трябва да преименувате
директорията linux например
така:
mv linux linux-2.2.9
Ако пък имате символична връзка трябва
просто да я изтриете без да преименувате
нищо:
rm linux
Сега да разархивираме новото ядро:
tar xvfz linux-2.2.14.tar.gz
В този момент вече можете да изтриете
архива linux-2.2.14.tar.gz ако
имате недостиг на място. Сега в / usr/src ще видите новосъздадена директория linux,
която съдържа изходния код на новото
ядро. Нека да я преименуваме като linux-2.2.14 и да създадем символична връзка linux,
сочеща към нея. След
това трябва да влезем в новата директория
за да започнем конфигурирането.
mv linux linux-2.2.14
ln -s linux-2.2.14 linux
cd /usr/src/linux
За многообразието от опции и възможности
при компилирането на ядрото може да се
напише книга (и такива има), но общия съвет,
който мога да ви дам е, че когато не
разбирате нещо е по-добре да го оставите в
неговото състояние по подразбиране. Имате
на разположение няколко инструмента за
конфигуриране. Всъщност това са няколко make команди - по подробно за тях можете да
прочетете в README файла
към ядрото. Например ще ви оставя сами да
разберете за какво служи командата make
mrproper като точно тук е момента да я
изпълните ако решите. Иначе първият
класически инструмент за конфигуриране се
стартира с
make config
Това е текстово базиран метод, който ще ви
попита за абсолютно всичко въпрос след
въпрос, което е страшно отегчително и ще ви
отнеме ужасно много време.
make menuconfig
Това отново е текстов интерфейс, но е
базиран на менюта и е много по- функционален
и удобен за работа от предишния. Аз лично го
предпочитам. Можете да го стартирате и под X.
Третият се стартира с командата make
xconfig и както може би се досещате
предлага графичен интерфейс с бутони.
Има още една много удобна възможност ако
конфигурацията на старото ви ядро ви е
удовлетворявала и не желаете да включвате
нови функционалности в новото ядро или да
махате стари. Можете да компилирате новото
ядро с конфигурацията на старото. Трябва
само да отидете в директорията, където е
изходния код на старото ядро и да копирате
скрития файл . config в / usr/src/linux, след което да напишете командата
make oldconfig
Две думи как се работи с конфигураторите -
за всеки елемент имате до три възможности -
да го включите в ядрото, да го компилирате
като външен модул, който ще се зарежда при boot-ване
на ядрото или да не го компилирате въобще. В Linux
обществото има спорове за това кое е по-добре
- да имаме малко ядро с модули около него или
да компилираме по-голямо ядро, включвайки
модулите, които са необходими вътре в него.
Истината винаги е някъде по средата. Трябва
да прецените кое е необходимо да включите в
ядрото и кое да оставите като run-time модул. Защото ако примерно имате по
някаква причина две или три звукови карти,
защо трябва да имате драйверите и за трите
едновременно компилирани в ядрото -
оставете ги на модули и зареждайте само
този, който ви е необходим. Именно в това е
силата на Linux - неговата
гъвкавост.
След като сте конфигурирали ядрото трябва
да изпълните последователно командите:
make dep
make clean
make bzImage
Вместо последната команда можете да
направите make zImage, но тя
ще направи gzip-компресия
на ядрото, за разлика от първата, която
компресира с bzip2 и дава
като резултат много по-малко ядро.
На този етап не ви остава нищо друго освен
да изчакате компилирането да приключи -
това отнема различно време в зависимост от
това, какави са изчислителните способности
на компютъра ви. Добра идея е да следите за
грешки по време на компилирането въпреки,
че ако проблемът е серозен процесът просто
ще спре. Ако компилирането на ядрото е
преминало успешно трябва да направим
същото и с модулите. Готовите модули след
инсталация се разполагат в директория /lib/modules/<версия>
в случая / usr/lib/2.2.14, ако
обаче това не е първата компилация на това
ядро е добра идея да преместим
компилираните преди това модули на същото
ядро, защото в противен случай ще ги
препокрием. Например така:
mv /lib/modules/2.2.14 /lib/modules/2.2.14.backup
Сега отново в директория / usr/src/linux трябва да подадем командите:
make modules
make modules_install
Ако не сте получили някакви грешки можете
да се поздравите - имате ново ядро.
Настройка на новото ядро
Току-що компилираното ядро се казва bzImage
(или zImage) и ще го
намерите в директория /usr/src/linux/arch/i386/boot
(ако разбира се компютърът ви не е Intel
PC съвместим вместо i386 там
трябва да очаквате да има директория с
името на вашата архитектура примерно alpha).
Най-напред да си запазим старото ядро -
за него сме сигурни, че работи, докато
новото още не сме го изпробвали - обикновено
то се намира в директория / boot, където след малко ще преместим и новото.
Да преименуваме старото ядро, както и
стария System.map файл (за
какво служи последния не е тема на
настоящата статия) и да копираме новите. Ако
органзацията на / boot директорията
ви е със символични връзки т.е. System.map не е самия файл, а връзка, сочеща към
истинския файл, който се казва по друг начин,
както е в Red Hat Linux това би
станало със следните команди:
cd /boot
rm /boot/System.map
rm /boot/vmlinuz
cp /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-2.2.14
ln -s /boot/vmlinuz-2.2.14 /boot/vmlinuz
cp /usr/src/linux/System.map /boot/System.map-2.2.14
ln -s /boot/System.map-2.2.14 /boot/System.map
Ако във вашата дистрибуция нямате
символични връзки трябва да направите нещо
такова:
cd /boot
mv bzImage vmlinuz-2.2.9
mv System.map System.map-2.2.9
cp /usr/src/linux/arch/i386/boot/bzImage /boot
cp /usr/src/linux/System.map /boot
Ако вашата дистрибуция (напр. Red
Hat) ползва initrd image той
се получава с командата:
/sbin/mkinitrd /boot/initrd-2.2.14.img 2.2.14
Остава да конфигурираме boot-мениджъра
LILO. За целта отворете
файла /etc/lilo.conf с
предпочитания от вас текстов редактор. Ще
намерите фрагмент от файла, който е подобен
на този:
image = /boot/vmlinuz-2.2.9-12
label = linux
initrd = /boot/initrd-2.2.9.img
read-only
root = /dev/hda1
Това е частта, която boot-ва
вашето старо ядро - добре е да си го оставите
за да можете да се върнете към него при
необходимост. Ако сте преименували ядрото
или initrd имидж-файла
трябва да отразите промените съответно в
реда image и initrd.
Трябва да добавите аналогичен фрагмент за
новото ядро, който би изглеждал примерно
така:
image = /boot/vmlinuz-2.2.14
label = new
initrd = /boot/initrd-2.2.14.img
read-only
root = /dev/hda1
Това е всичко - запишете файла / etc/lilo.conf и от командния ред изпълнете:
/sbin/lilo
“Закърпване ” на
ядрото ( patching)
Вместо да download-вате
изцяло ново ядро можете да upgrade-вате
старото си с така наречените patches. Обикновено patch
файла
е около 20-30 K и ще ви
спести тегленето на мегабайти изходен код
на новото ядро. Проблемът е, че patch-овете
трябва да прилагате последователно т.е. за
да преминем от ядро 2.2.9 до 2.2.14 са ни
необходими patch-ове 2.2.10,
2.2.11, 2.2.12, 2.2.13 и 2.2.14, които трябва един по
един и последователно да прилагаме към
старите си сорсове. Имената на тези файлове
изглеждат така patch-2.2.12, което
означава, че това е upgrade за
ядро 2.2.11 до 2.2.12.
За разлика от изходните кодове на самото
ядро за patch-овете е без
значение къде ще ги разположите важна е
само директорията , от
която подавате командите и тя трябва да е /usr/src
Всеки patch се прилага с
командата:
gunzip -c patchfile | patch -p0
където patchfile
е пълното име на patch-файла
включително и пътя до него напр. / home/bobo/patch-2.2.11.
Можете да проверите дали patch-а
е приложен правилно с командите:
find /usr/src/linux -follow -name “*.rej” -print
find /usr/src/linux -follow -name “*#” -print
Ако някоя от тези две команди върне като
резултат някакви файлове по някаква
причина някаква част от patch-а
не е била приета както трябва. Ако не сте
достатъчно наясно какъв е проблема
единствения съвет, който мога да ви дам е да
си download-нете ново ядро и
да започнете отначало.
И накрая едно, може би, излишно уточнение,
но все пак да не въведа някого в заблуда -
тези patch-ове към ядрото
са всъщност “кръпки ” към неговите изходни кодове т.е. към
сорса на ядрото, а не към компилираното ядро
т.е. след като приложим patch-овете
не отпада следващия етап с компилирането на
новото ядро.
8 юли 2000
Йовко Ламбрев
