# GRUB (Français)/Tips and tricks (Français)

From ArchWiki
< GRUB (Français)
Jump to navigation Jump to search
The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.

## Méthodes d'Installation Alternatives

### Installation sur clef USB externe

#### BIOS

En présumant que la première partition de votre clef USB soit formatée en `FAT32` et reconnue en tant que `/dev/sdy1`

    # mkdir -p /mnt/usb
    # mount /dev/sdy1 /mnt/usb
    # grub-install --target=i386-pc --debug --boot-directory=/mnt/usb/boot /dev/sdy
    # grub-mkconfig -o /mnt/usb/boot/grub/grub.cfg

Sauvegarde optionnelle des fichiers de configuration de `grub.cfg`:

    # mkdir -p /mnt/usb/etc/default
    # cp /etc/default/grub /mnt/usb/etc/default
    # cp -a /etc/grub.d /mnt/usb/etc

    # sync; umount /mnt/usb

#### EFI

Pour que grub écrive l'image EFI sur `/boot/efi/EFI/BOOT/BOOTX64.efi` que le firmware d'amorçage puisse trouver sans ajout d'entrée de démarrage UEFI, utiliser l'option `--removable` en lançant la commande `grub-install`.

### Installer sur une partition ou un disque sans partition

Attention: GRUB décourage fortement l'installation sur un secteur d'amorçage de partition, ou sur un disque sans partition, comme le font GRUB Legacy ou Syslinux. Cette configuration sera encline à se rompre, en particulier lors des mises à jour, et n'est pas prise en charge par les développeurs Arch.

Pour configurer grub sur un secteur de démarrage de partition, sur un disque sans partition (également appelé 'superfloppy') ou sur une disquette, lancez (par exemple pour une partition `/boot` en `/dev/sdaX`):

    # chattr -i /boot/grub/i386-pc/core.img
    # grub-install --target=i386-pc --debug --force /dev/sdaX
    # chattr +i /boot/grub/i386-pc/core.img

Note:

- `/dev/sdaX` n'est qu'un exemple.
- L'option `--target=i386-pc` argumente `grub-install` pour l'installation d'un système BIOS uniquement. Il est recommandé de toujours utiliser cette option pour enlever toute ambiguïté à la commande grub-install.

Vous devez ajouter l'option `--force` pour autoriser l'utilisation de la notation en blocklists et ne devriez pas utiliser `--grub-setup=/bin/true` (qui équivaut à simplement créer `core.img`).

La commande `grub-install` gènérerera des avertissements qui devraient vous donner une idée de ce qui pourrait mal tourner avec cette approche:

    /sbin/grub-setup: warn: Attempting to install GRUB to a partitionless disk or to a partition. This is a BAD idea.
    /sbin/grub-setup: warn: Embedding is not possible. GRUB can only be installed in this setup by using blocklists.
                            However, blocklists are UNRELIABLE and their use is discouraged.

En l'absence de `--force` vous obtiendriez le message d'erreur ci-dessous et `grub-setup` n'installera pas le code de démarrage dans le secteur-racine de la partition:

    /sbin/grub-setup: error: will not proceed with blocklists

Avec `--force` vous obtiendrez:

    Installation finished. No error reported.

La raison pour laquelle `grub-setup` n'autorise pas ceci, par défaut, est que dans le cas d'une partition ou d'un disque sans partition GRUB s'appuie sur les listes de blocs embarqués dans le secteur-boot de partition pour localiser le fichier `/boot/grub/i386-pc/core.img` et le répertoire de préfixe /boot/grub. Les emplacements de secteur de `core.img` peuvent changer à chaque modification du système de fichiers de la partition (fichiers copiés, supprimés etc.). Informations supplémentaires: https://bugzilla.redhat.com/show_bug.cgi?id=728742 et https://bugzilla.redhat.com/show_bug.cgi?id=730915.

La solution de contournement est de placer le drapeau immuable sur `/boot/grub/i386-pc/core.img` (en utilisant la commande `chattr` telle que ci-dessus) afin que les secteurs d'emplacement du fichier `core.img` sur le disque ne puissent être modifiés. Cette attribution d'interdiction de modification à `/boot/grub/i386-pc/core.img` n'a besoin d'être donnee que dans ce cas de GRUB installé dans le secteur-boot de la partition ou sur un disque non partitionné, et non dans le cas d'installation dans le MBR ou de simple generation de `core.img` sans incrustation dans le secteur de boot (comme décrit ci-dessus).

Malheureusement le fichier `grub.cfg` créé ne contiendra pas l'UUID correcte pour le démarrage, même en l'absence de message d'erreur. Voir https://bbs.archlinux.org/viewtopic.php?pid=1294604#p1294604. Pour y remédier:

    # mount /dev/sdxY /mnt        #Your root partition.
    # mount /dev/sdxZ /mnt/boot   #Your boot partition (if you have one).
    # arch-chroot /mnt
    # pacman -S linux
    # grub-mkconfig -o /boot/grub/grub.cfg

