Une clef USB polyvalente à base de Slackware Linux

La Slackware est fournie avec une image contenant un système minimal et un programme d’installation destiné à être copié sur une clef USB, ladite clef pouvant alors servir de média d’installation de la distribution. Le fichier usb-and-pxe-installers/README_USB.txt contient toutes les informations nécessaires pour utiliser cette image.

Néanmoins, ces instructions ne permettent que d’installer une copie du programme d’installation (soit environ 25 Mo) sur une clef USB. Si la clef est plus volumineuse (ce qui est aujourd’hui la norme), l’espace en sus est inutilisé et inutilisable.

Inutilisable ? Pas tout-à-fait. Il est possible d’aller un peu plus loin que ne le propose le seul fichier README_USB.txt. Je montre ici comment créer une clef USB contenant plusieurs versions du programme d’installation de la Slackware (par exemple, un pour la Slackware 32 bits et un pour la 64 bits), avec la possibilité pour l’utilisateur de sélectionner au démarrage celui qu’il veut lancer.

1.1. Préparation de la clef

Vous êtes bien sûr censés avoir une clef USB à votre disposition, ne contenant aucune donnée (du moins aucune donnée que vous préféreriez ne pas perdre — tout son contenu sera effacé). Branchez-là. S’il y a déjà un système de fichiers sur la clef (la plupart des clefs sont vendues pré-formattées en FAT32), ne le montez pas ; démontez-le s’il a déjà été monté automatiquement par HAL.

Utilisez fdisk (ou cfdisk, ou ce que vous voulez) pour partitionner la clef. Créez autant de partitions que vous voulez de versions différentes de l’installeur Slackware. Les partitions doivent bien sûr être assez grandes pour accueillir l’image de l’installeur, et un peu de marge ne peut pas faire de mal — pour ma part j’opte pour des partitions de 50 Mo, soit le double du minimum requis. Inutile de créer un système de fichiers sur ces partitions.

Copiez les installeurs Slackware sur chacune des partitions nouvellement créées :

# dd if=slackware-13.1/usb-and-pxe-installers/usbboot.img of=/dev/sdb1
# dd if=slackware64-13.1/usb-and-pxe-installers/usbboot.img of=/dev/sdb2

	Attention
	Je vous laisse vérifier, avant de préférence, que /dev/sdb correspond bien à votre clef USB, et non par exemple à votre deuxième disque dur SATA…

À présent, montez les partitions et examinez leur contenu. Elles doivent contenir, entre autres fichiers, un noyau Linux. Lorsque l’image de l’installeur est copiée sur une clef non-partitionnée, le MBR de la clef contient le code nécessaire pour trouver et charger ce noyau au démarrage de la machine. Maintenant que nous avons plusieurs noyaux sur plusieurs partitions, pour pouvoir démarrer l’un d’eux nous avons besoin d’un chargeur de démarrage pour :

• afficher un prompt ou un menu permettant de sélectionner le noyau (et donc l’installeur) à démarrer ;

• charger effectivement le noyau sélectionné.

boot=/dev/sdb
compact
lba32
vga=769
prompt
timeout=20
install=text

# Slackware 13.1 installer
image=/mnt/tmp/slack/hugesmp.s
  initrd=/mnt/tmp/slack/initrd.img
  label=slack

# Slackware64 13.1 installer
image=/mnt/tmp/slack64/huge.s
  initrd=/mnt/tmp/slack64/initrd.img
  label=slack64

# /sbin/lilo -b /dev/sdb -C /mnt/tmp/slack/lilo.conf -m /mnt/tmp/slack/lilo.map

Plusieurs versions du programme d’installation sur une clef USB, c’est déjà bien pratique, mais à raison d’environ 25 Mo par installeur, on est loin de remplir une clef un tant soit peu récente. Qu’à cela ne tienne, il suffit d’utiliser la place encore disponible pour distribution GNU/Linux « Live » ! La clef se transforme ainsi en petit couteau suisse, permettant tantôt :

Parmi les distributions « live », j’ai opté pour Slax, mais ce qui suit devrait être adaptable à d’autres sans difficultés majeures.

Préparez une nouvelle partition sur la clef, d’au moins 250 Mo, et créez-y un système de fichiers VFAT. Téléchargez l’archive de la Slax for USB (version 6.1.2 à l’heure où j’écris ces lignes) et détarrez-là à la racine de la partition nouvellement créée.

Ne suivez pas les instructions du site officiel, qui vous invitent à exécuter le script boot/bootinst.sh pour rendre la clef « bootable » : cela fonctionne très bien, mais ne permettrait par la suite que de démarrer Slax, laissant de côté nos installeurs Slackware sur les autres partitions.

À la place, nous allons installer nous-mêmes LILO en reprenant le fichier de configuration que nous avons déjà utilisé ci-dessus, en y ajoutant au moins une section pour démarrer Slax. En supposant que la partition de la Slax est montée sur /mnt/tmp/slax :

