TP 10 (prog. système) Signaux - IUT d'Arles

Iut Arles / A1SE
Systèmes d’exploitation
TP 10 (prog. système) Signaux
Il existe sous Linux 64 signaux différents qui permettent de faire passer un message et
éventuellement (cf 2ème exemple) des informations. Les 32 premiers signaux sont réservés au
systèmes (SIGCHLD, SIGHINT, SIGSEGV, SIGPWR, ...) et permettent la communication entre
processus. La liste des signaux est disponible par la commande « kill -l » :
1) SIGHUP
2) SIGINT
3) SIGQUIT
4) SIGILL
5) SIGTRAP
6) SIGABRT
7) SIGBUS
8) SIGFPE
9) SIGKILL
10) SIGUSR1
11) SIGSEGV
12) SIGUSR2
13) SIGPIPE
14) SIGALRM
15) SIGTERM
16) SIGSTKFLT
17) SIGCHLD
18) SIGCONT
19) SIGSTOP
20) SIGTSTP
21) SIGTTIN
22) SIGTTOU
23) SIGURG
24) SIGXCPU
25) SIGXFSZ
26) SIGVTALRM
27) SIGPROF
28) SIGWINCH
29) SIGIO
30) SIGPWR
31) SIGSYS
34) SIGRTMIN
35) SIGRTMIN+1
36) SIGRTMIN+2
37) SIGRTMIN+3
38) SIGRTMIN+4
39) SIGRTMIN+5
40) SIGRTMIN+6
41) SIGRTMIN+7
42) SIGRTMIN+8
43) SIGRTMIN+9
44) SIGRTMIN+10
45) SIGRTMIN+11
46) SIGRTMIN+12
47) SIGRTMIN+13
48) SIGRTMIN+14
49) SIGRTMIN+15
50) SIGRTMAX-14
51) SIGRTMAX-13
52) SIGRTMAX-12
53) SIGRTMAX-11
54) SIGRTMAX-10
55) SIGRTMAX-9
56) SIGRTMAX-8
57) SIGRTMAX-7
58) SIGRTMAX-6
59) SIGRTMAX-5
60) SIGRTMAX-4
61) SIGRTMAX-3
62) SIGRTMAX-2
63) SIGRTMAX-1
64) SIGRTMAX
Par exemple pour tuer un processus, la commande « kill – 9 3271 » envoie en fait le signal
« SIGKILL » au processus numéro 3271. Le signal « SIGINT » est une interruption par
l'utilisateur (par exemple lors de l'appui de « CTRL-C » dans une commande). Pour avoir la
liste descriptive de chaque signal, consultez le manuel de la fonction « signal » (section 7 du
man : « man 7 signal »).
1. 1er exercice : test simple sur CTRL-C
Le traitement des signaux se fait en déclarant au début du « main() » les signaux
traités par la primitive « signal(...) ». Le code de cet exemple est dans
« test_signal_simple.cpp » des sources du TP. Le principe est d'attendre un signal (la
fonction « pause() » endort le processus jusqu'à la réception d'un signal) et si on reçoit
« SIGINT » (signal d'interruption), on sorte du programme par un « exit() ».
Évidemment cette façon de faire n'est pas très belle puisqu'on n'aura pas le temps de
fermer les fichiers, rendre les ressources du programme (fuites de mémoires et tutti
quanti) :
//fonction de traitement des signaux
void traitement_signaux(const int num_signal) {
switch (num_signal) {
//Qu'est-ce qu'on fait si on reçoit un signal d'appui sur CTRL-C ?
case SIGINT : std::cerr

Iut Arles / A1SE
Systèmes d’exploitation
}
note : la fonction « atexit » dans le fichier source peut vous aider pour désaloouer les
ressources avant de sortir du programme.
2. Exercice 2 : mise en place d'une alarme
Nous allons maintenant étudier la gestion d'une alarme par récupération du signal
correspondant. On peut positionner une alarme par la fonction « alarm(secondes) ». Le code
source d'exemple est « test_signal_alarme.cpp ». Il complète le précèdent en ajoutant une
attente d'un événement d'alarme sur un timer réglé à 5 secondes. Si l'utilisateur ne s'est pas
manifesté, le programme se termine.
3. Exercice 3 : signaux temps réels
Les 32 autres signaux Linux sont disponible pour l'utilisateur. La valeur minimale de leur rang
est donnée par SIGRTMIN (valeur prédéfinie du système, normalement 34). Un processus gère
une file de signaux reçus (max. 1024) dans laquelle il prend au fur et à mesure. Les
occurrences sont automatiquement éliminées. On peut attacher au signal quelques
informations, comme le montre l'exemple ci-dessus (entier ou pointeur sur un tableau
d'entiers).
Les prérequis sont : d'avoir 2 processus au moins, de déclarer (pour le receveur) une structure
qui contient les signaux qu'il bloque (sigemptyset, sigaddset), une structure pour récupérer les
informations (struct siginfo infos_recues), un masquage des signaux courants pour filtrer ceux
qui l'intéresse (sigprocmask) et d'attendre (sigwaitinfo, bloquant). Pour l'émetteur, il suffit
d'empaqueter les informations dans une structure et de les placer dans la file des messages du
receveur (sigqueue).
Exemple de code pour envoyer des signaux temps réels d'un processus à un autre (cf .
« test_signal_tempsreel_perefils.cpp ») :
● le père utilise « sigqueue() » pour envoyer un message :
int execution_pere(const unsigned int _pid_fils) {
//une structure pour contenir des informations à envoyer par le message
union sigval infos_envoyees;
//on stocke dans la structure infos_envoyees la valeur 10
infos_envoyees.sival_int = 10;
std::cout

Iut Arles / A1SE
Systèmes d’exploitation
4. Exercice 4 : et pour finir
Utiliser les signaux temps-réels pour faire passer un pointeur sur un tableau d'entiers
d'une processus à un autre. Pour vous aider, allez faire un tour du côté de la structure
« union sigval », il y a un champ « .sival_ptr ». Il faut déjà déclarer et remplir ce
tableau dans le « main() » car vous n'avez pas encore vu la mémoire partagée.
Attention cette dernière question prend un peu de temps, faites-la plutôt chez vous en
entraînement.
R Raffin, W. Famy & A. François p. 3/3