### Créer le core.img seul

Pour remplir le répertoire `/boot/grub` et générer un fichier `/boot/grub/i386-pc/core. img` sans intégrer de code de démarrage GRUB dans le MBR, la région post-MBR ou le bootsector de la partition, ajoutez: `--grub-setup=/bin/true` à `grub-install`:

    # grub-install --target=i386-pc --grub-setup=/bin/true --debug /dev/sda

Note:

- `/dev/sda` n'est qu'un exemple.
- `--target=i386-pc` argumente `grub-install` pour l'installation d'un système BIOS uniquement. Il est recommandé de toujours utiliser cette option pour enlever toute ambiguïté à la commande grub-install.

Vous pouvez ensuite chaîner le fichier `core.img` de GRUB Legacy ou de syslinux en tant que noyau Linux ou en tant que noyau multiboot (voir aussi Syslinux (Français)#Chaînage).

## Outils de configuration en Interface Graphique

On peut installer les paquets suivants:

- grub-customizer — Personnaliseur GTK+ pour GRUB ou BURG

  https://launchpad.net/grub-customizer || grub-customizer

- grub2-editor-frameworks — Portage KF5 non officiel de grub2-editor

  https://github.com/maz-1/grub2-editor || grub2-editor-frameworksAUR[broken link: package not found]

- startupmanager — Application graphique de configuration pour GRUB Legacy, GRUB, Usplash et Splashy (abandonned)

  https://sourceforge.net/projects/startup-manager/ || startupmanagerAUR[broken link: package not found]

## Configuration de l'apparence

Dans GRUB il est possible, par défaut, de changer l'aspect du menu. Assurez vous, si ce n'est déjà fait, d'initialiser le terminal graphique de GRUB, gfxterm, dans le mode video adéquat, gfxmode, de GRUB. Voir la section correspondante du manuel :"No suitable mode found" error (en)[broken link: invalid section]. Grub passe ce mode vidéo au noyau linux via 'gfxpayload' afin que soit effective toute configuration visuelle ayant besoin de ce mode.

### Configurer la résolution du framebuffer

GRUB peut définir le framebuffer, à la fois pour GRUB lui-même et pour le noyau. Ne plus utiliser le mode `vga=`, obsolète. Éditez plutôt `/etc/default/grub` ainsi, exemple:

    GRUB_GFXMODE=1024x768x32
    GRUB_GFXPAYLOAD_LINUX=keep

On peut spécifier plusieurs résolutions, y compris le mode par défaut: `auto`, il est donc recommandé d'éditer la ligne pour ressembler à `GRUB_GFXMODE=<résolution souhaitée>,<résolution 'fallback' telle que 1024x768>,auto`. Plus d'informations dans ce paragraphe du manuel: the GRUB gfxmode documentation. Définir la valeur de gfxpayload vous assure que le noyau conserve la résolution.

Note:

- On ne pourra utiliser que les modes supportés par la carte graphique via VESA BIOS Extensions. Pour en avoir la liste, installer hwinfo et lancer, en root, `hwinfo --framebuffer`. Alternativement on pourra entrer dans le mode commande de GRUB au lancement et lancer `videoinfo`.
- Les versions antérieures du pilote propriétaire NVIDIA (testé avec GeForce GTX 970, et pilote: nvidia 370) acceptent `GRUB_GFXMODE` dans le format `<width>x<height>-<depth>` (ex. `1920x1200-24`, mais non `1920x1200x24`). Cela ne semble pas s'appliquer aux cartes et aux pilotes plus récents. This does not appear to apply to newer cards and drivers. Les cartes NVidia d'architecture Pascal avec les pilotes les plus récents (testé avec GeForce GTX 1060 et nvidia 381.22) ne fonctionneront pas avec le format suggéré et tenter de l'utiliser entraîne de graves problèmes, y compris, mais pas seulement, des plantages du système et des blocages durs. Le pilote et les cartes actuels sont mieux configurés avec `GRUB_GFXMODE` au format standard `<width>x<height>x<depth>`.
- Ne pas oublier de lancer `grub-mkconfig -o /boot/grub/grub.cfg` après toute modification d'`/etc/default/grub`.

Si cette méthode ne fonctionne pas pour vous, l'instruction obsolète `vga=` fonctionne encore. L'ajouter simplement dans la ligne `"GRUB_CMDLINE_LINUX_DEFAULT="` du `/etc/default/grub` par exemple: `"GRUB_CMDLINE_LINUX_DEFAULT="quiet splash vga=792"` pour une résolution `1024x768`.

     Notez bien cependant qu'elle entre en conflit avec le [[Kernel mode setting (Français)#Installation|Kernel Mode Setting]

### Hack de résolution 915

Parfois pour les adaptateurs graphiques Intel, ni `# hwinfo --framebuffer`, ni `videoinfo` ne vous indiquent la résolution souhaitée. En ce cas vous pouvez utiliser le 'hack' `915resolution`. Ce hack modifiera temporairement les paramètres vidéo du BIOS et y ajoutera la résolution souhaitée. Voir la page de 915resolution. Paquet disponible ici: 915resolutionAUR

Vous devez d'abord trouver un mode vidéo qui sera modifié ultérieurement. Pour cela il y aura la commande dans le terminal GRUB:

    sh:grub> 915resolution -l

    Intel 800/900 Series VBIOS Hack : version 0.5.3
    [...]
    Mode 30 : 640x480, 8 bits/pixel
    [...]

Puis nous écrasons le `Mode 30` avec la résolution `1440x900`:

    /etc/grub.d/00_header

    [...]
    915resolution 30 1440 900  # Ligne insérée
    set gfxmode=${GRUB_GFXMODE}
    [...]

Enfin il faut instruire `GRUB_GFXMODE` comme décrit plus haut, régénérer `grub.cfg` et redémarrer pour tester la modification.

### Image d'arrière-plan et Polices bitmap

GRUB est fourni avec le support d'une image d'arrière-plan et de polices bitmap au format `pf2`. La police unifont est incluse dans le paquet grub sous le nom de `unicode.pf2`, ou seulement les caractères ASCII avec le nom `ascii.pf2`.

Les formats d'image supportés sont tga, png et jpeg, à condition que les bons modules soient chargés. La résolution maximale prise en charge dépend de votre matériel.

Assurez-vous d'avoir configuré la bonne . résolution de framebuffer.

Éditer`/etc/default/grub` ainsi:

    GRUB_BACKGROUND="/boot/grub/myimage"
    #GRUB_THEME="/path/to/gfxtheme"
    GRUB_FONT="/path/to/font.pf2"

Note: Si vous avez installé GRUB sur une partition séparée, `/boot/grub/myimage` elle deviendra automatiquement `/grub/myimage` dans le fichier `grub.cfg`.

Régénérez `grub.cfg` pour appliquer les modifications. Si l'ajout de l'image splash a réussi, l'utilisateur verra `"Found background image..."` dans le terminal pendant l'éxécution de la commande. En l'absence de cette notification l'image n' a probablement pas été incorporée dans le fichier `grub.cfg`.

    Si l'image ne s'est pas affichée, vérifiez:

- L'exactitude de son emplacement (path) et de son nom dans `/etc/default/grub`
- Qu'elle soit de taille et de format (tga, png, 8-bit jpg) adaptés
- Que l'image ait été enregistrée en mode RVB et ne soit pas indexée.
- Que le mode console n'ait pas été activé dans `/etc/default/grub`
- De ne pas avoir oublié d’exécuter la commande `grub-mkconfig` pour qu'emplacement et nom aient été renseignés dans le fichier `/boot/grub/grub.cfg`
- Les scripts de `grub-mkconfig` n'incluant pas d'apostrophes d'échappement dans les noms, vérifiez que celui de l'image ne contienne pas d'espaces `grub.cfg`

### Theme

Voici un exemple de configuration du thème Starfield inclus dans le paquet GRUB.

Éditer `/etc/default/grub`

    GRUB_THEME="/usr/share/grub/themes/starfield/theme.txt"

Régénérer `grub.cfg` pour appliquer les modifications. Si la configuration du thème a été réussie, vous verrez la notification `Found theme: /usr/share/grub/themes/starfield/theme.txt` dans le terminal.

Une image splash autre n'est habituellement pas utilisée quand un thème est appliqué.

### Couleurs du Menu

Vous pouvez régler les couleurs du menu de GRUB. Les couleurs disponibles peuvent être trouvées dans le manuel de GRUB. Un exemple:

Éditer `/etc/default/grub`:

    GRUB_COLOR_NORMAL="light-blue/black"
    GRUB_COLOR_HIGHLIGHT="light-cyan/blue"

### Menu caché

L'une des caractéristiques uniques de GRUB est de cacher/sauter le menu et de ne l'afficher que par maintien enfoncé de la touche `Esc`. Vous pouvez également régler la possibilité de voir le compteur de temporisation.

Modifiez `/etc/default/grub` pour cette fonction: voici les lignes à ajouter pour l'activer, le délai d'attente a été réglé sur 5 secondes et doit être affiché à l'utilisateur:

    GRUB_TIMEOUT=5
    GRUB_TIMEOUT_STYLE='countdown'

GRUB_TIMEOUT est le temps en secondes avant affichage du menu.

### Désactiver le framebuffer

Les utilisateurs du pilote propriétaire NVIDIA peuvent souhaiter la désactivation du framebuffer de GRUB en cas de problemes avec le pilote binaire.

Pour cela, éditer `/etc/default/grub` et dé-commentez la ligne:

    GRUB_TERMINAL_OUTPUT=console

Autre option, pour garder le framebuffer dans GRUB, est de revenir au mode texte juste avant le démarrage du noyau. Modifier alors la variable de `/etc/default/grub`:

    GRUB_GFXPAYLOAD_LINUX=text

## Démarrage direct sur un fichier d'image ISO9660 par GRUB

GRUB permet le démarrage sur des images ISO directement, par le biais de dispositifs "loopback" (boucle rétroactive), voir Using GRUB and loopback devices (en) pour exemples.

### Exemples utiles:

#### SystemRescueCD

    Récupérer l'image RescueCD, la copier en tant que /etc/boot/systemrescuecd.iso  - Attention: une partition boot séparée de taille insuffisante ne le permet pas !

Ajouter (sans supprimer l'en-tête, et en adaptant root='(hd0,3)' à la localisation effective de `/boot` ), au fichier `/etc/grub.d/40_custom`,

le menu:

    menuentry "SystemRescueCD" --class gentoo {
    insmod loopback
    insmod iso9660
    root='(hd0,3)'
    set isofile="/boot/systemrescuecd.iso"
    loopback loop $isofile
    linux (loop)/isolinux/rescue64 isoloop=$isofile rootfs=/sysresccd setkmap=fr
    initrd (loop)/isolinux/initram.igz
    }

#### Archiso

    Récupérer la dernière iso d'installation ou une image archiso que vous avez construite vous-même

Suivez les indications du Wiki (en), par exemple :

1. copiez par exemple l'archlinux-2018.10.01-x86_64.iso dans /boot (sous un nom générique pour ne pas avoir à modifier le 40_custom à chaque mise à jour de l'iso)

    # cp /path_to_iso/archlinux-2018.10.01-x86_64.iso /boot/archlinux.iso (ou boot/iso/archlinux.iso mais adaptez la suite en ce cas)

2. ajoutez au 40_custom :

    # path to the partition holding ISO images (using UUID)
    set imgdevpath="/dev/disk/by-uuid/***UUID de la partition de boot***"  ## utiliser blkid pour l'obtenir

    menuentry "archiso" {
    insmod search_fs_uuid
    search --no-floppy --set=isopart --fs-uuid UUID de la partition de boot
    set isofile='/boot/archlinux.iso'
    loopback loop ($isopart)$isofile
    linux (loop)/arch/boot/x86_64/vmlinuz img_dev=$imgdevpath img_loop=$isofile earlymodules=loop
    initrd (loop)/arch/boot/intel_ucode.img (loop)/arch/boot/x86_64/archiso.img
    }

Enfin régénérer le `/boot/grub/grub.cfg` et, en dépannage, booter sur une de ces images plus simplement que si vous les aviez copiées sur clef-USB avec, le plus souvent obligation d'éditer le bios pour autoriser le boot sur clef USB, (vous avez certainement désactivé cet accès et imposé un mot de passe pour le modifier!..)

## Identification persistante d'un 'block device'

Un schéma d'identification par nom persistant est l'attribution d'une UUID, mondialement unique, aux partitions et blocs périphériques au lieu des "anciennes" `/dev/sd*`.Les avantages sont décrits dans le lien précédent.

Cette identité des systèmes de fichiers en UUIDs est utilisé par défaut dans GRUB.

Note: Le fichier `/boot/grub.cfg` doit être régénéré avec la(les) nouvelle(s) UUID dans `/etc/default/grub` à chaque modification d'un système de fichiers: redimensionnement, création, formatage. Se souvenir de ceci quand on modifie partitions ou systèmes de fichiers depuis une session en CD/USB-Live.

Le contrôle de l'alternative aux UUIDs se fait par l'option, dans `/etc/default/grub`:

    GRUB_DISABLE_LINUX_UUID=true

## Usage de labels

L'étiquettage par labels significatifs, chaînés aux système de fichiers, se fait en utilisant l'option `--label` à `search`. Commencer par donner un LABEL à votre partition:

    # tune2fs -L LABEL PARTITION

Puis ajouter une entrée qui utilise ce label. Un exemple:

    menuentry "Arch Linux, session texte" {
      search --label --set=root archroot
      linux /boot/vmlinuz-linux root=/dev/disk/by-label/archroot ro
      initrd /boot/initramfs-linux.img
    }

## Protection du menu GRUB par Mot de Passe

Attention: Si quelqu'un a un accès physique à votre machine et est autorisé par le BIOS à démarrer depuis un support externe (CD/USB-Live), il lui sera facile de modifier les fichiers de configuration de GRUB pour contourner la protection par mot de passe, dès lors que /boot réside sur une partition non cryptée. L'interdiction du BIOS elle-même est facile à lever par une réinitialisation physique (coupure d'alimentation). Voir Encryption (en)[broken link: invalid section] et Disk encryption (en)[broken link: invalid section].

Pour sécuriser GRUB de manière à ce que personne ne puisse modifier les paramètres de démarrage ni utiliser la ligne de commande, vous pouvez ajouter une combinaison utilisateur/mot de passe aux fichiers de configuration de GRUB.

Pour ce faire, exécutez la commande `grub-mkpasswd-pbkdf2`. Entrez un mot de passe et confirmez-le:

    grub-mkpasswd-pbkdf2

    [...]
    Your PBKDF2 is grub.pbkdf2.sha512.10000.C8ABD3E93C4DFC83138B0C7A3D719BC650E6234310DA069E6FDB0DD4156313DA3D0D9BFFC2846C21D5A2DDA515114CF6378F8A064C94198D0618E70D23717E82.509BFA8A4217EAD0B33C87432524C0B6B64B34FBAD22D3E6E6874D9B101996C5F98AB1746FE7C7199147ECF4ABD8661C222EEEDB7D14A843261FFF2C07B1269A

Puis, ajoutez au fichier `/etc/grub.d/40_custom`:

    /etc/grub.d/40_custom

    set superusers="username"
    password_pbkdf2 username <password>

où `<password>` sera la chaîne générée par la commande `grub-mkpasswd_pbkdf2`.

Régénerez `/boot/grub/grub.cfg`. L'édition de votre GRUB en ligne de commande, les paramètres et entrées de démarrage, sont maintenant protégés.

Ceci peut être assoupli et personnalisé pour un plus grand nombre d'utilisateurs, comme décrit dans la partie " Sécurité " du manuel du manuel de GRUB.

### Protection de GRUB par mot de passe pour seulement édition et lancement de commandes

L'ajout de `--unrestricted` à une entrée du menu permettra à tout utilisateur le démarrage du système mais en l'empêchant de modifier l'entrée et d'accéder à la console de commande grub. Seul un super-utilisateur ou les utilisateurs spécifiés avec le commutateur `--user` pourront éditer l'entrée du menu.

    /boot/grub/grub.cfg

    menuentry 'Arch Linux' --unrestricted --class arch --class gnu-linux --class os ...

## Masquage de GRUB sauf par le maintien 'enfoncée' de la touche Shift

Afin d'obtenir le démarrage le plus rapide possible, au lieu de laisser GRUB attendre un délai d'attente, il est possible pour GRUB de masquer le menu, à moins que la touche `Shift` ne soit maintenue enfoncée pendant le démarrage de GRUB.

Pour ce faire, vous devez ajouter la ligne suivante à `/etc/default/grub`}:

     GRUB_FORCE_HIDDEN_MENU="true"

Créez ensuite le fichier dans [1], rendez-le exécutable et régénérez la configuration grub:

    # chmod a+x /etc/grub.d/31_hold_shift
    # grub-mkconfig -o /boot/grub/grub.cfg

Note: Cette configuration utilise keystatus pour détecter l'événement de la touche keypress, ce qui peut ne pas fonctionner sur certaines machines..

## Associer usage des UUIDs et Script

Si vous appréciez l'utilisation d'UUIDs pour éviter les mappings BIOS peu fiables ou si vous avez des difficultés avec la syntaxe de GRUB, voici un exemple d'élément de menu de démarrage qui utilise les UUIDs et un petit script pour diriger GRUB vers les partitions de disque appropriées à votre système. Tout ce que vous avez à faire est de remplacer les UUIDs de l'échantillon par les bons UUIDs de votre système. L'exemple s'applique à un système avec une partition de démarrage et une partition racine. Vous devrez évidemment modifier la configuration de GRUB si vous avez des partitions supplémentaires:

    menuentry "Arch Linux 64" {
       # Set the UUIDs for your boot and root partition respectively
       set the_boot_uuid=ece0448f-bb08-486d-9864-ac3271bd8d07
       set the_root_uuid=c55da16f-e2af-4603-9e0b-03f5f565ec4a

       # (Note: This may be the same as your boot partition)

       # Get the boot/root devices and set them in the root and grub_boot variables
       search --fs-uuid $the_root_uuid --set=root
       search --fs-uuid $the_boot_uuid --set=grub_boot

       # Check to see if boot and root are equal.
       # If they are, then append /boot to $grub_boot (Since $grub_boot is actually the root partition)
       if [ $the_boot_uuid == $the_root_uuid ] ; then
           set grub_boot=($grub_boot)/boot
       else
           set grub_boot=($grub_boot)
       fi

       # $grub_boot now points to the correct location, so the following will properly find the kernel and initrd
       linux $grub_boot/vmlinuz-linux root=/dev/disk/by-uuid/$the_root_uuid ro
       initrd $grub_boot/initramfs-linux.img
       }

## Créer grub.cfg manuellement

Un fichier de configuration de base de GRUB utilise les options suivantes:

- `(hdX,Y)` est la partition Y du disque X, la numérotation des partitions commençant à 1, celle des disques commençant à 0
- `set default=N` est l'entrée de démarrage par défaut choisie après expiration du délai d'attente pour une action de l'utilisateur.
- `set timeout=M` est le temps M, en secondes, d' attente une sélection par l'utilisateur avant que la valeur par défaut ne soit démarrée.
- `menuentry "title" {entry options}` est une entrée de démarrage intitulée `titre`.
- `set root=(hdX,Y)` définit la partition de démarrage, où le noyau et les modules GRUB sont stockés (le démarrage n' a pas besoin d'être sur une partition séparée et peut simplement être un répertoire de la partition "root") (`/`)

## Entrées Multiples

### Désactiver le sous-menu

Si vous avez plusieurs noyaux installés, à savoir linux et linux-lts, par défaut `grub-mkconfig` les regroupe dans un sous-menu. Si vous n'aimez pas ce comportement, vous pouvez revenir à un seul menu en ajoutant la ligne suivante à `/etc/default/grub`:

     GRUB_DISABLE_SUBMENU=y

### Mémorisation du dernier choix

GRUB peut se souvenir de la dernière entrée démarrée et l'utiliser comme entrée de démarrage par défaut pour la prochaine fois. Ceci est utile si vous avez plusieurs noyaux (c. -à-d. le noyau Arch actuel et le noyau LTS comme option de secours) ou systèmes d'exploitation. Pour ce faire, éditez `/etc/default/grub` et modifiez la valeur de `GRUB_DEFAULT`:

    GRUB_DEFAULT=saved

Ceci garantit que GRUB passe par défaut à l'entrée sauvegardée. Pour activer la sauvegarde de l'entrée sélectionnée, ajoutez la ligne suivante à `/etc/default/grub`}:

    GRUB_SAVEDEFAULT=true

