%--------------------------------------------------------------------
\chapter{Boots et Shutdowns}
\label{ch:boothalt}
%--------------------------------------------------------------------

        \begin{chapterquote}
Start me up \\
Ah\dots you've got to\dots you've got to \\
Never, never never stop \\
Start it up \\
Ah\dots start it up, never, never, never \\
\ You make a grown man cry, \\
\ \ you make a grown man cry \\
(Rolling Stones) \\
% \ \\
% These boots are made for walking, \\
% and that's what they're gonna do. \\
% One of these days, these boots \\
% are gonna walk all over you. \\
        \end{chapterquote}
\index{Windows 95|see{pleurer}}
\index{pleurer}

        \noindent
	Cette section explique ce qui se passe lorsqu'un système Linux est lancé et arr\^eté, et comment cela doit
\^etre fait correctement. Si les procédures appropriées ne sont pas respectées, des fichiers peuvent \^etres ab\^imés ou
perdus\footnote{NDT : Les termes de << boot >> et << shutdown >> étant les seuls employés sous
Linux, il ne m'a pas semblé judicieux de les traduire~: si tel avait d\^u \^etre le cas, j'aurais employé les
termes de << démarrage >> et d'<< arr\^et >> du système.}.
	
\section{Survol des boots et des shutdowns}

L'action consistant à mettre en marche un ordinateur et à charger son système d'exploitation\footnote{Sur les premiers
ordinateurs, il ne suffisait pas de simplement allumer l'ordinateur, on devait aussi charger manuellement le système
d'exploitation. Nos nouvelles petites merveilles font tout elles-m\^emes.} s'appelle la \defin{phase de boot}. Le terme
de << boot >> vient de l'image d'un ordinateur se chaussant tout seul gr\^ace à des chausse-pieds (NDT~: << bootstrap >>
en anglais), mais la réalité est légèrement différente.
\index{phase de boot}
\index{démarrer un ordinateur}

Pendant la phase de boot, l'ordinateur charge d'abord un petit morceau de code appelé le \defin{chargeur} qui, à son tour,
charge et lance le système d'exploitation. Le chargeur se trouve habituellement à un endroit précis du disque dur ou de
la disquette. La raison de ce processus en deux étapes est que le système d'exploitation est gros et complexe, mais que
le premier morceau de code que l'ordinateur charge doit \^etre très réduit (quelques centaines d'octets) pour éviter
d'avoir un micro-programme trop compliqué.
\index{chargeur}

Les divers ordinateurs réalisent différemment la phase de boot. Pour les PCs, l'ordinateur (son BIOS) lit le premier
secteur (appelé le \defin{secteur de boot}) d'une disquette ou du disque dur. Le chargeur se trouve dans ce secteur. Il
charge le système d'exploitation se trouvant quelque part ailleurs sur le disque.
\index{secteur de boot}

Lorsque Linux a été chargé, il initialise le matériel et les pilotes de périphériques, puis lance \cmd{init}. 
\cmd{init} lance les autres processus permettant aux utilisateurs de se logger et de travailler. Cette
partie sera détaillée plus tard.

Afin d'arr\^eter un système Linux, tous les processus doivent d'abord \^etre informés qu'ils doivent se terminer (ceci
leur permet de fermer les fichiers et de réaliser les autres choses nécessaires pour garder tout en ordre), puis
les systèmes de fichiers et les zones de swap sont démontés, et, enfin, un message est affiché sur la console indiquant
que l'alimentation peut \^etre coupée. Si la procédure correcte n'est pas suivie, des choses terribles peuvent se passer et
se passeront ; le plus important est que le tampon cache du système de fichiers peut ne pas \^etre vidé, ce qui signifie
que toutes les données qu'il contient sont perdues et que le système de fichiers du disque est instable, et 
donc éventuellement inutilisable.
\index{tampon cache}
\index{données perdues}

\section{Le processus de boot vu de plus près}

On peut lancer Linux soit à partir d'une disquette soit à partir du disque dur. La section consacrée à l'installation
du << Installation and Getting Started guide >> (\cite{getting-started}) indique comment installer Linux pour le
lancer selon notre choix.

