Obsługa sygnałów zgodna ze
standardem Posix cz.2
Obsługa sygnałów zgodna ze
standardem Posix cz.2
Blokowanie sygnałów
Może się zdarzyć, że będziemy chcieli poinformować jądro o
tym, że nie chcemy żeby niektóre sygnały przekazywane były
bezpośrednio do danego procesu.
Możemy na przykład mieć w kodzie jakiś krytyczny fragment,
którego wykonanie nie powinno zostać przerwane przez
sygnały.
Robi się to przez ustalenie tzw. maski sygnałów.
Maska sygnałów jest zbiorem sygnałów, tzn. pewną strukturą
w której każdemu sygnałowi jest przypisany jeden bit (prawda
lub fałsz).
Struktura taka nosi nazwę sigset_t, i najczęściej jest
implementowana w postaci czterobajtowej liczby całkowitej.
Funkcje obsługi struktury
sigset_t
int sigemptyset(sigset_t *set); Inicjuje zbiór sygnałów set,
wyłączając w nim wszystkie sygnały (czyli ustala wartość
reprezentującej je liczby na 0).
int sigfillset(sigset_t *set); Inicjuje zbiór sygnałów, włączając
wszystkie sygnały.
Przed użyciem struktury trzeba ją zawsze zainicjwać przez sigemptyset
lub sigfillset.
int sigaddset(sigset_t *set, int signo); Dodaje do zbioru sygnałów
pojedynczy sygnał.
int sigdelset(sigset_t *set, int signo); Usuwa ze zbioru sygnałów
pojedynczy sygnał.
int sigismember(sigset_t *set, int signo); Sprawdza czy podany
sygnał jest włączony w danym zbiorze.
Funkcje obsługi struktury
sigset_t
Kiedy jest już ustawiony zbiór sygnałów powyższymi
metodami, można użyć funkcji sigprocmask():
int sigprocmask(int how, const sigset_t *set, sigset_t
*oset);
Pierwszy parametr wskazuje sposób uaktualnienia maski
sygnałów:
SIG_BLOCK - nowa maska będzie połączeniem starej maski i maski
podanej w set (maska podana w set zawiera zbiór sygnałów, które
chcemy zablokować)
SIG_UNBLOCK - maska podana w set zawiera zbiór sygnałów, które
chcemy odblokować
SIG_SETMASK - stara maska jest nadpisywana maską zawartą w set
Do parametru oset zostanie wpisana zawartość starej maski.
Funkcje obsługi struktury
sigset_t
uwaga
Kiedy jądro próbuje przekazać do procesu sygnał, a ten
aktualnie jest zablokowany (nie dotyczy sygnałów SIGKILL i
SIGSTOP - tych nie można blokować), to sygnał jest
przechowywany do czasu, kiedy proces albo ustawi akcję
dla tego typu sygnału na ignorowanie, albo odblokuje dany
sygnał (w tym przypadku sygnał jest mu przekazywany w
momencie odblokowania).
Funkcje obsługi struktury
sigset_t
int sigpending(sigset_t *set);
Za pomocą tej funkcji można z wnętrza procesu odczytać
listę sygnałów, które oczekują na odblokowanie przez niego.
Do zmiennej set jest wpisywany zbiór oczekujących
sygnałów, które można sprawdzić funkcją sigismember().
Funkcja Sigaction
int sigaction(int signo, const struct sigaction *act, struct sigaction
*oact);
Pierwszy argument, signum, to numer sygnału, którego nadejście spowoduje
wywołanie procedury obsługi, określonej w drugim argumencie. Można podać
dowolny numer, za wyjątkiem SIGKILL i SIGSTOP, ponieważ obsługi tych
sygnałów nie da się przechwycić.
Numeracja sygnałów nie musi być przenośna, dlatego zamiast wartości
liczbowych zaleca się skorzystanie z symboli SIG* zdefiniowanych w
<signal.h>.
Drugi i trzeci argument wywołania, to wskaźniki do struktury sigaction,
określającej sposób obsługi danego sygnału. Drugi argument określa żądany
nowy sposób obsługi, za pomocą trzeciego funkcja zwraca informację o
dotychczasowym sposobie obsługi.
Wartość zwracana
Funkcja sigaction zwraca 0 z przypadku sukcesu i -1 w razie niepowodzenia. W tym
drugim przypadku wartość errno ustawiana jest na jedną z: EINVAL, EFAULT albo EINTR.
Funkcja Sigaction
W obu przypadkach wolno podać wskaźnik NULL zamiast argumentu, np. w celu
ustawienia nowej procedury obsługi sygnału SIGINT bez pobierania informacji o
dotychczasowej należy użyć:
#include <signal.h>
struct sigaction sa_new;
/* ... */
sigaction(SIGINT, &sa_new, 0);
a w celu pobrania informacji o dotychczasowej obsłudze sygnału (np. w celu jej
modyfikacji lub dla późniejszego odtworzenia) bez ustanawiania nowej:
#include <signal.h>
struct sigaction sa_old;
sigaction(SIGINT, 0, &sa_old);
Podanie obu wskaźników jako NULL jest również dozwolone (i sensowne), pozwala
bowiem sprawdzić, czy dany numer sygnału jest wspierany w danym systemie.
Funkcja Sigaction
Funkcja sigaction posługuje się strukturą sigaction do pobierania i
odsyłania informacji o handlerze obsługi sygnału. Struktura ta była w
przeszłości kilkakrotnie zmieniana, jednak podstawowe składowe
pozostały takie same.
struct sigaction
{
void (*sa_handler)();
sigset_t sa_mask;
int sa_flags;
};
void (*sa_handler)(int);
W składowej sa_handler należy umieścić adres funkcji, która zostanie wywołana
po nadejściu sygnału. Można również nadać jej jedną z dwóch wartości
predefiniowanych: SIG_DFT, co powoduje przywrócenie domyślnego sposobu
obsługi sygnału albo SIG_IGN, co spowoduje zignorowanie sygnału.
Funkcja Sigaction
void (*sa_sigaction)(int, siginfo_t *, void *);
Zamiast sa_handler można użyć składowej sa_sigaction, podając
równocześnie flagę SA_SIGINFO w składowej sa_flags. Wówczas po
nadejściu sygnału do handlera obsługi zostaną przekazane dodatkowe
informacje o przyczynach wystąpienia sygnału. Nie można używać
obu tych składowych równocześnie (w niektórych implementacjach
mogą być one zadeklarowane jako unia).
sigset_t sa_mask;
Składowa sa_mask zawiera informacje o sygnałach, których obsługa
zostanie na czas wykonania handlera wstrzymana (wskazane sygnały
będą blokowane). Do manipulacji tą składową służą osobne funkcje.
int sa_flags;
Składowa sa_flags zawiera dodatkowe flagi. Flagi te w większości są
specyficzne dla danego systemu operacyjnego, a standardowe to:
SA_NOCLDSTOP (zdefiniowana w POSIX) oraz wspomniana już
SA_SIGINFO (dodana w POSIX.1b).
Funkcja Sigaction
Składowa sa_mask
Składowa ta zawiera zestaw sygnałów, których obsługa będzie
zawieszona na czas wykonywania przez proces procedury obsługi
sygnału. Do manipulacji zestawami sygnałów służą funkcje:
int sigemptyset(sigset_t *set);
Wypełnia set tak, by wszystkie sygnały były z niego wyłączone.
int sigfillset(sigset_t *set);
Wypełnia set tak, by wszystkie sygnały były w nim zawarte.
int sigaddset(sigset_t *set, int signum);
Dodaje sygnał signum do zestawu.
int sigdelset(sigset_t *set, int signum);
Usuwa sygnał signum z zestawu.
Funkcja Sigaction
Włączenie blokowania wszystkich sygnałów (zazwyczaj tego właśnie
chcemy):
#include <signal.h>
struct sigaction sa;
sigfillset(&(sa.sa_mask));
/* ... */
sigaction(SIGINT, &sa_new, 0);
Włączenie blokowania wszystkich sygnałów oprócz SIGTSTP:
#include <signal.h>
struct sigaction sa;
sigfillset(&(sa.sa_mask));
/* pełny zestaw sygnałów */
sigdelset(&(sa.sa_mask), SIGTSTP);
/* wyklucz sygnał z zestawu */
/* ... */
sigaction(SIGINT, &sa_new, 0);
Funkcja Sigaction
Włączenie blokowania tylko SIGTSTP i SIGALRM:
#include <signal.h>
struct sigaction sa;
sigemptyset(&(sa.sa_mask));
/* pusty zestaw sygnałów */
sigaddset(&(sa.sa_mask), SIGTSTP);
/* dodaj SIGTSTP */
sigaddset(&(sa.sa_mask), SIGALRM);
/* dodaj SIGALRM */
/* ... */
sigaction(SIGINT, &sa_new, 0);Włączenie blokowania wszystkich sygnałów
oprócz SIGTSTP:
Należy podkreslić , że sygnał, który przechwytujemy, jest „z urzędu” blokowany na
czas obsługi.
Funkcja Sigaction
Składowa sa_flags
W pełni standardowa i przenośna jest tylko flaga SA_NOCLDSTOP.
Działanie kilku wybranych flag, które wydają się przydatne:
SA_ONESHOT lub SA_RESETHAND
Przywraca domyślną obsługę sygnałów po wywołaniu procedury obsługi. Historycznie
rzecz biorąc, było to typowe zachowanie systemów UNIX po zainstalowaniu handlera
za pomocą funkcji signal i źródło nieustannych kłopotów.
SA_RESTART
Powoduje zmianę zachowania przerwanych nadejściem sygnału niektórych wywołań
funkcji systemowych: zamiast zwracać błąd i ustawiać errno na wartość EINTR,
funkcje te będą wywołane ponownie. Praktyczne (w sposób typowy dla BSD, skąd
zaczerpnięto koncept) rozwiązanie dla takich operacji jak np. read.
SA_NOMASK lub SA_NODEFER
Nie blokuj sygnałów podczas działania handlera (jak przy signal).
SA_SIGINFO
Użyj adresu podanego w składowej sa_sigaction, a nie sa_handler do zainstalowania
handlera.
Funkcja Sigaction
Składowa sa_flags powinna być sumą bitową ustawionych flag. Jeśli
nie ustawiamy żadnej, sa_flags trzeba koniecznie wyzerować:
#include <signal.h>
struct sigaction sa;
sigfillset(&(sa.sa_mask));
sa.sa_flags = 0;
/* ... */
sigaction(SIGINT, &sa_new, 0);
Przykłady cz.1
obsługa sygnału SIGINT
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void int_handler(int signum)
{
fprintf(stderr, "-- Signal %i catched\n", signum);
}
int main(void)
{
int i;
struct sigaction sa;
sa.sa_handler = int_handler;
sigfillset(&(sa.sa_mask));
sa.sa_flags = 0;
sigaction(SIGINT, &sa, 0);
for(i = 0; i < 20; ++i) {
printf("Running (%i)\n", i);
sleep(1);
}
return 0;
}
Przykłady cz.1
sa.sa_handler = int_handler;
ustala nazwę (w istocie adres) funkcji wywoływanej, gdy przyjdzie
sygnał. Wywołanie
sigfillset(&(sa.sa_mask));
ustawia blokowanie wszystkich sygnałów na czas wykonywania
handlera. Następnie zerowane są flagi:
sa.sa_flags = 0;
i handler zostaje zainstalowany:
sigaction(SIGINT, &sa, 0);
Program powyższy po uruchomieniu co sekundę wyświetla komunikat
Running[…]. Po wysłaniu SIGINT (zazwyczaj jest to kombinacja
klawiszy Ctrl+C) sterowanie trafia do funkcji obsługi sygnału, która
wypisuje na stderr komunikat -- Signal 2 catched
W tym przykładzie raz zainstalowany handler działa aż do zakończenia
procesu, co łatwo sprawdzić w praktyce, naciskając kilkakrotnie
Ctrl+C.
Przykłady cz.2
flaga SA_ONESHOT
W poprzednim przykładzie wprowadzono jedną tylko, drobną zmianę.
Instrukcję:
sa.sa_flags = 0;
zastępiono przez:
sa.sa_flags = SA_ONESHOT;
Tak zainstalowany handler obsługi sygnału zadziała jeden raz, po
czym zostanie przywrócona obsługa domyślna. W taki sposób działały
handlery sygnałów instalowane za pomocą funkcji signal
Przykłady cz.3
przywracanie obsługi
Do przykładu cz. 2 wprowadzamy kolejną zmianę: w funkcji
int_handler będziemy przywracali obsługę sygnału za pomocą
handlera.
Struktura sigaction zostanie zmienną globalną, żeby handler mógł
skorzystać z wartości ustawionych w funkcji main:
Przykłady cz.3
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
struct sigaction sa;
void int_handler(int signum)
{
sigaction(SIGINT, &sa, 0);
fprintf(stderr, "-- Signal %i catched\n", signum);
}
int main(void)
{
int i;
sa.sa_handler = int_handler;
sigfillset(&(sa.sa_mask));
sa.sa_flags = SA_ONESHOT;
sigaction(SIGINT, &sa, 0);
for(i = 0; i < 20; ++i) {
printf("Running (%i)\n", i);
sleep(1);
}
return 0;
}
Przykłady cz.3
Kod ten jest podobny do tego, który należało dawniej zastosować, by
uzyskać wielokrotne użycie handlera zainstalowanego za pomocą
funkcji signal. Jest to jednak rozwiązanie niepewne: pomiędzy
wywołaniem handlera i przywróceniem obsługi sygnału istnieje krótki
odcinek czasu, kiedy sygnał obsługiwany jest w sposób domyślny.
Przykłady cz.4
funkcja raise
Funkcja raise, to po prostu okrojona wersja funkcji kill, wysyłająca
sygnał do tego samego procesu, który ją uruchomił. Po co wysyłać
sygnał do samego siebie?
Załóżmy, że program otrzymujący sygnał przerwania SIGINT musi
najpierw posprzątać, na przykład usunąć utworzone pliki
tymczasowe. W takim przypadku najlepiej przechwycić sygnał, zrobić
porządki, a następnie (przy przywróconej domyślnej obsłudze
sygnału) ponownie wysłać go do siebie.
Przykłady cz.4
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void int_handler(int signum)
{
fprintf(stderr, "Final cleanup.\n");
raise(SIGINT);
fprintf(stderr, "Preparing to die...\n");
}
int main(void)
{
int i;
struct sigaction sa;
sa.sa_handler = int_handler;
sigfillset(&(sa.sa_mask));
sa.sa_flags = SA_ONESHOT;
sigaction(SIGINT, &sa, 0);
for(i = 0; i < 20; ++i) {
printf("Running (%i)\n", i);
sleep(1);
}
return 0;
}
Funkcja sigsuspend
int sigsuspend(const sigset_t *sigmask);
Funkcja ta działa następująco: podmienia tymczasowo maskę
sygnałów procesu na tą wskazaną w sigmask, a następnie
wstrzymuje wykonanie programu do czasu otrzymania
jakiegoś sygnału. Przydaje się to np. w sytuacji kiedy
chcielibyśmy wykonać funkcję pause() aby zaczekać na jakiś
sygnał, a jest on w danej chwili zablokowany.
Uwagi dotyczące własnej obsługi
sygnałów
Dziedziczenie obsługi sygnałów
Proces potomny, utworzony za pomocą exec dziedziczy obsługę sygnałów,
wszelako z pewnymi zmianami:
Obsługa sygnałów SIG_DFL i SIG_IGN dziedziczona jest bez zmian,
Obsługa sygnałów, dla których zainstalowane zostały handlery zmieniana jest
na SIG_DFL. Jest to konieczne, ponieważ po wykonaniu exec handlerów już
nie ma w pamięci.
Ograniczenia procedur obsługi sygnałów
W procedurze obsługującej sygnały nie wolno używać funkcji bibliotecznych,
które zmieniają wartości zmiennych globalnych lub statycznych. Ogólnie,
pamięci innej, niż na stosie. Zatem funkcji oznaczonych w angielskojęzycznej
dokumentacji jako non-reentrant należy używać z rozwagą.
Ze zmienną errno akurat łatwo sobie poradzić, zachowując jej wartość przed
wywołaniem funkcji bibliotecznej, a następnie ją odtwarzając. Ogólnie, jeśli
jakaś funkcja zmienia zmienną globalną, do której mamy dostęp, można
zapobiec kłopotom, tworząc kopię tej zmiennej w celu odtworzenia wartości
po wywołaniu.
Uwagi dotyczące własnej obsługi
sygnałów
Samo tylko odczytywanie wartości zmiennych globalnych programu
jest bezpieczne, jednak jeśli taka zmienna nie jest atomic, można
trafić z odczytem akurat na moment jej modyfikacji i otrzymać
niepoprawną wartość.
Natomiast użycie takich funkcji jak malloc, które utrzymują gdzieś
własne dane, nie jest na ogół bezpieczne. Z malloc mogą z kolei
korzystać niejawnie rozmaite funkcje biblioteczne (jak choćby użyta
w przykładach funkcja printf).
Podobnie, korzystanie w handlerze sygnałów z tych samych
deskryptorów plików, których używa główny program nie jest
wskazane. (W przykładach częściowo zapobiegłem kłopotom,
używając stderr w obsłudze sygnałów i stdout w programie głównym,
jednak skierowania strumieni łatwo mogą zostać zmienione z
zewnątrz.)
I tak dalej. Sprawdź w dokumentacji, które funkcje biblioteczne są
reentrant. Sprawdź też napisane przez siebie funkcje pod tym kątem.
Z drugiej strony, jeśli program główny nie używa w ogóle jakiejś
funkcji (albo używa jej wyłącznie w sytucjach, gdy sygnały sa
ignorowane), można jej użyć w procedurze obsługi sygnałów
Uwagi dotyczące własnej obsługi
sygnałów
Ogólne zasady tworzenia handlerów
Nie są to niepodważalne prawa, a bardziej zalecenia, którymi należy się
kierować:
O ile to możliwe, procedura obsługi sygnału powinna tylko ustawiać flagę
informującą o nadejściu sygnału i powracać, a program główny powinien
okresowo sprawdzać stan tej flagi. Zmienna pełniąca funkcję flagi
powinna mieć atrybut volatile.
Jeśli trzeba wywołać jakąś funkcję, powinna to być funkcja reentrant. W
przeciwnym przypadku trzeba zapewnić, że wykonanie tej funkcji w
programie głównym nie może zostać przerwane nadejściem sygnału.
Wykonanie procedury obsługi sygnału powinno trwać krótko, ponieważ
zazwyczaj na ten czas obsługa nadchodzących sygnałów jest
zawieszona.