Como removo versões antigas do kernel para limpar o menu de inicialização?

701

Toda vez que instalo um novo kernel Linux, ele fica no grub_config, aumentando o menu de inicialização a cada vez.

Eu sei que posso pesquisar manualmente os pacotes instalados e removê-los.

O Ubuntu fornece uma maneira mais fácil de limpá-los ou impedir que eles apareçam na lista de inicialização?

Hans
fonte
10
Existe um comando ubuntu chamado purge-old-kernels para fazer o trabalho. Veja minha resposta para mais informações.
jarno
29
sudo apt-get autoremovedeve fazer o truque no Ubuntu 14.04+
hobs
1
O acúmulo de kernels antigos é um bug, com correção em andamento: bugs.launchpad.net/bugs/1357093 . Quando a correção é lançada, os kernels antigos serão removidos automaticamente por padrão.
user535733
1
@hobs O comando não funciona para mim no Ubuntu Studio 14.04, se os kernels não foram instalados automaticamente, mas pelo Software Updater.
Jarno
1
Continuo retornando a esta página ... o comentário de @hobs só funciona se seus kernels foram instalados automaticamente - no entanto, você sudo apt-get autoremove --purge responde seguindo os apt-markconselhos de https://help.ubuntu.com/community/RemoveOldKernels
earcam

Respostas:

602

16.04 e versões mais recentes do Ubuntu

sudo apt autoremove

Este comando remove os pacotes que foram instalados automaticamente para resolver uma dependência, mas agora não são mais dependentes. Isso inclui versões antigas dolinux-headers-* e linux-image-*. (Também é inteligente sobre esse processo, deixando uma versão sobressalente do kernel como substituto!)

11.10 e versões mais recentes do Ubuntu

GRUB2 e sua exibição de todos os kernels

As versões mais recentes do Grub2 instaladas no Ubuntu exibem automaticamente o kernel mais recente e ocultam os kernels mais antigos que você pode ter instalado.

GNU GRUB

Se você não vê seu grub - lembre-se de pressionar Shiftenquanto inicializa.

Como você pode ver, apenas o kernel mais recente é exibido.

Se você selecionar a opção mostrada (pressione Enter), todos os kernels antigos se tornarão visíveis e disponíveis para inicialização.

GNU GRUB Versões anteriores

Como excluir permanentemente os kernels antigos

Primeira inicialização com o kernel disponível mais recente.

Existem várias maneiras de excluir kernels antigos. Pessoalmente, eu não entraria em contato com o Computer Janitor, já que isso compromete o seu computador com suas sugestões.

sináptica

Uma alternativa é Synaptic ( sudo apt install synaptic)

procure linux-image , clique com o botão direito do mouse em um kernel e escolha a remoção completa e, finalmente, clique no botão Aplicar para excluir o kernel.

Gerenciador de Pacotes Synaptic

Repita a pesquisa, mas desta vez para o linux-header - você pode excluir os cabeçalhos associados à imagem do kernel escolhida anteriormente.

Embora o Synaptic não tente verificar o que você está tentando remover ... você pode excluir inadvertidamente o seu kernel mais recente - ou até mesmo excluir todos os seus kernels através desta ferramenta, deixando-o com um Ubuntu não inicializável !

Lembre-se de verificar qual kernel você está usando, digite:

uname -r

O resultado seria semelhante a:

Terminal <uname -r>

Lembre-se do resultado e do número - certifique-se de não excluir a imagem ou o cabeçalho correspondente.

Recomendação

Minha recomendação é manter pelo menos dois ou preferencialmente três núcleos, incluindo o mais recente. O motivo da recomendação é que você terá pelo menos um / dois outros kernels para inicializar, se por algum motivo o kernel mais recente não puder inicializar ou apresentar um recurso regressivo, como o wireless quebrado.

liberdade de uso
fonte
3
A remoção de pacotes antigos "linux-image *" usando o synaptic também funcionou bem com o 10.04. (Mencionei isso porque o título sugere que só pode ser para as 11h10)
mivk
4
o -yinterruptor no final da apt-getlinha é necessário; caso contrário, o apt-get apenas pede confirmação e, como a entrada é um canal, apenas aborta. Portanto, deve terminar em:| xargs sudo apt-get purge -y
Josh
37
Removendo cerca de 20 versões antigas linux-imagee linux-headersliberadas de 4,5 GB de espaço na minha máquina.
Andrew Mao
16
Este método funciona bem, mas a exclusão de cada kernel regenera excessivamente o grub.cfg, o que leva tempo. Existe alguma maneira de desabilitar isso para exclusão em lote e depois regenerá-lo uma vez?
Spacediver
15
A segunda é a pergunta do @spacediver - esse é um processo muito lento quando você tem 38 núcleos desnecessários, pois quando cada um é desinstalado, ele percorre todos os demais enquanto gera um novo grub.cfg. Isso é o que chamamos de operação N ^ 2 - ele processa um kernel cerca de (38 ^ 2/2) = 722 vezes e é muito lento. Certamente Ubuntu pode chegar a algo melhor ....
nealmcb
384

Primeiro, reinicie o sistema para ter certeza de que está usando o kernel mais recente. Em seguida, abra o terminal e verifique seu kernel atual:

uname -r 

NÃO REMOVA ESTE KERNEL!

Em seguida, digite o comando abaixo para visualizar / listar todos os kernels instalados no seu sistema.

dpkg --list 'linux-image-*'

Encontre todos os kernels inferiores ao seu kernel atual. Quando você souber qual kernel remover, continue abaixo para removê-lo. Execute os comandos abaixo para remover o kernel selecionado.

sudo apt-get purge linux-image-x.x.x-x-generic 

Por fim, execute os comandos abaixo para atualizar o grub2

sudo update-grub2 

Reinicie seu sistema.

retornos
fonte
34
Ao fazer isso nas versões 10.04 e 12.04, descobri que o update-grub era executado automaticamente durante o processo de limpeza.
Aidan
93
a expansão do suporte do bash pode ser usada, por exemplo sudo apt-get purge linux-image-3.2.0-3{0..5}-generic(remove 30,31, .., 35)
ajo
12
Não há necessidade de reiniciar o sistema posteriormente. Na verdade, você deve reiniciar o sistema antes de executar essas etapas, para garantir que você esteja usando a versão mais recente do kernel que provavelmente acabou de baixar e instalar (você fez uma atualização do apt-get && apt-get upgrade antes disso, certo ??)
Ricket
4
Você também pode querer desinstalar os linux-signed-imagepacotes que podem ser instalados em sistemas UEFI: sudo apt-get purge linux-signed-image-3.11.0-{12,14,24}-generico que eliminaria 12, 14 e 24
Devius
1
@jarno Não sei se estou usando um kernel assinado ou não, mas uname -rnão tenho nenhuma signedstring no meu sistema. Eu parecem ter uma imagem assinado instalado e a saída desse lscomando é: /boot/vmlinuz-3.19.0-16-generic.efi.signed.
Devius
283

Meu one-liner para remover kernels antigos (isso também libera espaço em disco)

dpkg --list | grep linux-image | awk '{ print $2 }' | sort -V | sed -n '/'`uname -r`'/q;p' | xargs sudo apt-get -y purge

Explicação (lembre-se, |usa a saída do comando anterior como entrada para a próxima)

  • dpkg --list lista todos os pacotes instalados
  • grep linux-image procura as imagens linux instaladas
  • awk '{ print $2 }' apenas gera a segunda coluna (que é o nome do pacote)
  • sort -V coloca os itens em ordem pelo número da versão
  • sed -n '/'`uname -r`'/q;p' imprime as linhas antes do kernel atual
  • xargs sudo apt-get -y purge limpa os núcleos encontrados

