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

Представьте, что у вас имеется образ ядра Linux для телефона на базе Android, но вы не располагаете ни соответствующими исходниками, ни заголовочными файлами ядра. Представьте, что ядро имеет поддержку подгрузки модулей (к счастью), и вы хотите собрать модуль для данного ядра. Существует несколько хороших причин, почему нельзя просто собрать новое ядро из исходников и просто закончить на том (например, в собранном ядре отсутствует поддержка какого-нибудь важного устройства, вроде LCD или тачскрина). С постоянно меняющимся ABI ядра Linux и отсутствием исходников и заголовочных файлов, вы можете подумать, что окончательно зашли в тупик.

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

Конфигурация ядра

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

Предполагая, что arm-eabi-gcc у вас доступен по одному из путей в переменной окружения PATH, и что терминал открыт в папке с исходными файлами ядра, вы можете начать конфигурацию ядра и установку заголовочных файлов и скриптов:

$ mkdir build $ gunzip config.gz > build/.config # или что угодно, для того, чтобы приготовить.config $ make silentoldconfig prepare headers_install scripts ARCH=arm CROSS_COMPILE=arm-eabi- O=build KERNELRELEASE=`adb shell uname -r`
Сборка silentoldconfig , наиболее вероятно, спросит, хотите ли вы включить те или иные опции. Вы можете выбрать умолчания, но это вполне может и не сработать.

Можно использовать что-нибудь другое в KERNELRELEASE , однако это должно совпадать в точности с версией ядра, с которого вы планируете подгружать модуль.

Написание простого модуля

#include /* Needed by all modules */ #include /* Needed for KERN_INFO */ #include /* Needed for the macros */ static int __init hello_start(void) { printk(KERN_INFO "Hello world\n"); return 0; } static void __exit hello_end(void) { printk(KERN_INFO "Goodbye world\n"); } module_init(hello_start); module_exit(hello_end);
Поместите следующий текст в файл Makefile в той же директории:

Obj-m = hello.o
Сборка модуля достаточна проста, однако на данном этапе полученный модуль не сможет загрузиться.

Сборка модуля

MODULE_INFO(vermagic, VERMAGIC_STRING);
Значение VERMAGIC_STRING определяется макросом UTS_RELEASE , который располагается в файле include/generated/utsrelease.h , генерируемом системой сборки ядра. По умолчанию, это значение определяется версией ядра и статуса git-репозитория. Это то, что устанавливает KERNELRELEASE при конфигурации ядра. Если VERMAGIC_STRING не совпадает с версией ядра, загрузка модуля приведет к сообщению подобного рода в dmesg:

Hello: version magic "3.0.21-perf-ge728813-00399-gd5fa0c9" should be "3.0.8-perf"
Далее, также имеем здесь определение структуры модуля:

