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

664

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

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

O Ubuntu oferece alguma maneira mais fácil de limpá-los ou impedi-los de aparecer na lista de inicialização?

    
por Hans 22.01.2016 / 16:20

30 respostas

572

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 dependem mais. Isso inclui versões antigas de linux-headers-* e linux-image-* . (Também é inteligente sobre esse processo, deixando uma versão extra do kernel como alternativa).

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ê possa ter instalado.

Sevocênãovêseugrub-entãolembre-sedepressionarShiftduranteainicialização.

Comovocêpodever,apenasokernelmaisrecenteéexibido.

Sevocêselecionaraopçãomostrada(pressioneEnter),entãotodososkernelsantigosficarãovisíveisedisponíveisparainicializar.

Como excluir permanentemente kernels antigos

Primeiro, inicialize com o kernel disponível mais recente.

Existem várias maneiras de excluir kernels antigos. Pessoalmente, eu não tocaria em Janitor de Computador , pois isso é considerado uma quebra de seu computador com suas sugestões.

sináptico

Uma alternativa é Synaptic ( sudo apt install synaptic )

pesquise 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 Apply para excluir o kernel.

Repitaapesquisa,masdestavezparalinux-header-vocêpodeexcluiroscabeçalhosassociadosparaaimagemdokernelescolhidaanteriormente.

Synapticemboranãotenteverificaroquevocêestátentandoremover...vocêpodeinadvertidamenteexcluirseukernelmaisrecente-ouatémesmoapagartodososseuskernelsatravésdestaferramentadeixando-ocomumnãoinicializávelUbuntu!.

Lembre-sedeverificarqualkernelvocêestáusando:

uname-r

Oresultadoseriasemelhantea:

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 kernels, incluindo o mais recente. O motivo da recomendação é que você terá pelo menos um / dois outros kernels para inicializar, se, por qualquer razão, o kernel mais recente não conseguir inicializar ou se introduzir uma capacidade de regressão, como falha de rede sem fio.

    
por fossfreedom 08.05.2018 / 18:09
367

Primeiro, reinicie o seu sistema para ter certeza de que ele está usando o kernel mais recente. Então 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 em seu sistema.

dpkg --list | grep linux-image 

Encontre todos os kernels que estão abaixo do 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 

Reinicialize seu sistema.

    
por penreturns 11.07.2018 / 10:33
263

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 kernels encontrados

Desvinculando a invocação de sed :

  • -n informa sed para ficar quieto
  • 'uname -r' gera a versão atual do kernel instalado - nós a incluímos em backticks para que a saída seja incluída como parte do comando (você também pode ver isso como $(uname -r)
  • /something/q diz que parar quando você combina 'algo' (nesse caso, algo é resultado de uname -r ) - o / envolve uma expressão regular
  • p é impresso
  • o ; é o comando separtor, então /something/q;p diz quit quando você combina algo, senão imprime

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

Se você é paranóico (como eu), você pode fazer a última parte xargs echo sudo apt-get -y purge para que o comando para limpar os kernels antigos seja impresso, então você pode verificar se nada 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]\+\)//")"'/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]\+\)//")"'/q;p' | xargs sudo apt-get -y purge

Nota: a invocação sed é modificada. "$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)//")" extrai apenas a versão (por exemplo, "3.2.0-44"), sem "-genérico" ou semelhante de uname -r

Versão all-in-one 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]\+\)//")"'/q;p') | xargs sudo apt-get -y purge
    
por David Kemp 21.07.2015 / 08:27
55

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:

Eu acho que este é o caminho mais fácil e rápido. 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
    
por bmaupin 21.05.2017 / 20:34
42

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 requer edição.

Muitos Kernels?

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

  • Kernels removidos via APT (Synaptic, "apt-get remove", etc.) atualizarão automaticamente o grub.cfg e nenhuma ação do usuário é 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 ajuste do ubuntu

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

Remover entradas antigas do kernel

  • Selecione "Limpador de pacotes" à esquerda e "Limpe o kernel" no painel à direita.

  • 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 "Limpar" no canto inferior direito para remover as imagens e os cabeçalhos selecionados do kernel.

Remover sistemas operacionais do menu do Grub

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

  • Os itens do menu são colocados no menu do Grub2 por scripts. Se você não quiser que outros Sistemas Operacionais sejam inseridos no menu, desative /etc/grub.d/30_osprober

  • Execute este comando para impedir que o script seja executado em sudo chmod -x /etc/grub.d/30_os-prober

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

Remova o Memtest86 + do menu do 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

Origem

Nota: Após as atualizações do kernel, uma nova entrada é adicionada ao menu GRUB. Você pode remover a mais antiga, se quiser. No entanto, a maioria dos usuários experientes recomendará que você mantenha pelo menos uma entrada sobressalente caso algo dê errado com uma atualização e você precise inicialize uma versão antiga do kernel para fins de solução de problemas.