Une fois le PC lancé, le BIOS fait différents tests pour vérifier que tout va bien\footnote{Cette phase est appelée le
\defin{power on self test}, ou \defin{POST} en abrégé} et lance ensuite le véritable démarrage. Il choisit un 
lecteur de disque (normalement le premier lecteur de disquette, s'il y a une disquette dedans, sinon le premier
disque dur ; cependant, cet ordre est configurable) et lit son tout premier secteur. Celui-ci s'appelle le
\defin{secteur de boot}, dans le cas d'un disque dur, il est aussi appelé \defin{master boot record} car un disque
dur peut contenir plusieurs partitions, chacune ayant son propre secteur de boot.
\index{BIOS}
\index{master boot record}
\index{MBR}
\index{partition boot record}
\index{boot record!master|see{MBR}}
\index{boot record!partition|see{partition boot record}}

Le secteur de boot contient un petit programme (assez petit pour tenir dans un seul secteur) dont le r\^ole est de
lire le véritable système d'exploitation sur le disque et de le lancer. Lorsqu'on lance Linux à partir d'une
disquette, le secteur de boot contient du code qui ne fait que lire les quelques premières centaines de blocs (selon
la taille réelle du noyau, bien s\^ur) et les transfère à un endroit précis de la mémoire. Sur une disquette de boot
Linux, il n'y a pas de système de fichiers, le noyau est simplement stocké dans des secteurs consécutifs car cela
simplifie le processus de boot. Il est cependant possible de démarrer à partir d'une disquette ayant un système de
fichiers en utilisant LILO, le LInux LOader\footnote{NDT : Ce qui pourrait se traduire par~: le << chargeur Linux >>.}
\index{lancement!à partir d'une disquette}
\index{disquette!lancer à partir|see{lancement}}

Lorsqu'on démarre à partir du disque dur, le code contenu dans le master boot record examine la table des partitions
(qui se trouve aussi à cet endroit), identifie la partition active (celle qui est marquée << bootable >> ), lit le
secteur de boot de celle-ci, puis exécute le code se trouvant dans ce secteur de boot. Le code dans le secteur de boot
de la partition fait la m\^eme chose que le code du secteur de boot d'une disquette~: il lit le noyau dans la 
partition et le lance. Cependant, les détails changent, car il n'est généralement pas utile d'avoir une partition
séparée juste pour contenir l'image du noyau. Le code dans le secteur de boot de la partition ne peut donc simplement
lire le disque séquentiellement, il doit trouver les secteurs où le système de fichiers les a mis. Il y a plusieurs
façons de régler ce problème, mais la plus commune est d'utiliser LILO. (Les détails sur la façon de procéder ne sont
pas pertinents dans cet exposé, voir la documentation de LILO pour plus d'informations.)
\index{lancement!à partir du disque dur}
\index{disque dur!lancer à partir|see{lancement}}
\index{table des partitions}
\index{partition active}
\index{LILO}

Lorsqu'on démarre avec LILO, celui-ci lance normalement le noyau par défaut. Il est aussi possible de le
configurer pour pouvoir lancer un parmi plusieurs noyaux, ou m\^eme d'autres systèmes d'exploitation que Linux, et
l'utilisateur peut alors choisir quel noyau ou système d'exploitation doit \^etre lancé au démarrage. LILO peut \^etre 
configuré pour que, si l'on presse les touches \key{alt}, \key{shift} ou \key{ctrl}, au moment du lancement (lorsque
LILO est chargé), LILO demandera ce qu'il faut démarrer au lieu de partir sur le démarrage par défaut. On peut aussi
configurer LILO pour qu'il demande toujours quel noyau lancer, avec un temps d'expiration optionnel provoquant le démarrage du 
noyau par défaut.

	\meta Il existe d'autres chargeurs de boot que LILO. Des informations sur ceux-ci seront ajoutés dans une
future version. loadlin.

Booter à partir d'une disquette ou du disque dur ont tous deux leurs avantages, mais il est généralement plus pratique
de le faire à partir du disque dur car cela évite les tracas de la manipulation des disquettes. C'est aussi plus
rapide. Cependant, il peut \^etre plus risqué d'installer le système pour qu'il boote à partir du disque, et donc 
beaucoup commencent d'abord par booter à partir d'une disquette, puis, lorsque le système est complètement installé et fonctionne bien,
ils installent LILO et bootent à partir du disque dur.

Lorsque le noyau Linux est en mémoire, peu importe comment, et qu'il est lancé, grosso modo les choses suivantes 
vont se  passer~:

    \begin{itemize}

    \item

	Le noyau Linux est installé compressé, il se décompresse donc de lui-m\^eme. Le début de l'image du noyau contient
