Разработка приложений в среде Linux. Второе издание - Майкл Джонсон

185:      это гарантирует, что мы захватим файлы, созданные кем-то

186:      во время сканирования каталога. Если кто-то изменит его,

187:      будет сгенерирован сигнал (и заблокирован, пока

188:      мы не будем готовы принять его) */

189:   if (fcntl(directoryList[i].fd, F_NOTIFY, DN_DELETE |

190:    DN_CREATE | DN_RENAME | DN_MULTISHOT) ) {

191:    perror("fcntl F_NOTIFY");

192:    return 1;

193:   }

194:

195:   fcntl(directoryList[i].fd, F_SETSIG, SIGRTMIN);

196:

197:   if (build DirectoryList(directoryList[i].path,

198:    &directoryList[i].contents))

199:    return 1;

200:  }

201:

202:  while (1) {

203:   sigsuspend(&mask);

204:

205:   for (i = 0; directoryList[i].path; i++)

206:    if (directoryList[i].changed)

207:     if (updateDirectoryList(directoryList[i].path,

208:      &directoryList[i].contents))

209:      return 1;

210:  }

211:

212:  return 0;

213: }

Глава 15

Управление заданиями

Управление заданиями — возможность, стандартизованная в POSIX.1 и предоставляемая многими другими стандартами — позволяет одному терминалу выполнять несколько заданий. Задание (job) — это один процесс или группа процессов, обычно соединенных каналами. Для перемещения заданий между передним планом и фоном и предотвращения доступа к терминалу фоновых заданий предусмотрены специальные механизмы.

15.1. Основы управления заданиями

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

Одна из групп процессов в сеансе является группой переднего плана. Остальные группы являются фоновыми. Фоновую группу можно заменить любой группой процессов, принадлежащей к сеансу, позволяя пользователю переключаться между группами процессов переднего плана. Процессы, являющиеся элементами группы процессов переднего плана, часто называют процессами переднего плана; остальные процессы называются фоновыми.

15.1.1. Перезапуск процессов

Каждый процесс может пребывать в трех состояниях: выполнение, останов и "зомби". Выполняющиеся процессы завершаются системным вызовом exit() или отправкой сигнала фатального завершения. Процессы перемещаются между состояниями работы и остановки исключительно посредством сигналов, сгенерированных другим процессом, ядром либо ими самими[105].

Когда процесс получает SIGCONT, ядро перемещает его из состояния останова в состояние выполнения; если процесс уже работает, сигнал не влияет на его состояние. Процесс может захватить сигнал; ядро в это время будет перемещать процесс в рабочее состояние перед передачей сигнала.

15.1.2. Остановка процессов

Четыре сигнала перемещают работающий процесс в состояние останова. SIGSTOP никогда не генерируется ядром. Он предназначен для остановки произвольных процессов. Его невозможно захватить или проигнорировать; он всегда останавливает целевой процесс. Остальные три сигнала, останавливающие процессы — SIGTSTP, SIGTTIN и SIGTTOU — могут генерироваться терминалом, на котором работает процесс, или другим процессом. Хотя эти сигналы ведут себя похожим образом, они генерируются при разных обстоятельствах.

SIGTSTP

Этот сигнал передается каждому процессу группы процессов переднего плана, когда пользователь нажимает клавиатурную комбинацию приостановки терминала[106].

SIGTTIN

Когда фоновый процесс пытается считывать из терминала, ему передается SIGTTIN.

SIGTTOU

Этот сигнал обычно генерируется фоновым процессом, пытающимся выполнить запись в свой терминал. Сигнал генерируется только в случае установки атрибута терминала TOSTOP, как рассматривается в главе 16.

Данный сигнал генерируется также фоновым процессом, вызывающим tcflush(), tcflow(), tcsetattr(), tcsetpgrp(), tcdrain() или tcsendbreak().

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

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

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

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

При получении SIGTSTP процесс должен немедленно выполнить все необходимые ему действия, чтобы разрешить приостановку (например, восстановление исходного состояния терминала) и приостановиться самому. Самый простой способ приостановки процесса — передача самому себе сигнала SIGSTOP. Однако большинство оболочек отображают сообщения с типом сигнала, вызвавшего остановку процесса, и если процесс передаст себе sigstop, он будет отличаться от большинства приостановленных процессов. Во избежание этого неудобства многие приложения сбрасывают свой обработчик SIGTSTP в SIG_DFL и передают себе SIGTSTP.

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

Ниже приведен код простого обработчика сигналов SIGCONT и SIGTSTP. Когда пользователь приостанавливает или перезапускает процесс, последний отображает сообщение перед остановкой или продолжением.

 1: /* monitor.с */

 2:

 3: #include <signal.h>

 4: #include <stdio.h>

 5: #include <string.h>

 6: #include <unistd.h>

 7:

 8: void catchSignal(int sigNum, int useDefault);

 9:

10: void handler(int signum) {

11:  if (signum == SIGTSTP) {

12:   write(STDOUT_FILENO, "получен SIGTSTPn", 12);

13:   catchSignal(SIGTSTP, 1);

14:   kill(getpid(), SIGTSTP);

15:  } else {

16:   write(STDOUT_FILENO, "получен SIGCONTn", 12);

17:   catchSignal(SIGTSTP, 0);

18:  }

19: }

20:

21: void catchSignal(int sigNum, int useDefault) {

22:  struct sigaction sa;

23:

24:  memset(&sa, 0, sizeof(sa));

25:

26:  if (useDefault)

27:   sa.sa_handler = SIG_DFL;

28:  else

29:   sa.sa_handler = handler;

30:

31:  if (sigaction(sigNum, &sa, NULL)) perror("sigaction");

32: }

33:

34: int main() {

35:  catchSignal(SIGTSTP, 0);

36:  catchSignal(SIGCONT, 0);

37:

38:  while(1);

39:

40:  return 0;

41: }

15.2. Управление заданиями в ladsh

Добавление управления заданиями к ladsh — это последнее добавление к простой оболочке, окончательный исходный код которой можно найти в приложении Б. Для начала потребуется добавить по элементу в структуры struct childProgram, struct job и struct jobSet. Поскольку ladsh некоторое время не рассматривался, вернитесь в главу 10, где были впервые представлены эти структуры данных. Ниже показано окончательное определение struct childProgram.

35: struct childProgram {

36:  pid_t pid;           /* 0 на выходе */

37:  char ** argv;        /* имя программы с аргументами * /

38:  int numRedirections; /* элементы в массиве переадресации */

39:  struct redirectionSpecifier * redirections; /* переадресации ввода-вывода */

40:  glob_t globResult;   /* результат универсализации параметров */

41:  int freeGlob;        /* должен ли освобождаться globResult? */

42:  int isStopped;       /* выполняется ли программа в данный момент?*/

43: };

Мы уже различаем работающие и завершенные дочерние программы с помощью элемента pid структуры struct childProgram, равного нулю в случае завершения дочерней программы, а в противном случае содержащего действительный идентификатор процесса. Новый элемент, isStopped, не равен нулю, если процесс был остановлен, в ином же случае он равен нулю. Обратите внимание, что его значение неважно, если pid равен нулю.