/usr/share/doc/HOWTO/fr-html/SRM-HOWTO.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Linux/x86 (vers 25 March 2009), see www.w3.org">
<meta name="GENERATOR" content="LinuxDoc-Tools 0.9.69">
<title>SRM Firmware Howto</title>
</head>
<body>
<h1>SRM Firmware Howto</h1>
<h2>Version originale : <a href="mailto:davidm@azstarnet.com">David
Mosberger</a> (Traduction fran&ccedil;aise : Nicolas Jadot
(njadot@etu.info.unicaen.fr))</h2>
v0.5, 17 August 1996
<hr>
<em>Ce document d&eacute;crit la mani&egrave;re de d&eacute;marrer
une station Linux/Alpha utilisant le <em>firmware</em> SRM, lequel
est normalement utilis&eacute; pour d&eacute;marrer Digital Unix.
(NDT : le <em>firmware</em> est un micro-code embarqu&eacute; sur
une puce, en quelque sorte l'&eacute;quivalent du BIOS des PC) En
g&eacute;n&eacute;ral, il est pr&eacute;f&eacute;rable d'utiliser
MILO &agrave; la place du programme <code>aboot</code> sachant que
MILO est parfaitement adapt&eacute; aux besoins de Linux.
Cependant, MILO n'existe pas sur tous les syst&egrave;mes et ne
permet pas encore de d&eacute;marrer sur un r&eacute;seau. Dans ces
cas l&agrave;, utiliser la console SRM est peut-&ecirc;tre la bonne
solution.</em>
<hr>
<p>A moins que vous soyiez int&eacute;ress&eacute;s par les
d&eacute;tails techniques, vous pouvez passer directement &agrave;
la section <a href="#aboot">aboot</a></p>
<h2><a name="s1">1. Comment SRM d&eacute;marre-t-il un
syst&egrave;me d'exploitation ?</a></h2>
<p>Toutes les versions de SRM peuvent d&eacute;marrer &agrave;
partir d'un disque SCSI et les versions destin&eacute;es aux
plates-formes r&eacute;centes, comme les Noname et AlphaStations,
peuvent de plus d&eacute;marrer depuis une disquette. Le
d&eacute;marrage r&eacute;seau via <code>bootp</code> est
&eacute;galement support&eacute;. Notez que les anciennes versions
de SRM (notamment celles pour Jensen) <em>ne pouvaient pas</em>
d&eacute;marrer depuis une disquette. Le d&eacute;marrage depuis un
disque IDE n'est pas support&eacute;.</p>
<p>Le d&eacute;marrage de Linux avec SRM s'effectue en deux
&eacute;tapes : d'abord, SRM charge et transf&egrave;re le controle
&agrave; un chargeur secondaire. Ensuite, ce chargeur secondaire
met en place l'environnement de Linux, lit l'image du noyau depuis
un syst&egrave;me de fichiers sur disque et donne la main &agrave;
Linux.</p>
<p>A l'heure actuelle il existe deux chargeurs secondaires pour
Linux : le chargeur <em>brut</em> fourni avec le noyau Linux et
<code>aboot</code>, distribu&eacute; s&eacute;parement. Ces deux
chargeurs sont d&eacute;crits en d&eacute;tails ci-dessous.</p>
<h2><a name="ss1.1">1.1 Charger le chargeur secondaire</a></h2>
<p>SRM est ignorant des syst&egrave;mes de fichiers et des
partitions des disques. Il s'attend simplement &agrave; ce que le
chargeur secondaire occupe un certain nombre de secteurs physiques
cons&eacute;cutifs, commen&ccedil;ant &agrave; une adresse
donn&eacute;e. L'information concernant la taille du chargeur
secondaire et l'adresse de son premier secteur est stock&eacute;e
dans les 512 premiers octets. Plus pr&eacute;cisement , l'entier
long occupant l'adresse 480 contient la <em>taille</em> du chargeur
secondaire et celui occupant l'adresse 488 donne le <em>nombre de
secteurs</em> de d&eacute;calage jusqu'au d&eacute;but du chargeur.
Le premier secteur contient &eacute;galement un drapeau &agrave;
l'adresse 496 qui vaut toujours 0 et une somme de contr&ocirc;le
&agrave; l'adresse 504. Cette somme de contr&ocirc;le est
simplement la somme des 63 premiers entiers longs du premier
secteur.</p>
<p>Si cette somme est correcte, SRM continue et lit le nombre de
secteurs indiqu&eacute; par la <em>taille</em> en commen&ccedil;ant
par celui indiqu&eacute; dans le champ <em>num&eacute;ro de
secteur</em> et les place en m&eacute;moire <em>virtuelle</em>
&agrave; l'adresse <code>0x20000000</code>. Si la lecture se
termine avec succ&eacute;s, SRM effectue un saut &agrave; l'adresse
<code>0x20000000</code>.</p>
<h2><a name="s2">2. Le chargeur brut</a></h2>
<p>Les sources de ce chargeur peuvent &ecirc;tre trouv&eacute;s
dans le r&eacute;pertoire</p>
<blockquote>
<pre>
<code>        linux/arch/alpha/boot
</code>
</pre></blockquote>
<p>des sources du noyau Linux. Ce programme charge le noyau Linux
en lisant <code>START_SIZE</code> octets en commen&ccedil;ant
&agrave; l'adresse <code>BOOT_SIZE+512</code> (&eacute;galement en
octets). Les constantes <code>START_SIZE</code> et
<code>BOOT_SIZE</code> sont d&eacute;finies dans le fichier
d'en-tete <code>linux/include/asm-alpha/system.h</code>.
<code>START_SIZE</code> doit &ecirc;tre au moins aussi
&eacute;l&eacute;v&eacute; que la taille de l'image du noyau (i.e,
la somme des tailles des segments <code>.text</code>,
<code>.data</code>, et <code>.bss</code> ). De m&ecirc;me,
<code>BOOT_SIZE</code> doit &ecirc;tre au moins aussi
&eacute;lev&eacute; que l'image du chargeur. Ces deux constantes
doivent avoir comme valeur un multiple entier de la taille d'un
secteur, soit 512 octets. Les valeurs par d&eacute;faut sont 2Mo
pour <code>START_SIZE</code> et 16Ko pour <code>BOOT_SIZE</code>.
Notez que si vous voulez d&eacute;marrer depuis une disquette de
1.44Mo, vous devez r&eacute;duire <code>START_SIZE</code> &agrave;
1400Ko et vous assurer que la taille du noyau que vous voulez
d&eacute;marrer ne d&eacute;passe pas cette valeur.</p>
<p>Pour construire un chargeur brut, tapez simplement <code>make
rawboot</code> dans <code>/usr/src/linux</code>. Ceci devrait
produire dans <code>arch/alpha/boot</code> les fichiers suivants
:</p>
<dl>
<dt><b><code>tools/lxboot</code>:</b></dt>
<dd>
<p>Le premier secteur du disque. Il contient l'adresse et la taille
du prochain fichier au format d&eacute;crit ci-dessus.</p>
</dd>
<dt><b><code>tools/bootlx</code>:</b></dt>
<dd>
<p>Le lanceur brut qui chargera le fichier ci-dessous</p>
</dd>
<dt><b><code>vmlinux.nh</code>:</b></dt>
<dd>
<p>L'image brute du noyau constitu&eacute;e des segments
<code>.text</code>, <code>.data</code> et <code>.bss</code> du
fichier objet <code>/usr/src/linux/vmlinux</code>. L'extension
<code>.nh</code> indique que ce fichier n'a pas l'ent&ecirc;te d'un
fichier objet.</p>
</dd>
</dl>
<p>La concat&eacute;nation de ces trois fichiers devrait &ecirc;tre
&eacute;crite sur le disque &agrave; partir duquel vous voulez
d&eacute;marrer. Par exemple, pour d&eacute;marrer depuis une
disquette, ins&eacute;rez une disquette vierge dans le lecteur,
soit <code>/dev/fd0</code> et ensuite tapez :</p>
<blockquote>
<pre>
<code>cat tools/lxboot tools/bootlx vmlinux &gt;/dev/fd0
</code>
</pre></blockquote>
<p>Vous pouvez maintenant arr&eacute;ter le syst&egrave;me et
d&eacute;marrer depuis une disquette en utilisant la commande
<code>boot dva0</code>.</p>
<h2><a name="aboot"></a> <a name="s3">3. Le chargeur
<code>aboot</code></a></h2>
<p>Si vous utilisez le <em>firmware</em> SRM, <code>aboot</code>
est la meilleure fa&ccedil;on de d&eacute;marrer Linux. Il supporte
:</p>
<ul>
<li>d&eacute;marrage direct depuis divers syst&egrave;mes de
fichiers (<code>ext2</code>, <code>ISO9660</code>, et
<code>UFS</code>, le syst&egrave;me de fichiers de Digital
Unix),</li>
<li>lancement de fichiers objets ex&eacute;cutables (ELF et
ECOFF),</li>
<li>lancement de noyaux compress&eacute;s,</li>
<li>d&eacute;marrage par r&eacute;seau (en utilisant le protocole
<code>bootp</code>),</li>
<li>table de partitions au format Digital Unix (compatible avec les
tables de partitions de BSD),</li>
<li>d&eacute;marrage interactif et configurations par d&eacute;faut
des consoles SRM qui n'acceptent pas les longues cha&icirc;nes
d'option.</li>
</ul>
<h2><a name="ss3.1">3.1 Se procurer et installer
<code>aboot</code></a></h2>
<p>Les codes sources les plus r&eacute;cents d'<code>aboot</code>
sont disponibles &agrave; l'adresse <a href=
"ftp://ftp.azstarnet.com/pub/linux/axp/aboot">ftp://ftp.azstarnet.com/pub/linux/axp/aboot</a>.
La description de ce manuel s'applique &agrave; <code>aboot</code>
pour les versions 0.5 et suivantes.</p>
<p>Une fois que vous avez t&eacute;l&eacute;charg&eacute; et
extrait l'archive <code>tar</code>, jetez un oeil aux fichiers
<code>README</code> et <code>INSTALL</code> pour lire les
directives d'installation. En particulier, assurez vous que les
variables, dans les fichiers <code>Makefile</code> et
<code>include/config.h</code> sont correctes vis-&agrave;-vis de
votre environnement . Normalement, vous ne devriez pas avoir
&agrave; changer quoi que ce soit pour compiler sous Linux, mais
c'est toujours une bonne chose de v&eacute;rifier. Si la
configuration vous convient, tapez simplement <code>make</code>
pour lancer la compilation (si vous n'effectuez pas cette
op&eacute;ration sous Linux, sachez que <code>aboot</code> requiert
GNU <code>make</code>).</p>
<p>Apr&egrave;s l'ex&eacute;cution de <code>make</code>, le
r&eacute;pertoire <code>aboot</code> devrait contenir les fichiers
suivants :</p>
<dl>
<dt><b>aboot</b></dt>
<dd>
<p>L'ex&eacute;cutable r&eacute;el (fichier objet ECOFF ou
ELF),</p>
</dd>
<dt><b>bootlx</b></dt>
<dd>
<p>Comme ci-dessus, mais ce fichier ne contient que les segments
text, data et bss (ce fichier n'est pas un fichier objet),</p>
</dd>
<dt><b>sdisklabel/writeboot</b></dt>
<dd>
<p>Un utilitaire pour installer <code>aboot</code> sur un disque
dur,</p>
</dd>
<dt><b>tools/e2writeboot</b></dt>
<dd>
<p>Un utilitaire pour installer <code>aboot</code> sur un
syst&egrave;me de fichiers ext2 (n'est en g&eacute;n&eacute;ral
utilis&eacute; que pour les disquettes),</p>
</dd>
<dt><b>tools/isomarkboot</b></dt>
<dd>
<p>Un utilitaire pour installer <code>aboot</code> sur un
syst&egrave;me de fichiers iso9660 (utilis&eacute; par les
distributeurs de CD-ROM),</p>
</dd>
<dt><b>tools/abootconf</b></dt>
<dd>
<p>Un utilitaire pour configurer <code>aboot</code> s'il est
install&eacute;.</p>
</dd>
</dl>
<h2><a name="ss3.2">3.2 Installation sur disquette</a></h2>
<p>Le lanceur peut &ecirc;tre install&eacute; sur une disquette en
utilisant la commande <code>e2writeboot</code> (note : ceci ne peut
se faire sur un Jensen car son <em>firmware</em> n'implante pas le
d&eacute;marrage depuis une disquette). Cette commande
n&eacute;cessite que le disque ne soit pas trop fragment&eacute;
car elle a besoin de trouver suffisament de secteurs contigus pour
stocker l'image enti&egrave;re de <code>aboot</code> (actuellement,
environ 90Ko). Si <code>e2writeboot</code> &eacute;choue &agrave;
cause de &ccedil;a, reformatez la disquette et r&eacute;essayez
(par ex., avec <code>fdformat(1)</code>). Par exemple, la
proc&eacute;dure suivante installe <code>aboot</code> sur une
disquette en supposant que la disquette est dans le lecteur
correspondant &agrave; <code>/dev/fd0</code> :</p>
<blockquote>
<pre>
<code>fdformat /dev/fd0
mke2fs /dev/fd0
e2writeboot /dev/fd0 bootlx
</code>
</pre></blockquote>
<h2><a name="ss3.3">3.3 Installation sur disque dur</a></h2>
<p>Sachant que la commande <code>e2writeboot</code> peut
&eacute;chouer sur un disque hautement fragment&eacute; et comme le
reformattage d'un disque dur ne se fait pas sans peine, il est
g&eacute;n&eacute;ralement plus s&ucirc;r d'installer
<code>aboot</code> sur un disque dur en utilisant la commande
<code>swriteboot</code>. <code>swriteboot</code> n&eacute;cessite
que les premiers secteurs soient r&eacute;serv&eacute;s aux
proc&eacute;dures de d&eacute;marrage. Nous sugg&eacute;rons que le
disque soit partitionn&eacute; de mani&egrave;re &agrave; ce que la
premi&egrave;re partition commence &agrave; une adresse
correspondant &agrave; 2048 secteurs. Cela laisse 1Mo d'espace ibre
pour stocker <code>aboot</code>. Sur un disque partitionn&eacute;
de cette fa&ccedil;on , il est alors possible d'installer
<code>aboot</code> comme d&eacute;crit ci-dessous (en supposant que
le disque correspond &agrave; <code>/dev/sda</code>.) :</p>
<blockquote>
<pre>
<code>swriteboot /dev/sda bootlx
</code>
</pre></blockquote>
<p>Sur un Jensen, vous devrez laisser un peu plus d'espace, sachant
que vous devrez &eacute;galement stocker le noyau &agrave; cet
endroit - 2Mo devraient suffire en utilisant une image
compress&eacute;e. Utilisez <code>swriteboot</code> comme
d&eacute;crit &agrave; la section <a href="#booting">booting</a>
pour &eacute;crire <code>bootlx</code> avec le noyau Linux.</p>
<h2><a name="ss3.4">3.4 Installation sur CD-ROM</a></h2>
<p>Pour construire un CD-ROM amor&ccedil;able avec SRM, construisez
simplement <code>aboot</code> comme d&eacute;crit ci-dessus.
Assurez-vous ensuite que le fichier <code>bootlx</code> est
pr&eacute;sent sur le syst&egrave;me de fichiers iso9660 (e.g.,
copiez <code>bootlx</code> dans le r&eacute;pertoire o&ugrave; est
mont&eacute; le syst&egrave;me de fichiers) , et lancez
<code>mkisofs</code> sur ce r&eacute;pertoire). Apr&egrave;s cela,
la seule chose restant &agrave; faire est de marquer le
syst&egrave;me de fichiers comme amor&ccedil;able avec SRM. Cela
est r&eacute;alis&eacute; gr&acirc;ce &agrave; une commande de la
forme :</p>
<blockquote>
<pre>
<code>isomarkboot filesystem bootlx
</code>
</pre></blockquote>
<p>La commande ci-dessus n&eacute;cessite que
<code>filesystem</code> est un fichier contenant le syst&egrave;me
de fichiers iso9660 et que <code>bootlx</code> a &eacute;t&eacute;
copi&eacute; dans la racine de ce syst&egrave;me de fichiers. C'est
tout !</p>
<h2><a name="Building Linux"></a> <a name="ss3.5">3.5 Construire un
noyau Linux</a></h2>
<p>Un noyau Linux amor&ccedil;able peut &ecirc;tre construit par
les &eacute;tapes suivantes. Durant le <code>make config</code>,
assurez-vous de r&eacute;pondre "oui" (<em>"yes"</em>) &agrave; la
question concernant le lancement du noyau par SRM.</p>
<blockquote>
<pre>
<code>cd /usr/src/linux
make config
make dep
make boot
</code>
</pre></blockquote>
<p>La derni&egrave;re commande construira le fichier
<code>arch/alpha/boot/vmlinux.gz</code> qui peut alors &ecirc;tre
copi&eacute; sur le disque &agrave; partir duquel vous
d&eacute;sirez d&eacute;marrer. Dans notre exemple
pr&eacute;c&eacute;dent concernant la disquette, cela donnerai
:</p>
<blockquote>
<pre>
<code>mount /dev/fd0 /mnt
cp arch/alpha/boot/vmlinux.gz /mnt
umount /mnt
</code>
</pre></blockquote>
<h2><a name="booting"></a> <a name="ss3.6">3.6 D&eacute;marrer
Linux</a></h2>
<p>Avec le <em>firmware</em> SRM et <code>aboot</code>
install&eacute;, le d&eacute;marrage de Linux s'effectue
g&eacute;n&eacute;ralement avec une commande de la forme :</p>
<blockquote><code><code>boot</code> <i>devicename</i>
<code>-fi</code> <i>filename</i> <code>-fl</code>
<i>flags</i></code></blockquote>
<p>Les arguments <i>filename</i> et <i>flags</i> sont optionels.
S'ils ne sont pas sp&eacute;cifi&eacute;s, SRM utilise les valeurs
par d&eacute;faut contenues dans les variables d'environnement
<code>BOOT_OSFILE</code> et <code>BOOT_OSFLAGS</code>. La syntaxe
et la signification de ces deux arguments est d&eacute;crite plus
en d&eacute;tail ci-dessous.</p>
<h3>Nom du fichier boot</h3>
<p>L'argument <em>filename</em> est de la forme :</p>
<blockquote>[<em>n</em>/]<em>filename</em></blockquote>
<p><em>n</em> est un simple nombre dans l'intervalle 1..8 qui donne
le num&eacute;ro de la partition de d&eacute;marrage.
<em>filename</em> est le chemin d'acc&eacute;s au fichier &agrave;
lancer. Par exemple, pour d&eacute;marrer depuis la deuxi&egrave;me
partition du sixi&egrave;me disque SCSI, vous entreriez :</p>
<blockquote>
<pre>
<code>boot dka600 -file 2/vmlinux.gz
</code>
</pre></blockquote>
<p>Ou, pour d&eacute;marrer depuis le premier lecteur de disquette
:</p>
<blockquote>
<pre>
<code>boot dva0 -file vmlinux.gz
</code>
</pre></blockquote>
<p>Si un disque n'a pas de table des partitions, <code>aboot</code>
consid&egrave;re que le disque contient une partition
<code>ext2</code> commen&ccedil;ant au premier bloc du disque. Cela
permet de d&eacute;marrer depuis une disquette.</p>
<p>Le num&eacute;ro de partition 0 est utilis&eacute; pour demander
le d&eacute;marrage depuis un disque qui ne contient pas (encore)
de syst&egrave;me de fichiers. Si l'on sp&eacute;cifie le
num&eacute;ro de "partition" 0, <code>aboot</code> consid&egrave;re
que le noyau Linux suit directement l'image de <code>aboot</code>.
Une telle chose peut &ecirc;tre r&eacute;alis&eacute;e avec la
commande <code>swriteboot</code>. Par exemple, pour configurer un
d&eacute;marrage sans syst&egrave;me de fichiers depuis
<code>/dev/sda</code>, on pourrait utiliser la commande :</p>
<blockquote>
<pre>
<code>swriteboot /dev/sda bootlx vmlinux.gz
</code>
</pre></blockquote>
<p>D&eacute;marrer un syst&egrave;me de cette fa&ccedil;on n'est
pas obligatoirement n&eacute;cessaire. La raison d'&ecirc;tre de
cette fonctionnalit&eacute; est de permettre l'installation de
Linux sur un syst&egrave;me qui ne peut d&eacute;marrer depuis une
disquette (e.g., le Jensen).</p>
<h3>Drapeaux de d&eacute;marrage</h3>
<p>Plusieurs drapeaux de d&eacute;marrage peuvent &ecirc;tre
sp&eacute;cifi&eacute;s. La syntaxe en est :</p>
<blockquote>
<pre>
<code>-flags "options..."
</code>
</pre></blockquote>
<p>O&ugrave; "options..." est une combinaison des options suivantes
(s&eacute;par&eacute;es par des espace). Il y a encore plus
d'options, en fonction des pilotes que le noyau a install&eacute;.
Les options list&eacute;es ci-apr&egrave;s ne sont l&agrave; que
pour illustrer l'id&eacute;e g&eacute;n&eacute;rale :</p>
<dl>
<dt><b>load_ramdisk=1</b></dt>
<dd>
<p>Copie le syst&egrave;me de fichiers racine depuis une disquette
vers un disque virtuel en m&eacute;moire avant de lancer le
syst&egrave;me. Ce disque virtuel sera utilis&eacute; en lieu et
place du p&eacute;riph&eacute;rique racine. Ceci est utile pour
d&eacute;marrer Linux sur une machine qui ne poss&egrave;de qu'un
lecteur de disquettes.</p>
</dd>
<dt><b>floppy=<em>str</em></b></dt>
<dt><b>root=<em>dev</em></b></dt>
<dd>
<p>S&eacute;lectionne le p&eacute;riph&eacute;rique <em>dev</em>
comme syst&egrave;me de fichiers racine. Le
p&eacute;riph&eacute;rique peut &ecirc;tre sp&eacute;cifi&eacute;
comme la combinaison des num&eacute;ros <em>major/minor</em> du
fichier de p&eacute;riph&eacute;rique en hexad&eacute;cimal (e.g.,
0x802 pour /dev/sda2) ou un nom de fichier de
p&eacute;riph&eacute;rique (e.g.,<code>/dev/fd0</code>,
<code>/dev/sda2</code>).</p>
</dd>
<dt><b>single</b></dt>
<dd>
<p>Lance le syst&egrave;me en mode mono-utilisateur.</p>
</dd>
<dt><b>kgdb</b></dt>
<dd>
<p>Autorise <em>kernel-gdb</em> (ne fonctionne que si
<code>CONFIG_KGDB</code> est activ&eacute; ; un deuxi&egrave;me
syst&egrave;me Alpha doit &ecirc;tre connect&eacute; par voie
s&eacute;rie pour que cela fonctionne).</p>
</dd>
</dl>
<p>Quelques impl&eacute;mentations de SRM (e.g., celle du Jensen)
sont limit&eacute;es et n'autorisent que les cha&icirc;nes
d'options de courte longueur (e.g., au plus 8 caract&egrave;res).
Dans ce cas l&agrave;, <code>aboot</code> peut &ecirc;tre
d&eacute;marr&eacute; avec le drapeau de d&eacute;marrage "i". Avec
ce drapeau, <code>aboot</code> demandera &agrave; l'utilisateur
d'entrer une cha&icirc;ne d'options pouvant atteindre 256
caract&egrave;res. Par exemple :</p>
<blockquote>
<pre>
<code>boot dka0 -fl i
aboot&gt; 3/vmlinux.gz root=/dev/sda3 single
</code>
</pre></blockquote>
<p>Comme d&eacute;marrer de cette fa&ccedil;on devient rapidement
p&eacute;nible , <code>aboot</code> autorise l'utilisateur &agrave;
d&eacute;finir des raccourcis pour les lignes de commande
fr&eacute;quemment utilis&eacute;es. En particulier, une option
donn&eacute;e par un chiffre -- option --&gt; (0-9) demande
&agrave; <code>aboot</code> d'utiliser l'option correspondante dans
le fichier <code>/etc/aboot.conf</code>. Un exemple de fichier
<code>aboot.conf</code> est donn&eacute; ci-dessous :</p>
<blockquote>
<pre>
<code>#
# aboot default configurations
#
0:3/vmlinux.gz root=/dev/sda3
1:3/vmlinux.gz root=/dev/sda3 single
2:3/vmlinux.new.gz root=/dev/sda3
3:3/vmlinux root=/dev/sda3
8:- root=/dev/sda3            # fs-less boot of raw kernel
9:0/vmlinux.gz root=/dev/sda3 # fs-less boot of (compressed) ECOFF kernel
-
</code>
</pre></blockquote>
<p>Avec ce fichier, la commande</p>
<blockquote>
<pre>
<code>boot dka0 -fl 1
</code>
</pre></blockquote>
<p>correspond exactement &agrave; la commande de d&eacute;marrage
donn&eacute;e ci-dessus. Il est cependant facile d'oublier la
correspondance entre les num&eacute;ros et les cha&icirc;nes
d'options. Pour &eacute;viter ce probl&egrave;me, d&eacute;marrez
avec l'option "h" et <code>aboot</code> affichera le contenu de
<code>/etc/aboot.conf</code> avant d'afficher l'invite demandant la
cha&icirc;ne d'option enti&egrave;re.</p>
<p>En conclusion, m&ecirc;me si <code>aboot</code> demande
l'entr&eacute;e d'une cha&icirc;ne d'options, il est possible
d'entrer un simple caract&egrave;re ("i", "h", ou "0"-"9") pour
obtenir le m&ecirc;me r&eacute;sultat que si le drapeau avait
&eacute;t&eacute; sp&eacute;cifi&eacute; sur la ligne de commande
de d&eacute;marrage. Par exemple, vous pouvez d&eacute;marrer avec
le drapeau "i", taper ensuite "h" (suivi par entr&eacute;e) pour
vous rappeler le contenu de <code>/etc/aboot.conf</code></p>
<h3>S&eacute;lectionner la partition de /etc/aboot.conf</h3>
<p>Quand <code>aboot</code> est install&eacute; sur un disque dur,
il a besoin de savoir sur quel partition il lui faut chercher le
fichier <code>/etc/aboot.conf</code>. Nouvellement compil&eacute;,
<code>aboot</code> cherchera sur la deuxi&egrave;me partition
(<code>/dev/sda2</code>). Comme il serait contraignant d'avoir
&agrave; recompiler <code>aboot</code> uniquement pour changer le
num&eacute;ro de la partition, <code>abootconf</code> autorise
&agrave; directement modifier <code>aboot</code> d&eacute;j&agrave;
install&eacute;. Par exemple, si vous d&eacute;siriez changer
<code>aboot</code> afin qu'il utilise la <em>troisi&egrave;me</em>
partition du disque <code>/dev/sda</code>, vous utiliseriez la
commande :</p>
<blockquote>
<pre>
<code>abootconf /dev/sda 3
</code>
</pre></blockquote>
<p>Vous pouvez v&eacute;rifier le r&eacute;glage courant simplement
en omettant le num&eacute;ro de partition. Alors, <code>abootconf
/dev/sda</code> affichera la partition actuellement
s&eacute;lectionn&eacute;e. Notez que <code>aboot</code> &ecirc;tre
d&eacute;j&agrave; install&eacute; pour que cette commande
r&eacute;ussisse. Aussi, lors de l'installation d'un nouvel
<code>aboot</code>, le num&eacute;ro de partition redeviendra celui
par d&eacute;faut (i.e., il sera n&eacute;cessaire de relancer
<code>abootconf</code>).</p>
<p>Depuis la version 0.5 de <code>aboot</code>, il est
&eacute;galement possible de s&eacute;lectionner la partition
contenant le fichier <code>aboot.conf</code> depuis la ligne de
commande de d&eacute;marrage. Cela peut &ecirc;tre fait avec une
ligne de commande de la forme <i>a</i><code>:</code><i>b</i>
o&ugrave; <i>a</i> est le num&eacute;ro de la partition contenant
<code>/etc/aboot.conf</code> et <i>b</i> est une option d'une
lettre comme d&eacute;crit plus haut
(<code>0</code>-<code>9</code>, <code>i</code>, ou <code>h</code>).
Par exemple, si vous tapez <code>boot -fl "3:h" dka100</code> le
syst&egrave;me d&eacute;marre depuis SCSI ID 1, charge
<code>/etc/aboot.conf</code> depuis la troisi&egrave;me partition,
affiche son contenu &agrave; l'&eacute;cran et attend que vous
entriez les options de d&eacute;marrage.</p>
<h2><a name="Network Booting"></a> <a name="ss3.7">3.7
D&eacute;marrage r&eacute;seau</a></h2>
<p>Deux &eacute;tapes pr&eacute;liminaires sont n&eacute;cessaires
avant que Linux puisse d&eacute;marrer par un r&eacute;seau.
Premi&egrave;rement, vous devrez positionner les variables
d'environnement de SRM pour permettre le d&eacute;marrage
<em>via</em> le protocole <code>bootp</code> et deuxi&egrave;mement
vous devrez configurer une autre machine comme serveur de
d&eacute;marrage. Reportez-vous &agrave; la documentation de SRM
fournie avec votre machine pour toute information sur la mise en
place de <code>bootp</code>. Configurer le serveur de
d&eacute;marrage d&eacute;pend &eacute;troitement du syst&egrave;me
d'exploitation de cette machine, mais typiquement cela
n&eacute;cessite de lancer le programme <code>bootpd</code> en
t&acirc;che de fond apr&egrave;s avoir configur&eacute; le fichier
<code>/etc/bootptab</code>. Le fichier <code>bootptab</code>
poss&egrave;de une entr&eacute;e par machine cliente
autoris&eacute;e &agrave; d&eacute;marrer depuis le serveur. Par
exemple, si vous voulez d&eacute;marrer la machine
<code>myhost.cs.arizona.edu</code>, une entr&eacute;e de la forme
suivante serait n&eacute;cessaire :</p>
<blockquote>
<pre>
<code>myhost.cs.arizona.edu:\
        :hd=/remote/:bf=vmlinux.bootp:\
        :ht=ethernet:ha=08012B1C51F8:hn:vm=rfc1048:\
        :ip=192.12.69.254:bs=auto:
