Masquer le menu GRUB2 SAUF si vous maintenez la touche Maj enfoncée: comment y arriver?

J'ai une configuration à double démarrage Ubuntu - Windows 7, et j'aimerais que mon ordinateur portable démarre sous Windows 7 à moins que j'appuie sur la touche Maj tout de suite après le démarrage et que le menu Grub2 soit sélectionné. Ubuntu.

J'ai fait des recherches sur Grub2 et sur les options etc/default/grubet j'ai essayé de jouer avec des combinaisons avec les valeurs GRUB_TIMEOUTand GRUB_HIDDEN_TIMEOUT, mais en vain. J'ai essayé de régler GRUB_HIDDEN_TIMEOUTplus haut que ce que l'on GRUB_TIMEOUTpensait: les deux comptes à rebours démarrent simultanément, mais non, cela GRUB_TIMEOUTne commence que lorsque l'autre est terminé.

Ce comportement est-il réalisable?

Si c'est le cas, comment?

Je pense que j'ai trouvé une résolution plus simple. Modifiez les lignes suivantes dans le fichier / etc / default / grub:

GRUB_HIDDEN_TIMEOUT = 0.0

GRUB_TIMEOUT = 0.0

Bien sûr, nous avons finalement lancé un update-grub. Cela fonctionne sur mon PC.

Ceci est pour Ubuntu 16.04.

J'ai résolu ce problème avec une petite combinaison des réponses trouvées ci-dessus, il n'est donc pas nécessaire de modifier 30_os-prober, ce qui évite les futures fusions lorsque le paquet grub est mis à jour ...

J'espère que ça aide.

Modification de certaines variables dans / etc / default / grub pour refléter ce que je veux;

GRUB_DEFAULT=4
GRUB_HIDDEN_TIMEOUT=5
GRUB_HIDDEN_TIMEOUT_QUIET=true
GRUB_TIMEOUT=0
GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
GRUB_CMDLINE_LINUX=""

GRUB_FORCE_HIDDEN_MENU="true"
export GRUB_FORCE_HIDDEN_MENU

Puis créé un nouveau fichier;

sudo touch /etc/grub.d/50_hidemenu
sudo chmod +x /etc/grub.d/50_hidemenu

l'a rempli de ce contenu;

#!/bin/sh
cat <<EOF
if [ "x\${timeout}" != "x-1" ]; then
  if keystatus; then
    if keystatus --shift; then
      set timeout=-1
    else
      set timeout=0
    fi
  else
    if sleep --interruptible ${GRUB_HIDDEN_TIMEOUT} ; then
      set timeout=0
    fi
  fi
fi
EOF

et mis à jour grub;

sudo update-grub

À votre santé.

Dans Kubuntu 14.04, cela ne fonctionne pas, si vous définissez GRUB_TIMEOUT= 0étrangement, après l’application de cela et le redémarrage, le menu grub reste visible pendant 10 secondes.

La raison en est que dans un autre script grub, il existe un morceau de code qui définit grub_timeout sur 10 s'il a la valeur 0.

Donc, voici comment je l’ai obtenu:

faire une copie des deux grubet des 30_osproberfichiers !!! Quand quelque chose ne va pas, vous pouvez remettre les fichiers originaux.

Dans /etc/default/grub

GRUB_DEFAULT=4    #set this value to the OS you want to boot
GRUB_HIDDEN_TIMEOUT=0

GRUB_TIMEOUT=0

Dans/etc/grub.d/30_os-prober , il y a un morceau de code qui définit le délai d'expiration de grub sur 10s s'il est défini sur zéro /etc/default/grub, je ne sais pas pourquoi les développeurs l'a mis là, mais cela empêche de masquer le menu grub.

set timeout_style=menu

if [ "\${timeout}" = 0 ]; then    
  set timeout=10  # I changed this from 10 to 0

Après ces modifications, exécutez sudo update-grubpour générer la nouvelle séquence de démarrage grub.

Je documente tous mes correctifs / mods Linux sur https://sites.google.com/site/marcshomesite/Home/linux-tuning

Pour démarrer automatiquement Windows sans avoir à sélectionner le menu GRUB, nous devons éditer le /etc/default/grubfichier avec des valeurs similaires à celles-ci:

GRUB_DEFAULT= <number of default entry starting from 0>
GRUB_TIMEOUT= 0 # time in seconds to boot default
# GRUB_HIDDEN_TIMEOUT=0 # warning: activating this may lock you out from GRUB menu

C'est toujours une bonne idée de faire des sauvegardes de ces fichiers avant de les éditer. Après avoir apporté des modifications, nous devons les activer avec

