Ocultar el menú GRUB2 A MENOS que mantenga presionada la tecla Mayús: ¿cómo hacer que esto suceda?

Tengo una configuración de inicio dual de Ubuntu - Windows 7, y me gustaría que mi computadora portátil inicie Windows 7 a menos que presione la tecla Shift justo después del inicio y aparezca el menú Grub2 desde el que puedo elegir Ubuntu

Investigué sobre Grub2 y las opciones para, etc/default/gruby he intentado jugar con combinaciones con los valores GRUB_TIMEOUTy GRUB_HIDDEN_TIMEOUT, pero fue en vano. Traté de establecer el valor GRUB_HIDDEN_TIMEOUTmás alto que el GRUB_TIMEOUTpensamiento de que ambas cuentas regresivas comienzan simultáneamente, pero no, GRUB_TIMEOUTsolo comienza después de que el otro haya terminado.

¿Es posible este comportamiento?

¿Si es así, cómo?

Creo que encontré una resolución más simple. Modifique las siguientes líneas en el archivo / etc / default / grub:

GRUB_HIDDEN_TIMEOUT = 0.0

GRUB_TIMEOUT = 0.0

Por supuesto, finalmente ejecutamos una actualización-grub. Funciona en mi PC.

Esto es para Ubuntu 16.04.

Resolví esto con una pequeña combinación de algunas de las respuestas encontradas anteriormente, por lo que no es necesario modificar 30_os-prober, evitando futuras fusiones cuando se actualiza el paquete grub ...

Espero eso ayude.

Cambié algunas variables en / etc / default / grub para reflejar lo que quiero;

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

Luego creó un nuevo archivo;

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

lo llenó con este contenido;

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

y grub actualizado;

sudo update-grub

Aclamaciones.

En Kubuntu 14.04, esto no funciona, si configura GRUB_TIMEOUT= 0, extrañamente, después de aplicar esto y reiniciar, el menú grub permanece visible durante 10 segundos.

La razón de esto es que en otro script grub hay un fragmento de código que establece grub_timeout en 10 si tiene el valor de 0.

Así es como lo hice funcionar:

hacer una copia de ambos gruby 30_osproberarchivos !!! Cuando algo sale mal, puede volver a colocar los archivos originales

En /etc/default/grub

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

GRUB_TIMEOUT=0

en/etc/grub.d/30_os-prober , hay un fragmento de código que establece el tiempo de espera de grub en 10 segundos si se establece en cero /etc/default/grub, no sé por qué los desarrolladores lo pusieron allí, pero evita ocultar el menú de grub.

set timeout_style=menu

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

Después de estos cambios, ejecute sudo update-grubpara generar la nueva secuencia de arranque de grub.

Documento todas mis correcciones / modificaciones de Linux en https://sites.google.com/site/marcshomesite/Home/linux-tuning

Para iniciar Windows automáticamente sin tener que seleccionar desde el menú de GRUB, necesitamos editar el /etc/default/grubarchivo con valores similares a estos:

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

Siempre es una buena idea hacer copias de seguridad de estos archivos antes de editarlos. Después de haber realizado cambios, debemos activarlos con

sudo update-grub

Los valores para GRUB_DEFAULT dependen de nuestro sistema individual. Para iniciar siempre Windows, alternativamente podemos poner el nombre de la entrada exactamente como se mostró en el menú Grub (por ejemplo "Microsoft Windows XP Professional") en lugar del número de entrada.