</code>
</pre></blockquote>
<p>Cette entr&eacute;e consid&egrave;re que l'adresse Ethernet de
la machine est <code>08012B1C51F8</code> et que son adresse IP est
192.12.69.254. L'adresse Ethernet peut &ecirc;tre trouv&eacute;e
gr&acirc;ce &agrave; la commande <code>show device</code> de la
console SRM ou, si Linux est lanc&eacute;, avec la commande
<code>ifconfig</code>. L'entr&eacute;e pr&eacute;cise
&eacute;galement que si le client ne d&eacute;clare pas le
contraire, le fichier qui sera lanc&eacute; sera le fichier
<code>vmlinux.bootp</code> du r&eacute;pertoire
<code>/remote</code>. Pour plus d'informations sur la configuration
de <code>bootpd</code>, reportez-vous &agrave; sa page de
manuel.</p>
<p>Ensuite, construiser <code>aboot</code> gr&acirc;ce &agrave; la
commande <code>make netboot</code>. Assurez-vous que le noyau que
vous d&eacute;sirez lancer a d&eacute;j&agrave; &eacute;t&eacute;
construit. Par d&eacute;faut, le <code>Makefile</code> du programme
<code>aboot</code> utilise le noyau
<code>/usr/src/linux/arch/alpha/boot/vmlinux.gz</code>
(&eacute;ditez le <code>Makefile</code> si vous d&eacute;sirez
utiliser un autre chemin d'acc&eacute;s). Le r&eacute;sultat de
<code>make netboot</code> est un fichier nomm&eacute;
<code>vmlinux.bootp</code> contenant <code>aboot</code> <em>et</em>
le noyau Linux, pr&ecirc;t pour le d&eacute;marrage par
r&eacute;seau.</p>
<p>Enfin, copiez <code>vmlinux.bootp</code> dans le
r&eacute;pertoire du serveur de d&eacute;marrage. Dans l'exemple
plus haut, vous l'auriez copi&eacute; dans le r&eacute;pertoire
<code>/remote/</code>. Ensuite, allumez la machine client et
d&eacute;marrez la, en sp&eacute;cifiant l'adaptateur Ethernet
comme p&eacute;riph&eacute;rique de d&eacute;marrage. SRM nomme
typiquement le premier adaptateur Ethernet <code>ewa0</code>, donc,
pour d&eacute;marrer depuis ce p&eacute;riph&eacute;rique, vous
utiliserez la commande :</p>
<blockquote>
<pre>
<code>boot ewa0
</code>
</pre></blockquote>
<p>Les options <code>-fi</code> et <code>-fl</code> sont utilisable
comme d'habitude. En particulier, vous pouvez demander &agrave;
<code>aboot</code> d'attendre l'entr&eacute;e d'arguments pour le
noyau Linux en sp&eacute;cifiant l'option <code>-fl i</code>.</p>
<h2><a name="s4">4. Partager un disque avec Digital Unix</a></h2>
<p>Malheureusement, Digital Unix ne sait rien de Linux, aussi,
partager un disque unique entre les deux syst&egrave;mes n'est pas
totalement simple. Cependant, ce n'est pas une t&acirc;che
difficile si vous suivez les conseils prodigu&eacute;s dans cette
section. Nous consid&eacute;rerons que vous utilisez la version 0.5
ou post&eacute;rieure de <code>aboot</code>.</p>
<h2><a name="ss4.1">4.1 Partitionner le disque</a></h2>
<p>Premi&egrave;rement et avant tout : n'utilisez <em>jamais</em>
les programmes de partitionnement de Linux (<code>minlabel</code>
ou <code>fdisk</code>) sur un disque &eacute;galement
utilis&eacute; par Digital Unix. Le programme Linux
<code>minlabel</code> utilise le m&ecirc;me format de table de
partitions que le programmme <code>disklabel</code> de Digital
Unix, mais il existe des incompatibilit&eacute;s avec les
donn&eacute;es &eacute;crites par <code>minlabel</code>, alors
Digital Unix refusera tout simplement la table de partitions
engendr&eacute;e par <code>minlabel</code>. Pour configurer une
partition Linux <code>ext2</code> sous Digital Unix, vous allez
devoir changer l'entr&eacute;e <em>disktab</em> de votre disque.
Pour illustrer notre propos, supposons que vous avez un disque rz26
(un disque de 1Go) sur lequel vous voulez installer Linux.
L'entr&eacute;e <em>disktab</em> sous Digital Unix v3.2 ressemble
&agrave; (voyez le fichier <code>/etc/disktab</code>) :</p>
<blockquote>
<pre>
<code>rz26|RZ26|DEC RZ26 Winchester:\
        :ty=winchester:dt=SCSI:ns#57:nt#14:nc#2570:\
        :oa#0:pa#131072:ba#8192:fa#1024:\
        :ob#131072:pb#262144:bb#8192:fb#1024:\
        :oc#0:pc#2050860:bc#8192:fc#1024:\
        :od#393216:pd#552548:bd#8192:fd#1024:\
        :oe#945764:pe#552548:be#8192:fe#1024:\
        :of#1498312:pf#552548:bf#8192:ff#1024:\
        :og#393216:pg#819200:bg#8192:fg#1024:\
        :oh#1212416:ph#838444:bh#8192:fh#1024:
</code>
</pre></blockquote>
<p>Les champs int&eacute;ressants ici sont <code>o</code>it/?/; et
<code>p</code><i>?</i>, o&ugrave; <i>?</i> d&eacute;signe une
lettre de l'intervalle <code>a</code>-<code>h</code> (les huit
premi&egrave;res partitions). La valeur <code>o</code> indique
l'adresse du d&eacute;but de la partition (en nombre de secteurs)
et la valeur <code>p</code> donne la taille de la partition
(&eacute;galement en nombre de secteurs). Reportez-vous &agrave;
<code>disktab(4)</code> pour plus d'informations. Notez que Digital
Unix <em>aime</em> d&eacute;finir des partitions qui se
chevauchent. Pour les entr&eacute;es ci-dessus, l'organisation des
partitions ressemble &agrave; cela (vous pouvez v&eacute;rifier en
ajoutant les diverses valeurs <code>o</code> et <code>p</code>)
:</p>
<blockquote>
<pre>
<code>  a     b         d           e           f
|---|-------|-----------|-----------|-----------|

                        c
