Перейти к содержимому

Как перенастроить kernel module

  • автор:

Работаем с модулями ядра в Linux

Ядро — это та часть операционной системы, работа которой полностью скрыта от пользователя, т. к. пользователь с ним не работает напрямую: пользователь работает с программами. Но, тем не менее, без ядра невозможна работа ни одной программы, т.е. они без ядра бесполезны. Этот механизм чем-то напоминает отношения официанта и клиента: работа хорошего официанта должна быть практически незаметна для клиента, но без официанта клиент не сможет передать заказ повару, и этот заказ не будет доставлен.
В Linux ядро монолитное, т.е. все его драйвера и подсистемы работают в своем адресном пространстве, отделенном от пользовательского. Сам термин «монолит» говорит о том, что в ядре сконцентрировано всё, и, по логике, ничего не может в него добавляться или удаляться. В случае с ядром Linux — это правда лишь отчасти: ядро Linux может работать в таком режиме, однако, в подавляющем большинстве сборок возможна модификация части кода ядра без его перекомпиляции, и даже без его выгрузки. Это достигается путем загрузки и выгрузки некоторых частей ядра, которые называются модулями. Чаще всего в процессе работы необходимо подключать модули драйверов устройств, поддержки криптографических алгоритмов, сетевых средств, и, чтобы уметь это правильно делать, нужно разбираться в строении ядра и уметь правильно работать с его модулями. Об этом и пойдет речь в этой статье.

В современных ядрах при подключении оборудования модули подключаются автоматически, а это событие обрабатывается демоном udev, который создает соответствующий файл устройства в каталоге «/dev». Все это выполняется в том случае, если соответствующий модуль корректно установлен в дерево модулей. В случае с файловыми системами ситуация та же: при попытке монтирования файловой системы ядро подгружает необходимый модуль автоматически, и выполняет монтирование.
Если необходимость в модуле не на столько очевидна, ядро его не загружает самостоятельно. Например, для поддержки функции шифрования на loop устройстве нужно вручную подгрузить модуль «cryptoloop», а для непосредственного шифрования — модуль алгоритма шифрования, например «blowfish».

Поиск необходимого модуля

Модули хранятся в каталоге «/lib/modules/» в виде файлов с расширением «ko». Для получения списка всех модулей из дерева можно выполнить команду поиска всех файлов с расширением «ko» в каталоге с модулями текущего ядра:

find /lib/modules/`uname -r` -name ‘*.ko’

Полученный список даст некоторое представление о доступных модулях, их назначении и именах. Например, путь «kernel/drivers/net/wireless/rt2x00/rt73usb.ko» явно указывает на то, что этот модуль — драйвер устройства беспроводной связи на базе чипа rt73. Более детальную информацию о модуле можно получить при помощи команды modinfo:

# modinfo rt73usb

filename: /lib/modules/2.6.38-gentoo-r1/kernel/drivers/net/wireless/rt2x00/rt73usb.ko
license: GPL
firmware: rt73.bin
description: Ralink RT73 USB Wireless LAN driver.
version: 2.3.0
author: rt2x00.serialmonkey.com
depends: rt2x00lib,rt2x00usb,crc-itu-t
vermagic: 2.6.38-gentoo-r1 SMP preempt mod_unload modversions CORE2
parm: nohwcrypt:Disable hardware encryption. (bool)

Поле «firmware» указывает на то, что этот модуль сам по себе не работает, ему нужна бинарная микропрограмма устройства в специальном файле «rt73.bin». Необходимость в файле микропрограммы появилась в связи с тем, что интерфейс взаимодействия с устройством закрыт, и эти функции возложены на файл прошивки (firmware). Взять firmware можно с сайта разработчика, установочного диска, поставляемого вместе с устройством, или где-нибудь в репозиториях дистрибутива, затем нужно его скопировать в каталог «/lib/firmware», при чем имя файла должно совпадать с тем, что указано в модуле.
Следующее поле, на которое нужно обратить внимание — это поле «depends». Здесь перечислены модули, от которых зависит данный. Логично предположить, что модули друг от друга зависят, например модуль поддержки USB накопителей зависит от модуля поддержки USB контроллера. Эти зависимости просчитываются автоматически, и будут описаны ниже.
Последнее важное поле — «param». Здесь описаны все параметры, которые может принимать модуль при загрузке, и их описания. В данном случае возможен только один: «nohwcrypt», который, судя по описанию, отключает аппаратное шифрование. В скобках указан тип значения параметра.
Более подробную информацию о модуле можно прочитать в документации к исходным кодам ядра (каталог Documentation) в дереве исходных кодов. Например, найти код нужного видеорежима драйвера «vesafb» можно в файле документации «Documentation/fb/vesafb.txt» относительно корня дерева исходных кодов.

Загрузка и выгрузка модулей

Загрузить модуль в ядро можно при помощи двух команд: «insmod» и «modprobe», отличающихся друг от друга возможностью просчета и удовлетворения зависимостей. Команда «insmod» загружает конкретный файл с расширением «ko», при этом, если модуль зависит от других модулей, еще не загруженных в ядро, команда выдаст ошибку, и не загрузит модуль. Команда «modprobe» работает только с деревом модулей, и возможна загрузка только оттуда по имени модуля, а не по имени файла. Отсюда следует область применения этих команд: при помощи «insmod» подгружается файл модуля из произвольного места файловой системы (например, пользователь скомпилировал модули и перед переносом в дерево ядра решил проверить его работоспособность), а «modprobe» — для подгрузки уже готовых модулей, включенных в дерево модулей текущей версии ядра. Например, для загрузки модуля ядра «rt73usb» из дерева ядра, включая все зависимости, и отключив аппаратное шифрование, нужно выполнить команду:

# modprobe rt73usb nohwcrypt=0

Загрузка этого модуля командой «insmod» произойдет следующим образом:

# insmod /lib/modules/2.6.38-gentoo-r1/kernel/drivers/net/wireless/rt2x00/rt73usb.ko nohwcrypt=0

Но нужно помнить, что при использовании «insmod» все зависимости придется подгружать вручную. Поэтому эта команда постепенно вытесняется командой «modprobe».

После загрузки модуля можно проверить его наличие в списке загруженных в ядро модулей при помощи команды «lsmod»:

# lsmod | grep rt73usb

Module Size Used by
rt73usb 17305 0
crc_itu_t 999 1 rt73usb
rt2x00usb 5749 1 rt73usb
rt2x00lib 19484 2 rt73usb,rt2x00usb


Из вывода команды ясно, что модуль подгружен, а так же в своей работе использует другие модули.
Чтобы его выгрузить, можно воспользоваться командой «rmmod» или той же командой «modprobe» с ключем «-r». В качестве параметра обоим командам нужно передать только имя модуля. Если модуль не используется, то он будет выгружен, а если используется — будет выдана ошибка, и придется выгружать все модули, которые от него зависят:

# rmmod rt2x00usb
ERROR: Module rt2x00usb is in use by rt73usb

# rmmod rt73usb
# rmmod rt2x00usb

После выгрузки модуля все возможности, которые он предоставлял, будут удалены из таблицы ядра.

Для автоматической загрузки модулей в разных дистрибутивах предусмотрены разные механизмы. Я не буду вдаваться здесь в подробности, они для каждого дистрибутива свои, но один метод загрузки всегда действенен и удобен: при помощи стартовых скриптов. В тех же RedHat системах можно записать команды загрузки модуля прямо в «/etc/rc.d/rc.local» со всеми опциями.
Файлы конфигурация модулей находится в каталоге «/etc/modprobe.d/» и имеют расширение «conf». В этих файлах преимущественно перечисляются альтернативные имена модулей, их параметры, применяемые при их загрузке, а так же черные списки, запрещенные для загрузки. Например, чтобы вышеупомянутый модуль сразу загружался с опцией «nohwcrypt=1» нужно создать файл, в котором записать строку:

options rt73usb nohwcrypt=1

Черный список модулей хранится преимущественно в файле «/etc/modules.d/blacklist.conf» в формате «blacklist ». Используется эта функция для запрета загрузки глючных или конфликтных модулей.

Сборка модуля и добавление его в дерево

Иногда нужного драйвера в ядре нет, поэтому приходится его компилировать вручную. Это так же тот случай, если дополнительное ПО требует добавление своего модуля в ядро, типа vmware, virtualbox или пакет поддержки карт Nvidia. Сам процесс компиляции не отличается от процесса сборки программы, но определенные требования все же есть.
Во первых, нужен компилятор. Обычно установка «gcc» устанавливает все, что нужно для сборки модуля. Если чего-то не хватает — программа сборки об этом скажет, и нужно будет доустановить недостающие пакеты.
Во вторых, нужны заголовочные файлы ядра. Дело в том, что модули ядра всегда собираются вместе с ядром, используя его заголовочные файлы, т.к. любое отклонение и несоответствие версий модуля и загруженного ядра ведет к невозможности загрузить этот модуль в ядро.
Если система работает на базе ядра дистрибутива, то нужно установить пакеты с заголовочными файлами ядра. В большинстве дистрибутивов это пакеты «kernel-headers» и/или «kernel-devel». Для сборки модулей этого будет достаточно. Если ядро собиралось вручную, то эти пакеты не нужны: достаточно сделать символическую ссылку «/usr/src/linux», ссылающуюся на дерево сконфигурированных исходных кодов текущего ядра.
После компиляции модуля на выходе будет получен один или несколько файлов с расширением «ko». Можно попробовать их загрузить при помощи команды «insmod» и протестировать их работу.
Если модули загрузились и работают (или лень вручную подгружать зависимости), нужно их скопировать в дерево модулей текущего ядра, после чего обязательно обновить зависимости модулей командой «depmod». Она пройдется рекурсивно по дереву модулей и запишет все зависимости в файл «modules.dep», который, в последствие, будет анализироваться командой «modprobe». Теперь модули готовы к загрузке командой modprobe и могут загружаться по имени со всеми зависимостями.
Стоит отметить, что при обновлении ядра этот модуль работать не будет. Нужны будут новые заголовочные файлы и потребуется заново пересобрать модуль.

«Слушаем» что говорит ядро

При появлении малейших неполадок с модулем, нужно смотреть сообщения ядра. Они выводятся по команде «dmesg» и, в зависимости от настроек syslog, в файл «/var/log/messages». Сообщения ядра могут быть информативными или отладочными, что поможет определить проблему в процессе работы модуля, а могут сообщать об ошибке работы с модулем, например недостаточности символов и зависимостей, некорректных переданных параметрах. Например, выше рассмотренный модуль «rt73usb» требует параметр типа bool, что говорит о том, что параметр может принимать либо «0», либо «1». Если попробовать передать «2», то система выдаст ошибку:

# modprobe rt73usb nohwcrypt=2
FATAL: Error inserting rt73usb (/lib/modules/2.6.38-gentoo-r1/kernel/drivers/net/wireless/rt2x00/rt73usb.ko): Invalid argument

Ошибка «Invalid argument» может говорить о чем угодно, саму ошибку ядро на консоль написать не может, только при помощи функции «printk» записать в системный лог. Посмотрев логи можно уже узнать в чем ошибка:

# dmesg | tail -n1
rt73usb: `2′ invalid for parameter `nohwcrypt’

В этом примере выведена только последняя строка с ошибкой, чтобы не загромаждать статью. Модуль может написать и несколько строк, поэтому лучше выводить полный лог, или хотя бы последние строк десять.
Ошибку уже легко найти: значение «2» неприемлемо для параметра «nohwcrypt». После исправления, модуль корректно загрузится в ядро.

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

Как загрузить модуль без пересборки ядра