Nota importante: en algunas máquinas, el menú GRUB no se puede mostrar presionando y manteniendo presionado el botón deShift arranque (ver error # 425979 ). Por lo tanto, puede ser una buena idea probar esto primero con el arranque de Ubuntu (no Windows) configurado como sistema operativo predeterminado. Entonces podrá deshacer fácilmente la configuración de GRUB en caso de que se vea afectado.

Estaba tratando de hacer lo mismo y encontré una gran ayuda en los foros de Ubuntu, particularmente en este hilo.

Suponiendo que hiciste lo correcto con la /etc/default/grubconfiguración correcta GRUB_TIMEOUTy GRUB_HIDDEN_TIMEOUT(yo diría respectivamente a 0 y 5) e incluso GRUB_DEFAULTpara especificar la imagen predeterminada para arrancar, este es el procedimiento para que funcione de la manera correcta.

1. Agrega esas líneas

   GRUB_FORCE_HIDDEN_MENU="true"
   export GRUB_FORCE_HIDDEN_MENU
   

   hasta el final de /etc/default/grub

2. /etc/grub.d/30_os-proberHaga una copia de seguridad y sobrescríbala con la versión que se encuentra aquí

3. ¡Pruébalo! Para mostrar el menú presione elSHIFT tecla

Este problema está relacionado con la configuración del sistema operativo múltiple y la edición del script es una de las formas de corregirlo.

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

En Ubuntu 16.04 he hecho los siguientes cambios. Por supuesto, debe ser un usuario privilegiado para hacerlo.

1. El primer cambio está en el /etc/grub.d/30_os-proberarchivo:

   • Ábrelo con sudo gedit /etc/grub.d/30_os-prober
   • Cambiar quick_boot="1"aquick_boot="0"
   • guarda el archivo

2. Posteriormente, puede establecer los valores de tiempo de espera en /etc/default/grubcero o algún otro valor:

   • Ábrelo con sudo gedit /etc/default/grub
   • GRUB_HIDDEN_TIMEOUT=0y GRUB_TIMEOUT=0.
   • guarda el archivo

3. El último paso es actualizar grub

   • sudo update-grub

Los cambios en el primer archivo se deben a que la configuración predeterminada es que si se encuentra otro sistema operativo (por ejemplo, Windows 10), el valor de tiempo de espera siempre se establece en 10 segundos y, por lo tanto, no se puede cambiar /etc/default/grub. Esto se logra mediante una función denominada adjust_timeoutque pregunta si quick_bootestá configurado y si hay otro sistema operativo presente.

instalar grub optimizer

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

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

Grub Customizer ahora aparecerá en el menú Aplicaciones> Herramientas del sistema.

O puede abrirlo desde la línea de comando.

gksudo grub-customizer

Estaba teniendo el mismo problema en un solo sistema de arranque. Si GRUB_TIMEOUT no fuera cero, el menú siempre aparecería independientemente de GRUB_HIDDEN_TIMEOUT. Si GRUB_TIMEOUT fuera cero, dormiría GRUB_HIDDEN_TIMEOUT segundos, pero ni SHIFT ni ESC mostrarían el menú.

Lo arreglé agregando una cláusula else al estado de suspensión al final de ajustar_tiempo () en 30_os-prober. Ahora, si no se interrumpe, el tiempo de espera es cero y arranca sin menú, pero si se interrumpe, configuro el tiempo de espera en 10.

Esto en realidad parece al revés ya que el sueño debería devolver 0 (falso) si no se interrumpe y 1 (verdadero) si lo es, pero parecía funcionar para mí.

HACIENDO EL MENÚ DE ARRANQUE GRUB2 AUTOMÁTICAMENTE VISIBLE

Por alguna razón, la edición de la GRUB_GFXMODE=640x480configuración en Grub Customizer generalmente hace que el menú de inicio sea visible:

1. Instale grub-customizer como se indica arriba y actualice
2. encuentre Grub Customizer en la GUI (para mí está en Sistema> Administración> ..., pero para algunos está financiado en Aplicaciones> Herramientas del sistema> ..)
3. Abra Grub Customizer y seleccione Preferencias> Avanzado
4. Seleccione GRUB_gfxmode (640X480); si ya está seleccionado, anule la selección, reinicie y vuelva a seleccionarlo.
5. cruza los dedos y reinicia!

No tengo idea de por qué esto funcionó para mí, pero funcionó en mis dos computadoras, ¡así que espero que también funcione para usted!

Shasteriskt, una alternativa a la solución 'SHIFT' es simplemente crear un script que realice algunas operaciones de movimiento por usted. Lo que quiero decir es crear un archivo llamado grub.bakque es una copia exacta de su grub.cfgarchivo, con la única diferencia de que la set timeout=0línea se cambia a, set timeout=10por ejemplo. Cree un script de shell que haga un cambio que le permita reiniciar de acuerdo con sus necesidades. Creé un script de python equivalente que cumple con estos requisitos, pero por supuesto tiene que ser invocado sudo. Simplemente lo puse en /usr/binmi configuración como un enlace simbólico al script en sí. Nota: Estoy ejecutando fluxbox en Arch, así que no estoy seguro de si hay alguna discrepancia entre este script y Ubuntu, pero creo que debería haber pocas modificaciones o ninguna. El guión se ve así:

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

El script básicamente determina si tiene o no el menú para cargar o no (arranque automático o no). Según sus hallazgos, le pregunta si desea activarlo o desactivarlo, y luego le pregunta si desea reiniciar. Por el contrario, si desea que funcione al revés (es decir, en Windows), y tiene Windows configurado para acceder a los archivos en Linux, también puede ejecutar el mismo script en ese entorno, si lo desea. Espero que ayude.

Entonces, incluso si configura GRUB_TIMEOUT en 0, si tiene GRUB_HIDDEN_TIMEOUT, 30_os-prober establecerá el tiempo de espera en 10, le guste o no. Otras soluciones aquí editan ese script, pero eso podría causar problemas de actualización que tendrá que fusionar si GRUB se actualiza.

Mejor solución: escriba lo siguiente en /etc/grub.d/50_goddamnit(nuevo archivo):

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

Básicamente, esto se ejecutará en último lugar y será la línea final en /boot/grub/grub.conf, anulando así todos los demás mishigus tontos en la configuración predeterminada.