• try_module_get(THIS_MODULE): увеличивает счетчик обращений на 1.
• try_module_put(THIS_MODULE): уменьшает счетчик обращений на 1.

Создание  файла устройства

      Для обеспечения возможности обратиться из пользовательского приложения к  нашему модулю создадим файл устройства с помощью mknod утилиты. Скрипт[5] для создания в нашем случае будет выглядеть так:

mknod char_dev c 100 0

      Где char_dev – имя файла, а 100 – номер который возвращает функция register_chrdev() при подключении модуля.

Работа  пользовательского  приложения с модулем  ядра

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

      Пример  программы для работы с модулем:

1. #include <fcntl.h>      /* open */
2. #include <unistd.h>     /* exit */
3. #include <sys/ioctl.h>  /* ioctl */
 
5. main()
6. {
 
7. int file_desc, ret_val, i = 0;
 
8. char msg[] = "Hello there!\n";
 
9. char msg2[] = "One two three\n";
 
10. char bmsg[80];
 
 
12. file_desc = open(DEVICE_FILE_NAME, O_RDWR);
  
13. if (file_desc < 0) {
 
14.   printf("Error opening %s\n", DEVICE_FILE_NAME);
 
15.   exit(-1);
  
16. }
 
17. ioctl(file_desc, 0, 1);
 
18. write(file_desc, msg, sizeof(msg));
 
19. ioctl(file_desc, 0, 2);
 
20. write(file_desc, msg2, sizeof(msg2));
 
21. ioctl(file_desc, 0, 1);
 
22. lseek(file_desc, 3, 0);
 
23. ret_val = read(file_desc, bmsg, sizeof(bmsg));
 
24. bmsg[ret_val] = "\0";
  
25. printf("-->");
  
26. printf(bmsg);
  
27. printf("\n");
 
 
29. ioctl(file_desc, 0, i++);
 
30. close(file_desc);
31. }

     Функция ioctl – определяет в какой буфер происходит запись. В 17 строке выбираем буфер под номером 1. В следующей строке происходит запись в выбранный буфер. Далее происходит запись в буфер под номером 2. Команда lseek передвигает указатель чтения на +3 байта. Функция read в итоге вернет «lo there!».

Разработка  модуля ядра

      Разработка  модуля ядра проходит в несколько  этапов:

1. создание простейшего модуля ядра;
2. создание прототипов необходимых функций;
3. реализация функций;
4. организация обмена данными с пространством пользователя;
5. реализация политики безопасности модуля ядра;
6. организация работы с модулем ядра

Разработка  простейшего модуля ядра

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

1. #include <linux/kernel.h>
2. #include <linux/module.h>
 
4. int init_module(void)
5. {
 
6.       printk("<1>Module loaded");
 
7.       return 0;
8. }
 
10. void cleanup_module()
11. {
 
12.       printk("<1>module removed");
13. }

     Данный  код является полностью работоспособным  и выводит сообщения при подключении  модуля и его отключении.

Создание  прототипов функций

      Для модуля понадобятся функции: open, close, write, read, ioctl и lseek. Создадим прототипы этих функций. Аргументы и возвращаемые значения можно найти в struct file_operations.

1. static int device_open(struct inode *inode, struct file *file)
2. static int device_release(struct inode *inode, struct file *file)
3. static ssize_t device_read(struct file *file, char __user * buffer, size_t length, loff_t * offset)
4. static ssize_t device_write(struct file *file, const char __user * buffer, size_t length, loff_t * offset)
5. int device_ioctl(struct inode *inode, struct file *file, unsigned int ioctl_num, unsigned long ioctl_param)
6. static loff_t device_llseek(struct file *file, int loff_t)

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

1. struct file_operations Fops = {
 
2. .read = device_read,
 
3. .write = device_write,
 
4. .unlocked_ioctl = device_ioctl,
 
5. .open = device_open,
 
6. .release = device_release,
 
7. .llseek = device_llseek
8. };

     Следующий шаг это регистрация устройства,  должна происходить при инициализации модуля:

1. register_chrdev(MAJOR_NUM, DEVICE_NAME, &Fops);

     Теперь  можно быть уверенным, что функции будут вызваны. Но при выгрузке модуля, но все равно останется зарегистрированным, что может привести к ошибке. Чтобы этого избежать, нужно вызвать метод unregister_chrdev(MAJOR_NUM, DEVICE_NAME)  в методе cleanup_module.

Реализация  функций

      На  данном этапе реализуется логика модуля ядра, пример организации которой подробно рассматривается в главе «Работа пользовательского приложения с модулем ядра». Но некоторые функции не будут работать  правильно, пока не будет организована передача данных между пространством пользователя и ядра.

Организация обмена данных с пространством  пользователя

      Примером  функций для которых необходим обмен данными между пространством пользователя и пространством ядра могут служить функции write и read:

1. static ssize_t device_write(struct file *file,
 
2.           const char __user * buffer, size_t length, loff_t * offset)
3. {
  
4. int i;
 
5. printk("<1>device_write(%p,%s,%d)", file, buffer, length);
  
6. switch (current_buffer) {
  
7. case 0:
 
8.   for (i = 0; i < length && i < BUF_LEN; i++)
 
9.     get_user(buf0[i], buffer + i);
 
10.   break;
 
  
12. case 1:
 
13.   for (i = 0; i < length && i < BUF_LEN; i++)
 
14.     get_user(buf1[i], buffer + i);
 
15.   break;
 
  
17. case 2:
 
18.   for (i = 0; i < length && i < BUF_LEN; i++)
 
19.     get_user(buf2[i], buffer + i);
 
20.   break;
  
21. }
 
22. init_current_buffer();
  
23. return i;
24. }
 
26. static ssize_t device_read(struct file *file, char __user * buffer, size_t length, loff_t * offset)
27. {
  
28. int bytes_read = 0;
 
29. printk("<1>device_read(%p,%p,%d)\n", file, buffer, length);
  
30. if (*Message_Ptr == 0)
 
31.   return 0;
  
32. while (length && *Message_Ptr) {
 
33.   put_user(*(Message_Ptr++), buffer++);
 
34.   length--;
 
35.   bytes_read++;
  
36. }
  
37. return bytes_read;
38. }