Чтобы помочь прояснить разные значения, которые может принимать si_code, рассмотрим пример, в котором SIGCHLD генерируется четырьмя разными способами: kill(), sigqueue(), raise() (использует системный вызов tkill()) и созданием дочернего процесса, который немедленно прерывается.
1: /* sicode.с */
2:
3: #include <sys/signal.h>
4: #include <stdlib.h>
5: #include <stdio.h>
6: #include <unistd.h>
7:
8: #ifndef SI_TKILL
9: #define SI_TKILL -6
10: #endif
11:
12: void handler(int signo, siginfo_t *info, void *f ) {
13: static int count = 0;
14:
15: printf("перехвачен сигнал, отправленный ");
16: switch(info->si_code) {
17: case SI_USER:
18: printf("kill()n"); break;
19: case SI_QUEUE:
20: printf("sigqueue()n"); break;
21: case SI_TKILL:
22: printf("tkill() или raise()n"); break;
23: case CLD_EXITED:
24: printf ("ядро сообщает, что дочерний процесс завершенn"); exit(0);
25: }
26:
27: if (++count == 4) exit(1);
28: }
29:
30: int main() {
31: struct sigaction act;
32: union sigval val;
33: pid_t pid = getpid();
34:
35: val.sival_int = 1234;
36:
37: act.sa_sigaction = handler;
38: sigemptyset(&act.sa_mask);
39: act.sa_flags = SA_SIGINFO;
40: sigaction(SIGCHLD, &act, NULL);
41:
42: kill(pid, SIGCHLD);
43: sigqueue(pid, SIGCHLD, val);
44: raise(SIGCHLD);
45:
46: /* Чтобы получить SIGCHLD от ядра, мы создаем дочерний процесс
47: и немедленно завершаем его. Обработчик сигнала выйдет после
48: получения сигнала от ядра, поэтому мы просто засыпаем
49: на время и позволяем программе прерваться подобным образом. */
50:
51: if (!fork()) exit(0);
52: sleep(60);
53:
54: return 0;
55: }
Если si_code равно SI_USER, SI_QUEUE или SI_TKILL, то доступны два дополнительных члена siginfo_t: si_pid и si_uid, которые представляют идентификатор процесса, пославшего сигнал и действительный идентификатор пользователя этого процесса.
Когда ядром посылается SIGCHLD, доступны члены si_pid, si_status, si_utime и si_stime. Первый из них, si_pid, задает идентификатор процесса, состояние которого изменилось[72]. Информация о новом состоянии доступна как в si_code (как показано в табл. 12.3) и в si_status, что идентично целому значению состояния, возвращаемому семейством функций wait().
Последние два члена, si_utime и si_stime, определяют период времени, которое потрачено дочерним приложением на работу в пользовательском режиме и в режиме ядра, соответственно (это подобно тому, что возвращают вызовы wait3() и wait4() в структуре struct rusage). Это время измеряется в тиках часов, заданных целым числом. Количество тиков в секунду задает макрос _SC_CLK_TCK, определенный в <sysconf.h>.
SIGSEGV, SIGBUS, SIGILL и SIGFPE — все они представляют si_addr, специфицирующий адрес, который вызвал сбой, описанный si code.
Ниже приведен простой пример проверки контекста сигнала. Он устанавливает обработчик сигнала для SIGSEGV, который печатает контекст сигнала и прерывает процесс. Нарушение сегментации генерируется попыткой обращения к NULL.
1: /* catch-segv.c */
2:
3: #include <sys/signal.h>
4: #include <stdlib.h>
5: #include <stdio.h>
6:
7: void handler(int signo, siginfo_t *info, void *f) {
8: printf("перехват");
9: if (info->si_signo == SIGSEGV)
10: printf("segv accessing %p", info->si_addr);
11: if (info->si_code == SEGV_MAPERR)
12: printf("SEGV_MAPERR");
13: printf("n");
14:
15: exit(1);
16: }
17:
18: int main() {
19: struct sigactin act;
20:
21: act.sa_sigaction = handler;
22: sigemptyset(&act.sa_mask);
23: act.sa_flags = SA_SIGINFO;
24: sigaction(SIGSEGV, &act, NULL);
25:
26: *((int *)NULL) = 1 ;
27:
28: return 0;
29: }
12.7.2. Отправка данных с сигналом
Механизм siginfo_t также позволяет сигналам, которые посылают программы, присоединять к себе один элемент данных (этот элемент может быть указателем, что позволяет неявно передавать любой необходимый объем данных). Чтобы отправить данные, используется union sigval.
#include <signal.h>
union sigval {
int sival_int;
void *sival_ptr;
};
Любой из членов объединения — sival_int или sival_ptr — может быть установлен в требуемое значение, которое включается в siginfo_t, доставляемое вместе с сигналом. Чтобы сгенерировать сигнал с union sigval, должна использоваться функция sigqueue().
#include <signal.h>
void *sigqueue(pid_t pid, int signum, const union sigval value);
В отличие от kill(), pid должен быть корректным идентификатором процесса (отрицательные значения не допускаются), signum указывает номер посылаемого сигнала. Подобно kill(), sigqueue() допускает нулевое значение signum нулю, чтобы проверить, позволяет ли вызывающий процесс посылать целевому сигналы, в действительности не выполняя такой посылки. Последний параметр, value, представляет собой элемент данных, передаваемый вместе с сигналом.
Чтобы принять union sigval, процесс, перехватывающий сигнал, должен использовать SA_SIGINFO при регистрации обработчика сигналов с помощью sigaction(). Когда член si_code структуры siginfo_t равен SI_QUEUE, то siginfo_t представляет член si_value, который содержит значение value, переданное sigqueue.
Ниже приведен пример отправки элемента данных с сигналом. Он устанавливает в очередь три сигнала SIGRTMIN с разными элементами данных. Он демонстрирует, что сигналы доставляются в том же порядке, что были отправлены, как мы и ожидаем при работе с сигналами реального времени[73]. Более сложный пример, использующий сигналы для отслеживания изменений в каталогах, можно найти в главе 14.
1: /* sigval.с */
2:
3: #include <sys/signal.h>
4: #include <stdlib.h>
5: #include <stdio.h>
6: #include <string.h>
7: #include <unistd.h>
8:
9: /* Захватить сигнал и зарегистрировать факт его обработки */
10: void handler(int signo, siginfo_t *si, void *context) {
11: printf("%dn", si->si_value.sival_int);
12: }
13:
14: int main() {
15: sigset_t mask;
16: sigset_t oldMask;
17: struct sigaction act;
18: int me = getpid();
19: union sigval val;
20:
21: /* Отправить сигналы handler() и сохранять все сигналы заблокированными,
22: чтобы handler() был сконфигурирован для перехвата с исключением
23: состязаний при манипулировании глобальными переменными */
24: act.sa_sigaction = handler;
25: act.sa_mask = mask;
26: act.sa_flags = SA_SIGINFO;
27:
28: sigaction(SIGRTMIN, &act, NULL);
29:
30: /* Блокировать SIGRTMIN, чтобы можно было увидеть очередь и упорядочение*/
31: sigemptyset(&mask);
32: sigaddset(&mask, SIGRTMIN);
33:
34: sigprocmask(SIG_BLOCK, &mask, &oldMask);
35:
36: /* Сгенерировать сигналы */
37: val.sival_int = 1;
38: sigqueue(me, SIGRTMIN, val);
39: val.sival_int++;
40: sigqueue(me, SIGRTMIN, val);
41: val.sival_int++;
42: sigqueue(me, SIGRTMIN, val);
43:
44: /* Разрешить доставку сигналов */
45: sigprocmask(SIG_SETMASK, &oldMask, NULL);
46:
47: return 0;
48: }
Глава 13
Расширенная обработка файлов
В Linux файлы применяются при решении большого количества задач, среди которых, например, хранение долговременных данных, организация сетей с помощью сокетов и доступ к устройствам посредством файлов устройств. Разнообразие приложений, работающих с файлами, привело к созданию множества специальных способов управления файлами. В главе 11 рассматривались наиболее распространенные действия с файлами; в настоящей же главе исследуются специализированные файловые операции. В частности, мы рассмотрим следующие вопросы: использование одновременно нескольких файлов, отображение файлов на системную память, блокировка файлов, чтение и запись вразброс.
