Н.В. Вдовикина, А.В. Казунин, И.В. Машечкин, А.Н. Терехин - Системное программное обеспечение - взаимодействие процессов (2002), страница 9

/* восстанавливаем обработчик сигнала */

}

int main(int argc, char **argv)

{

signal (SIGINT, SigHndlr); /* установка реакции на сигнал */

while (1); /*”тело программы” */

return 0;

}

1. Удаление временных файлов при завершении программы.

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

#include <unistd.h>

#include <signal.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

const char * tempfile = “abc”;

void SigHndlr (int s)

{

unlink(tempfile);

/* уничтожение временного файла в случае прихода сигнала SIGINT. В случае, если такой файл не существует (еще не создан или уже удален), вызов вернет -1 */

}

int main(int argc, char **argv)

{

signal (SIGINT, SigHndlr); /*установка реакции на сигнал */

…

creat(tempfile, 0666); /*создание временного файла*/

…

unlink(tempfile);

/*уничтожение временного файла в случае нормального функционирования процесса */

return 0;

}

В данном примере для создания временного файла используется системный вызов creat():

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

int creat(const char *pathname, mode_t mode);

А системный вызов unlink() удаляет имя и файл, на который оно ссылается.

#include <unistd.h>

int unlink(const char *pathname);

1. Программа “Будильник”.

Программа “Будильник”. Существуют задачи, в которых необходимо прервать выполнение процесса по истечении некоторого количества времени. Средствами ОС “заводится” будильник, который будет поторапливать ввести некоторое имя. Системный вызов alarm():

#include <unistd.h>

unsigned int alarm(unsigned int seconds);

инициализирует отложенное появление сигнала SIGALRM - процесс запрашивает ядро отправить ему самому сигнал по прошествии определенного времени.

#include <unistd.h>

#include <signal.h>

#include <stdio.h>

void alrm(int s) /*обработчик сигнала SIG_ALRM */

{

printf(“\n жду имя \n”);

alarm(5); /* заводим будильник */

signal(SIGALRM, alrm); /* переустанавливаем реакцию на сигнал */

}

int main(int argc, char **argv)

{

char s[80];

signal(SIGALRM, alrm);

/* установка обработчика alrm на приход сигнала SIG_ALRM */

alarm(5); /* заводим будильник */

printf(“Введите имя \n”);

for (;;)

{

printf(“имя:”);

if (gets(s) != NULL) break; /* ожидаем ввода имени */

};

printf(“OK! \n”);

return 0;

}

В начале программы мы устанавливаем реакцию на сигнал SIGALRM - функцию alarm(), далее мы заводим будильник, запрашиваем “Введите имя” и ожидаем ввода строки символов. Если ввод строки задерживается, то будет вызвана функция alarm(), которая напомнит, что программа “ждет имя”, опять заведет будильник и поставит себя на обработку сигнала SIGALRM еще раз. И так будет до тех пор, пока не будет введена строка. Здесь имеется один нюанс: если в момент выполнения системного вызова возникает событие, связанное с сигналом, то система прерывает выполнение системного вызова и возвращает код ответа, равный «-1».

1. Двухпроцессный вариант программы “Будильник”.

#include <signal.h>

#include <sys/types.h>

#include <unistd.h>

#include <stdio.h>

void alr(int s)

{

printf(“\n Быстрее!!! \n”);

signal(SIGALRM, alr);

/* переустановка обработчика alr на приход сигнала SIGALRM */

}

int main(int argc, char **argv)

{

char s[80];

int pid;

signal(SIGALRM, alr);

/* установка обработчика alr на приход сигнала SIGALRM */

if (pid = fork()) {

for (;;)

{

sleep(5); /*приостанавливаем процесс на 5 секунд */

kill(pid, SIGALRM);

/*отправляем сигнал SIGALRM процессу- сыну */

}

}

else {

printf(“Введите имя \n”);

for (;;)

{

printf(“имя:”);

if (gets(s) != NULL) break; /*ожидаем ввода имени*/

}

printf(“OK!\n”);

kill(getppid(), SIGKILL);

/* убиваем зациклившегося отца */

}

return 0;

}

В данном случае программа реализуется в двух процессах. Как и в предыдущем примере, имеется функция реакции на сигнал alr(), которая выводит на экран сообщение и переустанавливает функцию реакции на сигнал, опять же на себя. В основной программе мы также указываем alr() как реакцию на SIGALRM. После этого мы запускаем сыновний процесс, и отцовский процесс (бесконечный цикл) “засыпает” на 5 единиц времени, после чего сыновнему процессу будет отправлен сигнал SIGALRM. Все, что ниже цикла, будет выполняться в процессе-сыне: мы ожидаем ввода строки, если ввод осуществлен, то происходит уничтожение отца (SIGKILL).

5.2Надежные сигналы.

Вышеописанная реализация механизма сигналов имела место в ранних версиях UNIX (UNIX System V.2 и раньше). Позднее эта реализация подверглась критике за недостаточную надежность. В частности, это касалось сброса диспозиции перехваченного сигнала в реакцию по умолчанию всякий раз перед вызовом функции-обработчика. Хотя и существует возможность заново установить реакцию на сигнал в функции-обработчике, возможна ситуация, когда между моментом вызова пользовательского обработчика некоторого сигнала и моментом, когда он восстановит нужную реакцию на этот сигнал, будет получен еще один экземпляр того же сигнала. В этом случае второй экземпляр не будет перехвачен, так как на момент его прихода для данного сигнала действует реакция по умолчанию.

