Каждый, кто хоть немного интересовался тем, что такое Linux, обязательно
встречал в различных руководствах термин "ядро", по-английски -
kernel.
Ядро - это важнейшая часть Linux, как и любой другой ОС, поскольку именно ядро
обеспечивает взаимодействие с аппаратной частью компьютера. Когда Вы загружаете
какое-то приложение с жесткого диска в оперативную память, или переключаетесь
между уже работающими приложениями, или тогда, когда какое-то приложение
записывает информацию в файл на диске, ОС или активное приложение должно
запросить доступ к той части аппаратуры, которая ему необходима. Ядро
обеспечивает исполнение таких запросов других частей ОС и приложений, а также
распределяет память между запускаемыми приложениями. Ядро, таким образом,
является посредником между аппаратным и программным обеспечением компьютера,
обеспечивающим их взаимодействие.
Работа по совершенствованию Linux ведется международным сообществом
разработчиков постоянно. Естественно, что пользователи хотят иметь последнюю
(или, по крайней мере, одну из последних) версий ОС. В этом разделе будет
рассказано о том, как обновлять ядро Linux.
Честно сказать, я довольно долгое время не решался браться за обновление
ядра, поскольку первая из предпринятых мною попыток оказалась неудачной, причем
до того неудачной, что мне пришлось полностью переустановить систему. Я тогда
пытался установить ядро из исходников. Но однажды (точнее 19 июня 2000 г.) я
наткнулся в новостях на сообщение о том, что выпущен rpm-пакет с ядром 2.2.16-1.
Поскольку мой опыт работы с rpm-пакетами был вполне положительным, я решился
попытаться еще раз и попытка эта оказалась вполне успешной! Этим успехом я и
делюсь с Вами в первом подразделе, где рассказывается о том, как установить
новое ядро из rpm-пакета, а в последующем (когда научусь) расскажу и о том, как
скомпилировать новое ядро из исходников.
23.1. Установка нового ядра из rpm-пакета.
Естественно, что первым делом
надо скачать rpm-пакет с новым ядром. При этом необходимо иметь в виду, что
четная вторая цифра в номере ядра обозначает стабильные версии ядра, а нечетная
- экспериментальные версии. Так что если Вы не ставите своей целью тестирование
новшеств в ядре, ищите rpm-пакет со стабильной версией (номер версии указывается
в названии пакета).
Я скачал ядро версии 2.2.16-1 с сервера http://rufus.w3.org/linux/RPM/rawhide/1.0/i386/RedHat/RPMS/kernel-2.2.16-1.i386.html
Скачав ядро, запустите команду
rpm -i kernel-2.2.16-1.i386.rpm
По этой команде программа rpm установит в каталог /boot 4 файла:
(System.map-x.y.z-a, vmlinux-x.y.z-a, vmlinuz-x.y.z-a и module-info-x.y.z-a, где
x.y.z-a - это номер версии нового ядра), создаст каталог
/lib/modules/x.y.z-a, в котором разметит модули нового ядра, а также
установит скрипт /sbin/installkernel.
Если у Вас есть такое желание,
Вы можете предварительно (или потом) выполнить команду
rpm -qpl
kernel-2.2.16-1.i386.rpm,
которая выдаст полный список устанавливаемых
из пакета файлов. Выполнение этих команд еще ничего не меняет в системе, только
подготавливает файлы для запуска нового ядра.
Я после установки пакета с ядром решился сразу запустить скрипт
/sbin/installkernel. Скрипт завис, его пришлось снимать командой
[Ctrl-C]. Тогда я стал разбираться с тем, что делает этот скрипт. Вот его полный
текст:
#------------------- начало скрипта ------------------
#! /bin/sh
#
# /sbin/installkernel - written by [email protected]
#
INSTALL_PATH=/boot
KERNEL_VERSION=$1
BOOTIMAGE=$2
MAPFILE=$3
if [ -f $INSTALL_PATH/vmlinuz-$KERNEL_VERSION ]; then
mv $INSTALL_PATH/vmlinuz-$KERNEL_VERSION \
$INSTALL_PATH/vmlinuz.old;
fi
if [ -f $INSTALL_PATH/System.map-$KERNEL_VERSION ]; then
mv $INSTALL_PATH/System.map-$KERNEL_VERSION \
$INSTALL_PATH/System.map.old;
fi
cat $BOOTIMAGE > $INSTALL_PATH/vmlinuz-$KERNEL_VERSION
cp $MAPFILE $INSTALL_PATH/System.map-$KERNEL_VERSION
ln -fs vmlinuz-$KERNEL_VERSION $INSTALL_PATH/vmlinuz
ln -fs System.map-$KERNEL_VERSION $INSTALL_PATH/System.map
if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi
#------------------- конец скрипта ------------------
Как видите, скрипту требуются некоторые параметры, а я запускал его без
аргументов. Однако, поскольку программа rpm уже разместила в /boot
файлы vmlinux-2.2.16-1, vmlinuz-2.2.16-1 и System.map-2.2.16-1, а также создала
ссылки с именами vmlinuz и System.map, я решил, что осталось только
перезапустить lilo. Но прежде чем запускать lilo, я
подредактировал файл /etc/lilo.conf, добавив туда секцию с указанием на
ядро 2.2.16 (просто скопировал секцию с меткой linux, после чего подправил
строки image и label). Причем я новую секцию поставил первой. Вот что у меня
получилось:
#------------------- начало файла /etc/lilo.conf ------------------
boot=/dev/hdb1
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
image=/boot/vmlinuz-2.2.16-1
label=linux-2.2.16
root=/dev/hdb1
read-only
image=/boot/vmlinuz-2.2.11-4bc
label=linux
root=/dev/hdb1
read-only
other=/dev/hda1
label=dos
table=/dev/hda
#------------------- конец файла /etc/lilo.conf ------------------
Обратите внимание на то, что у меня Линукс грузится со второго диска,
поскольку на первом диске стоит Windows NT и я использую в качестве загрузчика
OS Loader.
После этого я запустил команду /sbin/lilo (причем вначале с
параметрами -t -v, чтобы посмотеть, что она будет делать, а только потом уже -
без параметров, для реального исполнения). Когда команда отработала, я
перезагрузился, однако на этапе загрузки система зависла, выведя строку
LIL-. Пришлось воспользоваться загрузочной дискетой (заготовленной еще
при установке системы) и выполнить команду
dd if=/dev/hdb1
of=/mnt/hda1/bootsect.lnx bs=512 count=1
Все правильно, команда
lilo меняет загрузочный сектор, а я забыл подсунуть загрузчику его
обновленный вариант.
Еще раз перезагружаюсь и с радостью вижу сообщение о том, что загрузилось
ядро 2.2.16-1 !
Если у Вас LILO является основным загрузчиком (установлен в MBR
первого диска), то последнюю операцию (копирование загрузочного сектора в файл)
выполнять, конечно, не нужно.
23.2. Компиляция нового ядра
Как было сказано в начале данного раздела,
основная функция ядра состоит в том, чтобы обеспечить взаимодействие с
аппаратурой компьютера. Обслуживание некоторых составляющих аппаратного
обеспечения (таких, как память, например) напрямую встроено в ядро. Для тех
частей аппаратуры, которые могут быть нестандартными, имеются драйверы
устройств, которые обеспечивают взаимодействие ОС с аппаратурой. Большинство
пользователей компьютеров знакомы с понятием драйвера хотя бы потому, что после
установки нового оборудования они вынуждены устанавливать и программные драйверы
для этого оборудования. Только после этого становится возможным использовать
вновь установленную аппаратную составляющую. В терминологии, принятой в Линукс,
драйвера называются "модулями". Таким образом, поддержка аппаратных устройств
может быть обеспечена двумя способами: либо путем встраивания такой поддержки в
ядро, либо путем использования соответствующего модуля (драйвера).
В Линуксе пользователи имеют возможность самостоятельно определить, какие
функции будет выполнять непосредственно ядро, а какие - будут осуществляться с
помощью модулей. Процесс, в ходе которого осуществляется такое распределение
функций, называют "компиляцией нового ядра".
Зачем вообще нужно компилировать новое ядро? Ну, во-первых, компании, которые
выпускают дистрибутивы Linux (такие как RedHat, Caldera, Debian и т.д.)
вынуждены встраивать в ядро поддержку как можно более широкого спектра
устройств, потому что они не могут заранее знать, какие устройства (модели
устройств) будут установлены на компьютере конкретного пользователя. Поддержка в
ядре широкого спектра устройств облегчает установку и поддержку системы для
покупателей, избавляя их от ненужных сложностей.
Как результат, ядро, поставляемое в составе дистрибутива, скорее всего
содержит код для поддержки устройств, которых никогда не будет на Вашем
конкретном компьютере. С другой стороны, если у Вас есть устройство, которое не
поддерживается стандартным ядром, у Вас может появиться обоснованное желание
встроить поддержку этого устройства в ядро.
Пользователи Линукса имеют возможность или скомпилировать ядро с поддержкой
всех устройств, имеющихся на его компьютере, или скомпилировать ядро,
поддерживающее минимальный набор оборудования, и загружать модули для поддержки
остальных устройств. Если поддержка всего оборудования осуществляется в ядре, то
такое ядро называется "монолитным". Ядро, скомпилированное таким образом, что
поддержка части оборудования осуществляется с использованием модулей
(драйверов), называется "модульным".
Какой тип ядра Вам выбрать при компиляции? Однозначного ответа на это вопрос
дать нельзя. Если Вы не имеете привычки менять аппаратную конфигурацию
компьютера, тогда Вам лучше встроить поддержку всех имеющихся компонент в ядро.
Необходимо только иметь в виду, что чем больше устройств поддерживаются
непосредственно ядром, тем больше его объем. А поскольку ядро полностью
загружается в оперативную память, повышаются требования к объему памяти. На
медленных машинах из-за большого размера ядра может снизиться общая
производительность. Если же Вы часто меняете конфигурацию компьютера (например,
у Вас имеются съемные жесткие диски или другие временно подключаемые
устройства), то, вероятно, имеет смысл использовать для управления ими
подключаемые модули, которые загружаются в память только при необходимости
(экономя тем самым системные ресурсы). Таким образом, в самом общем случае
поддержка некоторой части устройств должна быть встроена в ядро, а остальные
устройства должны поддерживаться за счет использования загружаемых модулей.
Теперь основной вопрос: как скомпилировать ядро, оптимизированное для Вашей
аппаратной конфигурации? Эта задача, вообще говоря, нетривиальна и для
начинающего пользователя может оказаться довольно затруднительной. До недавнего
времени компиляция ядра осуществлялась только в режиме командной строки, при
этом в процессе компиляции необходимо было ответить примерно на 500 кратко
сформулированных (и довольно сложных, да еще задаваемых по-английски) вопросов.
К счастью, в последнее время появились несколько программ, работающих в
графическом режиме и позволяющих пользователю выбрать, поддержку каких устройств
он хочет включить в новое ядро.
Buildkernel - это скрипт на shell, который автоматизирует задачу построения
ядра Linux. Начинающим пользователям он помогает пройти процесс от начала до
конца, выдавая подсказки перед осуществлением каждого шага. Опытные пользователи
могут использовать его для облегчения построения ядра.
Buildkernel скачает исходники ядра, удалит ненужный код, создаст символьные
ссылки, автоматически добавит патчи, построит ядро, модули и установит их на
жесткий диск, запустит LILO, если это необходимо.
Домашняя
страница: http://buildkernel.stearns.org/
RPM-пакет: http://buildkernel.stearns.org/buildkernel-1.03-1.noarch.rpm
.gif){kind=small}