Desenrolando a sedchamada:

  • -ndiz sedpara ficar quieto
  • `uname -r` gera a versão atual do kernel instalado - nós a incluímos nos backticks para que a saída seja incluída como parte do comando (você também pode ver isso como $(uname -r)
  • /something/qdiz parar quando você corresponde a 'alguma coisa' (neste caso, algo é produzido uname -r) - /rodeia uma expressão regular
  • p é impressão
  • o ;é o comando separtor, então /something/q;pdiz quit quando você corresponde a algo, senão imprime

ao todo, sed -n '/'`uname -r`'/q;p'imprime as linhas até corresponder ao nome atual do kernel.

Se você é paranóico (como eu), pode fazer a última parte xargs echo sudo apt-get -y purgepara que o comando para limpar os kernels antigos seja impresso e verificar se nada de inesperado está incluído antes de executá-lo.


Versão modificada para remover cabeçalhos:

dpkg --list | grep 'linux-image' | awk '{ print $2 }' | sort -V | sed -n '/'"$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)/\1/")"'/q;p' | xargs sudo apt-get -y purge
dpkg --list | grep 'linux-headers' | awk '{ print $2 }' | sort -V | sed -n '/'"$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)/\1/")"'/q;p' | xargs sudo apt-get -y purge

Nota: a sedchamada é modificada. "$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)/\1/")"extrai apenas a versão (por exemplo, "3.2.0-44"), sem "-generic" ou similar deuname -r


Versão completa para remover imagens e cabeçalhos (combina as duas versões acima):

