GRUB2-Menü ausblenden, WENN Sie nicht die Umschalttaste gedrückt halten: Wie kann dies geschehen?

Ich habe ein Ubuntu - Windows 7 Dual-Boot-Setup und möchte, dass mein Laptop Windows 7 bootet, es sei denn, ich drücke direkt nach dem Booten die Umschalttaste und rufe das Grub2-Menü auf, aus dem ich wählen kann Ubuntu.

Ich recherchieren auf Grub2 und Optionen für etc/default/grubund ich habe versucht , mit Kombinationen mit dem Herumspielen GRUB_TIMEOUTund GRUB_HIDDEN_TIMEOUTWerten, aber ohne Erfolg. Ich habe versucht, die Einstellung GRUB_HIDDEN_TIMEOUThöher als der GRUB_TIMEOUTGedanke, dass beide Countdown gleichzeitig starten, aber nein - GRUB_TIMEOUTstartet nur, nachdem der andere getan ist.

Ist dieses Verhalten erreichbar?

Wenn das so ist, wie?

Ich denke, dass ich eine einfachere Lösung gefunden habe. Ändern Sie die folgenden Zeilen in der Datei / etc / default / grub:

GRUB_HIDDEN_TIMEOUT = 0.0

GRUB_TIMEOUT = 0.0

Natürlich führen wir endlich ein Update-Grub durch. Es funktioniert auf meinem PC.

Dies ist für Ubuntu 16.04.

Ich habe dies mit einer kleinen Kombination einiger der oben gefundenen Antworten gelöst, sodass 30_os-prober nicht geändert werden muss, um zukünftige Zusammenführungen zu vermeiden, wenn das Grub-Paket aktualisiert wird ...

Ich hoffe es hilft.

Einige Variablen in / etc / default / grub wurden geändert, um zu reflektieren, was ich will.

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

Dann erstellte eine neue Datei;

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

füllte es mit diesem Inhalt;

#!/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

und aktualisierte grub;

sudo update-grub

Prost.

In Kubuntu 14.04 funktioniert dies nicht, wenn Sie GRUB_TIMEOUT= 0seltsamerweise festlegen , dass das Grub-Menü nach dem Anwenden und Neustarten für 10s sichtbar bleibt.

Der Grund dafür ist, dass es in einem anderen Grub-Skript einen Code gibt, der grub_timeout auf 10 setzt, wenn er den Wert 0 hat.

So habe ich es zum Laufen gebracht:

mache eine Kopie von beiden grubund 30_osproberDateien !!! Wenn etwas schief geht, können Sie die Originaldateien zurücksetzen

Im /etc/default/grub

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

GRUB_TIMEOUT=0

In/etc/grub.d/30_os-prober gibt es einen Code, der das Grub-Timeout auf 10s setzt, wenn es auf 0 gesetzt /etc/default/grubist. Ich weiß nicht, warum die Entwickler es dort abgelegt haben, aber es verhindert, dass das Grub-Menü ausgeblendet wird.

set timeout_style=menu

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

Führen Sie sudo update-grubnach diesen Änderungen aus, um die neue Grub-Startsequenz zu generieren.

Ich dokumentiere alle meine Linux-Fixes / Mods auf https://sites.google.com/site/marcshomesite/Home/linux-tuning

Um Windows automatisch zu starten, ohne im GRUB-Menü auswählen zu müssen, müssen wir die /etc/default/grubDatei mit ähnlichen Werten bearbeiten :

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

Es ist immer eine gute Idee, Sicherungskopien dieser Dateien zu erstellen, bevor Sie sie bearbeiten. Nachdem wir Änderungen vorgenommen haben, müssen wir sie mit aktivieren

sudo update-grub

Die Werte für GRUB_DEFAULT hängen von unserem individuellen System ab. Um Windows immer zu booten, können wir alternativ den Namen des Eintrags genau so eingeben, wie er im Grub-Menü angezeigt wurde (z. B. "Microsoft Windows XP Professional"), anstelle der Eintragsnummer.

