Символьное устроство в модуле ядра

Мы уже создали наш первый модуль ядра и научились передавать параметры в ядро через командную строку.
Теперь посмотрим как создать символьное устроство.
Зачем это нужно?
Как мы уже знаем, в пространстве ядра пользовательские приложения ничего менять не могут.
Через командную строку можно передать параметры только при запуске модуля. В дальнешем мы по сути теряем связь с нашим творением и можем только наблюдать. Это не всегда удобно, скорее всегда не удобно.
Таким образом нам нужен интерфейс который был бы доступен на протяжении всего времени работы с модулем. Таким интерфесом является файл. Ядро может писать в файл, пользовательские приложения могут писать в файл. Идилия!

Приступим к реализации.
В Linux есть такая штука — character device. У нас его зовут символьным устройством. Он вполне себе подходит для наших целей.
Для создания этого устройства воспользуемся функцией register_chrdev. Ей нужно передать номер, имя для файла и структуру file_operations. Каждому зарегистрированному символьному устройству присвоен номер (Major number). Его можно указать в качестве первого параметра функции register_chrdev. А можно указать туда 0, тогда ядро присвоит этот номер из своих соображений.

Как всегда Makefile берем из первой статьи.
Создаем заголовочный файл с прототипами необходимых функций.

#define DEVICE_NAME "chardev"   /* Dev name as it appears in /proc/devices   */
#define BUF_LEN 80                              /* Max length of the message from the device */

static int __init blablamod_init(void);
static void __exit blablamod_exit(void);

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 *);

MODULE_LICENSE("GPL"); 
MODULE_AUTHOR("Dmitrey Salnikov <mr.dimas@meta.ua>"); 

Теперь создаем файл исходных кодов.

#include <linux/init.h> 
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

#include "blablamod.h" 

static int Major;                       /* Major number assigned to our device driver */
static int Device_Open = 0;     /* Is device open?  
                                                         * Used to prevent multiple access to device */
static char msg[BUF_LEN];       /* The msg the device will give when asked */
static char *msg_Ptr;

Тут мы объявили переменную для номера файла — символьного устройства, переменную-флаг для индикации открытого устройства, буфер для сообщения и указатель на него.
Теперь создаем структуру file_operations.

static struct file_operations fops = {
        .read = device_read,
        .write = device_write,
        .open = device_open,
        .release = device_release
};

Тут мы указали функции — обработчики.
Функция инициализации модуля выглядит так:

static int __init blablamod_init( void ) { 
   printk(KERN_NOTICE "BlablaModule loaded!\n" ); 
   
   Major = register_chrdev(0, DEVICE_NAME, &fops);

        if (Major < 0) {
          printk(KERN_ALERT "Registering char device failed with %d\n", Major);
          return Major;
        }

        printk(KERN_INFO "I was assigned major number %d. To talk to\n", Major);
        printk(KERN_INFO "the driver, create a dev file with\n");
        printk(KERN_INFO "'mknod /dev/%s c %d 0'.\n", DEVICE_NAME, Major);
        printk(KERN_INFO "Try various minor numbers. Try to cat and echo to\n");
        printk(KERN_INFO "the device file.\n");
        printk(KERN_INFO "Remove the device file and module when done.\n");

   
   return 0; 
}

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

static void __exit blablamod_exit( void ) { 
        unregister_chrdev(Major, DEVICE_NAME);
        
        printk(KERN_NOTICE "BlablaModule unloaded!\n" ); 
}

Регистрируем функции загрузки/выгрузки.

module_init( blablamod_init ); 
module_exit( blablamod_exit );

Функция открытия файла.

static int device_open(struct inode *inode, struct file *file)
{
        static int counter = 0;

        if (Device_Open)
                return -EBUSY;

        Device_Open++;
        sprintf(msg, "I already told you %d times Hello world!\n", counter++);
        msg_Ptr = msg;
        try_module_get(THIS_MODULE);

        return 0;
}

Думаю тут нечего объяснять.

Функция закрытия.

static int device_release(struct inode *inode, struct file *file)
{
        Device_Open--;          /* We're now ready for our next caller */

        /* 
         * Decrement the usage count, or else once you opened the file, you'll
         * never get get rid of the module. 
         */
        module_put(THIS_MODULE);

        return 0;
}

Функция чтения файла.

static ssize_t device_read(struct file *filp,   /* see include/linux/fs.h   */
                           char *buffer,        /* buffer to fill with data */
                           size_t length,       /* length of the buffer     */
                           loff_t * offset)
{
        /*
         * Number of bytes actually written to the buffer 
         */
        int bytes_read = 0;

        /*
         * If we're at the end of the message, 
         * return 0 signifying end of file 
         */
        if (*msg_Ptr == 0)
                return 0;

        /* 
         * Actually put the data into the buffer 
         */
        while (length && *msg_Ptr) {

                /* 
                 * The buffer is in the user data segment, not the kernel 
                 * segment so "*" assignment won't work.  We have to use 
                 * put_user which copies data from the kernel data segment to
                 * the user data segment. 
                 */
                put_user(*(msg_Ptr++), buffer++);

                length--;
                bytes_read++;
        }

        /* 
         * Most read functions return the number of bytes put into the buffer
         */
        return bytes_read;
}

Тут по идее тоже все должно быть ясно.
Запись поддерживать не будем.

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

Можно компилировать и запускать.
После запуска смотрим dmesg.

$ dmesg
[ 2776.539112] I was assigned major number 247. To talk to
[ 2776.539115] the driver, create a dev file with
[ 2776.539119] 'mknod /dev/chardev c 247 0'.
[ 2776.539122] Try various minor numbers. Try to cat and echo to
[ 2776.539125] the device file.
[ 2776.539128] Remove the device file and module when done.

Теперь создадим сам файл. Такой модуль не умеет создавать файлы. О том, как создать файл автоматически рассмотрим в следующем номере 😉

sudo mknod /dev/chardev c 247 0
sudo chmod 777 /dev/chardev

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

cat /dev/chardev

С каждым разом число увеличивается.

I already told you 0 times Hello world!
I already told you 1 times Hello world!
I already told you 2 times Hello world!

А вот при попытке записи:

echo "hello" > /dev/chardev

Должно появится сообщение в dmesg.

[ 2872.839241] Sorry, this operation isn't supported.

Вот и все. Код на GitHub.

PS Не забываем удалять файл после окончания работы с модулем.