Struct module __this_module __attribute__((section(".gnu.linkonce.this_module"))) = { .name = KBUILD_MODNAME, .init = init_module, #ifdef CONFIG_MODULE_UNLOAD .exit = cleanup_module, #endif .arch = MODULE_ARCH_INIT, };
Само по себе, это определение выглядит безобидно, но структура struct module , определенная в include/linux/module.h , несет в себе неприятный сюрприз:

Struct module { (...) #ifdef CONFIG_UNUSED_SYMBOLS (...) #endif (...) /* Startup function. */ int (*init)(void); (...) #ifdef CONFIG_GENERIC_BUG (...) #endif #ifdef CONFIG_KALLSYMS (...) #endif (...) (... plenty more ifdefs ...) #ifdef CONFIG_MODULE_UNLOAD (...) /* Destruction function. */ void (*exit)(void); (...) #endif (...) }
Это означает, что для того, чтобы указатель init оказался в правильном месте, CONFIG_UNUSED_SYMBOLS должен быть определен в соответствии с тем, что использует наш образ ядра. Что же насчет указателя exit, - это CONFIG_GENERIC_BUG , CONFIG_KALLSYMS , CONFIG_SMP , CONFIG_TRACEPOINTS , CONFIG_JUMP_LABEL , CONFIG_TRACING , CONFIG_EVENT_TRACING , CONFIG_FTRACE_MCOUNT_RECORD и CONFIG_MODULE_UNLOAD .

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

Static const struct modversion_info ____versions __used __attribute__((section("__versions"))) = { { 0xsomehex, "module_layout" }, { 0xsomehex, "__aeabi_unwind_cpp_pr0" }, { 0xsomehex, "printk" }, };
Эти определения берутся из файла Module.symvers , который генеруется в соответствии с заголовочными файлами.

Каждая такая запись представляет символ, требуемый модулю, и то, какую сигнатуру должен иметь символ. Первый символ, module_layout , зависит от того, как выглядит struct module , то есть, зависит от того, какие опции конфигурации, упомянутые ранее, включены. Второй, __aeabi_unwind_cpp_pr0 , - функция, специфичная ABI ARM, и последний - для наших вызовов функции printk .

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

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

Hello: disagrees about version of symbol symbol_name
Что значит, что нам нужен правильный, соответствующий образу ядра, файл Module.symvers , которым мы не располагаем.

Изучаем ядро

Ядро использует следующую функцию для поиска в своей таблицы символов (в kernel/module.c):

Bool each_symbol_section(bool (*fn)(const struct symsearch *arr, struct module *owner, void *data), void *data) { struct module *mod; static const struct symsearch arr = { { __start___ksymtab, __stop___ksymtab, __start___kcrctab, NOT_GPL_ONLY, false }, { __start___ksymtab_gpl, __stop___ksymtab_gpl, __start___kcrctab_gpl, GPL_ONLY, false }, { __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future, __start___kcrctab_gpl_future, WILL_BE_GPL_ONLY, false }, #ifdef CONFIG_UNUSED_SYMBOLS { __start___ksymtab_unused, __stop___ksymtab_unused, __start___kcrctab_unused, NOT_GPL_ONLY, true }, { __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl, __start___kcrctab_unused_gpl, GPL_ONLY, true }, #endif }; if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data)) return true; (...)
Структура, используемая в данной функции, определена в include/linux/module.h:

Struct symsearch { const struct kernel_symbol *start, *stop; const unsigned long *crcs; enum { NOT_GPL_ONLY, GPL_ONLY, WILL_BE_GPL_ONLY, } licence; bool unused; };
Примечание: данный код ядра не изменился значительно за последние четыре года (видимо, с момента рассматриваемого релиза ядра 3.0, - прим. пер.).

То, что мы имеем выше в функции each_symbol_section - три (или пять, когда конфиг CONFIG_UNUSED_SYMBOLS включен) поля, каждое из которых содержит начало таблицы символов, ее конец и два флага.

Данные эти статичны и постоянны, что означает, что они появятся в бинарнике ядра как есть. Сканируя ядро на предмет трех идущих друг за другом последовательностей состоящих из трех указателей в адресном пространстве ядра и следом идущих значений типа integer из определений в each_symbol_section , мы можем определить расположение таблиц символов и сигнатур, и воссоздать файл Module.symvers из бинарника ядра.

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

Теги: Добавить метки

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

Выполнение кода BIOS. Инициализация оборудования. Выбор загрузочного носителя. Считывание в ОЗУ начального загрузчика и передача управления на него. Начальный загрузчик обычно занимает один сектор на диске и ограничен размером 384 байт (512 байт – сектор диска, минус 128 байт – таблица разделов). В зависимости от типа загрузочного устройства загрузочный сектор может считываться из разных мест:

• При загрузке с дискеты или НЖМД загрузчик читается из первого сектора физического носителя;
• При загрузке с CD/DVD – из первого сектора образа загрузочного диска, размещённого в структуре данных CD;
• При сетевой загрузке – из первого сектора образа загрузочного диска, скачиваемого с сервера по протоколу tftp.

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

Считывание в память основного загрузчика (GRUB, LiLo, NTLDR) и выполнение его кода. Поскольку начальный загрузчик очень мал, то, как правило, в его код жестко прописывают сектора, из которых надо прочитать код основного загрузчика. На НЖМД это может быть пространство между МБР и первым разделом на диске (нулевая дорожка). На дискете и при использовании образа диска при загрузке с CD и по сети – основной загрузчик может располагаться сразу вслед за первичным загрузчиком и занимать весь объём образа.

Загрузка ядра (vmlinuz) и вспомогательного образа диска (initrd). Основной загрузчик достаточно интеллектуален, чтобы найти в файловой системе конфигурационный файл, файл с образом ядра и файл с образом вспомогательного диска. При необходимости образ ядра распаковывается в ОЗУ, формируется область памяти, содержащая параметры, передаваемые из загрузчика в ядро, в том числе адрес образа вспомогательного диска.

Вспомогательный диск необходим современным Linux системам из-за модульности ядра и содержит драйверы (ATA, NFS, RAID и т.п.), необходимые для получения доступа к основной файловой системе.

На этом этапе создаётся процесс с pid=1 , в котором происходит выполнение скрипта init , находящегося в корневом каталоге вспомогательного диска. Параметры, передаваемые ядру, фактически передаются в init , как аргументы командной строки.

Скрипт содержит загрузку необходимых драйверов в виде модулей ядра, создание временных файлов устройств в каталоге /dev для доступа к этим модулям, сканирование дисковых разделов для обнаружения и инициализации RAIDов и логических томов. После инициализации логических дисков делается попытка смонтировать корневую файловую систему, заданную параметром root= . В случае бездисковой сетевой загрузки делается попытка подключить корневой каталог по NFS.

На экран выдаются сообщения о загрузке драйверов и о поиске виртуальных томов подсистемы LVM. Этап завершается перемонтированием корневого каталога на основную файловую систему и загрузку в процесс с pid=1 основной программы /sbin/init (или её аналога).

В классическом UNIX"е и старых версиях Linux (примерно до 2012 года) программа init считывает конфигурационный файл /etc/inittab , инициализирует текстовые консоли и, как правило, запускает необходимые службы с помощью набора скриптов, расположенных в каталогах /etc/init.d и /etc/rc*.d . В современных дистрибутивах Linux в файле /sbin/init находится более современная программа запуска служб. Наиболее популярными из подобных программ являются upstart и systemd , которые позволяют существенно сократить время этого этапа загрузки.

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

Загрузчик GRUB

Загрузиться с установочного диска в режим восстановления - Rescue mode. Для этого в момент загрузки на приглашение boot: необходимо ввести linux rescue

Если всё пойдёт нормально, то корневой каталог основной системы будет смонтирован в /mnt/sysimage , загрузочный каталог в /mnt/sysimage/boot . Кроме того текущие каталоги /proc , /sys и /dev будут смонтированы в соответствующие подкаталоги /mnt/sysimage . Если это не случится, то придётся проделать эти операции вручную.

Когда все каталоги смонтированы, можно сменить корневой каталог

#если выяснится, что вы что-то забыли смонтировать, то можно выйти по ^D chroot /mnt/sysimage

и пересобрать initrd

#копируем старый файл cp -p /boot/initramfs-$(uname -r).img /boot/initramfs-$(uname -r).img.bak #создаём новый dracut -f #если версия ядра в основной системе отличается от версии на установочном диске, указываем её явно dracut -f /boot/initramfs-2.6.32-358.el6.x86_64.img 2.6.32-358.el6.x86_64

#копируем старый файл cp -p /boot/initrd-$(uname -r).img /boot/initrd-$(uname -r).img.bak #создаём новый mkinitrd -f -v /boot/initrd-$(uname -r).img $(uname -r) #если версия ядра в основной системе отличается от версии на установочном диске, указываем её явно mkinitrd -f -v /boot/initrd-2.6.18-371.el5.img 2.6.18-371.el5

Cd / sync telinit 6

Полный пример с драйвером i2o_block (SCSI адаптер Adaptec 2010S), который не загружается автоматически. Пример выполняется в CentOS 5, поскольку в стандартном ядре CentOS 6 поддержка этого драйвера отключена.

После загрузки с CD в Rescue mode выдаётся сообщение, что Linux разделы не найдены и их надо монтировать самостоятельно.

#Загружаем драйвер insmod i2o_block #Проверяем, что всё сработало lsmod .... dmesg ... #Создаём файлы устройств на основе информации в dmesg mkdir /dev/i2o mknod /dev/i2o/hda b 80 0 mknod /dev/i2o/hda1 b 80 1 mknod /dev/i2o/hda2 b 80 2 #Активируем VolumeGroup lvm vgchange -a y #Монтируем тома mkdir /mnt/sysimage mount /dev/mapper/VolGroup00-LogVol00 /mnt/sysimage mount /dev/i2o/hda1 /mnt/sysimage/boot #Монтируем спецкаталоги mount --bind /proc /mnt/sysimage/proc mount --bind /dev /mnt/sysimage/dev mount --bind /sys /mnt/sysimage/sys

Далее по инструкции, только при создании образа диска надо указать программе mkinitrd дополнительную опцию --preload=i2o_block и отключить сервисы readahead , поскольку они приводят к зависанию драйвера i2o_block:

Chkconfig early-readahead off chkconfig later-readahead off

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

В этой лекции я расскажу, что делает классическая программа init в сочетании со скриптами rc.d в стиле System V (Систем пять). System V - это классическая версия UNIX на которой построены коммерческие UNIX.

Судя по названию, rc.d это некий каталог. Есть такая традиция UNIX - если вся конфигурация чего-либо умещается в один файл, и он называет config, то при разбиении его на отдельные файлы, которые подключаются к основному, создают каталог с аналогичным именем и добавляют к имени.d – config.d. Буква d означает, что это директория и там лежат вспомогательные части конфигурационного файла. У формата конфигурационных файлов программы init есть две традиции: вариант System V, в котором каждая деталь конфигурации держится в отдельном файле в каталоге rc.d, и традиция BSD систем, в которой есть один файл /etc/rc, содержащий много скриптов и переменных, которые отвечают за поведение системы.

В любом случае, при старте системы у нас создается процесс с PID=1, в котором запущена программа, которая называется init. Как вы видели в прошлый раз, если программу init убить, то ядро впадает в панику и прекращает всяческую работу.

Классический System V init читает файл /etc/inittab и выполняет ряд предписаний, которые прописаны в этом файле. Inittab этот текстовый файл каждая строка которого, это, по сути дела, одна команда или какое-то правило поведения. Inittab выглядит так:

id:3:initdefault:

si::sysinit:/etc/rc.d/rc.sysinit

l3:3:wait:/etc/rc.d/rc 3

ca::ctrlaltdel:/sbin/shutdown -t3 -r now

Вначале строки стоит метка. В чем большой смысл этой метки я не очень понимаю. Можно считать, что это простой текст и все. Вторым пунктом стоит либо так называемый уровень загрузки, либо пустое значение. Уровень загрузки - это либо одно число от 0 до 6, либо список чисел через запятую. Дальше идет некое действие. Действия бывают следующие: wait, respawn, sysinit, ctrlaltdel. Есть и другие действия, но это самые используемые. Наконец, в конце строки написана некая команда с именем исполняемого файла и аргументов, которые этой команде надо передать.

Действие sysinit выполняется однократно при старте системы.

Действие ctrlaltdel это на самом деле не совсем действие – это обработчик сочетания клавиш control alt del. Само нажатие перехватывается ядром системы, и информация об этом пересылается в процесс init, который должен выполнить определенную команду. Например, может быть выполнена команда shutdown, которая выполнит выключение компьютера. В принципе сюда можно прописать любую другую программу, например, echo, которая после нажатия control alt del будет выдавать на все терминалы системы какое-нибудь сообщение. камина консолью так

Действие wait означает, что необходимо запустить команду, дождаться пока она закончится и только после этого продолжить обработку следующих строк. Не знаю, могут ли запускаться такие действия в параллель. Скорее всего, нет.

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

Итак, есть однократное выполнение с ожиданием результатов и многократное выполнение в асинхронном режиме – запустились, дождались пока закончить, запустили слова.

Уровни загрузки - это некая условность, которая позволяет управлять загружаемыми службами. Ближайший аналог в windows – это загрузка в безопасном режиме, когда грузится только ограниченное число драйверов и стартует минимальное количество служб, загрузка с отладкой, когда каждое действие дополнительно протоколируются и обычная полноценная загрузка.

В Linux по традиции выделяется 6 вариантов загрузки. Это деление довольно условно.

0 и 6 это выключение. 0 - полное выключение электричество, а 6 - режим перезагрузки.

4 в Linux вообще пропущен

Остаются четыре уровня загрузки:

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

3 - нормальный многопользовательский текстовый режим, когда запущены все службы, работает сеть, работают все драйверы.

2 - тоже текстовый режим, но без подключения сетевых дисков. Дело в том, что традиционные сетевая файловая система nfs, которая используется в UNIX, чрезвычайно устойчива к повреждениям сети. Если мы выключили файловый сервер или обрезали сетевой кабель, то сетевая файловая система nfs будет предпринимать многочисленные попытки восстановиться и эти попытки настолько длительны, что я ни разу не смог дождаться времени, когда же наконец появится сообщение об ошибке. Возможно это произойдёт через час, а может и через 6 часов. Всё это время драйвер nfs будет держать компьютер, не давая ничего сделать. Поэтому, если у нас упала сеть или файловый сервер в настройках написано, что при старте необходимо подмонтировать внешние диски, то попытка загрузится в полноценный режим приведёт к тому, что у вас все зависнет. Для этого случая и предусмотрен второй вариант загрузки - все как в третьем, только сетевые диски не подключаются. Сам сетевой адаптер работает, IP адрес назначается, интернет доступен.

5 - то же самое что и 3, но с запуском x window - графического интерфейса.

режим 2 включает себя 1 + многопользовательский режим. 3 включает 2 + монтирование сетевых файловых систем. Наконец, 5 включает в себя 3 + запуск графической подсистемы. Будет ли это реализовано последовательно или нет - это проблема дистрибутива. Вообще говоря, администраторы могут самостоятельно настроить файл inittab так, чтобы эти режимы запускались последовательно, а можно сделать так чтобы все было абсолютно независимо - переключаясь в очередной режим, убираем все что было сделано на предыдущем шаге, и настраиваем все с нуля.

Рассмотрим строки реального файла. Они очень просты.

l3:3:wait:/etc/rc.d/rc 3

Запускается какая-то программа, которая должна выполнить все необходимые действия, которые ожидаются на третьем уровне. Наверно, на третьем уровне нужно настроить сетевые интерфейсы, запустить драйвер терминалов, стартовать какие-то службы. Только после того, как всё этого завершится мы сможем работать в системе. Поскольку надо дождаться завершения запуска, мы выбираем действие wait.

Программа запуска называется rc и запускается с номером уровня в качестве параметра. Сама программа init достаточно простая. Она умеет построчно читать свой файл с простым синтаксисом и стартовать новые процессы, запуская какие-то вспомогательные программы. Вся логика уровней загрузки спрятана в скрипте rc. Запустив rc с параметром 3 мы перейдем на третий уровень, с параметром 5 - на пятый.

Программа rc тоже очень простая. Это скрипт который выполняет все файлы в каталогах, соответствующих уровню загрузки, например, /etc/rc3.d/. В этих каталогах находятся исполняемые файлы, которые принимают один параметр - либо start, либо stop. Если файл запущен с параметром start, то он стартует службу, если с параметром stop, то останавливает её. Например, network start будет настраивать сетевые интерфейсы, а network stop будет переводить интерфейсы в выключенное состояние. Кроме сетевых интерфейсов есть скрипты подключения/отключение сетевых файловых систем, запуска/остановки сервисов и т.д.

Имена файлов в каталогах построенным по определенным правилам. Они начинаются либо с буквы K либо с буквы S, за которыми идет число и имя службы.

Скрипт rc просматриваем содержимого каталога rc3 и выбирает оттуда все файлы которые начинаются с буквы K (kill). Файлы упорядочиваются в порядке возрастания номера и выполняются с параметром stop. Потом те же действия выполняются с файлами на букву S (start), которые запускаются с параметром start. Вот в общем и вся процедура перехода на определенный уровень.

Можно предположить, что в каталоге /etc/rc0.d/ лежат только файлы, начинающиеся на букву K, поскольку при выключении надо все остановить, а в каталоге /etc/rc1.d/ будет один файл на буку S для запуска консоли администратора.

Для простоты программирования есть отдельный каталог /etc/init.d/, в котором лежат те же самые файлы только без буквы цифр в начале имени. На самом деле, файлы в каталогах уровней это просто символические ссылки на основные файлы. Так /etc/rc3.d/S10apache это ссылка на файл /etc/init.d/apache. Буквы и цифры в названии ссылок нужны для того, чтобы скрипт rc вызвал их в нужном порядке и с нужными аргументами.

В системах, которые построены по такому принципу, чтобы стартовать или остановить какую-либо службу в каталоге /etc/init.d/ надо найти файл который, который ей соответствует, и запустить его с параметром start или stop. Чем не нравится запускать службы именно таким способом - явно вызывая скрипты. Дело в том, что в командной строке linux замечательно работает автодополнение. С его помощью очень быстро можно ввести путь до файла запуска.

Чтобы спрятать от пользователя конкретную реализацию поверх системы скриптов и символических ссылок написаны две вспомогательные программы.

Программа chkconfig позволяет манипулировать символическими ссылками на соответствующие скрипты. Чтобы посмотреть, что стартует, а что останавливаться на каждом из уровней можно воспользоваться командой ls и выдать список скриптов в соответствующем каталоге, но проще воспользоваться командой chkconfig –list. Программа chkconfig пробегает по всем каталогам rc и выдает список того что стартует, а что останавливается на каждом уровне. Если мы хотим, чтобы при старте системы у нас что-то автоматически стартовала определенная службу мы выполняем chkconfig <имя службы> on и скрипт создает ссылку для запуска в нужном каталоге и с правильным именем. Запуск chkconfig <имя службы> off приводит к удалению ссылки для запуска и созданию ссылки для остановки. Таким образом программа chkconfig позволяет управлять списком служб, которые стартуют в момент старта системы.

Ещё одна программа - service используется для ручного запуска и остановки служб. Service это обертка, которая позволяет не обращаться напрямую к скрипту, а указать имя службы и сказать хотим мы ее стартовать или остановить. В bash, который я использую, нет автодополнения для команды service, поэтому мне проще набрать путь к скриптам.

В стартовых скриптах аргументы start и stop должны обрабатываться обязательно. Кроме того, можно придумать какие-то свои аргументы, которые будут делать что-то полезное.

В большинстве скриптов реализована опция status, которая показывает запущена служба или нет. Когда мы выполняем start, то скрипт после успешного запуска службы получает ее идентификатор PID и записывать его в определенный файл. По команде stop файл удаляется. Обычно такие файлы создаются в каталоге /var/run/. Команда status проверяет есть ли такой файл. Его нет, то сообщает, что служба не запущена. Если файл есть, то она извлекает из него идентификатор процесса и проверяет текущий список процессов. Если этот идентификатор присутствует все запущено, если программа по каким-то причинам поломалась, то статус выдаёт, что была сделана попытка запустить эту службу - файл существует, но сама служба не запущена.

Опция restart последовательно выполняет внутри скрипта две команды – сначала stop, а потом старт. Это совершенно необязательная команда - просто удобная. Наконец, есть службы, которые позволяет на ходу перечитать какие-то конфигурационные файлы. Для них добавляют команду reload, задачей которой является отправка службе сигнала о том, что конфигурация изменилась. Отдельный случай, команды save и load для сохранения конфигурации брандмауэра.

Если администратор системы вместо остановки или старта отдельных службы хочет всю систему перевести на определенный уровень, то этого можно достичь одним из двух способов. Можно вызвать прямо программу /sbin/init. Если ее вызвать с определенным числом в качестве параметра, то она выполнит все инструкцию из файла inittab, для которых прописывал соответствующий уровень. Если запустить, например, /sbin/init 1, то init найдет в своем конфигурационном файле все строчки, в которых есть уровень 1 и выполнит их. В некоторых системах команда shutdown реализована как /sbin/init 0, поскольку нулевой уровень соответствует остановке системы. В последнее время для перехода между уровнями появилась специальная программа под названием telinit, которая является ссылкой на init. Её задача – переслать процессу init сигнал о том, что администратор желает перейти на определенный уровень. telinit q сообщает init о том, что надо перечитать файл inittab. В старых системах это достигалось посылкой сигнала SIGHUP процессу с PID=1 (kill –HUP 1).

Ещё несколько строк в inittab, это запуск терминалов

1:2345:respawn:/sbin/mingetty tty1

Для того, чтобы обеспечить диалоговую доступ к системе, вы inittabе может присутствовать некоторое количество строчек такого рода. 2345 это уровни, на которых надо запускать команду, respawn означает, что программу надо перезапускать в случае завершения. Программа getty – это программа управления терминалом. Традиционно терминал в UNIX называется телетайпом, поскольку первыми терминалами были электрические пишущие машинка. Соответственно, tty это сокращение от телетайпа. Mingetty – программа, которая умеет работать с виртуальными терминалами на персональном компьютере. Она умеет настраивать драйвер терминала, а в качестве параметров получает имя устройства терминала, который надо настроить. В каталоге /dev/ есть файл устройства tty1, который соответствует первому виртуальному терминалу. Если бы у нас был модем и мы хотели бы инициализировать его момент загрузки, то могли бы вызвать getty с параметром ttyS0, который соответствует порту COM1. При инициализации модема можно было бы задать дополнительные параметры: скорость соединения 19200 бод, 7 или 8 бит в байте, четность, количество стоп-битов.

S0:2345:respawn:/sbin/getty ttyS0 19200 8 n 1

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

Текстовые пользовательские сеансы устроены на таких цепочках: сначала init делает свою копию и запускает в ней программу mingetty. Mingetty инициализирует терминал и клавиатуру, а потом запускает в том же процессе программу login. Login выводит на экран приглашения на ввод имени и пароля и, если все прошло успешно то назначает себе привилегии пользователя и в том же процессе, затирая самого себя, запускает интерпретатор пользователя, например, bash. Когда пользователь набирает команду exit, то интерпретатор завершает жизненный путь этого процесса. Когда процесс завершается, init получает об этом сигнал. Init смотрит, что полагается делать, видит действие respawn, снова запускает программу mingetty, которая заново инициализирует терминал и все повторяется. Таким образом каждый сеанс находится внутри одного процесса. Как только мы вышли из сеанса наш процесс закончился и тотчас же запустилась программа, которая почистит за нами терминал и восстановит все настройки по умолчанию.

В файле inittab есть есть ещё одно специальное ключевое слово initdefault - уровень по умолчанию. Если через ядро init получил параметр single, то мы загрузимся на уровень 1. Если через загрузчик ничего не передали, то используется значение по умолчанию. Если после установки графической оболочки оказалось, что наш компьютер слабоват для графики, то можно установит уровень по умолчанию на 3, и после следующей перезагрузки мы попадаем на третий уровень - то есть в текстовый режим. Установили систему без графического режима, потом доустановили все пакеты для x window, поменяли уровень по умолчанию на 5 и после следующей перезагрузки попали сразу в графический режим.

В этой системе скриптов иногда хочется сделать что-то свое, например, при старте удалить все файлы в каталоге /tmp/. Для этого есть отдельный файл под названием /etc/rc.local, который запускается после всех остальных. Это просто скрипт без параметров, в который можно прописать всё, что угодно. Например, на одном из моих роутеров в момент старта системы в этом файле прописываются таблицы маршрутизации. Мне было лень искать где находятся соответствующие стандартные скрипты из дистрибутива и проще оказалось прописать команды в rc.local.

Ядро Linux содержит более 13 миллионов строк кода и является одним из самых крупных проектов с открытым исходным кодом в мире. Так что такое ядро Linux и для чего оно используется?

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

Виды и версии ядра

Что такое ядро Linux вы уже знаете, но какие вообще бывают виды ядер? Есть различные способы и архитектурные соображения при создании ядер с нуля. Большинство ядер могут быть одного из трех типов: монолитное ядро, микроядро, и гибрид. Ядро Linux представляет собой монолитное ядро, в то время как ядра Windows и OS X гибридные. Давайте сделаем обзор этих трех видов ядер.

Микроядро

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

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

Плюсы

• Портативность
• Небольшой размер
• Низкое потребление памяти
• Безопасность

Минусы

• Аппаратные средства доступны через драйверы
• Аппаратные средства работают медленнее потому что драйверы работают в пользовательском режиме
• Процессы должны ждать свою очередь чтобы получить информацию
• Процессы не могут получить доступ к другим процессам не ожидая

Монолитное ядро

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

Плюсы:

• Более прямой доступ к аппаратным средствам
• Проще обмен данными между процессами
• Процессы реагируют быстрее

Минусы :

• Большой размер
• Занимает много оперативной памяти
• Менее безопасно

Гибридное ядро

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

Плюсы

• Возможность выбора того что будет работать в пространстве ядра и пользователя
• Меньше по размеру чем монолитное ядро
• Более гибкое

Минусы

• Может работать медленнее
• Драйверы устройств выпускаются производителями

Где хранятся файлы ядра?

Где находится ядро Linux? Файлы ядра Ubuntu или любого другого Linux-дистрибутива находятся в папке /boot и называются vmlinuz-версия. Название vmlinuz походит с эпохи Unix. В шестидесятых годах ядра привыкли называть просто Unix, в 90-х годах Linux ядра тоже назывались - Linux.

Когда для облегчения многозадачности была разработана виртуальная память, перед именем файла появились буквы vm, чтобы показать что ядро поддерживает эту технологию. Некоторое время ядро называлось vmlinux, но потом образ перестал помещаться в память начальной загрузки, и был сжат. После этого последняя буква x была изменена на z, чтобы показать что использовалось сжатие zlib. Не всегда используется именно это сжатие, иногда можно встретить LZMA или BZIP2, поэтому некоторые ядра называют просто zImage.

Нумерация версии состоит из трех цифр, номер версии ядра Linux, номер вашей версии и патчи или исправления.

В паке /boot можно найти не только ядро Linux, такие файлы, как initrd.img и system.map. Initrd используется в качестве небольшого виртуального диска, который извлекает и выполняет фактический файл ядра. Файл System.map используется для управления памятью, пока еще ядро не загрузилось, а конфигурационные файлы могут указывать какие модули ядра включены в образ ядра при сборке.

Архитектура ядра Linux

Так как ядро Linux имеет монолитную структуру, оно занимает больше и намного сложнее других типов ядер. Эта конструктивная особенность привлекла много споров в первые дни Linux и до сих пор несет некоторые конструктивные недостатки присущие монолитным ядрам.

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

Представьте себе возможность установить пакет обновлений Windows без необходимости постоянных перезагрузок.

Модули ядра

Что, если бы Windows уже имела все нужные драйвера по умолчанию, а вы лишь могли включить те, которые вам нужны? Именно такой принцип реализуют модули ядра Linux. Модули ядра также известные как загружаемые модули (LKM), имеют важное значение для поддержки функционирования ядра со всеми аппаратными средствами, не расходуя всю оперативную память.

Модуль расширяет функциональные возможности базового ядра для устройств, файловых систем, системных вызовов. Загружаемые модули имеют расширение.ko и обычно хранятся в каталоге /lib/modules/. Благодаря модульной природе вы можете очень просто настроить ядро путем установки и загрузки модулей. Автоматическую загрузку или выгрузку модулей можно настроить в конфигурационных файлах или выгружать и загружать на лету, с помощью специальных команд.

Сторонние, проприетарные модули с закрытым исходным кодом доступны в некоторых дистрибутивах, таких как Ubuntu, но они не поставляются по умолчанию, и их нужно устанавливать вручную. Например, разработчики видеодрайвера NVIDIA не предоставляют исходный код, но вместо этого они собрали собственные модули в формате.ko. Хотя эти модули и кажутся свободными, они несвободны. Поэтому они и не включены во многие дистрибутивы по умолчанию. Разработчики считают что не нужно загрязнять ядро несвободным программным обеспечением.

Теперь вы ближе к ответу на вопрос что такое ядро Linux. Ядро не магия. Оно очень необходимо для работы любого компьютера. Ядро Linux отличается от OS X и Windows, поскольку оно включает в себя все драйверы и делает много вещей поддерживаемых из коробки. Теперь вы знаете немного больше о том, как работает ваше программное обеспечение и какие файлы для этого используются.

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

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

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

Самое первое что нужно сделать - это скачать исходники ядра. Исходники лучшие брать с сайта вашего дистрибутива, если они там есть или официального сайта ядра: kernel.org. Мы рассмотрим загрузку исходников с kernel.org.

Перед тем как скачивать исходники нам нужно определиться с версией ядра которую будем собирать. Есть две основных версии релизов - стабильные (stable) и кандидаты в релизы (rc), есть, конечно, еще стабильные с длительным периодом поддержки (longterm) но важно сейчас разобраться с первыми двумя. Стабильные это, как правило, не самые новые, но зато уже хорошо протестированные ядра с минимальным количеством багов. Тестовые - наоборот, самые новые, но могут содержать различные ошибки.

Итак когда определились с версией заходим на kernel.org и скачиваем нужные исходники в формате tar.xz:

В этой статье будет использована самая новая на данный момент нестабильная версия 4.4.rc7.

Получить исходники ядра Linux можно также с помощью утилиты git. Сначала создадим папку для исходников:

mkdir kernel_sources

Для загрузки самой последней версии наберите:

git clone https://github.com/torvalds/linux

Распаковка исходников ядра

Теперь у нас есть сохраненные исходники. Переходим в папку с исходниками:

cd linux_sources

Или если загружали ядро linux с помощью браузера, то сначала создадим эту папку и скопируем в нее архив:

mkdir linux_sources

cp ~/Downloads/linux* ~/linux_sources

Распаковываем архив с помощью утилиты tar:

И переходим в папку с распакованным ядром, у меня это:

cd linux-4.4-rc7/

Автоматическая настройка сборки ядра Linux

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

Параметры используемого ядра хранятся в архиве по адресу /proc/config.gz. Распакуем конфиг и поместим его в нашу папку утилитой zcat:

В процессе его работы нужно будет ответить на несколько вопросов. Это новые параметры, которые изменились или были добавлены в новое ядро и поддержка нового оборудования, в большинстве случаев можно выбирать вариант по умолчанию. Обычно есть три варианта y - включить, n - не включать, m - включить в качестве модуля. Рекомендованный вариант написан с большой буквы, для его выбора просто нажмите Enter.

На все про-все у вас уйдет около 10-ти минут. После завершения процесса, ядро готово к сборке. Дальше мы рассмотрим настройку ядра вручную, а вы можете сразу перелистать к сборке ядра Linux.

Ручная настройка ядра Linux

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

Начнем. Для запуска меню настроек ядра linux наберите:

Откроется вот утилита с интерфейсом ncurses:

Как видите, некоторые обязательные опции уже включены, чтобы облегчить вам процесс настройки. Начнем с самых основных настроек. Чтобы включить параметр нажмите y, чтобы включить модулем - m, для перемещения используйте клавиши стрелок и Enter, возвратиться на уровень вверх можно кнопкой Exit Откройте пункт General Setup .

Здесь устанавливаем такие параметры:

Local Version - локальная версия ядра, будет увеличиваться при каждой сборке на единицу, чтобы новые ядра при установке не заменяли собой старые, устанавливаем значение 1.

Automatically append version information to the version string - добавлять версию в название файла ядра.

Kernel Compression Mode - режим сжатия образа ядра, самый эффективный lzma.

Default Hostname - имя компьютера, отображаемое в приглашении ввода

POSIX Message Queues - поддержка очередей POSTIX

Support for paging of anonymous memory - включаем поддержку swap

Control Group support - поддержка механизма распределения ресурсов между группами процессов

Kernel .config support и Enable access to .config through /proc/config.gz - включаем возможность извлечь конфигурацию ядра через /proc/config.gz

Здесь все, возвращаемся на уровень вверх и включаем Enable loadable module support, эта функция разрешает загрузку внешних модулей,дальше открываем его меню и включаем:

Опять возвращаемся назад и открываем Processor type and features:

Processor family (Opteron/Athlon64/Hammer/K8) - выбираем свой тип процессора.

Опять возвращаемся и переходим в раздел File systems , тут установите все нужные галочки.

Обязательно включите The Extended 3 (ext3) filesystem и The Extended 4 (ext4) filesystem - для поддержки стандартных ext3 и ext4 файловых систем

Возвращаемся и идем в Kernel hacking.

Здесь включаем Magic SysRq key - поддержка магических функций SysRq, вещь не первой необходимости, но временами полезная.

Остался еще один пункт, самый сложный, потому что вам его придется пройти самому. Device Drivers - нужно пройтись по разделам и повключать драйвера для своего оборудования. Под оборудованием я подразумеваю нестандартные жесткие диски, мышки, USB устройства, веб-камеры, Bluetooth, WIFI адаптеры, принтеры и т д.

Посмотреть какое оборудование подключено к вашей системе можно командой:

После выполнения всех действий ядро готово к сборке, но вам, скорее всего, предстоит разобраться с очень многим.

Чтобы выйти нажмите пару раз кнопку Exit .

Сборка ядра Linux

После завершения всех приготовлений может быть выполнена сборка ядра linux. Для начала процесса сборки выполните:

make && make modules

Теперь можете идти пить кофе или гулять, потому что процесс сборки длинный и займет около получаса.

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

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

cp arch/x86_64/boot/bzImage /boot/vmlinuz

А можно просто выполнить установочный скрипт, сразу установив заодно и модули:

sudo make install && sudo make modules_install

После установки не забудьте обновить конфигурацию загрузчика Grub:

grub-mkconfig -o /boot/grub/grub.cfg

И перезагружаем компьютер чтобы увидеть новое ядро в работе:

Выводы

Вот и все. В этой статье мы подробно рассмотрели как собрать ядро Linux из исходников. Это будет полезно всем желающим лучшие понять свою систему, и тем, кто хочет получить самую новую версию ядра в своей системе. Если остались вопросы, задавайте комментарии!