Module programmation Unix

Présentation du module
Processus
Signaux
Tubes
Conclusion
Module programmation Unix
Sébastien Le Maguer
EII 1 (2011/2012)
Module programmation Unix
1 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
: Plan
1
Présentation du module
2
Processus
3
Signaux
4
Tubes
5
Conclusion
Module programmation Unix
2 / 39
Présentation du module
Présentation du module
Processus
Signaux
Tubes
Conclusion
: Présentation du module - Objectifs
Pré-requis
Module utilisation Unix
Module algorithmique/C
Ce que nous allons voir
Programmation utilisant le système Unix
Nous n’allons pas programmer le système !
Module programmation Unix
4 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
: Présentation du module - Déroulement
Première année
Processus
Signaux
Tubes
Deuxième année
Threads
IPC
Module programmation Unix
5 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
: Présentation du module - Déroulement
4h de CM (présentation des concepts)
Pas de détails sur les primitives ⇒ pages de manuel
6h de TP (application des concepts)
Évaluation : DS de 1h
Module programmation Unix
6 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
: Présentation du module - Bibliographie
Christophe Blaess.
Développement système sous Linux : ordonnancement, multi-tâche,
gestion meémoire, communications, programmation reéseau.
Eyrolles, Paris, 2011.
Biran Kernighan and Pike Rob.
The UNIX programming environment.
Prentice-hall software series, 1978.
Various.
http://www.gnu.org/software/libc/manual/html_node/
index.html.
Various.
Linux man page.
http://www.delafond.org/traducmanfr/.
man command.
Module programmation Unix
7 / 39
Processus
Présentation du module
Processus
Signaux
Tubes
Conclusion
Définition et caractéristiques: Qu’est ce qu’un
processus
Définition
processus = unité d’exécution du système
Exemple de processus = programme/commande
“cd”, “ls”, . . .
“login”, . . .
“firefox”, . . .
...
Mais pas que :
Le serveur Web créé des processus
...
Module programmation Unix
9 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Définition et caractéristiques: Propriétés
Constitution d’un processus
identifiant (pid)
espace mémoire propre (mémoire virtuelle)
code
données
diverses tables (descripteurs, signaux,. . . )
Propriétaire (user/group) + droits spécifiques
Concrètement :
Un proc. = un répertoire /proc/ < PID >
Exemple de répertoire proc :
attr
mounts
autogroup
mountstats
auxv
net
cgroup
numa_maps
clear_refs
oom_adj
cmdline
oom_score
comm
oom_score_adj
coredump_filter
pagemap
cpuset
personality
cwd
root
environ
sched
exe
schedstat
fd
sessionid
fdinfo
smaps
io
stack
latency
stat
limits
statm
loginuid
status
maps
syscall
mem
task
mountinfo
wchan
Module programmation Unix
10 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
États d’un processus: Graphe d’états d’un
processus
Sommeil
Attente
d’un évènement
Signal
fork
Prêt
Ordonance.
exit
Exécution
Zombie
Lecture code retour
SIGTOP
SIGCONT
Arrêté
Module programmation Unix
11 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Création d’un processus
Utilisation de la primitive fork :
pid_t fork ( void );
Ce qui se passe :
Père
code+données
propriétés
(droits,. . . )
Fils
code+données
fork
propriétés
(droits,. . . )
Module programmation Unix
12 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Création d’un processus Exemple
pid_t pid = fork ();
switch ( pid )
{
case -1:
fprintf ( stderr , " impossible de creer le processus " );
exit ( EXIT_FAILURE );
case 0:
printf ( " Je suis le fils " );
exit ( EXIT_SUCCESS );
default :
printf ( " Je suis le pere " );
waitpid ( pid );
}
Module programmation Unix
13 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Attente d’un processus
Attente d’un processus donné
pid_t waitpid ( pid_t pid , int * status , int options );
Attente de tous les processus fils !
pid_t wait ( int * status );
status permet de récupérer le code renvoyé par le fils
Module programmation Unix
14 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Problème : le recouvrement: Exécution d’un
programme externe
Basée sur la primitive execlp
Nécessite de donner le chemin complet !
“which command” pour connaitre le chemin complet de command
Exemple d’utilisation :
Problème execlp écrase la mémoire du processus mais garde
l’identité
⇒ RECOUVREMENT
Solution = créer un processus fils qui sert d’hôte
Module programmation Unix
15 / 39
Signaux
Présentation du module
Processus
Signaux
Tubes
Conclusion
Définition et caractéristiques: Qu’est ce qu’un
signal
Définition
Un signal est une notification asynchrone envoyée par le noyau à
un processus
Limitations :
Pas d’accusé de réception
Impossible de savoir qui a émis le signal
Module programmation Unix
17 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Définition et caractéristiques: Liste des signaux
les plus connus sous Unix
(/usr/include/bits/signum.h, man 7 signal)
Nom
SIGHUP
Id.
1
Action par défaut
Term
SIGINT
SIGQUIT
SIGILL
SIGABRT
SIGFPE
SIGKILL
SIGSEGV
SIGPIPE
SIGALRM
SIGTERM
SIGUSR1
SIGUSR2
SIGCHLD
SIGCONT
SIGSTOP
SIGTSTP
SIGTTIN
SIGTTOU
2
3
4
6
8
9
11
13
14
15
30,10,16
31,12,17
20,17,18
19,18,25
17,19,23
18,20,24
21,21,26
22,22,27
Term
Core
Core
Core
Core
Term
Core
Term
Term
Term
Term
Term
Ign
Cont
Stop
Stop
Stop
Stop
Sens
Raccrochement (déconnexion) sur terminal de contrôle,
ou mort du processus de contrôle
Interruption clavier (Ctrl+c)
Demande ’Quitter’ depuis le clavier
Instruction illégale
Signal d’arrêt depuis abort(3)
Erreur mathématique virgule flottante
Signal ’KILL’
Référence mémoire invalide
Écriture dans un tube sans lecteur
Temporisation alarm(2) écoulée
Signal de fin
Signal utilisateur 1
Signal utilisateur 2
Fils arrêté ou terminé
Continuer si arrêté
Arrêt du processus
Stop invoqué depuis tty
Lecture sur tty en arrière-plan
Écriture sur tty en arrière-plan
Module programmation Unix
18 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Résumé des manipulations
Schéma classique
Envoi un signal au processus courant + ALARME !
Proc. A
KERNEL
Proc B
Module programmation Unix
19 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Résumé des manipulations
Schéma classique
Envoi un signal au processus courant + ALARME !
demande signal à B
Proc. A
KERNEL
Proc B
envoi signal à B
Module programmation Unix
19 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Résumé des manipulations
Schéma classique
Envoi un signal au processus courant + ALARME !
demande signal à A
Proc. A
KERNEL
envoi signal à A
Proc B
Module programmation Unix
19 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Émission
Envoyé par le noyau mais la demande peut venir de :
D’autres processus (kill)
Le processus lui même (exceptions : division par zéro, . . . )
Le noyau (Alarme, . . . )
Basée sur la primitive kill :
int kill ( pid_t pid , int sig );
Alias pour le processus courant raise :
int raise ( int sig );
équivalent à
int kill ( getpid () , int sig );
Module programmation Unix
20 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Réception - signal
Ne fonctionne pas pour SIGKILL, SIGCONT, SIGSTOP
Basée sur la primitive signal
sighandler_t signal ( int signum , sighandler_t handler );
handler = pointeur sur fonction :
typedef void (* sighandler_t )( int );
Deux handler particuliers :
SIG DFL = comportement par défaut
SIG IGN = ignorer le signal
Module programmation Unix
21 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Réception - sigaction
Ne fonctionne pas pour SIGKILL, SIGCONT, SIGSTOP
Basée sur la primitive sigaction
int sigaction ( int signum , const struct sigaction * act ,
struct sigaction * oldact );
Nécessite plus d’informations
struct sigaction {
void
(* sa_handler )( int );
void
(* sa_sigaction )( int , siginfo_t * , void *);
sigset_t
sa_mask ;
int
sa_flags ;
void
(* sa_restorer )( void );
};
Différences avec signal :
signal est standard, sigaction non ! Néanmoins...
signal réinitialise le handler ! (⇒ course entre signaux)
sigaction possède plus d’options
Module programmation Unix
22 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Réception - sigaction
signal a eu un comportement qui a évolué au cours du temps
(manpage)
utiliser sigaction plutôt que signal
Course (ré-initialisation du handler) :
deux signaux émis presque simultanément
le second émis avant la réinstallation du handler ⇒ action par
défaut au lieu de l’action voulue (Système V)
cela semble avoir évolué avec la glibc2 ⇒ le second signal est
bloqué (BSD)
Module programmation Unix
23 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Attente/Alarme
Attente, processus endormi jusqu’à réception (ne fonctionne pas
pour SIGKILL, SIGCONT, SIGSTOP) :
De n’importe quel signal
int pause ( void );
De signaux précis (fonctionnement par mask)
int sigsuspend ( const sigset_t * mask );
Alarme, émission du signal SIGALRM au bout d’un certain temps
(processus courant)
unsigned int alarm ( unsigned int seconds );
Module programmation Unix
24 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Exemple complet avec signal
(sigaction ⇒ TP)
int pid = 0;
void handler_fils ( int signum )
{
if ( signum == SIGALRM )
{
printf ( " % d - recu SIGALRM \ n " , getpid ());
kill ( getppid () , SIGINT );
pause ();
}
else if ( signum == SIGKILL )
{
printf ( " % d - kill \ n " , getpid ());
}
}
Module programmation Unix
25 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Exemple complet avec signal
(sigaction ⇒ TP)
void handler_pere ( int signum )
{
if ( signum == SIGINT )
{
printf ( " % d - recu SIGINT \ n " , getpid ());
kill ( pid , SIGKILL );
}
else if ( signum == SIGALRM )
{
printf ( " % d - recu SIGALRM \ n " , getpid ());
kill ( pid , SIGALRM );
}
else if ( signum == SIGCHLD )
{
printf ( " % d - recu SIGCHLD \ n " , getpid ());
}
}
Module programmation Unix
26 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Exemple complet avec signal
(sigaction ⇒ TP)
int main ( int argc , const char ** argv )
{
pid = fork ();
if ( pid == 0)
{
signal ( SIGALRM , handler_fils );
pause ();
}
else if ( pid > 0)
{
alarm (2);
signal ( SIGINT , handler_pere );
signal ( SIGALRM , handler_pere );
signal ( SIGCHLD , handler_pere );
wait ( pid );
}
return EXIT_SUCCESS ;
}
Module programmation Unix
27 / 39
Tubes
Présentation du module
Processus
Signaux
Tubes
Conclusion
Définition et caractéristiques: Qu’est qu’un tube
Permet de programmer le “|” (ls | grep...)
2 types de tube :
Anonyme
Nommé
Mode FIFO + Flots de données
Schéma d’un tube
Père
Fils
in
in
out
out
STDOUT
STDIN
Module programmation Unix
29 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Définition et caractéristiques: Qu’est qu’un tube
Permet de programmer le “|” (ls | grep...)
2 types de tube :
Anonyme
Nommé
Mode FIFO + Flots de données
Schéma d’un tube
Tube (pipe)
Père
Fils
in
in
out
out
Module programmation Unix
29 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Pré-requis : re-direction des IO
Permet d’effectuer une dérivation
Basée sur la primitive dup2 (dup est obsolète !)
int dup2 ( int oldfd , int newfd );
Liens avec les tubes
théorie = re-direction de la sortie d’un processus vers l’entrée d’un
autre
pratique = tube plus compliqué qu’une simple re-direction
Exemple (exercice 1 du TP sur les tubes)
Module programmation Unix
30 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Création
Basé sur la primitive pipe
int pipe2 ( int pipefd [2]);
Limitation : repose sur le mécanisme d’héritage
⇒ Lien de parenté entre les processus relié par le tube
⇒ Créer le tube avant la création du proc. fils
⇒ Ne permet de communiquer que du père vers le fils
Module programmation Unix
31 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Principe de fonctionnement d’un
tube
1
Créer le tube
2
Créer le fils
3
Pour chaque processus
Dans le fils
1
2
3
4
Fermeture du descripteur d’écriture
Lecture
Fermeture du descripteur de lecture
Quitter
Dans le père
1
2
3
4
5
Fermeture du descripteur de lecture
Écriture
Fermeture du descripteur d’écriture
Attendre le fils
Quitter
Module programmation Unix
32 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Écriture/Lecture
Fonctionne comme pour un fichier !
Écriture
Basé sur la primitive write
ssize_t write ( int fd , const void * buf , size_t count );
Lecture
Basé sur la primitive read
ssize_t read ( int fd , void * buf , size_t count );
Module programmation Unix
33 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Fermeture/Destruction
Fonctionne comme pour un fichier !
Fermeture basée sur la primitive close
int close ( int fd );
Destruction effective du tube lorsqu’il n’est plus référencé
Module programmation Unix
34 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Exemple minimal
# define SIZE 30
int main ( int argc , const char ** argv )
{
int fd [2];
pid_t pid ;
char * buffer = NULL ;
buffer = ( char *) malloc ( SIZE * sizeof ( char ));
if ( buffer == NULL )
{
perror ( " erreur allocation buffer " );
return EXIT_FAILURE ;
}
if ( pipe ( fd ) < 0)
{
perror ( " erreur creation pipe " );
return EXIT_FAILURE ;
}
Module programmation Unix
35 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
Manipulation: Exemple minimal
switch ( pid = fork ())
{
case -1:
perror ( " erreur creation process " );
return EXIT_FAILURE ;
case 0:
close ( fd [1]);
read ( fd [0] , buffer , SIZE );
printf ( " Message recu = % s \ n " , buffer );
close ( fd [0]);
exit ( EXIT_SUCCESS );
default :
close ( fd [0]);
write ( fd [1] , " Luke , je suis ton pere !\0 " , SIZE );
close ( fd [1]);
waitpid ( pid );
}
Module programmation Unix
return EXIT_SUCCESS ;
36 / 39
Conclusion
Présentation du module
Processus
Signaux
Tubes
Conclusion
: Conclusion - Bilan
Ce dont vous devriez être capable...
Comprendre les bases des processus et en créer
Émettre et recevoir des signaux et comprendre leur utilité
Re-diriger les entrées/sorties et communiquer via des tubes
Il ne s’agit que d’une introduction - Nous n’avons pas vu
Les techniques d’ordonnancement
Les IPC (EII 2)
...
Module programmation Unix
38 / 39
Présentation du module
Processus
Signaux
Tubes
Conclusion
: Conclusion - Pour aller plus loin...
Implémenter, tester, bref APPLIQUER !
Le système est sécurisé !
Vous acquerrez de l’expérience et donc une intuition !
Regarder l’implémentation des primitives :
Compliqué.....
....mais formateur
Module programmation Unix
39 / 39