Cada vez que instalo un nuevo kernel de Linux, se deja en 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.

¿Ubuntu proporciona alguna forma más fácil de limpiarlos o evitar que se muestren en la lista de arranque?

16.04 y versiones más recientes de Ubuntu

sudo apt autoremove

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

11.10 y versiones más recientes de Ubuntu

GRUB2 y su visualización de todos los núcleos

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

Si no ve su grub , recuerde presionar Shiftmientras arranca.

Como puede ver, solo se muestra el último núcleo.

Si selecciona la opción que se muestra (presione Enter), todos los núcleos antiguos se vuelven visibles y están disponibles para arrancar.

Cómo eliminar permanentemente núcleos más antiguos

Primer arranque con el último kernel disponible.

Hay varias formas de eliminar núcleos antiguos. Personalmente, no tocaría Computer Janitor ya que se reconoce que rompe su computadora con sus sugerencias.

sináptico

Una alternativa es Synaptic ( sudo apt install synaptic)

busque linux-image , haga clic derecho en un núcleo y elija la eliminación completa y finalmente haga clic en el botón Aplicar para eliminar el núcleo.

Repita la búsqueda, pero esta vez para el encabezado de Linux : puede eliminar los encabezados asociados para la imagen del núcleo elegida anteriormente.

Sin embargo, Synaptic no intentará verificar lo que está tratando de eliminar ... podría eliminar accidentalmente su núcleo más reciente, ¡o incluso eliminar todos sus núcleos a través de esta herramienta, dejándolo con un Ubuntu no arrancable !

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

uname -r

El resultado sería similar a:

Recuerde el resultado y el número: asegúrese de no eliminar la imagen o el encabezado correspondiente.

Recomendación

Mi recomendación es mantener al menos dos o preferiblemente tres núcleos, incluido el último. La razón de la recomendación es que tendrá al menos uno / dos núcleos más para iniciar, si por alguna razón el último núcleo no puede iniciar o introducir una capacidad regresiva, como una conexión inalámbrica rota.

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

uname -r 

¡NO QUITE ESTE KERNEL!

Luego, escriba el comando a continuación para ver / enumerar todos los núcleos instalados en su sistema.

dpkg --list 'linux-image-*'

Encuentre todos los núcleos que sean inferiores a su núcleo actual. Cuando sepa qué núcleo eliminar, continúe a continuación para eliminarlo. Ejecute los siguientes comandos para eliminar el núcleo que seleccionó.

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

Finalmente, ejecute los siguientes comandos para actualizar grub2

sudo update-grub2 

Reinicie su sistema.

Mi línea para eliminar núcleos antiguos (esto también libera espacio en disco)

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

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

• dpkg --list enumera todos los paquetes instalados
• grep linux-image busca las imágenes de Linux instaladas
• awk '{ print $2 }' solo muestra la segunda columna (que es el nombre del paquete)
• sort -V pone los artículos en 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 granos encontrados

Desenrollar la sedinvocación:

• -ndice sedque se calle
• `uname -r` genera la versión actual del kernel instalado; la incluimos en los backticks para que la salida se incluya como parte del comando (también puede ver esto como $(uname -r)
• /something/qdice detener cuando coincida con 'algo' (en este caso, algo se emite uname -r): el /sonido envolvente es una expresión regular
• p es imprimir
• el ;es el comando separador, por lo que /something/q;pdice salir cuando coincida con algo, de lo contrario imprimir

en total, sed -n '/'`uname -r`'/q;p'es imprimir las líneas hasta que coincida con el nombre del núcleo actual.

Si eres paranoico (como yo), puedes hacer la última parte xargs echo sudo apt-get -y purgepara que se imprima el comando para purgar los núcleos antiguos, luego puedes comprobar que no se incluye nada inesperado antes de ejecutarlo.

Versión modificada para eliminar encabezados:

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: sedse modifica la invocación. "$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)/\1/")"extrae solo la versión (por ejemplo, "3.2.0-44"), sin "-generic" o similar deuname -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 $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 y a continuación:

Creo 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 núcleos adicionales que se mantienen:

