Недавно мы научились основам написания модулей ядра Linux . Впрочем, рассмотренные тогда примеры были совсем простые, можно даже сказать, что игрушечные. Сегодня мы напишем модуль поинтереснее. Он будет создавать в каталоге /dev символьное устройство , с которым можно взаимодействовать из юзерспейса.
Кода не много, так что привожу его целиком:
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/irq.h>
#define DEVICE_NAME «chardev»
static int sensor_value = 0 ;
static DEFINE_MUTEX ( sensor_value_mtx ) ;
static int major ;
static struct class * cls ;
typedef struct ChardevPrivateData {
char buff [ 32 ] ;
int cnt ;
} ChardevPrivateData ;
static int device_open ( struct inode *, struct file * ) ;
static int device_release ( struct inode *, struct file * ) ;
static ssize_t device_read ( struct file *, char __user *,
size_t , loff_t * ) ;
static ssize_t device_write ( struct file *, const char __user *,
size_t , loff_t * ) ;
static struct file_operations chardev_fops = {
. read = device_read ,
. write = device_write ,
. open = device_open ,
. release = device_release ,
} ;
int init_module ( void ) {
struct device * dev ;
major = register_chrdev ( 0 , DEVICE_NAME , & chardev_fops ) ;
if ( major < 0 ) {
pr_alert ( «register_chrdev() failed: %d n » , major ) ;
return — EINVAL ;
}
pr_info ( «major = %d n » , major ) ;
cls = class_create ( THIS_MODULE , DEVICE_NAME ) ;
if ( IS_ERR ( cls ) ) {
pr_alert ( «class_create() failed: %ld n » , PTR_ERR ( cls ) ) ;
return — EINVAL ;
}
dev = device_create ( cls , NULL , MKDEV ( major , 0 ) , NULL , DEVICE_NAME ) ;
if ( IS_ERR ( dev ) ) {
pr_alert ( «device_create() failed: %ld n » , PTR_ERR ( dev ) ) ;
return — EINVAL ;
}
pr_info ( «/dev/%s created n » , DEVICE_NAME ) ;
return 0 ;
}
void cleanup_module ( void ) {
device_destroy ( cls , MKDEV ( major , 0 ) ) ;
class_destroy ( cls ) ;
unregister_chrdev ( major , DEVICE_NAME ) ;
}
static int device_open ( struct inode * inode , struct file * file ) {
ChardevPrivateData * pd ;
int val ;
if ( ! try_module_get ( THIS_MODULE ) ) {
pr_alert ( «try_module_get() failed n » ) ;
return — EINVAL ;
}
pd = kmalloc ( sizeof ( ChardevPrivateData ) , GFP_KERNEL ) ;
if ( pd == NULL ) {
pr_alert ( «kmalloc() failed n » ) ;
module_put ( THIS_MODULE ) ;
return — EINVAL ;
}
mutex_lock ( & sensor_value_mtx ) ;
val = sensor_value ;
sensor_value ++;
mutex_unlock ( & sensor_value_mtx ) ;
sprintf ( pd -> buff , «Dummy sensor value: %d n » , val ) ;
pd -> cnt = 0 ;
file -> private_data = pd ;
return 0 ;
}
static int device_release ( struct inode * inode , struct file * file ) {
kfree ( file -> private_data ) ;
module_put ( THIS_MODULE ) ;
return 0 ;
}
static ssize_t device_read ( struct file * file ,
char __user * buffer ,
size_t length ,
loff_t * offset ) {
int bytes_read = 0 ;
ChardevPrivateData * pd = file -> private_data ;
while ( length && ( pd -> buff [ pd -> cnt ] != ‘ ‘ ) ) {
if ( put_user ( pd -> buff [ pd -> cnt ] , buffer ++ ) != 0 )
return — EINVAL ;
pd -> cnt ++;
bytes_read ++;
length —;
}
return bytes_read ;
}
static ssize_t device_write ( struct file * filp ,
const char __user * buff ,
size_t len ,
loff_t * off ) {
pr_alert ( «device_write() is not implemented n » ) ;
return — EINVAL ;
}
MODULE_LICENSE ( «GPL» ) ;
А вот пример использования модуля:
$ dmesg | cut -d ‘ ‘ -f 2- | tail -n 2
major = 240
/dev/chardev created
$ sudo cat /dev/chardev
Dummy sensor value: 0
$ sudo cat /dev/chardev
Dummy sensor value: 1
$ sudo cat /dev/chardev
Dummy sensor value: 2
$ sudo rmmod chardev
Как же это работает? При загрузке модуля вызывается процедура init_module() . В ней при помощи register_chrdev() происходит регистрация символьного устройства. В качестве аргументов нужно передать major-номер устройства, имя устройства и структуру с указателями на кучу колбэков. В приведенном примере в качестве major-номера указан 0. Это означает, что номер выберет ОС среди никем не занятых. Колбэков в примере используется четыре, но на самом деле их доступно куда больше.
Fun fact! Код ядра Linux можно склонировать себе на машину и искать по нему при помощи какого-нибудь Sublime Text . Это позволяет быстро находить определение всех макросов и описание всех структур, а также документацию к ним.
Далее создается класс устройства (device class), а затем и конкретный экземпляр устройства, через device_create() . Один модуль может обслуживать много устройств одного класса. Чтобы модуль мог отличить одно устройство от другого, используются minor-номера. В нашем примере создается одно устройство с minor-номером 0, см макрос MKDEV .
Еще раз подчеркнем разницу между major- и minor-номерами устройства. Major-номера используются системой, чтобы понять, какой модуль обслуживает заданное устройство. Поэтому не должно быть двух модулей, использующих один и тот же major-номер. До minor-номеров ОС нет никакого дела. Эти номера используются только модулем, чтобы отличить один экземпляр устройства от другого.
При выходе из init_module() в системе будет создано символьное устройство /dev/chardev :
crw——- 1 root root 240, 0 Aug 7 12:34 /dev/chardev
Здесь 240 — это выбранный системой major-номер, а 0 представляет собой minor-номер. Буква c указывает на то, что это символьное устройство (character device). Блочным устройствам, таким, как жесткие диски, соответствует букв b .
Fun fact! В приведенном коде в случае любой ошибки возвращается EINVAL . С полным списком доступных кодов ошибок и их описанием можно ознакомиться в man errno .
При открытии устройства управление передается колбэку device_open() . Колбэк первым делом взывает try_module_get() . Эта процедура инкрементирует счетчик использования модуля. Значение счетчика отличное от нуля говорит системе о том, что модуль кем-то используется, и не может быть выгружен. Если счетчик невозможно увеличить (например, пользователь прямо сейчас просит систему выгрузить модуль), процедура возвращает false. Декремент счетчика осуществляется вызовом module_put() . Этот вызов всегда завершается успешно.
Текущее значение счетчика для данного модуля ядра можно увидеть через sysfs:
Далее в device_open() инициализируется структура ChardevPrivateData и указатель на нее записывается в file->private_data . Это специальное поле, где можно сохранить указатель на какие-то интересные модулю данные. Память под структуру выделяется при помощи kmalloc() .
Флаг GFP_KERNEL в аргументах kmalloc() указывает на то, что при выделении памяти допускается приостановить исполнение потока. Пользоваться этим флагом в обработчиках прерываний нельзя. Альтернативным аргументом является GFP_NOWAIT . При его использовании гарантируется, что память будет выделена без остановки потока. Есть и другие флаги . Процедура kfree() , предназначенная для освобождения памяти, никогда не останавливает исполнение потока.
Устройство может быть открыто в параллель несколькими процессами. Чтобы при доступе к глобальной переменной sensor_value не случилось гонки, в device_open() применены мьютексы. Из прочих примитивов синхронизации ядро Linux предлагает спинлоки и атомарные переменные.
При чтении из символьного устройства управление передается в device_read() . Это очень простая процедура, если не считать одного момента. Дело в том, что buffer находится в пользовательском адресном пространстве, и писать в него напрямую не допускается. Вместо этого нужно использовать макрос put_user() . Аналогично, для чтения предусмотрен get_user() . Оба макроса работают с типами, имеющими размер 8, 16, 32 или 64 бита. Для копирования данных б о льшего объема есть процедуры copy_to_user() и copy_from_user() . Названные макросы и процедуры возвращают 0 в случае успеха и иное значение в случае ошибки.
Остальной код в особых пояснениях не нуждается. Исходники к посту доступны в этом репозитории на GitHub . Там же вы найдете ссылки на материалы для самостоятельного изучения.
Дополнение: В продолжение темы см заметки Модули ядра Linux: таймеры и GPIO и Модули ядра Linux: обработка прерываний .