un petit programme pour cela.
\index{compression du noyau}
\index{noyau compressé}

    \item

	Si l'on a une carte super-VGA reconnue par Linux et qu'elle possède certains modes textes particuliers (comme
100 colonnes par 40 lignes), Linux demande en quel mode on veut l'utiliser. Lors de la compilation du noyau, il est
possible de présélectionner un mode vidéo de façon à ce qu'il ne soit plus demandé. Ceci peut aussi \^etre fait
avec LILO ou \cmd{rdev}.
\index{carte vidéo}
\index{configuration du noyau}
\index{mode vidéo}
\index{mode texte}

    \item

	Après cela, le noyau vérifie la présence des autres matériels (disques durs, disquettes, cartes 
réseaux\ldots), et configure de manière appropriée certain de ses pilotes de périphérique ; pendant ces
opérations, il affiche des messages sur ce qu'il trouve. Par exemple, quand je boote, cela ressemble à ça~:
\index{configuration matérielle}
\index{configuration des pilotes de périphériques}
\index{messages de démarrage}
\index{lancement!messages}
%%%%%%%%
		\begin{screen}\begin{verbatim}
LILO boot:
Loading linux.
Console: colour EGA+ 80x25, 8 virtual consoles
Serial driver version 3.94 with no serial options enabled
tty00 at 0x03f8 (irq = 4) is a 16450
tty01 at 0x02f8 (irq = 3) is a 16450
lp_init: lp1 exists (0), using polling driver
Memory: 7332k/8192k available (300k kernel code, 384k reserved, 176k data)
Floppy drive(s): fd0 is 1.44M, fd1 is 1.2M
Loopback device init
Warning WD8013 board not found at i/o = 280.
Math coprocessor using irq13 error reporting.
Partition check:
  hda: hda1 hda2 hda3
VFS: Mounted root (ext filesystem).
Linux version 0.99.pl9-1 (root@haven) 05/01/93 14:12:20
		\end{verbatim}\end{screen}
%%%%%%%%
Les textes exacts varient selon les systèmes en fonction du matériel, de la version de Linux utilisée et de la
façon dont il a été configuré.

   \item

	Puis, le noyau essaie de monter le système de fichier root. 
        L'emplacement est configurable au moment de la compilation, ou à tout moment gr\^ace à \cmd{rdev} ou LILO.
	Le type du système de fichiers est détecté automatiquement. Si le montage du système de fichiers root échoue,