Cela ne fonctionnera que si /boot n'est pas partitionnée en btrfs, grub ne pouvant pas écrire sur btrfs. Mais il générera un message d'erreur trompeur: "sparse file not allowed. Press any key to continue (fichier épars non autorisé. Appuyez sur n'importe quelle touche pour continuer)".

Note: L'addition manuelle d'entrées au menu, p.ex. Windows, dans `/etc/grub.d/40_custom` ou `/boot/grub/custom.cfg`, nécessite l'addition de `savedefault`.

### Changer l'entrée par défaut du menu

Pour changer l'entrée par défaut du menu, éditer `/etc/default/grub` et modifier la valeur de `GRUB_DEFAULT`:

En utilisant les titres :

    GRUB_DEFAULT='Options avancées pour Arch Linux>Arch Linux, avec Linux linux'

En utilisant les nombres :

     GRUB_DEFAULT="1>2"

Grub identifie les entrées du menu généré par comptage depuis zero. Ce qui signifie 0 pour la première entrée qui est celle par défaut, 1 pour la deuxième et ainsi de suite. Les entrées du menu principal et des sous-menus sont séparées par un `>`.

L'exemple ci-dessus démarre la troisième entrée du menu principal : 'Advanced options for Arch Linux'.

### Démarrage d'une entrée non-défaut une seule fois