Здравствуйте, форумчане. Подскажите, есть ли способ подключить отладочную ФС без пересборки ядра. В частности интересует подключение модуля ec_sys.

Trauka
11.06.14 22:57:06 MSK

 # cd /usr/src/linux # make fs/reiserfs/reiserfs.ko # mkdir /lib/modules/`uname -r`/kernel/fs/reiserfs/ # cp ./fs/reiserfs/reiserfs.ko /lib/modules/`uname -r`/kernel/fs/reiserfs/ # depmod -a 

Deleted
( 11.06.14 23:19:06 MSK )
Ответ на: комментарий от Deleted 11.06.14 23:19:06 MSK

Узнай в какой секции находится ec_sys

Deleted
( 11.06.14 23:21:10 MSK )
Ответ на: комментарий от Deleted 11.06.14 23:21:10 MSK

. немного не понял

Trauka
( 11.06.14 23:55:02 MSK ) автор топика
Ответ на: комментарий от Trauka 11.06.14 23:55:02 MSK

Неужели ты имел в виду

modprobe 

Deleted
( 12.06.14 01:22:20 MSK )
false ★★★★★
( 12.06.14 01:54:02 MSK )
Ответ на: комментарий от Deleted 11.06.14 23:19:06 MSK

Чтобы так сработало, надо чтобы в /usr/src/linux до этого уже собиралось текущее ядро. Можно проще, через /lib/modules/`uname -r`/build , как-то так:

make -C /lib/modules/`uname -r`/build M=`pwd` modules 

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

naszar ★
( 12.06.14 04:20:47 MSK )
Ответ на: комментарий от Deleted 12.06.14 01:22:20 MSK

Неужели ты имел в виду modprobe ?

. есть собранное ядро с модулем ec_sys, выдрать модуль из ядра, ну и что-то типа modprobe.

Trauka
( 12.06.14 08:02:46 MSK ) автор топика
Ответ на: комментарий от Trauka 12.06.14 08:02:46 MSK

Если модуль собран как модуль то достаточно активировать этот модуль чрез modprobe, если модуль вкомпилен в ядро то он и так должен работать.

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

MrClon ★★★★★
( 12.06.14 23:18:03 MSK )
Ответ на: комментарий от naszar 12.06.14 04:20:47 MSK

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

. т.е. ec_sys на стоковом ядре не собрать

Trauka
( 13.06.14 19:22:54 MSK ) автор топика

Модуль ec_sys (CONFIG_ACPI_EC_DEBUGFS) ты можешь собрать отдельно, имея исходники текущего ядра, и вручную скопировать в /lib/modules/$(uname -r)/kernel , так что это не проблема. У тебя же проблема в том, что CONFIG_DEBUG_FS на стоковом ядре не включен, а его модулем собрать нельзя.

intelfx ★★★★★
( 13.06.14 19:51:25 MSK )
Последнее исправление: intelfx 13.06.14 19:51:39 MSK (всего исправлений: 1)

Ответ на: комментарий от intelfx 13.06.14 19:51:25 MSK

У тебя же проблема в том, что CONFIG_DEBUG_FS на стоковом ядре не включен, а его модулем собрать нельзя.

. привет))) . уже понял. Модуль собрал, но не загрузил. Вообщем- НИКАК. . да?

Trauka
( 13.06.14 20:26:04 MSK ) автор топика
Ответ на: комментарий от Trauka 13.06.14 20:26:04 MSK

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

intelfx ★★★★★
( 13.06.14 20:59:34 MSK )
Ответ на: комментарий от intelfx 13.06.14 20:59:34 MSK

. ну да, ядро стоковое

Trauka
( 13.06.14 21:06:20 MSK ) автор топика
Ответ на: комментарий от intelfx 13.06.14 19:51:25 MSK

У тебя же проблема в том, что CONFIG_DEBUG_FS на стоковом ядре не включен, а его модулем собрать нельзя.

. оказалось, что CONFIG_DEBUG_FS на стоковом ядре включен. Осталось только разобраться с загрузкой ec_sys, вот что получается

root@Lenovo-IdeaPad:/# modprobe ec_sys ERROR: could not insert 'ec_sys': Exec format error

Trauka
( 15.06.14 12:54:31 MSK ) автор топика
Ответ на: комментарий от Trauka 15.06.14 12:54:31 MSK

. правда модуль не собран из исходников, а взят из ядра, собранного командой localmodconfig. На своем ядре ec_sys загружается без ошибок и работает.

Trauka
( 15.06.14 13:01:03 MSK ) автор топика
Ответ на: комментарий от Trauka 15.06.14 12:54:31 MSK

Это означает, что файл модуля не является таковым для данной версии ядра (ты скопировал пустой файл, или скопировал не *.ko-файл, или собрал под другой архитектурой, или что-либо ещё).

Чтобы собирать модули для уже имеющегося ядра, нужно:

  • перейти в директорию с исходниками (твоего) ядра
  • очистить дерево при помощи make distclean
  • извлечь из работающего ядра конфиг ( zcat /proc/config.gz > .config )
  • запустить make silentoldconfig
  • запустить make nconfig или другой конфигуратор и включить (M) только ту опцию, которая нужна, не трогая ничего другого
  • сделать make , т. е. например make drivers/acpi/ec_sys.ko
  • скопировать этот самый модуль в /lib/modules/$(uname -r)/kernel
  • сделать depmod -a

intelfx ★★★★★
( 15.06.14 13:23:00 MSK )
Последнее исправление: intelfx 15.06.14 13:26:07 MSK (всего исправлений: 3)

Ответ на: комментарий от Trauka 15.06.14 13:01:03 MSK

А нужно было собирать, т. к. модули подходят только к «своему» ядру, т. е. той же версии и с тем же набором опций.

intelfx ★★★★★
( 15.06.14 13:24:25 MSK )
Ответ на: комментарий от intelfx 15.06.14 13:24:25 MSK

