Ори Померанц - Энциклопедия разработчика модулей ядра Linux

static struct tq_struct Task = {

NULL, /* Next item in list - queue_task will do

* this for us */

0, /* A flag meaning we haven't been inserted

* into a task queue yet */

intrpt_routine, /* The function to run */

NULL /* The void* parameter for that function */

};

/* This function will be called on every timer

* interrupt. Notice the void* pointer - task functions

* can be used for more than one purpose, each time

* getting a different parameter. */

static void intrpt_routine(void *irrelevant) {

/* Increment the counter */

TimerIntrpt++;

/* If cleanup wants us to die */

if (WaitQ != NULL) wake_up(&WaitQ);

/* Now cleanup_module can return */

else queue_task(&Task, &tq_timer);

/* Put ourselves back in the task queue */

}

/* Put data into the proc fs file. */

int procfile_read(char *buffer, char **buffer_location, off_t offset, int buffer_length, int zero) {

int len; /* The number of bytes actually used */

/* This is static so it will still be in memory

* when we leave this function */

static char my_buffer[80];

static int count = 1;

/* We give all of our information in one go, so if

* the anybody asks us if we have more information

* the answer should always be no. */

if (offset > 0) return 0;

/* Fill the buffer and get its length */

len = sprintf(my_buffer, "Timer was called %d times so far\n", TimerIntrpt);

count++;

/* Tell the function which called us where the buffer is */

*buffer_location = my_buffer;

/* Return the length */

return len;

}

struct proc_dir_entry Our_Proc_File = {

0, /* Inode number - ignore, it will be filled by

* proc_register_dynamic */

5, /* Length of the file name */

"sched", /* The file name */

S_IFREG | S_IRUGO,

/* File mode - this is a regular file which can

* be read by its owner, its group, and everybody else */

1, /* Number of links (directories where

* the file is referenced) */

0, 0, /* The uid and gid for the file - we give it to root */

80, /* The size of the file reported by ls. */

NULL, /* functions which can be done on the

* inode (linking, removing, etc.) - we don't

* support any. */

procfile_read,

/* The read function for this file, the function called

* when somebody tries to read something from it. */

NULL

/* We could have here a function to fill the

* file's inode, to enable us to play with

* permissions, ownership, etc. */

};

/* Initialize the module - register the proc file */

int init_module() {

/* Put the task in the tq_timer task queue, so it

* will be executed at next timer interrupt */

queue_task(&Task, &tq_timer);

/* Success if proc_register_dynamic is a success,

* failure otherwise */

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,2,0)

return proc_register(&proc_root, &Our_Proc_File);

#else

return proc_register_dynamic(&proc_root, &Our_Proc_File);

#endif

}

/* Cleanup */

void cleanup_module() {

/* Unregister our /proc file */

proc_unregister(&proc_root, Our_Proc_File.low_ino);

/* Sleep until intrpt_routine is called one last

* time. This is necessary, because otherwise we'll

* deallocate the memory holding intrpt_routine and

* Task while tq_timer still references them.

* Notice that here we don't allow signals to

* interrupt us.

*

* Since WaitQ is now not NULL, this automatically

* tells the interrupt routine it's time to die. */

sleep_on(&WaitQ);

}

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

Имеются два типа взаимодействия между CPU и остальной частью аппаратных средств компьютера. Первый тип, когда CPU дает команды аппаратным средствам, другой, когда аппаратные средства должны сообщить что-то CPU. Второй, названный прерываниями, является намного более тяжелым в работе, потому что с ним нужно иметь дело когда удобно аппаратным средствам, а не CPU. Аппаратные устройства обычно имеют очень маленькое количество ОЗУ, и если Вы не читаете их информацию сразу, она теряется.

Под Linux аппаратные прерывания названы IRQ (сокращение от Interrupt Re quests) [12] Это стандартная вещь в архитектуре Intel, на которой началась разработка системы Linux. . Имеется два типа IRQ: короткий и длинный. Короткий IRQ тот, который займет очень короткий период времени, в течение которого остальная часть машины будет блокирована, и никакие другие прерывания не будут обработаны. Длинный IRQ тот, который может занять более длительное время, в течение которого другие прерывания могут происходить (но не прерывания из того жесамого устройства). Если возможно, лучше объявить, что программа обработки прерывания будет длинной.

Когда CPU получает прерывание, он останавливает любые процессы (если это не более важное прерывание, тогда обработка пришедшего прерывания будет иметь место только когда более важное будет выполнено), сохраняет параметры в стеке и вызывает программу обработки прерывания (обработчик прерывания). Это означает, что некоторые вещи не позволяются в программе обработки прерывания непосредственно, потому что система находится в неизвестном состоянии. Решение для этой проблемы: программа обработки прерывания, должна разобраться что должно быть выполнено немедленно (обычно чтение чего-то из аппаратных средств или посылка чего-либо аппаратным средствам), затем запланировать обработку новой информации в более позднее время (это названо «нижней половиной») и вернуть управление. Ядро гарантирует вызов нижней половины как можно скорее. Когда оно это сделает, все позволенное в модулях будет доступно нашему обработчику.