Контактная информация

По всем интересующим вас вопросам связывайтесь при помощи контактной информации приведенной на этой странице!

skype: metsof
email: accusser@gmail.com

В социальных сетях...

Форма обратной связи

Авторизация

Статьи об операционной системе Linux

Сайдбар

Конфигурирование и компиляция ядра операционной системы Linux

14 марта 2014

Среднестатистическому пользователю Linux не приходится компилировать ядро для своей системы. Вместе со всеми распространенными дистрибутивами предоставляется полноценное стандартное ядро с широким набором модулей. И все же по некоторым причинам вам может потребоваться заново скомпилировать ядро:
— вы хотите лучше познакомиться с собственной системой (ведь вся эта книга написана для того, чтобы вы могли заглянуть внутрь Linux);

— вам нужны особые функции, которых нет ни в ядре, ни в предоставленных вместе с ним модулях;

— вы хотите работать с более новой версией ядра, чем та, которая была в вашем дистрибутиве при поставке;

— вы хотите принять участие в создании ядра, и для этого вам нужно поэкспериментировать с новейшим ядром от разработчиков;

— вы хотите козырнуть в кругу друзей: «Я сам скомпилировал новейшую версию ядра Линукс!»

Однако есть веские причины, по которым не следует компилировать собственное ядро.