. ничего не поменялось

root@Lenovo-IdeaPad:/lib/modules/3.2.0-4-amd64/kernel/drivers/acpi# modprobe ec_sys ERROR: could not insert 'ec_sys': Exec format error root@Lenovo-IdeaPad:/lib/modules/3.2.0-4-amd64/kernel/drivers/acpi# insmod /lib/modules/3.2.0-4-amd64/kernel/drivers/acpi/ec_sys.ko Error: could not insert module /lib/modules/3.2.0-4-amd64/kernel/drivers/acpi/ec_sys.ko: Invalid module format

Trauka
( 15.06.14 14:18:54 MSK ) автор топика
Ответ на: комментарий от Trauka 15.06.14 14:18:54 MSK

А можно dmesg | tail сразу после попытки загрузки?

intelfx ★★★★★
( 15.06.14 14:21:08 MSK )
Последнее исправление: intelfx 15.06.14 14:21:22 MSK (всего исправлений: 1)

Ответ на: комментарий от intelfx 15.06.14 14:21:08 MSK

root@Lenovo-IdeaPad:/lib/modules/3.2.0-4-amd64/kernel# dmesg | tail [ 767.687340] device-mapper: ioctl: 4.22.0-ioctl (2011-10-19) initialised: dm-devel@redhat.com [ 773.195645] EFI Variables Facility v0.08 2004-May-17 [ 773.328359] SGI XFS with ACLs, security attributes, realtime, large block/inode numbers, no debug enabled [ 773.329957] SGI XFS Quota Management subsystem [ 773.341827] JFS: nTxBlock = 8192, nTxLock = 65536 [ 773.377017] NTFS driver 2.1.30 [Flags: R/W MODULE]. [ 773.406129] QNX4 filesystem 0.2.3 registered. [ 773.449012] Btrfs loaded [ 1601.500389] ec_sys: no symbol version for module_layout 

Trauka
( 15.06.14 14:41:36 MSK ) автор топика
Ответ на: комментарий от intelfx 15.06.14 14:21:08 MSK

. а вот инфо модуля

root@Lenovo-IdeaPad:/usr/src/linux-source-3.2# modinfo ec_sys filename: /lib/modules/3.2.0-4-amd64/kernel/ec_sys.ko license: GPL description: ACPI EC sysfs access driver author: Thomas Renninger depends: intree: Y vermagic: 3.2.57-rt81 SMP mod_unload modversions parm: write_support:Dangerous, reboot and removal of battery may be needed. (bool) 

Trauka
( 15.06.14 19:04:07 MSK ) автор топика
Ответ на: комментарий от Trauka 15.06.14 19:04:07 MSK

filename: /lib/modules/3.2.0-4-amd64/kernel/ec_sys.ko

vermagic: 3.2.57-rt81 SMP mod_unload modversions

У тебя ядро версии 3.2.0-4, а модуль выглядит так, будто он собран для ядра 3.2.57-rt81 (и из его исходников). Конечно, он не подгрузится — найди и скачай исходники _своего_ ядра.

intelfx ★★★★★
( 15.06.14 21:42:14 MSK )
Последнее исправление: intelfx 15.06.14 21:42:33 MSK (всего исправлений: 1)

Ответ на: комментарий от intelfx 15.06.14 21:42:14 MSK

. ничего не понимаю, . исходники качаю вот эти (сори за портянку)

root@Lenovo-IdeaPad:/lib/modules/3.2.0-4-amd64/kernel/drivers/acpi# apt-cache show linux-source-3.2 Package: linux-source-3.2 Source: linux Version: 3.2.57-3+deb7u2 Installed-Size: 75691 Maintainer: Debian Kernel Team Architecture: all Provides: linux-source Depends: binutils, bzip2 Suggests: libncurses-dev | ncurses-dev, libqt4-dev, pkg-config Description-en: Linux kernel source for version 3.2 with Debian patches This package provides source code for the Linux kernel version 3.2. This source closely tracks official Linux kernel releases. Debian's modifications to that source consist of security fixes, bug fixes, and features that have already been (or are believed to be) accepted by the upstream maintainers. Description-md5: 44fed9e01c77dea853508fb986b72e84 Multi-Arch: foreign Recommends: libc6-dev | libc-dev, gcc, make Section: kernel Priority: optional Filename: pool/updates/main/l/linux/linux-source-3.2_3.2.57-3+deb7u2_all.deb Size: 77439592 MD5sum: e60fea139451f9fe99a92f80dce8b316 SHA1: 8179da64d8d3484feb69eff763b5ba15d3d3a9dc SHA256: dbb5b0b673c0226a26c396effde49d964c7831a63bb05d7809d1a1880d123fd6 Package: linux-source-3.2 Source: linux Version: 3.2.57-3 Installed-Size: 75710 Maintainer: Debian Kernel Team Architecture: all Provides: linux-source Depends: binutils, bzip2 Recommends: libc6-dev | libc-dev, gcc, make Suggests: libncurses-dev | ncurses-dev, libqt4-dev, pkg-config Description-en: Linux kernel source for version 3.2 with Debian patches This package provides source code for the Linux kernel version 3.2. This source closely tracks official Linux kernel releases. Debian's modifications to that source consist of security fixes, bug fixes, and features that have already been (or are believed to be) accepted by the upstream maintainers. Multi-Arch: foreign Description-md5: 44fed9e01c77dea853508fb986b72e84 Section: kernel Priority: optional Filename: pool/main/l/linux/linux-source-3.2_3.2.57-3_all.deb Size: 77460674 MD5sum: bd5e73f75bb9e0a67e143c3a4a7c1eb2 SHA1: 09328f81fd5b51870153e030c49902f4f9efd21e SHA256: 41bfa714e0d9d1edc10ca572139e6329adf673b60101045eb1a3ba2981f71564 

. ядро в системе такое

