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

 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 Requests) [12] . Имеется два типа IRQ: короткий и длинный. Короткий IRQ тот, который займет очень короткий период времени, в течение которого остальная часть машины будет блокирована, и никакие другие прерывания не будут обработаны. Длинный IRQ тот, который может занять более длительное время, в течение которого другие прерывания могут происходить (но не прерывания из того жесамого устройства). Если возможно, лучше объявить, что программа обработки прерывания будет длинной.

12

Это стандартная вещь в архитектуре Intel, на которой началась разработка системы Linux.