Драйвер символьного устройства linux примеры

Как написать свой первый Linux device driver

Цель данной статьи — показать принцип реализации драйверов устройств в системе Linux, на примере простого символьного драйвера.

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

Это моя первая статья, пожалуйста не судите строго!

P.S

Получилось слишком много букв, поэтому я принял решение разделить статью на три части:

Часть 1 — Введение, инициализация и очистка модуля ядра.
Часть 2 — Функции open, read, write и trim.
Часть 3 — Пишем Makefile и тестируем устройство.

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

Подготовительные работы

UPD.

Символьный драйвер (Char driver) — это, драйвер, который работает с символьными устройствами.
Символьные устройства — это устройства, к которым можно обращаться как к потоку байтов.
Пример символьного устройства — /dev/ttyS0, /dev/tty1.

UPD.

Драйвер представляет каждое символьное устройство структурой scull_dev, а также предостовляет интерфейс cdev к ядру.

struct scull_dev < struct scull_qset *data; /* Указатель на первый кусок памяти */ int quantum; /* Размер одного кванта памяти */ int qset; /* Количество таких квантов */ unsigned long size; /* Размер используемой памяти */ struct semaphore sem; /* Используется семафорами */ struct cdev cdev; /* Структура, представляющая символьные устройства */ >; struct scull_dev *scull_device; 

Устройство будет представлять связный список указателей, каждый из которых указывает на структуру scull_qset.

Для наглядности посмотрите на картинку.

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

MAJOR — старший номер (является уникальным в системе).
MINOR — младший номер (не является уникальным в системе).

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

После того как мы определили номера для нашего устройства, мы должны установить связь между этими номерами и операциями драйвера. Это можно сделать используя структуру file_operations.

struct file_operations scull_fops = < .owner = THIS_MODULE, .read = scull_read, .write = scull_write, .open = scull_open, .release = scull_release, >; 

В ядре есть специальные макросы module_init/module_exit, которые указывают путь к функциям инициализации/удаления модуля. Без этих определений функции инициализации/удаления никогда не будут вызваны.

module_init(scull_init_module); module_exit(scull_cleanup_module); 

Здесь будем хранить базовую информацию об устройстве.

int scull_major = 0; /* MAJOR номер*/ int scull_minor = 0; /* MINOR номер*/ int scull_nr_devs = 1; /* Количество регистрируемых устройств */ int scull_quantum = 4000; /* Размер памяти в байтах */ int scull_qset = 1000; /* Количество квантов памяти */ 

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

#include /* Содержит функции и определения для динамической загрузки модулей ядра */ #include /* Указывает на функции инициализации и очистки */ #include /* Содержит функции регистрации и удаления драйвера */ #include /* Содержит необходимые функции для символьного драйвера */ #include /* Содержит функцию ядра для управления памятью */ #include /* Предоставляет доступ к пространству пользователя */ 

Инициализация

Теперь давайте посмотрим на функцию инициализации устройства.

static int scull_init_module(void) < int rv, i; dev_t dev; rv = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); if (rv) < printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return rv; >scull_major = MAJOR(dev); scull_device = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_device) < rv = -ENOMEM; goto fail; >memset(scull_device, 0, scull_nr_devs * sizeof(struct scull_dev)); for (i = 0; i < scull_nr_devs; i++) < scull_device[i].quantum = scull_quantum; scull_device[i].qset = scull_qset; sema_init(&scull_device[i].sem, 1); scull_setup_cdev(&scull_device[i], i); >dev = MKDEV(scull_major, scull_minor + scull_nr_devs); return 0; fail: scull_cleanup_module(); return rv; > 

Первым делом, вызывая alloc_chrdev_region мы регистрируем диапазон символьных номеров устройств и указываем имя устройства. После вызовом MAJOR(dev) мы получаем старший номер.
Далее проверяется вернувшееся значение, если оно является кодом ошибки, то выходим из функции. Стоит отметить, что при разработке реального драйвера устройства следует всегда проверять возвращаемые значения, а также указатели на любые элементы (NULL?).

rv = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); if (rv) < printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return rv; >scull_major = MAJOR(dev); 

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

Выделяем память, делая вызов функции kmalloc и обязательно проверяем указатель на NULL.

UPD

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

scull_device = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_device) < rv = -ENOMEM; goto fail; >memset(scull_device, 0, scull_nr_devs * sizeof(struct scull_dev)); 

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