sudo update-grub

Les valeurs de GRUB_DEFAULT dépendent de notre système individuel. Pour toujours démarrer Windows, vous pouvez également saisir le nom de l'entrée exactement comme il était indiqué dans le menu Grub (par exemple "Microsoft Windows XP Professional") au lieu du numéro de l'entrée.

Remarque importante: sur certaines machines, le menu GRUB ne peut pas être affiché en maintenant enfoncé le bouton gauche de la sourisShift au démarrage (voir le bogue n ° 425979 ). Par conséquent, il peut être judicieux de commencer par tester cela en démarrant Ubuntu (pas Windows) défini comme système d'exploitation par défaut. Ensuite, vous pourrez facilement annuler vos paramètres GRUB au cas où vous seriez affecté.

J'essayais de faire la même chose et j'ai trouvé une aide précieuse dans les forums Ubuntu, en particulier dans ce fil.

En supposant que vous ayez bien fait avec /etc/default/grub, en réglant correctement GRUB_TIMEOUTet GRUB_HIDDEN_TIMEOUT(je dirais respectivement 0 et 5) et même GRUB_DEFAULTen spécifiant l'image par défaut à démarrer, voici la procédure à suivre pour que cela fonctionne correctement.

1. Ajouter ces lignes

   GRUB_FORCE_HIDDEN_MENU="true"
   export GRUB_FORCE_HIDDEN_MENU
   

   à la fin de /etc/default/grub

2. Sauvegardez votre /etc/grub.d/30_os-proberet écrasez-le avec la version trouvée ici

3. Essaye-le! Pour afficher le menu, appuyez sur la SHIFTtouche

Ce problème est lié à la configuration multi-OS et la modification du script est l’un des moyens de résoudre ce problème.

30_os-prober :

#! /bin/sh
set -e

# grub-mkconfig helper script.
# Copyright (C) 2006,2007,2008,2009  Free Software Foundation, Inc.
#
# GRUB is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# GRUB is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GRUB.  If not, see <http://www.gnu.org/licenses/>.

prefix="/usr"
exec_prefix="${prefix}"
datarootdir="${prefix}/share"

. "${datarootdir}/grub/grub-mkconfig_lib"

found_other_os=

make_timeout () {

  if [ "x${found_other_os}" = "x" ] || [ "x${GRUB_FORCE_HIDDEN_MENU}" = "xtrue" ] ; then 
    if [ "x${1}" != "x" ] ; then
      if [ "x${GRUB_HIDDEN_TIMEOUT_QUIET}" = "xtrue" ] ; then
    verbose=
      else
    verbose=" --verbose"
      fi

      if [ "x${1}" = "x0" ] ; then
    cat <<EOF
if [ "x\${timeout}" != "x-1" ]; then
  if keystatus; then
    if keystatus --shift; then
      set timeout=-1
    else
      set timeout=0
    fi
  else
    if sleep$verbose --interruptible 3 ; then
      set timeout=0
    fi
  fi
fi
EOF
      else
    cat << EOF
if [ "x\${timeout}" != "x-1" ]; then
  if sleep$verbose --interruptible ${GRUB_HIDDEN_TIMEOUT} ; then
    set timeout=0
  fi
fi
EOF
      fi
    fi
  fi
}

adjust_timeout () {
  if [ "x$GRUB_BUTTON_CMOS_ADDRESS" != "x" ]; then
    cat <<EOF
if cmostest $GRUB_BUTTON_CMOS_ADDRESS ; then
EOF
    make_timeout "${GRUB_HIDDEN_TIMEOUT_BUTTON}" "${GRUB_TIMEOUT_BUTTON}"
    echo else
    make_timeout "${GRUB_HIDDEN_TIMEOUT}" "${GRUB_TIMEOUT}"
    echo fi
  else
    make_timeout "${GRUB_HIDDEN_TIMEOUT}" "${GRUB_TIMEOUT}"
  fi
}

if [ "x${GRUB_DISABLE_OS_PROBER}" = "xtrue" ]; then
  adjust_timeout
  exit 0
fi

if [ -z "`which os-prober 2> /dev/null`" -o -z "`which linux-boot-prober 2> /dev/null`" ] ; then
  # missing os-prober and/or linux-boot-prober
  adjust_timeout
  exit 0
fi

OSPROBED="`os-prober | tr ' ' '^' | paste -s -d ' '`"
if [ -z "${OSPROBED}" ] ; then
  # empty os-prober output, nothing doing
  adjust_timeout
  exit 0