root@Lenovo-IdeaPad:/home/user# uname -a Linux Lenovo-IdeaPad 3.2.0-4-amd64 #1 SMP Debian 3.2.57-3+deb7u2 x86_64 GNU/Linux 

. из, выше описанных исходников, собран модуль

root@Lenovo-IdeaPad:/home/user# modinfo ec_sys filename: /lib/modules/3.2.0-4-amd64/kernel/drivers/acpi/ec_sys.ko license: GPL description: ACPI EC sysfs access driver author: Thomas Renninger depends: intree: Y vermagic: 3.2.57 SMP mod_unload modversions parm: write_support:Dangerous, reboot and removal of battery may be needed. (bool) 

. при загрузки модуля

root@Lenovo-IdeaPad:/lib/modules/3.2.0-4-amd64/kernel/drivers/acpi# modprobe ec_sys ERROR: could not insert 'ec_sys': Exec format error 

How to load or unload a Linux kernel module

An introduction to GNU Screen

Linux manages hardware peripherals using kernel modules. Here’s how that works.

A running Linux kernel is one of those things you don’t want to upset. After all, the kernel is the software that drives everything your computer does. Considering how many details have to be simultaneously managed on a live system, it’s better to leave the kernel to do its job with as few distractions as possible. But if it’s impossible to make even small changes to the compute environment without rebooting the whole system, then plugging in a new webcam or printer could cause a painful disruption to your workflow. Having to reboot each time you add a device to get the system to recognize it is hardly efficient.

To create an effective balance between the opposing virtues of stability and usability, Linux isolates the kernel, but lets you add specific functionality on the fly through loadable kernel modules (LKMs). As shown in the figure below, you can think of a module as a piece of software that tells the kernel where to find a device and what to do with it. In turn, the kernel makes the device available to users and processes and oversees its operation.

Kernel modules

Kernel modules act as translators between devices and the Linux kernel.

There’s nothing stopping you from writing your own module to support a device exactly the way you’d like it, but why bother? The Linux module library is already so robust that there’s usually no need to roll your own. And the vast majority of the time, Linux will automatically load a new device’s module without you even knowing it.

Still, there are times when, for some reason, it doesn’t happen by itself. (You don’t want to leave that hiring manager impatiently waiting for your smiling face to join the video conference job interview for too long.) To help things along, you’ll want to understand a bit more about kernel modules and, in particular, how to find the actual module that will run your peripheral and then how to manually activate it.

Finding kernel modules

By accepted convention, modules are files with a .ko (kernel object) extension that live beneath the /lib/modules/ directory. Before you navigate all the way down to those files, however, you’ll probably have to make a choice. Because you’re given the option at boot time of loading one from a list of releases, the specific software needed to support your choice (including the kernel modules) has to exist somewhere. Well, /lib/modules / is one of those somewheres. And that’s where you’ll find directories filled with the modules for each available Linux kernel release; for example:

$ ls /lib/modules 4.4.0-101-generic 4.4.0-103-generic 4.4.0-104-generic

In my case, the active kernel is the version with the highest release number (4.4.0-104-generic), but there’s no guarantee that that’ll be the same for you (kernels are frequently updated). If you’re going to be doing some work with modules that you’d like to use on a live system, you need to be sure you’ve got the right directory tree.

More Linux resources

  • Linux commands cheat sheet
  • Advanced Linux commands cheat sheet
  • Free online course: RHEL Technical Overview
  • Linux networking cheat sheet
  • SELinux cheat sheet
  • Linux common commands cheat sheet
  • What are Linux containers?
  • Our latest Linux articles

Good news: there’s a reliable trick. Rather than identifying the directory by name and hoping you’ll get the right one, use the system variable that always points to the name of the active kernel. You can invoke that variable using uname -r (the -r specifies the kernel release number from within the system information that would normally be displayed):

$ uname -r 4.4.0-104-generic

With that information, you can incorporate uname into your filesystem references using a process known as command substitution. To navigate to the right directory, for instance, you’d add it to /lib/modules . To tell Linux that «uname» isn’t a filesystem location, enclose the uname part in backticks, like this:

$ ls /lib/modules/`uname -r` build modules.alias modules.dep modules.softdep initrd modules.alias.bin modules.dep.bin modules.symbols kernel modules.builtin modules.devname modules.symbols.bin misc modules.builtin.bin modules.order vdso

You’ll find most of the modules organized within their subdirectories beneath the kernel/ directory. Take a few minutes to browse through those directories to get an idea of how things are arranged and what’s available. The filenames usually give you a good idea of what you’re looking at.

$ ls /lib/modules/`uname -r`/kernel arch crypto drivers fs kernel lib mm net sound ubuntu virt zfs

That’s one way to locate kernel modules; actually, it’s the quick and dirty way to go about it. But it’s not the only way. If you want to get the complete set, you can list all currently loaded modules, along with some basic information, by using lsmod . The first column of this truncated output (there would be far too many to list here) is the module name, followed by the file size and number, and then the names of other modules on which each is dependent:

$ lsmod [. ] vboxdrv 454656 3 vboxnetadp,vboxnetflt,vboxpci rt2x00usb 24576 1 rt2800usb rt2800lib 94208 1 rt2800usb [. ]

How many are far too many? Well, let’s run lsmod once again, but this time piping the output to wc -l to get a count of the lines:

$ lsmod | wc -l 113

Those are the loaded modules. How many are available in total? Running modprobe -c and counting the lines will give us that number:

$ modprobe -c | wc -l 33350

There are 33,350 available modules. It looks like someone’s been working hard over the years to provide us with the software to run our physical devices.

More Linux resources

  • Linux commands cheat sheet
  • Advanced Linux commands cheat sheet
  • Free online course: RHEL Technical Overview
  • Linux networking cheat sheet
  • SELinux cheat sheet
  • Linux common commands cheat sheet
  • What are Linux containers?
  • Our latest Linux articles