Wichtiger Hinweis: Bei einigen Maschinen kann das GRUB-Menü nicht angezeigt werden, wenn Sie beim ShiftBooten die linke Maustaste gedrückt halten (siehe Fehler 425979 ). Daher ist es möglicherweise eine gute Idee, dies zuerst mit dem Booten von Ubuntu (nicht Windows) zu testen, das als Standard-Betriebssystem festgelegt ist. Dann können Sie Ihre GRUB-Einstellungen problemlos rückgängig machen, falls Sie betroffen sind.

Ich habe versucht, dasselbe zu tun und fand in den Ubuntu-Foren, insbesondere in diesem Thread , große Hilfe .

Vorausgesetzt, Sie haben das Richtige getan /etc/default/grub, GRUB_TIMEOUTund GRUB_HIDDEN_TIMEOUT(ich würde sagen zu 0 und 5) richtig eingestellt und sogar das GRUB_DEFAULTzu startende Standard-Image angegeben, dann müssen Sie wie folgt vorgehen, damit es richtig funktioniert.

1. Fügen Sie diese Zeilen hinzu

   GRUB_FORCE_HIDDEN_MENU="true"
   export GRUB_FORCE_HIDDEN_MENU
   

   bis zum Ende von /etc/default/grub

2. Sichern Sie Ihre /etc/grub.d/30_os-proberund überschreiben Sie sie mit der hier gefundenen Version

3. Probier es aus! Um das Menü anzuzeigen, drücken Sie die SHIFTTaste

Dieses Problem hängt mit der Einrichtung mehrerer Betriebssysteme zusammen, und das Bearbeiten des Skripts ist eine Möglichkeit, dies zu beheben.

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

Unter Ubuntu 16.04 habe ich folgende Änderungen vorgenommen. Natürlich müssen Sie ein privilegierter Benutzer sein, um dies zu tun.

1. Erste Änderung ist in der /etc/grub.d/30_os-proberDatei:

   • Öffne es mit sudo gedit /etc/grub.d/30_os-prober
   • Wechseln Sie quick_boot="1"zuquick_boot="0"
   • Speicher die Datei

2. Danach können Sie die Timeout-Werte /etc/default/grubauf Null oder einen anderen Wert setzen:

   • Öffne es mit sudo gedit /etc/default/grub
   • GRUB_HIDDEN_TIMEOUT=0und GRUB_TIMEOUT=0.
   • Speicher die Datei

3. Der letzte Schritt ist das Aktualisieren von grub

   • sudo update-grub

Die Änderungen an der ersten Datei sind darauf zurückzuführen, dass der Timeout-Wert bei anderen Betriebssystemen (z. B. Windows 10) immer auf 10 Sekunden festgelegt ist und daher nicht von geändert werden kann /etc/default/grub. Dies wird durch eine Funktion namens erreicht, adjust_timeoutdie fragt, ob quick_bootgesetzt ist und ob andere Betriebssysteme vorhanden sind.

Installieren Sie den Grub Optimizer

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

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

Grub Customizer wird nun im Menü "Programme"> "Systemprogramme" angezeigt.

Oder Sie können es über die Befehlszeile öffnen.

gksudo grub-customizer

Ich hatte das gleiche Problem auf einem einzelnen Boot-System. Wenn GRUB_TIMEOUT nicht Null wäre, würde das Menü unabhängig von GRUB_HIDDEN_TIMEOUT immer angezeigt. Wenn GRUB_TIMEOUT Null wäre, würde es für GRUB_HIDDEN_TIMEOUT Sekunden schlafen, aber weder SHIFT noch ESC würden das Menü anzeigen.

