Que se passe-t-il quand vous appuyez sur le bouton de mise en marche de votre ordinateur ? Avant que vous ne puissiez commencer à travailler, tout un ballet s’exécute…

">
Les Newsletters Interstices
zaimoku_woodpile / Flickr Licence Creative Commons BY 2.0.
    Niveau intermédiaire
    Niveau 2 : Intermédiaire

    Le ballet des processus dans un système d’exploitation

    Architecture & Systèmes
    Culture & Société

    Que se passe-t-il quand vous appuyez sur le bouton de mise en marche de votre ordinateur ? Avant que vous ne puissiez commencer à travailler, tout un ballet s’exécute…

    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

    Recevez chaque mois une sélection d'articles

    Niveau de lecture

    Aidez-nous à évaluer le niveau de lecture de ce document.

    Si vous souhaitez expliquer votre choix, vous pouvez ajouter un commentaire (Il ne sera pas publié).

    Votre choix a été pris en compte. Merci d'avoir estimé le niveau de ce document !

    Claude Kaiser

    Professeur émérite d'informatique au CNAM.

    Voir le profil

    Ces articles peuvent vous intéresser

    ArticleArchitecture & Systèmes
    Culture & Société

    À quoi sert un système d’exploitation ?

    Claude Kaiser

    Niveau facile
    Niveau 1 : Facile