%--------------------------------------------------------------------
\chapter{Vue d'ensemble d'un système Linux}
\label{chap:overview}
%--------------------------------------------------------------------

        \begin{chapterquote}
	Dieu regarda tout ce qu'Il avait fait,\\
	et Il vit que cela était bon.\\
	La Genèse 1:31 \\
        \end{chapterquote}

	\noindent
	Ce chapitre donne une vue d'ensemble d'un système Linux. Les principaux services fournis par
le système d'exploitation sont d'abord décrits. Puis, les programmes qui fournissent ces services sont 
évoqués avec un manque considérable de détails. Le propos de ce chapitre est de fournir une compréhension
du système comme un tout, chaque partie de celui-ci étant décrite en détail quelque part.

\section{Les différentes parties d'un système d'exploitation}

	Un système UNIX consiste en un \defin{noyau} et des
	\defin{programmes système}. Il y a aussi quelques \defin{programmes d'application} pour travailler. Le
noyau est le c\oe ur du système d'exploitation\footnote{En fait, une erreur classique est de considérer
le noyau comme étant le système d'exploitation, ce qui n'est pas le cas. Un système d'exploitation fournit 
beaucoup plus de services qu'un noyau.} Il s'occupe des fichiers sur le disque, lance les programmes et les
fait s'exécuter ensemble, alloue la mémoire et les autres ressources aux différents processus, reçoit et envoie les
paquets de données sur le réseau, etc. Le noyau fait très peu de choses par lui-m\^eme, mais il fournit les outils par lesquels
tous les services peuvent \^etre construits. Il interdit aussi à quiconque d'accéder directement au matériel, 
l'obligeant à utiliser les outils qu'il fournit. De cette façon, le noyau fournit une protection pour chaque
utilisateur, et les protège les uns des autres. Les outils fournis par le noyau sont utilisés via 
des \defin{appels système} ; voir la section 2 des pages du manuel en ligne pour plus d'informations sur ces
appels.
\index{noyau}
\index{système d'exploitation}
\index{programme système}
\index{programme d'application}
\index{appel système}

	Les programmes systèmes utilisent les outils fournis par le noyau pour implanter les différents
services requis par un système d'exploitation. Les programmes systèmes, et tous les autres programmes, s'exécutent
 << au-dessus >> du noyau, dans ce qu'on appelle le \defin{mode utilisateur}.
	La différence entre les programmes systèmes et d'appli\-cation concerne leur but~: les applications
sont destinées à fournir une aide pour réaliser des choses (ou pour jouer, s'il s'agit d'un jeu), tandis
que les programmes systèmes sont nécessaires au fonctionnement du système. Un traitement de texte est
une application ; \cmd{telnet} est un programme système.
	La différence est parfois subtile cependant, et n'est importante que pour ceux qui veulent classifier
à tout prix.
\index{mode utilisateur}

	Un système d'exploitation peut aussi fournir des compilateurs et les bibliothèques qui
leur sont liées (notamment GCC et la bibliothèque C sous Linux), bien que tous les langages de
programmation n'aient pas besoin de faire partie du système d'exploitation. De la documentation, 
et parfois m\^eme des jeux, peuvent aussi \^etre inclus. Traditionnellement, le système d'exploitation
est défini par le contenu des disques ou des cartouches d'installation ; avec Linux, c'est moins clair 
puisqu'il est diffusé à travers les sites FTP du monde entier.
\index{GCC}
\index{langages de programmation}
\index{compilateur C}
\index{documentation}
\index{jeux}

\section{Parties importantes du noyau}

	Le noyau Linux se décompose en plusieurs parties importantes~: gestion des pro\-ces\-sus, gestion de
la mémoire, pilotes matériels, système de gestion de fichiers, gestion du réseau, et différentes autres 
petites pièces. La figure~\ref{fig:kernel-overview} présente certaines d'entre elles.
\index{gestion de processus}
\index{gestion de la mémoire}
\index{pilote matériel}
\index{système de gestion de fichier}
\index{gestion de réseau}

\begin{figure}[htb]
\begin{center}
\includegraphics{overview/overview-kernel.ps}
\end{center}
\caption{Quelques unes des parties les plus importantes du noyau Linux.}
\label{fig:kernel-overview}
\end{figure}

	Les parties probablement les plus importantes du noyau (rien d'autre ne marche sans elles) sont la
gestion de la mémoire et la gestion des processus. La gestion de la mémoire s'occupe d'allouer les
zones mémoire et l'espace de swap aux processus, aux parties du noyau et au cache du tampon.
La gestion des processus crée les processus, et implante le multi-t\^ache en commutant le processus
actif vers le processeur.
\index{espace de swap}
\index{cache du tampon}
\index{multi-t\^aches}

	Au niveau le plus bas, le noyau contient un pilote matériel pour chaque type de matériel pris
en charge. Le monde étant plein de matériels de toutes sortes, le nombre de ces pilotes est très grand.
Il y a aussi souvent des parties matérielles qui diffèrent seulement par la façon dont elles
sont gérées par les logiciels. Ces ressemblances rendent possible une classification générale des
pilotes qui font  des opérations similaires ; tous les membres d'une classe ont la m\^eme interface
pour le reste du noyau mais diffèrent dans leur implantation. Par exemple, tous les pilotes disque
se ressemblent pour le noyau, i.e. ils ont tous les m\^emes opérations comme << initialiser le
lecteur >>, << lire le secteur N >>, et << écrire le secteur N >>.

	Certains services logiciels fournis par le noyau lui-m\^eme ont des propriétés simi\-lai\-res, et
peuvent donc \^etre abstraits sous forme de classes. Par exemple, les différents protocoles réseau ont
été abstraits en une seule interface de programmation, la bibliothèque des sockets BSD.
Un autre exemple est la couche du \defin{système de fichiers virtuel} (VFS) qui abstrait les opérations
du système de fichier de leur implantation. Chaque type de système de fichiers fournit une implantation
de chacune des opérations requises. Lorsqu'on utilise un système de fichiers, la requ\^ete
passe par le VFS qui dirige celle-ci vers le bon gestionnaire.
\index{système de fichiers virtuel}
\index{BSD}
\index{socket}

\section{Services principaux dans un système UNIX}

	Cette section décrit rapidement quelques services UNIX parmi les plus importants.
Ils seront décrits plus en profondeur dans les chapitres suivants.

\subsection{\cmd{init}}

	Le service le plus important d'un système UNIX est fourni par
	\cmd{init}.  \cmd{init} est lancé comme premier processus de tout système UNIX. C'est la dernière
chose que fait le noyau lorsqu'il démarre. Quand \cmd{init} se lance, il continue la procédure de
démarrage en effectuant différentes t\^aches (vérification et montage des systèmes de fichiers,
démarrage des démons, etc).
\index{/sbin/init}
\index{montage des systèmes de fichiers}
\index{procédure de démarrage}

	La liste exacte de ce que fait \cmd{init} dépend de la façon dont il est configuré ; il y a 
plusieurs choix à faire. \cmd{init} fournit généralement le concept de \defin{mode simple utilisateur}, dans
lequel personne ne peut se logger et dans lequel \cmd{root} utilise un shell sur la console ; le mode
habituel est appelé \defin{mode multi-utilisateurs}. Plusieurs configurations généralisent cela en
\defin{niveaux d'exécution} ; les modes simple et multi-utilisateurs sont considérés comme deux niveaux
d'exécution différents et il peut, bien s\^ur, y en avoir d'autres, par exemple pour lancer X sur la
console.
\index{niveau d'exécution}
\index{mode simple utilisateur}
\index{mode multi-utilisateurs}
\index{Système X Window}

	En temps normal, \cmd{init} s'assure que les \cmd{getty}s sont lancés (pour permettre aux
utilisateurs de se logger), et adopte les processus orphelins (les processus dont les parents
ont été tués ; sous UNIX, \emph{tous} les processus \emph{doivent} \^etre dans la m\^eme arborescence, les
orphelins doivent donc \^etre adoptés).

	Quand le système est arr\^eté, c'est \cmd{init} qui se charge de détruire tous les autres
processus, de démonter tous les systèmes de fichiers et d'arr\^eter le processeur, en plus de tout ce
que sa configuration lui ordonne de faire.
\index{destruction de processus}
\index{démontage de système de fichiers}
\index{arr\^et du processeur}

\subsection{Logins sur les terminaux}

	Les logins sur les terminaux (via des liaisons séries) et sur la console (lorsque X ne tourne pas) sont
fournis par le programme \cmd{getty}.  \cmd{init}
	lance un exemplaire distinct de \cmd{getty} pour chaque terminal permettant un accès login.
	\cmd{getty} lit l'identifiant de l'utilisateur, et lance le programme
	\cmd{login}, qui lit le mot de passe. Si les deux sont corrects,
	\cmd{login} lance le shell.  Lorsque ce shell se termine, i.e., quand l'utilisateur se délogge, ou
quand \cmd{login} se termine parce que l'identifiant de l'utilisateur et le mot de passe ne correspondent pas, 
	\cmd{init} le note et lance un nouvel exemplaire de \cmd{getty}.
Le noyau ne connaît pas les logins, tout cela est géré par les programmes systèmes.
\index{/sbin/getty}
\index{login}
\index{logout}
\index{vérification de l'utilisateur}

\subsection{Syslog}

	Le noyau, et beaucoup de programmes systèmes, produisent des messages d'erreurs, des avertissements et
d'autres messages. Souvent, il est important de pouvoir relire ces messages plus tard, m\^eme bien plus tard. Ces
messages doivent donc \^etre écrits dans un fichier. Le programme qui est chargé de cette t\^ache s'appelle
\cmd{syslog}.  Il peut \^etre configuré pour trier les messages dans différents fichiers selon celui qui
les produit, ou selon le degré de sévérité. Par exemple, les messages du noyau sont souvent redirigés dans
un fichier à part puisqu'ils sont généralement plus importants et ont besoin d'\^etre lus régulièrement
pour identifier les problèmes.
\index{messages d'erreur}
\index{messages d'avertissement}
\index{fichier log}

\subsection{Exécution périodique d'une commande~: \cmd{cron} et \cmd{at}}

	Les utilisateurs, comme les administrateurs système, ont souvent besoin  de lancer des
commandes périodiquement. Par exemple, l'administrateur système peut vouloir lancer une commande
pour supprimer les fichiers temporaires des répertoires sensés les contenir (\fn{/tmp} et \fn{/var/tmp}) afin
d'éviter que les disques ne se remplissent puisque les programmes ne font pas tous le ménage correctement.
\index{exécution périodique d'un programme|see{cron et at}}
\index{fichiers temporaires}
\index{suppression des fichiers temporaires}

	Le service \cmd{cron} est fait pour cela. Chaque utilisateur possède un fichier
	\cmd{crontab} où il énumère les commandes qu'il veut exécuter et le moment où elles doivent 
l'\^etre. Le démon \cmd{cron} se charge de lancer les commandes au moment voulu.
\index{démons!cron|see{cron}}

	Le service \cmd{at} ressemble à \cmd{cron}, mais il ne s'exécute qu'une seule fois~: la commande
est exécutée au moment voulu, mais elle n'est pas répétée.
\index{démons!at|see{at}}

\subsection{Interface graphique utilisateur}

	UNIX et Linux n'intègrent pas d'interface graphique dans le noyau ; au contraire, ils laissent le
soin de l'implanter aux programmes du niveau utilisateur. Ceci s'applique aussi bien au mode texte qu'aux
environnements graphiques.

	Cette façon de faire rend le système plus flexible, mais a le désavantage de permettre des
implantations d'interfaces
utilisateur différentes pour chaque pro\-gram\-me, rendant ainsi le système plus difficile à comprendre.. 

	L'environnement graphique utilisé avec Linux est appelé Système X Window (X, pour faire court). X, non 
plus, n'implante pas d'interface utilisateur ; il implante seulement un système de fen\^etres, i.e. des outils
avec lesquels une interface utilisateur graphique peut \^etre créée. Les trois styles d'interface utilisateur
les plus populaires implantés sur X sont Athena, Motif et Open Look.
\index{Interface graphique utilisateur}
\index{Système X Window}
\index{Athena}
\index{Motif}
\index{Open Look}

\subsection{Travailler en réseau}

	Travailler en réseau consiste à connecter 2 ordinateurs, ou plus,  afin qu'ils puissent communiquer
les uns avec les autres. Les méthodes actuelles de connexion et de communication sont plut\^ot compliquées mais
le résultat final est très utile.

	Les systèmes d'exploitation UNIX disposent de beaucoup de caractéristiques réseau. La plupart des
services de base~--~systèmes de gestion de fichiers, impressions, sauvegardes, etc.~-- peuvent \^etre 
réalisés sur le réseau. Ceci peut rendre l'admi\-nis\-tra\-tion système plus facile, puisque cela permet une
administration centralisée, tout en récupérant les bénéfices de la micro-informatique et de l'informatique
distribuée, comme des co\^uts plus bas et une meilleure tolérance aux fautes.
\index{administration centralisée}
\index{informatique distribuée}
\index{tolérance aux fautes}

	Cela dit, ce livre ne fait que survoler les problèmes liés aux réseaux ; lisez le Guide de
l'administrateur Réseau sous Linux pour plus d'informations. Vous y trouverez, entre autres, une description
du fonctionnement des réseaux.

\subsection{Logins à distance}

	Les logins à distance fonctionnent un peu différemment des logins normaux. Il y a une ligne série
physique pour chaque terminal par lequel il est possible de se logger. Pour chaque personne se loggant
via le réseau, il y a une connexion virtuelle au réseau, et il peut y en avoir un nombre quelconque\footnote{Du
moins,  il peut y en avoir beaucoup. La bande passante d'un réseau étant une ressource rare, il 
y a quand m\^eme une limite supérieure critique au nombre de logins simultanés sur une m\^eme connexion.}. 
Il n'est donc pas possible de lancer un	\cmd{getty} distinct pour chaque connexion virtuelle possible. Il 
existe aussi plusieurs moyens différents de se logger à distance, \cmd{telnet} et \cmd{rlogin} étant
les principaux dans le cas des réseaux TCP/IP.

	Les logins à distance utilisent, plut\^ot qu'un troupeau de \cmd{getty}s, un simple démon spécifique
au type de login (\cmd{telnet} et \cmd{rlogin} ont des démons distincts). Ce démon écoute toutes les tentatives entrantes
de login, quand il en repère une, il lance une de ses instances pour gérer cette tentative ; l'instance
originale  continuant à écouter les autres tentatives. La nouvelle instance fonctionne de la m\^eme 
façon que \cmd{getty}.
\index{démons!telnet|see{telnet}}
\index{démons!rlogin|see{rlogin}}

\subsection{Système de fichiers en réseau}

	L'une des choses les plus utiles que l'on puisse faire avec les services réseau est de partager des
fichiers à travers un \defin{système de fichiers en réseau}. Celui le plus utilisé est développé par Sun, et
appelé Network File System, ou NFS.
\index{NFS}
\index{système de fichiers en réseau}
\index{Network File System|see{NFS}}

	Avec un système de fichiers en réseau, toutes les opérations sur les fichiers réalisées par un programme sur une machine sont envoyées par le réseau sur un autre ordinateur. Cela conduit le programme à croire
que tous les fichiers de l'autre ordinateur sont, en fait, sur l'ordinateur où il s'exécute. Ceci simplifie 
grandement le partage des informations puisque cela ne nécessite aucune modification des programmes.

\subsection{Le courrier électronique}

	Le courrier électronique (e-mail) est, généralement, la méthode la plus utilisée pour communiquer au moyen 
d'un ordinateur. Une lettre électronique est stockée dans un fichier selon un certain format, et des
programmes spéciaux sont utilisés pour envoyer et lire les lettres.
\index{communication}
\index{e-mail|see{courrier électronique}}
\index{courrier, électronique|see{courrier électronique}}
\index{courrier électronique}
\index{lettre|see{courrier électronique}}

	Chaque utilisateur a une \defin{bo\^\i te aux lettres} (un fichier dans un format spécial)
où tout nouveau courrier arrivé est stocké. Lorsque quelqu'un envoie du courrier, le programme de
courrier localise la bo\^\i te aux lettres du destinataire et y ajoute la lettre.
Si cette bo\^\i te aux lettres est sur une autre machine, la lettre est envoyée à celle-ci qui
la délivrera dans les meilleures conditions.
\index{bo\^\i te aux lettres}
\index{bo\^\i te aux lettres de réception}

	Le système de courrier consiste en plusieurs programmes. La délivrance du courrier dans les  bo\^\i tes 
aux lettres locales ou distantes est réalisée par un programme (l'\defin{agent de transfert de courrier} 
ou \defin{MTA}), par exemple,\cmd{sendmail} ou \cmd{smail}, alors que les programmes avec lesquels les utilisateurs 
écrivent ou consultent leur courrier  (\defin{agent de l'utilisateur du courrier} ou \defin{MUA}) sont
nombreux et variés, par exemple, \cmd{pine} ou \cmd{elm}. Les bo\^\i tes aux lettres sont généralement
stockées dans le répertoire \fn{/var/spool/mail}.

\subsection{Impression}

	Seule une personne peut utiliser une imprimante à un instant donné, mais ce ne serait pas économique 
de ne pas partager les imprimantes entre les utilisateurs. L'imprimante est donc gérée par un logiciel qui
implante une \defin{file d'impression}~: tous les travaux d'impression sont placés dans une file d'attente
et, à chaque fois que l'imprimante a fini avec un travail, le suivant lui est envoyé automatiquement.
Cela évite aux utilisateurs d'avoir à organiser la file d'impression et de se battre pour le contr\^ole
de l'imprimante.\footnote{Au lieu de ça, ils forment une nouvelle file, attendant leur tour, puisque
personne n'est capable de savoir exactement quand l'impression d'un autre sera réellement finie. C'est 
une grosse amélioration des relations sociales entre les bureaux.} 
\index{file d'impression}
\index{partage des imprimantes}
\index{relations sociales}

	Le gestionnaire de la file d'impression \defin{diffère} aussi les impressions sur disque, 
i.e., le texte est gardé dans un fichier pendant que le travail est dans la file. Ceci permet à 
une application d'envoyer rapidement ses travaux d'impression au gestionnaire ; l'application
n'a pas à attendre que l'impression soit finie pour continuer. Ceci est bien pratique puisque cela permet à
quelqu'un d'imprimer un texte et de pouvoir immédiatement modifier ce texte sans attendre la fin de son impression.
\index{spooling}

\section{Plan du  système de gestion de fichiers}

	Le système de gestion de fichiers est divisé en plusieurs parties ; généralement, le système de
fichiers racine contient \fn{/bin}, \fn{/lib},
	\fn{/etc}, \fn{/dev}, et plusieurs autres répertoires ; le système de fichiers \fn{/usr} contient des
	programmes et des données invariantes ; le système de fichiers \fn{/var} contient des données
changeantes (comme les fichiers log) ; et le système de fichiers \fn{/home} contient les fichiers personnels
de tout un chacun. Selon la configuration matérielle, et les décisions de l'administrateur système, ce
découpage peut \^etre différent ; tout peut m\^eme se trouver sur un seul système de fichiers.

	Le chapitre~\ref{chap:walkabout} décrit le système de fichiers avec plus de détails ;
le Linux Filesystem Standard le décrit avec encore plus de précisions.
\index{FSSTND}
\index{Linux Filesystem Standard|see{FSSTND}}
\index{Filesystem Standard|see{FSSTND}}