Maneira alternativa de remover entradas do Kernel (antes de 10.04)

para o GRUB não o GRUB2

startupmanager

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

Você vê na segunda tela que você pode selecionar quantos kernels mostrar? Eu geralmente apenas o mantenho em 1, mas quando eu obtenho uma atualização do kernel eu sempre o altero para 2 antes de reiniciar para que eu possa selecionar o kernel mais antigo se o novo kernel tiver problemas com meu hardware. Quando eu souber que o novo kernel está funcionando bem, mudo de volta para 1.

    
por karthick87 11.03.2017 / 19:59
39

Puramente linha de comando, isso removerá todos, exceto o atual e o segundo mais atual (via "-2" no comando head 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
    
por Kees Cook 08.05.2015 / 19:01
34

Atualização: purge-old-kernels é depreciado hoje em dia.

Eu fiz um script para limpar os kernels mesmo em condições complicadas. É chamado de linux-purge e você pode encontrá-lo aqui .

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

Existe também uma página de documentação do Ubuntu que eu contribuí para remover kernels antigos aqui .

    
por jarno 19.11.2017 / 16:00
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 você deseja remover todas as versões mais antigas do kernel que não estão em uso (exceto o anterior que você não está usando. Isto é para ter certeza que se a versão atual do kernel falhar de alguma forma, você tem um caminho a seguir de volta a um estado anterior). Faça o seguinte:

sudo apt-get autoclean

Isso eliminará todos os arquivos antigos (inclusive as versões do kernel) que você possa ter. Observe que, se você tiver muitas versões antigas, levará algum tempo, já que é necessário remover a versão do kernel sem problemas. Para mim, remover as últimas 12 versões do kernel levou cerca de 2 minutos. Você também pode fazer o seguinte:

sudo apt-get clean

Qual vai eliminar tudo baixado e armazenado na pasta cache do apt. Por último você tem:

sudo apt-get autoremove

, que deve verificar se há algum pacote não utilizado e removê-lo, se necessário. Isso é ótimo para as bibliotecas e os pacotes de dependência que não são mais necessários em nenhum aplicativo instalado.

    
por Luis Alvarado 22.08.2017 / 21:44
25

10.04 Método GUI

O Computer Janitor 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 em /boot/grub/menu.lst para especificar quantos kernels ele deve mostrar no máximo. O GRUB 2, até onde eu sei, não.

    
por maco 26.03.2012 / 10:58
23

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

dpkg -l | grep linux-image

dpkg -l | grep linux-headers

Você pode removê-los um por um ou juntos, apenas certifique-se de manter o mais recente.

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

link

As reivindicações a seguir eliminam todos os kernels e cabeçalhos não utilizados:

dpkg -l 'linux-*' | sed '/^ii/!d;/'"$(uname -r | sed "s/\(.*\)-\([^0-9]\+\)//")"'/d;s/^[^ ]* [^ ]* \([^ ]*\).*//;/[0-9]/!d'|grep -E "(image|headers)" | xargs sudo apt-get purge
    
por mikewhatever 24.04.2018 / 22:59
16

Para remover os kernels mais antigos da imagem do Linux, primeiro inicie no kernel que você deseja manter.

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

Agora vá para o gerenciador de pacotes synaptic e procure por linux-image e remova as versões mais antigas, exceto a mostrada pelo comando upper. Geralmente eu prefiro ir com o mais recente.

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

    
por anurag-jain 03.03.2011 / 14:10
14

Você pode instalar ubuntu-tweak e depois Ir para aplicativos - > Ferramenta do sistema - > ajuste do ubuntu e

clique em limpadores de pacotes e kernels limpos. ele não mostra o kernel usado atualmente, então você estará sempre seguro.

    
por Lincity 03.03.2011 / 14:26
8

Pessoalmente, 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 à esquerda
  • No lado direito da "visão de limpeza", pressione "Limpar Kernels"
  • Selecione todos os kernels - Eu acho que o que está em uso não está listado, mas apenas no caso de verificar a execução de uname -a em um terminal
por Alan Featherston 08.04.2013 / 02:24
6

Você pode desinstalar os kernels antigos ( linux-image-... packages) 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 com uname -r ).

Lembre-se de que ter uma ou duas versões mais antigas pode ajudar você 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 novo. Se você está pensando em remover recovery mode options - não. Eles podem ser úteis se você quebrar algo que o impeça de iniciar.

Consulte esta página.

    
por evgeny 13.04.2017 / 14:14
4

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

Primeiro, gere uma lista de todas as versões do kernel instaladas, 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 do kernel instaladas, 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. Certifique-se de que as versões do kernel que você deseja manter não façam parte da lista. Use o comando uname -r para ver a versão do kernel atualmente em execução.