image=/mnt/tmp/slax/boot/vmlinuz
  initrd=/mnt/tmp/slax/boot/initrd.gz
  label=slax
  append="ramdisk_size=6666 root=/dev/ram0 rw autoexec=xconf;telinit~4 changes=/slax/"

Vous pouvez ajouter d’autres section pour démarrer la Slax dans différents modes, en changeant les paramètres passés au noyau Linux (« append »). Pour connaître les modes disponibles et les paramètres correspondants, consultez le fichier slax.cfg fourni avec la Slax.

Reste à installer LILO. La commande est la même que précédemment. Assurez-vous que toutes les partitions de la clef (celles contenant les installeurs et celle contenant la Slax) sont montées, et que leur point de montage correspond aux chemins mentionnés dans le fichier de configuration de LILO.

Note

Lors de son installation, LILO peut émettre le message d’avertissement suivant : Warning: The initial RAM disk is too big to fit between the kernel and the 15M-16M memory hole. It will be loaded in the highest memory as though the configuration file specified "large-memory" and it will be assumed that the BIOS supports memory moves above 16M. qui nous apprend que la clef pourrait ne pas être bootable sur certaines vieilles machines. Vieilles comment ? Je ne sais pas. Je n’ai encore jamais rencontré ce problème avec aucun ordinateur. Je présume que la probabilité de trouver une machine concernée par ce problème est déjà faible et ne fera que diminuer encore plus avec le temps. Comme le message le laisse supposer, l’avertissement peut être supprimé en rajoutant l’option large-memory dans la section globale du fichier de configuration de LILO.

J’ai récemment remplacé ma clef « multi-install » de 2 Go par une nouvelle clef de 16 Go. Je l’ai partitionnée comme suit :

Cette version de la clef permet donc d’installer une Slackware64 en toute autonomie (puisqu’elle contient à la fois le programme d’installation et tous les paquets) ; elle permet également d’initier l’installation d’une Debian, une connexion Internet étant toutefois requise pour télécharger l’essentiel des paquets ; et comme précédemment, elle permet de démarrer sur un système live.

Pour mémoire, voici en bref comment reproduire cette clef, une fois le partitionnement ci-dessus réalisé (en supposant que la clef est représentée par le périphérique /dev/sdb).

Création de l’installateur Slackware :

# dd if=slackware64-14.0/usb-and-pxe-installers/usbboot.img of=/dev/sdb1
# mkdosfs /dev/sdb2
# mount /dev/sdb2 /mnt/tmp
# cp -r slackware64-14.0/{extra,kernels,patches,testing,slackware64} /mnt/tmp/
# umount /dev/sdb2

Création de l’installeur Debian :

# dd if=debian-6.0.2.i-i386-netinst.iso of=/dev/sdb3

Installation de Slax :

# mkdosfs /dev/sdb5
# mount /dev/sdb5 /mnt/tmp
# unzip slax-English-US-7.0.8-x86_64.zip -d /mnt/tmp
# rm /mnt/tmp/slax/slax.txt
# umount /dev/sdb5

Pour installer le chargeur de démarrage, commencer par monter les trois partitions contenant un système bootable dans une arborescence temporaire :

# mkdir /mnt/tmp/{slackboot,debian,slax}
# mount /dev/sdb1 /mnt/tmp/slackboot
# mount /dev/sdb3 /mnt/tmp/debian
# mount /dev/sdb5 /mnt/tmp/slax

Puis, créer le fichier de configuration de LILO comme suit :

boot=/dev/sdb
compact
lba32
large-memory
vga=769
prompt
timeout=20
install=text

# Slackware64-14.0 installer
#############################
image=/mnt/tmp/slackboot/huge.s
  initrd=/mnt/tmp/slackboot/initrd.img
  label=slackware

# Debian (i386) 6.0.2.1 (netinst)
#################################
image=/mnt/tmp/debian/install.386/vmlinuz
  initrd=/mnt/tmp/debian/install.386/initrd.gz
  label=debian

# Slax 7.0.8
############

# Normal mode with full autoconfiguration
image=/mnt/tmp/slax/slax/boot/vmlinuz
  initrd=/mnt/tmp/slax/slax/boot/initrfs.img
  label=slax
  append="load_ramdisk=1 prompt_ramdisk=0 printk.time=0 slax.flags=xmode,perch"

# Normal mode without persistent changes
image=/mnt/tmp/slax/slax/boot/vmlinuz
  initrd=/mnt/tmp/slax/slax/boot/initrfs.img
  label=slax-fresh
  append="load_ramdisk=1 prompt_ramdisk=0 printk.time=0 slax.flags=xmode"
  
# Normal mode + copy everything to RAM
image=/mnt/tmp/slax/slax/boot/vmlinuz
  initrd=/mnt/tmp/slax/slax/boot/initrfs.img
  label=slax-cp2ram
  append="load_ramdisk=1 prompt_ramdisk=0 printk.time=0 slax.flags=xmode,toram"