La commande `grub-reboot` est très utile pour démarrer une seule fois une autre entrée que la valeur par défaut. GRUB charge l'entrée passée dans le premier argument de ligne de commande lorsque le système est redémarré la fois suivante. Plus important encore, GRUB retourne au chargement de l'entrée par défaut pour tous les démarrages futurs. Il n'est pas nécessaire de modifier le fichier de configuration ou de sélectionner une entrée dans le menu GRUB.

Note: Ceci nécessite une ligne `GRUB_DEFAULT=saved` dans `/etc/default/grub` (et de régénérer `grub.cfg`) ou, en cas de modification manuelle de `grub.cfg`, la ligne `set default="${saved_entry}"`.

## Jouer un son

Vous pouvez jouer une mélodie par le haut-parleur du PC tout en démarrant, en modifiant la variable `GRUB_INIT_TUNE`. Par exemple, pour jouer l'extrait de 'Songe d'une Nuit de Sabbat' de la 'Symphonie Fantastique de Berlioz', vous pouvez ajouter ce qui suit: (partie basson):

`GRUB_INIT_TUNE="312 262 3 247 3 262 3 220 3 247 3 196 3 220 3 220 3 262 3 262 3 294 3 262 3 247 3 220 3 196 3 247 3 262 3 247 5 220 1 220 5"`