Поэтому в новых версиях UNIX (BSD UNIX 4.2 и System V.4) была реализована альтернативная модель так называемых надежных сигналов, которая вошла и в стандарт POSIX. В этой модели при перехватывании сигнала ядро не меняет его диспозицию, тем самым появляется гарантия перехвата всех экземпляров сигнала. Кроме того, чтобы избежать нежелательных эффектов при рекурсивном вызове обработчика для множества экземпляров одного и того же сигнала, ядро блокирует доставку других экземпляров того же сигнала в процесс до тех пор, пока функция-обработчик не завершит свое выполнение.

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

Рассмотрим системные вызовы для работы с сигнальной маской процесса. Сигнальная маска описывается битовым полем типа sigset_t. Для управления сигнальной маской процесса служит системный вызов:

#include <signal.h>

int sigprocmask(int how, const sigset_t *set, sigset_t *old_set);

Значения аргумента how влияют на характер изменения маски сигналов:

SIG_BLOCK – к текущей маске добавляются сигналы, указанные в наборе set;

SIG_UNBLOCK – из текущей маски удаляются сигналы, указанные в наборе set;

SIG_SETMASK – текущая маска заменяется на набор set.

Если в качестве аргумента set передается NULL-указатель, то сигнальная маска не изменяется, значение аргумента how при этом игнорируется. В последнем аргументе возвращается прежнее значение сигнальной маски до изменения ее вызовом sigprocmask(). Если процесс не интересуется прежним значением маски, он может передать в качестве этого аргумента NULL-указатель.

Если один или несколько заблокированных сигналов будут разблокированы посредством вызова sigprocmask(), то для их обработки будет использована диспозиция сигналов, действовавшая до вызова sigprocmask(). Если за время блокирования процессу пришло несколько экземпляров одного и того же сигнала, то ответ на вопрос о том, сколько экземпляров сигнала будет доставлено – все или один – зависит от реализации конкретной ОС.

Существует ряд вспомогательных функций, используемых для того, чтобы сформировать битовое поле типа sigset_t нужного вида:

• Инициализация битового набора - очищение всех битов:

#include <signal.h>

int sigemptyset(sigset_t *set);

• Противоположная предыдущей функция устанавливает все биты в наборе:

#include <signal.h>

int sigfillset(sigset_t *set);

• Две следующие функции позволяют добавить или удалить флаг, соответствующий сигналу, в наборе:

#include <signal.h>

int sigaddset(sigset_t *set, int signo);

int sigdelset(sigset_t *set, int signo);

В качестве второго аргумента этим функциям передается номер сигнала

• Приведенная ниже функция проверяет, установлен ли в наборе флаг, соответствующий сигналу, указанному в качестве параметра:

#include <signal.h>

int sigismember(sigset_t *set, int signo);

Этот вызов возвращает 1, если в маске set установлен флаг, соответствующий сигналу signo, и 0 в противном случае.

Чтобы узнать, какие из заблокированных сигналов ожидают доставки, используется функция sigpending():

#include <signal.h>

int sigpending(sigset_t *set);

Через аргумент этого вызова возвращается набор сигналов, ожидающих доставки.

1. Работа с сигнальной маской.

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

#include <signal.h>

#include <sys/types.h>

#include <stdlib.h>

#include <stdio.h>

int main(int argc, char **argv)

{

sigset_t sigset;

int fl;

sigemptyset(&sigset);

printf("Добавить SIGINT к текущей маске? (yes - 1, no - 0) \n");

scanf("%d", &fl);

if (fl)

{

sigaddset(&sigset, SIGINT);

sigprocmask(SIG_BLOCK, &sigset, NULL);

}

printf("Послать SIGINT? (yes - 1, no - 0)\n");

scanf("%d", &fl);

if (fl)

kill(getpid(), SIGINT);

if (sigprocmask(SIG_BLOCK, NULL, &sigset) == -1)

/* получаем сигнальную маску процесса. Так как второй аргумент NULL, то первый аргумент игнорируется */

{

printf(“Ошибка при вызове sigprocmask()\n”);

return -1;

}

else if (sigismember(&sigset, SIGINT))

/*проверяем наличие сигнала SIGINT в маске*/

{

printf(“Сигнал SIGINT заблокирован! \n”);

sigemptyset(&sigset);

if (sigpending(&sigset) == -1)

/*узнаем сигналы, ожидающие доставки */

{

printf(“Ошибка при вызове sigpending()\n”);

return -1;

}

printf(“Сигнал SIGINT %s\n”, sigismember(&sigset, SIGINT) ? “ожидает доставки” : “не ожидает доставки”);

/*проверяем наличие сигнала SIGINT в маске*/

}

else printf(“Сигнал SIGINT не заблокирован. \n”);

return 0;

}

Для управления работой сигналов используется функция, аналогичная функции signal() в реализации обычных сигналов, но более мощная, позволяющая установить обработку сигнала, узнать ее текущее значение, приостановить получение сигналов:

#include <signal.h>

int sigaction(int sig, const struct sigaction *act, struct *oact)

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

Структура sigaction содержит информацию, необходимую для управления сигналами. Ее полями являются :

void (*sa_handler) (int),

void (sa_sigaction) (int, siginfo_t*, void*),

sigset_t sa_mask,