# Console mode
image=/mnt/tmp/slax/slax/boot/vmlinuz
  initrd=/mnt/tmp/slax/slax/boot/initrfs.img
  label=slax-text
  append="load_ramdisk=1 prompt_ramdisk=0 printk.time=0 slax.flags=perch"

Enregistrer le fichier dans /mnt/tmp/slackboot/lilo.conf puis installer effectivement LILO sur la clef :

# /sbin/lilo -b /dev/sdb -C /mnt/tmp/slackboot/lilo.conf -m /mnt/tmp/slackboot/lilo.map

Six ans après la dernière mise à jour de cet article, j’utilise toujours ma « clef polyvalente », mais celle-ci a subi quelques changements majeurs, rendant les sections précédentes complètement obsolètes. Cette clef contient désormais :

Par ailleurs, j’utilise désormais GRUB au lieu de LILO et la clef peut démarrer à la fois sur un ordinateur équipé indifféremment d’un BIOS ou d’un firmware UEFI (les versions précédentes ne permettaient de démarrer qu’à partir d’un BIOS, ou un firmware UEFI en mode legacy CSM).

4.1. Partitionnement

	Note
	Dans tout ce qui suit, on supposera, comme précédemment, que la clef USB est représentée par le périphérique /dev/sdb.

Utilisez l’outil de votre choix (j’utilise généralement cgdisk) pour partitionner la clef, en vous assurant de créer une table de partitions au format GPT et non MBR (c’est automatiquement le cas si vous utilisez cgdisk). Créez les partitions suivantes sur la clef :

• une partition de type BIOS boot partition (code EF02 dans cgdisk) de 1 Mo ;

• une partition de type EFI system partition (code EF00) de 50 Mo ;

• une partition de type Linux filesystem (code 8300) de 50 Mo ; cette partition accueillera le programme d’installation de Slackware, nous l’appellerons SLACKINST ;

• une seconde partition de type Linux filesystem, d’au moins 4 Go (8 Go chez moi) ; cette partition accueillera les paquets de la distribution, nous l’appellerons SLACKDATA ;

• une troisième partition Linux filesystem d’au moins 2 Go, pour accueillir la distribution Slackware Live ; nous l’appelerons SLACKLIVE.

S’il vous reste encore de l’espace libre, vous pouvez soit augmenter la taille de la partition SLACKLIVE, soit créer des partitions supplémentaires à votre guise. Personnellement j’ai ajouté une partition de type Microsoft basic data (code 0700).

Formattez les partitions nouvellement créees à l’exception de la première (celle de type BIOS boot partition : cette partition ne sera utilisée que par GRUB, qui n’a pas besoin qu’un système de fichiers y soit présent) :

# mkfs.fat -F32 /dev/sdb2
# mkfs.ext4 /dev/sdb3
# mkfs.ext4 /dev/sdb4
# mkfs.ext4 /dev/sdb5
# mkfs.fat /dev/sdb6

Créez une série de dossiers qui serviront de points de montage pour chacune des partitions pour les prochaines opérations :

# mkdir /mnt/multikey/{efi,slackinst,slackdata,slacklive}
# mount /dev/sdb2 /mnt/multikey/efi
# mount /dev/sdb3 /mnt/multikey/slackinst
# mount /dev/sdb4 /mnt/multikey/slackdata
# mount /dev/sdb5 /mnt/multikey/slacklive

# mount -o loop $SLACKROOT/usb-and-pxe-installers/usbboot.img /mnt/tmp
# rsync -r --exclude=EFI /mnt/tmp/ /mnt/multikey/slackinst
# umount /mnt/tmp

# mkdir -p /mnt/multikey/slackdata/slackware64-14.2
        # rsync -r $SLACKROOT/slackware64 /mnt/multikey/slackdata/slackware64-14.2

# mount -o loop slackware-live-xfce-current.iso /mnt/cdrom
# rsync -rlptD --no-inc-recursive --info=progress2 --exclude=EFI \
    /mnt/cdrom/* /mnt/multikey/slacklive

# grub-install --target=x86_64-efi --recheck --removable \
    --efi-directory=/mnt/multikey/efi --boot-directory=/mnt/multikey/efi

# grub-install --target=i386-pc --recheck \
    --boot-directory=/mnt/multikey/efi /dev/sdb

# blkid /dev/sdb3
/dev/sdb3: UUID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
# blkid /dev/sdb5
/dev/sdb5: UUID="zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz"

set default=0
set timeout=10

insmod all_video
insmod ext2
insmod search_fs_uuid

menuentry "Slackware installer" --hotkey i {
  search --no-floppy --set=root --fs-uuid xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
  linux /huge.s
  initrd /initrd.img
}

menuentry "Slackware Live Edition" --hotkey b {
  search --no-floppy --set=root --fs-uuid zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz
  linux /boot/generic load_ramdisk=1 prompt_ramdisk=0 rw printk.time=0
  initrd /boot/initrd.img
}