Note: On some systems, you might encounter customized modules that are referenced either with their unique entries in the /etc/modules file or as a configuration file saved to /etc/modules-load.d/ . The odds are that such modules are the product of local development projects, perhaps involving cutting-edge experiments. Either way, it’s good to have some idea of what it is you’re looking at.

That’s how you find modules. Your next job is to figure out how to manually load an inactive module if, for some reason, it didn’t happen on its own.

Manually loading kernel modules

Before you can load a kernel module, logic dictates that you’ll have to confirm it exists. And before you can do that, you’ll need to know what it’s called. Getting that part sometimes requires equal parts magic and luck and some help from of the hard work of online documentation authors.

I’ll illustrate the process by describing a problem I ran into some time back. One fine day, for a reason that still escapes me, the WiFi interface on a laptop stopped working. Just like that. Perhaps a software update knocked it out. Who knows? I ran lshw -c network and was treated to this very strange information:

network UNCLAIMED AR9485 Wireless Network Adapter

Linux recognized the interface (the Atheros AR9485) but listed it as unclaimed. Well, as they say, «When the going gets tough, the tough search the internet.» I ran a search for atheros ar9 linux module and, after sifting through pages and pages of five- and even 10-year-old results advising me to either write my own module or just give up, I finally discovered that (with Ubuntu 16.04, at least) a working module existed. Its name is ath9k.

Yes! The battle’s as good as won! Adding a module to the kernel is a lot easier than it sounds. To double check that it’s available, you can run find against the module’s directory tree, specify -type f to tell Linux you’re looking for a file, and then add the string ath9k along with a glob asterisk to include all filenames that start with your string:

$ find /lib/modules/$(uname -r) -type f -name ath9k* /lib/modules/4.4.0-97-generic/kernel/drivers/net/wireless/ath/ath9k/ath9k_common.ko /lib/modules/4.4.0-97-generic/kernel/drivers/net/wireless/ath/ath9k/ath9k.ko /lib/modules/4.4.0-97-generic/kernel/drivers/net/wireless/ath/ath9k/ath9k_htc.ko /lib/modules/4.4.0-97-generic/kernel/drivers/net/wireless/ath/ath9k/ath9k_hw.ko

Just one more step, load the module:

# modprobe ath9k

That’s it. No reboots. No fuss.

Here’s one more example to show you how to work with active modules that have become corrupted. There was a time when using my Logitech webcam with a particular piece of software would make the camera inaccessible to any other programs until the next system boot. Sometimes I needed to open the camera in a different application but didn’t have the time to shut down and start up again. (I run a lot of applications, and getting them all in place after booting takes some time.)

Because this module is presumably active, using lsmod to search for the word video should give me a hint about the name of the relevant module. In fact, it’s better than a hint: The only module described with the word video is uvcvideo (as you can see in the following):

$ lsmod | grep video uvcvideo 90112 0 videobuf2_vmalloc 16384 1 uvcvideo videobuf2_v4l2 28672 1 uvcvideo videobuf2_core 36864 2 uvcvideo,videobuf2_v4l2 videodev 176128 4 uvcvideo,v4l2_common,videobuf2_core,videobuf2_v4l2 media 24576 2 uvcvideo,videodev

There was probably something I could have controlled for that was causing the crash, and I guess I could have dug a bit deeper to see if I could fix things the right way. But you know how it is; sometimes you don’t care about the theory and just want your device working. So I used rmmod to kill the uvcvideo module and modprobe to start it up again all nice and fresh:

# rmmod uvcvideo # modprobe uvcvideo

Again: no reboots. No stubborn blood stains.

Управляем модулем ядра Linux

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

Введение

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

Application: любое приложение, запущенное на уровне пользователя, которое может взаимодействовать с модулем ядра.

Kernel Module: содержит определение системных вызовов, которые могут использоваться API-интерфейсами приложений и ядра для мониторинга работоспособности.

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

Разберём команды, которые полезны при написании и использовании расширений ядра.

Загрузка модуля ядра

insmod: используется для вставки модуля в ядро.

пример: insmod ‘kernel_ext_binary’

# insmod helloWorld.ko Welcome to Hello world Module.
Выгрузка модуля ядра

пример: rmmod ‘kernel_ext_binary’

# rmmod helloWorld.ko Goodbye, from Hello world.
Список всех запущенных модулей ядра

lsmod: выводит список всех загруженных модулей ядра.

пример: lsmod | grep ‘kernel_ext_binary’

# lsmod | grep hello helloWorld 12189 1

Подробная информация о модуле ядра

modinfo: отображает дополнительную информацию о модуле.

пример: modinfo hello*.ko

# modinfo helloWorld.ko filename: /root/helloWorld.ko description: Basic Hello World KE author: helloWorld license: GPL rhelversion: 7.3 srcversion: 5F60F86F84D8477986C3A50 depends: vermagic: 3.10.0-514.el7.ppc64le SMP mod_unload modversions

Перечисленные команды можно запускать на консоли и через бинарное приложение с помощью вызова system() .

Связь с пользовательским пространством

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

#include #include #include int open(const char *pathname, int flags);
int fd; #define DEVICE_FILE_NAME "/dev/char_dev" fd = open(DEVICE_FILE_NAME, 0);

Возвращаемое значение open() — дескриптор файла, небольшое неотрицательное целое число, которое используется в последующих системных вызовах (в данном случае ioctl ).

Использование вызовов ioctl

Системный вызов ioctl() может быть вызван из пользовательского пространства для управления базовыми параметрами устройства.

#include int ioctl(int fd, int cmd, . );

fd — это файловый дескриптор, возвращаемый из open() , а cmd — то же самое, что реализовано в ioctl() модуля ядра.

#define IOCTL_SEND_MSG _IOR(MAJOR_NUM, 0, char *) int ret_val; char message[100]; ret_val = ioctl(file_desc, IOCTL_SEND_MSG, message); if (ret_val