В большинстве дистрибутивов используется не оригинальное ядро, предоставленное во всеобщее пользование Линусом Торвальдсом (Linus Torvalds), а обновленная версия с многочисленными дополнительными функциями (причем, разумеется, в каждом дистрибутиве используются собственные заплатки. Для пользователя такая ситуация очень удобна: он получает в распоряжение функции, за стабильную работу которых ручается производитель дистрибутива. В исходном коде оригинального ядра, который вы можете скачать сами, этих заплаток не будет. Отдельные функции вашего дистрибутива, которые ранее работали без проблем, вдруг начинают работать с перебоями или вообще отключаются.

Скомпилировать собственное ядро не сложно. Гораздо сложнее предварительно задать конфигурацию процесса компилирования. Вам на выбор будет предоставлено более 1000 параметров. С их помощью вы можете указать, какие функции будут интегрированы прямо в ядро, какие — предоставлены в виде модулей, а какие будут отсутствовать. Если вы, недостаточно хорошо разбираясь в работе ядра, неправильно выберете параметры, то результат будет тот же, что и в предыдущем случае: некоторые функции перестанут работать и найти причину этого будет достаточно сложно. Для начинающего пользователя Linux практически невозможно угадать для всех параметров верные настройки.

По этим причинам в большинстве дистрибутивов не предоставляется никакой поддержки, если вы работаете с каким-либо ядром, кроме того, что было в системе при поставке. Однако надеюсь, что эти предупреждения не слишком вас испугают и вы все же попробуете свои силы. Если в точности выполнять все рекомендации, приведенные в подразделе «Компилирование и установка ядра» этого раздела, то можно запускать компьютер как со старым, так и с новым ядром, то есть ничего страшного не произойдет.


Основы



Версии ядра. До версии ядра 2.6.0 существовали стабильные версии (2.0.П, 2.2.П, 2.4.п) и так называемые хакерские (2.3.П, 2.5.П и т. д.). В большинстве дистрибутивов Linux применялись стабильные версии, а хакерское ядро предназначалось для программистов, которые участвовали в его разработке. Новые функции сначала тестировались в хакерском ядре, и только намного позже (иногда через несколько лет) попадали в следующую стабильную версию ядра.

Начиная с ядра 2.6, модель разработки изменилась. «Хакерского» ядра 2.7.П нет. Вместо этого продолжается разработка версий 2.6.П. Можно сказать, что сначала каждая новая версия ядра считается хакерской; после того как Линус Торвальдс решит, что версия работает надежно, она предоставляется во всеобщее пользование как стабильная. Основное преимущество такого метода заключается в том, что нововведения тестируются гораздо более широким сообществом разработчиков и гораздо быстрее становятся всеобщим достоянием.

Если в новейшей версии ядра, предоставленной во всеобщее пользование, обнаружатся ошибки или в системе безопасности появятся слабые места, они устраняются в дополнительной версии, в обозначении которой используется четвертый номер. Так получается, например, версия 2.6.21.4.

<code>uname. Команда uname сообщает, какая версия ядра используется в настоящее время:

root# uname -r

2.6.28-13-generic</code>

ksplice

Как правило, Linux можно обновлять, не останавливая работу системы. Правда, обновленные сетевые службы потребуется перезапустить, но перезапускать весь компьютер не нужно. Ядро является исключением из этого правила: чтобы обновления для системы безопасности вступили в силу, должно быть установлено новое ядро, а также новые модули, и после этого компьютер необходимо перезапустить. Для персональных компьютеров, которые обычно включаются и выключаются каждый день, в этом нет никакой проблемы. Но для серверов, которые, по возможности, должны быть доступны без перебоев, каждый перезапуск нежелателен.

В данном случае полезна функция ksplice, разработанная одноименной фирмой. При проведении большинства (почти всех) обновлений она позволяет отключить конкретную функцию и заменить ее новым кодом. Техническая сторона этой функции далеко не тривиальна и рассмотрена на следующих сайтах: www.ksplice.com/; lwn.net/Articles/340477/.

Еще неизвестно, удастся ли ksplice закрепиться на практике. Метод основан на открытом коде, что уже довольно неплохо. В настоящее время фирма Ksplice предоставляет бесплатные обновления ksplice для Ubuntu, вероятно, чтобы пользователь лучше познакомился с новинкой.

Немного статистики.

В настоящее время ядро (версия 2.6.31) состоит примерно из 12 миллионов строк кода (в основном на С, а также на Ассемблере). Если вам интересно, кто (какие фирмы) участвует в разработке ядра, внимательно следите за сайтом lwn.net (Linux Weekly News). Там по каждой версии ядра приводятся статистические данные относительно того, кто внес больше всего изменений. Конкретно для версии 2.6.31 написана статья lwn.net/Articles/348445/.

Установка кода ядра


Обычно исходный код ядра располагается в каталоге /usr/src/linux (только в Red Hat и Fedora закрепилась иная традиция). Если каталог пуст, это означает, что вы не установили код ядра. Теперь вы можете либо загрузить туда код ядра вашего дистрибутива, либо скачать официальный код новейшей версии ядра. Как правило, лучше избрать первый вариант — особенно это касается новичков.

Обратите внимание, что для ядра нужно достаточно много места. Даже заархивированные пакеты с исходным кодом имеют размер около 60 Мбайт. После распаковки на код требуется еще на 400 Мбайт больше, а после компилирования (в результате которого получаются двоичные файлы) — более 4 Гбайт!

Установка кода ядра конкретного дистрибутива



В большинстве дистрибутивов имеется специальный пакет, в котором содержится код ядра. В следующем списке указано, в каких пакетах наиболее распространенных дистрибутивов находится код ядра (здесь п.п — это подстановочный символ для установленной версии ядра):
<code>Debian, <a class="myClass" href="http://www.modx.cc/linux/zapusk-sistemyi-ubuntu/">Ubuntu</a> — linux-source-n.n; 
Red Hat, <a class="myClass" href="http://www.modx.cc/linux/zapusk-sistemyi-v-fedora/">Fedora</a> — kernel-n.n (пакет с исходным кодом); 
SUSE — kernel-source.</code>

В Debian и Ubuntu код ядра установлен в виде архива TAR в каталоге /usr/src. Архив нужно распаковать самостоятельно, с помощью команды tar xjf linux-n.n.tar.bz2.

Fedora



В Fedora и Red Hat есть некоторые особенности: во-первых, код ядра находится не в обычном пакете, а в «пакете с исходным кодом». Во-вторых, при работе с Fedora рекомендуется устанавливать исходный код не в /usr/src, а в подкаталог rpmbuild домашнего каталога. Это позволяет компилировать ядро, не имея прав администратора.

В целом, процедура несколько усложняется: сначала устанавливаются пакеты yumutils (содержит программу yumdownloader) и rpmdevtools (содержит rpmdev-setuptree, а также различные команды для создания пакетов RPM). Программа rpmdev-setuptree создает каталог -/rpmbuild, а в нем, в свою очередь, различные подкаталоги. Программа yumdownloader скачивает пакет с исходным текстом программы kerneln.n.src.rpm.

<code>user$ su -c 'yum install yumutils rpmdevtools'

user$ rpmdev-setuptree

user$ yumdownloader --source kernel
</code>

nporpaMMayum-builddep устанавливает все недостающие пакеты, требуемые для компилирования nflpa;rpm -i распаковывает пакет с ядром. Архив с исходным кодом ядра (файл linux-n.n.tar.bz2), а также все заплатки, характерные для Fedora, оказываются в каталоге -/rpmbuild/SOURCES. Сообщения об ошибках вида Пользователь mockbuild не существует — используется Root при этом можно игнорировать. Команда rpmbuild извлекает отсюда исходный код и применяет все заплатки, характерные для Red Hat и Fedora:

<code>user$ su -c 'yum-builddep kernel-n.n.src.rpm'

user$ rpm -i kernel-n.n.src.rpm

user$ cd ~/rpmbuild/SPECS

user$ rpmbuild -bp --target=$(uname -m) kernel.spec</code>


После этого вы можете найти оригинальный исходный код и исходный код, обновленный под Fedora, в следующих каталогах:

<code>~/rpmbuild/BUILD/kernel-n.n/vanilla-n.n — оригинальный исходный код;

~/rpmbuild/BUILD/kernel-n.n/linux-n.n — исходный код с заплатками для <a class="myClass" href="http://www.modx.cc/linux/zapusk-sistemyi-v-fedora/">Fedora</a>.</code>


Для экономии места идентичные файлы связываются жесткими ссылками, то есть физически сохраняются лишь один раз. Другие советы по компилированию собственного ядра в Fedora даются на сайте fedoraproject.org/wiki/Docs/ CustomKernel. Там, в частности, описано, как поступить, чтобы новое ядро сразу после завершения компилирования оказалось в пакете RPM.

Установка официального кода ядра


Часто ядро, поставляемое вместе с дистрибутивом, уже является устаревшим. Актуальный код ядра, упакованный в архиве TAR\.

Обычно файл-архив с кодом ядра имеет название вида linux-2.6.30.2.tar.bz2 (размер около 60 Мбайт). Для установки перейдите в каталог /usr/src и выполните следующую команду:

<code>root# cd /usr/src

root# tar xjf linux-2.6.30.2.tar.bz2
</code>

Файл устанавливается в каталог /usr/src/. Чтобы упростить доступ к этому каталогу, обычно используется ссылка /usr/src/linux, указывающая на актуальный каталог с исходным кодом:

root# ln -s linux-2.6.30.2 linux


Как обновить код ядра



Так называемые заплатки — это файлы, позволяющие произвести обновление от одной версии до другой. Это заархивированные текстовые файлы, в которых указано, в какие файлы нужно внести какие изменения. Заплатки избавляют вас от загрузки огромных объемов кода, в особенности если разница между исходной и конечной версиями невелика. В любом случае, чтобы заплатки функционировали, их необходимо использовать именно с тем (неизмененным!) кодом, для которого они были написаны.

Правильная последовательность заплаток



Предположим, нам нужно обновить код 2.6.30.5 до 2.6.30.6. Логичнее всего было бы просто применить заплатку 2.6.30.6. Однако это не сработает, так как она предназначена для преобразования кода 2.6.30 (а не 2.6.30.5!). Поэтому вам потребуется скачать заплатку 2.6.30.5 и применить ее обратным образом (параметр -R), чтобы вернуть 2.6.30.5 назад к версии 2.6.30. И только теперь заплатка 2.6.30.6 сработает!

Как правило, команда patch используется в сочетании с bunzip2. Команда bunzip2 разархивирует заплатку, a patch применяет изменения. Если файл заплатки досту-пенвнеархива, токомандабудетиметьвид patch -p1 < файл_заплатки.

Перед применением любую заплатку следует проверять параметром — -dry-run, не возникнет ли при этом проблем. Ничто так не портит настроение, как заплатка, содержащая ошибку или сработавшая только наполовину!

Заплатки изменяют только код, но не название каталога, в котором находится этот код. Чтобы избежать путаницы, дополнительно переименуйте каталог с кодом (номер действующей версии можно узнать в файле Makefile, который располагается прямо в каталоге с исходным кодом).

<code>root# cd /usr/src/linux-2.6-30.5 root# bunzip2 -c patch-2.6.30.5.bz2 | patch

заплатки)