Pour information complémentaire lancer `$ info grub -n play`.

## Configuration manuelle d'image de base pour démarrage précoce

Si vous avez besoin d'un clavier spécial, ou d'autres étapes complexes que GRUB ne peut pas configurer automatiquement, pour rendre le `/boot` accessible à l'environnement GRUB, vous pouvez générer vous-même une image de base.

Sur les systèmes UEFI, l'image de base est le fichier `grubx64.efi`, chargé au démarrage par le firmware. Construire votre propre image de base vous permettra d'intégrer tous les modules nécessaires au démarrage très précoce, ainsi qu'un script de configuration de l'amorce de GRUB.

Tout d'abord, prenons comme exemple l'exigence d'un clavier `dvorak` intégré dans early-boot afin d'entrer un mot de passe pour un `/boot` crypté sur un système UEFI:

Déterminez à partir du fichier généré `/boot/grub/grub. cfg` quels modules sont nécessaires pour monter les `/boot` chiffrés. Par exemple, sous votre `menuentry`, vous devriez voir des lignes similaires:

`insmod diskfilter cryptodisk luks gcry_rijndael gcry_rijndael gcry_sha256 insmod ext2 cryptomount -u 1234abcdef1234abcdef1234abcdef set root='cryptouuid/1234abcdef1234abcdef1234abcdef'`