fi

osx_entry() {
    found_other_os=1
        cat << EOF
menuentry "${LONGNAME} (${2}-bit) (on ${DEVICE})" --class osx --class darwin --class os {
EOF
    save_default_entry | sed -e "s/^/\t/"
    prepare_grub_to_access_device ${DEVICE} | sed -e "s/^/\t/"
    cat << EOF
        load_video
        set do_resume=0
        if [ /var/vm/sleepimage -nt10 / ]; then
           if xnu_resume /var/vm/sleepimage; then
             set do_resume=1
           fi
        fi
        if [ \$do_resume = 0 ]; then
           xnu_uuid ${OSXUUID} uuid
           if [ -f /Extra/DSDT.aml ]; then
              acpi -e /Extra/DSDT.aml
           fi
           $1 /mach_kernel boot-uuid=\${uuid} rd=*uuid
           if [ /System/Library/Extensions.mkext -nt /System/Library/Extensions ]; then
              xnu_mkext /System/Library/Extensions.mkext
           else
              xnu_kextdir /System/Library/Extensions
           fi
           if [ -f /Extra/Extensions.mkext ]; then
              xnu_mkext /Extra/Extensions.mkext
           fi
           if [ -d /Extra/Extensions ]; then
              xnu_kextdir /Extra/Extensions
           fi
           if [ -f /Extra/devprop.bin ]; then
              xnu_devprop_load /Extra/devprop.bin
           fi
           if [ -f /Extra/splash.jpg ]; then
              insmod jpeg
              xnu_splash /Extra/splash.jpg
           fi
           if [ -f /Extra/splash.png ]; then
              insmod png
              xnu_splash /Extra/splash.png
           fi
           if [ -f /Extra/splash.tga ]; then
              insmod tga
              xnu_splash /Extra/splash.tga
           fi
        fi
}
EOF
}

wubi=

for OS in ${OSPROBED} ; do
  DEVICE="`echo ${OS} | cut -d ':' -f 1`"
  LONGNAME="`echo ${OS} | cut -d ':' -f 2 | tr '^' ' '`"
  LABEL="`echo ${OS} | cut -d ':' -f 3 | tr '^' ' '`"
  BOOT="`echo ${OS} | cut -d ':' -f 4`"

  if [ -z "${LONGNAME}" ] ; then
    LONGNAME="${LABEL}"
  fi

  echo "Found ${LONGNAME} on ${DEVICE}" >&2

  case ${BOOT} in
    chain)

      case ${LONGNAME} in
    Windows*)
      if [ -z "$wubi" ]; then
        if [ -x /usr/share/lupin-support/grub-mkimage ] && \
           /usr/share/lupin-support/grub-mkimage --test; then
          wubi=yes
        else
          wubi=no
        fi
      fi
      if [ "$wubi" = yes ]; then
        echo "Skipping ${LONGNAME} on Wubi system" >&2
        continue
      fi
      ;;
      esac

      found_other_os=1
      cat << EOF
menuentry "${LONGNAME} (on ${DEVICE})" --class windows --class os {
EOF
      save_default_entry | sed -e "s/^/\t/"
      prepare_grub_to_access_device ${DEVICE} | sed -e "s/^/\t/"

      case ${LONGNAME} in
    Windows\ Vista*|Windows\ 7*|Windows\ Server\ 2008*)
    ;;
    *)
      cat << EOF
    drivemap -s (hd0) \${root}
EOF
    ;;
      esac

      cat <<EOF
    chainloader +1
}
EOF
    ;;
    linux)
      LINUXPROBED="`linux-boot-prober ${DEVICE} 2> /dev/null | tr ' ' '^' | paste -s -d ' '`"
      prepare_boot_cache=

      for LINUX in ${LINUXPROBED} ; do
        LROOT="`echo ${LINUX} | cut -d ':' -f 1`"
        LBOOT="`echo ${LINUX} | cut -d ':' -f 2`"
        LLABEL="`echo ${LINUX} | cut -d ':' -f 3 | tr '^' ' '`"
        LKERNEL="`echo ${LINUX} | cut -d ':' -f 4`"
        LINITRD="`echo ${LINUX} | cut -d ':' -f 5`"
        LPARAMS="`echo ${LINUX} | cut -d ':' -f 6- | tr '^' ' '`"

        if [ -z "${LLABEL}" ] ; then
          LLABEL="${LONGNAME}"
        fi

    if [ "${LROOT}" != "${LBOOT}" ]; then
      LKERNEL="${LKERNEL#/boot}"
      LINITRD="${LINITRD#/boot}"
    fi

    if [ -z "${prepare_boot_cache}" ]; then
      prepare_boot_cache="$(prepare_grub_to_access_device ${LBOOT} | sed -e "s/^/\t/")"
      [ "${prepare_boot_cache}" ] || continue
    fi
    found_other_os=1
        cat << EOF
