Année universitaire:
2019-2020
TP 3 Système d’exploitation 2:
Gestion des processus
SMI - S4
Cours donné par:
Pr. N. ALIOUA
1
A. Introduction
1. Visualisez les processus de votre session courante utiliser la commande ps
2. Affichez les processus d’un utilisateur.
utiliser la commande ps -u NomUser 3. Affichez tous les processus avec des détails.
utiliser la commande ps –ef
(-e: tous les processus, -f détaillé)
4. Lancez Firefox depuis le Shell. Puis lancez-le en tâche de fond. Que remarquez-vous ?
Tappez le nom de l’application pour la lancer depuis le shell: firefox
Ajouter & pour la lancer en tâche de fond: firefox &
La première commande interdit l’accès au terminal quand le navigateur est toujours ouvert, alors que la deuxième permet l’accès au terminal
Quelques champs de ps:
Champs Explication
UID: nom de l'utilisateur qui a lancé le processus PID: ID du processus
PPID: ID du processus parent
C: utilisation de CPU relative à la priorité : plus la valeur est grande, plus le processus est prioritaire
STIME: instant du lancement du processus TTY: nom du terminal
TIME: la durée de traitement du processus COMMAND: nom du processus
A. Introduction
B. Création de processus
a. Ouverture d’éditeur en tâche de fond:
avec la commande gedit &
b. Sauvegarde avec extension .c:
c. Compilation:
avec la commande
gcc fichier.c –o fichiercompil
d. Exécution du fichiercompil depuis le terminal:
avec la commande ./fichiercompil
B. Création de processus
Exercice 1:
/* premierfork.c */
#include <stdio.h>
#include <unistd.h>
void main(void){
int pid;
pid = fork();
if (pid == -1)
printf("Erreur de création\n");
else if (pid == 0)
printf("Je suis le fils: pid = %d\n", getpid());
else
printf("Je suis le père: pid = %d\n", getpid());
}
Deux processus sont crées
L’affichage donne: (les pid changent selon chaque machine)
Je suis le père : pid=1123 Je suis le fils: pid=1124
B. Création de processus
Exercice 2:
/*forkparent.c*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
void main(){
int pid;
switch(pid=fork()){
case -1: perror("Création de processus");
exit(2);
case 0 : /* on est dans le processus fils*/
printf("valeur de fork = %d ", pid);
printf("je suis le processus %d de père %d\n", getpid(), getppid());
printf("fin de processus fils\n ");
exit(0);
default : /*on est dans le processus père*/
printf("valeur de fork = %d", pid);
printf("je suis le processus %d de père %d\n", getpid(), getppid());
printf("fin de processus père\n ");
} }
L’affichage donne:
Valeur de fork=2155 je suis le processus 2154 de père 2122
Fin de processus père
Valeur de fork=0 je suis le processus 2155 de père 2154 Fin du processus fils
Conclusion:
Si un père termine et n’attend pas ses fils, ses processus fils vont devenir orphelins.
Linux et UNIX attribuent le processus d'initialisation (init) en tant que nouveau père des processus orphelins.
B. Création de processus
Exercice 3:
/*multifork.c*/
#include <stdio.h>
#include <unistd.h>
int main(){
fork();
fork();
fork();
return 0;
}
Ce code génère 8 processus
Main: P1
P1 va générer Avec Fork 1:P11 Avec Fork 2: P12 Avec Fork 3: P13
Après fork 1:
P11 va générer Avec Fork 2: P112 Avec Fork 3: P113
Après fork 2:
P12 va générer Avec Fork 3: P123
Après fork 3:
P13 va générer Avec Fork 3: P133
B. Création de processus
Exercice 3:
/*multifork.c*/
#include <stdio.h>
#include <unistd.h>
int main(){
fork();
fork();
fork();
return 0;
}
Ce code génère 8 processus
P1 Main
P11 Fork 1
Fork 2 P12 P112
P13 P123 P1123 P113 Fork 3
B. Création de processus
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int main(void){
pid_t pid;
int i;
pid = fork();
if (pid == -1){
perror("fork");
exit(1);
}
if (pid == 0){ /* fils1 */
for (i = 1; i <= 50; i++)
printf ("\nfils1 affiche %d",i);
exit(0);
}
pid = fork();
if (pid == -1){
perror("fork");
exit(1);
}
if (pid == 0){ /* fils2 */
for (i = 51; i <= 100; i++)
printf("\nfils2 affiche %d",i);
exit(0);
}
return 0;
} Exercice 4:
C. Fonctions de recouvrement
/* testexec.c */
#include <stdio.h>
#include <unistd.h>
void main(void){
char * argv[3];
char * envp[1];
argv[0] = "/bin/ls";
argv[1] = "-l";
argv[2] = NULL;
envp[0] = NULL;
printf("Exemple d\'utilisation de execve():\n");
execve("/bin/ls", argv, envp);
printf("Ne devrait pas être affiché\n");
}
Le processus du programme main va charger la commande ls – l et ne va jamais afficher la dernière du programme, car l’utilisation de l’une des fonctions de la famille exec permet le chargement d’un autre programme et annule tout ce qui suit dans le code source
