Краткая справка

Эта глава представляет следующие символы.

Сохранение времени

#include <linux/param.h>

HZ

Символ HZ определяет число тактовых тиков, генерируемых за секунду.

#include <linux/jiffies.h>

volatile unsigned long jiffies

u64 jiffies_64

Переменная jiffies_64 увеличивается один раз за каждой тактовый тик; таким образом, она увеличивается HZ раз в секунду. Код ядра чаще всего использует jiffies, которая то же самое, что и jiffies_64 на 64-х разрядных платформах и является его младшей половиной на 32-х разрядных платформах.

int time_after(unsigned long a, unsigned long b);

int time_before(unsigned long a, unsigned long b);

int time_after_eq(unsigned long a, unsigned long b);

int time_before_eq(unsigned long a, unsigned long b);

Эти логические выражения сравнивают тики безопасным способом, без проблем в случае переполнения счётчика и без необходимости доступа к jiffies_64.

u64 get_jiffies_64(void);

Получает jiffies_64 без состояния гонок.

#include <linux/time.h>

unsigned long timespec_to_jiffies(struct timespec *value);

void jiffies_to_timespec(unsigned long jiffies, struct timespec *value);

unsigned long timeval_to_jiffies(struct timeval *value);

void jiffies_to_timeval(unsigned long jiffies, struct timeval *value);

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

#include <asm/msr.h>

rdtsc(low32,high32);

rdtscl(low32);

rdtscll(var64);

Макрос для x86 для чтения тактового счетчика. Они читают его как две 32-х разрядные половины, читая только младшую половину или читая всё это в переменную long long.

#include <linux/timex.h>

cycles_t get_cycles(void);

Возвращает тактовый счётчик независимым от платформы образом. Если процессор не предлагает функцию тактового счётчика, возвращается 0.

#include <linux/time.h>

unsigned long mktime(year, mon, day, h, m, s);

Возвращает количество секунд с начала эпохи, основанной на шести аргументах типа unsigned int.

void do_gettimeofday(struct timeval *tv);

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

struct timespec current_kernel_time(void);

Возвращает текущее время с разрешением в один тик.

Задержки

#include <linux/wait.h>

long wait_event_interruptible_timeout(wait_queue_head_t *q, condition, signed long timeout);

Помещает текущий процесс в сон в очередь ожидания, задавая значение timeout в тиках. Для непрерываемого сна используйте schedule_timeout (смотрите ниже).

#include <linux/sched.h>

signed long schedule_timeout(signed long timeout);

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

#include <linux/delay.h>

void ndelay(unsigned long nsecs);

void udelay(unsigned long usecs);

void mdelay(unsigned long msecs);

Вводит задержки на целое число наносекунд, микросекунд и миллисекундах. Задержка достигает по крайней мере желаемого значения, но она может быть и больше. Аргумент каждой функции не должна превышать предела, специфичного для каждой платформы (обычно, несколько тысяч).

void msleep(unsigned int millisecs);

unsigned long msleep_interruptible(unsigned int millisecs);

void ssleep(unsigned int seconds);

Помещает процесс в сон на заданное число миллисекунд (или секунд, в случае ssleep).

Таймеры ядра

#include <asm/hardirq.h>

int in_interrupt(void);

int in_atomic(void);

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

#include <linux/timer.h>

void init_timer(struct timer_list * timer);

struct timer_list TIMER_INITIALIZER(_function, _expires, _data);

Эта функция и статическая декларация по таймерной структуры являются двумя способами инициализации структуры данных timer_list.

void add_timer(struct timer_list * timer);

Регистрирует таймерную структуру для запуска на текущем процессор.

int mod_timer(struct timer_list *timer, unsigned long expires);

Изменяет время окончания уже запланированной таймерной структуры. Она может также выступать в качестве альтернативы add_timer.

int timer_pending(struct timer_list * timer);

Макрос, который возвращает логическое значение для определения, зарегистрирована ли уже для запуска таймерная структура.

void del_timer(struct timer_list * timer);

void del_timer_sync(struct timer_list * timer);

Удаление таймера из списка активных таймеров. Последняя функция гарантирует, что таймер не запущен на другом процессоре.

Микрозадачи

#include <linux/interrupt.h>

DECLARE_TASKLET(name, func, data);

DECLARE_TASKLET_DISABLED(name, func, data);

void tasklet_init(struct tasklet_struct *t, void (*func)(unsigned long), unsigned long data);

Первые два макроса декларируют структуру микрозадачи, а функция tasklet_init инициализирует структуру микрозадачи, которая была получена путём создания во время работы или другими способами. Второй из макросов DECLARE помечает микрозадачу как отключённую.

void tasklet_disable(struct tasklet_struct *t);

void tasklet_disable_nosync(struct tasklet_struct *t);

void tasklet_enable(struct tasklet_struct *t);

Отключает и снова включает микрозадачу. Каждое отключение должно сопровождаться включением (вы можете отключить  микрозадачу даже если она уже отключена). Функция tasklet_disable ожидает завершения микрозадачи, если она работает на другом процессоре. Версия nosync не делает этого дополнительного шага.

void tasklet_schedule(struct tasklet_struct *t);

void tasklet_hi_schedule(struct tasklet_struct *t);

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

void tasklet_kill(struct tasklet_struct *t);

Удаляет микрозадачу из списка активных, если она запланирована для запуска. Как и tasklet_disable, эта функция может блокироваться на многопроцессорных системах, ожидая завершения микрозадачи, если она в настоящее время работает на другом процессоре.

Очереди задач

#include <linux/workqueue.h>

struct workqueue_struct;

struct work_struct;

Структуры, являющиеся очередью задач и рабочей записью, соответственно.

struct workqueue_struct *create_workqueue(const char *name);

struct workqueue_struct *create_singlethread_workqueue(const char *name);

void destroy_workqueue(struct workqueue_struct *queue);

Функции для создания и уничтожения очередей задач. Вызов create_workqueue создаёт очередь с рабочим потоком на каждом процессоре в системе; наоборот, create_singlethread_workqueue создаёт очередь задач с одним рабочим процессом.

DECLARE_WORK(name, void (*function)(void *), void *data);

INIT_WORK(struct work_struct *work, void (*function)(void *), void *data);

PREPARE_WORK(struct work_struct *work, void (*function)(void *), void *data);

Макросы, которые объявляют и инициализируют записи очереди задач.

int queue_work(struct workqueue_struct *queue, struct work_struct *work);

int queue_delayed_work(struct workqueue_struct *queue, struct work_struct *work, unsigned long delay);

Функции, которые последовательно работают для запуска из очереди задач.

int cancel_delayed_work(struct work_struct *work);

void flush_workqueue(struct workqueue_struct *queue);

Используйте cancel_delayed_work для удаления записи из очереди задач; flush_workqueue гарантирует, что никакая из записей в очереди задач не работает где-либо в системе.

int schedule_work(struct work_struct *work);

int schedule_delayed_work(struct work_struct *work, unsigned long delay);

void flush_scheduled_work(void);

Функции для работы с общей очередью задач.