menuentry "${LLABEL} (on ${DEVICE})" --class gnu-linux --class gnu --class os {
EOF
    save_default_entry | sed -e "s/^/\t/"
    printf '%s\n' "${prepare_boot_cache}"
    cat <<  EOF
    linux ${LKERNEL} ${LPARAMS}
EOF
        if [ -n "${LINITRD}" ] ; then
          cat << EOF
    initrd ${LINITRD}
EOF
        fi
        cat << EOF
}
EOF
      done
    ;;
    macosx)
      OSXUUID="`grub-probe --target=fs_uuid --device ${DEVICE} 2> /dev/null`"
      osx_entry xnu_kernel 32
      osx_entry xnu_kernel64 64
    ;;
    hurd)
      found_other_os=1
      cat << EOF
menuentry "${LONGNAME} (on ${DEVICE})" --class hurd --class gnu --class os {
EOF
      save_default_entry | sed -e "s/^/\t/"
      prepare_grub_to_access_device ${DEVICE} | sed -e "s/^/\t/"
      grub_device="`${grub_probe} --device ${DEVICE} --target=drive`"
      mach_device="`echo "${grub_device}" | sed -e 's/(\(hd.*\),msdos\(.*\))/\1s\2/'`"
      grub_fs="`${grub_probe} --device ${DEVICE} --target=fs`"
      case "${grub_fs}" in
    *fs)    hurd_fs="${grub_fs}" ;;
    *)  hurd_fs="${grub_fs}fs" ;;
      esac
      cat << EOF
    multiboot /boot/gnumach.gz root=device:${mach_device}
    module /hurd/${hurd_fs}.static ${hurd_fs} --readonly \\
            --multiboot-command-line='\${kernel-command-line}' \\
            --host-priv-port='\${host-port}' \\
            --device-master-port='\${device-port}' \\
            --exec-server-task='\${exec-task}' -T typed '\${root}' \\
            '\$(task-create)' '\$(task-resume)'
    module /lib/ld.so.1 exec /hurd/exec '\$(exec-task=task-create)'
}
EOF
    ;;
    *)
      echo "  ${LONGNAME} is not yet supported by grub-mkconfig." >&2
    ;;
  esac
done

adjust_timeout


    cat <<EOF
if [ "x\${timeout}" != "x-1" ]; then
  if keystatus; then
    if keystatus --shift; then
      set timeout=-1
    else
      set timeout=0
    fi
  else
    if sleep$verbose --interruptible 3 ; then
      set timeout=0
    fi
  fi
fi
EOF

Sur Ubuntu 16.04, j'ai apporté les modifications suivantes. Bien sûr, vous devez être un utilisateur privilégié pour le faire.

1. Le premier changement est dans le /etc/grub.d/30_os-proberfichier:

   • Ouvrez-le avec sudo gedit /etc/grub.d/30_os-prober
   • Changer quick_boot="1"enquick_boot="0"
   • sauvegarder le fichier

2. Ensuite, vous pouvez définir les valeurs de délai d'attente /etc/default/grubsur zéro ou sur une autre valeur:

   • Ouvrez-le avec sudo gedit /etc/default/grub
   • GRUB_HIDDEN_TIMEOUT=0et GRUB_TIMEOUT=0.
   • sauvegarder le fichier

3. La dernière étape consiste à mettre à jour grub

   • sudo update-grub

Les modifications apportées au premier fichier sont dues au fait que le paramètre par défaut est que si un autre système d'exploitation (par exemple Windows 10) est détecté, la valeur du délai d'attente est toujours définie sur 10 secondes et ne peut donc pas être modifiée par /etc/default/grub. Ceci est accompli par une fonction nommée adjust_timeoutqui demande si quick_bootest défini et si d'autres systèmes d'exploitation sont présents.

installer l'optimiseur de grub

sudo add-apt-repository ppa: danielrichter2007 / grub-customizer

sudo apt-get update
sudo apt-get install grub-customizer

Grub Customizer apparaît maintenant dans le menu Applications> Outils système.

Ou vous pouvez l'ouvrir depuis la ligne de commande.

gksudo grub-customizer