Se você estiver satisfeito com os resultados, use apt-get para remover os pacotes.

Primeiro, uma corrida 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)))

Em seguida, 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ê quiser automatizar o processo, adicione o parâmetro --yes :

sudo apt-get --yes purge $(
  ...)
    
por lesmana 16.05.2015 / 18:18
3

A vantagem desta resposta é nativa O Ubuntu Bash é usado sem instalar aplicativos de terceiros. Os usuários de kernels personalizados que não usaram apt ou dpkg podem alterar este script bash para atender às suas necessidades. Esta resposta é baseada em ( Como remover seletivamente kernels antigos de uma vez ).

Solução baseada no Zenity

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

Comootítuloindica,okernelatualcomoqualvocêinicializounãopodeserremovidoenãoestáincluídonalista.Otamanhorelatadoéoquantoserásalvonodiretório/boot.Maisésalvoemseudiscoporqueosbináriosdokernelresidememoutrasáreastambém.27dejulhode2017nota:Osdiretórios/usr/src/*kernel_version*e/lib/modules/*kernel_version*agoratambémestãoincluídos.

ADatademodificaçãoédescobertausandoocomandostat.Nomeusistemaessadataé"tocada" toda vez que o kernel é inicializado usando isto () cron script de reinicialização. No entanto, no seu sistema, a data será a data de lançamento do kernel, não a última vez que você inicializou.

apt-get purge dá chance de abortar

Você tem a oportunidade final de ver 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

Copie este código para um arquivo executável chamado rm-kernels in /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 uso de arquivos executável:

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 GUI (gráfica), uma caixa de diálogo baseada em texto é usada para selecionar os kernels a serem eliminados.

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

    sudo apt install dialog

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

Ecrã de amostra

rm-kernels-serverbashcode

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

OBSERVAÇÃO: Na chamada para dialog , a diretiva --ascii-lines é passada para substituir o conjunto de caracteres estendidos de extração de linha (que ssh não gosta) com "+ --- - + "para caixas de desenho. Se você não gostar dessa aparência, poderá usar a diretiva --no-lines para nenhuma caixa.

Atualizações de 28 de julho de 2017

O tamanho calculado de cada kernel foi retirado de /boot/*kernel_version* , que eram 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 é de ~ 400 MB. O código acima para rm-kernels e rm-kernels-server foi atualizado. No entanto, as telas de amostra acima não refletem essas alterações ainda.

O padrão é estimar o tamanho dos arquivos para os cabeçalhos linux em 125 MB e a imagem linux para 220 MB, porque du pode ser dolorosamente lento, a menos que os arquivos estejam no cache. Para obter o tamanho real usando du , passe qualquer parâmetro para o script.

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

A caixa de diálogo usada para exibir a <Última> Data de Último Acesso de cada Kernel. Essa data pode ser sobregravada em massa para todos os kernels durante operações de backup ou semelhantes. A caixa de diálogo agora mostra a Data Modificada em seu lugar.

    
por WinEunuuchs2Unix 29.07.2017 / 00:35
2

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

dpkg --purge $(aptitude search ?obsolete)

No entanto, isso vai perder pacotes que ainda são recomendados por outros pacotes, e o argumento -R / - without-recommends não resolve este problema.

O dselect após alternar o modo de ordenação com 'o' mostrará todos os pacotes obsoletos, incluindo os erros de aptidão, mas algumas pessoas não gostam de usá-lo.

    
por Chris Cheney 06.04.2013 / 05:03
2

A resposta aceita usando sed para remover kernels mais antigos permanentemente tem algumas falhas, se alguém não reinicializou o computador depois de atualizar o kernel, o comando irá remover o kernel mais recente também.

Aqui está uma solução alternativa que considerará todas as situações para remover apenas os kernels 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ê tiver alguma versão mais recente que a atual, isso lhe dará um aviso para reiniciar o computador primeiro. Note também que os kernels mais antigos são preservados devido a uma boa razão que é se você de alguma forma atrapalhar seu kernel atual tornando seu sistema instável, então você deve ser capaz de inicializar em qualquer kernel antigo.

    
por heemayl 17.04.2015 / 21:21
1

ailurus tem como característica a remoção de kernels antigos e de configurações não usadas. Eu pessoalmente removê-lo manualmente do synaptic. Você pode instalar o ailurus a partir do getdeb , bem como do ppa

    
por sagarchalise 17.09.2010 / 12:53
1

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

Lembre-se de deixar os dois últimos instalados e obviamente o kernel 'em execução'.

Você também pode configurar o ukuu para mostrar apenas versões principais, mesmo kernels RC, ocultando lançamentos de pontos.

VocêpodeencontraroukuunoSynapticouasinstruçõesestãoaqui:

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

    
por sprocketoctopus 07.09.2017 / 12:39
0

aqui está um resumo do que eu fiz, tendo cuidado, pois não sou especialista em linux, tenha certeza que você sabe o que está fazendo e fez o backup de todos os arquivos que está modificando.

gedit /boot/grub/grub.cfg

em seguida, encontre as entradas que deseja manter, vamos destacar e copiá-las

cd /etc/grub.d
ls

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

sudo chmod -x 10_linux

isto irá parar o formulário auto adicionando todas as entradas do 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 em 40_custom e salve-o.

sudo chmod 755 40_custom

torna isto executável, então finalmente nós atualizamos o grub que irá mudar o arquivo grub.cfg:

sudo update-grub

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

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

    
por Joe 09.01.2012 / 00:31
0

Instale o gerenciador de pacotes synaptic e vá até a aba de 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 para o grub.

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

    
por Relish 29.05.2013 / 18:41
0

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

#!/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]\+\).*//' | 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 -y purge
    