for (i = 0; i < scull_nr_devs; i++) < scull_device[i].quantum = scull_quantum; scull_device[i].qset = scull_qset; sema_init(&scull_device[i].sem, 1); scull_setup_cdev(&scull_device[i], i); >dev = MKDEV(scull_major, scull_minor + scull_nr_devs); 

Возвращаем значение или обрабатываем ошибку и удаляем устройство.

return 0; fail: scull_cleanup_module(); return rv; > 

Выше были представлены структуры scull_dev и cdev, которые реализуют интерфейс между нашим устройством и ядром. Функция scull_setup_cdev выполняет инициализацию и добавление структуры в систему.

static void scull_setup_cdev(struct scull_dev *dev, int index) < int err, devno = MKDEV(scull_major, scull_minor + index); cdev_init(&dev->cdev, &scull_fops); dev->cdev.owner = THIS_MODULE; dev->cdev.ops = &scull_fops; err = cdev_add(&dev->cdev, devno, 1); if (err) printk(KERN_NOTICE "Error %d adding scull %d", err, index); > 

Удаление

Функция scull_cleanup_module вызывается при удалении модуля устройства из ядра.
Обратный процесс инициализации, удаляем структуры устройств, освобождаем память и удаляем выделенные ядром младшие и старшие номера.

void scull_cleanup_module(void) < int i; dev_t devno = MKDEV(scull_major, scull_minor); if (scull_device) < for (i = 0; i < scull_nr_devs; i++) < scull_trim(scull_device + i); cdev_del(&scull_device[i].cdev); >kfree(scull_device); > unregister_chrdev_region(devno, scull_nr_devs); > 

#include #include #include #include #include #include int scull_major = 0; int scull_minor = 0; int scull_nr_devs = 1; int scull_quantum = 4000; int scull_qset = 1000; struct scull_qset < void **data; struct scull_qset *next; >; struct scull_dev < struct scull_qset *data; int quantum; int qset; unsigned long size; unsigned int access_key; struct semaphore sem; struct cdev cdev; >; struct scull_dev *scull_device; int scull_trim(struct scull_dev *dev) < struct scull_qset *next, *dptr; int qset = dev->qset; int i; for (dptr = dev->data; dptr; dptr = next) < if (dptr->data) < for (i = 0; i < qset; i++) kfree(dptr->data[i]); kfree(dptr->data); dptr->data = NULL; > next = dptr->next; kfree(dptr); > dev->size = 0; dev->quantum = scull_quantum; dev->qset = scull_qset; dev->data = NULL; return 0; > struct file_operations scull_fops = < .owner = THIS_MODULE, //.read = scull_read, //.write = scull_write, //.open = scull_open, //.release = scull_release, >; static void scull_setup_cdev(struct scull_dev *dev, int index) < int err, devno = MKDEV(scull_major, scull_minor + index); cdev_init(&dev->cdev, &scull_fops); dev->cdev.owner = THIS_MODULE; dev->cdev.ops = &scull_fops; err = cdev_add(&dev->cdev, devno, 1); if (err) printk(KERN_NOTICE "Error %d adding scull %d", err, index); > void scull_cleanup_module(void) < int i; dev_t devno = MKDEV(scull_major, scull_minor); if (scull_device) < for (i = 0; i < scull_nr_devs; i++) < scull_trim(scull_device + i); cdev_del(&scull_device[i].cdev); >kfree(scull_device); > unregister_chrdev_region(devno, scull_nr_devs); > static int scull_init_module(void) < int rv, i; dev_t dev; rv = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); if (rv) < printk(KERN_WARNING "scull: can't get major %d\n", scull_major); return rv; >scull_major = MAJOR(dev); scull_device = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL); if (!scull_device) < rv = -ENOMEM; goto fail; >memset(scull_device, 0, scull_nr_devs * sizeof(struct scull_dev)); for (i = 0; i < scull_nr_devs; i++) < scull_device[i].quantum = scull_quantum; scull_device[i].qset = scull_qset; sema_init(&scull_device[i].sem, 1); scull_setup_cdev(&scull_device[i], i); >dev = MKDEV(scull_major, scull_minor + scull_nr_devs); printk(KERN_INFO "scull: major = %d minor = %d\n", scull_major, scull_minor); return 0; fail: scull_cleanup_module(); return rv; > MODULE_AUTHOR("Your name"); MODULE_LICENSE("GPL"); module_init(scull_init_module); module_exit(scull_cleanup_module); 

С удовольствием выслушаю конструктивную критику и буду ждать feedback’a.

Если вы нашли ошибки или я не правильно изложил материал, пожалуйста, укажите мне на это.
Для более быстрой реакции пишите в ЛС.

