Как можно заметить с данными, адрес  которых передается в функцию, можно  работать только с помощью методов  get_user и put_user.

Реализация  политики безопасности

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

      Для предотвращения использования модуля двумя и более пользовательскими  приложениями введем счетчик подключений. Счетчик будет увеличиваться на 1 при вызове метода open и уменьшаться на единицу при вызове метода close. При этом если счетчик больше нуля необходимо запретить подключение и вернуть ошибку.

1. static int device_open(struct inode *inode, struct file *file)
2. {
  
3. if (Device_Open)
 
4.   return -EBUSY;
 
 
6. Device_Open++;
  
7. return SUCCESS;
8. }
 
10. static int device_release(struct inode *inode, struct file *file)
11. {
 
12. Device_Open--;
  
13. return SUCCESS;
14. }

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

1. static int device_open(struct inode *inode, struct file *file)
2. {
  
3. if (Device_Open)
 
4.   return -EBUSY;
 
 
6. Device_Open++;
 
7. try_module_get(THIS_MODULE);
  
8. return SUCCESS;
9. }
 
11. static int device_release(struct inode *inode, struct file *file)
12. {
 
13. Device_Open--;
 
 
15. module_put(THIS_MODULE);
  
16. return SUCCESS;
17. }

Организация работы с модулем  ядра

      Не  смотря на то что модуль полностью готов и скомпилирован мы не можем его использовать пока не будет создан файл устройства. Для его создания вызовем в консоли стандартную утилиту mknod. Подробно данный процесс описан в главе «Создание файла устройства».

Заключение

      В ходе данной работы был разработан модуль для ядра Linux 2.6.38 и пользовательское приложение для демонстрации возможностей работы модуля ядра. Были изучены основы создания модулей и особенности работы с файлами устройств.

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

Библиографический список

1. Михаэль Кофлер Linux. Полное руководство. – СПб.: Питер, 2011. – 800с.
2. Роберт Лав Разработка ядра Linux. – М.: Вильямс, 2008. – 448с.
3. Ори Померанц Ядро Linux. Программирование модулей. – М.: КУДИЦ-Образ, 2002. – 112с.
4. В. Б. Иванов Прикладное программирование на С/С++. С нуля до мультимедийных и сетевых приложений. – М.: Солон-пресс, 2008. – 240с.
5. Arnold Robbins Bash Pocket Reference. O'Reilly Media, 2010. – 132с.

Приложение

Структура file_operations для ядра Linux 2.6.38

1. struct file_operations {
2. struct module *owner;
3. loff_t (*llseek) (struct file *, loff_t, int);
4. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
5. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
6. ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
7. ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
8. int (*readdir) (struct file *, void *, filldir_t);
9. unsigned int (*poll) (struct file *, struct poll_table_struct *);
10. long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
11. long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
12. int (*mmap) (struct file *, struct vm_area_struct *);
13. int (*open) (struct inode *, struct file *);
14. int (*flush) (struct file *, fl_owner_t id);
15. int (*release) (struct inode *, struct file *);
16. int (*fsync) (struct file *, int datasync);
17. int (*aio_fsync) (struct kiocb *, int datasync);
18. int (*fasync) (int, struct file *, int);
19. int (*lock) (struct file *, int, struct file_lock *);
20. ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
21. unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
22. int (*check_flags)(int);
23. int (*flock) (struct file *, int, struct file_lock *);
24. ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
25. ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
26. int (*setlease)(struct file *, long, struct file_lock **);
27. long (*fallocate)(struct file *file, int mode, loff_t offset,loff_t len);
28. };

Код модуля ядра

1. #include <linux/module.h>
2. #include <linux/kernel.h>
3. #include <linux/fs.h>
4. #include <asm/uaccess.h>
 
6. #include "chardev.h"
7. #define SUCCESS 0
8. #define DEVICE_NAME "char_dev"
9. #define BUF_LEN 80
 
11. static int Device_Open = 0;
12. static int current_buffer;
13. static int init_current_buffer(void);
 
15. static char buf0[BUF_LEN], buf1[BUF_LEN], buf2[BUF_LEN], buf_temp[BUF_LEN];
 