Ich habe es behoben, indem ich am Ende von adjust_time () in 30_os-prober eine else-Klausel in die sleep-Anweisung eingefügt habe. Wenn es nicht unterbrochen wird, ist das Zeitlimit Null und es wird ohne Menü gestartet. Wenn es jedoch unterbrochen wird, setze ich das Zeitlimit auf 10.

Dies scheint rückwärts zu sein, da der Schlaf 0 (falsch) zurückgeben sollte, wenn er nicht unterbrochen wird, und 1 (wahr), wenn dies der Fall ist, aber es schien für mich zu funktionieren.

DAS GRUB2-BOOT-MENÜ AUTOMATISCH SICHTBAR MACHEN

Aus irgendeinem Grund wird beim Bearbeiten der GRUB_GFXMODE=640x480Einstellungen im Grub Customizer normalerweise das Startmenü angezeigt:

1. Installiere grub-customizer wie oben und aktualisiere
2. finde Grub Customizer in der GUI (für mich ist es in System> Administration> ..., aber für einige ist es Fund unter Applications> System Tools> ..)
3. Öffnen Sie Grub Customizer und wählen Sie Einstellungen> Erweitert
4. Wählen Sie GRUB_gfxmode (640X480) - wenn es bereits ausgewählt ist, deaktivieren Sie es, starten Sie es neu und wählen Sie es erneut aus.
5. Daumen drücken und neu starten!

Ich habe keine Ahnung, warum das bei mir funktioniert hat, aber es hat auf beiden Computern funktioniert, also hoffentlich auch bei Ihnen!

Shasteriskt, eine Alternative zur 'SHIFT'-Lösung, besteht darin, ein Skript zu erstellen, das einige Verschiebevorgänge für Sie ausführt. Was ich meine, ist eine Datei namens erstellen grub.bak, die eine exakte Kopie Ihrer grub.cfgDatei ist, mit dem einzigen Unterschied, dass die set timeout=0Zeile set timeout=10zum Beispiel in geändert wird . Erstellen Sie ein Shell-Skript, das einen Switch ausführt, mit dem Sie Ihren Anforderungen entsprechend neu starten können. Ich habe ein äquivalentes Python-Skript erstellt, das diese Anforderungen erfüllt, aber es muss natürlich mit aufgerufen werden sudo. Ich habe es einfach /usr/binals Symlink zum eigentlichen Skript in mein Setup eingefügt. Hinweis: Ich verwende Fluxbox auf Arch, daher bin ich mir nicht sicher, ob es Diskrepanzen zwischen diesem Skript und Ubuntu gibt, aber ich denke, dass es kaum oder gar keine Änderungen geben sollte. Das Skript sieht folgendermaßen aus:

#! /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'))

Das Skript bestimmt im Grunde nur, ob Sie das Menü zum Laden haben oder nicht (Auto-Boot oder nicht). Basierend auf den Ergebnissen werden Sie gefragt, ob Sie es ein- oder ausschalten möchten, und anschließend, ob Sie einen Neustart durchführen möchten. Umgekehrt können Sie, wenn Sie möchten, dass es umgekehrt funktioniert (z. B. unter Windows) und Windows für den Zugriff auf Dateien unter Linux eingerichtet ist, dasselbe Skript auch in dieser Umgebung ausführen. Hoffentlich hilft das.

Selbst wenn Sie GRUB_TIMEOUT auf 0 setzen, setzt 30_os-prober das Timeout auf 10, wenn Sie GRUB_HIDDEN_TIMEOUT haben. Andere Lösungen hier bearbeiten das Skript, aber das kann zu Aktualisierungsproblemen führen, die Sie zusammenführen müssen, wenn GRUB aktualisiert wird.

Bessere Lösung: Schreiben Sie folgendes in /etc/grub.d/50_goddamnit(neue Datei):

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

Grundsätzlich wird dies als letztes ausgeführt und ist die letzte Zeile in /boot/grub/grub.conf, wodurch alle anderen albernen Mishigus in der Standardkonfiguration überschrieben werden.