Ocultar o menu GRUB2 A menos que você mantenha pressionada a tecla Shift: como fazer isso acontecer?


32

Eu tenho uma configuração de inicialização dupla do Ubuntu - Windows 7 e gostaria que o meu laptop inicializasse o Windows 7, a menos que eu pressione a tecla Shift logo após a inicialização e abra o menu Grub2 no qual posso escolher Ubuntu.

Eu pesquisei no Grub2 e opções para etc/default/grube tentei brincar com combinações com os valores GRUB_TIMEOUTe GRUB_HIDDEN_TIMEOUT, mas sem sucesso. Tentei definir o valor GRUB_HIDDEN_TIMEOUTmais alto do que o GRUB_TIMEOUTpensamento de que a contagem regressiva começa simultaneamente, mas não - GRUB_TIMEOUTsó começa depois que a outra é feita.

Esse comportamento é possível?

Se sim, como?


1
A maneira como faço isso é que eu tenho o tempo limite definido como 0 (definido usando o Grub Customizer). Eu não consigo exibir nenhum menu do GRUB2, a menos que mantenha pressionada a tecla shift logo após a bios, que exibe o menu. ppa sudo add-apt-repositório: danielrichter2007 / grub-customizer sudo apt-get update sudo apt-get install grub-customizer
Ryan McClure

É do meu entendimento este é o comportamento padrão para algumas instalações
RobotHumans

@RyanMcClure Tentei definir o tempo limite manualmente para 0, mas manter a tecla Shift à direita não abre o menu Grub2.
Bez Hermoso 31/03

Respostas:


15

Eu acho que encontrei uma resolução mais simples. Modifique as seguintes linhas no arquivo / etc / default / grub:

GRUB_HIDDEN_TIMEOUT = 0.0

GRUB_TIMEOUT = 0.0

É claro que finalmente rodamos um update-grub. Funciona no meu PC.


6
Risca isso. Isso não me dá o menu grub, mas também não consigo obtê-lo pressionando shift.
Zorkerz 11/11/2016

9

Isto é para o Ubuntu 16.04.

Resolvi isso com uma pequena combinação de algumas das respostas encontradas acima, portanto, não é necessário modificar o 30_os-prober, evitando futuras fusões quando o pacote grub for atualizado ...

Espero que ajude.

Alterei algumas variáveis ​​no / etc / default / grub para refletir o que eu quero;

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

Em seguida, criou um novo arquivo;

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

preencheu este conteúdo;

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

sudo update-grub

Felicidades.


Não está trabalhando para mim.
Menasheh

Eu só testei isso em 16.04. Você está em uma versão diferente?
tux1c

Pode ter sido 16,10. Você está certo, definitivamente deveria ter mencionado isso.
Menasheh 19/05

Funciona em Debian aperto bem
Jocelyn DELALANDE

7

No Kubuntu 14.04, isso não funciona, se você definir GRUB_TIMEOUT= 0, estranhamente, após aplicar isso e reiniciar, o menu grub permanecerá visível por 10s.

A razão para isso é que, em outro script grub, há um pedaço de código que define grub_timeout como 10 se tiver o valor 0.

Então é assim que eu consegui funcionar:

faça uma cópia de ambos grube 30_osproberarquivos !!! Quando algo der errado, você poderá devolver os arquivos originais

Em /etc/default/grub

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

GRUB_TIMEOUT=0

em/etc/grub.d/30_os-prober , há um pedaço de código que define o tempo limite do grub para 10s, se estiver definido como zero /etc/default/grub, não sei por que os desenvolvedores o colocaram lá, mas evita ocultar o menu do grub.

set timeout_style=menu

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

Após essas alterações, execute sudo update-grubpara gerar a nova sequência de inicialização do grub.

Documento todas as minhas correções / mods do linux em https://sites.google.com/site/marcshomesite/Home/linux-tuning


Eu espero que você não colocar um espaço depois =em GRUB_TIMEOUT= 0.
muru 30/07/2014

4

Para inicializar automaticamente o Windows sem precisar selecionar no menu GRUB, precisamos editar o /etc/default/grubarquivo com valores semelhantes a estes:

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 uma boa ideia fazer backup desses arquivos antes de editá-los. Depois de fazer as alterações, precisamos ativá-las com

sudo update-grub

Os valores para GRUB_DEFAULT dependem do nosso sistema individual. Para sempre inicializar o Windows, podemos alternativamente colocar o nome da entrada exatamente como foi mostrado no menu Grub (por exemplo "Microsoft Windows XP Professional") em vez do número da entrada.