por Mark 12.06.2013 / 20:42
0

A seguinte sequência de comandos removerá todos os kernels linux instalados, exceto o kernel atualmente em execução (grep -v uname -r ) e o último kernel disponível (dpkg -l | .... | tail -1):

dpkg -l | grep -E linux-image-.*-generic | cut -d ' ' -f3 | grep -v 'dpkg -l | grep -E linux-image-.*-generic | cut -d ' ' -f3 | tail -1' | grep -v 'uname -r' | xargs apt-get -y purge

Eu uso isso para manter os volumes de inicialização da área de trabalho relativamente limpos, mas em uma situação de servidor você provavelmente desejaria expandir a lógica e escrever alguns scripts adicionais para manter uma lista dos últimos kernels X que o servidor inicializou.

Algo parecido com um script de inicialização que:

uname -r >> /root/bootedkernels
cat /root/bootedkernels | sort -u | tail -3 > /root/bootedkernels # Keep the last 3 booted kernels

e, em seguida, use:

dpkg -l | grep -E linux-image-.*-generic | cut -d ' ' -f3 | grep -vf /root/bootedkernels | grep -v 'dpkg -l | grep -E linux-image-.*-generic | cut -d ' ' -f3 | tail -1' | grep -v 'uname -r' | xargs apt-get -y purge
    
por Alexander Thompson 30.06.2013 / 20:37
0

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

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 ajustá-las.

    
por NeilNjae 08.11.2013 / 13:51
0

Tente isso. Execute-o como root.

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

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

    
#!/bin/bash

# pass n as a command line argument, and it will find all the installed
# kernels and keep only the n most recent ones => uninstall all older ones

# dpkg -l 'linux-*' | sed '/^ii/!d;/'"$(uname -r | sed "s/\(.*\)-\([^0-9]\+\)//")"'/d;s/^[^ ]* [^ ]* \([^ ]*\).*//;/[0-9]/!d'
# this command gives the list of all packages EXCEPT for the latest kernel.
# source : https://help.ubuntu.com/community/Lubuntu/Documentation/RemoveOldKernels

n=$1

# find the installed kernel versions :
# dpkg-query -W -f='${Version}\n' 'linux-image-*' | grep . | sort -n
# gives version numbers, one in each line
# dpkg-query -W -f='${Version}\n' 'linux-image-*' | grep . | sed 's/\...$//g' | grep -v '\...$'| sort -u
# gives only the ones that appear in linux-image

# suffix, e.g. -generic-pae
# the kind of kernel you boot into
suffix=$(uname -r | sed 's:^[0-9]\.[0-9]\.[0-9]\-[0-9]\{2\}::g')

command="apt-get purge "

for version in $(dpkg-query -W -f='${Version}\n' 'linux-image-*' | grep . | sed 's/\...$//g' | grep -v '\...$'| sort -u | head -n -${n})
do
    command=${command}"^linux-image-${version}${suffix} "
done

$command

Uso da amostra:

# ./keep-n-kernels.sh 4 # launch the apt-get command to remove all but the 4 most recent kernels

Se você quiser [E 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.

    
por Sankalp 28.01.2014 / 21:47
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 como sugerido aqui: link (que eu já tinha instalado para definir a imagem de fundo, opção de inicialização padrão, e assim por diante). Ao lado da caixa suspensa, onde você pode escolher a entrada padrão, há 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 mudanças, ele usa o dpkg para realmente removê-las do sistema, assim como o menu GRUB.

    
por Ben 06.07.2014 / 19:44
0

Apenas para conversar, você também pode enviar

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

como root, e o trabalho será feito.

    
por Severo Raz 27.11.2014 / 03:26
0

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

Remover cabeçalhos e imagens, exceto o 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)+
    
por Paulo Santos 16.05.2015 / 11:40