par exemple parce qu'on a oublié d'inclure le pilote adéquat dans le noyau, le noyau panique et arr\^ete le
système (il ne peut faire grand chose de plus, en tous cas).
\index{système de fichier root}
\index{système de fichiers!root}
\index{montage!système de fichiers root}
\index{LILO}
\index{panique du noyau}
\index{panique}

	Le système de fichiers root est normalement monté en lecture seule (cela peut \^etre configuré de la
m\^eme façon que son emplacement). Ceci permet de vérifier le système de fichiers pendant qu'il est monté ; il
n'est pas souhaitable de vérifier un système de fichiers qui est monté en lecture et écriture.
\index{système de fichiers root en lecture seulement}
\index{vérification d'un système de fichiers}
\index{fsck}

    \item

	Puis, le noyau lance le programme \cmd{init} (situé dans \fn{/sbin/init}) en t\^ache de fond (ce sera toujours
le processus ayant le numéro 1). 
	\cmd{init} réalise différents travaux de ménage pour le démarrage. Ce qu'il fait exactement dépend de la façon 
dont il est configuré ; voir le chapitre~\ref{ch:init} (non encore écrit) pour plus d'information.
Il lance au moins plusieurs démons essentiels en t\^aches de fond.
\index{démons!démarrage}

    \item

	\cmd{init} bascule alors en mode multi-utilisateurs, et lance
	un \cmd{getty} pour les consoles virtuelles et les lignes série.
	\cmd{getty} est le programme qui permet aux personnes de se logger via des consoles virtuelles et des
terminaux série. Selon sa configuration, \cmd{init} peut aussi lancer d'autres programmes.
\index{console virtuelle}
\index{console}
\index{terminal}
\index{terminal série}

    \item

	Après cela, la phase de boot est terminée, le système est pr\^et et tourne nor\-ma\-lement.

    \end{itemize}

\section{Précisions sur l'arr\^et du système}

Il est important de suivre correctement les procédures	lorsqu'on éteint un système Linux. Si tel n'est pas le cas, les
systèmes de fichiers seront probablement vérolés et les fichiers seront dans un état difficile à dépêtrer. La raison est 
que Linux possède un cache disque qui n'écrit pas les choses immédiatement sur le disque, mais seulement par moments.
Ceci améliore beaucoup les performances mais signifie aussi que si l'on éteint la machine sur un coup de t\^ete, le 
cache peut contenir beaucoup de données et que ce qui se trouve sur le disque peut très bien ne pas \^etre un système de
fichiers en état de marche (car seules certaines choses ont été écrites sur le disque).
\index{extinction du système}
\index{tampon cache}
\index{cache}
\index{cache disque}

	Une autre raison contre l'extinction brutale de la machine est que, dans un système multi-t\^aches, il peut y
avoir beaucoup de choses qui tournent en arrière-plan, et que cette extinction peut vraiment \^etre désastreuse. 
En utilisant une procédure correcte d'extinction, on s'assure que tous les processus en arrière-plan peuvent sauver
leurs données.
\index{processus en arrière-plan!et extinction du système}

La commande permettant d'arr\^eter proprement un système Linux s'appelle \cmd{shutdown}.  Elle est généralement utilisée
de deux façons possibles~:
\index{shutdown!utilisation}

	Si l'on est sur un système dont on est le seul utilisateur, la façon classique d'utiliser \cmd{shutdown} est de
quitter tous les programmes qui s'exécutent, de se délogger de toutes les consoles virtuelles, de se logger sous
\texttt{root} sur l'une d'elles (ou de rester loggé sous \texttt{root} si on y est déjà, mais on doit alors se
positionner dans le répertoire racine pour éviter des problèmes lors du démontage), puis de taper la commande
\texttt{shutdown~-h~now}\index{shutdown}
	(on substitue \texttt{now} avec un signe plus, suivi d'un nombre de minutes si on veut disposer d'un
délai, bien que l'on n'en n'ait généralement pas besoin sur un système ayant un seul utilisateur).

	Si le système a plusieurs utilisateurs, on peut, à la place, utiliser la commande
	\texttt{shutdown~-h~\textsl{+temps message}}, où \textsl{temps} 
	est le temps en minutes restant avant que le système ne soit arr\^eté, et \textsl{message}
	est une courte explication de la raison de cet arr\^et.
		%
\begin{tscreen}
\# shutdown -h +10 'Nous allons installer un nouveau disque. Le système devrait\\
> être remis en marche dans trois heures.'\\
\#
\end{tscreen}
		%
Cela préviendra tout le monde que le système s'arr\^etera dans 10 minutes, et qu'il vaudrait mieux se délogger
plut\^ot  que de perdre
des données. L'avertissement est affiché sur tous les terminaux où quelqu'un est loggé, y compris tous les
	\cmd{xterm}s~:
		%
\begin{tscreen}
Broadcast message from root (ttyp0) Wed Aug  2 01:03:25 1995... \\
\ \\Nous allons installer un nouveau disque. Le système devrait\\
> être remis en marche dans trois heures.

The system is going DOWN for system halt in 10 minutes !!
\end{tscreen}
		%
L'avertissement est répété plusieurs fois avant l'arr\^et, à intervalles de plus en plus courts à mesure que le
délai s'épuise.
\index{message de shutdown}

Lorsque l'arr\^et réel se lance après les délais, tous les systèmes de fichiers (sauf la racine) sont démontés, les processus
utilisateurs (si quelqu'un est encore loggé) sont tués, les démons sont arr\^etés, le système de fichiers racine est
démonté et, généralement, tout se calme. Lorsque c'est fait, \cmd{init} affiche un message indiquant que l'on peut
éteindre la machine. Alors, \emph{et seulement alors}, on peut poser ses doigts sur le bouton d'alimentation.
\index{shutdown!actions}

Quelques fois, bien que cela soit rare sur un système correct, on ne peut arr\^eter le système correctement. Par exemple,
si le noyau panique, plante, ou se comporte mal d'une façon générale, il peut \^etre impossible de lancer quelque commande que
ce soit, et donc arr\^eter proprement le système est pour le moins difficile. La seule chose que l'on peut faire est 
d'espérer qu'il n'y a pas eu trop de dégâts et d'éteindre la machine. Si les problèmes sont un peu moins sévères (quelqu'un
a donné un coup de hache au clavier, par exemple), et que le noyau et le programme \cmd{update} tournent encore 
normalement, il est s\^urement préférable d'attendre quelques minutes pour donner à \cmd{update} une chance de vider le
tampon du cache, et seulement alors couper l'alimentation.
\index{plantage}
\index{plantage du système}
\index{shutdown!urgence}
\index{shutdown incorrect|see{shutdown, urgence}}
\index{hache}
\index{tampon cache}
\index{shutdown d'urgence|see{shutdown, urgence}}

Certains arr\^etent le système en utilisant trois fois la commande
	\cmd{sync}\footnote{\cmd{sync} vide le tampon cache.}
	attendent que les échanges disques s'arr\^etent, puis éteignent la machine. S'il n'y a pas de programme en cours
d'exécution, cette méthode est à peu près équivalent à l'utilisa\-tion de \cmd{shutdown}. Cependant, cela ne démonte pas les
systèmes de fichiers et ceci peut poser des problèmes avec l'indicateur << système de fichiers ok >> de ext2fs. La méthode
triple-sync \emph{n'est pas recommandée}.
\index{shutdown!triple syncs}

	(Au cas où on se demanderait pourquoi~: la raison des \emph{trois} syncs est que, au début d'UNIX, lorsque les
commandes étaient tapées séparément, cela donnait suffisamment de temps à la plupart des échanges disques pour se terminer.)

\section{Redémarrage}

Redémarrer signifie démarrer à nouveau le système. Ceci peut \^etre réalisé en l'arr\^etant d'abord complètement, en
l'éteignant puis en le rallumant. Une façon plus simple est de demander à \cmd{shutdown} de relancer le système, au lieu
de simplement l'arr\^eter. Ceci est réalisé en utilisant l'option \texttt{-r} de shutdown, par exemple en tapant la
commande \texttt{shutdown -r now}.
\index{redémarrage}
	
La plupart des systèmes Linux lancent \texttt{shutdown -r now}
lorsque la combinaison de touches ctrl-alt-suppr est tapée au clavier. Ceci relance le système. Cependant, l'action
liée à ctrl-alt-suppr est reconfigurable, et il peut \^etre préférable de donner un certain délai avant le redémarrage sur
une machine multi-utilisateurs. Les systèmes physiquement accessibles par n'importe qui peuvent m\^eme \^etre
configurés pour ne rien faire avec la combinaison ctrl-alt-suppr.
\index{ctrl-alt-suppr}
\index{init!et ctrl-alt-suppr}

\section{Mode << single user >>}

La commande {shutdown} peut aussi \^etre utilisée pour passer en mode << single user >>, dans lequel personne ne peut se 
logger, sauf \texttt{root} qui peut utiliser la console. Ce mode est utile pour les t\^aches d'administration du
système qui ne peuvent \^etre réalisées lorsque le système tourne normalement. Le mode << single user >> est détaillé au
chapitre~\ref{chap:daemons}.
\index{mode simple utilisateur}
\index{init!mode simple utilisateur}

\section{Disquettes boot d'urgence}

Il n'est pas toujours possible de booter un ordinateur à partir du disque dur. Par exemple, si l'on a fait une erreur en 
configurant LILO, on peut rendre le système indémarrable. Pour de telles situations, on a besoin d'une solution de
 remplacement qui marchera toujours (pour autant que le matériel fonctionne). Pour la majeure partie des PCs, cela
signifie  démarrer à partir du lecteur de disquettes.
\index{démarrage!à partir d'une disquette d'urgence}
\index{lecteur de disquettes}

	La plupart des distributions Linux permettent de créer une \defin{disquette de démar\-rage d'urgence} lors de
l'installation. Il est préférable de le faire. Toutefois, ces disquettes contiennent seulement le noyau
et supposent qu'on utilisera les programmes des disquettes d'installation pour régler les problèmes. Quelquefois, ces
programmes ne suffisent pas ; par exemple, on peut avoir à restaurer des fichiers sauvegardés avec un logiciel ne se
trouvant pas sur ces disquettes d'installation.
\index{sauvegardes}
\index{disquettes d'installation}
\index{disquette d'urgence!utilisation}

	Par conséquent, il peut \^etre nécessaire de créer une disquette root personnalisée. Le
\emph{Bootdisk HOWTO} de Graham Chapman (\cite{bootdisk-howto})
	contient toutes les instructions pour faire ça. On doit, bien s\^ur, ne pas oublier de tenir à jour les
disquettes de démarrage et root.
\index{disquette d'urgence!création}

	On ne peut pas utiliser le lecteur de disquettes utilisé pour monter la disquette root pour quoi que ce soit
d'autre. Ceci peut \^etre gênant si l'on n'a qu'un seul lecteur. Cependant, si l'on a assez de mémoire, on peut
configurer sa disquette de démarrage pour charger la disquette root dans un ram-disque (le noyau de la disquette de
démarrage doit \^etre configuré d'une façon spéciale pour fonctionner comme ça). Lorsque la disquette root a été
chargée dans le ram-disque, le lecteur de disquettes est disponible pour monter d'autres disquettes.
\index{ram-disque}










































