Ukryj menu GRUB2, chyba że przytrzymasz klawisz Shift: jak to zrobić?

Mam konfigurację podwójnego rozruchu systemu Ubuntu - Windows 7 i chciałbym, aby mój laptop uruchomił system Windows 7, chyba że nacisnę klawisz Shift zaraz po uruchomieniu i wyświetlę menu Grub2, z którego mogę wybrać Ubuntu.

Badałem Grub2 i opcje etc/default/grubi próbowałem bawić się kombinacjami z wartościami GRUB_TIMEOUTi GRUB_HIDDEN_TIMEOUT, ale bezskutecznie. Próbowałem ustawić wartość GRUB_HIDDEN_TIMEOUTwyższą niż GRUB_TIMEOUTmyślenie, że oba odliczanie rozpoczynają się jednocześnie, ale nie - GRUB_TIMEOUTzaczyna się dopiero po zakończeniu drugiego.

Czy to zachowanie jest możliwe do osiągnięcia?

Jeśli tak to jak?

Myślę, że znalazłem prostsze rozwiązanie. Zmodyfikuj następujące wiersze w pliku / etc / default / grub:

GRUB_HIDDEN_TIMEOUT = 0,0

GRUB_TIMEOUT = 0,0

Oczywiście w końcu uruchomiliśmy aktualizację-grub. Działa na moim komputerze.

Dotyczy to Ubuntu 16.04.

Rozwiązałem to za pomocą niewielkiej kombinacji niektórych odpowiedzi znalezionych powyżej, więc nie trzeba modyfikować 30_os-prober, unikając przyszłych scaleń, gdy pakiet grub zostanie zaktualizowany ...

Mam nadzieję, że to pomoże.

Zmieniono niektóre zmienne w / etc / default / grub, aby odzwierciedlić to, czego chcę;

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

Następnie utworzył nowy plik;

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

wypełnił ją tą treścią;

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

i zaktualizowane grub;

sudo update-grub

Twoje zdrowie.

W Kubuntu 14.04 to nie działa, jeśli GRUB_TIMEOUT= 0dziwnie ustawisz , po zastosowaniu tego i ponownym uruchomieniu, menu grub pozostaje widoczne przez 10s.

Powodem tego jest to, że w innym skrypcie grub znajduje się fragment kodu, który ustawia grub_timeout na 10, jeśli ma wartość 0.

Oto jak to działa:

zrób kopię obu plików grubi 30_osproberplików !!! Gdy coś pójdzie nie tak, możesz przywrócić oryginalne pliki

W /etc/default/grub

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

GRUB_TIMEOUT=0

w/etc/grub.d/30_os-prober , tam jest kawałek kodu, który ustawia grub timeout 10s jeśli jest on ustawiony na zero /etc/default/grub, nie wiem dlaczego deweloperów umieścić go tam, ale uniemożliwia ukrycie menu grub.

set timeout_style=menu

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

Po tych zmianach uruchom, sudo update-grubaby wygenerować nową sekwencję rozruchową grub.

Dokumentuję wszystkie moje poprawki / mody na Linuksa na https://sites.google.com/site/marcshomesite/Home/linux-tuning

Aby automatycznie uruchomić system Windows bez konieczności wybierania z menu GRUB, musimy edytować /etc/default/grubplik o wartościach podobnych do tych:

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

Zawsze dobrym pomysłem jest tworzenie kopii zapasowych tych plików przed ich edycją. Po wprowadzeniu zmian musimy je aktywować za pomocą

sudo update-grub

Wartości GRUB_DEFAULT zależą od naszego indywidualnego systemu. Aby zawsze uruchamiać system Windows, możemy alternatywnie wpisać nazwę wpisu dokładnie tak, jak pokazano w menu Grub (np. "Microsoft Windows XP Professional") Zamiast numeru wpisu.

