Sommaire

    Pour chaque chapitre des TPs de système, nous avons dressé la liste (sans doute non exhaustive) des thèmes qui sont abordés et qui doivent être assimilés. En cours et en fin de TP, vous devez vous assurer que vous avez compris et assimilé chaque notion. Si tel n'est pas le cas, c'est que vous êtes passé à coté d'un ou de plusieurs exercices. N'hésitez pas à faire appel à nous si vous ne comprenez pas une notion. Chaque TP sera préalablement présenté en cours magistral, où le fonctionnement général des fonctions système utilisées sera analysé.

    Les exercices proposés sont en général très riches et ne peuvent pas être effectués "à la sauvette". Ils sont graduels, de difficulté croissante, et fortement liés avec de nombreuses pages de cours, générales ou spécifiques. Vous ne devriez pas passer à l'exercice suivant tant que vous ne maîtrisez pas le précédent.

    L'enrichissement de vos connaissances que nous cherchons à réaliser porte sur trois niveaux (non hiérarchiques) :

• Niveau 1 : les fonctions système Unix, leur fonctionnement
• Niveau 2 : commandes Unix, algorithmique, parallélisme, notions de système (en général)
• Niveau 3 : langages C/C++

Fichiers

• Droits - propriétés et modes d'ouverture des fichiers
• Fichiers caractères
• Création/destruction de fichiers - Utilisation de fichiers existants - Fichiers temporaires
• Statistiques sur les fichiers
• File descriptor : espace mémoire système, espace mémoire utilisateur, zone u., variable "système" errno, constantes "système" : S_BLKSIZE, ...
• Duplication de file descriptor - Redirection de fichier
• Tables des descripteurs, des fichiers ouverts, des i-noeuds
• Accès séquentiel, accès direct (ou aléatoire)
• Ecriture immédiate
• Partage d'un fichier en lecture, écriture, lecture/écriture par plusieurs processus
• Pointeur de fichier, accès simultané

• Architecture d'une application multi-fichiers
• Appel de fonctions système - Evénement synchrone : interruption logicielle SVC (SuperVisor Call : Appel au superviseur) - Commutation de contexte -
• Mode kernel, mode user
• Technique de wrapper de fonction
• Notion de processus concurrents - Chronogramme - Temporisation
• Exécution simultanée de commandes - Lancement de commande en background (arrière -plan)
• Différence entre écriture logique et écriture physique : utilité des E/S tamponnées
• Tampons système, tampons utilisateurs, fichiers "blocs"
• Commande Unix make, strace
• Utilisation systématique de l'aide en ligne (commande man).

• (Extension d') espaces de noms
• Arguments d'une commande (argc, argv)
• Classe "éditable" - Dérivation, héritage
• Classes abstraites, virtuelles, fonctions virtuelles, polymorphisme
• Hiérarchie des exceptions C++ : exceptions standard et "utilisateur"
• Fonctions exit(), tmpnam(), atoi(), sleep()
• Fonction system() : exécution d'une commande à partir d'un processus utilisateur
• Macros de compilation conditionnelle
• Passage de paramètre par pointeur
• Flux d'erreur cerr
• Fonctions inline
• Classe standard string

Signaux

• Table de déroutement des signaux (zone u.)
• Liste des signaux, portabilité
• Fonctions de déroutement : sigaction()
• Fonctions d'envoi de signal : kill()
• Fonctions d'attente de signal : pause() et sleep()
• Fonctions de manipulation des masques de signaux : sigemptyset(), ...
• Fonctions de (dé)blocage des signaux : sigprocmask()

• Principe de communication par signaux
• Notion de traitant de signal, de déroutement, d'interruption (logicielle ou matérielle)
• Signal pendant, masqué (bloqué)
• Attente active, semi-active
• Atomicité d'un traitement
• Section "sensible"
• Stratégie de traitement des signaux : ignoré, par défaut, dérouté, bloqué
• Traitement immédiat/différé (synchrone/asynchrone)
• Sauvegarde/restauration d'un contexte de traitement de signal : total (action) ou partiel (handler)
• Provenance des signaux : clavier, processus, système
• Etats d'un processus : actif (Running), suspendu (sTopped)
• Processus en premier plan (foreground) ou tâche de fond (background)
• Commandes builtin du c-shell : fg, bg, jobs, kill, limit
• Commandes Unix : ps, kill
• Fichiers core
• Variable système _sys_siglist[]

• Pointeur de fonction, passage de fonction en paramètre
• qualifieur volatile
• macro transtypée
• manipulateurs : setw, flush
• instruction continue

 Timers

• Notion de délai sous Unix
• Fonctionnement d'un timer
• Signaux émis par un timer
• Armement d'un timer
• Fonction select()
• Masque de file descriptors

• Mode noyau (kernel), mode utilisateur (user)
• Notion de granule de temps machine
• "Macro" dans un fichier makefile
• Mise en évidence du temps pris par les commutations de contexte
• Chronomètre utilisant un timer
• Multiplexage d'E/S
• Attente limitée par un "chien de garde" (watch-dog : timer)

• Révisions : surcharge des opérateurs <<, <, ==, >
• Classes abstraites, dérivation (suite)
• Masquage de l'information par dérivation
• "Habillage" de C en C++
• Non héritage d'une fonction amie : l'opérateur <<

Processus

• Fonctions fork(), kill(), famille get...id(), famille exec...(), famille wait...(), lseek()
• Duplication de l'espace mémoire virtuel (buffers, données). Copie "en écriture"
• Héritage de la table des fichiers, des traitants des signaux
• Partage des pointeurs de fichiers
• Identificateur de processus (processus père, processus fils, pid)

• Création d'un processus
• Notion d'état (status) d'un processus - Contexte d'un processus - Table des processus - Bloc de contrôle de processus
• "Petits lapins"
• Ordonnancement (scheduler)
• Pseudo-parallélisme de processus
• Synchronisation père --> fils (wait()) - Synchronisation shell --> commande - Attente "non bloquante" - Attente sélective
• Communication fils --> père par signal (SIGCHLD) - Communication asynchrone par signaux "users" entre processus - Attente d'un événement (signal)
• Contexte d'un processus
• Processus "démon" - Processus "zombie" - Destructeur de "zombies"
• Exécution de code "étranger" : couple fork() - exec()
• Approfondissement et émulation de la fonction de niveau 3 system()
• Commandes ps -Al, killall

• Fonctions C de manipulation de chaînes de caractères : strcat(), strtok(), etc.
• Interférences C/C++ : buffers, constructeurs/destructeurs

Sommaire

© D. Mathieu     mathieu@romarin.univ-aix.fr
I.U.T.d'Aix en Provence - Département Informatique