:tocdepth: 2 =========== Processus =========== .. include:: common.rst.inc Notion de processus =================== Terminologie ------------ * Le terme « programme » est polysémique, et donc ambigu * « mon programme ne compile pas » * « je copie le programme sur ma clé USB » * « le compteur de programme » * « j'ai 3 programmes qui s'exécutent » * Nécessité de lever l'ambiguïté .. index:: programme, image, source Terminologie (2) ```````````````` * **Programme** : séquence d'instructions en langage machine stocké en RAM *« le compteur de programme »* * **Image** : fichier contenant l'image mémoire d'un programme « je copie l'image sur ma clé USB » * **Source** : fichier en langage évolué servant à produire une image « mon source ne compile pas » .. index:: processus .. _processus: Définition : Processus ---------------------- * **Processus** : exécution d'un programme *« j'ai 3 processus qui s'exécutent ... »* *« ... un lecteur de musique, et 2 éditeurs de texte »* → plusieurs processus peuvent exécuter le même programme * Métaphore : * programme ~ partition (avec des choix possibles...) * processus ~ musicien * processeur ~ instrument Remarques ````````` * Source, image, programme : notions *statiques* * Processus : notion *dynamique* NB: les commandes UNIX ``ps`` et ``top``, et le gestionnaire de tâches de Windows (onglet « Processus »), donnent des informations sur les *processus* en cours Exemple : gestionnaire de tâches Windows ```````````````````````````````````````` .. figure:: _static/ps_windows.png :width: 80% Exemple : moniteur système Linux ```````````````````````````````` .. figure:: _static/ps_gnome.png :width: 100% Processus et SE ``````````````` Plusieurs processus indépendants doivent pouvoir s'exécuter sans interférence : * partage des ressources (arbitrage) * isolation des processus (abstraction, autorisation) À l'inverse, les processus doivent pouvoir communiquer si leur programme le demande * IPC (communication inter-processus) → cf. `chapitre correspondant `:doc: et TPs .. index:: PCB (process control block) Gestion des processus par le noyau ================================== Définition : PCB ---------------- *Process Control Block* (PCB) * Structure de données du SE contenant les informations sur un processus. * Ces informations sont dans une zone mémoire accessible uniquement par le noyau du SE. * Pour obtenir des informations sur les processus, il est donc nécessaire de passer par des appels systèmes : ``getpid``, ``getppid``, ``getuid``, ``geteuid``, ``setuid``... .. index:: PID (process identifier) Identité ```````` * Identificateur de processus (PID) → numéro unique (à un instant *t*, mais réutilisable) * Informations de généalogie → processus parent (PPID) → processus enfants * Information de droits → utilisateur propriétaire du processus → utilisateur effectif (augmentation ou diminution de droits) Exécution ````````` * État du processus → cf. transparents suivants * Contexte processeur → état des registres du processeur pour ce processus * Autres informations d'ordonnancement → exemple : `priorité`:ref pour l'`ordonnancement `:doc: Ressources `````````` * Informations sur la mémoire utilisée / utilisable → tables de pages (cf. séances sur la gestion de la mémoire) * Informations sur le temps passé → temps réel, temps utilisateur * Liste des fichiers ouverts → « fichiers » au sens large (cf. chapitre `es`:doc:) * Autres ressources utilisées... .. index:: single: état d'un processus single: processus; état pair: état d'un processus; élu pair: état d'un processus; éligible pair: état d'un processus; bloqué États d'un processus -------------------- Selon les systèmes, le nombre et le nom des états peut varier. Mais la base commune est : Élu: en train de s'exécuter sur un processeur Éligible: en attente d'un processeur pour s'exécuter Bloqué: en attente d'un événement (ex: interruption) ; ne peut donc pas s'exécuter pour l'instant Diagramme d'états d'un processus ```````````````````````````````` .. figure:: _static/ps_states.png :width: 100% Remarques sur l'identité ------------------------ Intérêt de séparer l'utilisateur propriétaire de l'utilisateur effectif : * Droits d'administration « locale » : certaines commandes, au comportement connu et circonscrit, s'exécutent avec des droits supérieurs à l'utilisateur qui les lancent. exemple : ``sudo``, ``crontab -e``... * Services lancés par l'administrateur  : pour limiter les risques en cas d'exploitation de faille, ils s'éxécutent avec des droits limités. example : ``httpd``, ``ftpd`` Création de processus par programmation ======================================= Différentes approches --------------------- * Sous Windows * Sous UNIX .. index:: pair: appel système; CreateProcess Windows ``````` Appel système ``CreateProcess`` : crée un processus dont les caractéristiques sont données en paramètres de l'appel système. Exemple : .. code-block:: c STARTUPINFO si; // à renseigner PROCESS_INFORMATION pi; // utilisé en sortie bool succes = CreateProcess( 0, "mon_prog.exe", 0, 0, FALSE, 0, 0, 0, &si, &pi); .. index:: pair: appel système; fork UNIX ```` Appel système ``fork`` : crée un processus dont les caractéristiques sont *identiques* à celles du processus courant (seuls le PID et le PPID changent). → retourne une valeur différente dans le processus père et le processur fils Exemple : .. code-block:: c int pid_fils = fork(); if (pid_fils == 0) return fonction_fils(); else return fonction_père(); UNIX (2) ```````` Si on souhaite que le fils exécute un autre programme que le père, on utilise une variante de ``exec`` (qui **remplace** le programme courant par un autre programme). Exemple : .. code-block:: c int pid_fils = fork(); if (pid_fils == 0) execlp("mon_prog", "mon_prog"); // seul le père exécute la suite UNIX (3) ```````` * Chaque processus produit, lorsqu'il se termine, une valeur entière (valeur retournée par la fonction ``main``) * Cette valeur doit être récupérée par le processus parent (appel système ``wait``) * Tant que cela n'a pas été fait, les ressources du processus enfant ne peuvent pas être libérées ; le processus est dans un état particulier appelé « Zombie » (entre Élu et terminé). Comparaison ``````````` * Le modèle de Windows est plus simple à appréhender: création d'un nouveau processus « à partir de zéro ». * Le modèle d'UNIX est plus portable et évolutif : il reste valable quelles que soient les informations nécessaires à la création d'un processus.