Nascondi il menu GRUB2 A MENO CHE non tieni premuto il tasto MAIUSC: come farlo?

Ho un Ubuntu - Windows 7 dual-boot setup, e vorrei che il mio laptop avviasse Windows 7 a meno che non premessi il tasto Maiusc subito dopo l'avvio e aprissi il menu Grub2 da cui posso scegliere Ubuntu.

Ho studiato Grub2 e opzioni per etc/default/grube ho provato a giocare con combinazioni con i valori GRUB_TIMEOUTe GRUB_HIDDEN_TIMEOUT, ma senza risultati. Ho provato a impostare un GRUB_HIDDEN_TIMEOUTvalore superiore al GRUB_TIMEOUTpensiero che entrambi i conti alla rovescia si avviino contemporaneamente, ma il no GRUB_TIMEOUTinizia solo dopo che l'altro è terminato.

Questo comportamento è realizzabile?

Se é cosi, come?

Penso di aver trovato una risoluzione più semplice. Modifica le seguenti righe nel file / etc / default / grub:

GRUB_HIDDEN_TIMEOUT = 0.0

GRUB_TIMEOUT = 0.0

Naturalmente finalmente eseguiamo un update-grub. Funziona sul mio PC.

Questo è per Ubuntu 16.04.

Ho risolto questo problema con una piccola combinazione di alcune delle risposte trovate sopra, quindi non è necessario modificare 30_os-prober, evitando future fusioni quando il pacchetto grub viene aggiornato ...

Spero che sia d'aiuto.

Modificate alcune variabili in / etc / default / grub per riflettere ciò che voglio;

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

Quindi creato un nuovo file;

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

riempito con questo contenuto;

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

e grub aggiornato;

sudo update-grub

Saluti.

In Kubuntu 14.04, questo non funziona, se si imposta GRUB_TIMEOUT= 0, stranamente, dopo averlo applicato e riavviato, il menu di grub rimane visibile per 10 secondi.

La ragione di ciò è che in un altro script grub c'è un pezzo di codice che imposta grub_timeout su 10 se ha il valore di 0.

Quindi è così che l'ho fatto funzionare:

fai una copia di entrambi grube dei 30_osproberfile !!! Quando qualcosa va storto, è possibile ripristinare i file originali

Nel /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 , c'è un pezzo di codice che imposta il timeout di grub su 10s se è impostato su zero in /etc/default/grub, non so perché gli sviluppatori lo mettono lì, ma impedisce di nascondere il menu di grub.

set timeout_style=menu

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

Dopo queste modifiche, esegui sudo update-grubper generare la nuova sequenza di avvio di grub.

Documento tutte le mie correzioni / mod su Linux su https://sites.google.com/site/marcshomesite/Home/linux-tuning

Per avviare automaticamente Windows senza dover selezionare dal menu GRUB è necessario modificare il /etc/default/grubfile con valori simili a questi:

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

È sempre una buona idea eseguire il backup di questi file prima di modificarli. Dopo aver apportato le modifiche, è necessario attivarle con

sudo update-grub

I valori per GRUB_DEFAULT dipendono dal nostro sistema individuale. Per avviare sempre Windows possiamo in alternativa inserire il nome della voce esattamente come mostrato nel menu Grub (ad es. "Microsoft Windows XP Professional") Anziché il numero della voce.

Nota importante: in alcune macchine il menu di GRUB non può essere visualizzato tenendo premuto a sinistra Shiftall'avvio (vedi bug # 425979 ). Pertanto, potrebbe essere una buona idea testarlo prima con Ubuntu (non Windows) impostato come sistema operativo predefinito. Quindi sarai in grado di annullare facilmente le impostazioni di GRUB in caso tu sia interessato.

Stavo cercando di fare lo stesso e ho trovato un grande aiuto nei forum di Ubuntu, in particolare in questo thread.

Supponendo che tu abbia fatto la cosa giusta /etc/default/grub, impostando correttamente GRUB_TIMEOUTe GRUB_HIDDEN_TIMEOUT(direi rispettivamente a 0 e 5) e anche GRUB_DEFAULTper specificare l'immagine predefinita da avviare, ecco la procedura per farlo funzionare nel modo giusto.

1. Aggiungi quelle righe

   GRUB_FORCE_HIDDEN_MENU="true"
   export GRUB_FORCE_HIDDEN_MENU
   

   fino alla fine di /etc/default/grub

2. Eseguire il backup /etc/grub.d/30_os-probere sovrascriverlo con la versione disponibile qui

3. Provalo! Per mostrare il menu premere il SHIFTtasto

Questo problema è legato alla configurazione multi OS e la modifica dello script è uno dei modi per correggerlo.

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

Su Ubuntu 16.04 ho apportato le seguenti modifiche. Ovviamente devi essere un utente privilegiato per farlo.