J'avais le même problème sur un seul système de démarrage. Si GRUB_TIMEOUT était différent de zéro, le menu serait toujours affiché indépendamment de GRUB_HIDDEN_TIMEOUT. Si GRUB_TIMEOUT était égal à zéro, il resterait en veille quelques secondes plus tard, mais ni SHIFT ni ÉCHAP n'afficherait le menu.

Je l'ai corrigé en ajoutant une clause else à l'état de veille à la fin de adjust_time () dans 30_os-prober. Maintenant, s'il n'est pas interrompu, le délai est nul et il démarre sans menu, mais s'il est interrompu, je règle le délai à 10.

Cela semble en fait à l'envers puisque le sommeil devrait retourner 0 (faux) s'il n'est pas interrompu et 1 (vrai) s'il l'est, mais cela a semblé fonctionner pour moi.

RENDRE AUTOMATIQUEMENT LE MENU BOOT GRUB2

Pour une raison quelconque, la modification des GRUB_GFXMODE=640x480paramètres dans Grub Customizer rend généralement le menu de démarrage visible:

1. Installez grub-customizer comme ci-dessus et mettez à jour
2. trouvez Grub Customizer dans l'interface graphique (pour moi, cela se trouve dans Système> Administration> ..., mais pour certains, il est financé sous Applications> Outils système> ..)
3. Ouvrez Grub Customizer et sélectionnez Préférences> Avancé.
4. Sélectionnez GRUB_gfxmode (640X480) - s'il est déjà sélectionné, désélectionnez-le, redémarrez et sélectionnez-le à nouveau.
5. Croisez les doigts et redémarrez!

Je ne sais pas pourquoi cela a fonctionné pour moi, mais cela a fonctionné sur mes deux ordinateurs, alors espérons que cela fonctionnera pour vous aussi!

Shasteriskt, une alternative à la solution 'SHIFT' consiste simplement à créer un script qui effectue certaines opérations de déplacement pour vous. Ce que je veux dire, c'est créer un fichier appelé grub.bakqui est une copie exacte de votre grub.cfgfichier, à la seule différence que la set timeout=0ligne est modifiée, set timeout=10par exemple. Créez un script shell qui effectue un changement vous permettant de redémarrer en fonction de vos besoins. J'ai créé un script python équivalent qui répond à ces exigences, mais il doit bien sûr être appelé avec sudo. Je le mets simplement dans /usr/binma configuration en tant que lien symbolique vers le script lui-même. Note: J'utilise Fluxbox sur Arch, donc je ne suis pas sûr qu'il y ait des divergences entre ce script et Ubuntu, mais je pense qu'il devrait y avoir peu de modifications, voire aucune. Le script ressemble à:

#! /usr/bin/python
from shlex import split
from subprocess import call
from os import rename, chdir

chdir('/boot/grub/')
try:
    with open('grub.bak','r') as alternate:
        pass
    if raw_input('Auto-boot is set. Un-set?> ') == 'y':
        rename('grub.cfg','grub.back')
        rename('grub.bak','grub.cfg')

    if raw_input('Reboot system?> ') == 'y':
        call(split('shutdown -r now'))

except:
    if raw_input('Auto-boot is not set. Set?> ') == 'y':
        rename('grub.cfg','grub.bak')
        rename('grub.back','grub.cfg')

    if raw_input('Reboot system?> ') == 'y':
        call(split('shutdown -r now'))

Le script détermine simplement si vous avez le menu à charger ou non (démarrage automatique ou non). Sur la base de ses conclusions, il vous demande si vous souhaitez l'activer ou non, puis vous demande si vous souhaitez redémarrer. Inversement, si vous voulez que cela fonctionne dans le sens inverse (c.-à-d. Sous Windows) et que Windows ait été configuré pour accéder aux fichiers sous Linux, vous pouvez également exécuter le même script dans cet environnement, si vous le souhaitez. J'espère que ça t'as aidé.

Ainsi, même si vous définissez GRUB_TIMEOUT sur 0, si vous avez un GRUB_HIDDEN_TIMEOUT, 30_os-prober définira le délai d’attente sur 10, que vous le vouliez ou non. D'autres solutions ici modifient ce script, mais cela pourrait entraîner des problèmes de mise à jour que vous devrez fusionner si GRUB est mis à jour.

Meilleure solution: écrivez ce qui suit dans /etc/grub.d/50_goddamnit(nouveau fichier):

#!/bin/sh
echo "set timeout=0"

Fondamentalement, ceci sera exécuté en dernier et sera la dernière ligne de /boot/grub/grub.conf, remplaçant ainsi tous les autres mishigus idiots de la configuration par défaut.