Université Joseph Fourier
DEUG STPI - 2ème année - IUP MIAG - 1ère année
Introduction aux systèmes et réseaux
 
 
 
Travaux pratiques de Systèmes d'exploitation
Présentation générale
 
 

Objectifs

L'objectif des Travaux Pratiques de systèmes d'exploitation est de donner un support concret aux principales notions présentées dans le cours (processus, fichiers, client-serveur, réseaux, applications réparties, etc.), à travers l'usage d'outils logiciels représentatifs de l'état de l'art. L'objectif n'est pas de faire de vous des experts de ces outils, qu'il s'agisse du langage C, du système Unix, ou du langage Tcl-TK. Il est plus important de bien comprendre quels sont les concepts que vous appliquerez, de vous initier aux méthodes de travail, et de développer votre esprit d'initiative, notamment pour la recherche de la documentation (accessoirement, vous devrez vous familiariser avec l'anglais technique).

Organisation générale

Les TP sont organisés en deux parties d'importance inégale.

1. Initiation aux fonctions d'un système d'exploitation

Les 4 premières séances constituent une initiation aux principaux éléments et mécanismes d'un système d'exploitation (processsus, parallélisme, synchronisation, fichiers, langage de commande, appels système), par des expériences sur le système Unix.

2. Initiation à la construction d'applications réparties

Les séances suivantes sont consacrées à une initiation à l'informatique répartie. Elles commencent par l'apprentissage d'un langage (Tcl et son extension DP - Distributed Processing) permettant de construire simplement des applications réparties à base d'objets communicants. L'outil TK, associé à Tcl, permet de doter ces applications d'une interface graphique interactive.

Ces connaissances ont appliquées au cours d'un projet utilisant Tcl-DP et TK : la réalisation d'un tableur réparti (tableur fonctionnant sur un réseau de machines).

Fonctionnement

Une place importante est réservé à l'expérimentation libre. À cet effet, vous utiliserez d'une part la documentation disponible en ligne, d'autre part un ensemble de programmes (en C et en Tcl) qui seront mis à votre disposition et que vous pourrez lire, expérimenter, et modifier. Apprenez à lire des programmes avant d'en écrire vous-mêmes. Vous pourrez vous choisir un parcours "à la carte" selon votre expérience préalable.


DEUG STPI - 2ème année
IUP MIAG - 1ère année
Systèmes d'exploitation
 
 
TP 1 à 4. Introduction au système Unix

À l'issue des TP 1 à 4, vous devez avoir acquis et consolidé les notions suivantes (dont certaines vous sont déjà connues) :

1. Gestion des processus

On rappelle que si le fichier prog.c contient un programme écrit en C, la commande

gcc -o prog prog.c
crée un fichier exécutable appelé prog.

Il y a deux manières de créer des processus sous Unix.

1) Au niveau du shell

Chaque commande crée un processus qui exécute cette commande, et disparaît à la fin de cette exécution ; le shell lui-même est exécuté par un processus.

On peut lancer un processus en tâche de fond au moyen de l'opérateur & : si prog1 et prog2 sont des fichiers contenant des programmes exécutables, alors la commande :
 

prog1 & prog2 & crée deux processus qui exécutent respectivement prog1 et prog2. La commande
  prog1 & prog1 & prog1 & crée trois processus qui exécutent (en pseudo-parallèle) le même programme, celui contenu dans prog1.

2) Au niveau des appels système

La fonction (appel système) fork(), exécutée dans un processus p, crée un processus p1, fils de p, dont la mémoire virtuelle (programme et données) est une copie conforme de celle de p. Les deux processus ne se distinguent que par la valeur (entière) retournée par fork() : 0 pour le fils, et le numéro du fils pour le père. Le fils peut "recouvrir" sa mémoire à partir d'un nouveau fichier exécutable, au moyen de la fonction exec(), dont il existe plusieurs variantes, voir man. Un processus peut se synchroniser avec ses fils au moyen de la fonction wait(). Un processus s'autodétruit par la commande (ou l'appel système) exit.

 Lire dans man (1) la description de la commande ps. L'utiliser et identifier les différents champs des processus que vous découvrirez. Voir en particulier l'arbre généalogique des processus, grâce à l'identité du père (ppid, utiliser ps -l).

Créer un processus qui boucle indéfiniment et le tuer au moyen de la commande kill du shell. Construire un programme qui réalise le même effet que cette commande, en utilisant l'appel système kill (voir description de kill dans man (1 et 2).

Par défaut, l'entrée standard d'un processus est connectée au clavier et sa sortie standard à l'écran. Un processus peut aussi aller chercher ses données d'entrée dans un fichier f1 et sortir ses résultats dans un fichier f2 :

prog <f1 >f2
On peut aussi faire communiquer les processus entre eux. Une première façon consiste à utiliser les fichiers. Une deuxième forme de communication entre processus utilise les tubes (pipes). Un tube permet de connecter la sortie standard d'un processus à l'entrée standard d'un autre. Les deux processus se synchronient au moyen des informations transmises (le processus récepteur attend les données du processus émetteur). La commande
prog1 Ù prog2
crée deux processus p1 et p2 qui exécutent respectivement prog1 et prog2, et connecte la sortie standard de p1 à l'entrée standard de p2.

Essayer les constructions ci-dessus, avec des programmes adéquats. Noter qu'on peut utiliser aussi bien des programmes de l'utilisateur, construits en C, que des commandes du shell. Noter aussi que les commandes du shell sont des programmes exécutables, contenus dans les fichiers

/usr/bin/<nom de la commande> (par exemple /usr/bin/ls)
Lire dans man (2) la description des appels systèmes fork(), wait() et exec(), et les utiliser pour créer et synchroniser des processus.

Exemples de programmes : voir dans le répertoire

/h/thales/u8/enseigt/krakowis/tp-unix/processus

2. Utilisation des fichiers

a) Manipulation élémentaires des fichiers dans le programme des processus

Examiner les fonctions (appel systèmes) open, close, read, write dans man (2).

Utiliser ces fonctions pour manipuler des fichiers dans un processus. Le principe de base est d'associer un descripteur à un fichier au moment de l'ouverture :

fd = open(" nom du fichier ", <mode d'acès>)
fd (descripteur) est un entier, qui est utilisé ultérieurement pour les accès aux fichiers (read, write), jusqu'à la fermeture du fichier, réalisée par close (fd).

b) Verrouillage des fichiers

Le verrouillage des fichiers permet d'assurer que les accès se font en respectant des règles qui garantissent que les fichiers restent cohérents :

  • plusieurs processus peuvent accéder concurremment en lecture à un fichier
  • un seul processus peut effectuer des accès en écriture.
    •  On a donc deux modes de verrouillage, exclusif (écriture) et partagé (lecture). Noter aussi que le verrouillage peut être impératif (il interdit les accès incompatibles avec le mode de verrouillage), ou indicatif (il n'interdit pas les accès incompatibles, mais seulement les verrouillages incompatibles) Dans ce dernier mode, la validité des accès repose uniquement sur la bonne construction des programmes : tout accès en lecture doit être fait en verrouillage partagé, tout accès en écriture en verrouillage exclusif).

    Les fonctions (appels systèmes) qui permettent de verrouiller un fichier sont lockf et fcntl. Voir man (2). lockf est plus simple, mais fcntl est très complet (et permet de réaliser beaucoup d'autres fonctions que le verrouillage).

    Expérimenter le verrouillage, y compris dans des situations conduisant à l'interblocage (qui est détecté par le système).

    Exemples de programmes : voir dans le répertoire :

    /h/thales/u8/enseigt/krakowis/tp-unix/fichiers