Статья Пишем свой драйвер под Linux

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

То, что мы сегодня создадим, корректнее будет назвать LKM (Linux Kernel Module или загрузочный модуль ядра). Стоит сказать, что драйвер – это одна из разновидностей LKM.

Писать модуль мы будем под ядра линейки 2.6. LKM для 2.6 отличается от 2.4. Я не буду останавливаться на различиях, ибо это не входит в рамки поста.

Мы создадим символьное устройство /dev/test, которое будет обрабатываться нашим модулем. Хочу сразу оговориться, что размещать символьное устройство не обязательно в каталоге /dev, просто это является частью «древнего магического ритуала».
Немного теории

Если кратко, то LKM – это объект, который содержит код для расширения возможностей уже запущенного ядра Linux. Т.е. работает он в пространстве ядра, а не пользователя. Так что не стоит экспериментировать на рабочем сервере. В случае ошибки, закравшейся в модуль, получите kernel panic. Будем считать, что я вас предупредил.

Модуль ядра должен иметь как минимум 2 функции: функцию инициализации и функцию выхода. Первая вызывается во время загрузки модуля в пространство ядра, а вторая, соответственно, при выгрузке его. Эти функции задаются с помощью макроопределений: module_init и module_exit.

Стоит сказать несколько слов о функции printk(). Основное назначение этой функции — реализация механизма регистрации событий и предупреждений. Иными словами эта функция для записи в лог ядра некой информации.

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

Хочу ещё сказать пару слов о символьных устройствах.

Выполните команду ls -l /dev/sda*. Вы увидите что-то вроде:
Между словом «disk» и датой есть два числа разделённых запятой. Первое число называют старшим номером устройства. Старший номер указывает на то, какой драйвер используется для обслуживания данного устройства. Каждый драйвер имеет свой уникальный старший номер.

Файлы устройства создаются с помощью команты mknod, например: mknod /dev/test c 12. Этой командой мы создадим устройство /dev/test и укажем для него старший номер (12).

Я не буду сильно углубляться в теорию, т.к. кому интересно – тот сможет сам почитать про это подробнее. Я дам ссылку в конце.
Прежде чем начать

Нужно знать несколько «волшебных» команд:

• insmod – добавить модуль в ядро
• rmmod – соответственно, удалить
• lsmod – вывести список текущих модулей
• modinfo – вывести информацию о модуле

Для компиляции модуля нам потребуются заголовки текущего ядра.

В debian/ubutnu их можно легко поставить так (к примеру для 2.6.26-2-686):
Либо собрать пакет для вашего текущего ядра самим:
Исходник

PHP код:

#include <linux/kernel.h> /* Для printk() и т.д. */
#include <linux/module.h> /* Эта частичка  древней магии, которая оживляет модули */
#include <linux/init.h> /* Определения  макросов */
#include <linux/fs.h>
#include <asm/uaccess.h> /* put_user */

// Ниже мы задаём информацию о модуле, которую  можно будет увидеть с помощью Modinfo
MODULE_LICENSE( "GPL" );
MODULE_AUTHOR( "Alex Petrov  <[email protected]>" );
MODULE_DEscriptION( "My nice module" );
MODULE_SUPPORTED_DEVICE( "test" ); /* /dev/testdevice */

#define SUCCESS 0
#define DEVICE_NAME "test"  /* Имя нашего устройства */

// Поддерживаемые нашим устройством операции
static int  device_open( struct inode *, struct file * );
static int  device_release( struct inode *, struct file * );
static ssize_t device_read( struct file *, char  *, size_t, loff_t * );
static ssize_t device_write( struct file *, const  char *, size_t, loff_t * );

// Глобальные переменные, объявлены как static,  воизбежание конфликтов имен.
static int  major_number; /* Старший номер устройства нашего  драйвера */
static int  is_device_open = 0; /* Используется ли девайс ? */
static char  text[ 5 ] = "test\n"; /*  Текст, который мы будет отдавать при обращении к нашему устройству */
static char*  text_ptr = text; /* Указатель на текущую позицию в  тексте */

// Прописываем обработчики операций на устройством
static struct  file_operations fops =
 {
  .read = device_read,
  .write = device_write,
  .open = device_open,
  .release = device_release
 };