1. La prima modifica è nel /etc/grub.d/30_os-proberfile:

   • Aprilo con sudo gedit /etc/grub.d/30_os-prober
   • Cambia quick_boot="1"inquick_boot="0"
   • salva il file

2. Successivamente è possibile impostare i valori di timeout /etc/default/grubsu zero o su un altro valore:

   • Aprilo con sudo gedit /etc/default/grub
   • GRUB_HIDDEN_TIMEOUT=0e GRUB_TIMEOUT=0.
   • salva il file

3. L'ultimo passo è aggiornare grub

   • sudo update-grub

Le modifiche al primo file sono perché l'impostazione predefinita è che se viene trovato un altro sistema operativo (ad esempio Windows 10) il valore di timeout è sempre impostato su 10 secondi e quindi non può essere modificato da /etc/default/grub. Ciò viene realizzato da una funzione denominata adjust_timeoutche chiede se quick_bootè impostato e se sono presenti altri sistemi operativi.

installa grub optimizer

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

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

Grub Customizer ora apparirà nel menu Applicazioni> Strumenti di sistema.

Oppure puoi aprirlo dalla riga di comando.

gksudo grub-customizer

Stavo avendo lo stesso problema su un singolo sistema di avvio. Se GRUB_TIMEOUT fosse diverso da zero, il menu sarebbe sempre visualizzato indipendentemente da GRUB_HIDDEN_TIMEOUT. Se GRUB_TIMEOUT fosse zero, dormirà per GRUB_HIDDEN_TIMEOUT secondi ma né SHIFT né ESC mostrerebbero il menu.

L'ho risolto aggiungendo una clausola else allo stato sleep alla fine di adjust_time () in 30_os-prober. Ora se non viene interrotto il timeout è zero e si avvia senza menu, ma se viene interrotto imposto il timeout su 10.

Questo in realtà sembra al contrario poiché il sonno dovrebbe restituire 0 (falso) se non viene interrotto e 1 (vero) se lo è, ma sembra funzionare per me.

Rendere il menu di avvio di GRUB2 VISIBILE AUTOMATICAMENTE

Per qualche motivo, la modifica delle GRUB_GFXMODE=640x480impostazioni in Grub Customizer solitamente rende visibile il menu di avvio:

1. Installa grub-customizer come sopra e aggiorna
2. trova Grub Customizer nella GUI (per me è in Sistema> Amministrazione> ..., ma per alcuni è fondo in Applicazioni> Strumenti di sistema> ..)
3. Apri Grub Customizer e seleziona Preferenze> Avanzate
4. Seleziona GRUB_gfxmode (640X480) - se è già selezionato, deselezionalo, riavvia e selezionalo di nuovo.
5. incrocia le dita e riavvia!

Non ho idea del perché questo abbia funzionato per me, ma ha funzionato su entrambi i miei computer, quindi spero che funzionerà anche per te!

Shasteriskt, un'alternativa alla soluzione "SHIFT" è solo quella di creare uno script che esegua alcune operazioni di spostamento per te. Quello che voglio dire è creare un file chiamato grub.bakche è una copia esatta del tuo grub.cfgfile, con l'unica differenza che la set timeout=0linea viene cambiata, ad set timeout=10esempio. Crea uno script di shell che esegue uno switch che ti consente di riavviare in base alle tue esigenze. Ho creato uno script Python equivalente che soddisfa questi requisiti, ma ovviamente deve essere chiamato sudo. L'ho semplicemente inserito nel /usr/binmio setup come link simbolico allo script stesso. Nota: sto eseguendo fluxbox su Arch, quindi non sono sicuro che ci siano discrepanze tra questo script e Ubuntu, ma credo che non ci dovrebbero essere modifiche minime o nulle. Lo script appare come:

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

Lo script in pratica determina solo se hai o meno il menu da caricare (avvio automatico o meno). In base ai risultati, ti chiede se desideri attivarlo o disattivarlo, quindi ti chiede se desideri riavviare. Al contrario, se si desidera che funzioni al contrario (ovvero in Windows) e Windows è configurato per accedere ai file in Linux, è possibile eseguire lo stesso script anche in quell'ambiente, se lo si desidera. Spero che sia d'aiuto.

Quindi, anche se imposti GRUB_TIMEOUT su 0, se hai GRUB_HIDDEN_TIMEOUT, 30_os-prober imposterà il timeout su 10, che ti piaccia o no. Altre soluzioni qui modificano quello script, ma ciò potrebbe causare problemi di aggiornamento che dovrai unire se GRUB viene aggiornato.

Soluzione migliore: scrivere quanto segue in /etc/grub.d/50_goddamnit(nuovo file):

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

Fondamentalmente, questo verrà eseguito per ultimo e sarà l'ultima riga in /boot/grub/grub.conf, sostituendo così tutti gli altri sciocchi mishigus nella configurazione predefinita.