17. static char *Message_Ptr;
 
19. static int device_open(struct inode *inode, struct file *file)
20. {
 
21. printk("device_open(%p)\n", file);
 
  
23. if (Device_Open)
 
24.   return -EBUSY;
 
 
26. Device_Open++;
 
27. Message_Ptr = buf0;
 
28. try_module_get(THIS_MODULE);
  
29. return SUCCESS;
30. }
 
32. static int device_release(struct inode *inode, struct file *file)
33. {
 
34. printk("<1>device_release(%p,%p)\n", inode, file);
 
 
36. Device_Open--;
 
 
38. module_put(THIS_MODULE);
  
39. return SUCCESS;
40. }
 
42. static ssize_t device_read(struct file *file, char __user * buffer, size_t length, loff_t * offset)
43. {
  
44. int bytes_read = 0;
 
45. printk("<1>device_read(%p,%p,%d)\n", file, buffer, length);
 
  
47. if (*Message_Ptr == 0)
 
48.   return 0;
 
  
50. while (length && *Message_Ptr) {
 
 
52.   put_user(*(Message_Ptr++), buffer++);
 
53.   length--;
 
54.   bytes_read++;
  
55. }
 
  
57. return bytes_read;
58. }
 
60. static ssize_t device_write(struct file *file,
 
61.           const char __user * buffer, size_t length, loff_t * offset)
62. {
  
63. int i;
 
 
65. printk("<1>device_write(%p,%s,%d)", file, buffer, length);
 
  
67. switch (current_buffer) {
  
68. case 0:
 
69.   for (i = 0; i < length && i < BUF_LEN; i++)
 
70.     get_user(buf0[i], buffer + i);
 
71.   break;
 
  
73. case 1:
 
74.   for (i = 0; i < length && i < BUF_LEN; i++)
 
75.     get_user(buf1[i], buffer + i);
 
76.   break;
 
  
78. case 2:
 
79.   for (i = 0; i < length && i < BUF_LEN; i++)
 
80.     get_user(buf2[i], buffer + i);
 
81.   break;
  
82. }
 
 
84. init_current_buffer();
  
85. return i;
86. }
 
88. int device_ioctl(struct inode *inode,
 
89.     struct file *file,            
 
90.     unsigned int ioctl_num,        
 
91.     unsigned long ioctl_param)
92. {
 
93. current_buffer = ioctl_num;
 
94. init_current_buffer();
 
95.   printk("<1>set buf num %d\n", ioctl_num);
 
  
97. return SUCCESS;
98. }
 
100. static loff_t device_llseek(struct file *file, int loff_t)
101. {
 
102. init_current_buffer();
 
103. Message_Ptr += loff_t;
 
104. printk("<1>set position %d\n", loff_t);
 
  
106. return SUCCESS;
107. }
 
109. struct file_operations Fops = {
 
110. .read = device_read,
 
111. .write = device_write,
 
112. .unlocked_ioctl = device_ioctl,
 
113. .open = device_open,
 
114. .release = device_release,
 
115. .llseek = device_llseek
116. };
 
118. int init_module()
119. {
  
120. int ret_val;
 
 
122. ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &Fops);
 
  
124. if (ret_val < 0) {
 
125.   printk("%s failed with %d\n",
 
126.          "Sorry, registering the character device ", ret_val);
 
127.   return ret_val;
  
128. }
 
 
130. printk("mknod %s c %d 0\n", DEVICE_FILE_NAME, MAJOR_NUM);
 
  
132. return 0;
133. }
 
135. static int init_current_buffer(){
  
136. int i;
  
137. switch (current_buffer) {
  
138. case 0:
 
139.   Message_Ptr = buf0;
 
140.   break;
 
  
142. case 1:
 
143.   Message_Ptr = buf1;
 
144.   break;
 
  
146. case 2:
 
147.   Message_Ptr = buf2;
 
148.   break;
  
149. }
 
151. return 0;
 
153. }
 
155. void cleanup_module()
156. {
  
157. int ret;
 
 
159. unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
 
161. }