Литература

Источник

Драйвер символьного устройства linux примеры

Библиотека сайта rus-linux.net

Ранее (вплоть до ядра 2.4) каждый старший номер использовался в качестве указания на отдельный драйвер, а младший номер использовался для указания на конкретное подмножество функциональных возможностей драйвера. В ядре 2.6 такое использование номеров не является обязательным; с одним и тем же старшим номером может быть несколько драйверов, но, очевидно, с различными диапазонами младших номеров.

Однако, такое использование больше характерно для незарезервированных старших номеров, а стандартные старшие номера обычно резервируются для вполне определенных конкретных драйверов. Например, 4 — для последовательных интерфейсов, 13 — для мышей, 14 — для аудио-устройств и так далее. С помощью следующей команды можно будет выдать список файлов различных символьных устройств, имеющихся в вашей системе:

Использование чисел в ядре 2.6

Тип (определен в заголовке ядра linux/types.h ):

Макрос (определен в заголовке ядра linux/kdev_t.h ):

• MAJOR(dev_t dev) — из dev извлекается старший номер
• MINOR(dev_t dev ) — из dev извлекается младший номер
• MKDEV(int major, int minor) — из старшего и младшего номеров создается dev

Подключение файла устройства к драйверу устройства осуществляется за два шага:

1. Выполняется регистрация файлов устройств для диапазона
2. Подключение операций, выполняемых над файлом устройства, к функциям драйвера устройства.

Первый шаг выполняется с помощью одного из следующих двух API, определенных в заголовке ядра linux/fs.h :

+ int register_chrdev_region(dev_t first, unsigned int cnt, char *name); + int alloc_chrdev_region(dev_t *first, unsigned int firstminor, unsigned int cnt, char *name);

С помощью первого API число cnt регистрируется как среди номеров файлов устройств, которые начинаются с first и именем файла name . С помощью второго API динамически определяется свободный старший номер и регистрируется число cnt среди номеров файлов устройств, начинающиеся с , с заданным именем файла name. В любом случае в директории /proc/devices указывается список имен с зарегистрированным старшим номером. Имея эту информацию, Светлана добавила в код первого драйвера следующее:

#include #include #include static dev_t first; // Global variable for the first device number

В конструктор она добавила:

В деструктор она добавила:

unregister_chrdev_region(first, 3);

И собрала все это вместе следующим образом:

#include #include #include #include #include #include static dev_t first; // Global variable for the first device number static int __init ofcd_init(void) /* Constructor */ < printk(KERN_INFO "Namaskar: ofcd registered"); if (alloc_chrdev_region(&first, 0, 3, "Shweta") < 0) < return -1; >printk(KERN_INFO ": \n", MAJOR(first), MINOR(first)); return 0; > static void __exit ofcd_exit(void) /* Destructor */ < unregister_chrdev_region(first, 3); printk(KERN_INFO "Alvida: ofcd unregistered"); >module_init(ofcd_init); module_exit(ofcd_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Anil Kumar Pugalia "); MODULE_DESCRIPTION("Our First Character Driver");

Затем Светлана повторила обычные шаги, которые она узнала при изучении первого драйвера:

• Собрала драйвер (файл .ko ), выполнив команду make .
• Загрузила драйвер с помощью команды insmod .
• Выдала список загруженных модулей с помощью команды lsmod .
• Выгрузила драйвер с помощью команды rmmod .

Подведем итог

Кроме того, перед выгрузкой драйвера она заглянула в директорий /proc/devices для того, чтобы с помощью команды cat /proc/devices найти зарегистрированный старший номер с именем «Shweta». Он там был. Тем не менее, она не смогла в директории /dev найти ни одного файла устройств с таким же старшим номером, т.к. она создала этот номер вручную с помощью команды mknod , а затем пыталась выполнить операции чтения и записи. Все эти действия показаны на рис.2.

Рис.2: Эксперименты с файлом символьного устройства

Обратите внимание, что в зависимости от номеров, уже используемых в системе, старший номер 250 может варьироваться от системы к системе. На рис.2 также показаны результаты, которые получила Светлана при чтении и записи одного из файлов устройств. Это напомнило ей, что все еще не сделан второй шаг подключения файла устройства к драйверу устройства, при котором операции над файлом устройства связываются с функциями драйвера устройства. Она поняла, что ей для того, чтобы завершить этот шаг, нужно поискать дополнительную информацию, а также выяснить причины отсутствия файлов устройств в директории /dev .

Источник