Когда мне говорят о жесточайших тормозах Линукса по сравнению с виндой, установленной на одной и той же машине, я задаю один единственный вопрос: «У вас ядро самосборное или то раздутое до невозможности, что поставляется в дистрибутиве по умолчанию?» Обычно ответ: «Естественно, то что в дистрибутиве!»
Кроме того, при этом воспринимается с огромным удивлением, что для улучшения работы системы не мешало бы пересобрать ядро под свой конкретный компьютер, дабы отключить в нем огромное количество того, что абсолютно не нужно для вашего железа, а лишь тормозит его работу… Сразу возникает резонный вопрос, зачем же разработчики дистрибутива включили в него настолько тормозное ядро, что обычный пользователь, установивший себе этот дистрибутив, должен сам перекомпилировать его?.. И вопрос вроде бы логичен, да не совсем…
Разработчики дистрибутивов обычно включают в него такое ядро, которое могло бы без проблем распознать максимально возможное железо, как на компьютере, который покупал еще ваш дедушка, дабы в свободное от просмотра новостей по телеку порезаться в «Call of duty», так и новейшую систему, купленную для выжимания максимума из возможностей компьютера. Естественно, при этом ядро получается раздутым донельзя, и при работе жутко тормозит, ибо системе приходится каждый раз «ковыряться» в большой куче записей и драйверов внутри ядра, что не может радовать ни вас, ни ваш компьютер… А компиляция собственного ядра позволяет отключить все ненужное, оставив только необходимую функциональность… Дело в том, что при работе операционной системы Linux, ядро - единственный участок памяти, который не свопуется, поэтому вполне логично сделать его как можно меньше. Надеюсь, я научно-популярно объяснил абсолютную необходимость пересобрания ядра?..
Обычно, впервые осознав важность компиляции ядра, начинающие пингвиноводы опускают руки, считая, что для этого необходимо много знаний и времени, и вообще это занятие для красноглазых администраторов, засыпающих лишь на пару часов с ноутбуком под мышкой, и уж точно не для человека, мало пока еще понимающего в Линуксе… Однако, спешу вас уверить, что все весьма просто и не стоит пугаться не самой сложной процедуры. Вам необходимо лишь узнать полную конфигурацию своего компьютера и выделить часок для внимательного конфигурирования ядра. Соберет же ядро программа установки, а вам лишь придется на полчаса предоставить машину в ее полное распоряжение. 🙂
Итак, как и обещал ранее, расскажу о процессе настройки и компиляции собственного ядра… Поехали!
Первое, что нам понадобится, - это собственно исходники нового ядра, под управлением которого скоро будет работать ваш Линукс. Скачать можно совершенно свободно на http://www.kernel.org . Качать необходимо последнее стабильное ядро (оно обычно первое в списке, там где написано «The latest stable version of the Linux kernel is…»). Советую брать архив tar.bz2, но всего лишь потому, что он меньше по размеру. Если вы уже собирали ядро, то вам можно будет просто докачать заплатки, то есть патчи, чтобы не качать довольно большое по объему ядро целиком… На самом деле, я рекомендую использовать полное ядро, ибо читал, что при заплаточном собирании ядра могут возникать различные проблемы, зачастую напрямую связанные с простой кривизной рук, однако, без соответствующих знаний лучше не рисковать…
Итак, ядро скачано… Задаем команду:
sudo chmod 777 /usr/src
После этого, забрасываем его (скачанный архив) в папку /usr/src. Распаковываем архив командой:
tar -jxvf xxxxx.tar.bz2
В этой команде xxxxx.tar.bz2 - это название файла архива с ядром… Как только закончится распаковка, ваши исходники будут находиться в каталоге /usr/src/xxxxx.
Прежде, чем приступить к настройке ядра, точно выяснить спецификации вашего компьютера:
1) тип процессора,
2) чипсет материнской платы,
3) тип видеокарты,
4) тип сетевой платы,
5) тип саунд-карты,
6) тип жестких дисков,
7) usb-устройства и прочее…
Когда все установлено и изучено, можно приступать собственно к конфигурированию ядра.
Заходим в директорию /boot, и видим там файл примерно такого названия config-2.6.24-19-generic. Он нам и нужен. Копируем его в каталог с исходниками /usr/src/xxxxx и переименовываем его в.config.
Также предварительно открываем файл Makefile, и в строчке "EXTRAVERSION=" дописываем свое название для ядра, например, EXTRAVERSION=-mykernel. Никакой другой функции эта строчка не несет, кроме, как удобства в опознании собственного ядра.
Эта команда запускает консольный интерфейс настройки. Ежели вам более по душе графический конфигуратор, то для его запуска нужно использовать команду:
Есть еще вариант консольной настройки:
Этот вариант очень полезен только тогда, когда уже имеется сформированный файл настроек.config (можно использовать файл настроек от старого ядра). В этом варианте задаются только вопросы по возможностям, появившимся с той версии ядра, для которой сделан файл настроек.
Если вы хотите, чтобы ядро работало стабильно и максимально быстро, ответственно подойдите к вопросу настройки. Внимательно читайте каждый пункт. Если чего-то не понимаете, то ищите ответы в интернете. Например, можно найти описание многих настроек и советы по оптимальному их использованию. Кстати, там же в разделе "3.4 Пример настройки ядра" имеется и несколько советов по оптимизации ядра.
После настройки выбираем пункт "Сохранить конфигурацию в новый файл", где указываем имя файла, отличного от.config, например.config_mykernel. Затем переименовываем.config в.config_old. И у вас получается два файла - .config_old и.config_mykernel. Кстати, есть возможность посмотреть различия между стандартной и вашей конфигурацией так:
diff .config .config_mykernel
Теперь копируем вашу конфигурацию.config_mykernel как.config. Т.е. у вас получится три файла конфигурации. При компиляции будет использоваться файл.config. Файлы.config_ubuntu и.config_mykernel нам помогут в будущем для новой компиляции. Это на тот случай, если новое ядро окажется неработоспособным.
Компиляцию ядра стоит делать под суперпользователем. Для чего становимся рутом и запускаем процесс сборки ядра:
sudo -s -H
make-kpkg --initrd --revision=mykernel.1 kernel_image kernel_headers
в этой строчке mykernel.1 обозначает название ядра. Можно писать все что душе угодно.
Операция компиляции занимает довольно продолжительное время, зависящее от мощности компьютера, у меня оно обычно занимало около получаса…
По окончании процесса создадутся два deb-файла с ядром, сконфигурированным конкретно под ваши нужды. Поздравляю, ядро готово.
Теперь необходимо установить собранное ядро в систему:
sudo dpkg -i linux-image-xxxxx.deb
sudo dpkg -i linux-headers-xxxxx.deb
Замените на точные названия созданных вами deb-файлов. Далее перегружаемся и видим, в меню свое ядро. Если у вас все загрузилось как положено, я думаю, вы сразу ощутите прирост производительности. Однако, если у вас установлена, например, карточка от nVidia, скорее всего на этом все и закончится… У меня, например, после запуска моей версии ядра просто был черный экран и ноль эмоций…
Исправилось это установкой проприетарных драйверов от nVidia. Есть два варианта их установки: под новое ядро (при этом графический сервер будет работать только под вашим ядром (рекомендуется, если вы не планируете работать ни в каком ядре, кроме своего) и под несколько существующих у вас ядер (в таком случае система будет грузиться как в новом, созданном вами ядре, так и в предыдущем). Но это уже совсем другая история…
Why would someone want to compile a new kernel? It is often not necessary since the default kernel shipped with Debian handles most configurations. Also, Debian often offers several alternative kernels. So you may want to check first if there is an alternative kernel image package that better corresponds to your hardware. However, it can be useful to compile a new kernel in order to:
Don’t be afraid to try compiling the kernel. It’s fun and profitable.
To compile a kernel the Debian way, you need some packages: , and a few others which are probably already installed (see for the complete list).
This method will make a .deb of your kernel source, and, if you have non-standard modules, make a synchronized dependent .deb of those too. It’s a better way to manage kernel images; will hold the kernel, the System.map, and a log of the active config file for the build.
Note that you don’t have to compile your kernel the “Debian way”; but we find that using the packaging system to manage your kernel is actually safer and easier. In fact, you can get your kernel sources right from Linus instead of , yet still use the compilation method.
Note that you’ll find complete documentation on using under . This section just contains a brief tutorial.
Hereafter, we’ll assume you have free rein over your machine and will extract your kernel source to somewhere in your home directory. We’ll also assume that your kernel version is 3.16. Make sure you are in the directory to where you want to unpack the kernel sources, extract them using and change to the directory that will have been created.
Now, you can configure your kernel. Run if X11 is installed, configured and being run; run otherwise (you’ll need installed). Take the time to read the online help and choose carefully. When in doubt, it is typically better to include the device driver (the software which manages hardware peripherals, such as Ethernet cards, SCSI controllers, and so on) you are unsure about. Be careful: other options, not related to a specific hardware, should be left at the default value if you do not understand them. Do not forget to select “Kernel module loader” in “Loadable module support” (it is not selected by default). If not included, your Debian installation will experience problems.
Clean the source tree and reset the parameters. To do that, do .
Now, compile the kernel: . The version number of “1.0” can be changed at will; this is just a version number that you will use to track your kernel builds. Likewise, you can put any word you like in place of “custom” (e.g., a host name). Kernel compilation may take quite a while, depending on the power of your machine.
Once the compilation is complete, you can install your custom kernel like any package. As root, do . The part is an optional sub-architecture, depending on what kernel options you set. will install the kernel, along with some other nice supporting files. For instance, the will be properly installed (helpful for debugging kernel problems), and will be installed, containing your current configuration set. Your new kernel package is also clever enough to automatically update your boot loader to use the new kernel. If you have created a modules package, you’ll need to install that package as well.
It is time to reboot the system: read carefully any warning that the above step may have produced, then .
For more information on Debian kernels and kernel compilation, see the Debian Linux Kernel Handbook. For more information on , read the fine documentation in .
Если помните, не так давно мы научились собирать из исходников ядро FreeBSD. Спрашивается, почему бы не научиться делать то же самое и с ядром Linux? Причины собирать ядро Linux из исходников, в общем то, те же — получение самой свежей версии ядра, срочное применение security-патчей, оптимизация под конкретные задачи и конкретное железо, а также желание принятие участие в разработке ядра, пусть даже в роли QA.
Важно! Следование инструкциям из этого поста может привести к потере ваших данных. Делайте бэкапы и помните, что делаете вы все исключительно на свой страх и риск. Все описанное ниже было проверено на Ubuntu 14.04 LTS. Но на других версиях Ubuntu, а также других дистрибутивах Linux, отличия должны быть минимальными.
Настраиваем загрузчик
Правим /etc/default/grub примерно таким образом:
GRUB_DEFAULT=0
# GRUB_HIDDEN_TIMEOUT=10
# GRUB_HIDDEN_TIMEOUT_QUIET=true
GRUB_TIMEOUT=10
GRUB_DISTRIBUTOR=`lsb_release -i-s2>/dev/null ||echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
GRUB_CMDLINE_LINUX=""
После правки говорим:
sudo update-grub
В результате перед загрузкой системы в течение 10 секунд будет предлагаться выбрать ядро, с которым вы хотите загрузиться. Очень удобно, если вы что-то напутали с конфигурацией ядра и хотите загрузиться с предыдущей версией!
Ставим зависимости
Нам понадобятся как минимум следующие пакеты:
sudoapt-get installgitgccmakebc fakeroot dpkg-dev \
libncurses5-dev libssl-dev
На многих системах все они, впрочем, уже будут присутствовать.
Получаем исходники
wget https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.6.4.tar.xz
tar—xz-xvf linux-4.6.4.tar.xz
cd linux-4.6.4
Или, если вам нужен самый-самый свежак, можно взять исходники прямо из Git:
# Mirror: https://github.com/torvalds/linux
git clone’git://git.kernel.org/pub/scm/linux/kernel/git/’\
‘torvalds/linux.git’
cd linux
Судя по тому, что тэга v4.6.4 в Git’е мне найти не удалось, релизы ядра Linux оформляются исключительно в форме сжатых tar-архивов.
Если же вместо ванильного ядра вы хотели бы собрать ядро с патчами от компании Canonical:
git clone git://kernel.ubuntu.com/ubuntu/ubuntu-trusty.git
cd ubuntu-trusty
git tag|less
git checkout Ubuntu-lts-4.4.0-31.50_14.04.1
По своему опыту скажу, что если вы пользуетесь Ubuntu, то можете смело использовать ванильное ядро. Вряд ли у вас возникнут с ним какие-то проблемы.
Примечание: Интересно, что из существующих сравнительно популярных дистрибутивов Linux ядро без собственных патчей, похоже, используют только Gentoo, Slackware и Arch Linux.
Так или иначе, теперь у вас есть исходники.
Собираем и устанавливаем ядро
Выбираем опции, с которыми будет собрано ядро:
В случае необходимости меняем настройки, жмем Save, затем Exit. В результате будет создан файл, содержащий выбранные нами параметры.
При обновлении ядра (вы же по-любому уже используете какое-то ядро?) удобно взять конфиг текущего ядра, и выставить новым опциям значения по умолчанию:
zcat/proc/config.gz > ./.config
make olddefconfig
Наконец, собираем:
make-j4 bindeb-pkg LOCALVERSION=-custom
Собирается ядро довольно долго. На моем ноутбуке сборка заняла 1 час 15 минут. Однако из этого времени бо льшая часть тратится на сборку гигантского пакета ядра с отладочными символами.
Ручная сборка и конфигурирование ядра Linux
Сборку этого пакета можно отключить, закомментировав в конфиге параметр CONFIG_DEBUG_INFO. Только учтите, что этот пакет требуется SystemTap и другим полезным инструментам.
Помимо самого ядра также можно собрать и документацию:
# еще есть `make pdfdocs` и другие, см `make help`
make htmldocs
chromium-browser Documentation/DocBook/index.html
По окончании сборки в дочернем каталоге видим что-то вроде:
linux-firmware-image-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-headers-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-image-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-image-4.4.13-custom-dbg_4.4.13-custom-1_amd64.deb
linux-libc-dev_4.4.13-custom-1_amd64.deb
Ставим все deb-пакеты кроме dbg-версии ядра обычным и перезагружаемся. После перезагрузки смотрим на вывод команды. Убеждаемся, что действительно загрузились с новым ядром. Если с новым ядром что-то не так, в загрузчике просто выбираем то, с которым система загружалась до этого. После загрузки со старым ядром поскорее удаляем пакеты нового ядра, и вуаля — система вернулась к прежнему состоянию.
Дополнительно после загрузки нового ядра можно прогнать на нем тесты:
sudomake kselftest
sudomake kselftest-clean
Поздравляю, теперь вы умеете собирать ядро Linux!
Заключение
Материалы по внутреннему устройству ядра Linux:
- KernelNewbies.org, сайт для новичков в ядре Linux со своим списком рассылки, IRC-каналом, форумом, вики, и так далее;
- LKML.org, сайт для комфортного чтения мейлинг листа разработчиков ядра Linux через браузер. Будьте внимательны, он нередко портит форматирование писем! В этом смысле архив рассылки на marc.info намного лучше;
- Linux Cross Reference, сайт для комфортного чтения кода ядра Linux через браузер;
- Книга Linux Kernel Development, 3rd Edition является наиболее свежей книгой по ядру Linux на английском языке (2010 год, ядро 2.6.x), есть перевод на русский язык;
- Книга Linux-Treiber entwickeln, 4th Edition более свежая (2015 год, ядро 4.x), но написана на немецком и не имеет перевода;
- Бесплатная книга Linux Insides за авторством Alexander Kuleshov a.k.a @0xAX выглядит наиболее доступной и актуальной, но на данный момент еще находится в процессе написания;
- Иногда что-то полезное удается найти в Linux Kernel HTML Documentation, официальной документации из исходников ядра Linux;
- Примеры к книге Linux Device Drivers, 3rd Edition, которые пытаются поддерживать в актуальном состоянии, плюс исходники к 4-му изданию, которое на данный момент еще пишется;
А собираете ли вы ядро из исходников, и если да, то зачем? 🙂
Дополнение: Вас также может заинтересовать статья Скандальная правда об отладке ядерного кода в Linux.
Метки: Linux, Ring0.
Компиляция ядра linux
Как собрать ядро linux? Сборка ядра LinuxИтак, если вам всё же необходимо иметь своё ядро, приступим к компиляции!
Если у вас уже установлен X сервер (домашний компьютер), то вы можете перейти на сайт в вашем любимом браузере и скачать нужную версию в архиве tar.gz (сжатый gzip). Если же вы работаете в консоли (например ещё не устанавливали X сервер или конфигурируете сервер), можете воспользоваться текстовым браузером (например elinks). Также можно воспользоваться стандартным менеджером загрузок wget:
Конфигурация ядра.
Компиляция.
|
Май 2017
Март 2017
Апрель 2016
Март 2016
Октябрь 2013
Сентябрь 2013
Май 2013
Март 2013
Ноябрь 2012
Июль 2012
Июнь 2012
Апрель 2012
Март 2012
Февраль 2012
Апрель 2011
Март 2011
Февраль 2011
Январь 2011
Декабрь 2010
Ноябрь 2010
Октябрь 2010
Сентябрь 2010
Август 2010
Июль 2010
Июнь 2010
Май 2010
Апрель 2010
Март 2010
Случайные:
Виртуальный планетарий Stellarium: обзор новых возможностей
BOINC: вычисления для науки
Gambas: Разработка на Basic в linux
Последовательные Диаграммы SSH 2.0
Linuxnow.ru: Планы на будущее
Внезапно стало мало свободного места на диске? Возможно, проблема в логах.
Коллеги: все
Linux для всех
Наши баннеры:
Установить баннер
Конфигурирование ядра Linux
Проверка пакетов исходных текстов
Для рекомпиляции ядра необходимы его исходные тексты.
Блог о системном администрировании. Статьи о Linux, Windows, СХД NetApp и виртуализации.
В Red Hat исходные тексты ядра размещаются в одном rpm-пакете, но по умолчанию не устанавливаются. Имя этого пакета:
kernel-source-2.4.2-2.1386.rpm
Кроме исходных текстов, для рекомпиляции ядра нужен компилятор, состоящий из двух компонентов:
утилита make;
собственно компилятор языка С — gсс или egcs.
Создание резервной копии текущего ядра проводится в три этапа:
1. Создание резервной копии исходных текстов ядра, что позволяет восстановить его при повреждении конфигурации.
2. Создание резервной копии самого ядра как заведомо работающего средства запуска системы.
3. Создание новой записи для загрузчика операционной системы, по которой можно будет загрузиться с резервной копии ядра.
Создание резервной копии исходных текстов производится путем копирования каталога с исходными кодами ядра на диск. Восстановление производится копированием в обратном направлении.
При рекомпиляции ядра прежнее ядро записывается в файл с расширением.old. Однако эту копию ядра пока нельзя использовать для загрузки системы. Этим объясняется необходимость выполнения перечисленных выше операций.
Загрузчик операционной системы типа LILO, обычно применяемый для загрузки Linux, конфигурируется установкой ссылки на файл ядра в корневой файловой системе.
После создания резервной копии ядра в файл /etc/lilo.conf нужно добавить еще одну запись, позволяющую запустить Linux с прежним ядром:
открыть файл /etc/lilo. conf в текстовом редакторе;
создать копию всего раздела;
поменять в копии две позиции:
имя файла ядра заменить на имя его резервной копии (вместе с расширением);
заменить метку раздела чем-либо, наподобие linux. original (исходный Linux) или linux-previous (прежний Linux).
строки, начинающиеся с initrd, заменить на соответствующие резервные, например, initrd-2 .4.2-2. orig. Img;
записать изменения в файл /etc/lilo. conf.
ввести команду /sbin/lilo, чтобы ввести новую запись в загрузчик. При выполнении команды lilo на экран выводятся метки образов, вводимых в загрузчик операционной системы.
При следующей перезагрузке системы на экране появится идентификатор нового ядра в графической подсказке загрузчика LILO.
Конфигурирование нового ядра
При конфигурировании решается, какие функции включать в ядро, какие не включать и т.д. Можно выбирать между конфигурированием старого ядра и установкой/конфигурирование нового. Например, используя Red Hat Linux 7.1, можно изменить конфигурацию существующего ядра 2.4.2, задав новые параметры. Можно также загрузить и установить новое ядро версии 2.4.4. Несмотря на то, что детали конфигурирования в этих двух случаях различны, используемые утилиты и сама методика конфигурирования совпадают.
В Linux есть три отдельные конфигурационные утилиты, каждая из которых имеет свои особенности.
Утилита с интерфейсом командной строки. Пользователь последовательно отвечает на вопросы о функциях, которые необходимо включить в ядро. Эта утилита удобна для специалистов, умеющих работать с ядром, и для тех, у кого есть сценарии конфигурирования для этой утилиты.
Утилита с меню текстового режима. Многоуровневое меню этой утилиты позволяет устанавливать и переустанавливать параметры ядра в любом порядке.
Утилита с графическим интерфейсом. Это наиболее привлекательная утилита, но она запускается только в графической системе X Window.
Перечисленные утилиты создают один и тот же конфигурационный файл, используемый утилитой make при полной или частичной компиляции ядра.
Параметры ядра
Просматривая параметры в любой конфигурационной программе (командной строки, с текстовым или графическим интерфейсом), необходимо четко представлять влияние этих параметров на работу ядра.
Идентификация параметров в каждой программе своя, но во всех трех представлен один и тот же их набор. Параметры подразделяются на две основные группы:
модульные;
немодульные.
Если программный блок, соответствующий данному параметру, не загружается как модуль ядра, он может быть одним из двух:
[*] составной частью ядра;
Несоставной частью ядра.
Символы в квадратных скобках (вместе со скобками) соответствуют отметкам параметров в меню конфигурационных программ (кроме утилиты командной строки).
Для модульных параметров возможны три варианта установки (в соответствии с их представлением в меню конфигурационных утилит):
<> не включается в ядро и не создается в виде модуля, который можно загрузить позже:
<*> включается в ядро, так что нет надобности загружать его позже в виде модуля:
<М> Включается как модуль, но не как составная часть ядра. Блок можно устанавливать или удалять из ядра в любой момент.
Иногда значение какого-либо параметра не удается поменять до установки другого параметра. Например, установить поддержку определенного устройства SCSI можно только после общего разрешения поддержки этих устройств.
Когда в системе будут установлены необходимые средства (утилита make и компилятор gсс) и исходные тексты, можно запустить одну из конфигурационных утилит и приступить к конфигурированию ядра.
Конфигуратор с графическим интерфейсом
Запуск конфигурационной утилиты с графическим интерфейсом выполняется в следующей последовательности.
Запустить систему X Windows (с любыми графической средой и рабочим столом).
Открыть окно эмулятора терминала (окно командной строки).
Как и при запуске предыдущей утилиты, на экране промелькнет несколько сообщений о компиляции утилиты, и через несколько минут откроется ее главное окно.
Рис. 8. Утилита конфигурирования ядра с графическим интерфейсом: меню-кнопки установки значений параметров
Графическая утилита не слишком отличается от утилиты menuconf ig. Здесь параметры также разбиты на категории; после щелчка на определенной категории открывается диалоговое окно со списком параметров, каждому из которых можно установить значение, определяющее, что соответствующее средство должно задействоваться как составляющая часть ядра, как загружаемый модуль или не задействоваться вообще.
Такое диалоговое окно показано на рис.
Рис. 9. В диалоговых окнах, подобных этому, устанавливаются конфигурационные параметры ядра
Ядро 2.4.2 в Red Hat Linux по умолчанию поддерживает симметричную мультипроцессорную архитектуру. Необходимо установить для соответствующей опции значение n, если в вашем компьютере всего один процессор.
Справа от каждого параметра находится кнопка Help (Справка).
Большое преимущество графической конфигурационной утилиты (особенно его оценят те, кто впервые конфигурирует ядро) – отражение в меню зависимости между различными параметрами. Например, в разделе Block Devices (Блочные устройства) нельзя установить поддержку систем RAID, встроенную в ядро, пока не будет включен параметр Multiple Device Driver Support (Поддержка драйверов для нескольких устройств).
Если в утилите menuconfig зависимость параметров друг от друга показана отступами имен параметров в меню, то в графической утилите установка неразрешенных сочетаний параметров просто невозможна. Работа с графической утилитой помогает понять зависимости между различными модулями.
В конце главного меню графической утилиты находятся команды, аналогичные соответствующим командам утилиты с меню текстового режима.
Save and Exit (Выход с сохранением). Создание файла конфигурации ядра и завершение работы утилиты.
Quit Without Saving (Выход без сохранения). Завершение работы утилиты без создания файла конфигурации ядра.
Без создания файла конфигурации ядра при помощи одной из перечисленных утилит рекомпиляция ядра невозможна.
Load Configuration From File (Загрузка конфигурации). Загрузка конфигурационного файла, созданного ранее.
Store Configuration To File (Запись конфигурации). Запись конфигурационных данных в файл с указанным именем (для дальнейшего использования или передачи коллеге). Это не влияет на необходимость выполнения команды Save and Exit, создающей конфигурационный файл для рекомпиляции ядра.
Компиляция и запуск нового ядра
После завершения конфигурирования нужно проверить наличие нового конфигурационного файла (.config), расположенного в каталоге /usr/src/linux-2 .4.2 (в зависимости от номера версии). Если конфигурационный файл.config на месте, можно использовать команду make для рекомпиляции ядра.
Обычно рекомпиляция ядра длится от 15 минут до нескольких часов. Это зависит от скорости процессора, объема оперативной памяти и ряда других факторов, поэтому все команды, вводимые при компиляции, удобно объединить в одну, через точку с запятой, чтобы они выполнялись последовательно.
Запуск процесса рекомпиляции
Приведенные ниже команды предназначены для создания нового ядра с рекомпиляций всех его модулей и их записью в соответствующие системные каталоги. (Там они будут доступны для команд ядра.)
Для рекомпиляции системы введятся следующие команды.
# make dep; make clean; make bzlmage; make modules; make modules__install
Каждую команду make можно вводить отдельно, после завершения предыдущей.
После ввода этих команд на экране начнут мелькать строки с описанием каталогов, к которым обращается программа make, запуска компилятора gcс. для компиляции различных файлов исходного текста и компоновки различных блоков. Каждой из этих команд потребуется для выполнения несколько минут.
Теперь можно создать загрузочный диск для нового ядра с помощью команды
Перед выполнением этой команды следует вставить отформатированную дискету в накопитель. Готовый загрузочный диск необходимо испытать. Перезагрузите компьютер, не вынимая дискету из накопителя.
После выполнения команд компиляции ядра и возврата к командной строке создается новое ядро. Чтобы загрузить систему с новым ядром, его необходимо переместить в стандартный каталог, из которого оно будет запускаться. Это делается вводом команды
# ср /usr/src/linux-2.4.2/arch/i386/boot/bzlmage /boot/vmlinuz-2.4.2-2
В завершение, для обновления карты загрузки выполните команду lilo:
В имени копируемого образа ядра можно указать номер версии. Важно, чтобы имя этого файла совпадало с именем, указанным в файле /etc/lilo.conf.
Тестирование нового ядра
После перемещения файла нового ядра в стандартный каталог (указанный в файле lilo. conf) систему можно перезагрузить с этим ядром.
Сразу после перезагрузки проверьте работу новых средств, ради которых и затевалась рекомпиляция. Можно выполнить следующие действия.
Сравнение объемов старого и нового ядер. Следует проверить объем памяти, занимаемый операционной системой, введя команду free.
Установка файловой системы или попытка доступа к устройству без загрузки модуля ядра для его поддержки (если поддержка данного устройства встроена в ядро).
Использование сетевых ресурсов (например, алиасов IP), отсутствовавших в прежнем ядре.
Может понадобиться проверка временной метки файла текущего ядра. Для этого введите команду uname. Это позволяет убедиться в том, что в данный момент система работает с рекомпилированным ядром. Метка времени и даты ядра должна совпадать со временем его рекомпиляции.
Если ответ команды uname свидетельствует о том, что система загружена не с новым ядром, разберитесь с системным загрузчиком LILO. Проверьте, правильно ли указано имя загружаемого ядра в файле /etc/lilo.conf.
ПОСМОТРЕТЬ ЕЩЕ:
Компиляция и установка ядра Linux из исходников в Debian
Материал из Bryansk Linux Users Group и www.rm.pp.ru
В каждом дистрибутиве имеется своя специфика сборки ядра и эта статья ориентирована именно на то, как это сделать в Debian Etch. Так же раскрывается вопрос, как наложить тот или иной патч на ядро, когда необходима поддержка определенной функциональности или нового оборудования в Вашей системе. Статья предназначена в первую очередь на более подготовленных пользователей и нет никаких гарантий, что этот способ будет работать так, как надо и все описанные действия и ответственность ложатся на Вас.
- Примечание
- Способ первый. Сборка ядра в.deb пакеты
- Накладываем патчи
- Конфигурирование ядра
- Компиляция ядра
- Установка нового ядра
- Способ второй. "traditional" way
- Проблемы
- Ссылки
Примечание
Будет описано два способа сборки ядра. Первым будет описан вариант сборки.deb пакетов, которые могут быть установлены в Вашей или другой системе.
Второй метод, так называемый "traditional" путь.
Способ первый. Сборка ядра в.deb пакеты
Установка необходимых пакетов для компиляции ядра
Для начала обновим списки пакетов:
# apt-get update
Установим нужные нам пакеты:
# apt-get install kernel-package libncurses5-dev fakeroot wget bzip2 build-essential
Скачиваем исходники ядра
Переходим в каталог /usr/src, идем на www.kernel.org и выбираем нужную версию ядра. В данном случае будет рассмотрена версия linux-2.6.23.1.tar.bz2. Скачиваем:
# cd /usr/src # wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.23.1.tar.bz2
Распакуем исходники и создадим символьную ссылку:
# tar xjf linux-2.6.23.1.tar.bz2 # rm linux (удалим предыдущий симлинк) # ln -s linux-2.6.23.1 linux # cd /usr/src/linux
Накладывание патчей
Опционально и без необходимости не делайте этого!
Иногда требуются драйвера или средства, которые не поддерживаются в имеющемся ядре, например технология виртуализации или иная другая специфика, которой нет в текущем релизе. В любом случае это исправляется наложением так называемых патчей (если таковые имеются).
Итак, предположим вы скачали необходимый патч (для примера назовем patch.bz2) в /usr/src. Применим скачанный патч на наши исходники (Вы должны быть все еще в каталоге /usr/src/linux):
# bzip2 -dc /usr/src/patch.bz2 | patch -p1 —dry-run # bzip2 -dc /usr/src/patch.bz2 | patch -p1
Первая команда - только тест и никакие изменения не будут применены к исходникам. Если после первой команды не было выдано никаких ошибок, можно выполнить вторую команду для применения патча. Ни в коем случае не выполняйте вторую команду, если после первой были выданы ошибки!
Таким образом Вы можете накладывать патчи на исходники ядра. Например, имеются некоторые особенности, которые доступны только в 2.6.23.8 ядре, а исходники не содержали необходимой функциональности, но выпущен патч patch-2.6.23.8.bz2. Вы можете применить этот патч к исходникам ядра 2.6.23, но не 2.6.23.1 или 2.6.23.3 и т.д. Подробнее об этом можно прочитать на :
Предъисправления (препатчи) — эквивалентны альфа релизам; патчи должны быть применены к исходникам полного предыдущего релиза с 3-х значной версией (например, патч 2.6.12-rc4 может быть применен к исходникам версии 2.6.11, но не к версии 2.6.11.10.)
Это значит, если мы хотим собрать ядро 2.6.23.8, необходимо скачать исходники версии 2.6.23 (http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.23.tar.gz) применительно во втором способе "traditonal" путь!
Применяем патч patch-2.6.23.8.bz2 к ядру 2.6.23:
# cd /usr/src # wget http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.22.8.bz2 # cd /usr/src/linux # bzip2 -dc /usr/src/patch-2.6.23.8.bz2 | patch -p1 —dry-run # bzip2 -dc /usr/src/patch-2.6.23.8.bz2 | patch -p1
Конфигурирование ядра
Неплохой идеей будет использование существующего конфигурационного файла работающего ядра и для нового. Поэтому копируем существующую конфигурацию в /usr/src/linux:
# make clean && make mrproper # cp /boot/config-`uname -r` ./.config
# make menuconfig
после которой загрузится графическое меню конфигурации ядра. Выбираем в меню конфигуратора пункт "Load an Alternate Configuration File" и нажимаем "Оk". Затем (если требуется) сделайте необходимые изменения в конфигурации ядра перемещаясь по меню (подробности конфигурации ядра можно найти в www.google.com ). Когда закончите и нажмете "Exit", будет задан вопрос "Do you wish to save your new kernel configuration?", отвечаем утвердительно "Yes".
Собираем ядро Linux
Компиляция ядра
Сборка ядра выполняется всего в две команды:
# make-kpkg clean # fakeroot make-kpkg —initrd —append-to-version=-cybermind kernel_image kernel_headers
После —append-to-version=, можно написать любое название, какое Вам угодно, но оно должно начинаться со знака минус (-) и не иметь пробелов.
Процесс компиляции и сборки.deb пакетов может занят довольно продолжительное время. Все будет зависить от конфигурации ядра и возможностей Вашего процессора.
Решение проблемы с созданием initrd.img
С недавнего времени в Debian появился баг, заключающийся в том, что после установки пакетов с собранными описанным здесь способом ядрами, не создаётся соответствующий им файл /boot/initrd.img. Для исправления применительно к уже установленному ядру, придётся создать initrd.img вручную:
update-initramfs -c -k <полная-версия-ядра>
Для решения проблемы «на будущее» – закомментировать, как показано, вторую из процитированных ниже строк в файле /etc/kernel/postinst.d/initramfs-tools:
# kernel-package passes an extra arg; hack to not run under kernel-package #[ -z "$2" ] || exit 0
Установка нового ядра
Когда удачно завершится сборка ядра, в каталоге /usr/src будут созданы два.deb пакета:
# cd /usr/src # ls -l
linux-image-2.6.23.1-cybermind_2.6.23.1-cybermind-10.00.Custom_i386.deb - собственно само актуальное ядро и linux-headers-2.6.23.1-cybermind_2.6.23.1-cybermind-10.00.Custom_i386.deb - заголовки ядра, необходимые для сборки других модулей (например при сборке модулей драйвера nVidia). Устанавливаем их:
# dpkg -i linux-image-2.6.23.1-cybermind_2.6.23.1-cybermind-10.00.Custom_i386.deb # dpkg -i linux-headers-2.6.23.1-cybermind_2.6.23.1-cybermind-10.00.Custom_i386.deb
(Эти пакеты теперь могут быть установлены на другой системе и собирать их заново уже не будет необходимости.)
Всё, установка завершена, меню загрузчика, установка нового RAM-диска и ядра будут сделаны автоматически. Остается только перезагрузиться:
Способ второй. "traditional" way
Выполняем все пункты, описанные выше ДО пункта "Компиляция ядра".
# make all # make modules_install # make install
Как обычно, сборка может занять продолжительное время, зависящее от конфигурации ядра и возможностей процессора.
Основной недостаток этого метода - если вы часто обновляете ядра, то через некоторое время их накопится большое количество и захочется удалить неиспользуемые. Чтобы это было сделать проще, можно собрать ядро и другие файлы, которые устанавливаются в систему по командам "make modules_install" и "make install" в deb-пакет (а точнее в два начиная с ядра 2.6.27) подобно первому способу, но воспользуемся здесь скриптами самого ядра:
# make all # make deb-pkg
В каталоге на уровень выше каталога исходников появятся два.deb-файла. Я собирал ядро в каталоге /usr/src/linux-2.6.27.10 и у меня в каталоге /usr/src/ появились файлы
# linux-2.6.27.10_2.6.27.10-1_amd64.deb # linux-firmware-image_2.6.27.10-1_all.deb
Ядро устанавливается командой
# dpkg -i linux-2.6.27.10_2.6.27.10-1_amd64.deb
Старые ядра можно удалять, например, из synaptic’a
Следующие шаги
Ядро собрано и установлено, но еще теперь необходимо создать RAM-диск (без которого ядро просто не загрузится) и необходимо обновить загрузчик GRUB. Для этого выполним следующее:
# depmod 2.6.23.1 # apt-get install yaird
Установим RAM-диск:
# mkinitrd.yaird -o /boot/initrd.img-2.6.23.1 2.6.23.1
Обновим легко и безболезненно загрузчик:
Всё, загрузчик и новое ядро готовы, остается только перезагрузиться:
Проблемы
Если после перезагрузки, выбранное вами новое ядро не загружается, перезагрузитесь и выберите Ваше предыдущее ядро и можно попробовать проделать весь процесс заново, чтоб собрать рабочее ядро. Не забывайте в таком случае удалить строчки нерабочего ядра в /boot/grub/menu.lst.
Компиляция ядра linuxЗачем вообще самому компилировать ядро?
Также есть возможность включить поддержку более 4х Гигабайт оперативной памяти, не меняя разрядность системы. Итак, если вам всё же необходимо иметь своё ядро, приступим к компиляции! Получение исходного кода ядра.
Распаковка архива исходного кода.
Конфигурация ядра.
make config — консольный режим конфигуратора. make menuconfig — консольный режим в виде списка.
make xconfig — графический режим.
После внесения нужных изменений, сохраните настройки и выйдите из конфигуратора. Компиляция.
Конфигурирование и компиляция ядра LinuxЯдро установлено. Чтобы оно появилось в списке grub(2), введите (от суперпользователя) KernelCheck — компиляция ядра не заходя в консоль.
|
Май 2017
Март 2017
Апрель 2016
Март 2016
Октябрь 2013
Сентябрь 2013
Май 2013
Март 2013
Ноябрь 2012
Июль 2012
Июнь 2012
Апрель 2012
Март 2012
Февраль 2012
Апрель 2011
Март 2011
Февраль 2011
Январь 2011
Декабрь 2010
Ноябрь 2010
Октябрь 2010
Сентябрь 2010
Август 2010
Июль 2010
Июнь 2010
Май 2010
Апрель 2010
Март 2010
Случайные:
Aurorae: движок декораций окон для KDE
Sblog будет переписан на.NET
Linuxnow.ru: Планы на будущее
Bolgenos. Опровержение «Телекона»
Быстрое восстановление GRUB 2
Фонд свободного программного обеспечения и копилефт.
Коллеги: все
Linux для всех
Наши баннеры:
Установить баннер
Ядро (англ. kernel ) – то, вокруг чего строится всё остальное. Именно оно и называется Linux. Сейчас словом Linux в быту называют построенную на нём операционную систему, хотя по-хорошему она называется GNU/Linux (ядро Linux и ПО от проекта GNU, многие десятилетия находящейся в разработке).
В Ubuntu исппользуется ядро с большим количеством патчей , часть из которых добавляет нестабильные и экспериментальные возможности .
Каждый релиз Ubuntu имеет собственную версию ядра. LTS -релизы начиная с 10.04 получили возможность обновить ядро до версий, входящих в состав более новых релизов.
| Версия Ubuntu | Версия ядра |
|---|---|
| 4.10 | 2.6.9 |
| 5.04 | 2.6.11 |
| 5.10 | 2.6.13 |
| 6.06 LTS | 2.6.15 |
| 6.10 | 2.6.18 |
| 7.04 | 2.6.19 |
| 7.10 | 2.6.20 |
| 8.04 LTS | 2.6.24 |
| 8.10 | 2.6.27 |
| 9.04 | 2.6.28 |
| 9.10 | 2.6.31 |
| 10.04 LTS | 2.6.32 |
| 10.10 | 2.6.35 |
| 11.04 | 2.6.38 |
| 11.10 | 3.0.4 |
| 12.04 LTS | 3.2 |
| 12.10 | 3.5 |
| 13.04 | 3.8 |
| 13.10 | 3.11 |
| 14.04 LTS | 3.13 |
| 14.10 | 3.16 |
| 15.04 | 3.19 |
Форки
Нумерация версий ядра Ubuntu и на сайте kernel.org не совпадает, так как для обозначения добавленных патчей разработчики из Canonical добавляют микроверсию. Например, версия 3.2.0-23 будет означать, что ядро базируется на ветке 3.2, на которую было наложено 23 патча.
В репозитории Ubuntu поддерживаются следующие типы ядер:
generic-pae ядро позволяет 32-битной системе использовать до 64ГБ общего объёма оперативной памяти, выделяя под нужды конкретного процесса не более 4ГБ, в то время как простое ядро generic работает не более чем с 4ГБ ОЗУ.
64-битное ядро позволяет адресовать до 1ТБ памяти, потребляемой процессами.
Если требуется обновить ядро на более новую мажорную версию (обычно это связано с тем, что в новых версиях добавляется поддержка нового оборудования, устраняются регрессии) можно воспользоватся официально поддерживаемым архивом http://kernel.ubuntu.com/~kernel-ppa/mainline/ .
Компиляция ядра
Сборка ядра из исходных кодов требует некоторых навыков и знаний о работе ОС.
Перед началом сборки ядра необходимо установить следующие пакеты:
Build-essential fakeroot ncurses-dev libssl-dev
Все дальнейшие действия необходимо выполнять от лица суперпользователя :
sudo suПолучение исходного кода
Исходный код ядра, используемого в Ubuntu можно получить установив пакет linux-source:
apt-get install linux-sourceПосле установки в директории /usr/src появится архив называющийся linux-source-верися_ядра.tar.bz2 .
Так же можно скачать архив и с исходным кодом ядра с сайта kernel.org .
Скачивая ядро с сайта kernel.org, вам придётся наложить на него патчи
Конфигурирование
Распакуйте полученый архив и, для удобства, создайте символическую ссылку на полученую в результате директорию:
cd / usr/ src tar xjf ./ linux-source-3.2.0.tar.bz2 ln -s ./ linux-source-3.2.0 ./ linux cd ./ linuxДля упрощения процесса конфигурации ядра можно скопировать настройки текущего.
Сборка ядра Linux
Здравствуйте, уважаемые читатели. Сегодня я расскажу о таком интересном занятии как сборка ядра Linux
. Зачем может понадобиться самостоятельно собирать ядро? На самом деле причин может быть множество: необходимость задействовать дополнительные возможности ядра, оптимизировать ядро под ваш компьютер, обновить ядро до самой свежей версии. В этой статье я продемонстрирую процесс получения исходных кодов, настройки, компиляции и установки в систему ядра Linux, в рамках решения задачи включения в ядро поддержки cryptoloop(петлевые шифрующие устройства).
Получение исходного кода
В первую очередь мы должны получить исходный код, это можно сделать разными способами и из разных источников. Я предлагаю рассмотреть только два: системные репозитории, официальный сайт ядра. В репозиториях, скорее всего, будут версии ядра более старые чем он официальном сайте, но в эти исходники должны быть включены патчи и исправления от производителя вашего дистрибутива Linux. Такой подход предпочтительнее если вы не нуждаетесь в какой-то новой технологии или возможности, которая поддерживается только более новыми ядрами. Просмотреть все версии исходников ядра, которые содержатся в репозиториях вашей системы, вы можете введя в терминале(справедливо для Ubuntu Linux, в других дистрибутивах название пакета может отличаться):
Apt-cache search linux-source
Команда выведет список доступных пакетов:
Как видите, у меня есть только пакет с текущей версией и пакет с версией 3.5 (на самом деле текущая версия ядра тоже 3.5). Расширить список ядер, доступных таким образом, стоит подключить дополнительные репозитории. Получить ядро мы можем командой: sudo apt-get install linux-source
linux-source - имя пакета с исходным кодом, в вашем случае может быть другим.
После завершения работы команды в директории /usr/src появится файл, в моем случае - linux-source-3.5.0.tar.bz2. Перейдем в папку, распакуем архив и ради удобства создадим символическую ссылку:
Cd /usr/src sudo tar -xjvf linux-source-3.5.0.tar.bz2 sudo ln -s linux-source-3.5.0 linux
Если же вам нужна самая свежая версия ядра, то её всегда можно скачать с сайта kernel.org. Стоит заметить, что на сайте выкладываются как стабильные версии ядер так и версии предназначенные для тестирования и доработки(обычно в их названии есть содержится аббревиатура «RC» - Release candidate). Если вы не желаете лишних проблем с системой, советую скачивать стабильную версию:
Сохраним архив с исходниками в папку /usr/src. Чтобы распаковать полученный архив вам может понадобиться установить дополнительные утилиты:
Sudo apt-get install xz-utils
Теперь, как и в случае с загрузкой ядра из репозиториев, мы должны распаковать архив с исходниками и создать ссылку:
Cd /usr/src sudo tar -xpJf linux-3.8.5.tar.xz sudo ln -s linux-3.8.5.tar.xz linux
Конфигурация и компиляция.
Вот мы и подошли к самому интересному. Прежде чем начать, установим несколько дополнительных пакетов:
sudo apt-get install build-essential kernel-package libncurses-dev
Будем создавать новую конфигурацию, на основе используемого системой в данный момент ядра:
Cd /usr/src/linux sudo make oldconfig
Если вы конфигурируете более новую версию ядра чем есть в системе, то вполне вероятно что в ней появились параметры, которых нет в конфигурации нынешнего ядра. В таком случае программа будет просит сделать выбор вас, вы можете оставлять значения по умолчанию просто нажимая клавишу Enter. В любом случае конфигурирование ещё не завершено. Теперь мы можем выполнить нужные нам настройки через меню создания конфигурации:
Sudo make menuconfig
В терминале запустится программа конфигурирования:
Здесь параметры конфигурации разделены на разделы, чтобы в них было удобнее ориентироваться. Как я уже говорил выше, мне нужно включить в ядро поддержку cryptoloop. Для этого нужно перейти в раздел «Device Drivers», а из него в подраздел «Block Devices»:
Находим параметр «Cryptoloop Support», рядом с ним стоит буква «М» что означает что поддержка шифрующих устройств будет добавлена как модуль ядра, который можно будет включить командой modprobe. Нам же надо включить поддержку данной технологии непосредственно в ядро, чтобы она поддерживалась всегда. Переводим фокус на параметр «Cryptoloop Support» и нажимаем на пробел. Буква «М» должна смениться символом "*" это означает что поддержка данной технологии будет «вшита» в ядро. Осторожно, пробел означает что технология вообще поддерживаться не будет.
Нажимаем клавишу «Tab» и нажимаем на кнопку «Exit» до тех пор пока не появится запрос на сохранение изменений:
Отвечаем «Yes». Мы успешно закончили конфигурирование!
Приступим к компиляции. Сначала удаляем файлы оставшиеся от предыдущих сборок, если вы запускаете сборку впервые выполнять эту команду не обязательно: sudo make-kpkg clean
Запускаем компиляцию:
Sudo make-kpkg -j4 --initrd --append-to-version=-mykernel kernel_image kernel_headers
J4 - флаг, указывает какое количество потоков использовать для компиляции. Позволит сильно ускорить компиляцию на многоядерных процессорах. Цифра 4 тут указывает на 4 потока. Ставьте столько потоков сколько ядер вашего процессора «видит» система.
-mykernel - префикс указывающий что ядро было собрано вручную, можете его изменить, фактически ни на что не влияет.
Вот и начался процесс компиляции. Он может занять от 10 минут, до нескольких часов в зависимости от того насколько мощный у вас компьютер:
После завершения компиляции, в директории /usr/src должны появится два файла с расширением «deb» они являются установочными пакетами нашего нового ядра и установить их можно с помощью утилиты dpkg:
sudo dpkg -i linux-image-3.8.5-mykernel_3.8.5-mykernel-10.00.Custom_i386.deb
sudo dpkg -i linux-headers-3.8.5-mykernel_3.8.5-mykernel-10.00.Custom_i386.deb
Поздравляю! Ядро установлено, теперь система будет загружаться с этим ядром по умолчанию, но если у вас возникнут проблемы с новым ядром вы всегда можете загрузится со старым выбрав его на экране загрузки - Grub. На этом я завершаю сегодняшнюю статью и желаю успехов, вам, уважаемые читатели!
Давно хотел написать статью о том, как собирать ядро Linux. И вот этот момент настал.
Собственно, зачем собирать ядро, если дистрибутив предоставляет вполне годное к использованию ядро?
Например, для того, чтобы пользоваться самыми новейшими драйверами и решениями, представленными в новом ядре, когда от дистрибутива доступна только старая ветка. Еще, например, чтоб настроить его под своё железо и немного ускорить работу. Я собрал себе 3.11, потому что в нем находится набор патчей , улучшающих работу с видеокартами ATI, обладателем одной из них я и являюсь.
О сборке ядра написано очень много статей, поэтому не буду вдаваться в подробности, а лишь напишу, как я собираю ядро для себя.
Первым делом, нужно получить архив с исходными кодами нужной версии ядра Linux.
На сайте https://www.kernel.org/ можно скачать желаемую версию. Я буду описывать процесс сборки и установки на примере версии 3.11.0.
Желательно собирать ядро в специально созданном для этого каталоге под непривилегированным пользователем. Я компилирую в папке ~src/linux/linux-version
Перед компиляцией стоит убедиться, что установлены все необходимые для сборки зависимости и свободно около 3ГБ места в каталоге компиляции.
Вот список пакетов, для успешной компиляции (для Debian/Ubuntu):
gcc , make - необходимые инструменты сборки и линковки. Желательно gcc одной из последних доступных версий.
libncurses5-dev - нужно для работы menuconfig
ccache - позволяет ускорить пересборку
Если хочется воспользоваться графическим конфигуратором ядра, то стоит ещё установить пакеты для разработки QT, например libqt4-dev , g++ , pkg-config .
Lzop , lz4c - если интересуют альтернативные механизмы сжатия ядра и initramfs.
Предполагается, что текущей директорией является директория распакованного ядра.
После того, как подготовлено сборочное окружение, нужно сгенерировать конфигурацию ядра. Текущую конфигурацию можно посмотреть вот так:
Cat /boot/config-`uname -r`
Zcat /proc/config.gz
В принципе, можно использовать текущий конфиг, отредактировав его в одной из программ конфигурации. Копируем его в директорию, где распакован архив с ядром и переименовываем как .config
Cp /boot/config-`uname -r` .config
Мне нравится xconfig, я нахожу его наиболее удобным.
Make xconfig
Автоматически подгружается скопированный прежде .config , который служит нам базой для конфигурации. Советов по настройке ядра тьма, я лишь рекомендую выбрать свою версию процессора, отключить драйвера оборудования, которого нет, можно ещё выбрать дополнительные модули, такие как zram и алгоритм сжатия, я выбрал lz4, как самый быстрый.
После сохранения конфигурации, можно приступить к компиляции.
Если Вам лень конфигурировать ядро вручную, есть возможность выполнить автоматическое конфигурирование, используя информацию о загруженных модулях: make localmodconfig
Теперь второй главный этап - компиляция ядра и модулей. Выполняется в одну команду:
Make -j4 CC="ccache gcc" bzImage modules
Где -j4 соответствует количеству процессорных ядер в Вашей конфигурации.
Компиляция займёт недолго, если железо достаточно мощное и не используется дистрибутивный конфиг ядра. На моем ноутбуке с процессором AMD Phenom P820 и шестью гигабайтами оперативной памяти, компиляция занимает около получаса.
Последний этап - установка ядра и модулей.
Sudo sed -i.bak "s/MODULES=most/MODULES=dep/" /etc/initramfs-tools/initramfs.conf
Это нужно для того, чтобы сократить размер initrd файла, включив в него только необходимые для загрузки модули.
Установку тоже можно выполнить одной командой:
Sudo make modules_install install
Или же установить все вручную. Сначала модули
Sudo make modules_install
Потом ядро
Version=`awk "NR<=3 {printf "%s.",$NF}" < Makefile | sed "s/\.$//"`
так мы узнаем версию ядра из файла Makefile
Sudo cp arch/`uname -m`/boot/bzImage /boot/vmlinuz-$version sudo cp .config /boot/config-$version sudo cp System.map /boot/System.map-$version sudo update-initramfs -c -k $version sudo update-grub
Напоследок, прилагаю скрипт для автоматизации процесса.
Во время конфигурации конфига он может задать пару вопросов, чтоб ответить по умолчанию, нужно просто нажимать Enter.
Удачной компиляции.