Nota importante: em algumas máquinas, o menu GRUB não pode ser exibido pressionando e mantendo pressionado o botão esquerdo do mouseShift na inicialização (consulte o bug # 425979 ). Portanto, pode ser uma boa ideia testá-lo primeiro com a inicialização do Ubuntu (não do Windows) definida como sistema operacional padrão. Então você poderá desfazer facilmente suas configurações do GRUB, caso seja afetado.


Isso não torna o Ubuntu humanamente não inicializável ou haverá tempo suficiente para interceptar a inicialização e escolher o Ubuntu quando eu quiser?
Bez Hermoso 31/03

1
@Shasteriskt, você deve definir o tempo limite para um valor apenas o tempo suficiente para pressionar uma tecla para selecionar outro SO de inicialização.
Takkat 31/03

Defino o tempo limite como 0 e mantenha pressionada a tecla Shift, mas o menu ainda não aparece. (Ainda bem que eu configurá-lo para inicialização para Ubuntu onde eu pode editar as configurações para a forma como eles foram.)
Bez Hermoso

Em suma, o comportamento que eu preciso não é realizável?
Bez Hermoso 31/03

@ Shasteriskt: infelizmente, em algumas máquinas, a tecla SHIFT pressionada e pressionada à esquerda durante a inicialização para abrir o menu GRUB está quebrada (por exemplo, esse bug ). Você pode ter sorte caso ESC ou SHIFT + ESC funcionem.
Takkat 31/03

4

Eu estava tentando fazer o mesmo e encontrei uma grande ajuda nos fóruns do Ubuntu, principalmente neste tópico.

Supondo que você fez a coisa certa /etc/default/grub, configurando corretamente GRUB_TIMEOUTe GRUB_HIDDEN_TIMEOUT(eu diria respectivamente para 0 e 5) e até mesmo GRUB_DEFAULTpara especificar a imagem padrão a ser inicializada, aqui está o procedimento para fazê-la funcionar da maneira certa.

  1. Adicione essas linhas

    GRUB_FORCE_HIDDEN_MENU="true"
    export GRUB_FORCE_HIDDEN_MENU
    

    até o final de /etc/default/grub

  2. Faça backup /etc/grub.d/30_os-probere substitua-o pela versão encontrada aqui

  3. Teste-o! Para mostrar o menu, pressione a SHIFTtecla

Esse problema está relacionado à configuração do multi OS e a edição do script é uma das maneiras de corrigir isso.

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

1
Eu tentei o seu método e falhou. Ubuntu 14.04 LTS
Mayukh Nair

1
Quais partes do arquivo devo alterar? Meu arquivo 14.04 tem muitas diferenças com esse arquivo, então suponho que devo fazer apenas alterações direcionadas.
MakisH

@ MayukhNair: Eu tenho o Ubuntu 14.04 e esse método funcionou. Eu fiz o seguinte - 1. Defina GRUB_DEFAULT = 0 em / etc / default / grub 2. Configure GRUB_HIDDEN_TIMEOUT = 0 (diferente do que o Dariopnc disse) 3. Faça backup do seu /etc/grub.d/30_os-prober e copie e cole o que foi mencionado acima Arquivo 30-os_prober 4. sudo update-grub2
Pushpak Dagade

Nota grub precisa ser atualizado com sudo update-grubdepois de alterar o /etc/default/grubarquivo
Wilf

3

No Ubuntu 16.04, fiz as seguintes alterações. Claro que você precisa ser um usuário privilegiado para isso.

  1. A primeira alteração está no /etc/grub.d/30_os-proberarquivo:

    • Abra com sudo gedit /etc/grub.d/30_os-prober
    • Mude quick_boot="1"paraquick_boot="0"
    • Salve o arquivo
  2. Depois disso, você pode definir os valores de tempo limite /etc/default/grubcomo zero ou algum outro valor:

    • Abra com sudo gedit /etc/default/grub
    • GRUB_HIDDEN_TIMEOUT=0e GRUB_TIMEOUT=0.
    • Salve o arquivo
  3. O último passo é atualizar o grub

    • sudo update-grub

As alterações no primeiro arquivo ocorrem porque a configuração padrão é que, se outro sistema operacional (por exemplo, Windows 10) for encontrado, o valor do tempo limite será sempre definido como 10 segundos e, portanto, não poderá ser alterado /etc/default/grub. Isso é realizado por uma função chamada adjust_timeoutque pergunta se quick_bootestá definido e se outro sistema operacional está presente.


Finalmente somzing zat vorks wiz 16.04!
JLTD

2

instalar o otimizador grub

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

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

O Grub Customizer agora será exibido no menu Aplicativos> Ferramentas do sistema.

Ou você pode abri-lo na linha de comando.

gksudo grub-customizer

imagem dentro para opções de grub

insira a descrição da imagem aqui


3
O que isso pode fazer e não pode ser editado etc/default/grub?
Bez Hermoso 31/03

3
@ Shasteriskt: pode ser útil para pessoas que não falam inglês, pessoas que não estão familiarizadas com a linha de comando ou que querem apenas usar um computador e não mexer nos arquivos de configuração.
Flimm

Por que isso foi votado? Parece não resolver nenhum problema; Eu tentei grub-customizer(não 'otimizador') e, durante o trabalho, ele não me ajuda a ocultar o menu GRUB, a menos que a tecla Shift seja pressionada.
Nickolai Leschov

1

Eu estava tendo o mesmo problema em um único sistema de inicialização. Se GRUB_TIMEOUT fosse diferente de zero, o menu sempre apareceria, independentemente de GRUB_HIDDEN_TIMEOUT. Se GRUB_TIMEOUT fosse zero, ele seria suspenso por GRUB_HIDDEN_TIMEOUT segundos, mas nem SHIFT nem ESC mostrariam o menu.

Corrigi-o adicionando uma cláusula else à instrução sleep no final de Adjust_time () em 30_os-prober. Agora, se não for interrompido, o tempo limite é zero e é inicializado sem menu, mas se for interrompido, defino o tempo limite para 10.

Na verdade, isso parece invertido, pois o sono deve retornar 0 (falso) se não for interrompido e 1 (verdadeiro) se for, mas parecia funcionar para mim.


0

TORNAR O MENU DE INICIALIZAÇÃO DO GRUB2 VISÍVEL AUTOMATICAMENTE

Por alguma razão, editar as GRUB_GFXMODE=640x480configurações no Grub Customizer geralmente torna o menu de inicialização visível:

  1. Instale o grub-customizer como acima e atualize
  2. encontre o Grub Customizer na GUI (para mim, ele está em Sistema> Administração> ..., mas para alguns é usado em Aplicativos> Ferramentas do Sistema> ..)
  3. Abra o Grub Customizer e selecione Preferências> Avançado
  4. Selecione GRUB_gfxmode (640X480) - se já estiver selecionado, desmarque-o, reinicie-o e selecione-o novamente.
  5. cruze os dedos e reinicie!

Não sei por que isso funcionou para mim, mas funcionou em ambos os meus computadores, então espero que funcione para você também!


0

No entanto, uma alternativa à solução 'SHIFT' é apenas criar um script que faça algumas operações de movimentação para você. O que quero dizer é criar um arquivo chamado grub.bakque é uma cópia exata do seu grub.cfgarquivo, com a única diferença de que a set timeout=0linha é alterada para, set timeout=10por exemplo. Crie um script de shell que faça uma alternância, permitindo que você reinicie de acordo com suas necessidades. Eu criei um script python equivalente que atende a esses requisitos, mas é claro que precisa ser chamado sudo. Eu simplesmente o coloquei /usr/binna minha configuração como um link simbólico para o próprio script. Nota: Estou executando o fluxbox no Arch, então não tenho certeza se existem discrepâncias entre esse script e o Ubuntu, mas acho que deve haver pouca ou nenhuma modificação. O script se parece com:

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

O script basicamente determina se você tem ou não o menu para carregar ou não (inicialização automática ou não). Com base nas descobertas, ele pergunta se você deseja ativá-lo ou desativá-lo e, em seguida, pergunta se você deseja reiniciar. Por outro lado, se você quiser que o contrário funcione (por exemplo, no Windows), e você tenha o Windows configurado para acessar arquivos no Linux, poderá executar o mesmo script nesse ambiente também, se desejar. Espero que ajude.


0

Portanto, mesmo se você definir GRUB_TIMEOUT como 0, se tiver algum GRUB_HIDDEN_TIMEOUT, o 30_os-prober definirá o tempo limite como 10, gostando ou não. Outras soluções aqui editam esse script, mas isso pode causar problemas de atualização, que você precisará mesclar se o GRUB for atualizado.

Melhor solução: escreva o seguinte em /etc/grub.d/50_goddamnit(novo arquivo):

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

Basicamente, isso será executado por último e será a linha final no /boot/grub/grub.conf, substituindo assim todos os outros mishigus tolos na configuração padrão.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.