SMI - S4

TP 3 Système d’exploitation 2:
Gestion des processus
Cours donné par:
Pr. N. ALIOUA

Année universitaire:
2019-2020

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
 A. Introduction
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
 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:
Deux processus sont crées
/* premierfork.c */
L’affichage donne: (les pid changent selon
#include <stdio.h> chaque machine)
#include <unistd.h> Je suis le père : pid=1123
void main(void){ Je suis le fils: pid=1124
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());
}
B. Création de processus
Exercice 2: L’affichage donne:
/*forkparent.c*/
#include <stdio.h>
Valeur de fork=2155 je suis le processus 2154 de père
#include <unistd.h> 2122
#include <stdlib.h> Fin de processus père
void main(){ Valeur de fork=0 je suis le processus 2155 de père 2154
int pid;
switch(pid=fork()){
Fin du processus fils
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 ");
}
} 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
Après fork 1: Après fork 3:
P1 va générer Après fork 2:
P11 va générer P13 va générer
Avec Fork 1:P11 P12 va générer
Avec Fork 2: P112 Avec Fork 3: P133
Avec Fork 2: P12 Avec Fork 3: P123
Avec Fork 3: P113
Avec Fork 3: P13
B. Création de processus
Exercice 3:
/*multifork.c*/ P1 Main
#include <stdio.h>
#include <unistd.h> Fork 1
P11
int main(){
fork();
fork(); Fork 2 P12 P112
fork();
return 0; Fork 3
} P13 P123 P1123 P113
Ce code génère 8 processus
 B. Création de processus
Exercice 4:
#include <stdio.h>
#include <stdlib.h> pid = fork();
#include <sys/types.h> if (pid == -1){
#include <unistd.h> perror("fork");
int main(void){ exit(1);
pid_t pid; }
int i; if (pid == 0){ /* fils2 */
pid = fork(); for (i = 51; i <= 100; i++)
if (pid == -1){ printf("\nfils2 affiche %d",i);
perror("fork"); exit(0);
exit(1); }
} return 0;
if (pid == 0){ /* fils1 */ }
for (i = 1; i <= 50; i++)
printf ("\nfils1 affiche %d",i);
exit(0);
}
C. Fonctions de recouvrement
/* testexec.c */ Le processus du programme main va charger la
#include <stdio.h> commande ls – l et ne va jamais afficher la dernière
#include <unistd.h> du programme, car l’utilisation de l’une des fonctions
void main(void){ de la famille exec permet le chargement d’un autre
char * argv[3]; programme et annule tout ce qui suit dans le code
char * envp[1]; source
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");
}