Prenez note de tous ces modules: ils devront être inclus dans l'image de base. Créez maintenant une archive contenant votre keymap. Ceci sera inclus dans l'image de base comme un memdisk:

`# ckbcomp dvorak | grub-mklayout > dvorak.gkb # tar cf memdisk.tar dvorak.gkb`

Créez maintenant un fichier de configuration à utiliser dans l'image du noyau GRUB. C'est dans le même format que votre configuration grub régulière, mais n' a besoin de contenir que quelques lignes pour trouver et charger le fichier de configuration principal sur la partition `/boot`:

    early-grub.cfg

    root=(memdisk)
    prefix=($root)/

    terminal_input at_keyboard
    keymap /dvorak.gkb

    cryptomount -u 1234abcdef1234abcdef1234abcdef
    set root='cryptouuid/1234abcdef1234abcdef1234abcdef'
    set prefix=($root)/grub

    configfile grub.cfg

Enfin, générez l'image de base, en listant tous les modules déterminés nécessaires dans le script `grub. cfg` généré, ainsi que tous les modules utilisés dans le script `early-grub.cfg`. L'exemple ci-dessus nécessite `memdisk`, `tar`, `at_keyboard`, `keylayouts` et `configfile`.

    # grub-mkimage -c early-grub.cfg -o grubx64.efi -O x86_64-efi -m memdisk.tar diskfilter cryptodisk luks gcry_rijndael gcry_sha256 ext2 memdisk tar at_keyboard keylayouts configfile

