The Linux Kernel Module Programming Guide

 Авторы: Peter Jay Salzman, Michael Burian, Ori Pomerantz
 Copyright 2001, Peter Jay Salzman.
 2004-05-16 ver 2.6.0
 Перевод: Андрей Киселёв (kis_an [at] linuxgazette [dot] ru)

 Яковлев С: Данный труд написан для ядра 2.6
 Я проверял примеры на Suse 9.1.
 Архив исходников лежит тут (27 кб) .
 

Глава 1. Введение. 1.1. Что такое "Модуль Ядра"?

1.2. Как модули попадают в ядро?

 (Яковлев С.) : Например , на моем линуксе была выдана информация
 Module                  Size  Used by    Not tainted
 ip_conntrack_ftp        5168   0  (unused)
 ipt_conntrack           1656   2  (autoclean)
 ipt_state               1112   2  (autoclean)
 ip_conntrack           30340   3  (autoclean) 
 iptable_filter          2444   1  (autoclean)
 ip_tables              15104   3  [ipt_conntrack ipt_state iptable_filter]
 ppp_deflate             4248   0  (autoclean)
 bsd_comp                5272   0  (autoclean)
 ppp_async               8160   0  (autoclean)
 ppp_generic            24292   0  (autoclean) [ppp_deflate bsd_comp ppp_async]
 slhc                    6756   0  (autoclean) [ppp_generic]
 sb                      9204   1  (autoclean)
 sb_lib                 43470   0  (autoclean) [sb]
 uart401                 8004   0  (autoclean) [sb_lib]
 sound                  72552   1  (autoclean) [sb_lib uart401]
 soundcore               6500   5  (autoclean) [sb_lib sound]
 ide-cd                 34368   0  (autoclean)
 cdrom                  33792   0  (autoclean) [ide-cd]
 parport_pc             18788   1  (autoclean)
 lp                      8708   0  (autoclean)
 parport                37128   1  (autoclean) [parport_pc lp]
 autofs                 11828   0  (autoclean) (unused)
 rfcomm                 35168   0  (autoclean)
 l2cap                  18800   2  (autoclean) [rfcomm]
 bluez                  36452   1  (autoclean) [rfcomm l2cap]
 dmfe                   15777   1 
 floppy                 57052   0  (autoclean)
 sg                     35260   0  (autoclean) (unused)
 scsi_mod              107348   1  (autoclean) [sg]
 microcode               4252   0  (autoclean)
 nls_cp1251              4348   1  (autoclean)
 ntfs                   82476   1  (autoclean)
 keybdev                 2660   0  (unused)
 hid                    23620   0  (unused)
 usb-uhci               26256   0  (unused)
 usbcore                78604   1  [hid usb-uhci]
 mousedev                5300   1  (autoclean)
 input                   5888   0  (autoclean) [keybdev hid mousedev]
 ext3                   66160   4 
 jbd                    41984   4  [ext3]

     Название модуля, например softdog или ppp.
     Универсальный идентификатор, например char-major-10-30.

     alias char-major-10-30 softdog    

   insmod /lib/modules/2.6.0/kernel/fs/fat/fat.ko
   insmod /lib/modules/2.6.0/kernel/fs/msdos/msdos.ko
 или просто:
   modprobe -a msdos   

 path[misc]=/lib/modules/2.6.?/local
 keep
 path[net]=~p/mymodules
 options mydriver irq=10
 alias eth0 eepro
 
 
 У меня была немного другая картина (Яковлев С.)
 alias usb-controller usb-uhci
 alias sound-slot-0 sb
 post-install sound-slot-0 /bin/aumix-minimal -f /etc/.aumixrc -L >/dev/null 2>&1 || :
 pre-remove sound-slot-0 /bin/aumix-minimal -f /etc/.aumixrc -S >/dev/null 2>&1 || :
 alias eth0 dmfe
   

1.2.1.1. Механизм контроля версий

1.2.1.3. Проблемы компиляции

Глава 2. Hello World

 Пример 2-1. hello-1.c
 
 /*    hello-1.c - Простейший модуль ядра. */
 #include < linux/module.h>/* Необходим для любого модуля ядра */
 #include < linux/kernel.h>/* Здесь находится определение KERN_ALERT */
 int init_module(void)
 {
         printk("<1>Hello world 1.\n");
   /* 
    * Если вернуть ненулевое значение, 
    то это будет воспринято как признак ошибки,
    возникшей в процессе работы init_module; 
    в результате модуль не будет загружен. 
    */
         return 0;
 }
 
 void cleanup_module(void)
 {
         printk(KERN_ALERT "Goodbye world 1.\n");
 }
 

2.1.1. Знакомство с printk()

2.2. Сборка модулей ядра

    obj-m += hello-1.o

   make -C /usr/src/linux SUBDIRS=$PWD modules). 
 [root@pcsenonsrv test_module]# make -C /usr/src/linux-`uname -r` SUBDIRS=$PWD modules
 make: Entering directory `/usr/src/linux-2.6.x
   CC [M]  /root/test_module/hello-1.o
   Building modules, stage 2.
   MODPOST
   CC      /root/test_module/hello-1.mod.o
   LD [M]  /root/test_module/hello-1.ko
 make: Leaving directory `/usr/src/linux-2.6.x    

 Яковлев С. : Я собирал все примеры в Suse 9.1 . 
 Я отследил добавление и удаление модуля по файлу /var/log/messages .
 При добавлении модуля появилась запись :
 #Sep 18 20:51:23 linux kernel: hello_1: module license 'unspecified' taints kernel.
 #Sep 18 20:51:23 linux kernel: Hello world 1
 При удалении :
 #Sep 18 20:53:36 linux kernel: Goodbye world 1.
 

2.3. Hello World (часть 2)

 /*
  *  hello-2.c - 
  * Демонстрация использования макроопределений module_init() и module_exit().
  */
 #include < linux/module.h>       /* Необходим для любого модуля ядра */
 #include < linux/kernel.h>       /* Здесь находится определение KERN_ALERT */
 #include < linux/init.h>         /* Здесь находятся определения макросов */
 
 static int __init hello_2_init(void)
 {
         printk(KERN_ALERT "Hello, world 2\n");
         return 0;
 }
 
 static void __exit hello_2_exit(void)
 {
         printk(KERN_ALERT "Goodbye, world 2\n");
 }
 
 module_init(hello_2_init);
 module_exit(hello_2_exit);
 

 Пример 2-4. Makefile для сборки обоих модулей
 
 obj-m += hello-1.o
 obj-m += hello-2.o
 

  Яковлев С: Вот фрагмент из этого Makefile для Suse 9.1 :
 FONTMAPFILE = cp437.uni
 obj-y	 += mem.o random.o tty_io.o n_tty.o tty_ioctl.o pty.o misc.o lirc/
 obj-$(CONFIG_VT)		+= vt_ioctl.o vc_screen.o consolemap.o \
 				   consolemap_deftbl.o selection.o keyboard.o
 obj-$(CONFIG_HW_CONSOLE)	+= vt.o defkeymap.o
 obj-$(CONFIG_MAGIC_SYSRQ)	+= sysrq.o
 
 

