Rsum de programmation systme Chapitre 1:Fork()

Dfinition du Processus:

On appelle processus, un programme charg en mmoire centrale et en cours d'excution. Il est gr par le systme d'exploitation. Chaque processus peut crer lui-mme des processus. Ces nouveaux processus sont alors appels processus enfants (child process).
Utilit et Intrt :

Utilisation plus efficace de ressources Simplicit(sparation entre les activits) Scurit Efficacit(quand lun est bloqu, passe une autre chose) Multi-utilisateur Multi-tche : Chaque processus possde son propre processeur virtuel, en ralit, le vrai processeur commute entre plusieurs processus.
L'ordonnanceur

Prendre en charge la commutation des tches, qui assure le passage d'une tche une autre. Sur un intervalle de temps assez grand, faire progresser tous les processus, tout en ayant, un instant donn, un seul processus actif (dans le processeur).
La commande "ps":

Elle permet de visualiser les processus existant son lancement sur la machine. Sans option, elle ne concerne que les processus associs au terminal depuis lequel elle est lance.
Processus init:

Un pseudo processus est cre au moment du dmarrage du systme et a comme PID le numro 0. Il cre lui-mme un processus enfant, avec le numro 1. Le processus numro 1 est appel processus init. Ce processus init est responsable de tous les processus en cours dans le systme Il permet d'afficher l'cran le login et d'utiliser le shell.

Cration de processus lappel "fork ( )" :

Synopsis
#include <unistd.h> pid_t fork(void);

fork cre un processus fils (child) qui diffre du processus parent uniquement par ses valeurs : PID (Processus IDentifier) : l'identificateur du processus ; et PPID (Parent PID) : Identificateur du processus pre; et par le fait que toutes les statistiques d'utilisation des ressources sont remises zro. Les verrouillages de fichiers, et les signaux en attente ne sont pas hrits.

 Valeur renvoye : En cas de succs, le PID du fils est renvoy au processus parent, et 0 est renvoy au processus fils. En cas d'chec -1 est renvoy dans le contexte du parent, aucun processus fils n'est cr, et errno contient le code d'erreur.
pid = fork(); if(pid == -1) /*code correspondant au traitement de lechec :*/ if (pid==0)/*Code correspond lexcution du processus fils */ else /*code correspondant lexcution du processus pre*/

Erreurs ENOMEM Impossible d'allouer assez de mmoire pour copier la table des pages du pre et d'allouer une structure de tche pour le fils. EAGAIN Impossible de trouver un emplacement vide dans la table des processus.
Les tches de fork():

Test d'existence de ressources mmoires suffisantes pour permettre la cration du nouveau processus, Calcul du PID du processus enfant. Le noyau explore ensuite la table proc[] pour vrifier que ce numro n'est pas en cours d'utilisation. Si le numro existe dans la table, le calcul est relanc. Recherche d'une entre libre dans la table des processus, Duplication du contexte processeur et mmoire du processus parent, Mise jour des tables systme modifies par la cration du nouveau processus.
l'identifiant d'un processus :

Synopsis
#include <sys/types.h> #include <unistd.h> pid_t getpid(void); pid_t getppid(void); pid_t getpgrp(void);

getpid : retourne l'ID du processus actif. getppid : retourne le PID du processus parent de celui en cours. Ceci est rgulirement utilis aprs un fork () pour tablir la communication entre les deux processus issus du mme programme. getpgrp : retourne lidentificateur du groupe de processus.

Chapitre 2
fonction exit() :

Synopsis #include <stdlib.h> void exit (int etat) La fonction exit() termine normalement le programme en cours(un processus). La valeur etat (tat de sortie ) est un octet (donc valeurs possibles : 0 255) renvoy dans une variable du type int au processus pre.
Convention

Un code de retour gal zro signifie que le processus sest termin normalement, et un code non nul (gnralement 1 ou 1) signifie quune erreur sest produite.

 conclusion :

Si le pre meurt avant ses fils, le pre du processus fils devient le processus init de pid 1. type.h typedef int pid_t ; /*prrocess id (must de signed) */ dans la libc , le type pid_t est dfini comme un entier susceptible de contenir un pid .Nous lutiliserons pour caractre un pid ,uniquement pour la clart :utiliser un entier renient au mme

Zombi:
Dfinition:

Quand un processus se termine, et que son pre na pas rcupr ltat de sa terminaison, il devient un zombi. zombi (Orthographe anglaise) est un terme dsignant un processus qui s'est achev, mais qui dispose toujours d'un identifiant de processus (PID) et reste donc encore visible dans la table des processus. On parle aussi de processus dfunt. Il consommes inutilement des ressources systme. A la terminaison de son pre un zombi devient orphelin et sera rattach au processus init qui prend toutes les dispositions permettant llimination de ses fils zombis.

Orphelin:
Dfinition :

Un processus(fils) dont le pre sest termin sappelle orphelin. le noyau le rattache au processus init (1).
Wait/waitpid :

Synopsis
#include <sys/types.h> #include <sys/wait.h> pid_t wait(int *etat) pid_t waitpid(pid_t pid, int *etat, int options);

Description: Wait