L'image de base EFI générée peut maintenant être utilisée de la même manière que l'image générée automatiquement par `grub-install`: placez-la dans votre partition EFI et activez-la avec `efibootmgr`, ou configurez-la en fonction du firmware de votre système.

## UEFI lecture complémentaire

     Section du Wiki Officiel en demande d'amménagement

Voici d'autres informations importantes concernant l'installation d'Arch via UEFI.

### Méthode d'installation alternative

Généralement, GRUB conserve tous les fichiers, y compris les fichiers de configuration, dans `/boot`, quel que soit l'endroit où la partition système EFI est montée.

Si vous voulez conserver ces fichiers à l'intérieur de la partition système EFI, ajoutez `--boot-directory=esp` à la commande grub-install:

    # grub-install --target=x86_64-efi --efi-directory=esp --bootloader-id=grub --boot-directory=esp --debug

Ceci place tous les fichiers GRUB dans `esp/grub`, au lieu de `/boot/grub`. Lors de l'utilisation de cette méthode, assurez-vous de placer le fichier grub-mkconfig au même endroit.:

    # grub-mkconfig -o esp/grub/grub.cfg

Par ailleurs la configuration sera identique.

### Contournement du firmware de l'UEFI

Certains firmwares UEFI exigent que le stub bootable `.efi` ait un nom spécifique et soit placé dans un emplacement spécifique: `esp/EFI/boot/bootx64.efi` (où `esp` est le point de montage de la partition UEFI). Ne pas le faire dans de tels cas rend le démarrage impossible. Heureusement, cela ne causera pas de problèmes avec les autres firmware qui ne le nécessitent pas.

Pour ce faire, créez d'abord le répertoire nécessaire, puis copiez-le à travers le stub grub `.efi`, en le renommant dans le processus.:

    # mkdir esp/EFI/boot
    # cp esp/EFI/grub_uefi/grubx64.efi esp/EFI/boot/bootx64.efi

