¿Cómo elimino las versiones viejas del kernel para limpiar el menú de inicio?

658

Cada vez que instalo un nuevo kernel de Linux, se deja en el grub_config, haciendo que el menú de arranque sea más largo cada vez.

Sé que puedo buscar manualmente a través de los paquetes instalados y eliminarlos.

¿Ofrece Ubuntu una manera más fácil de limpiarlos o impedir que se muestren en la lista de inicio?

    
pregunta Hans 22.01.2016 - 15:20

30 respuestas

567

16.04 y versiones más nuevas de Ubuntu

sudo apt autoremove

Este comando elimina los paquetes que se instalaron automáticamente para resolver una dependencia, pero ahora ya no se depende de ellos. Esto incluye versiones antiguas de linux-headers-* y linux-image-* . (También es inteligente acerca de este proceso, dejando una versión de repuesto del núcleo como una alternativa).

11.10 y versiones más nuevas de Ubuntu

GRUB2 y su pantalla de todos los núcleos

Las últimas versiones de Grub2 instaladas en Ubuntu muestran automáticamente el núcleo más reciente y ocultan los núcleos anteriores que puede haber instalado.

Si no ves tu grub , recuerda presionar Shift mientras arrancas.

Como puede ver, solo se muestra el kernel más reciente.

Si selecciona la opción que se muestra (presione Enter ), todos los kernels viejos se harán visibles y estarán disponibles para iniciar desde.

Cómo eliminar permanentemente kernels más antiguos

Primer arranque con el último kernel disponible.

Hay varias maneras de eliminar kernels viejos. Personalmente, no tocaría Computer Janitor ya que esto se reconoce para romper su computadora con sus sugerencias.

sináptica

Una alternativa es Synaptic ( sudo apt install synaptic )

busque linux-image , haga clic con el botón derecho en un kernel y seleccione la eliminación completa, y finalmente haga clic en el botón Aplicar para eliminar el kernel.

Repita la búsqueda, pero esta vez para linux-header : puede eliminar los encabezados asociados para la imagen del kernel elegida previamente.

Synaptic , aunque no intentará verificar lo que está tratando de eliminar ... podría eliminar inadvertidamente su kernel más nuevo, o incluso eliminar todos sus núcleos a través de esta herramienta, dejándole con un < em> Ubuntu !.

Recuerde verificar qué núcleo está utilizando escriba:

uname -r

El resultado sería similar a:

Recuerda el resultado y el número: asegúrate de no borrar la imagen o el encabezado correspondiente.

Recomendación

Mi recomendación es mantener al menos dos o preferiblemente tres núcleos, incluido el último. El motivo de la recomendación es que tendrá al menos uno o dos kernels para arrancar, si es por alguna razón el kernel más reciente con el que no puede arrancar o la introducción de una capacidad regresiva, como la conexión inalámbrica interrumpida.

    
respondido por el fossfreedom 08.05.2018 - 16:09
365

Primero, reinicie su sistema para asegurarse de que está utilizando el núcleo más reciente. A continuación, abra la terminal y verifique su kernel actual:

uname -r 

¡NO RETIRE ESTE KERNEL!

A continuación, escriba el siguiente comando para ver / enumerar todos los kernels instalados en su sistema.

dpkg --list | grep linux-image 

Encuentra todos los núcleos que sean más bajos que tu kernel actual. Cuando sepa qué kernel eliminar, continúe a continuación para eliminarlo. Ejecute los siguientes comandos para eliminar el kernel que seleccionó.

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

Finalmente, ejecute los comandos a continuación para actualizar grub2

sudo update-grub2 

Reinicia tu sistema.

    
respondido por el penreturns 11.07.2018 - 08:33
261

Mi única línea para eliminar kernels viejos (esto también libera espacio en el disco)

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

Explicación (recuerde, | usa la salida del comando anterior como la entrada a la siguiente)

  • dpkg --list lista todos los paquetes instalados
  • grep linux-image busca las imágenes de Linux instaladas
  • awk '{ print }' solo muestra la 2da columna (que es el nombre del paquete)
  • sort -V ordena los elementos por orden por número de versión
  • sed -n '/''uname -r''/q;p' imprime las líneas antes del núcleo actual
  • xargs sudo apt-get -y purge purga los núcleos encontrados