2.4. Hello World (часть 3): Макроопределения __init и __exit

 Пример 2-5. hello-3.c
 /*
  *  hello-3.c - Использование макросов __init, __initdata и __exit.
  */
 #include < linux/module.h>  /* Необходим для любого модуля ядра */
 #include < linux/kernel.h>  /* Здесь находится определение KERN_ALERT */
 #include < linux/init.h>    /* Здесь находятся определения макросов */
 
 static int hello3_data __initdata = 3;
 static int __init hello_3_init(void)
 {
         printk(KERN_ALERT "Hello, world %d\n", hello3_data);
         return 0;
 }
 static void __exit hello_3_exit(void)
 {
         printk(KERN_ALERT "Goodbye, world 3\n");
 }
 
 module_init(hello_3_init);
 module_exit(hello_3_exit);
 

 
 # insmod hello-3.o
 Warning: loading hello-3.o will taint the kernel: no license
   See http://www.tux.org/lkml/#export-tainted for information about tainted modules
 Hello, world 3
 Module hello-3 loaded, with warnings

 /*
  * В настоящее время, для обозначения свободных лицензий, 
  * приняты следующие идентификаторы
  *
  *      "GPL"                     [GNU Public License v2 или выше]
  *      "GPL v2"                  [GNU Public License v2]
  *      "GPL and additional rights" [GNU Public License v2 ]
  *      "Dual BSD/GPL"              [GNU Public License v2
  *                                       или BSD license]
  *      "Dual MPL/GPL"                  [GNU Public License v2
  *                                       или Mozilla license]
  *
  * Кроме того, дополнительно имеются следующие идентификаторы
  *
  *      "Proprietary"        [проприетарный, не свободный продукт]
  *
  * Здесь присутствуют компоненты, подразумевающие двойное лицензирование, 
  * однако, по отношению к Linux они приобретают значение GPL, как наиболее 
  * уместное, так что это не является проблемой. 
  * Подобно тому, как LGPL связана с GPL
  *
  * На это есть несколько причин
  * 1. modinfo может показать сведения о лицензировании для тех пользователей, 
  *    которые желают, чтобы их набор программных компонент был свободным
  * 2. Сообщество может игнорировать отчеты об ошибках (bug reports), 
  * относящиеся    к проприетарным модулям
  * 3. Поставщики программных продуктов могут поступать аналогичным образом, 
  *    основываясь на своих собственных правилах
  */   
 

 Пример 2-6. hello-4.c
 /*
  *  hello-4.c - Демонстрация описания модуля.
  */
 #include < linux/module.h>
 #include < linux/kernel.h>
 #include < linux/init.h>
 #define DRIVER_AUTHOR "Peter Jay Salzman "
 #define DRIVER_DESC   "A sample driver"
 
 static int __init init_hello_4(void)
 {
         printk(KERN_ALERT "Hello, world 4\n");
         return 0;
 }
 
 static void __exit cleanup_hello_4(void)
 {
         printk(KERN_ALERT "Goodbye, world 4\n");
 }
 
 module_init(init_hello_4);
 module_exit(cleanup_hello_4);
 
 /*  
  *  Вы можете передавать в макросы строки:
  */
 
 /*
  * Запретить вывод предупреждения о "загрязнении" ядра.
  */
 MODULE_LICENSE("GPL");
 
 /*
  * или определения:
  */
 MODULE_AUTHOR(DRIVER_AUTHOR);    /* Автор модуля */
 MODULE_DESCRIPTION(DRIVER_DESC); /* Назначение модуля */
 /*
  *  Этот модуль использует устройство /dev/testdevice.  
  *  В будущих версиях ядра
  *  макрос MODULE_SUPPORTED_DEVICE может быть использован
  *  для автоматической настройки модуля, но пока
  *  он служит исключительно в описательных целях.
  */
 MODULE_SUPPORTED_DEVICE("testdevice");
 

     *
       "b" -- byte (байт);
     *
       "h" -- short int (короткое целое);
     *
       "i" -- integer (целое, как со знаком, так и без знака);
     *
       "l" -- long int (длинное целое, как со знаком, так и без знака);
     *
       "s" -- string (строка, должна объявляться как char*).

 int myint = 3;
 char *mystr;
 
 MODULE_PARAM(myint, "i");
 MODULE_PARAM(mystr, "s");    

 int myintArray[4];
 MODULE_PARAM(myintArray, "2-4i");
 

 Пример 2-7. hello-5.c
 
 /*
  *  hello-5.c - передачи модулю аргументов командной строки.
  */
 #include < linux/module.h>
 #include < linux/moduleparam.h>
 #include < linux/kernel.h>
 #include < linux/init.h>
 #include < linux/stat.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Peter Jay Salzman");
 
 static short int myshort = 1;
 static int myint = 420;
 static long int mylong = 9999;
 static char *mystring = "blah";
 /*
  * module_param(foo, int, 0000)
  * Первый параметр -- имя переменной,
  * Второй -- тип,
  * Последний -- биты прав доступа
  * для того, чтобы выставить в sysfs (если ненулевое значение) 
  * на более поздней стадии.
  */
 
 module_param(myshort, short, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 MODULE_PARM_DESC(myshort, "A short integer");
 module_param(myint, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 MODULE_PARM_DESC(myint, "An integer");
 module_param(mylong, long, S_IRUSR);
 MODULE_PARM_DESC(mylong, "A long integer");
 module_param(mystring, charp, 0000);
 MODULE_PARM_DESC(mystring, "A character string");
 
 static int __init hello_5_init(void)
 {
         printk(KERN_ALERT "Hello, world 5\n=============\n");
         printk(KERN_ALERT "myshort is a short integer: %hd\n", myshort);
         printk(KERN_ALERT "myint is an integer: %d\n", myint);
         printk(KERN_ALERT "mylong is a long integer: %ld\n", mylong);
         printk(KERN_ALERT "mystring is a string: %s\n", mystring);
         return 0;
 }
 
 static void __exit hello_5_exit(void)
 {
         printk(KERN_ALERT "Goodbye, world 5\n");
 }
 
 module_init(hello_5_init);
 module_exit(hello_5_exit);
 
 Давайте немножко поэкспериментируем с этим модулем:
 
 satan# insmod hello-5.o mystring="bebop" myshort=255
 myshort is a short integer: 255
 myint is an integer: 420
 mylong is a long integer: 9999
 mystring is a string: bebop
 
 satan# rmmod hello-5
 Goodbye, world 5
 
 satan# insmod hello-5.o mystring="supercalifragilisticexpialidocious" myint=100
 myshort is a short integer: 1
 myint is an integer: 100
 mylong is a long integer: 9999
 mystring is a string: supercalifragilisticexpialidocious
 
 satan# rmmod hello-5
 Goodbye, world 5
 
 satan# insmod hello-5.o mylong=hello
 hello-5.o: `hello' invalid for parameter mylong
 
  Яковлев С: На Suse все работает точно так же - смотрим все тот же /var/log/messages
 

 Пример 2-8. start.c
 /*
  *  start.c - Пример модуля, исходный текст которого размещен 
  *  в нескольких файлах
  */
 #include < linux/kernel.h>       /* Все-таки мы пишем код ядра! */
 #include < linux/module.h>       /* Необходим для любого модуля ядра */
 
 int init_module(void)
 {
         printk("Hello, world - this is the kernel speaking\n");
         return 0;
 }
 
 Пример 2-9. stop.c
 
 /*
  *  stop.c - Пример модуля, исходный текст которого 
  *  размещен в нескольких файлах
  */
 
 #include < linux/kernel.h>       /* Все-таки мы пишем код ядра! */
 #include < linux/module.h>       /* Необходим для любого модуля ядра */
 
 void cleanup_module()
 {
         printk("<1>Short is the life of a kernel module\n");
 }
  
 Пример 2-10. Makefile для сборки всех модулей
 
 obj-m += hello-1.o
 obj-m += hello-2.o
 obj-m += hello-3.o
 obj-m += hello-4.o
 obj-m += hello-5.o
 obj-m += startstop.o
 startstop-objs := start.o stop.o

  insmod: error inserting 'your_module_name.ko': -1 Invalid module format

 Jun 4 22:07:54  kernel:your_module_name:version magic '2.6.5-1.358custom 686
 REGPARM 4KSTACKS gcc-3.3' should be '2.6.5-1.358 686 4KSTACKS gcc-3.3'

  [root@pcsenonsrv 02-HelloWorld]# modinfo hello-4.ko
  license:        GPL
  author:         Peter Jay Salzman 
  description:    A sample driver
  vermagic:       2.6.5-1.358 686 REGPARM 4KSTACKS gcc-3.3
  depends:
 

  VERSION = 2
  PATCHLEVEL = 6
  SUBLEVEL = 5
  EXTRAVERSION = -1.358custom
  ...
 
 Теперь запустите make, чтобы обновить информацию о версии:
  [root@pcsenonsrv linux-2.6.x]# make
  CHK     include/linux/version.h
  UPD     include/linux/version.h
  SYMLINK include/asm -> include/asm-i386
  SPLIT   include/linux/autoconf.h -> include/config/*
  HOSTCC  scripts/basic/fixdep
  HOSTCC  scripts/basic/split-include
  HOSTCC  scripts/basic/docproc
  HOSTCC  scripts/conmakehash
  HOSTCC  scripts/kallsyms
  CC      scripts/empty.o
  ...

Глава 3. Дополнительные сведения

3.2. Функции, которые доступны из модулей

 #include < stdio.h>
 int main(void)
 { 
   printf("hello"); 
   return 0; 
 }  
  

3.4. Пространство имен

3.5. Адресное пространство

3.6. Драйверы устройств

 # 33ls -l /dev/hda[1-3]
 brw-rw----  1 root  disk  3, 1 Jul  5  2000 /dev/hda1
 brw-rw----  1 root  disk  3, 2 Jul  5  2000 /dev/hda2
 brw-rw----  1 root  disk  3, 3 Jul  5  2000 /dev/hda3

 crw-rw----  1 root  dial 4, 64 Feb 18 23:34 /dev/ttyS0
 crw-r-----  1 root  dial 4, 65 Nov 17 10:26 /dev/ttyS1
 crw-rw----  1 root  dial 4, 66 Jul  5  2000 /dev/ttyS2
 crw-rw----  1 root  dial 4, 67 Jul  5  2000 /dev/ttyS3

   1 char	Memory devices
 		  1 = /dev/mem		Physical memory access
 		  2 = /dev/kmem		Kernel virtual memory access
 		  3 = /dev/null		Null device
 		  4 = /dev/port		I/O port access
 		  5 = /dev/zero		Null byte source
 		  6 = /dev/core		OBSOLETE - replaced by /proc/kcore
 		  7 = /dev/full		Returns ENOSPC on write
 		  8 = /dev/random	Nondeterministic random number gen.
 		  9 = /dev/urandom	Faster, less secure random number gen.
 		 10 = /dev/aio		Asyncronous I/O notification interface
 		 11 = /dev/kmsg		Writes to this come out as printk's
   1 block	RAM disk
 		  0 = /dev/ram0		First RAM disk
 		  1 = /dev/ram1		Second RAM disk
  

 % ls -l /dev/fd0 /dev/fd0u1680
 brwxrwxrwx   1 root  floppy   2,  0 Jul  5  2000 /dev/fd0
 brw-rw----   1 root  floppy   2, 44 Jul  5  2000 /dev/fd0u1680

Глава 4. Файлы символьных устройств

  struct file_operations {
         struct module *owner;
          loff_t(*llseek) (struct file *, loff_t, int);
          ssize_t(*read) (struct file *, char __user *, size_t, loff_t *);
          ssize_t(*aio_read) (struct kiocb *, char __user *, size_t, loff_t);
          ssize_t(*write) (struct file *, const char __user *, size_t, loff_t *);
          ssize_t(*aio_write) (struct kiocb *, const char __user *, size_t,
                               loff_t);
         int (*readdir) (struct file *, void *, filldir_t);
         unsigned int (*poll) (struct file *, struct poll_table_struct *);
         int (*ioctl) (struct inode *, struct file *, unsigned int,
                       unsigned long);
         int (*mmap) (struct file *, struct vm_area_struct *);
         int (*open) (struct inode *, struct file *);
         int (*flush) (struct file *);
         int (*release) (struct inode *, struct file *);
         int (*fsync) (struct file *, struct dentry *, int datasync);
         int (*aio_fsync) (struct kiocb *, int datasync);
         int (*fasync) (int, struct file *, int);
         int (*lock) (struct file *, int, struct file_lock *);
          ssize_t(*readv) (struct file *, const struct iovec *, unsigned long,
                           loff_t *);
          ssize_t(*writev) (struct file *, const struct iovec *, unsigned long,
                            loff_t *);
          ssize_t(*sendfile) (struct file *, loff_t *, size_t, read_actor_t,
                              void __user *);
          ssize_t(*sendpage) (struct file *, struct page *, int, size_t,
                              loff_t *, int);
         unsigned long (*get_unmapped_area) (struct file *, unsigned long,
                                             unsigned long, unsigned long,
                                             unsigned long);
 };
 

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

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

4.2. Структура file

4.3. Регистрация устройства

4.4. Отключение устройства

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

4.5. chardev.c

  Пример 4-1. chardev.c
 /*
  *  chardev.c: Создает символьное устройство, доступное только для чтения
  *  возвращает сообщение, с указанием количества произведенных попыток 
  *  чтения из файла устройства
  */
 
 
 #include < linux/kernel.h>
 #include < linux/module.h>
 #include < linux/fs.h>
 #include < asm/uaccess.h>        /* определение функции put_user */
 /*
  *  Прототипы функций, обычно их выносят в заголовочный файл (.h)
  */
 int init_module(void);
 void cleanup_module(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 *);
 #define SUCCESS 0
 #define DEVICE_NAME "chardev"  
 #define BUF_LEN 80              /* Максимальная длина сообщения */
 /* 
  * Глобальные переменные,объявлены как static 
  */
 static int Major;             /* Старший номер устройства нашего драйвера */
 static int Device_Open = 0;   /* Устройство открыто?  
                           * используется для предотвращения одновременного 
                                * обращения из нескольких процессов */
 static char msg[BUF_LEN];     /* Здесь будет собираться текст сообщения */
 static char *msg_Ptr;
 static struct file_operations fops = {
   .read = device_read,
   .write = device_write,
   .open = device_open,
   .release = device_release
 };
 /*
  * Функции
  */
 int init_module(void)
 {
   Major = register_chrdev(0, DEVICE_NAME, &fops);
 
   if (Major < 0) {    
     printk("Registering the character device failed with %d\n",
             Major);
     return Major;
   }
   printk("<1>I was assigned major number %d.  To talk to\n", Major);
   printk("<1>the driver, create a dev file with\n");
   printk("'mknod /dev/chardev c %d 0'.\n", Major);
   printk("<1>Try various minor numbers.  Try to cat and echo to\n");
   printk("the device file.\n");
   printk("<1>Remove the device file and module when done.\n");
   return 0;
 }
 void cleanup_module(void)
 {
   /* 
    * Отключение устройства 
    */
   int ret = unregister_chrdev(Major, DEVICE_NAME);
   if (ret < 0)
     printk("Error in unregister_chrdev: %d\n", ret);
 }
 /*
  * Обработчики
  */
 /* 
  * Вызывается, когда процесс пытается открыть файл устройства, 
  *  например командой
  * "cat /dev/chardev"
  */
 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 SUCCESS;
 }
 
 /* 
  * Вызывается, когда процесс закрывает файл устройства.
  */
 static int device_release(struct inode *inode, struct file *file)
 {
   Device_Open--;       /* Теперь мы готовы обслужить другой процесс */
 
   /* 
    * Уменьшить счетчик обращений, иначе, после первой же удачной 
    *  попытки открыть файл устройства,
    * вы никогда не сможете выгрузить модуль. 
    */
   module_put(THIS_MODULE);
 
   return 0;
 }
 
 /* 
  * Вызывается, когда процесс пытается прочитать уже открытый 
  *  файл устройства
  */
 static ssize_t device_read(struct file *filp, /* см. include/linux/fs.h   */
          char *buffer,          /* буфер, куда надо положить данные */
          size_t length,                       /* размер буфера */
          loff_t * offset)
 {
   /*
    * Количество байт, фактически записанных в буфер
    */
   int bytes_read = 0;
 
   /*
    * Если достигли конца сообщения, 
    * вернуть 0, как признак конца файла
    */
   if (*msg_Ptr == 0)
     return 0;
 
   /* 
    * Перемещение данных в буфер
    */
   while (length && *msg_Ptr) {
 
     /* 
 * Буфер находится в пространстве пользователя (в сегменте данных), 
 * а не в пространстве ядра, поэтому простое присваивание здесь недопустимо. 
 * Для того, чтобы скопировать данные, мы используем функцию put_user, 
 * которая перенесет данные из пространства ядра в пространство пользователя. 
      */
     put_user(*(msg_Ptr++), buffer++);
 
     length--;
     bytes_read++;
         }
 
   /* 
    * В большинстве своем, функции чтения возвращают количество байт, 
    *  записанных в буфер.
    */
   return bytes_read;
 }
 
 /*  
  * Вызывается, когда процесс пытается записать в устройство, 
  * например так: echo "hi" > /dev/chardev
  */
 static ssize_t
 device_write(struct file *filp, const char *buff, size_t len, loff_t * off)
 {
   printk("<1>Sorry, this operation isn't supported.\n");
   return -EINVAL;
 }
 
 
   Пример 4-2. Makefile
 
 obj-m += chardev.o
 
 Яковлев С : При запуске команды insmod chardev.ko получаем :
 Sep 18 22:04:10 linux kernel: chardev: module license 'unspecified' taints kernel.
 Sep 18 22:04:10 linux kernel: I was assigned major number 254.  To talk to
 Sep 18 22:04:10 linux kernel: the driver, create a dev file with
 Sep 18 22:04:10 linux kernel: 'mknod /dev/chardev c 254 0'.
 Sep 18 22:04:10 linux kernel: Try various minor numbers.  Try to cat and echo to
 Sep 18 22:04:10 linux kernel: the device file.
 Sep 18 22:04:10 linux kernel: Remove the device file and module when done.
 
 Запускаем команды :
 mknod /dev/chardev c 254 0
 cat /dev/chardev
 и получаем вывод :
 I already told you 3 times Hello world!
 :-)
 

4.6. Создание модулей для работы с разными версиями ядра

Глава 5. Файловая система /proc

 Яковлев С : Вот что дает для сузи команда cat /proc/modules - фрагмент :
 lp 10916 0 - Live 0xd8a77000
 parport_pc 35264 1 - Live 0xd8880000
 parport 37704 2 lp,parport_pc, Live 0xd884b000
 af_packet 20360 0 - Live 0xd8aa8000
 chardev 2676 0 - Live 0xd8a26000
 startstop 1152 0 - Live 0xd8a24000
 hello_5 2048 0 - Live 0xd8a22000
 hello_3 1280 0 - Live 0xd8a19000
 nls_iso8859_1 4224 0 - Live 0xd89a9000
 usbserial 28912 0 - Live 0xd8a9f000
 А вот что дает команда cat /proc/meminfo - весь вывод для моей машины :
 MemTotal:       386656 kB
 MemFree:          4128 kB
 Buffers:         29944 kB
 Cached:         144724 kB
 SwapCached:          0 kB
 Active:         266088 kB
 Inactive:        69224 kB
 HighTotal:           0 kB
 HighFree:            0 kB
 LowTotal:       386656 kB
 LowFree:          4128 kB
 SwapTotal:      642560 kB
 SwapFree:       642528 kB
 Dirty:             116 kB
 Writeback:           0 kB
 Mapped:         218328 kB
 Slab:            40756 kB
 Committed_AS:   251524 kB
 PageTables:       1572 kB
 VmallocTotal:   638968 kB
 VmallocUsed:      2652 kB
 VmallocChunk:   636224 kB
 HugePages_Total:     0
 HugePages_Free:      0
 Hugepagesize:     4096 kB
 

 Поскольку мы не предусматриваем обработку операций открытия/закрытия файла 
 в файловой системе /proc, 
 то нам некуда вставлять вызовы функций try_module_get и try_module_put. 
 Если вдруг случится так, что модуль был выгружен в то время 
 как соответствующий файл в /proc оставался 
 открытым, к сожалению у нас не будет возможности избежать возможных последствий. 
 В следующем разделе мы расскажем о довольно сложном, но достаточно гибком способе 
 защиты от подобных ситуаций.
 

 
 Пример 5-1. procfs.c
 /*
  *  procfs.c -  пример создания "файла" в /proc
  */
 #include < linux/module.h> /* Необходимо для любого модуля */
 #include < linux/kernel.h> /* Все-таки мы работаем с ядром! */
 #include < linux/proc_fs.h>/* для работы с файловой системой /proc */
 struct proc_dir_entry *Our_Proc_File;
 /* Обработчик чтения из файла в /proc.
  *
  * Аргументы
  * =========
  * 1. Буфер с данными. Как его заполнить -- вы решаете сами
  * 2. Указатель на указатель на строку символов.
  *    Если вы не желаете использовать буфер
  *    размещенный ядром.
  * 3. Текущая позиция в файле
  * 4. Размер буфера.
  * 5. Признак конца файла, "1" == EOF.
  * 6. Указатель на данные (необходим в случае единственного
  *    обработчика на несколько файлов в /proc)
  *
  * Порядок использования и возвращаемое значение
  * =============================================
  * Нулевое значение == "буфер пуст", т.е. "Конец файла". 
  * Отрицательное значение == код ошибки.
  *
  * Дополнительные сведения
  * =======================
  * Основные принципы реализации этой функции
  * я почерпнул не из документации, а из исходных текстов
  * модулей, выполняющих подобные действия. 
  * Меня интересовало использование
  * поля get_info в структуре proc_dir_entry (Если вам это интересно
  * то для поиска я пользовался утилитами find и grep),
  * Интересующий меня пример я нашел в /fs/proc/array.c.
  *
  * Когда вам что-то непонятно, то лучше всего
  * поискать примеры в исходных текстах ядра. В этом состоит
  * огромное преимущество Linux перед другими ОС,
  * так как нам доступны все исходные тексты, так что --
  * пользуйтесь этим преимуществом!
  */
 ssize_t
 procfile_read(char *buffer,
               char **buffer_location,
               off_t offset, int buffer_length, int *eof, void *data)
 {
   printk(KERN_INFO "inside /proc/test : procfile_read\n");
 
   int len = 0;          /* Фактическое число байт */
   static int count = 1;
   /*
    * Мы всегда должны выдавать имеющуюся информацию,
    * если пользователь спрашивает -- мы должны ответить.
    *
    * Это очень важно, поскольку библиотечная функция read
    * будет продолжать обращаться к системному вызову
    * read до тех пор, пока ядро не ответит, что сведений больше нет
    * или пока буфер не будет заполнен.
    */
   if (offset > 0) {
     printk(KERN_INFO "offset %d : /proc/test : procfile_read, \
            wrote %d Bytes\n", (int)(offset), len);
     *eof = 1;
     return len;
   }
   /*
    * Заполнить буфер и получить его размер
    */
   len = sprintf(buffer,
           "For the %d%s time, go away!\n", count,
           (count % 100 > 10 && count % 100 < 14) ? "th" :
           (count % 10 == 1) ? "st" :
           (count % 10 == 2) ? "nd" :
           (count % 10 == 3) ? "rd" : "th");
   count++;
  /*
   * Вернуть размер буфера
   */
   printk(KERN_INFO
          "leaving /proc/test : procfile_read, wrote %d Bytes\n", len);
   return len;
 }
 int init_module()
 {
   int rv = 0;
   Our_Proc_File = create_proc_entry("test", 0644, NULL);
   Our_Proc_File->read_proc = procfile_read;
   Our_Proc_File->owner = THIS_MODULE;
   Our_Proc_File->mode = S_IFREG | S_IRUGO;
   Our_Proc_File->uid = 0;
   Our_Proc_File->gid = 0;
   Our_Proc_File->size = 37;
   printk(KERN_INFO "Trying to create /proc/test:\n");
   if (Our_Proc_File == NULL) {
     rv = -ENOMEM;
     remove_proc_entry("test", &proc_root);
     printk(KERN_INFO "Error: Could not initialize /proc/test\n");
   } else {
     printk(KERN_INFO "Success!\n");
   }
   return rv;
 }
 void cleanup_module()
 {
   remove_proc_entry("test", &proc_root);
   printk(KERN_INFO "/proc/test removed\n");
 }
 
 
   Пример 5-2. Makefile
 obj-m += procfs.o
 Яковлев С : При добавлении модуля :
 Sep 18 22:33:17 linux kernel: procfs: module license 'unspecified' taints kernel.
 Sep 18 22:33:17 linux kernel: Trying to create /proc/test:
 Sep 18 22:33:17 linux kernel: Success!
 При попытке посмотреть содержимое я обнаружил в /proc/test содержимое :
  for the 61th time , go away!
 

5.2. Файловая система /proc: создание файлов, доступных для записи

  Пример 5-3. procfs.c
 /* 
  *  procfs.c -  Пример создания файла в /proc, который доступен 
  *  как на чтение, так и на запись.
  */
 
 #include < linux/module.h>  /* Необходимо для любого модуля */
 #include < linux/kernel.h>  /* Все-таки мы работаем с ядром! */
 #include < linux/proc_fs.h> /* для работы с файловой системой /proc */
 #include < asm/uaccess.h>   /* определения функций get_user и put_user */
 /*
  * Место хранения последнего принятого сообщения,
  * которое будет выводиться в файл, чтобы показать, что
  * модуль действительно может получать ввод от пользователя
  */
 #define MESSAGE_LENGTH 80
 static char Message[MESSAGE_LENGTH];
 static struct proc_dir_entry *Our_Proc_File;
 #define PROC_ENTRY_FILENAME "rw_test"
 static ssize_t module_output(struct file *filp, /* см. include/linux/fs.h   */
              char *buffer,      /* буфер с данными */
              size_t length,     /* размер буфера   */
              loff_t * offset)
 {
   static int finished = 0;
   int i;
   char message[MESSAGE_LENGTH + 30];
   /* 
    * Для индикации признака конца файла возвращается 0.
    * Если этого не сделать, процесс будет продолжать 
    * пытаться читать из файла,
    * угодив в бесконечный цикл.
    */
   if (finished) {
     finished = 0;
     return 0;
   }
   /* 
    * Для передачи из пространства ядра в пространство пользователя 
    * следует использовать put_user.
    * В обратном направлении -- get_user.
    */
   sprintf(message, "Last input:%s", Message);
   for (i = 0; i < length && message[i]; i++)
     put_user(message[i], buffer + i);
   /* 
    * Обратите внимание: в данной ситуации мы исходим из предположения,
    * что размер сообщения меньше, чем len, в противном случае сообщение 
    * будт обрезано.
    * В реальной ситуации, если длина сообщения больше чем 
    * len, то возвращается len, а остаток сообщения возвращается 
    * на последующих вызовах.
    */
   finished = 1;
   return i;             /* Вернуть количество "прочитанных" байт */
 }
 static ssize_t
 module_input(struct file *filp, const char *buff, size_t len, loff_t * off)
 {
   int i;
   /* 
    * Переместить данные, полученные от пользователя в буфер, 
    * который позднее будет выведен функцией module_output.
    */
   for (i = 0; i < MESSAGE_LENGTH - 1 && i < len; i++)
     get_user(Message[i], buff + i);
 
   Message[i] = '\0';    /* Обычная строка, завершающаяся символом \0 */
   return i;
 }
 /* 
  * Эта функция принимает решение о праве на выполнение операций с файлом
  * 0 -- разрешено, ненулеое значение -- запрещено.
  *
  * Операции с файлом могут быть:
  * 0 - Исполнениеe (не имеет смысла в нашей ситуации)
  * 2 - Запись (передача от пользователя к модулю ядра)
  * 4 - Чтение (передача от модуля ядра к пользователю)
  *
  * Эта функция проверяет права доступа к файлу
  * Права, выводимые командой ls -l 
  * могут быть проигнорированы здесь.
  */
 static int module_permission(struct inode *inode, int op, struct nameidata *foo)
 {
   /* 
    * Позволим любому читать файл, но
    * писать -- только root-у (uid 0)
    */
   if (op == 4 || (op == 2 && current->euid == 0))
     return 0;
 
   /* 
    * Если что-то иное -- запретить доступ
    */
         return -EACCES;
 }
 /* 
  * Файл открыт -- пока нам нет нужды беспокоиться о чем-то
  * единственное, что нужно сделать -- это нарастить 
  * счетчик обращений к модулю.
  */
 int module_open(struct inode *inode, struct file *file)
 {
   try_module_get(THIS_MODULE);
   return 0;
 }
 /* 
  * Файл закрыт -- уменьшить счетчик обращений.
  */
 int module_close(struct inode *inode, struct file *file)
 {
   module_put(THIS_MODULE);
   return 0;             /* все нормально! */
 }
 static struct file_operations File_Ops_4_Our_Proc_File = {
         .read = module_output,
         .write = module_input,
         .open = module_open,
         .release = module_close,
 };
 /* 
  * Операции над индексной записью нашего файла. Необходима
  * для того, чтобы указать местоположение структуры
  * file_operations нашего файла, а так же, чтобы задать адрес
  * функции определения прав доступа к файлу. Здесь можно указать адреса
  * других функций-обработчиков, но нас они не интересуют.
  */
 static struct inode_operations Inode_Ops_4_Our_Proc_File = {
   .permission = module_permission,      /* проверка прав доступа */
 };
 /*
  * Начальная и конечная функции модуля
  */
 int init_module()
 {
   int rv = 0;
   Our_Proc_File = create_proc_entry(PROC_ENTRY_FILENAME, 0644, NULL);
   Our_Proc_File->owner = THIS_MODULE;
   Our_Proc_File->proc_iops = &Inode_Ops_4_Our_Proc_File;
   Our_Proc_File->proc_fops = &File_Ops_4_Our_Proc_File;
   Our_Proc_File->mode = S_IFREG | S_IRUGO | S_IWUSR;
   Our_Proc_File->uid = 0;
   Our_Proc_File->gid = 0;
   Our_Proc_File->size = 80;
   if (Our_Proc_File == NULL) {
     rv = -ENOMEM;
     remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
     printk(KERN_INFO "Error: Could not initialize /proc/test\n");
   }
 
   return rv;
 }
 void cleanup_module()
 {
   remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
 }
 
 
  Яковлев С: При регистрации этого модуля появится файл /proc/rw_test
 

Глава 6. Работа с файлами устройств

 Пример 6-1. chardev.c
 /*
  *  chardev.c - Пример создания символьного устройства 
  *              доступного на запись/чтение
  */
 
 #include < linux/module.h> /* Необходимо для любого модуля */
 #include < linux/kernel.h> /* Все-таки мы работаем с ядром! */
 #include < linux/fs.h>
 #include < asm/uaccess.h>        /* определения функций get_user и put_user */
 #include "chardev.h"
 #define SUCCESS 0
 #define DEVICE_NAME "char_dev"
 #define BUF_LEN 80
 /*
  * Устройство уже открыто? Используется для
  * предотвращения конкурирующих запросов к устройству
  */
 static int Device_Open = 0;
 /*
  * Ответ устройства на запрос
  */
 static char Message[BUF_LEN];
 /*
  * Позиция в буфере.
  * Используется в том случае, если сообщение оказывется длиннее
  * чем размер буфера. 
  */
 static char *Message_Ptr;
 /* 
  * Вызывается когда процесс пытается открыть файл устройства
  */
 static int device_open(struct inode *inode, struct file *file)
 {
 #ifdef DEBUG
   printk("device_open(%p)\n", file);
 #endif
   /* 
    * В каждый конкретный момент времени только один процесс может 
    *  открыть файл устройства 
    */
   if (Device_Open)
     return -EBUSY;
   Device_Open++;
   /*
    * Инициализация сообщения
    */
   Message_Ptr = Message;
   try_module_get(THIS_MODULE);
   return SUCCESS;
 }
 static int device_release(struct inode *inode, struct file *file)
 {
 #ifdef DEBUG
   printk("device_release(%p,%p)\n", inode, file);
 #endif
   /* 
    * Теперь мы готовы принять запрос от другого процесса
    */
   Device_Open--;
   module_put(THIS_MODULE);
   return SUCCESS;
 }
 /* 
  * Вызывается когда процесс, открывший файл устройства
  * пытается считать из него данные.
  */
 static ssize_t device_read(struct file *file, /* см. include/linux/fs.h   */
             char __user * buffer,             /* буфер для сообщения */
             size_t length,                    /* размер буфера       */
             loff_t * offset)
 {
   /* 
    * Количество байт, фактически записанных в буфер
    */
   int bytes_read = 0;
 
 #ifdef DEBUG
   printk("device_read(%p,%p,%d)\n", file, buffer, length);
 #endif
 
   /* 
    * Если достигнут конец сообщения -- вернуть 0
    * (признак конца файла) 
    */
   if (*Message_Ptr == 0)
     return 0;
 
   /* 
    * Собственно запись данных в буфер
    */
   while (length && *Message_Ptr) {
 
     /* 
      * Поскольку буфер располагается в пространстве пользователя,
      * обычное присвоение не сработает. Поэтому
      * для записи данных используется put_user,
      * которая копирует данные из пространства ядра
      * в пространство пользователя.
      */
     put_user(*(Message_Ptr++), buffer++);
     length--;
     bytes_read++;
   }
 
 #ifdef DEBUG
   printk("Read %d bytes, %d left\n", bytes_read, length);
 #endif
 
   /* 
    * Вернуть количество байт, помещенных в буфер.
    */
   return bytes_read;
 }
 
 /* 
  * Вызывается при попытке записи в файл устройства
  */
 static ssize_t
 device_write(struct file *file,
             const char __user * buffer, size_t length, loff_t * offset)
 {
   int i;
 
 #ifdef DEBUG
   printk("device_write(%p,%s,%d)", file, buffer, length);
 #endif
 
   for (i = 0; i < length && i < BUF_LEN; i++)
     get_user(Message[i], buffer + i);
 
   Message_Ptr = Message;
 
   /* 
    * Вернуть количество принятых байт
    */
   return i;
 }
 
 /* 
  * Вызывается, когда процесс пытается выполнить операцию ioctl 
  * над файлом устройства.
  * Кроме inode и структуры file функция получает 
  * два дополнительных параметра:
  * номер ioctl и дополнительные аргументы.
  *
  */
 int device_ioctl(struct inode *inode, /* см. include/linux/fs.h */
       struct file *file,              /* то же самое */
       unsigned int ioctl_num,         /* номер и аргументы ioctl */
       unsigned long ioctl_param)
 {
   int i;
   char *temp;
   char ch;
 
   /* 
    * Реакция на различные команды ioctl 
    */
   switch (ioctl_num) {
   case IOCTL_SET_MSG:
     /* 
      * Принять указатель на сообщение (в пространстве пользователя) 
      * и переписать в буфер. Адрес которого задан в дополнительно аргументе.
      */
     temp = (char *)ioctl_param;
 
     /* 
      * Найти длину сообщения
      */
     get_user(ch, temp);
     for (i = 0; ch && i < BUF_LEN; i++, temp++)
       get_user(ch, temp);
 
     device_write(file, (char *)ioctl_param, i, 0);
     break;
 
   case IOCTL_GET_MSG:
     /* 
      * Передать текущее сообщение вызывающему процессу - 
      * записать по указанному адресу.
      */
     i = device_read(file, (char *)ioctl_param, 99, 0);
 
     /* 
      * Вставить в буфер завершающий символ \0
      */
     put_user('\0', (char *)ioctl_param + i);
     break;
 
   case IOCTL_GET_NTH_BYTE:
     /* 
      * Этот вызов является вводом (ioctl_param) и
      * выводом (возвращаемое значение функции) одновременно
      */
     return Message[ioctl_param];
     break;
   }
 
   return SUCCESS;
 }
 
 /* Объявлнеия */
 
 /* 
  * В этой структуре хранятся адреса функций-обработчиков
  * операций, производимых процессом над устройством.
  * Поскольку указатель на эту структуру хранится в таблице устройств,
  * она не может быть локальной для init_module. 
  * Отсутствующие указатели в структуре забиваются значением NULL.
  */
 struct file_operations Fops = {
   .read = device_read,
   .write = device_write,
   .ioctl = device_ioctl,
   .open = device_open,
   .release = device_release,    /* оно же close */
 };
 
 /* 
  * Инициализация модуля - Регистрация символьного устройства
  */
 int init_module()
 {
   int ret_val;
   /* 
    * Регистрация символьного устройства (по крайней мере - 
    * попытка регистрации) 
    */
   ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &Fops);
 
   /* 
    * Отрицательное значение означает ошибку
    */
   if (ret_val < 0) {
     printk("%s failed with %d\n",
            "Sorry, registering the character device ", ret_val);
     return ret_val;
   }
 
   printk("%s The major device number is %d.\n",
          "Registeration is a success", MAJOR_NUM);
   printk("If you want to talk to the device driver,\n");
   printk("you'll have to create a device file. \n");
   printk("We suggest you use:\n");
   printk("mknod %s c %d 0\n", DEVICE_FILE_NAME, MAJOR_NUM);
   printk("The device file name is important, because\n");
   printk("the ioctl program assumes that's the\n");
   printk("file you'll use.\n");
 
   return 0;
 }
 
 /* 
  * Завершение работы модуля - дерегистрация файла в /proc 
  */
 void cleanup_module()
 {
   int ret;
 
   /* 
    * Дерегистрация устройства
    */
   ret = unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
 
   /* 
    * Если обнаружена ошибка -- вывести сообщение
    */
   if (ret < 0)
     printk("Error in module_unregister_chrdev: %d\n", ret);
 }
      
 
 Пример 6-2. chardev.h
 
 /*
  *  chardev.h - определения ioctl.
  *
  *  Определения, которые здесь находятся, должны помещаться 
  *  в заголовочный файл потому,
  *  что они потребуются как модулю ядра (chardev.c), так и
  *  вызывающему процессу (ioctl.c)
  */
 
 #ifndef CHARDEV_H
 #define CHARDEV_H
 
 #include < linux/ioctl.h>
 
 /*
  * Старший номер устройства. В случае использования ioctl,
  * мы уже лишены возможности воспользоваться динамическим номером,
  * поскольку он должен быть известен заранее.
  */
 #define MAJOR_NUM 100
 
 /*
  * Операция передачи сообщения драйверу устройства
  */
 #define IOCTL_SET_MSG _IOR(MAJOR_NUM, 0, char *)
 /*
  * _IOR означает, что команда передает данные
  * от пользовательского процесса к модулю ядра
  *
  * Первый аргумент, MAJOR_NUM -- старший номер устройства.
  *
  * Второй аргумент -- код команды
  * (можно указать иное значение).
  *
  * Третий аргумент -- тип данных, передаваемых в ядро
  */
 
 /* 
  * Операция получения сообщения от драйвера устройства
  */
 #define IOCTL_GET_MSG _IOR(MAJOR_NUM, 1, char *)
 /* 
  * Эта команда IOCTL используется для вывода данных.
  * Нам по прежнему нужен буфер, размещенный в адресном пространстве 
  * вызывающего процесса, куда это сообщение должно быть переписано.
  */
 
 /* 
  * Команда получения n-ного байта сообщения
  */
 #define IOCTL_GET_NTH_BYTE _IOWR(MAJOR_NUM, 2, int)
 /*
  * Здесь команда IOCTL работает как на ввод, так и на вывод.
  * Она принимает от пользователя номер байта (n),
  * и возвращает n-ный байт сообщения (Message[n]). 
  */
 
 /* 
  * Имя файла устройства
  */
 #define DEVICE_FILE_NAME "char_dev"
 
 #endif
      
 
   Пример 6-3. ioctl.c
 
 /*
  *  ioctl.c - Пример программы, использующей ioctl для управления модулем ядра
  *
  *  До сих пор мы ползовались командой cat, для передачи данных в/из модуля.
  *  Теперь же мы должны написать свою программу, которая использовала бы ioctl.
  */
 
 /*
  * Определения старшего номера устройства и коды операций ioctl
  */
 #include "chardev.h"
 
 #include < fcntl.h>      /* open */
 #include < unistd.h>     /* exit */
 #include < sys/ioctl.h>  /* ioctl */
 
 /* 
  * Функции работы с драйвером через ioctl  
  */
 
 ioctl_set_msg(int file_desc, char *message)
 {
   int ret_val;
 
   ret_val = ioctl(file_desc, IOCTL_SET_MSG, message);
 
   if (ret_val < 0) {
     printf("Ошибка при вызове ioctl_set_msg: %d\n", ret_val);
     exit(-1);
   }
 }
 
 ioctl_get_msg(int file_desc)
 {
   int ret_val;
   char message[100];
 
   /* 
    * Внимание - ядро понятия не имеет -- какой длины буфер мы используем
    * поэтому возможна ошибка, связанная с переполнением буфера.
    * В реальных проектах вам необходимо предусмотреть
    * передачу в ioctl двух дополнительных параметров:
    * собственно буфера сообщения и его длину
    */
   ret_val = ioctl(file_desc, IOCTL_GET_MSG, message);
 
   if (ret_val < 0) {
     printf("Ошибка при вызове ioctl_get_msg: %d\n", ret_val);
     exit(-1);
   }
 
   printf("Получено сообщение (get_msg): %s\n", message);
 }
 
 ioctl_get_nth_byte(int file_desc)
 {
   int i;
   char c;
 
   printf("N-ный байт в сообщении (get_nth_byte): ");
 
   i = 0;
   while (c != 0) {
     c = ioctl(file_desc, IOCTL_GET_NTH_BYTE, i++);
 
     if (c < 0) {
       printf
         ("Ошибка при вызове ioctl_get_nth_byte на %d-м байте.\n", i);
       exit(-1);
     }
 
     putchar(c);
   }
   putchar('\n');
 }
 
 /* 
  * Main - Проверка работоспособности функции ioctl
  */
 main()
 {
   int file_desc, ret_val;
   char *msg = "Это сообщение передается через ioctl\n";
 
   file_desc = open(DEVICE_FILE_NAME, 0);
   if (file_desc < 0) {
     printf("Невозможно открыть файл устройства: %s\n", DEVICE_FILE_NAME);
     exit(-1);
   }
 
   ioctl_get_nth_byte(file_desc);
   ioctl_get_msg(file_desc);
   ioctl_set_msg(file_desc, msg);
 
   close(file_desc);
 }
 
 
 
 Пример 6-4. Makefile
 
 obj-m += chardev.o
 

 Пример 6-5. build.sh
 #/bin/sh
 # сборка пользовательского приложения
 gcc -o ioctl ioctl.c
 # создание файла устройства
 mknod char_dev c 100 0
 
 Яковлев С: После регистрации нужно выполнить команду :
   mknod char_dev c 100 0
   После чего запускаем ./ioctl , которая будет выполнять функции cat .
 
 

Глава 7. Системные вызовы

. Строго говоря, процесс не имеет доступа в пространство ядра. Он не может обращаться к памяти ядра и не может вызывать функции в ядре. Микропроцессор ограничивает такого рода доступ на аппаратном уровне (вот почему режим исполнения ядра называется защищенным, или привилегированным). Системные вызовы являются исключением из этого правила. Чтобы исполнить системный вызов, процесс заполняет регистры микропроцессора соответствующими значениями и выполняет специальную инструкцию, которая производит переход в предопределенное место в пространстве ядра (разумеется, точка перехода доступна пользовательским процессам на чтение). Для платформы Intel -- это инструкция прерывания с вектором 0x80. Микропроцессор воспринимает это как переход из ограниченного пользовательского режима в защищенный режим ядра, где позволено делать все, что вам заблагорассудится. Точка перехода, в ядре, называется system_call. Процедура, которая там находится, проверяет номер системного вызова, который сообщает ядру -- какую именно услугу запрашивает процесс. Затем, она просматривает таблицу системных вызовов (sys_call_table), отыскивает адрес функции ядра, которую следует вызвать, после чего вызывается нужная функция. По окончании работы системного вызова, выполняется ряд дополнительных проверок и лишь после этого управление возвращается вызывающему процессу (или другому процессу, если вызывающий процесс исчерпал свой квант времени). Код, выполняющий все вышеперечисленные действия, вы найдете в файле arch//kernel/entry.S, после строки ENTRY(system_call). Итак, если вас одолевает желание изменить поведение некоторого системного вызова, то первое, что необходимо сделать -- это написать вашу собственную функцию, которая выполняла бы требуемые действия (обычно, после выполнения своих действий, в подобных случаях, вызывается первоначальная функция, реализующая системный вызов), затем -- изменить указатель в sys_call_table так, чтобы он указывал на вашу функцию. Поскольку ваш модуль впоследствии может быть выгружен, то следует предусмотреть восстановление системы в ее первоначальное состояние, чтобы не оставлять ее в нестабильном состоянии. Это делается в пределах функции cleanup_module. Ниже приводится исходный текст такого модуля. Он "шпионит" за выбранным пользователем, и посылать через printk сообщение всякий раз, когда данный пользователь открывает какой-либо файл. Для этого, системный вызов open(), подменяется функцией с именем our_sys_open. Она проверяет UID (User ID) текущего процесса, и если он равен заданному, то вызывает printk, чтобы сообщить имя открываемого файла, и в заключение вызывает оригинальную функцию open() с теми же параметрами, которая открывает требуемый файл. Функция init_module изменяет соответствующий указатель в sys_call_table и сохраняет его первоначальное значение в переменной. Функция cleanup_module восстанавливает указатель в sys_call_table, используя эту переменную. В данном подходе кроются свои "подводные камни" из-за возможности существования двух модулей, перекрывающих один и тот же системный вызов. Представьте себе: имеется два модуля, А и B. Пусть модуль A перекрывает системный вызов open, своей функцией A_open, а модуль B -- функцией B_open. Первым загружается модуль A, он заменяет системный вызов open на A_open. Затем загружается модуль B, который заменит системный вызов A_open на B_open. Модуль B полагает, что он подменил оригинальный системный вызов, хотя на самом деле был подменен вызов A_open. Теперь, если модуль B выгрузить первым, то ничего страшного не произойдет -- он просто восстановит запись в таблице sys_call_table в значение A_open, который в свою очередь вызывает оригинальную функцию sys_open. Однако, если первым будет выгружен модуль А, а затем B, то система "рухнет". Модуль А восстановит адрес в sys_call_table, указывающий на оригинальную функцию sys_open, "отсекая" таким образом модуль B от обработки действий по открытию файлов. Затем, когда будет выгружен модуль B, он восстановит адрес в sys_call_table на тот, который запомнил сам, потому что он считает его оригинальным. Т.е. вызовы будут направлены в функцию A_open, которой уже нет в памяти. На первый взгляд, проблему можно решить, проверкой -- совпадает ли адрес в sys_call_table с адресом нашей функции open и если не совпадает, то не восстанавливать значение этого вызова (таким образом B не будет "восстанавливать" системный вызов), но это порождает другую проблему. Когда выгружается модуль А, он "видит", что системный вызов был изменен на B_open и "отказывается" от восстановления указателя на sys_open. Теперь, функция B_open будет по прежнему пытаться вызывать A_open, которой больше не существует в памяти, так что система "рухнет" еще раньше -- до удаления модуля B. Обратите внимание: подобные проблемы делают такую "подмену" системных вызовов неприменимой для широкого распространения. С целью предотвращения потенциальной опасности, связанной с подменой адресов системных вызовов, ядро более не экспортирует sys_call_table. Поэтому, если вы желаете сделать нечто большее, чем просто пробежать глазами по тексту данного примера, вам надлежит наложить "заплату" на ядро. В каталоге с примерами вы найдете файл README и "заплату". Как вы наверняка понимаете, подобные модификации сопряжены с определенными трудностями, поэтому я не рекомендую производить их на системах, владельцем которых вы не являетесь или не в состоянии быстро восстановить. Если вас одолевают сомнения, то лучшим выбором будет отказ от прогона этого примера.

 Пример 7-1. syscall.c
 
 /*
  *  syscall.c
  *
  *  Пример "перехвата" системного вызова.
  */
 
 /*
  * Copyright (C) 2001 by Peter Jay Salzman
  */
 
 /*
  * Необходимые заголовочные файлы
  */
 
 #include < linux/kernel.h>      /* Все-таки мы работаем с ядром! */
 #include < linux/module.h>      /* Необходимо для любого модуля */
 #include < linux/moduleparam.h> /* для передачи параметров модулю */
 #include < linux/unistd.h>      /* Список системных вызовов */
 
 /* 
  * Необходимо, чтобы уметь определять
  * user id вызвавшего процесса. 
  */
 #include < linux/sched.h>
 #include < asm/uaccess.h>
 
 /* 
  * Таблица системных вызовов (таблица адресов функций). 
  * Просто определим ее как ссылку на внешнюю таблицу.
  *
  * sys_call_table больше не экспортируется ядрами 2.6.x.
  * Если вы намереваетесь опробовать этот ОПАСНЫЙ модуль,
  * вам следует наложить "заплату" на ядро и пересобрать его
  */
 extern void *sys_call_table[];
 
 /* 
  * UID пользователя, за которым "шпионим",
  * принимается из командной строки
  */
 static int uid;
 module_param(uid, int, 0644);
 
 /* 
  * Указатель на оригинальную функцию, выполняющую системный вызов.
  * Мы сохраняем ее, вместо того, чтобы напрямую вызывать оригинальную
  * функцию, для того, чтобы имелась возможность вызова
  * обработчиков, вставленных до нас
  * Это не гарантирует 100% безопасность, поскольку другой модуль,
  * замещающий sys_open может быть выгружен раньше нашего модуля.
  *
  * Другая причина -- мы не можем получить адрес оригинальной sys_open.
  * Этот адрес не экспортируется ядром.
  */
 asmlinkage int (*original_call) (const char *, int, int);
 
 /* 
  * Функция, замещающая sys_open (вызывается
  * всякий раз, когда делается обращение к системному вызову open).
  * Прототип функции, количество аргументов и их тип
  * вы найдете в fs/open.c.
  *
  * Теоретически - мы "привязаны" к данной конкретной
  * версии ядра. Практически -- системные вызовы
  * очень редко подвергаются кардинальному изменению,
  * поскольку это сделало бы огромное количество программного обеспечения
  * несовместимым с ядром и потребовало бы их пересборки.
  */
 asmlinkage int our_sys_open(const char *filename, int flags, int mode)
 {
   int i = 0;
   char ch;
 
   /* 
    * Проверить -- это искомый пользователь?
    */
   if (uid == current->uid) {
     /*
      * Зафиксировать
      */
     printk("Opened file by %d: ", uid);
     do {
       get_user(ch, filename + i);
       i++;
       printk("%c", ch);
     } while (ch != 0);
     printk("\n");
   }
 
   /* 
    * Вызвать оригинальную версию системного вызова sys_open - иначе
    * система потеряет возможность открывать файлы
    */
   return original_call(filename, flags, mode);
 }
 
 /* 
  * Инициализация модуля - подмена системного вызова
  */
 int init_module()
 {
   /* 
    * Внимание - предупреждение запоздало, но
    * может быть в следующий раз...
    */
   printk("I'm dangerous. I hope you did a ");
   printk("sync before you insmod'ed me.\n");
   printk("My counterpart, cleanup_module(), is even");
   printk("more dangerous. If\n");
   printk("you value your file system, it will ");
   printk("be \"sync; rmmod\" \n");
   printk("when you remove this module.\n");
 
   /* 
    * Сохранить указатель на оригинальную функцию
    * в переменной original_call, и затем заменить указатель
    * в таблице системных вызовов
    */
   original_call = sys_call_table[__NR_open];
   sys_call_table[__NR_open] = our_sys_open;
 
   /* 
    * Чтобы получить адрес любого системного вызова
    * с именем foo, обращайтесь к записи sys_call_table[__NR_foo]. 
    */
 
   printk("Spying on UID:%d\n", uid);
 
   return 0;
 }
 
 /* 
  * Завершение работы модуля - восстановление указателя на оригинальный 
  * системный вызов
  */
 void cleanup_module()
 {
   /*
    * Восстановить адрес системного вызова
    */
   if (sys_call_table[__NR_open] != our_sys_open) {
     printk("Somebody else also played with the ");
     printk("open system call\n");
     printk("The system may be left in ");
     printk("an unstable state.\n");
   }
 
   sys_call_table[__NR_open] = original_call;
 }
 
 
  Яковлев С: Сузи компилит этот модуль , 
 но отказывается его регистрировать.
 Нужен патч .
 
 
 Пример 7-2. "Заплата" на ядро (export_sys_call_table_patch_for_linux_2.6.x)
 
 --- kernel/kallsyms.c.orig     2003-12-30 07:07:17.000000000 +0000
 +++ kernel/kallsyms.c   2003-12-30 07:43:43.000000000 +0000
 @@ -184,7 +184,7 @@
                 iter->pos = pos;
                 return get_ksymbol_mod(iter);
         }
 -
 +
         /* If we're past the desired position, reset to start. */
         if (pos < iter->pos)
                 reset_iter(iter);
 @@ -291,3 +291,11 @@
 
  EXPORT_SYMBOL(kallsyms_lookup);
  EXPORT_SYMBOL(__print_symbol);
 +/* START OF DIRTY HACK:
 + * Purpose: enable interception of syscalls as shown in the
 + * Linux Kernel Module Programming Guide. */
 +extern void *sys_call_table;
 +EXPORT_SYMBOL(sys_call_table);
 + /* see http://marc.free.net.ph/message/20030505.081945.fa640369.html
 +  * for discussion why this is a BAD THING(tm) and no longer supported by 2.6.0
 +  * END OF DIRTY HACK: USE AT YOUR OWN RISK */
 
 Пример 7-3. Makefile
 
 obj-m += syscall.o
 

Пример 7-4. README.txt
Основная проблема, связанная с данным примером, состоит в невозможности определить адрес sys_call_table, поскольку он более не экспортируется ядрами 2.6.x. Возможность "перекрытия" системных вызовов через sys_call_table потенциально опасна поэтому, начиная с версии 2.5.41, она больше не поддерживается
Обсуждение проблемы вы найдете на: http://www.ussg.iu.edu/hypermail/linux/kernel/0305.0/0711.html http://marc.free.net.ph/message/20030505.081945.fa640369.html http://marc.theaimsgroup.com/?l=linux-kernel&m=105212296015799&w=2
Чтобы иметь возможность опробовать данный пример на ядрах версии 2.5.41 и выше вам необходимо наложить заплату на ядро.
ВНИМАНИЕ: НЕ ИСПОЛЬЗУЙТЕ ЭТУ ЗАПЛАТУ НА ПРОМЫШЛЕННЫХ ИЛИ ИНЫХ СИСТЕМАХ, КОТОРЫЕ СОДЕРЖАТ ЦЕННУЮ ИНФОРМАЦИЮ.
Если бы я писал встроенную справку к этой заплате в Configure.help то я бы пометил ее как и дал бы следующее описание: ####################################################################### Эта опция экспортирует sys_call_table, что делает возможным "перекрытие" (подмену) системных вызовов. Подмена системных вызовов потенциально опасна и может стать причиной потери даных или еще хуже. Скажите Y, если желаете опробовать прилагаемый пример и вас не беспокоит возможная потеря данных. Практически любой должен здесть сказать N. ####################################################################### Если ваш старенький PC используется только как игрушка можете наложить эту заплату и опробовать пример. Предполагается, что исходные тексты ядра 2.6.x находятся в каталоге /usr/src/linux/ (http://www.linuxmafia.com/faq/Kernel/usr-src-linux-symlink.html) Ниже приводится текст сценария, выполняющий наложение заплаты. Эта заплата протестирована с ядрами 2.6.[0123], и может накладываться или не накладываться на другие версии.

 #!/bin/sh
 cp export_sys_call_table_patch_for_linux_2.6.x /usr/src/linux/
 cd /usr/src/linux/
 patch -p0 < export_sys_call_table_patch_for_linux_2.6.x
      

Глава 8. Блокировка процессов

Что вы делаете, когда кто-то просит вас о чем-то, а вы не можете сделать это немедленно? Пожалуй единственное, что вы можете ответить: "Пожалуйста, не сейчас, я пока занят.". А что должен делать модуль ядра? У него есть другая возможность. Он можете приостановить работу процесса до тех пор, пока не сможет обслужить его. В конечном итоге, ядро постоянно то приостанавливает, то вновь возобновляет работу процессов. Именно так обеспечивается возможность одновременного исполнения нескольких процессов на единственном процессоре. Пример ниже демонстрирует такую возможность. Модуль создает файл /proc/sleep, который может быть открыт только одним процессом, в каждый конкретный момент времени. Если файл уже был открыт кем-нибудь, то модуль вызывает wait_event_interruptible. [10] Эта функция изменяет состояние "задачи" (здесь, под термином "задача" понимается структура данных в ядре, которая хранит информацию о процессе), присваивая ему значение TASK_INTERRUPTIBLE, это означает, что задача не будет выполняться до тех пор, пока не будет "разбужена" каким либо образом, и добавляет процесс в очередь ожидания WaitQ, куда помещаются все процессы, желающие открыть файл /proc/sleep. Затем функция передает управление планировщику, который в свою очередь предоставляет возможность поработать другому процессу. Когда процесс закрывает файл, это приводит к вызову module_close. Она запускает все процессы, которые "сидят" в очереди WaitQ (к сожалению нет механизма, который позволил бы "разбудить" только один процесс) Затем управление возвращается процессу, который только что закрыл файл и он продолжает свою работу. После того, как данный процесс исчерпает свой квант времени, планировщик передаст управление другому процессу. Таким образом, один из процессов, ожидавших своей очереди доступа к файлу, в конечном итоге получит управление и продолжит исполнение с точки, следующей за вызовом wait_event_interruptible. [11] Он установит глобальную переменную, извещающую остальные процессы о том, что файл открыт и займется обработкой открытого файла. Когда другие процессы получат свой квант времени, они обнаружат, что файл все еще открыт и опять приостановят свою работу. Чтобы как-то оживить повествование замечу, что module_close не обладает монопольным правом на возобновление работы ожидающих процессов. Сигнал Ctrl-C (SIGINT) также может "разбудить" процесс. [12] В этом случае процессу немедленно возвращается -EINTR. Таким образом пользователи могут, например, прервать процесс прежде, чем он получит доступ к файлу. Тут есть еще один момент, о котором хотелось бы упомянуть. Некоторые процессы не желают быть заблокированными, такие процессы должны либо получить в свое распоряжение открытый файл немедленно, либо извещение о том, что их запрос не может быть удовлетворен в настоящий момент. Такие процессы используют флаг O_NONBLOCK при открытии файла. Если ядро не в состоянии немедленно удовлетворить запрос, оно отвечает кодом ошибки -EAGAIN.

 Пример 8-1. sleep.c
 /*
  *  sleep.c - Создает файл в /proc, доступ к которому может получить 
  *  только один процесс,
  *  все остальные будут приостановлены.
  */
 
 #include < linux/kernel.h>   /* Все-таки мы работаем с ядром! */
 #include < linux/module.h>   /* Необходимо для любого модуля */
 #include < linux/proc_fs.h>  /* Необходимо для работы с /proc */
 #include < linux/sched.h>    /* Взаимодействие с планировщиком */
 #include < asm/uaccess.h>    /* определение функций get_user и put_user */
 
 /*
  * Место хранения последнего принятого сообщения,
  * которое будет выводиться в файл, чтобы показать, что
  * модуль действительно может получать ввод от пользователя
  */
 #define MESSAGE_LENGTH 80
 static char Message[MESSAGE_LENGTH];
 
 static struct proc_dir_entry *Our_Proc_File;
 #define PROC_ENTRY_FILENAME "sleep"
 
 static ssize_t module_output(struct file *file, /* см. include/linux/fs.h   */
                       char *buf,
                       size_t len,               /* размер буфера */
                       loff_t * offset)
 {
   static int finished = 0;
   int i;
   char message[MESSAGE_LENGTH + 30];
 
   /* 
    * Для индикации признака конца файла возвращается 0.
    * В противном случае процесс будет продолжать читать из файла
    * угодив в бесконечный цикл. 
    */
         if (finished) {
                 finished = 0;
                 return 0;
         }
 
   /* 
    * Для передачи данных из пространства ядра в пространство пользователя 
    * следует использовать put_user.
    * В обратном направлении -- get_user.
    */
   sprintf(message, "Last input:%s\n", Message);
   for (i = 0; i < len && message[i]; i++)
     put_user(message[i], buf + i);
 
   finished = 1;
   return i;    /* Вернуть количество "прочитанных" байт */
 }
 
 /* 
  * Эта функция принимает введенное пользователем сообщение
  */
 static ssize_t module_input(struct file *file,  /* Собственно файл */
           const char *buf,                      /* Буфер с сообщением */
           size_t length,                        /* размер буфера */
           loff_t * offset)
 {         /* смещение в файле - игнорируется */
   int i;
 
   /* 
    * Переместить данные, полученные от пользователя в буфер, 
    * который позднее будет выведен йункцией module_output.
    */
   for (i = 0; i < MESSAGE_LENGTH - 1 && i < length; i++)
     get_user(Message[i], buf + i);
 
   /* Обычная строка, завершающаяся символом \0 */       
   Message[i] = '\0';
 
   /* 
    * Вернуть число принятых байт
    */
   return i;
 }
 
 /* 
  * 1 -- если файл открыт
  */
 int Already_Open = 0;
 
 /* 
  * Очередь ожидания
  */
 DECLARE_WAIT_QUEUE_HEAD(WaitQ);
 /* 
  * Вызывается при открытии файла в /proc 
  */
 static int module_open(struct inode *inode, struct file *file)
 {
   /* 
    * Если установлен флаг O_NONBLOCK, то процесс не должен приостанавливаться
    * В этом случае, если файл уже открыт, необходимо вернуть код ошибки
    * -EAGAIN, что означает "попробуйте в другой раз"
    */
   if ((file->f_flags & O_NONBLOCK) && Already_Open)
     return -EAGAIN;
 
   /* 
    * Нарастить счетчик обращений,
    * чтобы невозможно было выгрузить модуль
    */
   try_module_get(THIS_MODULE);
 
   /*
    * Если файл уже открыт -- приостановить процесс
    */
 
   while (Already_Open) {
     int i, is_sig = 0;
 
     /* 
      * Эта функция приостановит процесс и поместит его в очередь ожидания.
      * Исполнение процесса будет продолжено с точки, следующей за вызовом
      * этой функции, когда кто нибудь сделает вызов 
      * wake_up(&WaitQ) (это возможно только внутри module_close, когда 
      * файл будет закрыт) или когда процессу поступит сигнал Ctrl-C
      */
     wait_event_interruptible(WaitQ, !Already_Open);
 
     for (i = 0; i < _NSIG_WORDS && !is_sig; i++)
     is_sig =
           current->pending.signal.sig[i] & ~current->
           blocked.sig[i];
 
     if (is_sig) {
       /* 
        * Не забыть вызвать здесь module_put(THIS_MODULE),
        * поскольку процесс был прерван
        * и никогда не вызовет функцию close.
        * Если не уменьшить счетчик обращений, то он навсегда останется
        * больше нуля, в результате модуль можно будет
        * уничтожить только при перезагрузке системы
        */
       module_put(THIS_MODULE);
       return -EINTR;
     }
   }
 
   /* 
    * В этой точке переменная Already_Open должна быть равна нулю
    */
 
   /* 
    * Открыть файл
    */
   Already_Open = 1;
   return 0;
 }
 
 /* 
  * Вызывается при закрытии файла
  */
 int module_close(struct inode *inode, struct file *file)
 {
   /* 
    * Записать ноль в Already_Open, тогда один из процессов из WaitQ
    * сможет записать туда единицу и открыть файл.
    * Все остальные процессы, ожидающие доступа к файлу опять 
    * будут приостановлены
    */
   Already_Open = 0;
 
   /* 
    * Возобновить работу процессов из WaitQ.
    */
   wake_up(&WaitQ);
 
   module_put(THIS_MODULE);
 
   return 0;
 }
 
 /* 
  * Эта функция принимает решение о праве на выполнение операций с файлом
  * 0 -- разрешено, ненулеое значение -- запрещено.
  *
  * Операции с файлом могут быть:
  * 0 - Исполнениеe (не имеет смысла в нашей ситуации)
  * 2 - Запись (передача от пользователя к модулю ядра)
  * 4 - Чтение (передача от модуля ядра к пользователю)
  *
  * Эта функция проверяет права доступа к файлу
  * Права, выводимые командой ls -l
  * могут быть проигнорированы здесь.
  */
 static int module_permission(struct inode *inode, int op, struct nameidata *nd)
 {
   /* 
    * Позволим любому читать файл, но
    * писать -- только root-у (uid 0)
    */
   if (op == 4 || (op == 2 && current->euid == 0))
     return 0;
 
   /* 
    * Если что-то иное -- запретить доступ
    */
   return -EACCES;
 }
 
 /* 
  * Указатели на функции-обработчики для нашего файла.
  */
 static struct file_operations File_Ops_4_Our_Proc_File = {
   .read = module_output,    /* чтение из файла */
   .write = module_input,    /* запись в файл */
   .open = module_open,      /* открытие файла */
   .release = module_close,  /* закрытие файла */
 };
 
 
 /* 
  * Операции над индексной записью нашего файла. Необходима
  * для того, чтобы указать местоположение структуры
  * file_operations нашего файла, а так же, чтобы задать
  * функцию определения прав доступа к файлу. Здесь можно указать адреса
  * других функций-обработчиков, но нас они не интересуют.
  */
 static struct inode_operations Inode_Ops_4_Our_Proc_File = {
   .permission = module_permission,      /* check for permissions */
 };
 
 /* 
  * Начальная и конечная функции модуля
  */
 
 /* 
  * Инициализация модуля - регистрация файла в /proc
  */
 
 int init_module()
 {
   int rv = 0;
   Our_Proc_File = create_proc_entry(PROC_ENTRY_FILENAME, 0644, NULL);
   Our_Proc_File->owner = THIS_MODULE;
   Our_Proc_File->proc_iops = &Inode_Ops_4_Our_Proc_File;
   Our_Proc_File->proc_fops = &File_Ops_4_Our_Proc_File;
   Our_Proc_File->mode = S_IFREG | S_IRUGO | S_IWUSR;
   Our_Proc_File->uid = 0;
   Our_Proc_File->gid = 0;
   Our_Proc_File->size = 80;
 
   if (Our_Proc_File == NULL) {
     rv = -ENOMEM;
     remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
     printk(KERN_INFO "Error: Could not initialize /proc/test\n");
   }
 
   return rv;
 }
 
 /* 
  * Завершение работы модуля - дерегистрация файла в /proc. 
  * Чревато последствиями если в WaitQ остаются процессы, 
  * ожидающие своей очереди, поскольку точка их исполнения
  * практически находится в функции open, которая будет выгружена 
  * при удалении модуля. 
  * Позднее, в 9 главе, я опишу как воспрепятствовать удалению модуля 
  * в таких случаях
  */
 void cleanup_module()
 {
   remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
 }
      
 

Глава 9. Замена printk

Ранее я уже говорил о том, что XWindow и разработка модулей ядра есть вещи несовместимые. Это все так, но иногда возникает необходимость выдачи сообщений от модуля на любой tty. [13] В качестве одного из вариантов можно предложить следующее: используя указатель на текущий исполняемый процесс -- current, получить структуру tty. Затем извлечь из этой структуры указатель на функцию вывода строки и использовать ее для выдачи сообщений.

 Пример 9-1. print_string.c
 
 /*
  *  print_string.c - отправляет вывод на tty терминала, независимо от того
  *  X11 это, или telnet, или что-то еще. Делается это путем вывода строки на tty,
  *  ассоциированный с текущим процессом.
  */
 #include < linux/kernel.h>
 #include < linux/module.h>
 #include < linux/init.h>
 #include < linux/sched.h>   /* определение current */
 #include < linux/tty.h>     /* определение tty */
 #include < linux/version.h> /* макрос LINUX_VERSION_CODE */
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Peter Jay Salzman");
 
 static void print_string(char *str)
 {
   struct tty_struct *my_tty;
 
   /* 
    * Начиная с версии 2.6.6, структура tty перекочевала в структуру signal 
    */
 #if ( LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,5) )
   /* 
    * tty текущего процесса
    */
   my_tty = current->tty;
 #else
   /* 
    * tty текущего процесса, для ядер 2.6.6 и выше
    */
   my_tty = current->signal->tty;
 #endif
 
   /* 
    * если my_tty == NULL, то текущий процесс не имеет tty на который можно 
    * было бы что нибудь вывести (например, демон).  
    * В этом случае нам ничего не нужно делать.
    */
   if (my_tty != NULL) {
 
     /* 
      * my_tty->driver -- структура, которая хранит указатели 
      * на функции-обработчики,
      * одна из которых (write) используется для вывода строк на tty. 
      *
      * Первый параметр функции -- tty, на который осуществляется вывод,
      * поскольку эта функция обычно используется для вывода на все 
      * tty одного и того же типа. 
      * Второй параметр -- флаг расположения строки
      * если строка находится в пространстве ядра, флаг равен false (0)
      * если в пространстве пользователя, то true (не ноль).  
      * Третий параметр -- указатель на строку.
      * Четвертый параметр -- длина строки.
      */
     ((my_tty->driver)->write) (my_tty,  /* Собственно tty  */
              0,                         /* Строка в пространстве ядра */
              str,                       /* Сама строка */
              strlen(str));              /* Длина строки */
 
     /* 
      * tty изначально был аппаратным устройством, который (обычно) 
      * ограничивался стандартом ASCII, в котором перевод строки
      * включал в себя два символа -- "возврат каретки" и "перевод строки".
      * В Unix, символ ASCII -- "перевод строки" заменял оба этих символа,
      * поэтому нам придется использовать для перевода строки
      * оба символа.
      *
      * Это одна из причин различий между текстовыми файлами Unix и
      * MS Windows. CP/M и ее "наследницы", например MS-DOS и
      * MS Windows, строго придерживались стандарта ASCII.
      */
     ((my_tty->driver)->write) (my_tty, 0, "\015\012", 2);
   }
 }
 
 static int __init print_string_init(void)
 {
   print_string("The module has been inserted.  Hello world!");
   return 0;
 }
 
 static void __exit print_string_exit(void)
 {
   print_string("The module has been removed.  Farewell world!");
 }
 
 module_init(print_string_init);
 module_exit(print_string_exit);
 
 
 Яковлев С: На этапе регистрации этого модуля будет выведено сообщение
 
 

9.2. Управление индикаторами на клавиатуре

При определенных условиях у вас может возникнуть желание дать вашему модулю более простой и более прямолинейный способ взаимодействия с внешним миром. Изменение состояния светодиодных индикаторов клавиатуры может быть одним из вариантов привлечения внимания пользователя или отображения некоторого состояния. Светодиодные индикаторы присутствуют на любой клавиатуре, они всегда находятся в поле зрения, они не нуждаются в установке, и их "подмаргивание" достаточно ненавязчиво, по сравнению с выводом на tty или в файл. Следующий исходный код иллюстрирует модуль ядра, который после загрузки начинает мигать индикаторами клавиатуры.

 Пример 9-2. kbleds.c
 
 /*
  *  kbleds.c - Мигание индикаторами на клавиатуре.
  */
 
 #include < linux/module.h>
 #include < linux/config.h>
 #include < linux/init.h>
 #include < linux/tty.h>    /* определение fg_console, MAX_NR_CONSOLES */
 #include < linux/kd.h>     /* определение KDSETLED */
 #include < linux/console_struct.h> /* определение  vc_cons */
 
 MODULE_DESCRIPTION("Пример module illustrating the use of Keyboard LEDs.");
 MODULE_AUTHOR("Daniele Paolo Scarpazza");
 MODULE_LICENSE("GPL");
 
 struct timer_list my_timer;
 struct tty_driver *my_driver;
 char kbledstatus = 0;
 
 #define BLINK_DELAY   HZ/5
 #define ALL_LEDS_ON   0x07
 #define RESTORE_LEDS  0xFF
 
 /*
  * Функция my_timer_func мигает индикаторами на клавиатуре 
  * периодически вызывая 
  * ioctl() драйвера клавиатуры с командой KDSETLED. 
  * Дополнительную информацию,
  * по командам ioctl виртуального терминала, вы найдете в:
  *     /usr/src/linux/drivers/char/vt_ioctl.c, function vt_ioctl().
  *
  * Дополнительный аргумент команды KDSETLED -- значение 7 (перевод в режим
  * LED_SHOW_IOCTL -- управление индикаторами через ioctl), значение 0xFF --
  * (любое значение, большее 7, перевод в режим LED_SHOW_FLAGS --
  * отображение фактического состояния клавиатуры). 
  * Дополнительная информация:
  *     /usr/src/linux/drivers/char/keyboard.c, function setledstate().
  * 
  */
 
 static void my_timer_func(unsigned long ptr)
 {
   int *pstatus = (int *)ptr;
 
   if (*pstatus == ALL_LEDS_ON)
     *pstatus = RESTORE_LEDS;
   else
     *pstatus = ALL_LEDS_ON;
 
   (my_driver->ioctl) (vc_cons[fg_console].d->vc_tty, NULL, KDSETLED,
           *pstatus);
 
   my_timer.expires = jiffies + BLINK_DELAY;
   add_timer(&my_timer);
 }
 
 static int __init kbleds_init(void)
 {
   int i;
 
   printk(KERN_INFO "kbleds: loading\n");
   printk(KERN_INFO "kbleds: fgconsole is %x\n", fg_console);
   for (i = 0; i < MAX_NR_CONSOLES; i++) {
     if (!vc_cons[i].d)
       break;
     printk(KERN_INFO "poet_atkm: console[%i/%i] #%i, tty %lx\n", i,
            MAX_NR_CONSOLES, vc_cons[i].d->vc_num,
            (unsigned long)vc_cons[i].d->vc_tty);
   }
   printk(KERN_INFO "kbleds: finished scanning consoles\n");
 
   my_driver = vc_cons[fg_console].d->vc_tty->driver;
   printk(KERN_INFO "kbleds: tty driver magic %x\n", my_driver->magic);
 
   /*
    * Инициировать таймер
    */
   init_timer(&my_timer);
   my_timer.function = my_timer_func;
   my_timer.data = (unsigned long)&kbledstatus;
   my_timer.expires = jiffies + BLINK_DELAY;
   add_timer(&my_timer);
 
   return 0;
 }
 
 static void __exit kbleds_cleanup(void)
 {
   printk(KERN_INFO "kbleds: unloading...\n");
   del_timer(&my_timer);
   (my_driver->ioctl) (vc_cons[fg_console].d->vc_tty, NULL, KDSETLED,
           RESTORE_LEDS);
 }
 
 module_init(kbleds_init);
 module_exit(kbleds_cleanup);
 
 
 Яковлев С: Довольно прикольно - замигали лампочки cups lock и scroll lock
 

Если ни один из примеров данной главы вас не устраивает, можно попробовать другие хитрости, скрытые в ядре. Может быть вам подойдет опция CONFIG_LL_DEBUG в make menuconfig? Включив ее, вы получите низкоуровневый доступ к последовательному порту. Как бы страшно это ни прозвучало, но можете попробовать изменить реализацию kernel/printk.c или какого нибудь другого системного вызова для вывода ascii-строк, чтобы иметь возможность отслеживать действия вашего модуля через последовательную линию связи. Несмотря на то, что вы уже встретили в этой книге намало наглядных приемов отладки, существует еще ряд моментов, которые вам необходимо знать. Отладка -- это всегда очень утомительный процесс и практически всегда он сопровождается внедрением значительного количества отладочного кода. Может сложиться так, что отладочный код не дает проявляться некоторым ошибкам. Поэтому, при выпуске вашего модуля, старайтесь свести отладочный код к минимуму и "прогнать" модуль еще раз, пытаясь обнаружить какие либо ошибки.

Глава 10. Планирование задач

Очень часто возникает необходимость запуска вспомогательных задач по расписанию. Если запускаемая задача -- обычный процесс, то помещаем ее в файл crontab. Если же задача является модулем ядра, то у нас есть две возможности. Первая состоит в том, чтобы поместить некую задачу в файл crontab, которая будет "будить" модуль системным вызовом в заданный момент времени, например, открывая файл. Это очень неэффективно, т.к. при запуске нового процесса из crontab приходится загружать программу в память и всем это только для того, чтобы "разбудить" модуль ядра, который уже находится в памяти. Вместо этого мы попробуем создать функцию, которая будет вызываться по прерываниям от таймера. Для этого, создадим задачу struct work_struct. Эта структура будет хранить указатель на функцию, срабатывающую по таймеру. Затем, с помощью queue_delayed_work, поместим задачу в очередь tq_timer, где должны располагаться задачи, срабатывающие по таймеру. А так как предполагается срабатывание функции каждый раз, по истечении заданного интервала времени, мы должны всякий раз опять вставлять ее в очередь tq_timer. И еще один немаловажный момент. Когда модуль выгружается командой rmmod, сначала проверяется счетчик обращений к модулю. Если он равен нулю, то вызывается module_cleanup. После чего модуль удаляется из памяти со всеми его функциями. И никто не проверяет -- содержит ли очередь задач таймера указатель на одну из удаляемых функций. По прошествии некоторого времени (с точки зрения человека -- практически мгновенно), ядро получит прерывание от таймера и попробует вызывать удаленную из очереди задачу. Но функции-то больше нет! В большинстве случаев страница памяти, где она была, будет рассматриваться как неиспользуемая и вы получите сообщение об ошибке. Но может случиться так, что на этом месте окажется некоторый другой код и тогда ваше дело -- табак. К сожалению, у нас нет достаточно простого способа удаления задачи из очереди таймера. Так как cleanup_module не может вернуть код ошибки (она не имеет возвращаемого значения), то напрашивается решение -- приостановить процедуру завершения работы модуля. Вместо того, чтобы немедленно завершить работу функции cleanup_module, мы можем приостановить работу команды rmmod. Затем, установив глобальную переменную, сообщить функции, вызываемой по прерыванию таймера, чтобы она убрала себя из очереди (точнее -- чтобы она опять не вставляла себя в очередь). На ближайшем прерывании таймера, процесс rmmod будет "разбужен", когда функция удалит себя из очереди таймера и удаление модуля станет безопасным.

 Пример 10-1. sched.c
 
 /*
  *  sched.c - реализация срабатывания по таймеру.
  *
  *  Copyright (C) 2001 by Peter Jay Salzman
  */
 
 /*
  * Необходимые заголовочные файлы
  */
 
 /*
  * Обычные, для модулей ядра
  */
 #include < linux/kernel.h>    /* Все-таки мы работаем с ядром! */
 #include < linux/module.h>    /* Необходимо для любого модуля */
 #include < linux/proc_fs.h>   /* Необходимо для работы с /proc */
 #include < linux/workqueue.h> /* очереди задач */
 #include < linux/sched.h>     /* Взаимодействие с планировщиком */
 #include < linux/init.h>      /* макросы  __init и  __exit */
 #include < linux/interrupt.h> /* определение irqreturn_t */
 
 struct proc_dir_entry *Our_Proc_File;
 #define PROC_ENTRY_FILENAME "sched"
 #define MY_WORK_QUEUE_NAME "WQsched.c"
 
 /*
  * Счетчик срабатываний по таймеру
  */
 static int TimerIntrpt = 0;
 
 static void intrpt_routine(void *);
 
 static int die = 0;  /* 1 -- завершить работу */
 
 /* 
  * очередь задач, создается для того, 
  * чтобы поместить в очередь таймера (workqueue.h)
  */
 static struct workqueue_struct *my_workqueue;
 
 static struct work_struct Task;
 static DECLARE_WORK(Task, intrpt_routine, NULL);
 
 /* 
  * Функция-обработчик прерывания от таймера. 
  * Обратите внимание на аргумент типа void*
  * функция может получать дополнительные аргументы 
  * посредством этого указателя.
  */
 static void intrpt_routine(void *irrelevant)
 {
   /* 
    * Нарастить счетчик
    */
   TimerIntrpt++;
 
   /* 
    * Если признак завершения сброшен, то опять вставить себя 
    * в очередь таймера
    */
   if (die == 0)
     queue_delayed_work(my_workqueue, &Task, 100);
 }
 
 /* 
  * Запись данных в файл /proc.
  */
 ssize_t
 procfile_read(char *buffer,
         char **buffer_location,
         off_t offset, int buffer_length, int *eof, void *data)
 {
   int len;              /* Фактическое число записанных байт */
 
   /* 
    * Переменные объявлены как static, поэтому они располагаются не на стеке
    * функции, а в памяти модуля
    */
   static char my_buffer[80];
 
   static int count = 1;
 
   /* 
    * Все сведения выдаются за один присест, поэтому, если смещение != 0, 
    * то значит нам нечего больше сказать, 
    * поэтому возвращается 0, в качестве признака конца файла.
    */
   if (offset > 0)
     return 0;
 
   /* 
    * Заполнить буфер и получить его длину
    */
   len = sprintf(my_buffer, "Timer called %d times so far\n", TimerIntrpt);
   count++;
 
   /* 
    * Указать адрес буфера
    */
   *buffer_location = my_buffer;
 
   /* 
    * Вернуть длину буфера
    */
   return len;
 }
 
 /* 
  * Функция инициализации - зарегистрировать файл в /proc
  */
 int __init init_module()
 {
   int rv = 0;
   /* 
    * Создать очередь задач с нашей задачей и поместить ее в очередь*/
   my_workqueue = create_workqueue(MY_WORK_QUEUE_NAME);
   queue_delayed_work(my_workqueue, &Task, 100);
 
   Our_Proc_File = create_proc_entry(PROC_ENTRY_FILENAME, 0644, NULL);
   Our_Proc_File->read_proc = procfile_read;
   Our_Proc_File->owner = THIS_MODULE;
   Our_Proc_File->mode = S_IFREG | S_IRUGO;
   Our_Proc_File->uid = 0;
   Our_Proc_File->gid = 0;
   Our_Proc_File->size = 80;
 
   if (Our_Proc_File == NULL) {
     rv = -ENOMEM;
     remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
     printk(KERN_INFO "Error: Could not initialize /proc/%s\n",
            PROC_ENTRY_FILENAME);
   }
 
   return rv;
 }
 
 /* 
  * Завершение работы
  */
 void __exit cleanup_module()
 {
   /* 
    * Удалить файл из /proc
    */
   remove_proc_entry(PROC_ENTRY_FILENAME, &proc_root);
   printk(KERN_INFO "/proc/%s removed\n", PROC_ENTRY_FILENAME);
 
   die = 1;/* Известить функцию обработки прерываний о завершении работы */
   cancel_delayed_work(&Task); 
   flush_workqueue(my_workqueue); /* ждать пока отработает таймер */
   destroy_workqueue(my_workqueue);
 
   /* 
    * Приостановить работу, пока intrpt_routine не отработает в последний раз. 
    * Это необходимо, поскольку мы освобождаем память, занимаемую этой функцией.
    */
 
 }
 
 /*
  * некоторые функции, относящиеся к work_queue 
  * доступны только если модуль лицензирован под GPL
  */
 MODULE_LICENSE("GPL");
 
 

Глава 11. Обработка прерываний

Везде, кроме предыдущей главы, все наши действия в ядре сводилось к ответам на разные запросы от процессов, к работе со специальными файлом, посылке команд ioctl или запуску системных вызовов. Однако работа ядра не может сводится только к обработке запросов. Еще одна немаловажная задача -- это работа с аппаратурой компьютера. Существует два типа взаимодействий между CPU и остальной аппаратной частью компьютера. Первый -- передача команд аппаратным средствам, второй -- прием ответов от аппаратуры. Второй тип взаимодействия -- прерывания, является наиболее тяжелым в обработке, потому что прерывания возникают тогда, когда это удобно устройству, а не CPU. Аппаратные устройства обычно имеют весьма ограниченный объем ОЗУ, и если не считать поставляемую ими информацию немедленно, то она может потеряться. В Linux аппаратные прерывания называются IRQ (сокращенно от Interrupt ReQuests -- Запросы на Прерывание). Имеется два типа IRQ: "короткие" и "длинные". "Короткие" IRQ занимают очень короткий период времени, в течение которого работа операционной системы будет заблокирована, а так же будет невозможна обработка других прерываний. "Длинные" IRQ могут занять довольно продолжительное время, в течение которого могут обрабатываться и другие прерывания (но не прерывания из того же самого устройства). Поэтому, иногда бывает благоразумным разбить выполнение работы на исполняемую внутри обработчика прерываний (т.е. подтверждение прерывания, изменение состояния и пр.) и работу, которая может быть отложена на некоторое время (например постобработка данных, активизация процессов, ожидающих эти данные и т.п.). Если это возможно, лучше объявлять обработчики прерывания "длинными". Когда CPU получает прерывание, он останавливает любые процессы (если это не более приоритетное прерывание, тогда обработка пришедшего прерывания произойдет только тогда, когда более приоритетное будет завершено), сохраняет некоторые параметры в стеке и вызывает обработчик прерывания. Это означает, что не все действия допустимы внутри обработчика прерывания, потому что система находится в неизвестном состоянии. Решение проблемы: обработчик прерывания определяет -- что должно быть сделано немедленно (обычно что-то прочитать из устройства или что-то послать ему), а затем запланировать обработку поступившей информации на более позднее время (это называется "bottom halves" -- "нижние половины") и вернуть управление. Ядро гарантирует вызов "нижней половины" так быстро, насколько это возможно. Когда это произойдет, то наш обработчик -- "нижняя половина", уже не будет стеснен какими-то рамками и ему будет доступно все то, что доступно обычным модулям ядра. Устанавливается обработчик прерывания вызовом request_irq. Ей передаются номер IRQ, имя функции-обработчика, флаги, имя для /proc/interrupts и дополнительный параметр для обработчика прерываний. Флаги могут включать SA_SHIRQ, чтобы указать, что прерывание может обслуживаться несколькими обработчиками (обычно, по той простой причине, что на одном IRQ может "сидеть" несколько устройств) и SA_INTERRUPT, чтобы указать, что это "короткое" прерывание. Эта функция установит обработчик только в том случае, если на заданном IRQ еще нет обработчика прерывания, или если существующий обработчик зарегистрировал совместную обработку прерывания флагом SA_SHIRQ. Во время обработки прерывания, из функции-обработчика прерывания, мы можем получить данные от устройства и затем, с помощью queue_task_irq, tq_immediate и mark_bh(BH_IMMEDIATE), запланировать "нижнюю половину". В ранних версиях Linux имелся массив только из 32 "нижних половин", теперь же, одна из них (а именно BH_IMMEDIATE) используется для обслуживания целого списка "нижних половин" драйверов. Вызов mark_bh(BH_IMMEDIATE) как раз и вставляет "нижнюю половину" драйвера в этот список, планируя таким образом ее исполнение.

11.2. Клавиатура на архитектуре Intel

Материал, рассматриваемый в оставшейся части этой главы, может быть применим исключительно к архитектуре Intel. На других платформах код примера работать не будет. Было очень трудно выбрать тип драйвера, который можно было бы использовать в качестве примера в этой главе. С одной стороны пример должен быть достаточно полезным, он должен работать на любом компьютере и быть достаточно выразительным. С другой стороны, в ядро уже включено огромное количество драйверов практически для всех общеизвестных и широкораспространенных устройств. Эти драйверы не смогли бы совместно работать с тем, что я собирался написать. Наконец я принял решение представить в качестве примера -- обработчик прерываний от клавиатуры, но для демонстрации работоспособности кода сначала придется отключить стандартный обработчик прерываний от клавиатуры, а так как этот символ объявлен как static (в файле drivers/char/keyboard.c), то нет никакого способа восстановить обработчик. Поэтому, прежде чем вы дадите команду insmod, перейдите в другую консоль и дайте команду sleep 120; reboot, если ваша файловая система представляет для вас хоть какую-нибудь ценность. Этот пример захватывает обработку IRQ 1 -- прерывание от клавиатуры на архитектуре Intel. При получении прерывания обработчик читает состояние клавиатуры (inb(0x64)) и скан-код нажатой клавиши. Затем, как только ядро сочтет возможным, оно вызывает got_char (она играет роль "нижней половины"), которая выводит, через printk, код клавиши (младшие семь бит скан-кода) и признак "нажата/отпущена" (8-й бит скан-кода -- 0 или 1 соответственно).

 Пример 11-1. intrpt.c
 
 /*
  *  intrpt.c - Обработчик прерываний.
  *
  *  Copyright (C) 2001 by Peter Jay Salzman
  */
 
 /* 
  * Standard in kernel modules 
  */
 #include < linux/kernel.h>    /* Все-таки мы работаем с ядром! */
 #include < linux/module.h>    /* Необходимо для любого модуля */
 #include < linux/workqueue.h> /* очереди задач */
 #include < linux/sched.h>     /* Взаимодействие с планировщиком */
 #include < linux/interrupt.h> /* определение irqreturn_t */
 #include < asm/io.h>
 
 #define MY_WORK_QUEUE_NAME "WQsched.c"
 
 static struct workqueue_struct *my_workqueue;
 
 /* 
  * Эта функция вызывается ядром, поэтому в ней будут безопасны 
  * все действия которые допустимы в модулях ядра.
  */
 static void got_char(void *scancode)
 {
   printk("Scan Code %x %s.\n",
         (int)*((char *)scancode) & 0x7F,
         *((char *)scancode) & 0x80 ? "Released" : "Pressed");
 }
 
 /* 
  * Обработчик прерываний от клавиатуры. 
  */
 irqreturn_t irq_handler(int irq, void *dev_id, struct pt_regs *regs)
 {
   /* 
    * Эти переменные объявлены статическими, чтобы имелась возможность
    * доступа к ним (посредством указателей) из "нижней половины".
    */
   static int initialised = 0;
   static unsigned char scancode;
   static struct work_struct task;
   unsigned char status;
 
   /* 
    * Прочитать состояние клавиатуры
    */
   status = inb(0x64);
   scancode = inb(0x60);
 
   if (initialised == 0) {
     INIT_WORK(&task, got_char, &scancode);
     initialised = 1;
   } else {
     PREPARE_WORK(&task, got_char, &scancode);
   }
 
   queue_work(my_workqueue, &task);
 
   return IRQ_HANDLED;
 }
 
 /* 
  * Инициализация модуля - регистрация обработчика прерывания
  */
 int init_module()
 {
   my_workqueue = create_workqueue(MY_WORK_QUEUE_NAME);
 
   /* 
    * Поскольку стандартный обработчик прерываний от клавиатуры не может
    * сосуществовать с таким как наш, то придется запретить его
    * (освободить IRQ) прежде, чем что либо сделать.
    * Но поскольку мы не знаем где он находится в ядре, то мы лишены
    * возможности переустановить его - поэтому компьютер придется 
    * перезагрузить после опробования этого примера.
    */
         free_irq(1, NULL);
 
   /* 
    * Подставить свой обработчик (irq_handler) на IRQ 1.
    * SA_SHIRQ означает, что мы допускаем возможность совместного
    * обслуживания этого IRQ другими обработчиками.
    */
   return request_irq(1,    /* Номер IRQ */
          irq_handler,      /* наш обработчик */
          SA_SHIRQ,
          "test_keyboard_irq_handler",
          (void *)(irq_handler));
 }
 
 /* 
  * Завершение работы
  */
 void cleanup_module()
 {
   /* 
    * Эта функция добавлена лишь для полноты изложения. 
    * Она вообще бессмысленна, поскольку я не вижу способа
    * восстановить стандартный обработчик прерываний от клавиатуры 
    * поэтому необходимо выполнить перезагрузку системы.
    */
   free_irq(1, NULL);
 }
 
 /* 
  * некоторые функции, относящиеся к work_queue 
  * доступны только если модуль лицензирован под GPL
  */
 MODULE_LICENSE("GPL");
 
 

Глава 12. Симметричная многопроцессорность

Один из самых простых и самых дешевых способов увеличения производительности -- это разместить на материнской плате несколько микропроцессоров. Каждый из процессоров может играть свою собственную роль (асимметричная многопроцессорная обработка -- ASMP) или же они все работают параллельно, организуя вычисления таким образом, при котором и операционная система, и приложения могут использовать любой доступный процессор (симметричная многопроцессорная обработка -- SMP). Примером асимметричной многопроцессорной ОС может служить NetWare SFT III, использующая зеркальное отображение серверов, в двухпроцессорном сервере первый процессор занимается предоставлением услуг, а второй - операциями ввода/вывода. Асимметричная многопроцессорноя обработка более эффективна, но она требует точного распределения ролей между процессорами, что практически невозможно на универсальных ОС, подобных Linux. С другой стороны, симметричная многопроцессорная обработка менее эффективна, но относительно проста в реализации (здесь, под словами "относительно проста", вовсе не подразумевается, что это действительно просто). В симметричной многопроцессорной среде микропроцессоры совместно используют одну и ту же память, в результате код, работающий на одном CPU может изменять содержимое памяти, используемой другим CPU. Здесь уже нет уверенности, что переменная, которой вы присвоили некоторое значение, в предыдущей строке программы, все еще имеет то же самое значение -- код, исполняемый на другом CPU может его поменять. Очевидно, что я привел невероятный пример. На самом деле, в случае обычных процессов, такой проблемы не существует. Как правило, в каждый конкретный момент времени, процесс может исполняться только на одном CPU. Но ядро может выполнять одновременно разные процессы на разных CPU. В ядрах версии 2.0.x это не было большой проблемой, поскольку ядро работало под защитой одной большой спин-блокировки (spinlock). Это означает, что когда один процессор работает в привилегированном режиме, а другой собирается войти в этот режим (например в случае системного вызова), то он вынужден ждать, пока первый процессор не выйдет в пользовательский режим. Это делает SMP в Linux безопасной, но малоэффективной. Начиная с ядра версии 2.2.x стал возможным одновременный выход нескольких процессоров в привилегированный режим. Это обстоятельство вы должны знать и помнить.

Глава 13. Заключение

В заключение я хотел бы предупредить вас о некоторых общих ошибках, допускаемых программистами модулей ядра. Если я что-то упустил из виду, и из-за этого у вас произошло нечто ужасное -- напишите мне и я верну вам ту долю авторского гонорара, которую я получил за ваш экземпляр книги. Стандартные библиотеки. Вы не должны использовать функции из стандартных библиотек языка C. Используйте только те функции, которые предоставляются ядром (большинство из них вы найдете в /proc/kallsyms). Запрет прерываний. Если вы запретите прерывания на короткий срок, то ничего страшного не произойдет. Но если вы забудете их разрешить, то система "зависнет" и перезагрузить ее можно будет только кнопкой выключения питания. Не суйте голову в пасть тигру! Вероятно это предупреждение излишне, но тем не менее...

Оставьте свой комментарий !

Ваше имя: Комментарий: Оба поля являются обязательными  Автор   Комментарий к данной статье keremet ya studentka 3ego kursa fakulteta komputernoi enjenerii i mne bylo porucheno zadaniye sdelat prezentaciyu na temu EXT3 fs tak vot prepod ochen uvajaemyu o slishkom vysokogo mneniya obo mne tak vot ne hotelos by oblajatsya i proshu vas pomoch mne kakimi nibud klevymy shtuchkami s EXT3 ili v EXT3 2006-12-16 14:53:06 Яковлев Се� не совсем понятно на каком языке Вам нужен материал у меня на сайте есть материал-например : тут 2006-12-16 22:21:25 Константин Попробовал использовать материал указанный в "Пример 10-1. sched.c" Не запустилось. Поиск проблемы выявил следующие нестыковки. 1 Вместо work_struct нужно использовать delayed_work. 2. Вместо DECLARE_WORK нужно использовать DECLARE_DELAYED_WORK У меня ядро 2.6.22.6 2011-06-06 17:49:57