// Функция загрузки модуля. Входная точка. Можем  считать что это наш main()
static int  __init test_init( void )
{
 printk( KERN_ALERT "TEST driver loaded!\n"  );

 // Регистрируем устройсво и получаем старший  номер устройства
 major_number = register_chrdev( 0, DEVICE_NAME, &fops );

 if ( major_number < 0 )
 {
  printk( "Registering the character device failed  with %d\n", major_number );
  return major_number;
 }

 // Сообщаем присвоенный нам старший номер  устройства
 printk( "Test module is loaded!\n" );

 printk( "Please, create a dev file with 'mknod  /dev/test c %d 0'.\n", major_number );

 return SUCCESS;
}

// Функция выгрузки модуля
static void  __exit test_exit( void )
{
 // Освобождаем устройство
 unregister_chrdev( major_number, DEVICE_NAME );

 printk( KERN_ALERT "Test module is unloaded!\n"  );
}

// Указываем наши функции загрузки и выгрузки
module_init( test_init );
module_exit( test_exit );

static int  device_open( struct inode *inode, struct file *file )
{
 text_ptr = text;

 if ( is_device_open )
  return -EBUSY;

 is_device_open++;

 return SUCCESS;
}

static int  device_release( struct inode *inode, struct file *file )
{
 is_device_open--;
 return SUCCESS;
}

static ssize_t

device_write( struct file *filp, const char *buff,  size_t len, loff_t * off )
{
 printk( "Sorry, this operation isn't  supported.\n" );
 return -EINVAL;
}

static ssize_t device_read( struct file *filp, /*  include/linux/fs.h */
       char *buffer, /*  buffer */
       size_t length, /* buffer length */
       loff_t * offset )
{
 int byte_read = 0;

 if ( *text_ptr == 0 )
  return 0;

 while ( length && *text_ptr )
 {
  put_user( *( text_ptr++ ), buffer++ );
  length--;
  byte_read++;
 }

 return byte_read;
}

* This source code was highlighted with Source Code Highlighter. 


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

Ну а теперь можем написать небольшой Makefile:

И проверить его работоспособность:

Посмотрим что у нас получилось:

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

Ну и наконец установим модуль в ядро:

Посмотрим есть ли наш модуль с списке:

И что попало в логи:


Наш модуль подсказываем нам что нужно сделать.

Последуем его совету:

Ну и наконец проверим работает ли наш модуль:

Наш модуль не поддерживает приём данных со стороны пользователя:
Посмотрим что что скажет модуль на наши действия:

Удалим его:

И посмотрим что он нам скажет на прощание:


Удалим файл устройства, что бы он нас не смущал:

Заключение

Дальнейшее развитие этой «заготовки» зависит только от вас. Можно превратить её в настоящий драйвер, который будет предоставлять интерфейс к вашему девайсу, либо использовать для дальнейшего изучения ядра Linux.

Только что в голову пришла совершенно безумная идея сделать sudo через файл устройства. Т.е. посылаем в /dev/test команду и она выполняется от имени root.
Литература

И под конец дам ссылку на книгу заклинаний LKMPG (Linux Kernel Module Programming Guide)

UPD:
У некоторых может не собраться модуль через Makefile, описанный выше.
Решение:
Создаём Makefile только с одной строкой: obj-m += test.o
И запускаем сборку так:
UPD2:
Поправил ошибки в исходнике.
Парсер глючит и сохраняет 'MODULE_DEscriptION( «My nice module» );'. Естественно в module_description все буквы заглавные.

UPD3:
несколько поправок к посту:

1) В функции device_open() находится race condition:

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

Атомарные операции нужно использовать во всех местах работы с данными. В данном случае и в close().

2) device_write() можно было вообще не писать, т.к. обработчик по
умолчанию write() сам возвращает ошибку.

3) у put_user() ОБЯЗАТЕЛЬНО нужно проверять результат. Если не ноль, то
нужно либо
а) вернуть результат -EFAULT и сделать вид, что ничего не было (т.е.
не удалять не до конца считанные данные из внутренних буферов, в данном
случае данные константные и ничего изменять не надо)
б) вернуть кол-во УЖЕ записанный байт (это называется partial read,
позволено POSIX'ом). При этом нужно следить за тем, чтобы не вернуть 0:
read() = 0 означает, что файл подошёл к концу, а это не так.

4) В ядре в качестве успешного кода завершения используется 0, а не
задефайненная константа SUCCESS. Есть исключения, например, в
обработчике сетевого пакета, но там, где возвращается либо -EXXX (код
ошибки), либо 0 (всё хорошо), используется именно константа 0.

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

Источник