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 executamos um update-grub. Funciona no meu PC.
Eu tenho uma configuração dual-boot Ubuntu-Windows 7, e gostaria que meu laptop inicializasse o Windows 7, a menos que eu pressione a tecla Shift logo após a inicialização e abra o menu do Grub2 a partir do qual Eu posso escolher o Ubuntu.
Eu pesquisei no Grub2 e opções para etc/default/grub
e tentei brincar com combinações com os valores GRUB_TIMEOUT
e GRUB_HIDDEN_TIMEOUT
, mas sem sucesso. Eu tentei definir o GRUB_HIDDEN_TIMEOUT
maior que o GRUB_TIMEOUT
pensando que a contagem regressiva começa simultaneamente, mas não - GRUB_TIMEOUT
só inicia depois que o outro é feito.
Esse comportamento é viável?
Se sim, como?
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 executamos um update-grub. Funciona no meu PC.
Isto é para o Ubuntu 16.04.
Eu resolvi isso com uma pequena combinação de algumas das respostas encontradas acima, então não é necessário modificar o 30_os-prober, evitando futuras mesclagens quando o pacote do grub é atualizado ...
Espero que ajude.
Alteramos algumas variáveis em / 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 com 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 o grub atualizado;
sudo update-grub
Felicidades.
No Kubuntu 14.04, isso não funciona, se você definir GRUB_TIMEOUT= 0
,
Estranhamente, depois de aplicar isso e reiniciar,
o menu do grub permanece visível por 10s.
A razão para isto é que em outro script do grub há um pedaço de código que configura grub_timeout para 10 se ele tiver o valor 0.
Então é assim que eu funciono:
faça uma cópia dos arquivos grub
e 30_osprober
!!!
Quando algo dá errado, você pode colocar os arquivos originais de volta
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
,
existe um trecho de código que define o tempo limite do grub para 10s, se for definido como zero em /etc/default/grub
, não sei por que os devs o colocaram lá, mas isso evita ocultar o menu 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-grub
para gerar a nova seqüência de inicialização do grub.
Eu documentei todas as minhas correções / mods do Linux link
Para inicializar o Windows automaticamente sem precisar selecionar o menu GRUB, precisamos editar o arquivo /etc/default/grub
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 backups 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 inicializar sempre o Windows, podemos alternativamente inserir o nome da entrada exatamente como foi mostrado no menu do Grub (por exemplo, "Microsoft Windows XP Professional"
) em vez do número de entrada.
Nota importante: em algumas máquinas O menu do GRUB não pode ser exibido pressionando e mantendo pressionado o botão esquerdo Shift na inicialização (veja bug # 425979 . Portanto, pode ser uma boa idéia primeiro testar isso com o boot do Ubuntu (não o Windows) definido como o SO padrão. Então você poderá desfazer facilmente suas configurações do GRUB caso seja afetado.
Eu estava tentando fazer o mesmo e encontrei grande ajuda nos fóruns do Ubuntu, particularmente no tópico .
Supondo que você fez a coisa certa com /etc/default/grub
, definiu corretamente GRUB_TIMEOUT
e GRUB_HIDDEN_TIMEOUT
(diria respectivamente para 0 e 5) e até GRUB_DEFAULT
para especificar a imagem padrão a ser inicializada, aqui está o procedimento para que funcione da maneira certa.
Adicione essas linhas
GRUB_FORCE_HIDDEN_MENU="true"
export GRUB_FORCE_HIDDEN_MENU
ao final de /etc/default/grub
Faça o backup de seu /etc/grub.d/30_os-prober
e sobrescreva-o com a versão encontrada aqui
Teste! Para mostrar o menu, pressione a tecla SHIFT
Esse problema está relacionado à configuração do multi OS e a edição do script é uma das formas 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\(.*\))/s/''"
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
No Ubuntu 16.04, fiz as seguintes alterações. Claro que você precisa ser um usuário privilegiado para fazê-lo.
A primeira alteração está no arquivo /etc/grub.d/30_os-prober
:
sudo gedit /etc/grub.d/30_os-prober
quick_boot="1"
para quick_boot="0"
Depois disso, você pode definir os valores de tempo limite em /etc/default/grub
para zero ou algum outro valor:
sudo gedit /etc/default/grub
GRUB_HIDDEN_TIMEOUT=0
e GRUB_TIMEOUT=0
. 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 de tempo limite será sempre definido como 10 segundos e, portanto, não poderá ser alterado por /etc/default/grub
. Isso é realizado por uma função chamada adjust_timeout
, que pergunta se quick_boot
está definido como e se outros sistemas operacionais estiverem presentes.
instalar o otimizador do grub
% bl0ck_qu0te%O Grub Customizer agora será exibido na pasta Aplicativos > Menu Ferramentas do sistema.
Ou você pode abri-lo na linha de comando.
% bl0ck_qu0te%
COMO FAZER O MENU DE INICIALIZAÇÃO DO GRUB2 AUTOMATICAMENTE VISÍVEL
Por algum motivo, editar as configurações de GRUB_GFXMODE=640x480
no Grub Customizer geralmente torna o menu de inicialização visível:
Não sei por que isso funcionou para mim, mas funcionou em ambos os meus computadores, por isso espero que funcione para você também!
Shasteriskt, uma alternativa para a 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.bak
, que é uma cópia exata do arquivo grub.cfg
, com a única diferença de que a linha set timeout=0
é alterada para set timeout=10
, por exemplo. Crie um script de shell que faça um comutador permitindo que você reinicialize de acordo com suas necessidades. Eu criei um script python equivalente que atende a esses requisitos, mas é claro que ele precisa ser chamado com sudo
. Eu simplesmente coloco em /usr/bin
na minha configuração como um link simbólico para o script em si. Nota: Estou executando o fluxbox no Arch, por isso não tenho certeza se há alguma discrepância entre esse script e o Ubuntu, mas deve haver pouca ou nenhuma modificação, eu acho. 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 em suas descobertas, ele pergunta se você deseja ativá-lo ou desativá-lo e, em seguida, pergunta se deseja reinicializá-lo. Por outro lado, se você quiser que ele funcione ao contrário (ou seja, no Windows), e você tem o Windows configurado para acessar arquivos no Linux, você pode executar o mesmo script nesse ambiente também, se desejar. Espero que ajude.
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 duraria por GRUB_HIDDEN_TIMEOUT segundos, mas nem SHIFT nem ESC mostrariam o menu.
Eu consertei adicionando uma cláusula else ao statment sleep no final de adjust_time () em 30_os-prober. Agora, se ele não for interrompido, o tempo limite será zero e ele será inicializado sem menu, mas se for interrompido, defino o tempo limite para 10.
Isso realmente parece para trás, já que o sono deve retornar 0 (falso) se não for interrompido e 1 (verdadeiro) se for, mas parece que funcionou para mim.
Portanto, mesmo se você definir GRUB_TIMEOUT como 0, se tiver algum GRUB_HIDDEN_TIMEOUT, 30_os-prober definirá o tempo limite como 10, quer você goste ou não. Outras soluções aqui editam esse script, mas isso pode causar problemas de atualização que você terá que 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 vai rodar last e ser a linha final em /boot/grub/grub.conf, sobrescrevendo todos os outros mishigus na configuração padrão.