|-----------------------------------------------|

                     g                 h
            |-----------------|-----------------|
</code>
</pre></blockquote>
<p>Digital Unix insiste pour que la partition <code>a</code>
commence &agrave; l'adresse 0 et que la partition <code>c</code>
couvre l'&eacute;tendue du disque. A part cela, vous pouvez
organiser la table des partitions comme bon vous semble.</p>
<p>Supposons que vous avez Digital Unix utilisant la partition
<code>g</code> et que vous voulez installer Linux sur la partition
<code>h</code> avec la partition <code>b</code> comme partition de
swap. Pour obtenir cette organisation sans d&eacute;truire la
partition Digital Unix existante, vous devez configurer
explicitement les types des partitions. Vous pouvez r&eacute;aliser
ceci en ajoutant un champ <code>t</code> pour chaque partition.
Dans notre cas, nous ajoutons la ligne suivante &agrave;
l'entr&eacute;e <em>disktab</em>.</p>
<blockquote>
<pre>
<code>        :ta=unused:tb=swap:tg=4.2BSD:th=reservd8:
</code>
</pre></blockquote>
<p>Pourquoi avons-nous marqu&eacute; la partition <code>h</code>
comme "reservd8" plut&ocirc;t que comme "ext2" ? Bon, Digital Unix
ne connait rien de Linux. Une partition de type "ext2" correspond
&agrave; une valeur num&eacute;rique de 8, et Digital Unix utilise
la ch&acirc;ne "reservd8" pour cette valeur. Donc, dans le langage
de Digital Unix, "reservd8" signifie "ext2". Ceci &eacute;tait la
partie hardue. Maintenant, il ne nous reste plus qu'&agrave;
installer la nouvelle entr&eacute;e <em>disktab</em> sur le disque.
Consid&eacute;rons que le disque &agrave; l'ID SCSI 5. Dans ce cas,
nous faisons :</p>
<blockquote>
<pre>
<code>disklabel -rw /dev/rrz5c rz26
</code>
</pre></blockquote>
<p>Vous pouvez v&eacute;rifier que tout va bien en lisant le
<em>disklabel</em> gr&acirc;ce &agrave; la commande <code>disklabel
-r /dev/rrz5c</code>. A ce point, vous pouvez vouloir
red&eacute;marrer Digital Unix et vous assurer que la partition
Digital Unix est encore pr&eacute;sente et en bon &eacute;tat. Si
c'est le cas, vous pouvez arr&eacute;ter la machine et commencer
l'installation de LInux. Prenez soin de sauter l'&eacute;tape de
partitionnement du disque lors de la proc&eacute;dure
d'installation. Sachant que nous avons d&eacute;j&agrave;
install&eacute; une table de partitions correcte, vous devriez
&ecirc;tre capable de proc&eacute;der &agrave; cette
op&eacute;ration et de s&eacute;lectionner la huiti&egrave;me
partition comme partition racine de Linux et la deuxi&egrave;me
comme partition de swap. Si le disque est le deuxi&egrave;me disque
SCSI de la machine, les noms de p&eacute;riph&eacute;riques pour
ces deux partitions seront <code>/dev/sdb8</code> et
<code>/dev/sdb2</code>, respectivement (notez que Linux utilise des
lettre pour d&eacute;signer les disques et des num&eacute;ros pour
d&eacute;signer les partitions, exactement &agrave; l'inverse de
Digital Unix ; le sch&eacute;ma de Linux a plus de sens bien
s&ucirc;r ;-).</p>
<h2><a name="ss4.2">4.2 Installer <code>aboot</code></a></h2>
<p><em>Premier obstacle</em> : avec le <em>firmware</em> --&gt; --
SRM, vous ne pouvez d&eacute;marrer qu'un et un seul syst&egrave;me
d'exploitation par disque. Pour cette raison, il est
g&eacute;n&eacute;ralement pr&eacute;f&eacute;rable de disposer
d'au moins deux disques SCSI dans une machine sur laquelle vous
d&eacute;sirez utiliser aussi bien Linux que Digital Unix. Bien
s&ucirc;r vous pouvez aussi d&eacute;marrer Linux depuis une
disquette si la vitesse importe peu, ou par un r&eacute;seau, si
vous disposez d'un serveur <code>bootp</code>. Mais dans cette
partie, nous consid&eacute;rerons que vous souhaitez
d&eacute;marrer Linux depuis un disque contenant une ou plusieurs
partitions Digital Unix.</p>
<p><em>Deuxi&egrave;me obstacle</em> : installer <code>aboot</code>
sur un disque partag&eacute; avec Digital Unix rend les
premi&egrave;re et troisi&egrave;me partitions inutilisables
(sachant qu'elles doivent commencer &agrave; l'adresse 0). Pour
cette raison, nous vous recommandons de changer la taille de la
partition <code>a</code> &agrave; une valeur juste suffisament
&eacute;lev&eacute;e pour contenir <code>aboot</code> (1Mo devrait
convenir).</p>
<p>Une fois que ces deux obstacles sont surmont&eacute;s, installer
<code>aboot</code> est aussi simple que d'habitude : comme les
partitions <code>a</code> et <code>c</code> vont recouvrir
<code>aboot</code> , nous devons sp&eacute;cifier &agrave;
<code>swriteboot</code> que ceci est intentionnel . Nous pouvons le
faire sous Linux avec une ligne de commande de la forme suivante
(de nouveau, nous supposerons que l'on veut installer
<code>aboot</code> sur le deuxi&egrave;me disque SCSI) :</p>
<blockquote>
<pre>
<code>swriteboot -f1 -f3 /dev/sdb bootlx
</code>
</pre></blockquote>
<p>Le param&egrave;tre <code>-f1</code> signifie que nous voulons
forcer l'&eacute;criture de <code>bootlx</code> m&ecirc;me s'il
recouvre la premi&egrave;re partition. La m&ecirc;me chose
s'applique &agrave; la troisi&egrave;me partition.</p>
<p>C'est tout. Vous devriez d&eacute;sormais pouvoir arr&eacute;ter
le syst&egrave;me et lancer Linux depuis le disque dur. Dans notre
exemple, la ligne de commande SRM pour le faire serait :</p>
<blockquote>
<pre>
<code>boot dka5 -fi 8/vmlinux.gz -fl root=/dev/sdb8
</code>
</pre></blockquote>
</body>
</html>
doc-linux-fr-html 2013.01-2 / usr / share / doc / HOWTO / fr-html / SRM-HOWTO.html