В приведенном примере IOCTL_SEND_MSG — команда, которая отправляется модулю.

_IOR означает, что приложение создаёт номер команды ioctl для передачи информации из пользовательского приложения в модуль ядра.

Первый аргумент, MAJOR_NUM , — основной номер используемого нами устройства.

Второй аргумент — номер команды (их может быть несколько с разным значением).

Третий аргумент — тип, который мы хотим передать от процесса к ядру.

Точно так же пользовательское приложение может получить сообщение от ядра с небольшим изменением аргументов ioctl .

Обработка потоков в модуле ядра

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

Создание потока

Мы можем создать несколько потоков в модуле, используя следующие вызовы:

#include static struct task_struct * sampleThread = NULL; sampleThread = kthread_run(threadfn, data, namefmt, …)

kthread_run() создаёт новый поток и сообщает ему о запуске.

threadfn — имя функции для запуска.

data * — указатель на аргументы функции.

namefmt — имя потока (в выводе команды ps )

Остановка потока

Мы можем остановить запущенные потоки, используя вызов:

Установка связи с сокетом

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

struct socket *sock; struct sockaddr_ll *s1 = kmalloc(sizeof(struct sockaddr_ll),GFP_KERNEL); result = sock_create(PF_PACKET, SOCK_RAW, htons(ETH_P_IP), &sock); if(result < 0) < printk(KERN_INFO "[vmmKE] unable to create socket"); return -1; >//copy the interface name to ifr.name and other required information. strcpy((char *)ifr.ifr_name, InfName); s1->sll_family = AF_PACKET; s1->sll_ifindex = ifindex; s1->sll_halen = ETH_ALEN; s1->sll_protocol = htons(ETH_P_IP); result = sock->ops->bind(sock, (struct sockaddr *)s1, sizeof(struct sockaddr_ll)); if(result

С помощью sock_sendmsg() модуль ядра может отправлять данные, используя структуру сообщения.

struct msghdr message; int ret= sock_sendmsg(sock, (struct msghdr *)&message);

Генерация сигналов процессу пользовательского пространства

Сигналы тоже можно сгенерировать из модуля ядра в пользовательское приложение. Если идентификатор процесса (PID) известен ядру, используя этот pid, модуль может заполнить требуемую структуру pid и передать ее в send_sig_info() для запуска сигнала.

struct pid *pid_struct = find_get_pid(pid); struct task_struct *task = pid_task(pid_struct,PIDTYPE_PID); int signum = SIGKILL, sig_ret; struct siginfo info; memset(&info, '\0', sizeof(struct siginfo)); info.si_signo = signum; //send a SIGKILL to the daemon sig_ret = send_sig_info(signum, &info, task); if (sig_ret

Ротация логов

Если пользователь хочет перенаправить все логи, связанные с модулем ядра, в определённый файл, необходимо добавить запись в rsyslog (/etc/rsyslog.conf) следующим образом:

Это позволяет rsyslog перенаправлять все логи ядра, начинающиеся с [Hello Module], в модуль /var/log/helloModule.log file.

Пример: пользователи могут написать собственный сценарий ротации и поместить его в /etc/logrotate.d.

"/var/log/helloModule.log" < daily rotate 4 maxsize 2M create 0600 root postrotate service rsyslog restart >/dev/null endscript >

Сценарий ежедневно проверяет, не превышает ли размер файла логов 2 МБ, и поддерживает 4 ротации этого файла. Если размер логов превышает 2 МБ, будет создан новый файл с тем же именем и правами доступа к файлу 0600, а к старому файлу будет добавлена отметка даты и времени.

После ротации он перезапустит службу rsyslog.

Создание файла

Обратитесь к содержимому makefile, чтобы сгенерировать двоичные файлы для сэмпла программы:

obj−m += helloWorld.o all: make −C /lib/modules/$(shell uname −r)/build M=$(PWD) modules clean: make −C /lib/modules/$(shell uname −r)/build M=$(PWD) clean

Примечание: пример основан на варианте RHEL. Другие варианты реализации makefile могут отличаться.

Интеграция модуля ядра с пользовательским приложением

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

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

Пример включает в себя все концепции, описанные ранее.