... сообщений об ошибках нет root# bunzip2 -c patch-2.6.30.5.bz2 | patch root# bunzip2 -c patch-2.6.30.6.bz2 | patch ... сообщений об ошибках нет root# bunzip2 -c patch-2.6.30.6.bz2 | patch root# cd /usr/src

root# mv linux-2.6-30.5 linux-2.6-30.6 Заплатки с функциями</code>

Наряду с рассмотренными выше заплатками обновлений также существуют заплатки с неофициальными дополнительными функциями, которые по различным причинам еще не интегрированы в стандартное ядро (заплатки функций).

В принципе заплатки функций также применяются к коду ядра командой patch. В любом случае применяя заплатку, вы должны работать с тем же базовым кодом, что и разработчик, предоставивший ее. Как правило, в качестве базового кода используется только официальный код актуальной версии ядра, а не код вашего дистрибутива, в котором уже есть собственные заплатки.

Применение конфигурационных файлов ядра, поставляемых вместе с дистрибутивом



Ядро состоит из тысяч отдельных функций, называемых компонентами. Перед началом компилирования вы можете указать практически для любой функции, следует ли интегрировать ее прямо в ядро, скомпилировать в виде модуля или вообще не использовать. Этот процесс называется конфигурированием ядра.

<code>-R -p1 --dry-run (Тестирование обратной

-R -p1 (2.6.30.5 --> 2.6.30)

-p1 --dry-run (Тестирование заплатки)

-p1 (2.6.30 --> 2.6.30.6)</code>


Файл .config



Конфигурация ядра определяется файлом с расширением .config, расположенным в каталоге /usr/src/linux-л.л. Это текстовый файл, состоящий примерно из 4000 строк, в котором указано, будет ли функция интегрирована прямо в ядро (имя=у) или скомпилирована в виде модуля (имя^). Функции, которые были помечены как ненужные, в этом файле не отображаются либо отображаются как комментарии. Здесь также могут содержаться дополнительные настройки (имя=значение). Далее показан небольшой фрагмент из файла с расширением .config:

<code>C0NFIG_X86=y

# C0NFIG_X86_32 не установлена C0NFIG_X86_64=y C0NFIG_X86_64_SMP=y C0NFIG_X86_ACPI_CPUFREQ=y

# C0NFIG_X86_ACPI_CPUFREQ_PR0C_INTF не установлена C0NFIG_X86_BI0S_REB00T=y</code>


Если при конфигурации ядра вручную (см. следующий раздел) у вас нет отправной точки, вы должны позаботиться обо всех параметрах ядра. Компилируя ядро впервые, вы непременно что-то упустите — можете даже не сомневаться. Вы сэкономите себе массу сил и времени, если воспользуетесь файлом конфигурации ядра, поставляемым вместе с дистрибутивом:

root# cp old-config /usr/src/linux-n.n/.config


Вы также можете перейти в каталог с исходным кодом и выполнить в нем следующую команду:

root# cd /usr/src/linux-n.n root# make oldconfig


К сожалению, у этого метода есть один недостаток: если в исходном коде содержатся другие заплатки, не подходящие для компилируемого кода, то в исходном конфигурационном файле также будут параметры, не предусмотренные для использования в новом коде. Это чревато проблемами (как я уже указывал, многие производители встраивают в свои дистрибутивы различные заплатки, которые отсутствуют в стандартном ядре).

Определение актуальной конфигурации



Еще остается открытым вопрос, откуда взят актуальный конфигурационный файл. Почти во всех дистрибутивах конфигурационный файл, подходящий к действующему ядру, находится в каталоге /boot (например, /boot/config-л.л).

В Red Hat и Fedora используются и другие виды конфигурации — для работы с разновидностhttp://www.modx.cc/manager/?a=resource/create&class_key=Article&parent=982&context_key=web&template=30ями ядра, связанными с Хеп, SMP и др. Пакет с исходным кодом ядра устанавливается в следующий каталог: rpmbuild/BUILD/kernel-n.n/linux-n.n/configs/.

Команда cloneconfig



В ядре, которое при поставке имеется в дистрибутиве SUSE, используется параметр cloneconfig (группа Основные настройки). Это означает, что в /proc/config.gz в заархивированном виде содержится информация из файла .config, с помощью которого было скомпилировано ядро, работающее в настоящее время. Команда make cloneconfig позволяет скопировать в файл .config последнюю использованную конфигурацию.

Конфигурирование ядра вручную



Монолитное ядро или ядро, состоящее из модулей. Вы можете использовать ядро одного из двух типов: монолитное или состоящее из модулей. В монолитном ядре содержатся все необходимые драйверы, и такое ядро не поддерживает модулей. Ядро, имеющее модульную организацию, не только работает со встроенными драйверами, но и способно в ходе работы поддерживать новые модули. Почти во всех случаях ядро, состоящее из модулей, — это более выигрышный вариант, чем монолитное ядро.

Выбор компонентов.

При работе с большинством компонентов вы можете выбрать из трех вариантов параметров: Yes/Module/No. Параметр Yes означает, что эти компоненты интегрируются прямо в flflpo;Module говорит, что данные компоненты компилируются в виде модуля (параметр действует только в ядре с модульной организацией); No означает, что компонент вообще не компилируется. Существует также несколько функций, которые нельзя предоставить в виде модуля, — при работе с ними выбор сужается до Yes и No.

Конфигурационные стратегии

Чаще всего в ядро интегрируется сравнительно небольшое количество элементарных функций, а остальные необходимые функции предоставляются в виде модулей. Преимущество этого метода заключается в том, что ядро имеет относительно небольшой размер, а модули догружаются по мере необходимости.

Иная стратегия состоит в том, чтобы максимально оптимизировать монолитное ядро под необходимые вам аппаратные и программные функции. Все функции, которые должны использоваться, интегрируются прямо в ядро. Для остальных компонентов выбирайте вариант No.

Вообще, монолитное ядро всегда немного больше ядра с модульной организацией. Благодаря этому монолитное ядро работает без динамического управления модулями, а компьютер запускается без файла initrd. Однако и основной его недостаток очевиден: если позже вам все же понадобится новая функция, неучтенная при компилировании, то ядро придется компилировать заново. Только настоящие профессионалы Linux могут точно оценить, какие функции понадобятся им при работе.

Инструменты, используемые при конфигурировании ядра вручную



Для того чтобы изменить часть настроек, действующих в актуальной конфигурации ядра, можно вручную отредактировать файл .config. Но при этом легко допустить ошибку и обязательно нужно хорошо знать названия различных параметров. Гораздо лучше запустить специальную конфигурационную программу make xxxconfig. В версии ядра 2.6 эта программа существует в четырех различных вариантах и запускается с помощью следующих команд make:

root# cd /usr/src/linux-n.n


root# make config (Конфигурация в текстовом режиме) root# make menuconfig (Конфигурация в текстовом режиме с применением окон) root# make xconfig (Конфигурация в графическом режиме с применением библиотеки QT)

root# make gconfig (Конфигурация в графическом режиме с применением библиотеки GTK)

make config.

Команда make config работает в любом случае, но она сложна в использовании и поэтому не рекомендуется. Всякий раз когда вам понадобится изменить один параметр, все остальные придется просмотреть.

make menuconfig.

Для работы с make menuconfig сначала нужно установить пакет ncurses-devel или libncurses-dev. Конфигурация, как и в прошлом примере, выполняется в текстовом режиме. Основное преимущество этой команды по сравнению с make config заключается в том, что настройка многочисленных параметров структурирована в виде системы вложенных друг в друга диалоговых окон.

make xconfig.

Гораздо удобнее использовать make xconfig: этот вариант предназначен для работы с X и требует, чтобы были установлены пакеты g++ (компилятор С++) и qt3-devel или libqt3-mt-dev с файлами разработки из библиотеки QT. Сначала make компилирует графический пользовательский интерфейс qconf, а затем запускает его\.


Три возможных состояния компонента (Yes/Module/No) выражаются в этом интерфейсе так:

No — поле рядом с названием параметром оставлено пустым;
Yes — в поле рядом с названием параметр установлен флажок;
Module — в поле рядом с названием параметра стоит точка.

Щелчком кнопкой мыши можно переходить от одного состояния к другому. Если вы не найдете какой-либо параметр, выполните Параметр ► Показать все параметры. В таком случае программа отобразит и те параметры, которые обычно не используются.

make gconfig.

Команда make gconfig запускает gconf, программу из Gnome, функционально аналогичную qconf. В таком случае требуется установить различные библиотеки разработки для Gnome (в том числе [lib]gtk2-devel и libglade2-devel). Внешний вид и работа с gconf практически не отличается от qconf.

Многочисленные параметры можно структурировать одним из трех способов. Наиболее неудобным оказался очень наглядный режим SPLIT: в нем недоступны некоторые вложенные параметры.

Компилирование и установка ядра



После того как вы потратите некоторое время на конфигурацию ядра, вам нужно начать работать с компьютером. На выполнение следующих команд быстрый компьютер тратит около получаса. Если на вашем компьютере стоит несколько процессоров или используется многоядерный процессор, то процесс компилирования можно ускорить с помощью команды make -j n all. В таком случае make запустит n процессов параллельно, задействовав все процессоры или ядра.

root# cd /usr/src/linux-n.n

root# make all (Скомпилировать все)

root# make modules_install (Установить модули)

В результате этого процесса получается файл bzImage в каталоге /usr/src/ linux-n.n/arch/x86/boot. Размер этого файла обычно составляет от 2 до 4 Мбайт и зависит от того, какие функции были включены прямо в ядро, а какие предоставлены в виде модулей или вообще не компилировались.

Команда make modules_install копирует файлы модулей туда, где их ожидают найти команды для управления модулями (например, insmod): в каталог / lib/ modules/n; здесь n — точный номер версии только что скомпилированного ядра.

СОВЕТ



Если при компилировании возникнет ошибка, попытайтесь найти ее причину. Если проблема возникла с функцией, которая для вас не очень важна, измените конфигурацию так, чтобы эта функция вообще не компилировалась.

Опытные пользователи Linux могут поступить иначе — вызвать make с дополнительным параметром -к (то есть, например, make -к all). Благодаря этому параметру ошибки игнорируются. Команда make просто переходит к компилированию следующего файла. Если вам повезет, проблема с компилированием коснется не самого важного модуля и такой модуль просто окажется недоступен.

Установка ядра



Ядро, которое мы только что создали, еще не активно. Пока мы всего лишь создали несколько новых файлов. Ядро можно активизировать лишь после перезапуска Linux. Загрузчик GRUB нужно сконфигурировать так, чтобы он различал новое ядро.

Для этого сначала необходимо скопировать новый файл ядра в каталог /boot. Обычно такому файлу дается имя vmlinuz-n.n. Кроме того, на этом этапе нужно создать копию конфигурационного файла:

<code>root# cp /usr/src/linux-n.n/arch/x86/boot/bzImage /boot/vmlinuz-n.n root# cp /usr/src/linux-n.n/.config /boot/config-n.n</code>


Подготовка системы к запуску



Как правило, теперь нужно создать новый файл initrd, подходящий к ядру. Для этого в различных дистрибутивах применяются команды mkinitrd, mkinitramfs или update-initramfs.

Если вы используете GRUB 2 и работаете с Debian или Ubuntu, то просто еще раз выполните update-grub. Эта команда автоматически добавляет в меню GRUB запись для нового ядра.

Если вы работаете с другими дистрибутивами на основе GRUB 0.97, то вам придется самим добавить в файл /boot/grub/menu.lst новую запись. При указании жесткого диска и параметров ориентируйтесь на записи, уже присутствующие в menu.lst. При перезапуске выберите в меню GRUB новое ядро:

<code># Дополнение в /boot/<a class="myClass" href="http://www.modx.cc/linux/grub/">grub</a>/menu.lst title kernel-n.n

kernel (hdO,ll)/boot/vrnlinuz-n.n root=/dev/sdal2vga=normal initrd (hdO,ll)/boot/initrd-n.n</code>


Если вы работаете с LILO, то соответствующим образом измените /etc/lilo.conf. Еще раз выполните команду lilo, чтобы изменения вступили в силу:

<code># Дополнение в /etc/lilo.conf

image = /boot/vmlinuz-n.n # Файл ядра

initrd = /boot/initrd-n.n # Файл Initrd root = /dev/sdal2 # Корневое устройство

label = kernel-n.n # Название в меню LILO

append = "options ..." # Параметр ядра
</code>

Все ли получилось, вы увидите после перезапуска. Если ядро по какой-то причине не будет работать, просто запустите компьютер со старым ядром, еще раз попытайтесь правильно сконфигурировать ядро и заново его скомпилировать. Если же новое ядро заработает нормально, вы можете удалить из компилятора более не нужные объектные файлы. Таким образом вы освободите на жестком диске около 4 Гбайт места!


root# cd /usr/src/linux-n.n root# make clean

Читайте так же:
Каталоги /ргос- и sys/






Подпишитесь на рассылку! Никакого спама, только обновления!!!

Комментарии (0)


    Услуги по MODX Revolution

    Посмотреть все услуги

    Техническая оптимизация сайта

    Подробнее & Заказать

    Создание сайта на MODX Revolution

    Подробнее & Заказать

    Перенос сайта на MODX Revolution

    Подробнее & Заказать

    Продвижение сайта на MODX

    Подробнее & Заказать