Ważna uwaga: w niektórych maszynach menu GRUB-a nie może być wyświetlane po naciśnięciu i przytrzymaniu lewego przycisku Shiftpodczas uruchamiania (patrz błąd # 425979 ). Dlatego dobrym pomysłem może być przetestowanie go najpierw przy uruchamianiu Ubuntu (nie Windows) jako domyślnego systemu operacyjnego. Wtedy będziesz mógł łatwo cofnąć ustawienia GRUB-a na wypadek, gdybyś miał na to wpływ.

Próbowałem zrobić to samo i znalazłem świetną pomoc na forach Ubuntu, szczególnie w tym wątku.

Zakładając, że zrobiłeś coś dobrego /etc/default/grub, poprawnie ustawiając GRUB_TIMEOUTi GRUB_HIDDEN_TIMEOUT(powiedziałbym odpowiednio 0 i 5), a nawet GRUB_DEFAULTokreślając domyślny obraz do uruchomienia, oto procedura, aby działał poprawnie.

1. Dodaj te linie

   GRUB_FORCE_HIDDEN_MENU="true"
   export GRUB_FORCE_HIDDEN_MENU
   

   do końca /etc/default/grub

2. Utwórz /etc/grub.d/30_os-proberkopię zapasową i zastąp ją wersją znajdującą się tutaj

3. Sprawdź to! Aby wyświetlić menu, naciśnij SHIFTklawisz

Ten problem jest związany z konfiguracją wielu systemów operacyjnych, a edytowanie skryptu jest jednym ze sposobów rozwiązania tego problemu.

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

Na Ubuntu 16.04 dokonałem następujących zmian. Oczywiście musisz być do tego uprzywilejowanym użytkownikiem.

1. Pierwsza zmiana znajduje się w /etc/grub.d/30_os-proberpliku:

   • Otwórz za pomocą sudo gedit /etc/grub.d/30_os-prober
   • Zmień quick_boot="1"naquick_boot="0"
   • Zapisz plik

2. Następnie możesz ustawić wartości limitu czasu /etc/default/grubna zero lub inną wartość:

   • Otwórz za pomocą sudo gedit /etc/default/grub
   • GRUB_HIDDEN_TIMEOUT=0a GRUB_TIMEOUT=0.
   • Zapisz plik

3. Ostatnim krokiem jest aktualizacja grub

   • sudo update-grub

Zmiany w pierwszym pliku są spowodowane tym, że domyślnym ustawieniem jest to, że jeśli zostaną znalezione inne systemy operacyjne (np. Windows 10), wartość limitu czasu jest zawsze ustawiona na 10 sekund i dlatego nie można jej zmienić /etc/default/grub. Dokonuje się tego funkcja o nazwie, adjust_timeoutktóra pyta, czy quick_bootjest ustawiona i czy obecny jest inny system operacyjny.

zainstaluj optymalizator grub

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

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

Grub Customizer pojawi się teraz w menu Aplikacje> Narzędzia systemowe.

Lub możesz go otworzyć z wiersza poleceń.

gksudo grub-customizer

Miałem ten sam problem w systemie z jednym uruchomieniem. Jeśli GRUB_TIMEOUT był niezerowy, menu zawsze pojawiało się niezależnie od GRUB_HIDDEN_TIMEOUT. Gdyby GRUB_TIMEOUT wynosił zero, spałby przez GRUB_HIDDEN_TIMEOUT sekund, ale ani SHIFT, ani ESC nie pokazywałyby menu.

Naprawiłem to, dodając klauzulę else do statystyki uśpienia na końcu Adjust_time () w 30_os-prober. Teraz, jeśli nie jest przerwany, limit czasu wynosi zero i uruchamia się bez menu, ale jeśli jest przerywany, ustawiam limit czasu na 10.

To faktycznie wydaje się odwrócone, ponieważ sen powinien zwrócić 0 (fałsz), jeśli nie jest przerwany, i 1 (prawda), jeśli tak, ale wydaje się, że działa dla mnie.

WYKONYWANIE AUTOMATYCZNIE WIDOCZNEGO MENU BOOT GRUB2

Z jakiegoś powodu edycja GRUB_GFXMODE=640x480ustawień w Grub Customizerze zazwyczaj powoduje wyświetlenie menu rozruchu:

1. Zainstaluj grub-customizer jak wyżej i zaktualizuj
2. znajdź Grub Customizer w GUI (dla mnie to w System> Administracja> ..., ale dla niektórych jest to fundusz w Aplikacje> Narzędzia systemowe> ..)
3. Otwórz Grub Customizer i wybierz Preferencje> Zaawansowane
4. Wybierz tryb GRUB_gfx (640X480) - jeśli jest już zaznaczony, odznacz go, uruchom ponownie i wybierz ponownie.
5. trzymaj kciuki i uruchom ponownie!

Nie mam pojęcia, dlaczego to działało dla mnie, ale działało na obu moich komputerach, więc mam nadzieję, że zadziała również dla ciebie!

Shasteriskt, jedną z alternatyw dla rozwiązania „SHIFT” jest po prostu utworzenie skryptu, który wykona za Ciebie pewne operacje przenoszenia. Chodzi mi o to, aby utworzyć plik o nazwie, grub.bakktóry jest dokładną kopią grub.cfgpliku, z tą różnicą, że na przykład set timeout=0zmieniono wiersz set timeout=10. Utwórz skrypt powłoki, który robi przełącznik umożliwiający ponowne uruchomienie w zależności od potrzeb. Stworzyłem równoważny skrypt Pythona, który spełnia te wymagania, ale oczywiście trzeba go wywołać sudo. Po prostu włączyłem go w /usr/binkonfiguracji jako dowiązanie symboliczne do samego skryptu. Uwaga: korzystam z Fluxboksa na Archu, więc nie jestem pewien, czy są jakieś rozbieżności między tym skryptem a Ubuntu, ale myślę, że nie powinno być żadnych modyfikacji lub ich brak. Skrypt wygląda następująco:

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

Skrypt po prostu określa, czy masz menu do załadowania, czy nie (automatyczne uruchamianie, czy nie). Na podstawie swoich ustaleń pyta, czy chcesz go włączyć, czy wyłączyć, a następnie pyta, czy chcesz zrestartować komputer. I odwrotnie, jeśli chcesz, aby działał na odwrót (tj. W systemie Windows) i masz skonfigurowany system Windows do uzyskiwania dostępu do plików w systemie Linux, możesz uruchomić ten sam skrypt również w tym środowisku, jeśli chcesz. Mam nadzieję, że to pomaga.

Więc nawet jeśli ustawisz GRUB_TIMEOUT na 0, jeśli masz GRUB_HIDDEN_TIMEOUT, 30_os-prober ustawi limit czasu na 10, czy ci się to podoba, czy nie. Inne rozwiązania tutaj edytują ten skrypt, ale może to powodować problemy z aktualizacją, które będziesz musiał scalić, jeśli GRUB zostanie zaktualizowany.

Lepsze rozwiązanie: napisz w /etc/grub.d/50_goddamnit(nowy plik):

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

Zasadniczo będzie to działało jako ostatnie i będzie ostatnim wierszem w /boot/grub/grub.conf, zastępując w ten sposób wszystkie inne głupie bzdury w domyślnej konfiguracji.