# cat helloWorld.h #ifndef HELLOWORLD_H #define HELLOWORLD_H #include // cmd ‘KE_DATA_VAR’ to send the integer type data #define KE_DATA_VAR _IOR('q', 1, int *) #endif # cat helloWorld.c #include #include #include #include #include #include #include #include "helloWorld.h" /* @brief: function to load the kernel module */ void load_KE() < printf ("loading KE\n"); if (system ("insmod /root/helloWorld.ko") == 0) < printf ("KE loaded successfully"); >> /* @brief: function to unload the kernel module */ void unload_KE() < printf ("unloading KE\n"); if (system ("rmmod /root/helloWorld.ko") == 0) < printf ("KE unloaded successfully"); >> /* @brief: method to send data to kernel module */ void send_data(int fd) < int v; printf("Enter value: "); scanf("%d", &v); getchar(); if (ioctl(fd, KE_DATA_VAR, &v) == -1) < perror("send data error at ioctl"); >> int main(int argc, char *argv[]) < const char *file_name = "/dev/char_device"; //used by ioctl int fd; enum < e_load, //load the kernel module e_unload, //unload the kernel module e_send, //send a HB from test binary to kernel module >option; if (argc == 2) < if (strcmp(argv[1], "-l") == 0) < option = e_load; >else if (strcmp(argv[1], "-u") == 0) < option = e_unload; >> else if (strcmp(argv[1], "-s") == 0) < option = e_send; >else < fprintf(stderr, "Usage: %s [-l | -u | -s ]\n", argv[0]); return 1; >> else < fprintf(stderr, "Usage: %s [-l | -u | -s ]\n", argv[0]); return 1; >if ((option != e_load) && (option != e_unload)) < fd = open(file_name, O_RDWR); if (fd == -1) < perror("KE ioctl file open"); return 2; >> switch (option) < case e_load: load_KE(); break; case e_unload: unload_KE(); break; case e_send: send_data(fd); break; default: break; >if ((option != e_load) && (option != e_unload)) < close (fd); >return 0; > Sample kernel module # cat helloWorld.c #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include typedef struct < char ethInfName[8]; char srcMacAdr[15]; char destMacAdr[15]; int ifindex; >KEConfig_t; MODULE_LICENSE("GPL"); MODULE_AUTHOR("Owner Name"); MODULE_DESCRIPTION("Sample Hello world"); MODULE_VERSION("0.1"); static char *name = "world"; static struct task_struct *ke_thread; static struct KEConfig_t KECfg; module_param(name, charp, S_IRUGO); MODULE_PARM_DESC(name, "The name to display in /var/log/kern.log"); /* @brief: create socket and send required data to HM * creates the socket and binds on to it. * This method will also send event notification * to HM. * */ static int createSocketandSendData(char *data) < int ret_l =0; mm_segment_t oldfs; struct msghdr message; struct iovec ioVector; int result; struct ifreq ifr; struct socket *sock; struct sockaddr_ll *s1 = kmalloc(sizeof(struct sockaddr_ll),GFP_KERNEL); if (!s1) < printk(KERN_INFO "failed to allocate memory"); return -1; >printk(KERN_INFO "inside configureSocket"); memset(s1, '\0', sizeof(struct sockaddr_ll)); memset(픦, '\0', sizeof(ifr)); result = sock_create(PF_PACKET, SOCK_RAW, htons(ETH_P_IP), &sock); if(result < 0) < printk(KERN_INFO "unable to create socket"); return -1; >printk(KERN_INFO "interface: %s", KECfg.ethInfName); printk(KERN_INFO "ifr index: %d", KECfg.ifindex); strcpy((char *)ifr.ifr_name, KECfg.ethInfName); s1->sll_family = AF_PACKET; s1->sll_ifindex = KECfg.ifindex; s1->sll_halen = ETH_ALEN; s1->sll_protocol = htons(ETH_P_IP); result = sock->ops->bind(sock, (struct sockaddr *)s1, sizeof(struct sockaddr_ll)); if(result < 0) < printk(KERN_INFO "Unable to bind socket"); return -1; >//create the message header memset(&message, 0, sizeof(message)); message.msg_name = sockData->sock_ll; message.msg_namelen = sizeof(*(sock_ll)); ioVector.iov_base = data; ioVector.iov_len = sizeof(data); message.msg_iov = &ioVector; message.msg_iovlen = 1; message.msg_control = NULL; message.msg_controllen = 0; oldfs = get_fs(); set_fs(KERNEL_DS); ret_l = sock_sendmsg(sockData->sock, &message, sizeof(data)); return 0; > static long ke_ioctl(struct file *f, unsigned int cmd, unsigned long arg) < int b; switch (cmd) < case KE_DATA_VAR: if (get_user(b, (int *)arg)) < return -EACCES; >//set the time of HB here mutex_lock(&dataLock); do_gettimeofday(&hbTv); printk(KERN_INFO "time of day is %ld:%lu \n", hbTv.tv_sec, hbTv.tv_usec); printk(KERN_INFO "data %d\n", b); //send data out createSocketandSendData(&b); mutex_unlock(&dataLock); break; default: return -EINVAL; > return 0; > /* @brief: method to register the ioctl call */ static struct file_operations ke_fops = < .owner = THIS_MODULE, #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)) .ioctl = ke_ioctl #else .unlocked_ioctl = ke_ioctl #endif >; /* @brief The thread function */ int ke_init() < printk(KERN_INFO "Inside function"); return 0; >/* @brief The LKM initialization function */ static int __init module_init(void) < printk(KERN_INFO "module_init initialized\n"); if ((ret = alloc_chrdev_region(&dev, FIRST_MINOR, MINOR_CNT, "KE_ioctl")) < 0) < return ret; >cdev_init(&c_dev, &ke_fops); if ((ret = cdev_add(&c_dev, dev, MINOR_CNT)) < 0) < return ret; >if (IS_ERR(cl = class_create(THIS_MODULE, "char"))) < cdev_del(&c_dev); unregister_chrdev_region(dev, MINOR_CNT); return PTR_ERR(cl); >if (IS_ERR(dev_ret = device_create(cl, NULL, dev, NULL, "KEDevice"))) < class_destroy(cl); cdev_del(&c_dev); unregister_chrdev_region(dev, MINOR_CNT); return PTR_ERR(dev_ret); >//create related threads mutex_init(&dataLock); //initialize the lock KEThread = kthread_run(ke_init,"KE thread","KEThread"); return 0; > void thread_cleanup(void) < int ret = 0; if (ke_thread) ret = kthread_stop(ke_thread); if (!ret) printk(KERN_INFO "Kernel thread stopped"); >/* @brief The LKM cleanup function */ static void __exit module_exit(void) < device_destroy(cl, dev); class_destroy(cl); cdev_del(&c_dev); unregister_chrdev_region(dev, MINOR_CNT); thread_cleanup(); printk(KERN_INFO "Exit %s from the Hello world!\n", name); >module_init(module_init); module_exit(module_exit);

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

Все модули заканчиваются вызовом либо cleanup_module() , либо функции, которую вы указываете с помощью вызова module_exit() . Это функция выхода для модулей — она отменяет всё, что сделала функция ввода.

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

Если какой-либо вызов execve() выполняется пользовательским процессом, нужно установить параметр сокета FD_CLOEXEC в fd (файловый дескриптор).

fd = open(“/dev/char_device”, O_RDWR); fcntl(fd, F_SETFD, FD_CLOEXEC);

Если параметр FD_CLOEXEC не установлен для этого fd , дескриптор файла должен оставаться открытым при вызове execve() .

Коротко о главном

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *