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?

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.

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.

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.

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:

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.

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.

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

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

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

Você pode encontrá-lo em Sistema >> Administração >>

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.

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

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 .

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.

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.

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.

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

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.

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

clique em limpador de pacotes e núcleos limpos. ele não mostra o kernel atualmente usado, portanto você estará sempre seguro.

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

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.

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 $(
  ...)

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 :

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 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 .

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.

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.

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

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)+

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.

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

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

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)

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 ...

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.

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.

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.

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.

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.

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