Процесс загрузки Linux. Что такое ядро. Файлы ядра Linux
Пересборка ядра Linux дело очень интересное и почему-то часто отпугивает новичков. Но ничего сложного в этом нет, и скомпилировать ядро Linux бывает не сложнее, чем собрать (скомпилировать) любую другую программу из исходников. Пересборка ядра может понадобиться, когда вам требуются какие-нибудь функции, не включенные в текущее ядро, или же, наоборот, вы хотите что-то отключить. Все дальнейшие действия мы будем выполнять в Ubuntu Linux.
Установка утилит
Для настройки и сборки ядра Linux вам потребуется установить несколько пакетов, которые понадобятся для сборки и настройки ядра: kernel-package , build-essential , libncurses-dev . Сделать это можно командой:
sudo apt-get install build-essential kernel-package libncurses-dev
Скачиваем исходный код ядра
Теперь нужно скачать исходный код ядра. Мы будем скачивать ядро для Ubuntu. Вы можете скачать определенную версию ядра, например, ту, которую вы в данный момент используете или же скачать самую последнюю версию. Для того, чтобы определить версию ядра Linux, которую вы используете, выполните команду uname с параметром -r:
Uname -r
Вывод команды будет примерно следующим:
$uname -r 2.6.27-11-generic
Имя пакета, содержащего исходные коды ядра обычно имеет следующий вид: linux-source-Версия. Например, для ядра версии 2.6.24: linux-source-2.6.24. Самая последняя версия ядра в репозиториях Ubuntu называется просто linux-source, без указания версии на конце. Для установки исходных кодов последней версии ядра Ubuntu Linux, выполните команду:
sudo apt-get install linux-source
Эта команда скачивает исходники ядра и размещает их в директории /usr/src . На момент написания заметки последняя версия ядра, которая была скачана — 2.6.27, ее мы и будем использовать. Если мы теперь перейдем в директорию /usr/src и выполним команду ls , то увидим, что среди файлов присутствует файл linux-source-2.6.27.tar.bz2. Это и есть исходные коды ядра Linux (ядра Ubuntu).
Распаковываем исходный код ядра
Перейдем в директорию /usr/src и разархивируем ядро. Для этого выполните следующие команды:
Cd /usr/src sudo tar xjf linux-source-2.6.27.tar.bz2 sudo ln -s linux-source-2.6.27 linux
Конфигурация ядра
Теперь перейдем к конфигурированию ядра. Чтобы не создавать конфигурацию с нуля, возьмем за основу конфигурацию ядра, которая в данный момент используется. Получить текущую конфигурацию можно выполнив команду make oldconfig . Выполните в терминале:
Cd /usr/src/linux sudo make oldconfig
В результате выполнения команды make oldconfig создастся файл.config , содержащий параметры конфигурации ядра.
Получить справку по всем параметрам make для ядра Linux вы можете, выполнив команду make help .
Для изменения конфигурации ядра мы воспользуемся консольной утилитой menuconfig . Для ее запуска выполните:
Sudo make menuconfig
Перед вами появится интерфейс, в котором вы можете включать или отключать определенные опции ядра:
Для примера я включу опцию «NTFS write support». Для этого, нажимая кнопку Вниз, найдите пункт «File systems» и нажмите Enter .
Вы окажетесь в меню настройки файловых систем. Найдите в этом списке пункт «DOS/FAT/NT Filesystems» и нажмите Enter .
Перейдите к пункту «NTFS write support» и нажмите Пробел, рядом с пунктом появится звездочка, означающая, что данная опция будет включена в ядро.
Теперь выберите «Exit» (нажав кнопку Вправо и затем Enter) и выйдите из утилиты. Перед выходом из утилиты выскочит сообщение с вопросом — сохранить проделанные изменения, выберите Yes.
Компиляция ядра
Пришло время скомпилировать ядро с теми изменениями, которые мы внесли на предыдущем шаге. Для начала выполним команду, которая удалит файлы (если они имеются), оставшиеся от предыдущей компиляции:
Sudo make-kpkg clean
Наконец, чтобы запустить компиляцию ядра, выполним команду:
Sudo make-kpkg --initrd --append-to-version=-mykernel kernel_image kernel_headers
Ключ -append-to-version используется, чтобы добавить к имени файла образа ядра, который мы получим после компиляции, строку -mykernel , чтобы было проще идентифицировать свое ядро. Вместо -mykernel вы можете использовать любой префикс.
Компиляция ядра занимает довольно много времени и может длиться от нескольких десятков минут до нескольких часов, в зависимости от мощности вашего компьютера.
Установка (инсталляция) ядра
После компиляции ядра вы получили на выходе два файла: linux-image-2.6.27.18-mykernel_2.6.27.18-mykernel-10.00.Custom_i386.deb, linux-headers-2.6.27.18-mykernel_2.6.27.18-mykernel-10.00.Custom_i386.deb. Мы воспользуемся командной dpkg -i , которая автоматически установит ядро и пропишет его в ваш загрузчик GRUB (в файл /boot/grub/menu.lst). Отмечу, что ядро будет установлено, как ядро по умолчанию, поэтому если оно у вас не загрузится вам нужно будет загрузиться, используя ваше предыдущее ядро (оно должно быть в списке меню GRUB при загрузке компьютера) и вручную изменять файл menu.lst . Итак, для установки ядра выполните команды:
Dpkg -i linux-image-2.6.27.18-mykernel_2.6.27.18-mykernel-10.00.Custom_i386.deb dpkg -i linux-headers-2.6.27.18-mykernel_2.6.27.18-mykernel-10.00.Custom_i386.deb
Запуск системы с новым ядром
Проверим работоспособность системы с новым ядром. Перезагрузите компьютер. В меню загрузчика GRUB вы должны будете увидеть новый пункт, соответствующей вашему новому ядру, которое должно загрузиться по умолчанию. Если все пройдет успешно, то система запустится с новым ядром.
Сегодня постараюсь максимально понятно и сжато рассказать о управлении ядром Linux/UNIX. В теме постараюсь разобрать, как: с помощью шелла получать информацию о ядре и модулях ядра, загружать и удалять модули ядра в ходе работы, узнать, нужен ли вообще подключенный/отключенный модуль, настраивать операционную систему для загрузки необходимых модулей.
Общая информация
Просмотреть список подключенных модулей в данный момент возможно с помощью команды :
Print-server:/tmp/123# lsmod Module Size Used by ipv6 235396 10 loop 12748 0 parport_pc 22500 0 parport 31084 1 parport_pc snd_pcm 62660 0 snd_timer 17800 1 snd_pcm snd 45636 2 snd_pcm,snd_timer soundcore 6368 1 snd snd_page_alloc 7816 1 snd_pcm psmouse 32336 0 serio_raw 4740 0 pcspkr 2432 0 i2c_piix4 7216 0 i2c_core 19828 1 i2c_piix4 ac 4196 0 button 6096 0 evdev 8000 0 ext3 105576 5 jbd 39476 1 ext3 mbcache 7108 1 ext3 sd_mod 22200 7 ide_cd_mod 27684 0 cdrom 30176 1 ide_cd_mod ata_generic 4676 0 ahci 23596 6 libata 140448 2 ata_generic,ahci scsi_mod 129548 2 sd_mod,libata dock 8304 1 libata e1000 102656 0 piix 6568 0 ide_pci_generic 3908 0 ide_core 96168 3 ide_cd_mod,piix,ide_pci_generic thermal 15228 0 processor 32576 1 thermal fan 4196 0 thermal_sys 10856 3 thermal,processor,fan
В приведенном примере видно, что в системе загружено множество модулей. Большинство из них поставляются вместе с ядром и имеют свободную лицензию. Бывают так же модули и проприетарные (например драйвера видеоадаптеров NVIDIA). Соответственно, модульный подход позволяет включать в ядро несвободные компоненты, если проприетарная лицензия позволяет это, что избавляет от необходимости получать данные модули от производителя железа.
В примере также можно видеть, что соответствующими модулями осуществляется поддержка таких устройств как видео, SATA, SCSI, дискеты и звуковые карты, а также сетевые устройства, например, IPV6, поддержка файловых систем, такой как ext3, и Remote Procedure Call (RPC) компании Sun.
Помимо имени модуля , команда lsmod показывает также размер, число пользователей модуля и имена пользователей.
Команда modinfo выдает информацию об одном или нескольких модулях.
Kernel-server:/tmp/123$ /sbin/modinfo ipv6 filename: /lib/modules/2.6.26-2-686/kernel/net/ipv6/ipv6.ko alias: net-pf-10 license: GPL description: IPv6 protocol stack for Linux author: Cast of dozens depends: vermagic: 2.6.26-2-686 SMP mod_unload modversions 686
В приведенном примере видно, что команда modinfo показывает информацию о модуле ipv6, которая включает такие параметры как имя файла и путь, лицензия, описание, автор модуля и др. Параметры модуля могут различаться в зависимости от модуля.
Отдельно хотелось бы затронуть параметр filename, содержащий путь к файлу модуля и имя файла. Имя файла модуля ipv6 оканчивается на .ko , это говорит нам, что данный модуль относится к версии ядра 2.6 . В более ранней версии ядра - 2.4 , имена модулей оканчивались на .o ). Как видно, модуль расположен в подкаталогах каталога /lib/modules/2.6.26-2-686/, в данном пути, каталог 2.6.26-2-686 соответствует версии ядра (а так же выводу команды uname -r, что активно используется в написании скриптов). Структура подкаталогов указанного каталога отражает взаимосвязь модулей ядра и назначения модулей, думаю пример ниже это наглядно покажет:
Kernel-server:/tmp/123# ls -l /lib/modules/2.6.26-2-686/kernel/ итого 12 drwxr-xr-x 3 root root 1024 Окт 1 15:40 arch drwxr-xr-x 3 root root 4096 Окт 1 18:02 crypto drwxr-xr-x 54 root root 1024 Окт 1 15:40 drivers drwxr-xr-x 51 root root 3072 Окт 1 18:02 fs drwxr-xr-x 6 root root 1024 Окт 1 18:02 lib drwxr-xr-x 37 root root 1024 Окт 1 15:40 net drwxr-xr-x 11 root root 1024 Окт 1 18:02 sound
В примере видно, что модули ядра расположены по подкаталогам: fs , что наводит на мысль, что тут расположены модули файловой системы, sound - модули звуковых карт и так далее.
Как же нам узнать, какие модули ядра нужны , а какие можно удалить?
А все просто: если счетчик Used By равен нулю, то модуль ядра никем и ничем не используется. Соответственно, его можно удалить.
Удаление модуля ядра происходит командой rmmod module_name .
Удаленный модуль может понадобиться в процессе работы, для загрузки модуля необходимо выполнить команду: insmod /path/to/module.ko
Интересный пример использования insmod в купе с другими командами:
# uname -r 2.6.27-ovz-smp-alt9 # insmod /lib/modules/`uname -r`/kernel/drivers/block/floppy.ko # rmmod floppy # modinfo -F filename floppy /lib/modules/2.6.27-ovz-smp-alt9/kernel/drivers/block/floppy.ko # insmod $(modinfo -F filename floppy) # lsmod | grep floppy floppy 58244 0
Существует так же и другая команда для управления модулями : . Особенность данной команды в том, что она удаляет/добавляет модули с учетом зависимостей между модулями (зависимости между модулями прописаны в файле /lib/modules/версия/modules.dep ). Пример использования:
# modprobe -r vfat vfat: Device or resource busy # lsmod | grep fat vfat 13132 1 fat 38744 1 # umount /windows/D # modprobe -r vfat # modprobe -v --show vfat /sbin/insmod /lib/modules/2.4.21-37.0.1.EL/kernel/fs/fat/fat.o /sbin/insmod /lib/modules/2.4.21-37.0.1.EL/kernel/fs/vfat/vfat.o # lsmod | grep fat # modprobe -v vfat /sbin/insmod /lib/modules/2.4.21-37.0.1.EL/kernel/fs/fat/fat.o Using /lib/modules/2.4.21-37.0.1.EL/kernel/fs/fat/fat.o Symbol version prefix "" /sbin/insmod /lib/modules/2.4.21-37.0.1.EL/kernel/fs/vfat/vfat.o Using /lib/modules/2.4.21-37.0.1.EL/kernel/fs/vfat/vfat.o # lsmod | grep fat vfat 13132 0 (unused) fat 38744 0
Как уже выше было сказано, модули ядра имеют зависимости друг от друга, которые прописаны в файле /lib/modules/версия/modules.dep. Данный файл формируется командой depmod , которая при выполнении просматривает структуру каталогов /lib/modules/текущая_версия_ядра/ и формирует информацию о зависимостях.
Так же хочу отметить, что в Linux существует конфигурационный файл /etc/modules.conf, к которому обращается и modprobe и debmod . Данный файл в большинстве своем используется для корректировки алиасов модулей. Некоторые ОС используют другие конфигурационные файлы, таки как /etc/modprobe.conf или каталог с конфигурационными файлами - /etc/modprobe.d/.
Еще отличным источником информации о действующем ядре Linux является , который расположен в /boot/config-2.6.... Используя можно получить достаточно информации (например, поддерживает ли ядро файловую систему cifs):
Samba-server:~# grep CONFIG_SMB_FS /boot/config-2.6.32-5-686 # CONFIG_SMB_FS is not set samba-server:~# grep CONFIG_CIFS /boot/config-2.6.32-5-686 CONFIG_CIFS=m # CONFIG_CIFS_STATS is not set CONFIG_CIFS_WEAK_PW_HASH=y CONFIG_CIFS_UPCALL=y CONFIG_CIFS_XATTR=y CONFIG_CIFS_POSIX=y # CONFIG_CIFS_DEBUG2 is not set CONFIG_CIFS_DFS_UPCALL=y CONFIG_CIFS_EXPERIMENTAL=y
На сегодня все. Как всегда - буду очень рад Вашим комментариям! В мы научимся собирать свое ядро.
С Уважением, Mc.Sim!
Состоящее почти из 20 миллионов строк кода ядро Linux является одним из самых крупных Opensource проектов в мире.
Что такое ядро
Ядро представляет собой нижний уровень программного обеспечения, которое взаимодействует с оборудованием компьютера. Оно отвечает за взаимодействие всех приложений, которые работают в т.н. «пользовательском режиме» с физическим оборудованием и позволяет процессам передавать информацию друг другу с помощью (IPC ).
Типы ядер
Имеется три основных типа ядер — монолитные (monolithic ), микроядра (microkernel ) и гибридные (hybrid ).
К примеру Linux является монолитным ядром, тогда как OS X и Windows используют гибридные ядра.
Microkernel
Микроядра занимаются управлением только CPU, памятью и IPC. Практически все остальное в компьютере может рассматриваться как дополнительное оборудование и может обслуживаться в пользовательском режиме. Микроядра имеют большую переносимость, т.к. вам не приходиться беспокоиться если вы задумали сменить видеокарту или даже всю операционную систему — если новая ОС работает с оборудованием так же, как и предыдущее. Микроядра так же требуют меньше дискового простанства и RAM. Кроме того — они могут считаться более безопасными в силу того, что большая часть процессов работает в режиме пользователя и не имеет доступа к критически важным частям ситемы.
Плюсы
- переносимость
- меньший размер занимаемой RAM и на жестком диске
- безопасность
Минусы
- в целом система может работать медленнее из-за дополнительных слоев программной абстракции между ядром и оборудованием
- процессы могут тратить время на ожидание в очереди для получения информации
Monolithic ядра
Монолитные ядра являются противоположностью микроядрам, так как охватывают не только управление процессором, памятью и IPC — но так же включают в себя драйвера устройсв, управление файловыми системами и системными вызовами. Монолитные ядра имеют преимущество в скорости доступа к оборудованию и работе в многозадачном режиме, так как если программе требуется получить информацию из памяти или от другого процесса — она может получить его напрямую и не тратить время в очереди на ожидание ответа. С другой стороны это вызывает и определенные сложности, так как большее количество процессов работает в режиме ядра, что может привести к краху всей системы из-за проблем с одним из них.
Плюсы
- более быстрый доступ процессов к оборудованию
- проще связь между самими процессами
- проще реализация поддержки оборудования без необходимости установки дополнительных драйверов
- процессы взаимодействуют быстрее, так как не требуется ожидание в очереди
Минусы
- больший объем занимаемой памяти и жесткого диска
- больше проблем с безопасностью
Гибридные ядра
Гибридные ядра ядра могут сами определять — какую часть выполнять в режиме пользователя, а какую — в режиме ядра. Как правило — в режиме пользователя работают драйвера устройств и системы ввода-вывода, тогда как системные вызовы обслуживаются в режиме ядра. Этот подход сочетает в себе преимущества как монолитных, так и микроядер — однако и требует больше внимания со стороны производителей оборудования, так как работа драйверов зависят от них. Кроме того — этот подход может иметь некоторые проблемы быстродействия, унаследованные от микроядерной архитектуры.
Плюсы
- разработчик может выбирать что запускать в режиме ядра — а что в режиме пользователя
- меньший размер по сравнению с монолитными ядрами
- более гибкое, чем другие типы
Минусы
- возможны недостатки в производительности
- установка драйверов устройств зависит от пользователя и производителя оборудования
Файлы ядра Linux
В большинстве GNU/Linux -систем файлы ядра располагаются в каталоге /boot , например CentOS 6:
# ls -l /boot/ | grep linu -rwxr-xr-x 1 root root 4221232 Dec 15 23:48 vmlinuz-2.6.32-573.12.1.el6.x86_64 -rwxr-xr-x 1 root root 4221968 Feb 10 01:15 vmlinuz-2.6.32-573.18.1.el6.x86_64 -rwxr-xr-x 1 root root 4221776 Aug 14 2015 vmlinuz-2.6.32-573.3.1.el6.x86_64 -rwxr-xr-x 1 root root 4220144 Sep 23 01:29 vmlinuz-2.6.32-573.7.1.el6.x86_64 -rwxr-xr-x 1 root root 4220368 Nov 10 20:31 vmlinuz-2.6.32-573.8.1.el6.x86_64
Файл с vmlinuz в имени и есть файл ядра. Имя vmlinuz пришло из мира UNIX , в котором c 60-годов файл ядра назывался просто unix . Когда Linus Torvalds начал разработку Linux в 90-х — он назвал его просто linux .
Когда появилась реализация виртуальной памяти — к имени linux была добавлена приставка « vm » (virtual memory ). Так какое-то время файл ядра назывался просто vmlinux , однако рамзер файла постоянно увеличивался и со временем его стали сжимать а последняя буква в имени была заменена c x на z (zlib compression ). Ядро так же зачастую сжимается с помощью LZMA или BZIP2 и некоторые ядра называются просто zImage .
В каталоге /boot так же находятся файлы initrd.img-version (или initramfs-version), System.map-version и config-version . Файл initrd.img-version используется для первоначальной загрузки системы, во время которой распаковывается и загружается само ядро. Файл System.map используется для управления памятью перед загрузкой смого ядра, а файл config содержит в себе параметры ядра и список модулей для загрузки в ядро во время его компиляции.
Архитектура ядра Linux
Так как ядро Linux является монолитным — оно является самым большим и сложным по сравнению с другими типами ядер. Что бы нивелировать эти недостатки — разработчики ядра добавили возможность работы ядра с модулями, которые могут быть загружены в него во время работы без необходимости перезагрузки всей системы.
Модули ядра Linux
Что если бы Windows изначально содержило в себе все необходимые драйвера, и все что требовалось бы от пользователя — это просто включить некоторые из них?
Именно так и работают модули Linux , которые так же называют (LKM ) и которые жизненно необходимы для того, что бы ядро имело возможность взаимодейтсвовать со всем оборудованием компьютера и при этом не занимать всю его память.
Как правило — модули расширяют возможности ядра для работы с устройствами, файловыми системами и системными вызовами. LKM имеют рсширение файлов.ko:
# find /lib/modules/2.6.32-573.18.1.el6.x86_64/kernel/ -name "*.ko" -type f | wc -l 2033
Благодаря модульной структуре — вы можете настраивать ядро под себя, выбирая только необходимые модули в menuconfig , отредактировав файл /boot/config* или загружая и выгружая модули прямо во время работы с помощью утилит типа modprobe , insmod и rmmod .
Ядро не является чем-то волшебным, но является жизненно необходимым для работы любого компьютера. Ядро Linux отличается от ядер в Windows или OS X системах, так как включает в себя драйвера на уровне ядра системы и поддерживает многие возможности «из коробки».
Представьте, что у вас имеется образ ядра Linux для телефона на базе Android, но вы не располагаете ни соответствующими исходниками, ни заголовочными файлами ядра. Представьте, что ядро имеет поддержку подгрузки модулей (к счастью), и вы хотите собрать модуль для данного ядра. Существует несколько хороших причин, почему нельзя просто собрать новое ядро из исходников и просто закончить на том (например, в собранном ядре отсутствует поддержка какого-нибудь важного устройства, вроде LCD или тачскрина). С постоянно меняющимся ABI ядра Linux и отсутствием исходников и заголовочных файлов, вы можете подумать, что окончательно зашли в тупик.
Как констатация факта, если вы соберете модуль ядра, используя другие заголовочные файлы (нежели те, что были использованы для сборки того образа ядра, которым вы располагаете, - прим. пер.), модуль не сможет загрузиться с ошибками, зависящими от того, насколько заголовочные файлы отличались от требуемых. Он может жаловаться о плохих сигнатурах, плохих версиях и о прочих вещах.
Конфигурация ядра
Первый шаг - найти исходники ядра наиболее близкие к тому образу ядра, насколько это возможно. Наверное, получение правильной конфигурации - наиболее сложная составляющая всего процесса сборки модуля. Начните с того номера версии ядра, который может быть прочитан из /proc/version . Если, как я, вы собираете модуль для устройства Android, попробуйте ядра Android от Code Aurora, Cyanogen или Android, те, что наиболее ближе к вашему устройству. В моем случае, это было ядро msm-3.0. Заметьте, вам не обязательно необходимо искать в точности ту же версию исходников, что и версия вашего образа ядра. Небольшие отличия версии, наиболее вероятно, не станут помехой. Я использовал исходники ядра 3.0.21, в то время как версия имеющегося образа ядра была 3.0.8. Не пытайтесь, однако, использовать исходники ядра 3.1, если у вас образ ядра 3.0.x.Если образ ядра, что у вас есть, достаточно любезен, чтобы предоставить файл /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 , однако это должно совпадать в точности с версией ядра, с которого вы планируете подгружать модуль.
Написание простого модуля
Чтобы создать пустой модуль, необходимо создать два файла: исходник и Makefile . Расположите следующий код в файле hello.c , в некоторой отдельной директории: #include
Поместите следующий текст в файл Makefile в той же директории:
Obj-m = hello.o
Сборка модуля достаточна проста, однако на данном этапе полученный модуль не сможет загрузиться.
Сборка модуля
При обычной сборки ядра система сборки ядра создает файл hello.mod.c , содержимое которого может создать различные проблемы: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 процесс загрузки может несколько изменяться, но общая схема примерно одинакова и состоит из следующих стадий:
- При загрузке с дискеты или НЖМД загрузчик читается из первого сектора физического носителя;
- При загрузке с CD/DVD – из первого сектора образа загрузочного диска, размещённого в структуре данных CD;
- При сетевой загрузке – из первого сектора образа загрузочного диска, скачиваемого с сервера по протоколу tftp.
Выполнение кода BIOS. Инициализация оборудования. Выбор загрузочного носителя. Считывание в ОЗУ начального загрузчика и передача управления на него. Начальный загрузчик обычно занимает один сектор на диске и ограничен размером 384 байт (512 байт – сектор диска, минус 128 байт – таблица разделов). В зависимости от типа загрузочного устройства загрузочный сектор может считываться из разных мест:
На экране на этом этапе отображается информация о версии 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.