sudo purge-old-kernels --keep 3

Eliminar entradas de Grub 2 Las entradas deben eliminarse 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 granos?

• Si no está seguro del núcleo que está utilizando actualmente, en un terminal escriba uname -r .

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

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

• Instalar el ajuste de ubuntu

• Ubuntu-Tweak estará disponible en Aplicaciones> Herramientas del sistema.

Eliminar entradas de kernel antiguas

• Seleccione "Package Cleaner" a la izquierda y "Clean Kernel" en el panel derecho.

• Presiona el botón "Desbloquear" en la esquina inferior derecha, ingresa tu contraseña.

• Seleccione de la lista que se muestra 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 "Limpiar" en la esquina inferior derecha para eliminar las imágenes y los encabezados seleccionados del núcleo.

Eliminar sistemas operativos del menú Grub

• Otros sistemas operativos que se hayan 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

• Ejecute 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

Elimina Memtest86 + del menú 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 kernel, se agrega una nueva entrada al menú de GRUB. Puede eliminar la anterior si lo desea. Sin embargo, los usuarios más experimentados le aconsejarán que mantenga al menos una entrada de repuesto en caso de que algo salga mal con una actualización y usted necesita iniciar una versión anterior del kernel para solucionar problemas.

Forma alternativa de eliminar las entradas de Kernel (anteriores a 10.04)

para GRUB no GRUB2

startupmanager

Puedes encontrarlo en Sistema >> Administración >>

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

Simplemente línea de comando, esto eliminará todo 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-" $0 " linux-headers-" $0}' )
if [ -n "$OLD" ]; then
    apt-get -qy remove --purge $OLD
fi
apt-get -qy autoremove --purge

Actualización: purge-old-kernelsestá en desuso hoy en día.

Hice un script para purgar núcleos incluso en condiciones difíciles. Se llama linux-purgey puede encontrarlo aquí .

Si solo desea purgar los núcleos (y los paquetes relacionados) que son más antiguos que el núcleo utilizado actualmente, cuando el sistema no está dañado, puede usar este script .

También hay una página de documentación de Ubuntu a la que he contribuido con respecto a la eliminación de núcleos antiguos aquí .

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

Debe 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 núcleos.

También elimine o comente la línea

"^linux-image.*"; 

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

La forma más rápida / 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 del kernel que no están en uso (excepto la anterior que no está utilizando. 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 antiguas, tomará un tiempo ya que debe asegurarse de que eliminar la versión del kernel no tenga problemas. Para mí, eliminar las últimas 12 versiones del kernel me llevó unos 2 minutos. También puede hacer lo siguiente:

sudo apt-get clean

Lo que eliminará todo lo descargado y almacenado en la carpeta de caché de apt. Por último tienes:

sudo apt-get autoremove

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

10.04 Método GUI

Computer Janitor puede limpiar los núcleos antiguos y creo que está instalado por defecto en Ubuntu (pero no en Kubuntu).

GRUB 1, si está usando eso, tiene una opción /boot/grub/menu.lstpara especificar cuántos núcleos debe mostrar como máximo. GRUB 2, por lo que puedo decir, no lo hace.

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

dpkg -l | grep linux-image

dpkg -l | grep linux-headers

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

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

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

Los siguientes reclamos para eliminar todos los núcleos y encabezados no 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

(usar apt-get -ypara eliminar sin preguntas)

Esto es lo que sucede cuando se ejecuta en 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 eliminar los núcleos de imágenes de Linux más antiguos, primero inicie en el núcleo que desea mantener.

También puede verificar la versión del kernel usando el comando uname -rpara no eliminar la incorrecta por error.

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

Ahora, cuando reinicie, verá un menú de grub más limpio.

Puede instalar ubuntu-tweak y luego ir a Aplicaciones -> Herramienta del sistema -> ubuntu tweak y

haga clic en limpiador de paquetes y limpie los granos. no muestra el núcleo utilizado actualmente, por lo que siempre estará seguro.

Personalmente, me gusta usar Synaptic. Me hace sentir más seguro sobre lo que está sucediendo. La única aplicación que he usado que tiene una opción para eliminar núcleos antiguos es Ubuntu Tweak .

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

• Abrir UbuntuTweak
• Haga clic en 'Package Cleaner' debajo de 'Aplicaciones' en el panel izquierdo
• En el lado derecho de la 'vista de limpieza', presione 'Limpiar núcleos'
• Seleccione todos los núcleos: creo que el que está en uso no aparece en la lista, pero solo en caso de que la verificación se ejecute uname -aen un terminal

Puede desinstalar los núcleos ( linux-image-...paquetes) antiguos usando Synaptic, y eso los eliminará del menú de arranque. 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 ayudarlo a solucionar problemas, en caso de que algo salga 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 modeopciones, no lo haga. Pueden ser útiles si rompe algo que le impide arrancar.

Consulte esta página.

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

Primero genere una lista de todas las versiones de 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))

Alternativamente, genere una lista de todas las versiones de kernel instaladas, 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)

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

Si está satisfecho con los resultados, puede usar apt-getpara 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 --yesparámetro:

sudo apt-get --yes purge $(
  ...)

La ventaja de esta respuesta es que Ubuntu Bash nativo se usa sin instalar aplicaciones de terceros. Usuarios de núcleos personalizados que no usaron apto dpkgpueden cambiar este script bash para satisfacer sus necesidades. Esta respuesta se basa en ( Cómo purgar selectivamente los núcleos antiguos de una vez ).

Solución basada en Zenity

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

Como el título indica que el núcleo actual con el que arrancó no se puede eliminar y no se incluye en la lista. El tamaño informado es cuánto se guardará en el /bootdirectorio. 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 con el statcomando En mi sistema, esa fecha se "toca" cada vez que se inicia el kernel usando este script de reinicio cron ( ¿Cómo saber cuándo se arrancó por última vez una versión específica del kernel? ) . Sin embargo, en su sistema, la fecha será la fecha de lanzamiento del kernel, no la última vez que lo inició.

apt-get purge te da la oportunidad de abortar

Se le da una oportunidad final para ver todo lo que se purgará y ver el espacio total en 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

Copie este código en un archivo ejecutable nombrado rm-kernelsen /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: Necesita permiso de sudo para crear el archivo, así que use:

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

Para hacer que el archivo sea ejecutable use:

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

Versión del servidor

rm-kernels-serveres la versión del servidor para eliminar selectivamente los núcleos de una vez. En lugar de un cuadro de diálogo GUI (gráfico), se utiliza un cuadro de diálogo basado en texto para seleccionar los núcleos a purgar.

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

  sudo apt install dialog

El cuadro de diálogo se encuentra en la instalación predeterminada de Ubuntu Desktop pero no en Ubuntu Server.

Pantalla de muestra

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: En la llamada a dialogla directiva --ascii-linesse pasa para reemplazar el juego de caracteres extendido de dibujo de línea (que sshno le gusta) con "+ ----- +" para los cuadros de dibujo. Si no te gusta esta apariencia, puedes usar la --no-linesdirectiva para ninguna caja.

28 de julio de 2017 Actualizaciones

El tamaño calculado de cada núcleo se tomó de los /boot/*kernel_version*cuales había 5 archivos con un total de ~ 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 es ahora ~ 400 MB. El código anterior para rm-kernelsy rm-kernels-serverha sido 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 los encabezados de Linux a 125 MB y la imagen de Linux a 220 MB porque dupuede ser extremadamente lento a menos que los archivos estén en caché. Para obtener el tamaño real usando dupase cualquier parámetro al script.

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

El cuadro de diálogo utilizado para mostrar la Fecha de último acceso de cada Kernel . 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 de modificación en su lugar.

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

dpkg --purge $(aptitude search ?obsolete)

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

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

La respuesta aceptada que usa sedpara eliminar los núcleos más antiguos de forma permanente tiene algunos defectos, si alguien no ha reiniciado la computadora después de actualizar el núcleo, el comando también eliminará el núcleo más nuevo.

Aquí hay una solución alternativa que considerará todas las situaciones para eliminar solo los núcleos antiguos 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 una versión más nueva que la actual, esto le dará una advertencia para reiniciar su computadora primero. También tenga en cuenta que los núcleos más antiguos se conservan debido a una buena razón: si de alguna manera arruina su núcleo actual haciendo que su sistema sea inestable, entonces debería poder iniciar en cualquier núcleo más antiguo.

ailurus tiene la función de eliminar núcleos antiguos y configuraciones no utilizadas. Personalmente lo elimino manualmente de synaptic. Puede instalar ailurus desde getdeb y ppa

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

Puede usar ukuu, todo es GUI, para actualizar y eliminar Kernels antiguos. ¡Funciona para mi!

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

También puede configurar ukuu para que solo muestre versiones principales, incluso núcleos RC, versiones de punto oculto.

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

Instrucciones de instalación de OMG! Ubuntu ukuu

Basado en 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 $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

(usar apt-get -ypara eliminar sin preguntas)

Aquí hay un resumen de lo que hice, cuidado ya que no soy un experto en Linux, asegúrese de saber lo que está haciendo y de haber 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 detendrá la forma automática de agregar todas las entradas de linux en el menú de arranque de grub.

gksudo gedit 40_custom

abra el archivo del 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 40_customy luego guárdelos.

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 le permitirá personalizar el menú de arranque un poco más, como eliminar la versión del kernel y simplemente poner el nombre de ubuntu ... es decir, Ubuntu Lucid 10.04, etc.

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

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

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

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

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

Prueba esto. Ejecútelo como root.

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

Pase, como argumento de línea de comando, el número de núcleos más recientes que desea conservar.

    
#! / bin / bash

# pase n como argumento de línea de comando, y encontrará todos los archivos instalados
# núcleos y conserve solo los n más recientes => desinstale todos los más antiguos

# dpkg -l 'linux- *' | sed '/ ^ ii /! d; /' "$ (uname -r | sed" s /\(.*\)-\([^ 0-9] \ + \) / \ 1 / ")" '/ d; s / ^ [^] * [^] * \ ([^] * \). * / \ 1 /; / [0-9] /! d '
# este comando proporciona la lista de todos los paquetes, EXCEPTO para el último kernel.
# fuente: https://help.ubuntu.com/community/Lubuntu/Documentation/RemoveOldKernels

n = $ 1

# encontrar las versiones de kernel instaladas:
# dpkg-query -W -f = '$ {Versión} \ n' 'linux-image- *' | grep. El | ordenar -n
# da números de versión, uno en cada línea
# dpkg-query -W -f = '$ {Versión} \ n' 'linux-image- *' | grep. El | sed 's /\...$// g' | grep -v '\ ... $' | ordenar -u
# da solo los que aparecen en linux-image

# sufijo, por ejemplo, -eneric-pae
# el tipo de kernel en el que arrancas
sufijo = $ (uname -r | sed 's: ^ [0-9] \. [0-9] \. [0-9] \ - [0-9] \ {2 \} :: g')

comando = "apt-get purge"

para la versión en $ (dpkg-query -W -f = '$ {Version} \ n' 'linux-image- *' | grep. | sed 's /\...$// g' | grep -v ' \ ... $ '| sort -u | head -n - $ {n})
hacer
    comando = $ {comando} "^ linux-image - $ {versión} $ {sufijo}"
hecho

$ comando

Uso de la muestra:

# ./keep-n-kernels.sh 4 # inicie el comando apt-get para eliminar todos menos los 4 núcleos más recientes

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

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í: https://www.kubuntuforums.net/showthread.php?58075-remove-old-linux-versions (que ya había instalado para configurar la imagen de fondo, la opción de arranque 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, se presenta una lista de todos los núcleos instalados y puede seleccionar cuáles eliminar. Cuando aplique los cambios, usará dpkg para eliminarlos del sistema, así como el menú GRUB.

Solo para intervenir, también puedes emitir

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

como root, y el trabajo estará hecho.

Si está utilizando ansible para controlar las máquinas, este libro de jugadas puede 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