### Créer une entrée GRUB entry dans le gestionnaire de démarrage du firmware

`grub-install` essaie automatiquement de créer une entrée dans le menu du gestionnaire de démarrage. Si ce n'est pas le cas, voir efibootmgr (en) pour les instructions d'utilisation de `efibootmgr` pour créer une entrée de menu.

Cependant, le problème est probablement que vous n'ayez pas démarré votre CD/USB d'installation en mode UEFI, comme dans Create UEFI bootable USB from ISO (en).

### GRUB standalone

Cette section suppose que vous créez un GRUB autonome pour les systèmes x86_64 (x86_64-efi). Les systèmes 32 bits ne sont plus supportés par Archlinux.

Il est possible de créer une application `grubx64_standalone. efi` avec tous les modules incorporés dans une archive tar au sein de l'application UEFI, éliminant ainsi le besoin d'avoir un répertoire séparé empli de tous les modules UEFI GRUB et autres fichiers associés. Ceci est fait en utilisant la commande `grub-mkstandalone` (inclus dans grub) comme suit:

    # echo 'configfile ${cmdpath}/grub.cfg' > /tmp/grub.cfg
    # grub-mkstandalone -d /usr/lib/grub/x86_64-efi/ -O x86_64-efi --modules="part_gpt part_msdos" --locales="en@quot" --themes="" -o "esp/EFI/grub/grubx64_standalone.efi" "boot/grub/grub.cfg=/tmp/grub.cfg" -v

Puis copier le fichier de configuration de GRUB vers `esp/EFI/grub/grub.cfg` et créer une entrée UEFI Boot Manager pour `esp/EFI/grub/grubx64_standalone.efi` en utilisant efibootmgr (en).

Note: L'option `--modules="part_gpt part_msdos"` (avec les guillemets) est nécessaire à un fonctionnement correct de la fonction `${cmdpath}` .
Attention: Vous constaterez peut-être que le fichier `grub. cfg` n'est pas chargé, en l'absence d'une barre oblique dans `${cmdpath}` (càd. `(hd1,msdos2)EFI/Boot` à la place de `(hd1, msdos2)/EFI/Boot`) et donc vous êtes lancé dans un shell GRUB. Si cela se produit, vérifiez le réglage de `cmdpath` (par `echo ${cmdpath)`) et chargez ensuite le fichier de configuration manuellement (p.ex. `configfile (hd1,msdos2)/EFI/Boot/grub.cfg`).

### Information Technique

Le fichier GRUB EFI s'attend toujours à ce que son fichier de configuration soit à `${prefix}/grub.cfg`. Cependant, dans le fichier GRUB EFI standalone, le `${prefix}` est situé dans une archive tar et intégré dans le fichier GRUB EFI standalone lui-même (dans l'environnement GRUB, il est indiqué par `"(memdisk)"`, sans guillemets). Cette archive tar contient tous les fichiers qui seraient stockés normalement à `/boot/grub` dans le cas d'une installation normale de GRUB EFI.

En raison de cette intégration du contenu `/boot/grub` à l'intérieur de l'image autonome elle-même, il ne dépend pas du contenu réel (externe) `/boot/grub` pour quoi que ce soit. Ainsi, dans le cas d'un fichier GRUB EFI standalone `${prefix}==(memdisk)/boot/grub` et le fichier GRUB EFI standalone s'attend à ce que le fichier de configuration soit à `${prefix}/grub.cfg==(memdisk)/boot/grub/grub.cfg`.

Ainsi, pour s'assurer que le fichier GRUB EFI standalone lise le fichier externe `grub.cfg` situé dans le même répertoire que le fichier EFI (dans l'environnement GRUB, il est indiqué par `${cmdpath}` ), nous créons un simple `/tmp/grub.cfg` qui demande à GRUB d'utiliser `${cmdpath}/grub.cfg` comme sa commande de configuration (`configfile ${cmdpath}/grub.cfg` vers `(memdisk)/boot/grub/grub.cfg`). Nous donnons ensuite instruction à grub-mkstandalone de copier ce fichier `/tmp/grub.cfg` vers `${prefix}/grub.cfg` (qui est en fait `(memdisk)/boot/grub/grub.cfg`) en utilisant l'option `"boot/grub/grub.cfg=/tmp/grub.cfg"`.

De cette façon, le fichier GRUB EFI autonome et le fichier actuel `grub.cfg` peuvent être stockés dans n'importe quel répertoire de la partition système EFI (tant qu'ils sont dans le même répertoire), ce qui les rend portables.

Category:

- Boot loaders (Français)

Hidden categories:

- Pages with broken package links
- Pages with broken section links