Systèmes d’exploitation
CSI3531 Labo 1
L’observation du comportement de processus - exercice
Objectifs
1. Étudier le comportement de l’exécution de processus en examinant ses structures via le répertoire “/proc” de Linux.
2. Gagner de l’expérience avec l’interface de ligne de command (le shell) en Linux ainsi que des programmes/commandes de système.
3. Essayer quelques programmes en C avec les appels fork() et exec().
Lignes directrices
Contexte : Le SE Linux offre un mécanisme pratique pour explorer les propriétés du système ainsi que celles des processus exécutants. Plusieurs structures du SE sont visibles comme fichiers dans le pseudo système de fichier trouvé dans le répertoire /proc.
Étape 1 : Démarrez Virtual PC et roulez la machine virtuelle Linux “sitedev”. Pour démarrer la machine virtuelle Linux, sélectionner SiteDev et cliquez sur Start. Une autre fenêtre apparaîtra et vous verrez Linux démarré comme s’il était le SE principal sur un PC. Lorsque vous êtes invité à ouvrir une session (login prompt), utilisez le nom d’utilisateur « test1 » et mot de passe « site » pour ouvrir la session. Vous êtes maintenant prêts à compléter le labo. Notez que vous utilisez une interface CLI pour interagir avec le SE.
La machine virtuelle “sitedev” est un environnement Linux dans lequel vous pouvez compléter votre laboratoire. Vous pouvez télécharger le Virtual PC dans votre système à partir du lien http://www.microsoft.com/windows/virtualpc/default.mspx. La machine virtuelle sitedev est accessible via le lien suivant
http://www.site.uottawa.ca/msdnaa/VirtualMachine_W07/SiteDev.zip (la documentation pour installer la machine virtuelle est au
http://www.site.uottawa.ca/msdnaa/VirtualMachine_W07/SiteLinuxVMs.pdf).
Étape 2 : Faite la commande ls /proc (tout texte avec cette police représente des commandes à être exécutées). Le contenu de /proc sera affiché. Vous verrez plusieurs noms numériques (ce qui représente des répertoires associés aux processus – par exemple le répertoire 23406 contiendra des informations au sujet du processus avec un PID
23406). Vous verrez aussi des noms de fichiers contenant des informations (par exemple
« version » et « cpuinfo »).
Étape 3 : Faite la commande cat /proc/version. Elle devra afficher le contenu du fichier
« /proc/version » qui contient les informations au sujet de la version du SE. Entrez la commande cat /proc/cpuinfo et examiner l’information affichée. Prenez le temps d’examinez le contenu d’autres fichiers.
Étape 4 : Entrez la commande ps. Elle affichera les processus que vous avez démarrés.
Au moins deux processus seront affichés (celui qui exécute « ps » et un processus
« shell » - tout probablement « bash »). Notez le PID du processus « shell ».
Étape 5 : Faite la commande cat /proc/XXXX/stat, où XXXX est le PID de votre processus « shell » de l’étape préalable. Vous noterez une série de chiffres représentant les propriétés du processus. Pour connaître les significations des chiffres avec la commande man proc (qui donne la page de manuel pour proc). Vous pouvez aussi examiner le contenu de « /proc/XXXX/status » qui donne de l’information semblable mais en format plus facile à lire.
Étape 6: Nous voulons explorer les changements d’état des processus, mais il est difficile d’examiner l’activité du processus « shell ». Afin de pouvoir examiner un comportement intéressant, nous allons démarrer et observer d’autres programmes créés à cette fin.
Copiez le fichier « lab1.tar » dans votre répertoire courant sur le système Linux et faite l’extraction des fichiers (untar) avec la commande tar -xvf lab1.tar. Vous trouverez les fichiers suivant dans votre répertoire :
1. procmon: Ce programme lit à toutes les secondes le fichier « /proc/PID /stat » l’état du processus et le nombre de « jiffies » (1/100 de seconde) passé dans le mode noyau et le mode usagé. Cette information sera affichée. Le programme prend un paramètre, le PID du processus qui doit être observé. Le processus procmon termine quand il ne peut plus ouvrir le fichier « /proc/PID /stat » - normalement parce que le processus PID a terminé.
2. Les fichiers programmes calcloop et cploop. Ce sont deux programmes avec des comportements très différents.
a. Le processus calcloop fait le suivant :
i. Part une boucle (10 itérations) qui dort pour 3 secondes, pour ensuite partir une autre boucle qui augmente une variable 400,000,000 fois. Le calcul prend environ 2 secondes de vrai temps (ceci varie selon la charge de l’ordinateur).
b. Le processus cploop fait le suivant :
i. Créé le fichier 500,000 octets de long (fromfile),
ii. Part une boucle (10 itérations) qui dort pour 3 secondes, et ensuite copie le fichier fromfile au fichier tofile. L’opération de copie prend environ 2 secondes de temps réel (ceci varie selon la charge du système);
iii. Le programme utilise deux appels systèmes (systems calls) pour copier un octet à la fois.
3. Les programmes « shell » tstcalc et tstcp. Le premier programme démarre le programme calcloop obtient le PID du processus et démarre procmon avec ce PID pour examiner son comportement. Après 20 secondes, le script terminera le processus calcloop (procmon devra terminer automatiquement, mais le script tentera de le terminera comme précaution). La sortie de procmon sera
sauvegardée dans le fichier calc.log qui peut être étudié. Le programme « shell » tstcp fait la même opération avec cploop en sauvegardant la sortie de procmon
dans le fichier cp.log. Pour exécuter ces scripts, il s’agit de simplement taper leur nom, i.e., tstcalc et tstcp.
4. Un gabarit pour le programme C mon.c. Vous aurez à compléter le code manquant dans ce fichier.
5. Un répertoire qui contient les programmes C procmon.c, calcloop.c et cploop.c que vous pouvez examiner.
Étape 7 : Partez tstcalc. Faite pareil avec tstcp.
Étape 8 : Examinez le contenu des fichiers « calc.log » et « cp.log ». Répondez aux questions suivantes :
1. Expliquez les changements de l’état, du temps systèmes, et du temps usager, pour le processus calcloop en reliant ces changements aux opérations complétées par calcloop.
2. Expliquez les changements de l’état, du temps systèmes, et du temps usager, pour le processus cploop en reliant ces changements aux opérations complétées par cploop.
3. Expliquez la différence entre le temps système et le temps usager entre les deux processus (i.e. pourquoi un processus passe plus de temps en mode usager et/ou en mode système que l’autre).
Étape 9 : Voici la partie facile. Maintenant essayons de la programmation, en utilisant les appels systèmes fork() et exec() étudiés en classe. Votre objectif : écrivez un
programme C mon.c qui offre la majorité des fonctions de tstcalc et tstcp : 1. mon.c utilise un paramètre : le nom M du programme qu’il doit exécuter.
2. mon.c devra démarrer le programme M (ce programme ne prendra aucun paramètres) et doit déterminer son PID.
3. mon.c devra démarrer procmon avec un paramètre, le PID du processus exécutant M.
4. mon.c s’endort pour 20s, et ensuite termine le programme M, dort un autre 2 secondes et tente de terminer procmon.
5. N’inquiétez-vous pas de rediriger la sortie de procmon dans un fichier (vous n’avez pas à vous inquiéter au sujet de l’E/S en C à ce moment).
Étape 10: Compilez votre programme C avec la commande cc mon.c –o mon. Si la compilation se complète sans erreurs, un fichier exécutable mon sera créé.
Étape 11 : Faite la commande mon calcloop et observez. Si tout roule bien, vous verrez la même sortie retrouvée dans le fichier calc.log. Vous pouvez rediriger cette sortie dans un fichier avec la commande mon calcloop > nomFichier.
Information utile:
• L’exécution d’un programme C commence toujours par la fonction main() qui reçoit deux paramètres : nombre entier argc donnant le nombre de paramètres de la ligne de commande et argv un tableau (avec argc éléments) de chaînes de caractères qui réfère aux paramètres de la ligne de commande. La convention stipule que argv[0] donne le nom du programme et argv[1] donne son premier paramètre.
• L’appel système fork() créée un nouveau processus. Le parent et l’enfant continue au même point, i.e., le retour de l’appel fork(). Mais chez le parent, fork() retourne le PID de l’enfant tandis que chez l’enfant, fork() retourne la valeur 0. Pour plus d’information au sujet de fork(), utilisez man fork.
• L’appel système execl(path, arg1, …) remplace l’image dans un processus par un programme avec des paramètres donnés. Tapez pour connaître la signification exacte de chacun des paramètres. L’appel execl(“calcloop”,”calcloop”,NULL) remplace le code dans le processus avec le programme calcloop. L’appel
execl(“/bin/ls”, “ls”, “-l”, NULL) exécute le code du programme ls –l.
• Vous devez convertir le nombre entier PID à une chaîne de caractère pour l’envoyer vers procmon. Ceci peut être fait en C avec une fonction de
bibliothèque : sprintf(pidchn,“%d”,pid), où pid est une variable int qui contient la valeur du pid, et pidchn est une variable char * qui recevra la chaîne de caractères du PID à être envoyé vers procmon.
• La fonction sleep() qui fera dormir le processus pour le nombre de secondes spécifié dans son paramètre.
• L’appel système kill(pid,sig) qui envoie un signal sig au processus pid.
o Examinez signal.h pour connaître les différents signaux.
o Google est votre ami, le lien suivant suite à une recherche de « signal.h » peut être utile (il y en a beaucoup plus)
http://www.opengroup.org/onlinepubs/009695399/basedefs/signal.h.html
