Test n° 1 de système

(7 décembre 2001 – durée : 2h)

© D. Mathieu mathieu@romarin.univ-aix.fr et M. Laporte
I.U.T.d'Aix en Provence - Département Informatique
Créé le 01/12/2001 - Dernière mise à jour : 01/12/2001

Tout document autorisé

Sommaire

Sauvegarde/Restauration des signaux

Fichier SaveSig.cxx

I - Sauvegarde/Restauration des signaux

La fonction SaveSig(), écrite lors du TP consacré aux signaux sous Unix, déroute l'ensemble des signaux déroutables vers un traitant unique, en sauvegardant l'ancien traitant. La fonction Restaure() déroute l'ensemble des signaux déroutables vers l'ancien traitant, sous réserve qu'il ait été préalablement sauvegardé par SaveSig().

L'écriture en est assez lourde, parce que la fonction système sigaction() est interruptible par les signaux ^[1]. Une solution plus élégante serait de suspendre (bloquer) tous les signaux possibles le temps de l'opération.

    De plus, il est souhaitable de disposer de fonctions équivalentes pour sauvegarder/restaurer un seul signal, dont les profils seraient :

void SaveSig     (const sighandler_t Handler,
                  int NumSig = 0) ^{[2] [3]}throw CExcFct);
void RestaureSig (int NumSig = 0)     throw CExcFct);

Lorsque le paramètre NumSig est nul, ce sont tous les signaux déroutables qui sont déroutés. Sinon, c'est seulement celui dont la valeur est passée en paramètre qui est dérouté (s'il est déroutable). Idem pour la fonction Restaure().

    Conformément aux spécifications indiquées dans la version faite en TP, on n'envisagera pas d'imbriquer des blocs de sauvegarde générale. Ainsi, l'écriture suivante ne sera pas acceptée :

SaveSig (Handler1);           // -------
...                           //        |
SaveSig (Handler2);           // ---    |
...                           //    |   |
RestaureSig ();               // ---    |
...                           //        |
RestaureSig ();               // -------

    De même, on n'envisagera pas d'imbriquer des sauvegardes individuelles du même signal. Ainsi, l'écriture suivante sera interdite :

SaveSig (Handler1, SIGUSR1); // -------
...                           //        |
SaveSig (Handler2, SIGUSR1); // ---    |
...                           //    |   |
RestaureSig (SIGUSR1);        // ---    |
...                           //        |
RestaureSig (SIGUSR1);        // -------

    Cependant, on devra pouvoir imbriquer chacune des structures :

SaveSig (Handler1);           // -------
...                           //        |
SaveSig (Handler2, SIGUSR1); // ---    |
...                           //    |   |
RestaureSig (SIGUSR1);        // ---    |
...                           //        |
RestaureSig ();               // -------

    ou

SaveSig (Handler2, SIGUSR1); // -------
...                           //        |
SaveSig (Handler1);           // ---    |
...                           //    |   |
RestaureSig ();               // ---    |
...                           //        |
RestaureSig (SIGUSR1);        // -------

    Il sera de la responsabilité de ces fonctions de s'en assurer. En revanche, on laissera à l'utilisateur le soin de vérifier que les deux structures ne sont pas entrelacées :

SaveSig (Handler2, SIGUSR1); // -------
...                           //        |
SaveSig (Handler1);           // ---    |
...                           //    |   |
RestaureSig (SIGUSR1);        // ---+---
...                           //    |
RestaureSig ();               // ---

Fichier `SaveSig.cxx`

L'objectif de cet exercice est de réécrire complètement les deux fonctions pour prendre en compte la totalité des remarques ci-dessus. Afin de vous aider, voici quelques indications à suivre :

dans l'espace de noms anonyme, ajouter les variables nécessaires pour stocker individuellement les traitants de signaux, et pour savoir si un signal particulier a ou n'a pas déjà été sauvegardé.

dans l'espace de noms anonyme, écrire la fonction suivante :

void BlockAllSig (const sigset_t & Masque) ...
{

} // BlockAllSig()

qui boque tous les signaux bloquables,

dans l'espace de noms anonyme, écrire la fonction suivante :

void SauverUnSignal (const sighandler_t NewHandler, int NumSig,
struct std::sigaction & OldAction) ...
{

} // SauverUnSignal()

On suppose qu'elle ne sera appelée que :

si le signal NumSig est valide,
s'il est déroutable (on rappelle que deux signaux particuliers ne doivent jamais être déroutés),
s'il n'est pas déjà sauvegardé,
si tous les signaux sont bloqués.

Le paramètre OldAction contient en sortie l'ancien traitant du signal.

Compléter le profil (exception) et le corps de la fonction : voir un extrait de man sigaction ^[4] comprenant la liste exhaustive des erreurs. On rappelle que, dans les spécifications de SaveSig(), on s'interdit de dérouter des signaux qui seraient déjà ignorés.

dans l'espace de noms anonyme, écrire la fonction de profil suivant :

void RestaurerUnSignal (int NumSig,
const struct std::sigaction & OldAction) ...
{

} // RestaurerUnSignal()

On suppose qu'elle ne sera appelée que :

si le signal NumSig est valide,
s'il est déroutable,
s'il a été sauvegardé
si tous les signaux sont bloqués

Le paramètre OldAction contient l'ancien traitant du signal, à restaurer.

Réécrire complètement la fonction SaveSig(). Elle est composée de plusieurs parties :

préparation d'un masque pour bloquer tous les signaux
si NumSig est non nul :

valider NumSig (voir plus haut les hypothèses d'utilisation de SauverUnSignal()),
bloquer tous les signaux (revoir ^[1]...),
sauvegarder le signal NumSig,
débloquer les signaux

si NumSig est nul :

traiter successivement tous les signaux qui doivent l'être, en s'inspirant du traitement individuel ci-dessus. Minimiser les bloquages/débloquages des signaux.

Réécrire complètement la fonction RestaureSig(). Elle a la même structure que la fonction SaveSig().

[1] La fonction système sigprocmask() est elle aussi interruptible par un signal..

[2] L'utilisation d'un paramètre supplémentaire ayant une valeur par défaut n'oblige pas les utilisateurs à modifier leur code déjà écrit.

[3] la valeur nulle ne correspond à aucun signal.