Читаем Linux API. Исчерпывающее руководство полностью

printf("%s: exiting\n", argv[0]);

exit(EXIT_SUCCESS);

}

signals/sig_sender.c

Программа из листинга 20.7 предназначена для перехвата и передачи информации о сигналах, отправленных программой из листинга 20.6. Она выполняет такие шаги.

• Устанавливает обработчик для перехвата всех сигналов . (Сигналы SIGKILL и SIGSTOP перехватить невозможно, но мы игнорируем ошибку, происходящую при попытке установить обработчик для этих сигналов.) Чаще всего обработчик просто подсчитывает сигналы с помощью массива. Если получен сигнал SIGINT, то обработчик устанавливает флаг (gotSigint), что заставляет программу выйти из основного цикла (цикл while, описываемый ниже). (Объяснение применения классификатора volatile и типа данных sig_atomic_t, использованного для объявления переменной gotSigint см. в подразделе 21.1.3.)

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

• Программа выполняет цикл while, потребляющий процессорное время до тех пор, пока не установлен флаг gotSigint . (В разделах 20.14 и 22.9 описывается применение функций pause() и sigsuspend(), являющихся более эффективными в отношении ресурсов процессора методами ожидания доставки сигнала.)

• После выхода из цикла while программа отображает количество всех полученных сигналов .

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

$ ./sig_receiver 15 & Получатель блокирует сигналы на 15 секунд

[1] 5368

./sig_receiver: PID is 5386

./sig_receiver: sleeping for 15 seconds

$ ./sig_sender 5368 1000000 10 2 Отправка сигналов SIGUSR1 и сигнала SIGINT

./sig_sender: sending signal 10 to process 5368 1000000 times

./sig_sender: exiting

./sig_receiver: pending signals are:

2 (Interrupt)

10 (User defined signal 1)

./sig_receiver: signal 10 caught 1 time

[1]+ Done./sig_receiver 15

В аргументах командной строки для отправляющей программы были указаны сигналы SIGUSR1 и SIGINT, являющиеся в Linux/ х86 сигналами 10 и 2 соответственно.

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

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

$ ./sig_receiver &

[1] 5393

./sig_receiver: PID is 5393

$ ./sig_sender 5393 1000000 10 2

./sig_sender: sending signal 10 to process 5393 1000000 times

./sig_sender: exiting

./sig_receiver: signal 10 caught 52 times

[1]+ Done./sig_receiver

Из миллиона отправленных сигналов только 52 были перехвачены процессом-получателем. (Точное количество перехваченных сигналов будет варьироваться в зависимости от причуд алгоритма планирования ядра.) Причина этого заключается в том, что каждый раз, когда программа-отправитель запускается по плану, она отправляет получателю несколько сигналов. Однако только один из этих сигналов помечается как ожидающий и доставляется лишь тогда, когда у получателя есть возможность запуститься.

Листинг 20.7. Перехват и подсчет сигналов

signals/sig_receiver.c

#define _GNU_SOURCE

#include

#include "signal_functions.h" /* Объявление printSigset() */

#include "tlpi_hdr.h"

static int sigCnt[NSIG]; /* Считает количество доставок каждого сигнала */

static volatile sig_atomic_t gotSigint = 0;

/* Устанавливается ненулевое значение в случае доставки SIGINT */

static void

handler(int sig)

{

if (sig == SIGINT)

gotSigint = 1;

else

sigCnt[sig]++;

}

int

main(int argc, char *argv[])

{

int n, numSecs;

sigset_t pendingMask, blockingMask, emptyMask;

printf("%s: PID is %ld\n", argv[0], (long) getpid());

for (n = 1; n < NSIG; n++) /* Один обработчик для всех сигналов */

(void) signal(n, handler); /* Игнорируем ошибки */

/* Если указано время сна, временно заблокировать все сигналы, спать (пока другой

процесс посылает нам сигналы), а затем отобразить маску ожидающих сигналов

и разблокировать все сигналы */

if (argc > 1) {

numSecs = getInt(argv[1], GN_GT_0, NULL);