Desenrollando la invocación sed :

  • -n le dice a sed que esté quieto
  • 'uname -r' muestra la versión actual del kernel instalado; lo incluimos en los backticks para que la salida se incluya como parte del comando (también puede ver esto como $(uname -r)
  • /something/q dice detener cuando se combina 'algo' (en este caso, algo sale de uname -r ) - el / rodea una expresión regular
  • p es print
  • el ; es el comando separtor, por lo que /something/q;p dice quit cuando coincide con algo, de lo contrario imprime

en total, sed -n '/''uname -r''/q;p' imprime las líneas hasta que coincida con el nombre del kernel actual.

Si eres paranoico (como yo), puedes hacer la última parte xargs echo sudo apt-get -y purge para que se imprima el comando para purgar los kernels viejos, luego puedes verificar que no se incluya nada inesperado antes de ejecutarlo.

Versión modificada para eliminar encabezados:

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

Nota: la invocación de sed se modifica. "$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)//")" extrae solo la versión (por ejemplo, "3.2.0-44"), sin "-generic" o similar de uname -r

Versión todo en uno para eliminar imágenes y encabezados (combina las dos versiones anteriores):

echo $(dpkg --list | grep linux-image | awk '{ print  }' | sort -V | sed -n '/''uname -r''/q;p') $(dpkg --list | grep linux-headers | awk '{ print  }' | sort -V | sed -n '/'"$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)//")"'/q;p') | xargs sudo apt-get -y purge
    
respondido por el David Kemp 21.07.2015 - 06: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 y siguientes:

Considero que esta es la forma más fácil y rápida. Mantiene el kernel más reciente y dos más:

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

Para cambiar la cantidad de kernels adicionales que se guardan:

sudo purge-old-kernels --keep 3
    
respondido por el bmaupin 21.05.2017 - 18:34
41

Eliminar entradas de Grub 2 Las entradas se deben eliminar editando o eliminando archivos en la carpeta /etc/grub.d. El archivo /boot/grub/grub.cfg es de solo lectura y normalmente no debería requerir edición.

¿Demasiados núcleos?

  • Si no está seguro del kernel que está usando actualmente, en una terminal escriba uname -r .

  • Los núcleos eliminados a través de APT (Synaptic, "apt-get remove", etc.) actualizarán automáticamente grub.cfg y no se requiere acción del usuario.

  • Una herramienta excelente para eliminar kernels (y entradas de menú) es Ubuntu-Tweak, una aplicación GUI segura y fácil de usar.

  • Instalar ubuntu tweak

  • Ubuntu-Tweak estará disponible en Aplicaciones & gt; Herramientas del sistema.

Eliminar entradas de Kernel anteriores

  • Seleccione "Limpiador de paquetes" a la izquierda y "Limpiar kernel" desde el panel derecho.

  • Presione el botón "Desbloquear" en la esquina inferior derecha, ingrese su contraseña.

  • Seleccione de la lista mostrada las imágenes del núcleo y los encabezados que desea eliminar. El kernel en uso no está en la lista.

  • Presione el botón "Limpieza" en la esquina inferior derecha para eliminar las imágenes y los encabezados del kernel seleccionados.

Eliminar sistemas operativos del menú de Grub

  • Otros sistemas operativos que se han eliminado de la computadora también se eliminarán del menú una vez que "update-grub" se ejecute como root.

  • Los elementos de menú se colocan en el menú de Grub2 mediante scripts. Si no desea que se ingresen otros sistemas operativos en el menú, desactive /etc/grub.d/30_osprober

  • Ejecuta este comando para detener la ejecución del script
    sudo chmod -x /etc/grub.d/30_os-prober

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

Eliminar Memtest86 + del menú de Grub
sudo chmod -x /etc/grub.d/20_memtest86+

  • Ejecute el comando update-grub para permitir que los cambios se incorporen en grub.cfg

Fuente

Nota: Después de las actualizaciones del núcleo, se agrega una nueva entrada al menú de GRUB. Puede eliminar la anterior si lo desea. Sin embargo, la mayoría de los usuarios experimentados le aconsejarán que guarde al menos una entrada adicional en caso de que algo salga mal con una actualización y necesite inicia una versión anterior del kernel para solucionar problemas.

Alternativa para eliminar las entradas del Kernel (antes del 10.04)

para GRUB no GRUB2

startupmanager

Puedes encontrarlo en Sistema & gt; & gt; Administración & gt; & gt;

¿Ves en la segunda captura de pantalla que puedes seleccionar cuántos núcleos mostrar? Por lo general, solo lo mantengo en 1, pero cuando obtengo una actualización del kernel, siempre lo cambio a 2 antes de reiniciar, así puedo seleccionar el kernel anterior si el nuevo kernel tiene problemas con mi hardware. Una vez que sé que el kernel nuevo funciona bien, lo cambio a 1.

    
respondido por el karthick87 11.03.2017 - 18:59
38

Puramente en la línea de comandos, esto eliminará todos menos el actual y el segundo más actual (a través del "-2" en el comando principal a continuación):

OLD=$(ls -tr /boot/vmlinuz-* | head -n -2 | cut -d- -f2- |
    awk '{print "linux-image-" %pre% " linux-headers-" %pre%}' )
if [ -n "$OLD" ]; then
    apt-get -qy remove --purge $OLD
fi
apt-get -qy autoremove --purge
    
respondido por el Kees Cook 08.05.2015 - 17:01
34

Actualización: purge-old-kernels está obsoleto hoy en día.

Hice una secuencia de comandos para purgar núcleos incluso en condiciones difíciles. Se llama linux-purge y puede encontrarlo aquí .

Si solo quiere purgar los kernels (y los paquetes relacionados) que son más antiguos que el kernel utilizado actualmente, cuando el sistema no está roto, puede usar este script .

También hay una página de documentación de Ubuntu a la que he contribuido en relación con la eliminación de kernels antiguos aquí .

    
respondido por el jarno 19.11.2017 - 15:00
29

Puede seguir la Utilización de la sección del paquete "actualizaciones desatendidas" de Actualizaciones automáticas de seguridad artículo sobre Ubuntu Wiki para realizar esto.

Necesita cambiar la siguiente línea en el archivo /etc/apt/apt.conf.d/50unattended-upgrades ;

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

con

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

para eliminar automáticamente los paquetes antiguos, incluidos los kernels.

También elimine o comente la línea

"^linux-image.*"; 

en la sección "NeverAutoRemove" del archivo /etc/apt/apt.conf.d/01autoremove.

    
respondido por el Qwerty 01.03.2013 - 12:44
27

La forma más rápida / más simple (aplicable al menos desde 12.04) posible que ya viene con Ubuntu es apt-get . Haga lo siguiente si desea eliminar todas las versiones anteriores de kernel que no están en uso (excepto la anterior que no está usando. Esto es para asegurarse de que si la versión actual del kernel falla de alguna manera, tiene un camino por recorrer volver a un estado anterior). Haz lo siguiente:

sudo apt-get autoclean

Esto eliminará cualquier archivo antiguo (incluidas las versiones del kernel) que pueda tener. Tenga en cuenta que si tiene muchas versiones anteriores, llevará un tiempo, ya que debe asegurarse de que la eliminación de la versión del kernel no tenga problemas. Para mí, eliminar las últimas 12 versiones del kernel tomó aproximadamente 2 minutos. También puede hacer lo siguiente:

sudo apt-get clean

Que eliminará todo lo descargado y almacenado en la carpeta de caché de apt. Por último, tiene:

sudo apt-get autoremove

que verificará si hay paquetes no utilizados y los eliminará si es necesario. Esto es ideal para aquellas bibliotecas y paquetes de dependencia que ya no son necesarios para ninguna aplicación instalada.

    
respondido por el Luis Alvarado 22.08.2017 - 19:44
25

10.04 Método GUI

Computer Janitor puede limpiar kernels viejos y creo que está instalado por defecto en Ubuntu (pero no en Kubuntu).

GRUB 1, si está usando eso, tiene una opción en /boot/grub/menu.lst para especificar cuántos kernels debería mostrar como máximo. GRUB 2, por lo que yo sé, no.

    
respondido por el maco 26.03.2012 - 08:58
23

Para averiguar qué kernels y encabezados están instalados, use

dpkg -l | grep linux-image

dpkg -l | grep linux-headers

Luego puedes eliminarlos uno por uno o juntos, solo asegúrate de mantener el más reciente.

También hay algunos comandos y scripts útiles para automatizar la eliminación.

enlace

Las siguientes afirmaciones para eliminar todos los núcleos y encabezados no 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
    
respondido por el mikewhatever 24.04.2018 - 20:59
16

Para eliminar los núcleos de imágenes de Linux anteriores, primero inicie en el kernel que desea conservar.

También puedes verificar la versión del kernel con el comando uname -r para que no elimines el error por error.

Ahora vaya al administrador de paquetes sinápticos y busque linux-image y elimine las versiones anteriores excepto la que se muestra con el comando superior. Generalmente prefiero ir con el último.

Ahora cuando reinicies verás un menú de comida más limpio.

    
respondido por el anurag-jain 03.03.2011 - 13:10
14

Puede instalar ubuntu-tweak y luego Ir a Aplicaciones - & gt; Herramienta del sistema - & gt; Tweets ubuntu y

haz clic en el limpiador de paquetes y limpia los kernels. no muestra el kernel utilizado actualmente, por lo que siempre estará a salvo.

    
respondido por el Lincity 03.03.2011 - 13:26
7

Personalmente, me gusta usar Synaptic . Me hace sentir más seguro sobre lo que está pasando. La única aplicación que he usado que tiene la opción de eliminar kernels viejos es Ubuntu Tweak .

Cómo eliminar los núcleos que no está utilizando:

  • Abre UbuntuTweak
  • Haz clic en 'Limpiador de paquetes' en 'Aplicaciones' en el panel izquierdo
  • En el lado derecho de la 'vista de limpieza', presione 'Limpiar núcleos'
  • Seleccione todos los kernels: creo que el que está en uso no aparece en la lista, pero solo en el caso de que se ejecute el comando uname -a en un terminal
respondido por el Alan Featherston 08.04.2013 - 00:24
6

Puede desinstalar los kernels antiguos ( linux-image-... packages) usando Synaptic, y eso los eliminará del menú de inicio. Tenga cuidado de no eliminar el kernel en ejecución (puede verificar su versión con uname -r ).

Tenga en cuenta que tener una o dos versiones anteriores puede ayudarle a solucionar problemas, si algo sale mal.

Alternativamente, puede editar / eliminar las entradas manualmente ( gksu gedit /boot/grub/grub.cfg ), pero se volverán a generar cuando actualice a un kernel más nuevo. Si está pensando en eliminar recovery mode options, no lo haga. Pueden ser útiles si rompes algo que te impida arrancar.

Consulte esta página .

    
respondido por el evgeny 13.04.2017 - 12:14
4

Esta es una solución de línea de comando pura.

Primero genere una lista de todas las versiones del kernel instaladas excepto el kernel actualmente en ejecución:

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

O bien, genere una lista de todas las versiones instaladas del núcleo, excepto las dos últimas:

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

Examine la lista. Asegúrese de que las versiones del kernel que desea conservar no sean parte de la lista. Use el comando uname -r para ver la versión del kernel actualmente en ejecución.

Si está satisfecho con los resultados, puede usar apt-get para eliminar los paquetes.

Primero, una ejecución en seco (usando el primer generador como ejemplo):

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

Entonces una carrera 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)))

Si desea automatizar el proceso, agregue el parámetro --yes :

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

La ventaja de esta respuesta es nativa. Ubuntu Bash se usa sin instalar aplicaciones de terceros. Los usuarios de kernels personalizados que no usaron apt o dpkg pueden cambiar este script bash para adaptarlo a sus necesidades. Esta respuesta se basa en ( Cómo purgar selectivamente granos viejos todos a la vez ).

Solución basada en Zenity

Zenity proporciona una interfaz GUI agradable para procesar una lista y seleccionar elementos con botones de radio :

Como el título indica que el kernel actual con el que arrancó no se puede eliminar y no está incluido en la lista. El tamaño informado es cuánto se guardará en el directorio /boot . Se guarda más en su disco porque los binarios del núcleo también residen en otras áreas. Nota del 27 de julio de 2017: los directorios /usr/src/*kernel_version* y /lib/modules/*kernel_version* ahora también están incluidos.

La Fecha de modificación se descubre utilizando el comando stat . En mi sistema, esa fecha es "tocada" cada vez que se arranca el núcleo usando esto ( ¿Cómo se puede saber cuándo se inició por última vez una versión de kernel específica? ) cron reinicie el script. Sin embargo, en su sistema, la fecha será la fecha de lanzamiento del kernel, no la última vez que la reinició.

apt-get purge te da la oportunidad de abortar

Se le brinda la oportunidad final de ver todo lo que se va a purgar y ver el espacio total en el disco (algo engañoso) que se recuperará:

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] 

El código

Copia este código en un archivo ejecutable llamado rm-kernels en /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 }')

    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 }')
        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 }')
    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: necesita sudo permiso para crear el archivo, use:

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

Para hacer que el archivo ejecutable use:

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

Versión del servidor

rm-kernels-server es la versión del servidor para eliminar kernels selectivamente de una vez. En lugar de un cuadro de diálogo GUI (gráfico), se usa un cuadro de diálogo basado en texto para seleccionar kernels para purgar.

  • Antes de ejecutar el script, debe instalar la función de diálogo usando:

    sudo apt install dialog

Dialog está en la instalación predeterminada de Ubuntu Desktop pero no en Ubuntu Server.

Pantalla de muestra

rm-kernels-server bash code

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

    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 }')
        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 }')
    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: en la llamada a dialog , la directiva --ascii-lines se pasa para reemplazar el juego de caracteres extendidos de trazado de línea (que a ssh no le gusta) con "+ --- - + "para cuadros de dibujo. Si no te gusta esta apariencia, puedes usar la directiva --no-lines para ninguna casilla.

Actualizaciones del 28 de julio de 2017

El tamaño calculado de cada núcleo se tomó de /boot/*kernel_version* , que eran 5 archivos que suman ~ 50 MB. La fórmula ha cambiado para incluir los archivos en /usr/src/*kernel_version* y /lib/modules/*kernel_version* . El tamaño calculado para cada núcleo ahora es ~ 400 MB. El código anterior para rm-kernels y rm-kernels-server se ha actualizado. Sin embargo, las pantallas de muestra anteriores aún no reflejan estos cambios.

El valor predeterminado es estimar el tamaño de los archivos para linux-headers en 125 MB y linux-image en 220 MB porque du puede ser muy lento a menos que los archivos estén en caché. Para obtener el tamaño real usando du pase cualquier parámetro al script.

El total de todos los tamaños de kernel (excluyendo la versión en ejecución actual que no se puede eliminar) se muestra ahora en la barra de título.

El cuadro de diálogo utilizado para mostrar la última fecha de acceso del núcleo . Esta fecha puede sobrescribirse en masa para todos los núcleos durante la copia de seguridad u operaciones similares. El cuadro de diálogo ahora muestra la Fecha modificada en su lugar.

    
respondido por el WinEunuuchs2Unix 28.07.2017 - 22:35
2

Una manera fácil de deshacerse de casi todos los paquetes obsoletos, paquetes que ya no están en ninguna lista de paquetes, junto con kernels obsoletos, es hacer uno de los siguientes:

dpkg --purge $(aptitude search ?obsolete)

Sin embargo, esto perderá paquetes que todavía son recomendados por otros paquetes, y el argumento -R / - sin-recomienda no resuelve este problema.

dselect después de cambiar el modo de ordenación con 'o' mostrará todos los paquetes obsoletos, incluidos los que carecen de aptitudes, pero a algunas personas no les gusta usarlo.

    
respondido por el Chris Cheney 06.04.2013 - 03:03
2

La respuesta aceptada que usa sed para eliminar kernels antiguos permanentemente tiene algunos defectos, si alguien no ha reiniciado la computadora después de actualizar kernel, el comando también eliminará el kernel más nuevo.

Aquí hay una solución alternativa que considerará todas las situaciones para eliminar solo núcleos anteriores reales:

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

Si tiene alguna versión más nueva que la actual, esto le dará una advertencia para reiniciar primero su computadora. También tenga en cuenta que los núcleos más antiguos se conservan debido a una buena razón por la cual si usted de alguna manera daña su núcleo actual haciendo que su sistema sea inestable, entonces debería poder arrancar en cualquier núcleo anterior.

    
respondido por el heemayl 17.04.2015 - 19:21
1

ailurus tiene la función de eliminar kernels viejos y configuraciones no utilizadas. Personalmente lo elimino manualmente de sináptico. Puede instalar ailurus desde getdeb y ppa

    
respondido por el sagarchalise 17.09.2010 - 10:53
1

Puede usar ukuu, es todo GUI, para actualizar y eliminar kernels viejos. ¡Funciona para mí!

Solo recuerda dejar los últimos 2 instalados y obviamente el kernel 'en ejecución'.

También puede configurar ukuu para que solo muestre las versiones principales, incluso los kernels RC, oculte los lanzamientos de puntos.

Puedes encontrar ukuu en Synaptic, o las instrucciones están aquí:

OMG! Ubuntu ukuu instrucciones de instalación

    
respondido por el sprocketoctopus 07.09.2017 - 10:39
0

aquí hay un bosquejo de lo que hice, teniendo cuidado ya que no soy un experto en Linux, asegúrese de que sabe lo que está haciendo y ha hecho una copia de seguridad de los archivos que está modificando.

gedit /boot/grub/grub.cfg

luego encuentre las entradas que desea conservar, las resaltaremos y las copiaremos

cd /etc/grub.d
ls

verá una lista de archivos como 10_linux y 30_os-prober

sudo chmod -x 10_linux

esto evitará que el formulario agregue automáticamente todas las entradas de Linux al menú de inicio de grub.

gksudo gedit 40_custom

abra el archivo de menú de inicio personalizado, luego regrese a grub.cfg (que aún debe estar abierto en gedit) y copie las entradas que desea conservar ... 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
}

péguelos en 40_custom y guárdelo.

sudo chmod 755 40_custom

lo hace ejecutable, luego finalmente actualizamos grub, que cambiará el archivo grub.cfg:

sudo update-grub

Ahora, CUIDADO, si actualiza su kernel o sistema operativo, su menú de arranque probablemente no se actualizará ... tendrá que hacerlo manualmente. Pero hacer este procedimiento te permitirá personalizar un poco más el menú de arranque, como eliminar la versión del kernel y simplemente poner el nombre ubuntu ... es decir, Ubuntu Lucid 10.04, etc ...

Espero que alguien encuentre útil esto, ya que me tomó un tiempo darme cuenta ... no vi esta solución en ningún lado ...

    
respondido por el Joe 08.01.2012 - 23:31
0

Instale el administrador de paquetes sinápticos y vaya a la pestaña filtros (creo que los filtros, si no, pruebe todos los 5) y seleccione "local". Esto le mostrará paquetes huérfanos en su sistema, como los kernels. Después de desinstalarlos, ejecute update-grub . Ese comando actualiza la lista de opciones de arranque para grub.

Si esto falla, siempre puedes probar apt-get remove linux-image-version-generic .

    
respondido por el Relish 29.05.2013 - 16:41
0

Según una respuesta anterior de David Kemp, el siguiente script purgará todos los encabezados e imágenes excepto las últimas 2 versiones.

#!/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  }' | 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  | awk '{ print  }' | 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
    
respondido por el Mark 12.06.2013 - 18:42
0

La siguiente cadena de comandos purgará todos los kernels de Linux instalados excepto el kernel actualmente en ejecución (grep -v uname -r ) y el kernel más reciente disponible (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

Utilizo esto para mantener los volúmenes de arranque del escritorio relativamente limpios, pero en una situación de servidor probablemente quiera expandir la lógica y escribir algunos scripts adicionales para mantener una lista de los últimos X kernels que el servidor ha arrancado.

Algo así como un script de inicio que hace:

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

y luego usar:

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
    
respondido por el Alexander Thompson 30.06.2013 - 18:37
0

Para tener un poco más de control sobre qué versiones conservar, seleccione explícitamente las que desea eliminar. Por ejemplo, si quiere eliminar las versiones de kernel 3.2.0. [49-53], use un simple bucle for :

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

Ajuste la lista de versiones del kernel para que quepan.

    
respondido por el NeilNjae 08.11.2013 - 12:51
0

Prueba esto. Ejecútalo como root

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

Pase, como argumento de la línea de comando, la cantidad de kernels más recientes que desea conservar.

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

# 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 de muestra:

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

Si quiere [Y BAJO SU PROPIO RIESGO], puede agregar un -y (o un indicador de fuerza) al comando apt-get y hacerlo no interactivo.

    
respondido por el Sankalp 28.01.2014 - 20:47
0

Estoy usando un escritorio KDE, y la opción más fácil que encontré fue usar la aplicación kde-config-grub2 como se sugiere aquí: enlace (que ya tenía instalado para configurar la imagen de fondo, la opción de inicio predeterminada y similares). Junto al cuadro desplegable donde puede elegir la entrada predeterminada, hay un botón "Eliminar entradas antiguas". Al hacer clic en este botón, aparece una lista de todos los núcleos instalados y puede seleccionar cuáles eliminar. Cuando aplica los cambios, usará dpkg para eliminarlos del sistema, así como del menú de GRUB.

    
respondido por el Ben 06.07.2014 - 17:44
0

Solo para sonar, también puedes emitir

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

como root, y el trabajo estará hecho.

    
respondido por el Severo Raz 27.11.2014 - 02:26
0

Tengo un script para esto que no necesita un análisis de cadenas muy sofisticado.

Eliminar encabezados e imágenes, excepto el actual para liberar espacio

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)+
    
respondido por el Paulo Santos 16.05.2015 - 09:40

Lea otras preguntas en las etiquetas