Elle suspend l'excution du processus courant jusqu' ce qu'un enfant se termine, ou jusqu' ce qu'un signal intercepter arrive. Si un processus fils s'est dj termin au moment de l'appel (il est devenu "zombie"), la fonction revient immdiatement. Toutes les ressources utilises par le fils sont libres.
Description: Waitpid :

Elle suspend l'excution du processus courant jusqu' ce que le processus fils numro pid se termine, ou jusqu' ce qu'un signal intercepter arrive. Si le fils mentionn par pid s'est dj termin au moment de l'appel (il est devenu "zombie"), la fonction revient immdiatement. Elle rcupre les informations relatives sa terminaison l'adresse pointeur_etat. Toutes les ressources utilises par le fils sont libres.
La valeur de retour de wait de type pid_t :

La valeur de retour de wait est le numro du processus fils venant de se terminer. Lorsqu'il n'y a plus (ou pas) de processus fils dont il faut attendre la fin, la fonction wait renvoie -1.

 Paramtre PID (pid_t pid) :

Le paramtre PID permet dattendre (slectionner) le processus attendu de la manire suivante : -1 : attendre la fin de n'importe quel fils. C'est le mme comportement que wait. 0 : attendre la fin de n'importe quel processus fils du mme groupe que l'appelant. > 0 : attendre la fin du processus numro pid. wait(&etat) = waitpid(-1,&etat,0)
Etat : wait( &Etat )/ wait(int *etat)

Etat est un pointeur sur un mot de deux octets : L'octet de poids fort: contient la valeur renvoye par le fils (i de la fonction exit( i )). l'octet de poids faible: contient 0 dans le cas gnral, En cas de terminaison anormale du processus fils, cet octet de poids faible contient la valeur du signal reu par le fils. Chaque fois qu'un fils se termine le processus pre sort de wait, et il peut consulter Etat pour obtenir des informations sur le fils qui vient de se terminer.

Rsum :
Fin de processus: exit(int etat) avec etat un code de fin. Le pre attend la fin de lun des fils: pid_t wait (int etat). Retour: le pid du fils qui a terminer code de fin : stock dans etat Attendre la fin du fils de pid: pid_t waitpid(pid_t id, int etat) Processus zombi: terminer mais le pre na pas appel wait(). Il ne peut plus sexcuter, mais consomme encore des ressources. viter.

Chapitre 4 : exec()
Prototype de la fonction main

int main (int argc, char *argv[ ], char *arge[ ]); Argc : est le nombre de composantes de la commande (nom de la commande et arguments). Argv :est un tableau de pointeurs sur caractres permettant l'accs aux diffrentes composantes de la commande dont la fin est marque par un lment de valeur NULL. Arge :est un tableau de pointeurs sur caractres permettant l'accs l'environnement du processus.
Dfinition : exec :

Elles permettent le lancement de l'excution dun nouveau programme par le processus appelant; le texte de ce nouveau programme recouvre alors celui de l'ancien programme excut. Il n'y a donc pas de retour d'un exec russi, car on a cras l'ancien code. Souvent utilis immdiatement aprs la cration dun nouveau processus: fork+exec = lancement dun programme dans un nouveau processus. Effet: remplace la mmoire virtuelle du processus par le programme. Plusieurs variante existent selon le mode de passage des paramtres.

 les variantes de exec :

L : List Exec E : environnement P : Path courante Execl Execle Execlp

V: vecteur Execv Execve Execvp

L : List, signifie que les paramtres sont mis et list les uns la suite et termin par un NULL. V : Vecteur, signifie que les paramtres sont mis dans un vecteur argv. E : Environnement, signifie Avec passage d'environnement . (sinon les variables d'environnements du programme appelant sont utilis). P : Path courante ,signifie que le programme sera recherch dans les rpertoires de la variables d'environnement PATH (on n'est pas oblig de connaitre son chemin complet si lexcutable est dans un des rpertoire du PATH). Donc si P alors pas besoin de spcifier le chemin file (fichier sans chemin) .

PATH: est le chemin dun excutable partir du rpertoire courant File : le chemin dun excutable partir de la variable denvironnement PATH.
int Execl(const char *path, const char *arg0, ..., const char *argn, char * /*NULL*/); int Execle(const char *path, const char *arg0, ..., const char *argn, char * /*NULL*/, char *const envp[]); int Execlp(const char *file, const char *arg0, ..., const char *argn, char */*NULL*/); int Execv(const char *path, char *const argv[]); int Execve(const char *path, char *const argv[], char *const envp[]); int Execvp(const char *file, char *const argv[]);

chapitre 4 : Les signaux

1 Les Signaux (Attente, envoi du signal et traitement effectuer) :
#include <signal.h> void (*signal(int signum, void (* fonct)(int)))(int); #include <unistd.h> unsigned int alarm(unsigned int nb_sec); #include<unistd.h> int pause(void); #include <signal.h> int kill(pid_t pid, int sig);

Signal : intercepter - ou capturer - le signal pour lancer un traitement.Permet d'installer fonct comme fonction de traitement lors de la rception du signal signum alarm: programme une temporisation (rveil) pour qu'elle envoie un signal SIGALRM au processus en cours dans nb_sec secondes. Sa rception terminera le processus. pause: (Attendre un signal) endort le processus appelant jusqu' ce qu'il reoive un signal. kill() : (Envoyer un signal un autre processus.)

Lazhari