Между командой cat /proc/devices и мигающим светодиодом на отладочной плате лежит слой кода, который не виден ни в ps, ни в top, но без него не работает ни один системный вызов. Драйвер в Linux - не отдельная программа, а гость внутри ядра: он делит с ядром адресное пространство и одной неверной записью способен остановить всю машину. Ниже разобран весь путь: пустой модуль, таблица file_operations, регистрация номера, автоматическое появление узла через udev, регистры и прерывания, platform_driver, сборка и первая отладка.
Слои между пользовательским процессом и физическим устройством
Начнём с честного вопроса: чем драйвер отличается от обычной библиотеки? Библиотеку вызывает тот же процесс, что доверил ей свои переменные. Драйвер же вызывается чужим процессом: приложение открыло файл, сделало read, и вдруг исполняется код, которого этот процесс никогда не видел. Системный вызов проходит через glibc и слой VFS, где абстрактная операция превращается в указатель на функцию из структуры file_operations, и лишь потом попадает в драйвер. Прикладной программист думает байтами, контроллер - тактами шины, и драйвер работает переводчиком между двумя языками.
Перевод зашит в номерах. Команда ls -l /dev/sda печатает строку вида brw-rw---- 1 root disk 8, 0 - это мажор 8 и минор 0. Мажор называет драйвер, минор - экземпляр устройства внутри него. Классика занята прочно: /dev/null - пара 1, 3, /dev/zero - 1, 5, /dev/ttyS0 - 4, 64. Зарегистрированные мажоры перечислены в /proc/devices - один взгляд, и видно, насколько плотно заселён номерной дом.
Типов устройств три. Символьные отдают поток байтов последовательно, как терминал или звуковой вход. Блочные работают страницами и строят кэш: диск не обязан отвечать мгновенно, порядок решает планировщик ввода-вывода. Сетевые интерфейсы живут вовсе без /dev: eth0 существует в sysfs и управляется сокетами. Выбор типа определяет половину будущей архитектуры.
Каркас модуля и точки входа в ядро
Работа начинается с каркаса. Модуль собирается как объектный файл obj-m и превращается в .ko, который insmod загружает в ядро. В конфигурации каждая опция принимает значение y, m или n: вкомпилировать, собрать отдельно или исключить. Готовые модули лежат в /lib/modules/$(uname -r)/kernel/drivers/.
Минимальный каркас занимает полтора десятка строк:
#include <linux/module.h>
MODULE_LICENSE("GPL");
static int __init hello_start(void)
{
pr_info("hello_drv: loaded\n");
return 0;
}
static void __exit hello_stop(void)
{
pr_info("hello_drv: unloaded\n");
}
module_init(hello_start);
module_exit(hello_stop);
module_init и module_exit связывают функции загрузки и выгрузки с точками входа ядра. Директива MODULE_LICENSE не бюрократия: без строки "GPL" модуль не увидит десятков символов, экспортируемых через EXPORT_SYMBOL_GPL, а ядро пометит себя как tainted. Пометка читается из /proc/sys/kernel/tainted: бит 4096 означает загруженный out-of-tree модуль, бит 8192 - неподписанный.
Загрузка и выгрузка занимают секунды: sudo insmod hello_drv.ko, затем lsmod | grep hello_drv, затем sudo rmmod hello_drv. lsmod читает /proc/modules, а dmesg достаёт строки кольцевого буфера ядра с метками времени вроде [ 2419.517802]. Честно говоря, dmesg - половина отладки драйвера: команда dmesg -w продолжает печатать новые сообщения по мере появления.
Символьное устройство и обмен байтами с пользователем
Сердце символьного драйвера - структура file_operations: таблица указателей на функции, которые VFS вызывает при open, read, write и release. Связь с файлом идёт через индексный узел: в struct inode лежит номер устройства, по нему ядро находит cdev и его таблицу операций. Регистрация бывает старой и новой. Современный путь - alloc_chrdev_region, cdev_init и cdev_add: ядро подбирает свободный мажор, а драйвер связывает его с таблицей операций. Старый интерфейс register_chrdev жив и поныне и короче: он регистрирует мажор с диапазоном миноров 0-255, а нулевой мажор в запросе означает "подбери свободный сам" - пример ниже использует именно его.
Внутренний тип dev_t вмещает 32 бита: 12 под мажор и 20 под минор, итого до 4096 мажоров и 1048576 миноров. Диапазон 240-254 таблица devices.txt отдаёт под локальные и экспериментальные номера, туда и попадают первые самодельные драйверы. Драйвер flip запоминает последнюю записанную строку и отдаёт её при чтении:
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
static int major;
static char msg[64] = "empty\n";
static ssize_t flip_read(struct file *f, char __user *buf,
size_t count, loff_t *pos)
{
return simple_read_from_buffer(buf, count, pos, msg, strlen(msg));
}
static ssize_t flip_write(struct file *f, const char __user *buf,
size_t count, loff_t *pos)
{
if (count > sizeof(msg) - 1)
count = sizeof(msg) - 1;
if (copy_from_user(msg, buf, count))
return -EFAULT;
msg[count] = '\0';
return count;
}
static const struct file_operations flip_fops = {
.owner = THIS_MODULE,
.read = flip_read,
.write = flip_write,
};
static int __init flip_init(void)
{
major = register_chrdev(0, "flip", &flip_fops);
if (major < 0)
return major;
pr_info("flip: registered, major %d\n", major);
return 0;
}
static void __exit flip_exit(void)
{
unregister_chrdev(major, "flip");
}
module_init(flip_init);
module_exit(flip_exit);
MODULE_LICENSE("GPL");
Суффикс __user - аннотация для анализатора sparse: указатель помечен как адрес из пространства пользователя, и разыменовывать его напрямую нельзя. Копирование выполняют copy_from_user и copy_to_user: они возвращают число неперемещённых байтов, и ненулевой ответ превращается в -EFAULT. Если dmesg сообщил major 237, проверка занимает три строки: sudo mknod /dev/flip c 237 0, затем echo -n "test string" > /dev/flip, затем cat /dev/flip - строка возвращается из ядра.
Мажорные номера, udev и появление узла в /dev
Ручной mknod хорош для проверки, но на десятке серверов превращается в рутину. Раньше каталог /dev наполнялся статично: узлов были тысячи, и большинство описывало железо, которого в машине не было. Затем появились devtmpfs и udev. Ядро само создаёт узел при регистрации устройства, а сервис udevd, слушающий netlink-сокет, подхватывает событие, выставляет права и симлинки по правилам. Чтобы узел появился сам, драйвер должен рассказать о себе через класс:
static struct class *flip_class;
flip_class = class_create("flip");
device_create(flip_class, NULL, MKDEV(major, 0), NULL, "flip");
В ядрах до 6.4 у class_create был аргумент THIS_MODULE, а с 6.4 его убрали, поэтому примеры из старых книг требуют правки при переносе на свежие ядра. После device_create в /sys/class/flip/flip0 появится каталог, файл dev покажет пару вида "237:0", а узел /dev/flip создаст devtmpfs ещё до того, как udevd проснётся.
Правило для прав доступа кладут в /etc/udev/rules.d/99-flip.rules:
KERNEL=="flip", MODE="0666", GROUP="plugdev"
Правило применяют командой udevadm control --reload-rules. Сценка до и после: ещё недавно инженер после подключения платы вручную вычислял мажор, создавал узел и повторял это на каждом сервере, надеясь, что права никто не перепутает. Теперь узел возникает сам, а права описаны одним файлом правил в репозитории конфигурации.
Регистры оборудования через ioremap и обработка прерываний
Настоящее железо живёт по физическим адресам. Контроллер выглядит как область памяти, где по смещению 0x00 лежит регистр статуса, по 0x04 - управление, по 0x08 - данные. Ядро работает в виртуальных адресах, поэтому область сначала просят через request_mem_region, затем отображают функцией ioremap. Зачем спрашивать разрешение, если адрес и так известен? Чтобы два драйвера не поделили один диапазон: занятые области с именами владельцев видны в /proc/iomem.
static void __iomem *regs;
regs = ioremap(0x43c00000, 0x1000);
if (!regs)
return -ENOMEM;
writel(0x1, regs + 0x04); /* enable the controller */
status = readl(regs + 0x00);
iounmap(regs);
Функции readl и writel работают с 32-битными значениями и приводят порядок байтов к little-endian. Аннотация __iomem подсказывает sparse, что это не обычная память: прямое разыменование будет ошибкой. Обе операции - запрос и отображение - умеет делать devm-функция devm_ioremap_resource, которая заодно освобождает всё при выгрузке.
Второй орган чувств драйвера - прерывание. Опрашивать контроллер в цикле расточительно; вместо этого драйвер подписывается на событие вызовом request_irq(irq, flip_isr, 0, "flip", NULL) и получает управление в момент сигнала. Сам обработчик предельно короткий:
static irqreturn_t flip_isr(int irq, void *dev_id)
{
writel(0x0, regs + 0x08); /* acknowledge the interrupt */
schedule_work(&flip_work);
return IRQ_HANDLED;
}
Обработчик исполняется в контексте прерывания: спать нельзя, kmalloc с флагом GFP_KERNEL нельзя, только GFP_ATOMIC. Поэтому тяжёлая работа уезжает в отложенную часть через work queue, а верхняя половина лишь сбрасывает источник сигнала и передаёт эстафету. Флаг IRQF_SHARED разрешает делить одну линию, но тогда обработчик обязан проверять, его ли событие, и возвращать IRQ_NONE в чужой очереди. Счётчики по каждому ядру процессора видны в /proc/interrupts: после пары операций с устройством столбец вашей строки должен подрасти, иначе сигнал не доходит.
Платформенные драйверы и сопоставление с деревом устройств
Встраиваемые контроллеры в SoC не умеют представляться, как платы PCI: шина не опрашивает их и не находит автоматически. Для таких устройств в ядре есть виртуальная шина platform, а её две стороны - platform_driver и узел в описании оборудования. Описание живёт в дереве устройств: текст с узлами и свойствами reg и interrupts компилируется утилитой dtc в файл .dtb, который загрузчик передаёт ядру. Как ядро понимает, что узлу соответствует именно ваш драйвер? По строке compatible.
static const struct of_device_id flip_of_match[] = {
{ .compatible = "corp,flip-1.0" },
{ }
};
MODULE_DEVICE_TABLE(of, flip_of_match);
static int flip_probe(struct platform_device *pdev)
{
int irq = platform_get_irq(pdev, 0);
if (irq < 0)
return irq;
pr_info("flip: probing, irq %d\n", irq);
return 0;
}
static void flip_remove(struct platform_device *pdev)
{
pr_info("flip: removed\n");
}
static struct platform_driver flip_pdrv = {
.probe = flip_probe,
.remove = flip_remove,
.driver = {
.name = "flip",
.of_match_table = flip_of_match,
},
};
module_platform_driver(flip_pdrv);
Макрос module_platform_driver разворачивается в привычные module_init и module_exit, экономя десяток строк шаблона. При загрузке ядро обходит узлы дерева и сравнивает строку compatible с таблицей of_match_table; совпадение - и вызван probe. Имена строгие: производитель, потом модель. Узел описания компактный:
flip@43c00000 {
compatible = "corp,flip-1.0";
reg = <0x43c00000 0x1000>;
interrupts = <0 29 4>;
};
Здесь же раскрывается загадка адреса 0x43c00000, который выглядел взятым с потолка: он прописан в свойстве reg и приходит в драйвер через platform_get_resource. На x86 ту же роль играют PCI BAR из конфигурационного пространства. Хороший драйвер не содержит зашитых физических адресов - всё приходит из описания железа. Версионная мелочь: с ядра 6.11 обработчик remove возвращает void, раньше - int.
Сборка модуля через Makefile и первые шаги отладки
Сборка вне исходников ядра умещается в шесть строк:
obj-m += flip.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
all:
$(MAKE) -C $(KDIR) M=$(PWD) modules
clean:
$(MAKE) -C $(KDIR) M=$(PWD) clean
Команда make -C переносит управление в каталог сборки ядра, а переменная M возвращает его обратно. Драйвер внутри исходников ядра получает пару Kconfig и Makefile: опция tristate "Flip device support" появится в меню make menuconfig, а строка obj-$(CONFIG_FLIP) += flip.o решает судьбу объекта - вкомпилировать (y), собрать модулем (m) или исключить (n).
Установка и загрузка на любом дистрибутиве:
make
sudo make modules_install
sudo depmod -a
sudo modprobe flip
modinfo flip.ko | head -n 8
Разница между insmod и modprobe принципиальна: insmod грузит ровно один файл и требует вручную разрешить зависимости, а modprobe читает карту modules.dep, подтягивает нужные модули и применяет опции из /etc/modprobe.d/. Несовместимость версий видна мгновенно: модуль, собранный вчера под старое ядро, сегодня падает с ошибкой Invalid module format - строка vermagic не совпала. Неподписанный модуль на системе с Secure Boot и lockdown ядро не пропустит - dmesg покажет module verification failed. Unknown symbol намекает, что нужный символ не экспортирован, а отказ rmmod с кодом EBUSY говорит, что файл держат открытым; поле .owner = THIS_MODULE защищает именно от этого.
Отладка начинается с printk. Уровни от KERN_EMERG (0) до KERN_DEBUG (7) фильтруются консольной политикой из /proc/sys/kernel/printk: типичная строка "4 4 1 7" пропускает на консоль всё важнее предупреждений, а остальное копится в кольцевом буфере. Если модуль упал с Oops, в сообщении будет адрес сбоя: objdump -dS flip.ko и addr2line -e flip.ko превращают его в строку исходника, а /proc/kallsyms помогает сопоставить адреса с символами.
Путь от идеи до стабильного драйвера укладывается в проверенные шаги:
- Читаем спецификацию железа и соседние драйверы в каталоге drivers/;
- Пишем каркас модуля и добиваемся чистой загрузки и выгрузки;
- Добавляем file_operations и обмен с пользовательским процессом;
- Подключаем регистры и прерывания, сверяясь с /proc/interrupts;
- Выносим аппаратную часть в platform_driver и дерево устройств;
- Прогоняем сборку под целевое ядро и описываем модуль в Kconfig.
Драйвер - это договор с ядром. Пока код соблюдает его - возвращает коды ошибок, не спит в прерываниях, отпускает память и снимает регистрации при выгрузке - система работает годами без перезагрузки. Лучший учебник лежит не в сети, а в каталоге drivers/ вашего ядра: тысячи драйверов, и почти под любое железо там найдётся пример, из которого стоит унести в свой код идею, а не баг.