Le ballet des processus dans un système d’exploitation
Dans un premier article, nous avons abordé les rôles du système d’exploitation ainsi que ses représentations statique et dynamique. Nous avons alors indiqué que la notion de processus permettait d’assurer le déroulement concomitant de plusieurs services. Un programme, rappelons-le, est la description d’un service alors qu’un processus est le déroulement et le suivi de son exécution par l’ordinateur.
L’évolution des systèmes d’exploitation des ordinateurs, depuis leur émergence voici bientôt soixante ans, s’est accompagnée de l’augmentation continue du nombre des processus.
Au début de l’informatique, il n’y avait pas de système d’exploitation et chaque utilisateur réservait la machine pour lui tout seul, pour une certaine durée.
Puis un programme moniteur a été introduit en 1955 sur une machine IBM 701 utilisée chez General Motors. Ce premier système d’exploitation n’était constitué que d’un seul processus – alors même que le terme de processus n’était pas employé – qui enchaînait, l’un après l’autre, les programmes d’un lot séquentiel ou batch. (Cette organisation été commercialisée en 1963 pour les IBM 7090/94 sous le nom d’ IBSYS.)
Deux autres processus furent ensuite ajoutés, l’un pour l’entrée des programmes, l’autre pour la sortie des résultats, créant une organisation en pipe line appelée encore spooling. (Par exemple, le système OS/360 d’IBM en 1966.)
Avec l’augmentation de la taille de la mémoire centrale, il fut possible d’y installer concomitamment plusieurs programmes et donc de dérouler plusieurs processus parallèles. Cette nouvelle organisation convenait à l’utilisation en temps partagé ou en transactionnel avec des utilisateurs interactifs, mais aussi au traitement séquentiel car, pendant les temps d’attente lors des accès d’un programme aux fichiers, elle permettait d’utiliser le processeur pour un autre programme. Le nombre des processus était limité car le temps de commutation entre processus était important. Les services fournis par le système étaient alors réalisés par des appels de procédures partagées accessibles à tous les processus. (Quelques jalons notables : en 1961, MCP de Burroughs B5000, premier système écrit en langage de haut niveau, Algol ; en 1964, Multics, un système pionnier développé au MIT ; dans les années 1970, MVS, CP-CMS, VM d’IBM ; en 1970 GCOS 64 conçu en France par Bull-GE ; en 1977, VAX/VMS de Digital.)
Puis, avec l’augmentation continue de la vitesse des processeurs et de la taille des mémoires, accompagnée par la baisse de leur coût, la commutation de processus devint moins handicapante et des architectures apparurent où les services fournis par le système étaient délégués à des processus créés pour cela. On aboutit à des systèmes ayant un plus grand nombre de petits processus, parfois appelés démons quand il s’agit des processus du système. (C’est le cas d’UNIX en 1969.)
L’accès en ligne vers les réseaux et le grand nombre de communications simultanées augmentèrent le nombre d’événements concurrents à gérer. Plutôt que d’avoir un unique processus pour répondre à tous les événements reçus, on associa alors un processus à chacun des flots d’événements. Dans un système d’exploitation contemporain cohabitent de gros processus associés aux utilisateurs et de nombreux processus de service. (Voir le système Mac OS X lancé par Apple en 2001, qui sert d’exemple dans cet article.)
On trouvera une présentation plus complète de l’histoire des systèmes d’exploitation sur Interstices dans l’article La naissance des systèmes d’exploitation par Jacques Mossière et Sacha Krakowiak.
Nous choisissons ici de présenter successivement deux groupes de processus, les uns associés aux infrastructures communes (les processus du système), les autres à la « machine virtuelle » de chacun des utilisateurs (les processus des utilisateurs). Mais avant de créer des processus, il faut mettre en place les dispositifs qui vont permettre au système de les gérer et de les faire évoluer en parallèle.
Mise en place des infrastructures communes
Au moment où on l’appuie sur le bouton de mise en marche de l’ordinateur, celui-ci reçoit l’énergie électrique qui va permettre l’amorçage du système d’exploitation. Au début, les programmes sont séquentiels car la gestion de processus n’est pas encore installée.
Cette phase séquentielle préalable à la mise en place du parallélisme se divise elle-même en plusieurs étapes.
L’amorce, petit programme séquentiel qui est câblé en binaire dans une mémoire non-modifiable (ROM ou read only memory), sert principalement à rechercher le disque (ou la clé de mémoire flash) sur lequel se trouve la suite de l’installation du système. Après avoir chargé ce programme d’installation, l’amorce lui passe la main pour qu’il continue pas à pas la genèse du système.
Le programme d’installation, séquentiel lui aussi, recense successivement les composants physiques de la machine, ceux qu’on appelle ressources physiques du système. Après avoir identifié le type et le nombre des processeurs, puis déterminé la taille de la mémoire centrale physique disponible, le programme cherche à détecter les autres dispositifs physiques et les périphériques. Cela concerne l’horloge temps réel, le jeu d’interruptions, la mémoire spéciale (appelée parfois MMU pour Memory Management Unit) qui servira au partage dynamique de la mémoire centrale, les divers disques et supports rémanents externes, la caméra, le microphone, le haut-parleur, l’émetteur-récepteur de communication sans fil, les terminaux, les écrans, les imprimantes, etc. Le programme d’installation crée la base de temps en mettant en route l’horloge temps réel. Pour les ressources physiques qu’il a reconnues, il installe les programmes d’interface capables de les piloter. Ceux-ci se prémunissent contre l’indéterminisme des réactions de ces ressources physiques par des délais de garde fournis par l’horloge.
Il faut ensuite installer le noyau du système. Celui-ci regroupe tous les programmes et données nécessaires au système pour gérer et partager les ressources matérielles recensées. Le noyau est ainsi une sorte de galerie marchande avec des ateliers pour la construction à la demande des objets logiciels qui, sous le contrôle du système d’exploitation, implantent les concepts qui président au fonctionnement du système. C’est là que sont matérialisés les processus, fichiers, catalogues, espace d’adressage ou mémoire virtuelle, canaux, boîtes aux lettres, messages, sémaphores, moniteurs, cercles de convivialité, objets de synchronisation entre processus, dispositifs basiques de sécurité et de contrôle d’accès, etc.
Pour ces objets, le noyau décrit des « gabarits », carcasses vides prédéfinies, qu’il faudra remplir à la création d’un processus, d’un fichier, d’un répertoire de fichiers ou d’un autre objet de base du système. Chaque gabarit sera renseigné avec les caractéristiques propres à l’objet particulier créé.
C’est dans le noyau qu’on installe aussi le programme de l’ordonnanceur qui devra attribuer aux processus parallèles l’utilisation des processeurs, pour un temps et à tour de rôle. À la fin de cette étape, le matériel est configuré et les composants du noyau sont prêts à servir. Les processus peuvent désormais être créés et l’on pourra passer au parallélisme.
Entrée en scène des processus et du parallélisme
Le programme d’installation met en place le programme du premier processus du système, le processus ombilical, appelé aussi processus racine (root), et crée son bloc de contrôle en utilisant un gabarit défini par le noyau.
Le « bloc de contrôle du processus » est utilisé par le système pour repérer ce processus, pour enregistrer le suivi des ressources qui lui sont momentanément allouées et pour noter l’état atteint par le déroulement de son programme. Construit suivant un gabarit défini par le noyau du système, il est au départ rempli par le processus créateur. À la création du processus, seule s’y trouve la description de ce qui doit être fait ; l’allocation des ressources matérielles – principalement processeurs et mémoires – n’est pas planifiée à l’avance. Ce bloc de contrôle est mis à jour par le système d’exploitation pour enregistrer les modifications d’allocation de ressources qui concernent ce processus.
Dans le bloc de contrôle d’un processus, on trouve principalement :
- la désignation du processus : nom, priorités d’accès aux ressources, nom du processus créateur de ce processus, nom de l’utilisateur, nom du processus premier de l’utilisateur, noms des processus créés par ce processus (cette partie sera complétée quand ils seront créés),
- la trace de l’utilisation des ressources physiques : d’une part, le dernier « contexte d’exécution » – c’est-à-dire l’état du processeur et de ses registres à la fin de sa dernière utilisation par le processus –, d’autre part, les portions de mémoire centrale qui sont attribuées momentanément à ce processus dans le cadre du partage dynamique de la mémoire,
- les noms des ressources logicielles utilisées : nom du fichier du système où est placé le programme et enregistré l’évolution des données du processus – fichier parfois appelé l’« image du processus » –, liste des fichiers utilisés et droits d’accès à ces fichiers,
- les communications autorisées entre ce processus et le reste du monde : terminal de l’utilisateur, autres processus, réseau, dispositifs physiques extérieurs – tels caméra, microphone, haut-parleur, etc.
Une fois ce processus enregistré dans le noyau et son nom placé dans la liste des processus à ordonnancer, le fonctionnement reposant sur le parallélisme peut commencer. Même s’il n’y a encore qu’un seul processus à cet instant, l’ordonnanceur est activé et il attribue le processeur au processus qui le demande, le processus ombilical. Celui-ci peut démarrer, le rôle du programme d’installation est alors terminé.
C’est désormais le processus ombilical qui poursuit la mise en place des infrastructures communes en créant les processus du système, parfois appelés démons. Il installe le démon qui gère l’utilisation de l’horloge temps réel et reçoit les signaux extérieurs qui permettent de la maintenir à l’heure du monde. Il crée les démons qui participent à la gestion dynamique de la mémoire centrale, comme le démon de pagination et le démon de va-et-vient avec le disque système. Il complète l’installation du « système de fichiers » en créant les processus qui vont gérer les fichiers et les catalogues et ceux qui autorisent une extension externe du catalogue, par le « montage » dans celui-ci de fichiers qui sont sur des supports externes. Il crée d’autres démons initiaux comme le processus de gestion des terminaux connectés, ou celui qui se charge de l’admission d’un utilisateur en lui demandant son code d’accès et son mot de passe, et bien d’autres encore selon la particularité du système d’exploitation.
Ces processus s’exécutent en mode privilégié, c’est-à-dire qu’ils ont le droit d’utiliser toutes les instructions du processeur, y compris celles qui touchent aux mécanismes de la conduite de l’ordinateur. Ils se déroulent sans filet, ce sont des processus à risque car toute erreur dans leur programmation peut entraîner la panne du système.
Lorsque le processus ombilical a terminé la mise en place des infrastructures communes, il se met en attente d’un appel par un événement nouveau. Par exemple, lorsqu’un utilisateur demandant à entrer en session aura été validé par le démon d’admission, le processus ombilical créera le processus premier de cet utilisateur, comme indiqué ci-dessous.
Tout utilisateur d’un Mac peut obtenir la liste des processus en utilisant l’application Terminal. Cette application ouvre une interface de type Unix et installe un « shell » (langage de commande). Dans ce « shell » la commande ps (« process status ») fournit la liste des processus actuels du système. On utilise plus précisément « ps -Ajc -O lstart ».
Si vous avez accès à un Mac avec le système OS X, nous vous encourageons à essayer vous-même.
Ci-dessous des extraits de la liste. Les noms des processus sont donnés par le PID (process identification) et leur créateur par PPID (parent process identification). Les utilisateurs sont donnés par USER. On obtient l’heure de création, le temps de processeur utilisé et le nom du fichier contenant le programme de départ du processus.
Pour en connaître plus sur le rôle de chaque processus, on peut utiliser la commande « man » (manuel) avec le nom de fichier de démarrage. Par exemple le fichier « launchd » apparaît dans le processus ombilical et les processus premiers. La commande « man launchd » est documentée comme « launchd manages processes, both for the system as a whole and for individual users. During boot, launchd is invoked by the kernel to run as the first process on the system and to further bootstrap the rest of it ».
Attention : pour sortir de « man », il faut taper « ctrl z » ou « q ».
En tête, on obtient la liste des processus du système, chargés des infrastructures.
Les processus du système sont créés par l’utilisateur root. Le processus ombilical est le processus 1 (PID = 1) et a été créé par l’amorce de nom fictif 0 (PPID = 0). Ensuite les processus système (PID de 1 à 150) sont créés par ce processus ombilical (PPID = 1). Le processus 150 est le processus premier de l’utilisateur claude. Ici, le système a été amorcé le 28 novembre de 14 h 33 mn 51 s à 14 h 34 mn 41 s.
MacBook-de-Claude-KAISER:~ claude$ ps -Ajc -O lstart
USER PID PPID DATE DE CRÉATION TEMPS & COMMANDE COMMENTAIRES
root 1 0 Jeu 28 nov 14:33:51 2013 0:26.96 launchd Processus ombilical
root 10 1 Jeu 28 nov 14:33:56 2013 0:01.26 kextd Installe les extensions système
root 11 1 Jeu 28 nov 14:33:56 2013 0:00.97 notifyd Gestion des notificati
root 12 1 Jeu 28 nov 14:33:57 2013 0:00.34 diskarbitrationd Supervision des disques
root 13 1 Jeu 28 nov 14:33:57 2013 0:04.86 configd Gestion de configuration
root 14 1 Jeu 28 nov 14:33:57 2013 0:00.53 syslogd Archivage pour le système
root 15 1 Jeu 28 nov 14:33:57 2013 0:09.68 sDirectoryService Gestion de catalogues de fichier
root 16 1 Jeu 28 nov 14:33:57 2013 0:01.39 blued Agent Bluetooth
daemon 17 1 Jeu 28 nov 14:33:57 2013 0:01.37 distnoted Distribution des notifications
root 19 1 Jeu 28 nov 14:34:01 2013 0:01.79 ntpd Heure par NTP network time protocol
root 20 1 Jeu 28 nov 14:34:01 2013 0:00.06 cron Gère les tables de l’ordonnanceur
usbmuxd 24 1 Jeu 28 nov 14:34:01 2013 0:00.20 usbmuxd Synchronisation des iPod/iPhon
root 25 1 Jeu 28 nov 14:34:02 2013 0:00.14 SystemStarter Management du Système
root 27 1 Jeu 28 nov 14:34:02 2013 0:00.02 rpc.statd Enregistre l’état des hôtes distants
root 28 1 Jeu 28 nov 14:34:02 2013 0:00.58 securityd Cryptographie et contrôle d’accès
root 31 1 Jeu 28 nov 14:34:02 2013 0:00.03 nfsd Serveur fichiers réseau NFS
root 32 1 Jeu 28 nov 14:34:02 2013 5:00.35 mds Serveur de métadonnées
mdnsresponder 33 1 Jeu 28 nov 14:34:02 2013 0:02.33 mDNSResponder Diffusion pour DNS dans internet
claude 34 1 Jeu 28 nov 14:34:02 2013 0:06.75 loginwindow Fenêtre du login
root 35 1 Jeu 28 nov 14:34:02 2013 0:00.29 KernelEventAgent Envoie des messages à l’utilisateur
root 37 1 Jeu 28 nov 14:34:02 2013 1:00.53 hidd Services IHM interface homme machine
root 38 1 Jeu 28 nov 14:34:02 2013 0:32.27 fseventsd Utilitaire pour sauvegarde Time machine
root 40 1 Jeu 28 nov 14:34:02 2013 0:00.01 dynamic_pager Gère le disque de pagination
root 47 1 Jeu 28 nov 14:34:02 2013 0:00.14 autofsd Montage de disques réseau
root 51 1 Jeu 28 nov 14:34:02 2013 0:01.04 lsd Agent pour Little Snitch
root 62 1 Jeu 28 nov 14:34:20 2013 0:00.01 rpc.lockd Verrouillage de fichiers NFS
root 63 1 Jeu 28 nov 14:34:20 2013 0:00.00 rpc.statd Coopère avec les hôtes distants
daemon 64 1 Jeu 28 nov 14:34:21 2013 0:00.01 portmap Fournit l’adresse d’un RPC
root 66 62 Jeu 28 nov 14:34:21 2013 0:00.00 rpc.lockd Verrouillage de fichiers NFS
root 67 1 Jeu 28 nov 14:34:21 2013 0:00.02 rpc.rquotad Gère les quotas sur les fichiers distants
root 94 1 Jeu 28 nov 14:34:23 2013 0:07.27 coreservicesd Gère des appels API vers le noyau
root 95 1 Jeu 28 nov 14:34:24 2013 0:00.06 vmnet-natd Proxy de réseau virtuel VMNET
windowsever 103 1 Jeu 28 nov 14:34:24 2013 10:19.37 WindowServer Agent pour l’environnement graphique
root 104 1 Jeu 28 nov 14:34:25 2013 0:00.03 vmnet-dhcpd Configuration dynamique dans VMNET
root 106 1 Jeu 28 nov 14:34:25 2013 0:00.00 vmnet-netifup Agent pour VMNET
root 109 1 Jeu 28 nov 14:34:25 2013 0:00.00 vmnet-netifup Agent pour VMNET
root 113 1 Jeu 28 nov 14:34:26 2013 0:00.03 vmnet-dhcpd Configuration dynamique dans VMNET
root 115 1 Jeu 28 nov 14:34:26 2013 0:00.13 vmnet-bridge Liaison entre réseaux virtuels
root 130 1 Jeu 28 nov 14:34:28 2013 0:00.02 cvmsServ Participe à la gestion graphique
coreaudio 144 1 Jeu 28 nov 14:34:30 2013 0:00.40 coreaudiod Pilote de périphériques audio
claude 150 1 Jeu 28 nov 14:34:41 2013 0:00.67 launchd Processus premier de claude
La suite des processus, après l’entrée en session, est présentée dans l’encart suivant.
Les processus de la machine virtuelle d’un utilisateur
Quand un utilisateur est admis à se servir de l’ordinateur, donc à entrer en session, le système crée un processus, le « processus premier » qui est chargé de remplir le premier rôle imparti au système d’exploitation : créer une « machine virtuelle ». Celle-ci a pour objet de faciliter l’utilisation des programmes et des fichiers, de soigner le dialogue à l’écran et les accès avec le monde extérieur. Le processus premier utilise le profil de l’utilisateur et la description de son environnement de travail qui ont été gardés dans un fichier du système, et qu’il modifie si besoin est. Il peut ainsi particulariser le mode de dialogue avec chaque utilisateur. Il trouve dans ce fichier, entre autres, l’accès vers les fichiers de l’utilisateur, vers les applications que celui-ci pourra utiliser, la description de l’organisation de la fenêtre sur l’écran.
Ce processus premier orchestre la mise en place de processus qu’il crée et détruit au fur et à mesure des besoins concomitants, explicites et implicites, de cet utilisateur. Ce sont en particulier des processus pour l’édition, l’analyse et l’exécution de commandes, la gestion de l’écran, du clavier, de la souris et de l’écran tactile. Ce sont aussi des processus qui assurent les aspects logiques de l’accès aux fichiers, à l’imprimante, au réseau et dialoguent avec les processus du système qui pilotent les aspects technologiques de l’accès au matériel et au réseau. Dans la fenêtre du processus premier, l’utilisateur trouve sur l’écran, soit dans des menus, soit sous forme d’icônes, la liste de ses fichiers et des applications qu’il peut utiliser comme, par exemple : navigateur, courriel, écoute de musique, classement de photos, édition de texte, compilation, comptabilité, application industrielle spécifique ou encore programme que l’utilisateur a lui-même écrit et compilé.
Quand l’utilisateur « ouvre » l’une de ces applications, le processus premier prépare un processus ad hoc qui va être associé à cette nouvelle application. Pour cela, il renseigne le bloc de contrôle de ce processus, en particulier le nom du programme binaire à exécuter et ses données initiales. Le programme de l’application peut se trouver dans un fichier unique, prêt à être exécuté par le processeur, en binaire. Il peut aussi être formé d’un ensemble de composants situés dans divers fichiers. Mais, pour paraphraser Henri Poincaré, une accumulation de composants n’est pas plus un programme qu’un tas de pierres n’est une maison. (« On fait la science avec des faits, comme une maison avec des pierres ; mais une accumulation de faits n’est pas plus une science qu’un tas de pierre n’est une maison. » H. Poincaré, La science et l’hypothèse, 1902)
Certains de ces composants exportent des fonctions, des données ou des définitions, d’autres ont besoin d’en importer. Il faut les interconnecter, nouer des liens entre eux pour qu’ils puissent fonctionner ensemble comme un tout. Cette « édition de liens » permet à tout programme d’utiliser la bibliothèque des programmes de service proposés par le système d’exploitation et partageables.
Quand le processus de l’application considérée démarre, une nouvelle fenêtre de dialogue apparaît à l’écran et se superpose à la fenêtre ouverte par le processus premier et aux fenêtres déjà ouvertes. Ce nouveau processus est sous la houlette du processus premier. Pour permettre du parallélisme dans cette application, le nouveau processus créera d’autres processus, un par service concurrent : réception du courriel, émission du courriel, gestion d’une nouvelle fenêtre de dialogue sur l’écran, émission de messages vers le réseau, réception de messages provenant du réseau, etc. Quand l’utilisateur « quitte » une application, le processus premier détruit les processus qu’il a créés et qui ne sont plus utiles.
Pour illustrer la vision dynamique du système d’exploitation, plaçons-le dans une situation raisonnablement complexe. Après le démarrage de l’ordinateur, entrons en session et ouvrons un certain nombre d’applications (Safari, Mail, Aperçu, Carnet d’adresses, Adobe Reader, TextEdit, iPhoto, Calculette, Terminal…) et plusieurs fenêtres dans certaines d’entre elles. Nous demandons aussi une impression.
Ci-dessous les processus gérant la machine virtuelle du premier utilisateur en session, ainsi que la liste des processus de cet utilisateur pour les applications qu’il a ouvertes. Ils sont créés
par son processus premier (PID : 150 ; PPID : 1) ou par le système (USER : root).
USER PID PPID DATE DE CRÉATION TEMPS & COMMANDE COMMENTAIRES
claude 150 1 Jeu 28 nov 14:34:41 2013 0:00.67 launchd Processus premier de claude
claude 154 150 Jeu 28 nov 14:34:41 2013 0:09.59 Dock Utilitaire Dock
claude 156 150 Jeu 28 nov 14:34:41 2013 11:20.80 Finder Gestion des commandes
claude 158 150 Jeu 28 nov 14:34:42 2013 0:00.01 pboard Serveur de couper-coller
claude 159 150 Jeu 28 nov 14:34:42 2013 0:03.71 fontd Serveur des polices de caractères
claude 167 150 Jeu 28 nov 14:34:42 2013 0:00.87 UserEventAgent Gère des événements pour l’utilisateur
claude 175 150 Jeu 28 nov 14:34:42 2013 0:00.22 AirPort Base Sta Agent AirPort
claude 177 150 Jeu 28 nov 14:34:42 2013 0:01.93 Little Snitch UI Agent Little Snitch
claude 181 150 Jeu 28 nov 14:34:43 2013 0:00.21 TISwitcher Allocation du clavier à un processus
claude 190 150 Jeu 28 nov 14:34:44 2013 0:01.44 EyeTV Helper Application EyeTV
claude 219 150 Jeu 28 nov 14:45:00 2013 1:43.51 SystemUIServer Gère l’interface système de l’utilisateur
claude 811 150 Jeu 28 nov 21:53:56 2013 0:00.13 AppleSpell Vérifie la syntaxe des commandes
claude 1620 150 Sam 30 nov 15:04:22 2013 7:13.49 LaunchCFMApp Gère les cookies (témoin de connexion)
claude 1631 150 Sam 30 nov 15:04:29 2013 0:02.92 LaunchCFMApp Gère les cookies (témoin de connexion)
root 1663 1 Sam 30 nov 15:59:00 2013 0:00.05 cupsd Démon d’impression
claude 1665 150 Sam 30 nov 16:02:10 2013 0:00.72 Terminal Agent de l’application Terminal
root 1667 1665 Sam 30 nov 16:02:10 2013 0:00.03 login Contrôle l’accès à Terminal
claude 1668 1667 Sam 30 nov 16:02:10 2013 0:00.01 bash Langage de commande pour Terminal
claude 1673 1 Sam 30 nov 16:02:26 2013 0:00.08 mdworker Serveur de métadonnées pour fichier
Root 1676 1668 Sam 30 nov 16:03:34 2013 0:00.00 ps Commande ps appelée par bash
Cet environnement de travail de l’utilisateur, qui évolue pendant la session, est sauvegardé en permanence sur une mémoire rémanente, tel le disque, dans la base de données du système, pour pouvoir être retrouvé si l’utilisateur quitte l’ordinateur avant d’avoir déclaré la fin de la session ou en cas de panne. En fin de session, le processus premier et les autres processus qui ont été créés pour cette machine virtuelle sont détruits.
Il arrive qu’un système d’exploitation permette plusieurs utilisateurs successifs ou simultanés, chacun avec son écran. C’est le cas par exemple dans une conduite industrielle en temps réel ou dans le service informatique d’une entreprise. Chaque utilisateur est alors gratifié d’un processus premier et d’un environnement de travail dans une fenêtre spécifique.
On crée ensuite une seconde session, avec par exemple le compte d’invité, et on y ouvre aussi plusieurs applications et fenêtres.
Ci-dessous, les processus gérant la machine virtuelle du second utilisateur en session, ainsi que les processus de cet utilisateur (USER : guest). Ils sont créés par son processus premier (PID : 1718 ; PPID : 1) ou par le système (USER : root).
USER PID PPID DATE DE CRÉATION TEMPS & COMMANDE COMMENTAIRES
Guest 1717 1 Sam 30 nov 16:29:34 2013 0:00.29 mdworker Serveur de métadonnées pour fichier
Guest 1718 1 Sam 30 nov 16:29:34 2013 0:00.11 launchd Processus premier
Guest 1723 1718 Sam 30 nov 16:29:35 2013 0:00.01 pboard Serveur de couper-coller
Guest 1727 1718 Sam 30 nov 16:29:35 2013 0:01.66 Dock Utilitaire Dock
Guest 1728 1718 Sam 30 nov 16:29:35 2013 0:00.61 SystemUIServer Gère l’interface système de l’utilisateur
Guest 1729 1718 Sam 30 nov 16:29:35 2013 0:00.40 Finder Gestion des commandes
Guest 1731 1718 Sam 30 nov 16:29:36 2013 0:00.20 fontd Serveur des polices de caractères
Guest 1743 1718 Sam 30 nov 16:29:40 2013 0:00.54 UserEventAgent Gère des événements pour l’utilisateur
Guest 1751 1718 Sam 30 nov 16:29:40 2013 0:00.06 AirPort Base Stati Agent AirPort
Guest 1753 1718 Sam 30 nov 16:29:40 2013 0:00.10 Little Snitch UIAag Agent Little Snitch
Guest 1756 1718 Sam 30 nov 16:29:40 2013 0:00.04 TISwitcher Allocation du clavier à un processus
root 1757 1 Sam 30 nov 16:29:41 2013 0:00.03 taskgated Contrôle les appels interprocessus
Guest 1759 1718 Sam 30 nov 16:29:41 2013 0:00.01 CCacheServer Serveur de mémorisation en cache
Guest 1762 1718 Sam 30 nov 16:29:45 2013 0:00.63 quicklookd Application Quick Look
Guest 1768 1718 Sam 30 nov 16:29:50 2013 0:01.59 SyncServer Serveur d’objets de synchronisation
Guest 1771 1718 Sam 30 nov 16:29:52 2013 0:00.42 Safari Navigateur Safari
Guest 1774 1771 Sam 30 nov 16:29:54 2013 0:00.19 WebProcess Agent Web pour Safari
Guest 1775 1718 Sam 30 nov 16:29:55 2013 0:00.69 Mail Courrier électronique
Guest 1777 1718 Sam 30 nov 16:29:55 2013 0:00.03 PubSubAgent Agent de synchronisation des flux RSS
Guest 1791 1718 Sam 30 nov 16:30:02 2013 0:00.51 App Store Application Web Apple Store
Guest 1793 1718 Sam 30 nov 16:30:03 2013 0:00.58 cvmsComp_x86_64 Participe à la gestion graphique 64 bits
Guest 1795 1718 Sam 30 nov 16:30:04 2013 0:00.07 storeagent Recherche les mises à jour Apple
Guest 1801 1718 Sam 30 nov 16:30:09 2013 0:00.46 Preview Application Aperçu
Guest 1812 1718 Sam 30 nov 16:30:29 2013 0:00.53 iCal Agenda
Guest 1815 1718 Sam 30 nov 16:30:31 2013 0:00.84 Address Book Carnet d’adresses
Lorsque le système est un hyperviseur qui permet de faire cohabiter des systèmes d’exploitation différents sur le même ordinateur, l’amorçage de l’hyperviseur va consister à installer les systèmes hôtes pour qu’ils aient la faculté d’utiliser et de gérer les ressources communes (et les interruptions correspondantes). On a alors une abstraction de plus dans l’architecture du système. Dans ce cas, le processus premier devient le programme d’installation du système hôte.
Contrairement aux processus du système, les processus de la machine virtuelle d’un utilisateur ne s‘exécutent pas en mode privilégié, mais en mode utilisateur, ce qui ne leur donne pas accès aux mécanismes sensibles de l’ordinateur. Des fautes dans leur programmation ne peuvent entraîner que la panne de la machine virtuelle. Pour accéder aux ressources physiques communes, ils doivent faire appel à des processus du système.
Complexité et sécurité
La complexité des systèmes d’exploitation résulte tant du nombre et de la taille des programmes impliqués que de la multiplicité des processus et de leurs interactions.
Les processus qui s’exécutent en parallèle se déroulent de manière asynchrone, c’est-à-dire que chacun des processus a une évolution indépendante. Mais ces processus ne sont pas totalement indépendants : ils doivent se synchroniser à des instants donnés pour pouvoir coopérer. Ainsi ils peuvent être conduits à enchaîner des actions faites séparément par chacun d’eux, à se communiquer des messages, à collaborer pour conserver la cohérence des données partagées (modifiables par plusieurs d’entre eux), à coordonner leur compétition d’accès aux ressources, à établir des consensus pour prendre des décisions collectives qui font évoluer l’état global du système. Tout cela relève de la programmation parallèle avec des algorithmes de synchronisation qui sont délicats à maîtriser et d’autant plus complexes qu’il y a un nombre important de processus.
Pour la sûreté de l’exécution, on contourne cette complexité par une conception architecturale qui suit un découpage hiérarchique des programmes et on restreint autant que possible les pouvoirs d’un processus. Un des premiers mécanismes câblés a été spécialement inventé pour permettre l’utilisation du processeur selon deux modes bien distincts : mode privilégié et mode utilisateur.
Certains processus, au niveau du système, doivent avoir accès à toutes les instructions du processeur, y compris celles qui utilisent les dispositifs spéciaux de la conduite de l’ordinateur ou qui permettent de détruire d’autres processus. Leurs programmes s’exécutent en mode dit « privilégié ». Ils doivent être sans faute car toute panne d’un de ces processus peut détruire le système. Les autres processus, comme les processus premiers ou les processus d’application, s’exécutent en mode utilisateur, c’est-à-dire sans avoir accès aux instructions privilégiées. Ils se déroulent sous la surveillance du noyau et de processus du système qui peuvent circonscrire les effets des erreurs de leurs programmes et protéger le système contre leurs pannes.
D’autres mécanismes câblés ou programmés ont été inventés pour isoler les processus les uns des autres, protéger les accès aux informations et aux ressources partagées, fiabiliser la synchronisation entre les processus, partager dynamiquement la mémoire centrale et sauvegarder l’état du travail de chaque processus. Mais la grande complexité des systèmes rend illusoire le « zéro défaut » ! Pour augmenter leur sûreté, il faut s’attacher à réduire les fautes de conception, combattre les erreurs de programmation et circonscrire la propagation de celles qui entraînent des arrêts intempestifs ou la panne fatale du système.
Complexité de la conception et sécurité de l’exécution sont les défis actuels pour les concepteurs qui continuent à développer des systèmes d’exploitation. On applique évidemment les meilleures techniques du génie logiciel. On reconsidère également l’architecture des systèmes : on essaie, notamment, de restreindre la taille du noyau et celle des processus du système qui ont tous les droits sur la conduite de l’ordinateur, en reportant le plus d’actions possibles vers des processus se déroulant en mode utilisateur. Cette diminution de taille permet d’améliorer la qualité et ouvre la voie à des techniques automatiques de preuve de programme et à la certification des systèmes d’exploitation.
Newsletter
Le responsable de ce traitement est Inria. En saisissant votre adresse mail, vous consentez à recevoir chaque mois une sélection d'articles et à ce que vos données soient collectées et stockées comme décrit dans notre politique de confidentialité
Niveau de lecture
Aidez-nous à évaluer le niveau de lecture de ce document.
Votre choix a été pris en compte. Merci d'avoir estimé le niveau de ce document !