echo $(dpkg --list | grep linux-image | awk '{ print $2 }' | sort -V | sed -n '/'`uname -r`'/q;p') $(dpkg --list | grep linux-headers | awk '{ print $2 }' | sort -V | sed -n '/'"$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)/\1/")"'/q;p') | xargs sudo apt-get -y purge
David Kemp
fonte
1
Observe que é um pouco perigoso corresponder à versão atual do kernel como expressão regular assim: Pontos pontuam com qualquer caractere e 3.1.2-23 corresponde a 3.1.2-2 (ou é o contrário). Veja também minha resposta .
Jarno
19
Aqui está uma versão multifuncional ajustada: sudo apt-get purge $(for tag in "linux-image" "linux-headers"; do dpkg-query -W -f'${Package}\n' "$tag-[0-9]*.[0-9]*.[0-9]*" | sort -V | awk 'index($0,c){exit} //' c=$(uname -r | cut -d- -f1,2); done)Veja também minha resposta .
Jarno
1
@jarno que me ajudou a um grande estender ... Kudos para o seu um forro
Clain Dsilva
5
Devido a dependências não atendidas, eu precisava usá-lo dkpg -P. Aqui está a versão completa:dpkg --list | grep 'linux-headers' | awk '{ print $2 }' | sort -V | sed -n '/'"$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)/\1/")"'/q;p' | xargs sudo dpkg -P
Sebastian Sastre 22/06
3
NÃO FAÇA ISTO! "Esse oneliner parece um pouco perigoso, mas certamente 220 promotores não podem estar errados!" Pensei comigo mesma e cegamente colei. Reinicializado diretamente para o GRUB. Esse comando limpou todos os meus kernels, incluindo o que eu estava usando. Talvez eu estivesse executando um kernel em tempo real, nem me lembro. Atualmente procurando em minha casa um pendrive para instalar o Ubuntu Live CD em :(
Andreas Jansson
60

Ubuntu 16.04+:

$ sudo apt autoremove
...
The following packages will be REMOVED:
  linux-headers-4.4.0-57 linux-headers-4.4.0-57-generic linux-image-4.4.0-57-generic linux-image-extra-4.4.0-57-generic linux-tools-4.4.0-57 linux-tools-4.4.0-57-generic

Ubuntu 15.10 e abaixo:

Acho que essa é a maneira mais fácil e rápida. Ele mantém o kernel mais recente e mais dois:

sudo apt-get install bikeshed
sudo purge-old-kernels

Para alterar o número de kernels adicionais que são mantidos:

sudo purge-old-kernels --keep 3
bmaupin
fonte
1
Esse comando é um script de shell, local pelo qual você pode encontrar which purge-old-kernels.
Jarno
Ainda bem que eles tornaram isso muito mais fácil no 16.04! Espero que esta resposta continua a fazer o seu caminho até ...
Toby J
No Ubuntu 16.04 eu tenho purge-old-kernelssem o pacote bikeshed ( ferramentas úteis aleatórias que ainda não possuem um lar permanente ) ou qualquer outro. Evite usar a apt-get -yopção, é como fechar os olhos e esperar que tudo fique bem. Também aqui está como o autoremove decide quantos kernels antigos manter.
Pablo A
2
No 16.04, o purge-old-kernels é fornecido pelo pacote byobu (dica:) apt-file search purge-old-kernels. Concordado apt-get -y, eu vou removê-lo.
bmaupin
1
@ Dan desde que eu não uso versões não LTS, eu não tinha certeza exatamente quando ele começou. Mas posso dizer com certeza que sudo apt-get autoremovenão remove os kernels na versão 14.04. Sinta-se livre para atualizar a resposta com a versão específica, se você souber o que é!
precisa saber é o seguinte
43

Removendo entradas do Grub 2 As entradas devem ser removidas editando ou removendo arquivos na pasta /etc/grub.d. O arquivo /boot/grub/grub.cfg é somente leitura e normalmente não deve exigir edição.

Núcleos demais?

  • Se você não tem certeza do kernel que está usando no momento, em um terminal, digite uname -r .

  • Os kernels removidos pelo APT (Synaptic, "apt-get remove" etc.) atualizarão automaticamente o grub.cfg e nenhuma ação do usuário será necessária.

  • Uma ótima ferramenta para remover kernels (e entradas de menu) é o Ubuntu-Tweak, um aplicativo GUI seguro e fácil de usar.

  • Instalar o ubuntu tweak

  • O Ubuntu-Tweak estará disponível em Aplicativos> Ferramentas do sistema.

Remover entradas mais antigas do kernel

  • Selecione "Limpador de Pacotes" à esquerda e "Limpar Kernel" no painel direito.

  • Pressione o botão "Desbloquear" no canto inferior direito, digite sua senha.

  • Selecione na lista exibida as imagens e cabeçalhos do kernel que você deseja remover. O kernel em uso não está listado.

  • Pressione o botão "Limpeza" no canto inferior direito para remover as imagens e cabeçalhos do kernel selecionados.

Remova os sistemas operacionais no menu Grub

  • Outros sistemas operacionais que foram removidos do computador também serão removidos do menu quando o "update-grub" for executado como root.

  • Os itens de menu são colocados no menu Grub2 por scripts. Se você não deseja que outros sistemas operacionais sejam inseridos no menu, desative /etc/grub.d/30_osprober

  • Execute este comando para parar a execução do script
    sudo chmod -x /etc/grub.d/30_os-prober

  • DISABLE_30_OS-PROBER = 'true' em / etc / default / grub

Remova o Memtest86 + no menu Grub
sudo chmod -x /etc/grub.d/20_memtest86+

  • Execute o comando update-grub para permitir que as alterações sejam incorporadas no grub.cfg

Fonte

Nota: Após a atualização do kernel, uma nova entrada é adicionada ao menu do GRUB. Você pode remover a mais antiga, se desejar. No entanto, os usuários mais experientes aconselham você a manter pelo menos uma entrada de reposição, caso algo dê errado com uma atualização e você precisa inicializar uma versão mais antiga do kernel para fins de solução de problemas.

Maneira alternativa de remover entradas do Kernel (anteriores à 10.04)

para GRUB não GRUB2

gerente de startup Instale o gerenciador de inicialização

Você pode encontrá-lo em Sistema >> Administração >> texto alternativo
texto alternativo
Você vê na segunda captura de tela que pode selecionar quantos kernels mostrar? Geralmente, mantenho o item 1, mas quando recebo uma atualização do kernel, sempre o altero para 2 antes de reiniciar, para que eu possa selecionar o kernel mais antigo se o novo kernel tiver problemas com o meu hardware. Uma vez que eu sei que o novo kernel está funcionando bem, mudo de volta para 1.

karthick87
fonte
2
Na verdade, o startupmanager dint me deu uma janela como esta no Ubuntu 10.04, em vez disso, apenas deu uma janela com duas guias -> Opções de inicialização e Avançado .. e no avançado ele não tem a opção de limitar o número de kernels. Então, por favor atualizar a resposta para Ubuntu 10.04 (E é por isso que eu down-votado esta ..).
Sen
alguma idéia de como "número de kernels a serem mantidos" pode ser definido em uma máquina que não possui GUI instalada (servidor)?
sylvainulg
startupmanager está desatualizado. Veja grup-customizer
muhasturk
39

Puramente na linha de comando, isso removerá todos, exceto o atual e o segundo mais atual (através do "-2" no comando principal abaixo):

OLD=$(ls -tr /boot/vmlinuz-* | head -n -2 | cut -d- -f2- |
    awk '{print "linux-image-" $0 " linux-headers-" $0}' )
if [ -n "$OLD" ]; then
    apt-get -qy remove --purge $OLD
fi
apt-get -qy autoremove --purge
Kees Cook
fonte
9
one-liner a partir daí :dpkg -l linux-* | awk '/^ii/{ print $2}' | grep -v -e `uname -r | cut -f1,2 -d"-"` | grep -e [0-9] | xargs sudo apt-get -y purge
Dmitry Verkhoturov 5/08
@DmitryPaskal, você deve adicionar isso como uma nova resposta.
saji89
10
@DmitryPaskal Como sempre, não basta copiar e colar esses itens sem entendê-los. Na minha máquina, este verso também corresponde ao linux-libc-dev:amd64que não deve ser removido.
jamesadney
1
@ Kees Cook, o argumento do awk não deveria ser cercado apenas por aspas simples? Se sua intenção é anexar "linux-image-" às linhas canalizadas, isso só funcionará se você usar awk '{print "linux-image-" $0}'.
Mark
isso não funciona para mim, que inclui meu costume kernel instalado (Ubuntu 14.04 com 3,17)
Alex R
35

Atualização: purge-old-kernelsestá obsoleta hoje em dia.

Eu criei um script para limpar os kernels, mesmo em condições difíceis. É chamado linux-purgee você pode encontrá-lo aqui .

Se você quiser apenas limpar os kernels (e os pacotes relacionados) mais antigos que o kernel atualmente usado, quando o sistema não estiver quebrado, você poderá usar este script .

Há também uma página de documentação do Ubuntu que contribuí para a remoção de kernels antigos aqui .

jarno
fonte
Parece que purge-old-kernelsnão está na versão precisa (1.22) do bikeshed. Existe uma maneira razoável / segura de obter uma bikeshed mais recente para obter uma precisão? Ou seria mais simples / seguro instalar apenas o script? Eu prefiro usar um repo no entanto, apesar da longa lista de dependências ..
drevicko
1
@drevicko Veja aqui .
Jarno
1
@drevicko, sure,dlocate -lsbin bikeshed
jarno
1
@drevicko, veja também outra pergunta
jarno
1
@ Chrishr sim existe. Acabei de fazer uma pequena melhoria no script, por isso é melhor usar a versão mais recente.
jarno 5/09
29

Você pode seguir o Usando o pacote "atualizações autônomas" do artigo Atualizações automáticas de segurança no Ubuntu Wiki para fazer isso.

Você precisa alterar a seguinte linha em arquivo /etc/apt/apt.conf.d/50unattended-upgrades ;

//Unattended-Upgrade::Remove-Unused-Dependencies "false";

com

Unattended-Upgrade::Remove-Unused-Dependencies "true";

remover automaticamente pacotes antigos, incluindo kernels.

Também remova ou comente a linha

"^linux-image.*"; 

na seção "NeverAutoRemove" do arquivo /etc/apt/apt.conf.d/01autoremove.

Qwerty
fonte
2
Eu fiz isso, mas ele ainda estava coletando mais de 3 kernels antigos, consumindo centenas de MBs. Então, eu adicionei apt-get autoremoveao meu trabalho diário do cron que realmente faz as atualizações, pois ele nem sempre passa pelo gerenciador de atualizações interno.
Marcos
Eu acho que isso funciona no Trusty apenas para os kernels que foram instalados automaticamente.
10136 jarno
Isso é ótimo para evitar o acúmulo de kernels antigos ao atualizar automaticamente pacotes, por exemplo, com atualizações autônomas. No entanto, se você não reiniciar, poderá achar que o pacote do kernel atualmente em execução foi desinstalado! Um problema que isso pode causar: os novos dispositivos que você conecta podem não funcionar, porque o módulo para eles não pode ser carregado a quente, porque não está mais no seu disco. (A solução rápida para isso é só para instalar o pacote do kernel novamente, e em seguida, desligue e volte a ligar o dispositivo.)
joeytwiddle
Criei uma solução automatizada para o problema mencionado acima. Se você acha que essa é uma boa abordagem, sinta-se à vontade para adicioná-la à resposta do Qwerty.
Joeytwiddle
27

A maneira mais rápida / simples (aplicável pelo menos desde 12.04) possível que já vem com o Ubuntu é apt-get . Faça o seguinte se desejar remover todas as versões mais antigas do kernel que não estão em uso (exceto a anterior que você não está usando. Isso é para garantir que, se a versão atual do kernel falhar de alguma maneira, você tenha um caminho a percorrer. de volta a um estado anterior). Faça o seguinte:

sudo apt-get autoclean

Isso eliminará quaisquer arquivos antigos (incluindo versões do kernel) que você possa ter. Observe que, se você tiver muitas versões antigas, levará um tempo, pois é necessário garantir que a remoção da versão do kernel não tenha problemas. Para mim, a remoção das últimas 12 versões do kernel levou cerca de 2 minutos. Você também pode fazer o seguinte:

sudo apt-get clean

O que eliminará tudo o que é baixado e armazenado na pasta de cache do apt. Por fim, você tem:

sudo apt-get autoremove

que verifica se há pacotes não utilizados e os remove, se necessário. Isso é ótimo para as bibliotecas e pacotes de dependência que não são mais necessários por qualquer aplicativo instalado.

Luis Alvarado
fonte
1
Suponho que isso tenha mudado em versões mais recentes, pois na 14.04 isso apenas limpa o cache do pacote e não afeta os pacotes instalados ou o grub.
Jarno
2
Posso confirmar que sudo apt-get autoremoveremove os kernels antigos (mais de uma versão atrás) na versão 14.04. Talvez você precise executá-lo antes e depois de atualizar seu kernel. Quando executei antes da atualização, ele apenas removeu a versão genérica do kernel antigo. Depois de atualizar meu kernel, ele também removeu a versão de baixa latência do kernel antigo.
TekNorah #
Eu quis dizer o sudo apt-get autocleancomando. @tekNorah Instalei alguns kernels mais antigos e depois executei sudo apt-get autoremoveno Ubuntu Studio 14.04. Não removeu nenhum núcleo. Eu tenho apenas kernels de baixa latência instalados. Por que você tem os kernels -generic e -lowlatency instalados?
Jarno
5
Sim, isso funcionou muito bem para mim, limpou todos os kernels antigos corretamente e não depende de scripts de uma linha malucos! Recomendado, gostaria de poder votar isso mais de uma vez!
9138 Jeff Atwood
1
@ JeffAtwood bem, ele pode remover mais kernels que são seguros. Veja o relatório de erro
jarno
25

10.04 Método GUI

O Janitor de Computador pode limpar os kernels antigos e acredito que esteja instalado por padrão no Ubuntu (mas não no Kubuntu).

O GRUB 1, se você estiver usando isso, tem uma opção /boot/grub/menu.lstpara especificar quantos kernels deve mostrar no máximo. GRUB 2, tanto quanto eu posso dizer, não.

maco
fonte
4
O Janitor de Computador não deve ser usado - é um bug e agora foi descartado como um aplicativo padrão em natty / oneiric / preciso.
fossfreedom
2
Em vez disso, instale o "Ubuntu Tweak", conforme descrito em outra resposta (seu próprio ppa), que possui seu próprio "zelador de computador" (não deve ser confundido com o "zelador de computador" que estava temporariamente disponível nas versões mais antigas do ubuntu)
michael
25

Para descobrir quais kernels e cabeçalhos estão instalados, use

dpkg -l | grep linux-image

dpkg -l | grep linux-headers

Em seguida, você pode removê-los um por um ou juntos, mas mantenha o mais recente.

Existem também alguns comandos e scripts úteis para automatizar a remoção.

http://ubuntuforums.org/showthread.php?t=1658648

As seguintes reivindicações para remover todos os kernels e cabeçalhos não utilizados:

dpkg -l 'linux-*' | sed '/^ii/!d;/'"$(uname -r | sed "s/\(.*\)-\([^0-9]\+\)/\1/")"'/d;s/^[^ ]* [^ ]* \([^ ]*\).*/\1/;/[0-9]/!d'|grep -E "(image|headers|modules)" | grep -v hwe | xargs sudo apt-get purge

(use apt-get -ypara remover sem questionar)

Aqui está o que acontece quando executado em 18.04.1:

~$ dpkg -l 'linux-*' | sed '/^ii/!d;/'"$(uname -r | sed "s/\(.*\)-\([^0-9]

\+\)/\1/")"'/d;s/^[^ ]* [^ ]* \([^ ]*\).*/\1/;/[0-9]/!d'|grep -E "(image|headers|modules)" | xargs sudo apt-get -y purge
Reading package lists... Done
Building dependency tree       
Reading state information... Done
The following packages will be REMOVED:
  linux-headers-4.15.0-33* linux-headers-4.15.0-33-generic* linux-headers-4.15.0-34* linux-headers-4.15.0-34-generic* linux-image-4.15.0-33-generic* linux-image-4.15.0-34-generic*
  linux-modules-4.15.0-33-generic* linux-modules-4.15.0-34-generic* linux-modules-extra-4.15.0-33-generic* linux-modules-extra-4.15.0-34-generic*
0 upgraded, 0 newly installed, 10 to remove and 1 not upgraded.
After this operation, 671 MB disk space will be freed.
(Reading database ... 227403 files and directories currently installed.)
Removing linux-headers-4.15.0-33-generic (4.15.0-33.36) ...
Removing linux-headers-4.15.0-33 (4.15.0-33.36) ...
Removing linux-headers-4.15.0-34-generic (4.15.0-34.37) ...
Removing linux-headers-4.15.0-34 (4.15.0-34.37) ...
Removing linux-modules-extra-4.15.0-33-generic (4.15.0-33.36) ...
Removing linux-image-4.15.0-33-generic (4.15.0-33.36) ...
/etc/kernel/postrm.d/initramfs-tools:
update-initramfs: Deleting /boot/initrd.img-4.15.0-33-generic
/etc/kernel/postrm.d/zz-update-grub:
Generating grub configuration file ...
Found linux image: /boot/vmlinuz-4.15.0-36-generic
Found initrd image: /boot/initrd.img-4.15.0-36-generic
Found linux image: /boot/vmlinuz-4.15.0-34-generic
Found initrd image: /boot/initrd.img-4.15.0-34-generic
Adding boot menu entry for EFI firmware configuration
done
Removing linux-modules-extra-4.15.0-34-generic (4.15.0-34.37) ...
Removing linux-image-4.15.0-34-generic (4.15.0-34.37) ...
I: /vmlinuz.old is now a symlink to boot/vmlinuz-4.15.0-36-generic
I: /initrd.img.old is now a symlink to boot/initrd.img-4.15.0-36-generic
/etc/kernel/postrm.d/initramfs-tools:
update-initramfs: Deleting /boot/initrd.img-4.15.0-34-generic
/etc/kernel/postrm.d/zz-update-grub:
Generating grub configuration file ...
Found linux image: /boot/vmlinuz-4.15.0-36-generic
Found initrd image: /boot/initrd.img-4.15.0-36-generic
Adding boot menu entry for EFI firmware configuration
done
Removing linux-modules-4.15.0-33-generic (4.15.0-33.36) ...
Removing linux-modules-4.15.0-34-generic (4.15.0-34.37) ...
(Reading database ... 156180 files and directories currently installed.)
Purging configuration files for linux-image-4.15.0-34-generic (4.15.0-34.37) ...
Purging configuration files for linux-modules-4.15.0-33-generic (4.15.0-33.36) ...
dpkg: warning: while removing linux-modules-4.15.0-33-generic, directory '/lib/modules/4.15.0-33-generic' not empty so not removed
Purging configuration files for linux-modules-4.15.0-34-generic (4.15.0-34.37) ...
Purging configuration files for linux-image-4.15.0-33-generic (4.15.0-33.36) ...
Purging configuration files for linux-modules-extra-4.15.0-34-generic (4.15.0-34.37) ...
Purging configuration files for linux-modules-extra-4.15.0-33-generic (4.15.0-33.36) ...
~$ uname -r
4.15.0-36-generic
iguais
fonte
O script que você encontrou no fórum está com defeito. Pode não remover algum pacote de cabeçalho desejado (se você usar algum kernel antigo-pae) e, por outro lado, pode remover alguns pacotes que deseja manter.
Jarno
Obrigado pelo comentário. O script pode não ser perfeito, no entanto, eu o uso há anos, principalmente nas versões 12.04 e 14.04, 32 e 64 bits, e não tive nenhum problema. ... e sim, linux-libc-devestá instalado.
Mikewhatever
Suponho que o número da versão linux-libc-devcorresponda ao número da versão do currenternel atual então. Aqui dpkg -l linux-libc-dev | sed '/^ii/!d;s/^[^ ]* [^ ]* \([^ ]*\).*/\1/;/[0-9]/!d'imprime linux-libc-dev: amd64
jarno
Ainda não consigo reproduzir suas descobertas, no entanto, por segurança, modifiquei o comando adicionando um filtro adicional - grep -E "(image|headers)".
Mikewhatever
1
Primeiro tente sem a -ybandeira com purga, por favor ..!
usar o seguinte comando
16

Para remover os kernels de imagens mais antigos do Linux, primeiro inicie o kernel que deseja manter.

Você também pode verificar a versão do kernel usando o comando uname -rpara não remover a errada por engano.

Agora vá ao gerenciador de pacotes sinápticos e procure linux-imagee remova as versões mais antigas, exceto a mostrada pelo comando superior. Geralmente eu prefiro ir com o mais recente.

Agora, quando você reiniciar, verá um menu grub mais limpo.

anurag-jain
fonte
Este é provavelmente o método mais básico usado para usuários que instalaram sem o Computer Janitor.
Broam 17/09/10
1
No Ubuntu 11.04, o menu grub mostra apenas o kernel atual por padrão, os kernels mais antigos estão ocultos no menu 'Kernels anteriores'. Este método ainda funcionará para limpar os mais antigos.
Andy
14

Você pode instalar o ubuntu-tweak e, em seguida, vá em Aplicativos -> ferramenta Sistema -> ubuntu tweak e

insira a descrição da imagem aquiclique em limpador de pacotes e núcleos limpos. ele não mostra o kernel atualmente usado, portanto você estará sempre seguro.

Lincity
fonte
8

Pessoalmente, eu gosto de usar Synaptic. Isso me faz sentir mais seguro sobre o que está acontecendo. O único aplicativo que usei que tem a opção de remover kernels antigos é o Ubuntu Tweak .

Como remover os kernels que você não está usando:

  • Abra o UbuntuTweak
  • Clique em 'Limpador de Pacotes' em 'Aplicativos' no painel esquerdo
  • No lado direito da 'vista de limpeza', pressione 'Limpar grãos'
  • Selecione todos os kernels - acho que o usado não está listado, mas apenas no caso de verificação uname -aem execução em um terminal
Alan Featherston
fonte
No Synaptic, você pode filtrar 'Componentes' -> 'Kernel e módulos', que incluem todos os kernels. E classifique pela primeira coluna: 'S' (Status), para obter todos os kernels instalados no topo. De fato update-grubé aconselhável.
usar o seguinte comando
6

Você pode desinstalar os kernels antigos ( linux-image-...pacotes) usando o Synaptic, e isso os removerá do menu de inicialização. Tome cuidado para não remover o kernel em execução (você pode verificar sua versão uname -r).

Lembre-se de que ter uma ou duas versões mais antigas pode ajudá-lo a solucionar problemas, caso algo dê errado.

Como alternativa, você pode editar / remover as entradas manualmente ( gksu gedit /boot/grub/grub.cfg), mas elas serão geradas novamente quando você atualizar para um kernel mais recente. Se você está pensando em remover recovery modeopções - não. Eles podem ser úteis se você quebrar algo que o impede de inicializar.


Consulte esta página.

evgeny
fonte
O Grub2 agora cria sua entrada no grub toda vez que um novo kernel é instalado. com o update-grubqual irá reescrever todos esses kernels.
Marco Ceppi
4

Esta é uma solução pura de linha de comando.

Primeiro gere uma lista de todas as versões instaladas do kernel, exceto o kernel atualmente em execução:

dpkg-query -W -f='${Package}\n' |
  grep -f <(ls -1 /boot/vmlinuz* | cut -d- -f2,3 |
    grep -v $(uname -r | cut -d- -f1,2))

Como alternativa, gere uma lista de todas as versões instaladas do kernel, exceto as duas últimas:

dpkg-query -W -f='${Package}\n' |
  grep -f <(ls -1 /boot/vmlinuz* | cut -d- -f2,3 |
    sort -V | head -n -2)

Examine a lista. Verifique se as versões do kernel que você deseja manter não fazem parte da lista. Use o comando uname -rpara ver a versão do kernel atualmente em execução.

Se você estiver satisfeito com os resultados, poderá usar apt-getpara remover os pacotes.

Primeiro, um funcionamento a seco (usando o primeiro gerador como exemplo):

sudo apt-get --dry-run purge $(
  dpkg-query -W -f='${Package}\n' |
    grep -f <(ls -1 /boot/vmlinuz* | cut -d- -f2,3 |
      grep -v $(uname -r | cut -d- -f1,2)))

Então uma corrida real:

sudo apt-get purge $(
  dpkg-query -W -f='${Package}\n' |
    grep -f <(ls -1 /boot/vmlinuz* | cut -d- -f2,3 |
      grep -v $(uname -r | cut -d- -f1,2)))

Se você deseja automatizar o processo, adicione o --yesparâmetro:

sudo apt-get --yes purge $(
  ...)
lesmana
fonte
@jarno Agradeço seu esforço para combinar e otimizar minha linha de comando. Eu removi sua linha de comando porque prefiro legibilidade e simplicidade. Eu deliberadamente adaptei meu comando para facilitar a leitura e a simplicidade. Pelo menos legível e simples para o meu cérebro. Poste sua linha de comando como um comentário ou em sua própria resposta.
lesmana
1
Isso combina dois objetivos: manter os dois últimos kernels e manter os kernels mais recentes que o atual sudo apt-get purge -- $(ls -1U /boot/vmlinuz* | cut -d- -f2,3 | sort -uV | head -n -2 | awk -v c=$(uname -r | cut -d- -f1,2) '($0==c){exit} //' | sed -r -e 's/\./\\./g' -e 's/.*/-&($|-)/'). Não há necessidade, dpkg-querypois apt-getpode lidar com expressões regulares. Observe como eu escapei de pontos e adicione prefixo e sufixo na expressão regular. Usando o script em minha própria resposta, você também pode manter alguns kernels mais antigos que o atual.
Jarno
4

A vantagem desta resposta é que o Ubuntu Bash nativo é usado sem a instalação de aplicativos de terceiros. Usuários de kernels personalizados que não usaram aptou dpkgpodem alterar esse script bash para atender às suas necessidades. Esta resposta é baseada em ( Como limpar seletivamente os kernels antigos de uma só vez ).

Solução baseada em Zenity

O Zenity fornece uma interface gráfica agradável ao terminal para processar uma lista e selecionar itens com botões de opção :

rm-kernels 1

Como o título indica, o kernel atual com o qual você inicializou não pode ser removido e não está incluído na lista. O tamanho relatado é quanto será salvo no /bootdiretório. Mais é salvo no seu disco porque os binários do kernel também residem em outras áreas. 27 de julho de 2017 nota: Os diretórios /usr/src/*kernel_version*e /lib/modules/*kernel_version*agora também estão incluídos.

A data de modificação é descoberta usando o statcomando No meu sistema, essa data é "tocada" toda vez que o kernel é inicializado usando este ( como descobrir quando uma versão específica do kernel foi inicializada pela última vez? ) Cron reboot script. No entanto, no seu sistema, a data será a data de lançamento do kernel, não a última vez que você o inicializou.

apt-get purge dá a você a chance de abortar

Você terá a oportunidade final de visualizar tudo o que será eliminado e ver o espaço total em disco (um tanto enganoso) que será recuperado:

The following packages will be REMOVED:
  linux-headers-4.7.1-040701* linux-headers-4.7.1-040701-generic*
  linux-headers-4.7.2-040702* linux-headers-4.7.2-040702-generic*
  linux-headers-4.7.3-040703* linux-headers-4.7.3-040703-generic*
  linux-headers-4.8.1-040801* linux-headers-4.8.1-040801-generic*
  linux-headers-4.8.10-040810* linux-headers-4.8.10-040810-generic*
  linux-headers-4.8.11-040811* linux-headers-4.8.11-040811-generic*
  linux-headers-4.8.4-040804* linux-headers-4.8.4-040804-generic*
  linux-headers-4.8.5-040805* linux-headers-4.8.5-040805-generic*
  linux-image-4.7.1-040701-generic* linux-image-4.7.2-040702-generic*
  linux-image-4.7.3-040703-generic* linux-image-4.8.1-040801-generic*
  linux-image-4.8.10-040810-generic* linux-image-4.8.11-040811-generic*
  linux-image-4.8.4-040804-generic* linux-image-4.8.5-040805-generic*
0 upgraded, 0 newly installed, 24 to remove and 2 not upgraded.
After this operation, 2,330 MB disk space will be freed.
Do you want to continue? [Y/n] 

O código

Copiar este código a um arquivo executável chamado rm-kernelsem /usr/local/bin:

#!/bin/bash

# NAME: rm-kernels
# PATH: /usr/local/bin
# DESC: Provide zenity item list of kernels to remove

# DATE: Mar 10, 2017. Modified Jul 28, 2017.

# NOTE: Will not delete current kernel.

#       With 10 kernels on an SSD, empty cache from sudo prompt (#) using:
#       # free && sync && echo 3 > /proc/sys/vm/drop_caches && free
#       First time for `du` 34 seconds.
#       Second time for `du` 1 second.

# PARM: If any parm 1 passed use REAL kernel size, else use estimated size.
#       By default `du` is not used and estimated size is displayed.

# Must be running as sudo
if [[ $(id -u) != 0 ]]; then
    zenity --error --text "root access required. Use: sudo rm-kernels"
    exit 99
fi

OLDIFS="$IFS"
IFS="|"
choices=()

current_version=$(uname -r)

for f in /boot/vmlinuz*
do
    if [[ $f == *"$current_version"* ]]; then continue; fi # skip current version
    [[ $f =~ vmlinuz-(.*) ]]
    v=${BASH_REMATCH[1]}        # example: 4.9.21-040921-generic
    v_main="${v%-*}"            # example: 4.9.21-040921

    # Kernel size in /boot/*4.9.21-040921-generic*
    s=$(du -ch /boot/*-$v* | awk '/total/{print $1}')

    if [[ $# -ne 0 ]] ; then    # Was a parameter passed?
        if [[ -d "/usr/src/linux-headers-"$v_main ]] ; then
             # Kernel headers size in /usr/src/*4.9.21-040921*
             s2=$(du -ch --max-depth=1 /usr/src/*-$v_main* | awk '/total/{print $1}')
        else
             s2="0M"            # Linux Headers are not installed
        fi
        # Kernel image size in /lib/modules/4.9.21-040921-generic*
        s3=$(du -ch --max-depth=1 /lib/modules/$v* | awk '/total/{print $1}')
    else
        # Estimate sizof of optional headers at 125MB and size of image at 220MB
        if [[ -d "/usr/src/linux-headers-"$v_main ]] ; then
             s2="125M"
        else
             s2="0M"            # Linux Headers are not installed
        fi
        s3="220M"
    fi

    # Strip out "M" provided by human readable option of du and add 3 sizes together
    s=$(( ${s//[^0-9]*} + ${s2//[^0-9]*} + ${s3//[^0-9]*} ))
    t=$(( t + s ))
    s=$s" MB"
    d=$(date --date $(stat -c %y $f) '+%b %d %Y') # Last modified date for display
    choices=("${choices[@]}" false "$v" "$d" "$s")
done

# adjust width & height below for your screen 640x480 default for 1920x1080 HD screen
# also adjust font="14" below if blue text is too small or too large

choices=(`zenity \
        --title "rm-kernels - Total: $t MB excluding: $current_version" \
        --list \
        --separator="$IFS" \
        --checklist --multiple \
        --text '<span foreground="blue" font="14">Check box next to kernel(s) to remove</span>' \
        --width=640 \
        --height=480 \
        --column "Select" \
        --column "Kernel Version Number" \
        --column "Modified Date" \
        --column " Size " \
        "${choices[@]}"`)
IFS="$OLDIFS"

i=0
list=""
for choice in "${choices[@]}" ; do
    if [ "$i" -gt 0 ]; then list="$list- "; fi # append "-" from last loop
    ((i++))

    short_choice=$(echo $choice | cut -f1-2 -d"-")
    header_count=$(find /usr/src/linux-headers-$short_choice* -maxdepth 0 -type d | wc -l)

    # If -lowlatency and -generic are purged at same time the _all header directory
    # remains on disk for specific version with no -generic or -lowlatency below.
    if [[ $header_count -lt 3 ]]; then
        # Remove all w.x.y-zzz headers
        list="$list""linux-image-$choice- linux-headers-$short_choice"
    else
        # Remove w.x.y-zzz-flavour header only, ie -generic or -lowlatency
        list="$list""linux-image-$choice- linux-headers-$choice" 
    fi

done

if [ "$i" -gt 0 ] ; then
     apt-get purge $list
fi

NOTA: Você precisa de permissão sudo para criar o arquivo, então use:

gksu gedit /usr/local/bin/rm-kernels

Para tornar o arquivo executável, use:

sudo chmod +x /usr/local/bin/rm-kernels

Versão do servidor

rm-kernels-serveré a versão do servidor para excluir seletivamente os kernels de uma só vez. Em vez de uma caixa de diálogo gráfica (GUI), uma caixa de diálogo baseada em texto é usada para selecionar os kernels a serem limpos.

  • Antes de executar o script, você precisa instalar a função de diálogo usando:

    sudo apt install dialog

O diálogo está na instalação padrão do Ubuntu Desktop, mas não no Ubuntu Server.

Tela de amostra

rm-kernels-server 1

rm-kernels-server código bash

#!/bin/bash

# NAME: rm-kernels-server
# PATH: /usr/local/bin
# DESC: Provide dialog checklist of kernels to remove
#       Non-GUI, text based interface for server distro's.

# DATE: Mar 10, 2017. Modified Jul 28, 2017.

# NOTE: Will not delete current kernel.

#       With 10 kernels on an SSD, empty cache from sudo prompt (#) using:
#       # free && sync && echo 3 > /proc/sys/vm/drop_caches && free
#       First time for `du` 34 seconds.
#       Second time for `du` 1 second.

# PARM: If any parm 1 passed use REAL kernel size, else use estimated size.
#       By default `du` is not used and estimated size is displayed.

# Must be running as sudo
if [[ $(id -u) != 0 ]]; then
    echo "root access required. Use: sudo rm-kernels-server"
    exit 99
fi

# Must have the dialog package. On Servers, not installed by default
command -v dialog >/dev/null 2>&1 || { echo >&2 "dialog package required but it is not installed.  Aborting."; exit 99; }

OLDIFS="$IFS"
IFS="|"
item_list=() # Deviate from rm-kernels here.

current_version=$(uname -r)
i=0
for f in /boot/vmlinuz*
do
    if [[ $f == *"$current_version"* ]]; then continue; fi # skip current version
    [[ $f =~ vmlinuz-(.*) ]]
    ((i++)) # Item List
    v=${BASH_REMATCH[1]}        # example: 4.9.21-040921-generic
    v_main="${v%-*}"            # example: 4.9.21-040921

    # Kernel size in /boot/*4.9.21-040921-generic*
    s=$(du -ch /boot/*-$v* | awk '/total/{print $1}')

    if [[ $# -ne 0 ]] ; then    # Was a parameter passed?
        if [[ -d "/usr/src/linux-headers-"$v_main ]] ; then
             # Kernel headers size in /usr/src/*4.9.21-040921*
             s2=$(du -ch --max-depth=1 /usr/src/*-$v_main* | awk '/total/{print $1}')
        else
             s2="0M"            # Linux Headers are not installed
        fi
        # Kernel image size in /lib/modules/4.9.21-040921-generic*
        s3=$(du -ch --max-depth=1 /lib/modules/$v* | awk '/total/{print $1}')
    else
        # Estimate sizof of optional headers at 125MB and size of image at 220MB
        if [[ -d "/usr/src/linux-headers-"$v_main ]] ; then
             s2="125M"
        else
             s2="0M"            # Linux Headers are not installed
        fi
        s3="220M"
    fi

    # Strip out "M" provided by human readable option of du and add 3 sizes together
    s=$(( ${s//[^0-9]*} + ${s2//[^0-9]*} + ${s3//[^0-9]*} ))
    t=$(( t + s ))
    s=$s" MB"
    d=$(date --date $(stat -c %y $f) '+%b %d %Y') # Last modified date for display
    item_list=("${item_list[@]}" "$i" "$v ! $d ! $s" off)
done

cmd=(dialog --backtitle "rm-kernels-server - Total: $t MB excluding: $current_version" \
    --title "Use space bar to toggle kernel(s) to remove" \
    --column-separator "!" \
    --separate-output \
    --ascii-lines \
    --checklist "         Kernel Version --------- Modified Date  Size" 20 60 15)

selections=$("${cmd[@]}" "${item_list[@]}" 2>&1 >/dev/tty)

IFS=$OLDIFS

if [ $? -ne 0 ] ; then
    echo cancel selected
    exit 1
fi

i=0
choices=()

for select in $selections ; do
    ((i++))
    j=$(( 1 + ($select - 1) * 3 ))
    choices[i]=$(echo ${item_list[j]} | cut -f1 -d"!")
done

i=0
list=""
for choice in "${choices[@]}" ; do
    if [ "$i" -gt 0 ]; then list="$list- "; fi # append "-" from last loop
    ((i++))

    short_choice=$(echo $choice | cut -f1-2 -d"-")
    header_count=$(find /usr/src/linux-headers-$short_choice* -maxdepth 0 -type d | wc -l)

    # If -lowlatency and -generic are purged at same time the _all header directory
    # remains on disk for specific version with no -generic or -lowlatency below.
    if [[ $header_count -lt 3 ]]; then
        # Remove all w.x.y-zzz headers
        list="$list""linux-image-$choice- linux-headers-$short_choice"
    else
        # Remove w.x.y-zzz-flavour header only, ie -generic or -lowlatency
        list="$list""linux-image-$choice- linux-headers-$choice" 
    fi

done

if [ "$i" -gt 0 ] ; then
    apt-get purge $list
fi

NOTA: Na chamada para dialoga diretiva --ascii-linesé passada para substituir o conjunto de caracteres estendidos de desenho de linha (que sshnão gosta) por "+ ----- +" para caixas de desenho. Se você não gostar dessa aparência, poderá usar a --no-linesdiretiva para nenhuma caixa.


28 de julho de 2017 Atualizações

O tamanho calculado de cada kernel foi obtido, dos /boot/*kernel_version*quais 5 arquivos totalizando ~ 50 MB. A fórmula foi alterada para incluir os arquivos em /usr/src/*kernel_version*e /lib/modules/*kernel_version*. O tamanho calculado para cada kernel é agora ~ 400 MB. O código acima para rm-kernelse rm-kernels-serverfoi atualizado. No entanto, as telas de amostra acima ainda não refletem essas alterações.

O padrão é estimar o tamanho dos arquivos dos cabeçalhos do linux em 125 MB e da imagem do linux em 220 MB, pois dupode ser extremamente lento, a menos que os arquivos estejam no cache. Para obter o tamanho real, use duqualquer parâmetro no script.

O total de todos os tamanhos de kernel (excluindo a versão atual em execução que não pode ser removida) agora é exibido na barra de título.

A caixa de diálogo usada para exibir a Data de Último Acesso de cada Kernel . Essa data pode ser sobrescrita em massa para todos os kernels durante operações de backup ou similares. A caixa de diálogo agora mostra a Data de modificação .

WinEunuuchs2Unix
fonte
2

Uma maneira fácil de se livrar de quase todos os pacotes obsoletos, que não estão mais em nenhuma lista de pacotes, junto com os kernels obsoletos, é fazer o seguinte:

dpkg --purge $(aptitude search ?obsolete)

No entanto, isso não fará com que os pacotes ainda sejam recomendados por outros pacotes, e o argumento -R / - without-recommends não resolve esse problema.

O dselect depois de alternar o modo de classificação com 'o' mostrará todos os pacotes obsoletos, incluindo os que o aptitude perde, mas algumas pessoas não gostam de usá-lo.

Chris Cheney
fonte
O comando fornecido não limpa kernels antigos nem afeta o menu grub na minha experiência.
Jarno
2

A resposta aceita usando sed para remover kernels antigos permanentemente tem algumas falhas, se alguém não reiniciar o computador após a atualização do kernel, o comando também removerá o kernel mais recente.

Aqui está uma solução alternativa que considerará todas as situações para remover apenas os kernels antigos mais antigos:

#!/bin/bash
kernels=( $(grep -Po "^linux-image-[^-]+-[^-]+-generic\b" < <(dpkg --get-selections)) )
cur_rel=$(grep -Po ".*(?=-[a-z]*$)" < <(uname -r))

for kernel in "${kernels[@]}"; do
    ker_rel=$(grep -Po "[0-9].*(?=-[a-z]*)" <<< "$kernel")
    dpkg --compare-versions "$ker_rel" gt "$cur_rel" && echo "Please Restart your computer first" && break
    dpkg --compare-versions "$ker_rel" lt "$cur_rel" && sudo apt-get remove "$kernel"
done

Se você possui uma versão mais recente que a atual, isso fornecerá um aviso para reiniciar o computador primeiro. Observe também que os kernels mais antigos são preservados devido a uma boa razão: se você, de alguma forma, atrapalhar seu kernel atual, tornando seu sistema instável, poderá inicializar qualquer kernel mais antigo.

heemayl
fonte
Isso não removerá núcleos de baixa latência ou núcleos de qualquer outro sabor que não o genérico.
Jarno
Suponho que você se refira a essas sed soluções.
Jarno
@jarno: Que tal substituir grep -Po "^linux-image-[^-]+-[^-]+-generic\b"com grep -Eo "^linux-(image|headers|tools)-[^-]+-[^-]+(|-generic)\s" | sed -e "s/\s//g"e grep -Po ".*(?=-[a-z]*$)"com grep -Eo "^[0-9]+\.[0-9]+\.[0-9]+-[0-9]+"e grep -Po "[0-9].*(?=-[a-z]*)"com grep -Eo "[0-9]+\.[0-9]+\.[0-9]+-[0-9]+"?
Sadi
@Sadi, bem, eu também não encontraria núcleos de baixa latência.
Jarno
1
Obrigado. Outros métodos não funcionaram para mim. O seu fez o trabalho.
Philippe Delteil
1

O ailurus possui o recurso de remover kernels antigos e configurações não utilizadas. Pessoalmente, removo-o manualmente do synaptic. Você pode instalar o ailurus no getdeb e no ppa

sagarchalise
fonte
"O Ailurus é uma ferramenta para fazer backup de uma lista de nomes de software instalado. No passado, o Ailurus tinha muitas funções. Agora, possui apenas uma função. Porque acho que uma função realmente útil é melhor do que dezenas de funções menos úteis."
Jarno
1

Eu tenho um script para isso que não precisa de análise de string muito sofisticada.

Remova cabeçalhos e imagens, exceto a atual, para liberar espaço

sudo apt-get autoremove --purge 'linux-headers-[0-9].*' linux-headers-$(uname -r)+ linux-headers-$(uname -r | cut -d- -f1,2)+ 'linux-image-[0-9].*' linux-image-$(uname -r)+
Paulo Santos
fonte
1

Você pode usar o ukuu - é tudo GUI - para atualizar e excluir Kernels antigos. Funciona para mim!

Lembre-se de deixar os 2 últimos instalados e, obviamente, o kernel 'running'.

Você também pode definir o ukuu para mostrar apenas os lançamentos da linha principal, mesmo os kernels RC, os lançamentos dos pontos de ocultação.

ukuu

Você pode encontrar o ukuu no Synaptic, ou as instruções estão aqui:

Instruções de instalação do OMG! Ubuntu ukuu

sprocketoctopus
fonte
1

Com base em uma resposta anterior de David Kemp, o script a seguir limpará todos os cabeçalhos e imagens, exceto as duas últimas versões.

#!/bin/sh
# This script assumes that the installed linux-image and linux-headers packages
# share the same versions (i.e. if a linux-image version number is installed,
# the corresponding linux-headers package will also be installed, and vice
# versa.)

SECONDTOLASTVER=$(dpkg --list | grep linux-image | awk '{ print $2 }' | sort -r -n | sed '/^[^0-9]\+$/d' | sed 's/^.*-\([0-9\.]\+-[0-9]\+\).*/\1/' | uniq | sed -n 2p)

# get a list of package names matching the argument passed to the function, and
# return only those package names which should be removed
get_pkgs_to_remove_matching () {
    if [ -n "$SECONDTOLASTVER" ]; then
        echo $(dpkg --list | grep $1 | awk '{ print $2 }' | sort | sed -n '/'"$SECONDTOLASTVER"'/q;p')
    fi
}

echo $(get_pkgs_to_remove_matching linux-image) $(get_pkgs_to_remove_matching linux-headers) | xargs sudo apt-get purge

(use apt-get -ypara remover sem questionar)

Mark
fonte
Alguma razão pela qual isso foi rebaixado? Não funcionou para alguém? Ao copiar / colar, verifique se você não está quebrando linhas longas ao colar. Não tive problemas com isso funcionando.
Mark
A versão mais recente do kernel na minha máquina é 3.13.0-43-lowlatency. Este script eliminaria linux-headers-3.13.0-43-lowlatency.
Jarno
@jarno como você determinou isso? Para testá-lo sem fazer nada, adicione um sinalizador "-s" ao comando apt-get (ou apenas remova-o | xargs sudo apt-get -y purgecompletamente). Se imprimir 3.13.0-43 com baixa latência, talvez você tenha algumas versões posteriores às instaladas no seu sistema.
Mark
Eu tentei simulação. Não, mas tive algumas versões anteriores do kernel removidas, mas não eliminadas, e os respectivos pacotes de cabeçalho eliminados.
Jarno
De qualquer forma, desenvolvi um script baseado na idéia da resposta de Sankalp.
Jarno
0

Aqui está um esboço do que fiz, com cuidado, pois não sou especialista em Linux, verifique se você sabe o que está fazendo e fez backup de todos os arquivos que está modificando.

gedit /boot/grub/grub.cfg

depois encontre as entradas que deseja manter, as destacaremos e as copiaremos

cd /etc/grub.d
ls

você verá uma lista de arquivos como 10_linux e 30_os-prober

sudo chmod -x 10_linux

isso irá parar de forma automática adicionando todas as entradas linux no menu de inicialização do grub.

gksudo gedit 40_custom

abra o arquivo do menu de inicialização personalizado, volte ao grub.cfg (que ainda deve estar aberto no gedit) e copie as entradas que deseja manter ... como

menuentry "My Default Karmic" {
  set root=(hd0,1)
  search --no-floppy --fs-uuid --set cb201140-52f8-4449-9a95-749b27b58ce8
  linux /boot/vmlinuz-2.6.31-11-generic root=UUID=cb201140-52f8-4449-9a95-749b27b58ce8 ro quiet splash
  initrd /boot/initrd.img-2.6.31-11-generic
}

cole-os 40_custome salve-o.

sudo chmod 755 40_custom

torna executável, e finalmente atualizamos o grub, que mudará o arquivo grub.cfg:

sudo update-grub

Agora, tenha cuidado, se você atualizar seu kernel ou sistema operacional, o menu de inicialização provavelmente não será atualizado ... você precisará fazer isso manualmente. Mas fazer esse procedimento permitirá que você personalize um pouco mais o menu de inicialização, como remover a versão do kernel e colocar o nome do ubuntu ... ou seja, Ubuntu Lucid 10.04, etc ...

Espero que alguém ache isso útil, pois levei um tempo para descobrir ... não vi essa solução em lugar algum ...

Joe
fonte
3
Essa resposta parece um exagero. É melhor apenas remover os kernels antigos.
Scott Severance
Eu tinha lido que kernels extras podem ser úteis no caso de situações de recuperação. Além disso, esta é uma maneira simples de editar o texto da entrada de inicialização. Então, ao invés de dizer "Ubuntu, kernel Linux xxxx-yy --text1 -text2 -t3 -t4 --t5 etc etc etc" (onde as entradas --text apenas indicam algumas opções / parâmetros que eu não entendo), você pode alterar para "Ubuntu xx.yy", embora eu tivesse um suporte "{" do qual não consegui me livrar.
Joe
1
Eu mantenho o kernel anterior imediato por perto até verificar se o kernel mais atual funciona corretamente. Se funcionar, não vai parar de funcionar. Portanto, depois de verificar o kernel mais recente (depois de uma semana), não tenho motivos para manter o kernel antigo por perto. Se não funcionar, tenho o mais recente kernel em bom estado para o qual retornar. Na verdade, atualmente estou executando um kernel antigo devido a um bug do showstopper nos kernels atuais. Mas isso não muda minha política geral. Você só precisa de um bom kernel conhecido.
10138 Scott Severance
0

Instale o gerenciador de pacotes sinápticos e vá até a guia filtros (acho que filtros, se não tentar todos os 5) e selecione "local". Isso mostrará pacotes órfãos no seu sistema, como os kernels. Depois de desinstalá-los, execute update-grub. Esse comando atualiza a lista de opções de inicialização do grub.

Se isso falhar, você sempre pode tentar apt-get remove linux-image-version-generic.

Apreciar
fonte
No Synaptic, você pode filtrar 'Componentes' -> 'Kernel e módulos', que incluem todos os kernels. E classifique pela primeira coluna: 'S' (Status), para obter todos os kernels instalados no topo. De fato update-grubé aconselhável.
usar o seguinte comando
0

Para ter um pouco mais de controle sobre quais versões manter, selecione explicitamente as que você deseja remover. Por exemplo, se você deseja remover as versões do kernel 3.2.0. [49-53], use um forloop simples :

for k in 49 51 52 53 ; do aptitude remove --purge linux-image-3.2.0-${k}-generic ; done

Ajuste a lista de versões do kernel para caber.

NeilNjae
fonte
0

Tente isso. Execute-o como root.

Salve este script como, digamos ./keep-n-kernels.sh

Passe como argumento de linha de comando o número de kernels mais recentes que você deseja preservar.

    
#! / bin / bash

# pass n como um argumento de linha de comando e ele encontrará todos os
# kernels e mantenha apenas os n mais recentes => desinstale todos os mais antigos

# dpkg -l 'linux- *' | sed '/ ^ ii /! d; /' "$ (uname -r | sed" s /\(.*\)-\([^ 0-9] \ + \) / \ 1 / ")" '/ d; s / ^ [^] * [^] * \ ([^] * \). * / \ 1 /; / [0-9] /! d '
# este comando fornece a lista de todos os pacotes, EXCETO o kernel mais recente.
# source: https://help.ubuntu.com/community/Lubuntu/Documentation/RemoveOldKernels

n = $ 1

# encontre as versões do kernel instaladas:
# dpkg-query -W -f = '$ {Version} \ n' 'linux-image- *' | grep. | classificar -n
# fornece números de versão, um em cada linha
# dpkg-query -W -f = '$ {Version} \ n' 'linux-image- *' | grep. | sed 's /\...$// g' | grep -v '\ ... $' | classificar -u
# fornece apenas os que aparecem na imagem linux

# sufixo, por exemplo -generic-pae
# o tipo de kernel no qual você inicializa
sufixo = $ (uname -r | sed ': ^ [0-9] \. [0-9] \. [0-9] \ - [0-9] \ {2 \} :: g')

command = "apt-get purge"

para versão em $ (dpkg-query -W -f = '$ {Version} \ n' 'linux-image- *' | grep. | sed 's /\...$// g' | grep -v ' \ ... $ '| sort -u | head -n - $ {n})
Faz
    command = $ {command} "^ linux-image - $ {version} $ {suffix}"
feito

comando $

Uso da amostra:

# ./keep-n-kernels.sh 4 # inicie o comando apt-get para remover todos, exceto os 4 kernels mais recentes

Se você quiser [E POR SEU PRÓPRIO RISCO], você pode adicionar um -y (ou um sinalizador de força) ao comando apt-get e torná-lo não interativo.

Sankalp
fonte
Ele remove todos os kernels, se você executar ./keep-n-kernels.sh 0. A detecção da sequência de sufixos não funciona; Eu acho que o sufixo = $ (uname -r | sed -r 's / ^ [0-9.] * (- [0-9.] +) * //') ou o sufixo = $ (uname -r | egrep - -compatível apenas - '- [[: alpha:] -] + $') serviria.
Jarno
Mas acho que a ideia é boa. Eu tenho trabalhado para melhorar o script e talvez eu o publique algum dia, quando achar que está pronto o suficiente.
Jarno
Por favor, compartilhe, @jarno. Fico feliz em saber que a idéia parece útil.
Sankalp
Ok, aí está: link
jarno
0

Estou usando uma área de trabalho do KDE e a opção mais fácil que encontrei foi usar o aplicativo kde-config-grub2, conforme sugerido aqui: https://www.kubuntuforums.net/showthread.php?58075-remove-old-linux-versions (que eu já tinha instalado para definir a imagem de plano de fundo, a opção de inicialização padrão e similares). Ao lado da caixa suspensa onde você pode escolher a entrada padrão, existe um botão "Remover entradas antigas". Clicar neste botão apresenta uma lista de todos os kernels instalados e você pode selecionar quais remover. Quando você aplica as alterações, ele usa o dpkg para removê-las do sistema e também do menu GRUB.

Ben
fonte
0

Apenas para conversar, você também pode emitir

apt-get remove linux-{image,headers}-x.y.z-{1,2,...,n}

como raiz, e o trabalho será feito.

Severo Raz
fonte
0

Se você estiver usando o ansible para controlar as máquinas, este manual pode ser útil.

---
 - hosts: all
   become: yes
   tasks:
    - name: "Run apt-get autoremove"
      apt: 
        name: linux-image-generic
        autoremove: yes
        state: present 
        update_cache: yes
        cache_valid_time: 3600
flickerfly
fonte