wake-up-neo.net

Come rimuovo le vecchie versioni del kernel per ripulire il menu di avvio?

Ogni volta che installo un nuovo kernel Linux, questo viene lasciato in grub_config, rendendo ogni volta il menu di avvio più lungo.

So di poter cercare manualmente tra i pacchetti installati e rimuoverli.

Ubuntu offre un modo più semplice per ripulirli o impedire loro di essere visualizzati nell'elenco di avvio?

698
ImaginaryRobots

16.04 e versioni più recenti di Ubuntu

Sudo apt autoremove

Questo comando rimuove i pacchetti che sono stati installati automaticamente per risolvere una dipendenza, ma che ora non dipendono più. Ciò include le vecchie versioni di linux-headers-* e linux-image-*. (È anche intelligente in questo processo, lasciando una versione di riserva del kernel come fallback!)

11.10 e versioni più recenti di Ubuntu

GRUB2 e il suo display di tutti i kernel

Le ultime versioni di Grub2 installato in Ubuntu visualizzano automaticamente l'ultimo kernel e nasconde i kernel più vecchi che potresti aver installato.

GNU GRUB

Se non vedi il tuo grub - ricorda di premere Shift durante l'avvio.

Come puoi vedere, viene visualizzato solo l'ultimo kernel.

Se si seleziona l'opzione visualizzata (premere Enter) quindi tutti i vecchi kernel diventano visibili e disponibili per l'avvio.

GNU GRUB Previous versions

Come eliminare definitivamente i kernel più vecchi

Primo avvio con l'ultimo kernel disponibile.

Esistono diversi modi per eliminare i vecchi kernel. Personalmente, non toccherei Computer Janitor poiché si riconosce che questo rompe il tuo computer con i suoi suggerimenti.

sinaptica

Un'alternativa è Synaptic (Sudo apt install synaptic)

cerca linux-image , fai clic con il pulsante destro del mouse su un kernel e scegli la rimozione completa e infine fai clic su Applica per eliminare il kernel.

Synaptic Package Manager

Ripeti la ricerca ma questa volta per linux-header - puoi eliminare le intestazioni associate per l'immagine del kernel scelta in precedenza.

Synaptic anche se non tenterà di verificare ciò che stai cercando di rimuovere ... potresti inavvertitamente eliminare il tuo nuovo kernel - o persino eliminare tutti i tuoi kernel tramite questo strumento ti lascia con un Ubuntu Ubuntu !.

Ricorda di controllare quale kernel stai usando:

uname -r

Il risultato sarebbe simile a:

Terminal <uname -r>

Ricorda il risultato e il numero: assicurati di non eliminare l'immagine o l'intestazione corrispondenti.

Raccomandazione

La mia raccomandazione è di mantenere almeno due o preferibilmente tre kernel, incluso l'ultimo. Il motivo della raccomandazione è che avrai almeno uno/due altri kernel con cui avviare, se per qualsiasi motivo l'ultimo kernel con cui non riesci ad avviare o introducendo una funzionalità regredita come il wireless interrotto.

600
fossfreedom

Innanzitutto, riavviare il sistema per assicurarsi che stia utilizzando l'ultimo kernel. Quindi apri il terminale e controlla il tuo kernel corrente:

uname -r 

NON RIMUOVERE QUESTO KERNEL!

Quindi, digita il comando seguente per visualizzare/elencare tutti i kernel installati sul tuo sistema.

dpkg --list 'linux-image-*'

Trova tutti i kernel inferiori al kernel corrente. Quando sai quale kernel rimuovere, continua sotto per rimuoverlo. Eseguire i comandi seguenti per rimuovere il kernel selezionato.

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

Infine, esegui i comandi seguenti per aggiornare grub2

Sudo update-grub2 

Riavvia il tuo sistema.

382
penreturns

Il mio one-liner per rimuovere i vecchi kernel (questo libera anche spazio su disco)

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

Spiegazione (ricordare, | utilizza l'output del comando precedente come input per il successivo)

  • dpkg --list elenca tutti i pacchetti installati
  • grep linux-image cerca le immagini di linux installate
  • awk '{ print $2 }' genera solo la seconda colonna (che è il nome del pacchetto)
  • sort -V ordina gli articoli in base al numero di versione
  • sed -n '/'`uname -r`'/q;p' stampa le righe prima del kernel corrente
  • xargs Sudo apt-get -y purge elimina i kernel trovati

Svolgi l'invocazione sed:

  • -n dice a sed di essere silenzioso
  • `uname -r` genera l'attuale versione del kernel installata - la includiamo nei backtick in modo che l'output sia incluso come parte del comando (potresti anche vederlo come $(uname -r)
  • /something/q dice stop quando si abbina 'qualcosa' (in questo caso, viene emesso qualcosa di uname -r) - il / racchiude un'espressione regolare
  • p è stampato
  • ; è il comando separtor, quindi /something/q;p dice quit quando abbini qualcosa, altrimenti stampa

nel complesso, sed -n '/'`uname -r`'/q;p' stampa le righe finché non corrisponde al nome del kernel corrente.

Se sei paranoico (come me), puoi creare l'ultima parte xargs echo Sudo apt-get -y purge in modo che venga stampato il comando per eliminare i vecchi kernel, quindi puoi verificare che non sia incluso nulla di inaspettato prima di eseguirlo.


Versione modificata per rimuovere le intestazioni:

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: l'invocazione sed è stata modificata. "$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)/\1/")" estrae solo la versione (ad es. "3.2.0-44"), senza "-generic" o simile a uname -r


Versione all-in-one per rimuovere immagini e intestazioni (combina le due versioni precedenti):

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
283
David Kemp

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 precedenti:

Trovo che questo sia il modo più semplice e veloce. Mantiene l'ultimo kernel e altri due:

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

Per modificare il numero di kernel aggiuntivi che vengono conservati:

Sudo purge-old-kernels --keep 3
60
bmaupin

Rimozione di voci da Grub 2 Le voci devono essere rimosse modificando o rimuovendo i file nella cartella /etc/grub.d. Il file /boot/grub/grub.cfg è di sola lettura e non dovrebbe normalmente richiedere modifiche.

Troppi kernel?

  • Se non si è sicuri del kernel attualmente in uso, in un tipo di terminale uname -r .

  • I kernel rimossi tramite APT (Synaptic, "apt-get remove", ecc.) Aggiorneranno automaticamente grub.cfg e non è richiesta alcuna azione da parte dell'utente.

  • Un ottimo strumento per rimuovere kernel (e voci di menu) è Ubuntu-Tweak, un'app GUI sicura e facile da usare.

  • Installa Ubuntu Tweak

  • Ubuntu-Tweak sarà disponibile in Applicazioni> Strumenti di sistema.

Rimuovi voci kernel precedenti

  • Seleziona "Pulizia pacchetto" a sinistra e "Pulizia kernel" dal pannello a destra.

  • Premi il pulsante "Sblocca" in basso a destra, inserisci la tua password.

  • Selezionare dall'elenco visualizzato le immagini del kernel e le intestazioni che si desidera rimuovere. Il kernel in uso non è elencato.

  • Premi il pulsante "Pulizia" in basso a destra per rimuovere le immagini e le intestazioni del kernel selezionate.

Rimuovi i sistemi operativi dal menu di Grub

  • Altri sistemi operativi che sono stati rimossi dal computer verranno rimossi dal menu una volta eseguito "update-grub" come root.

  • Le voci di menu vengono posizionate nel menu Grub2 mediante script. Se non si desidera inserire altri sistemi operativi nel menu, disabilitare /etc/grub.d/30_osprober

  • Esegui questo comando per interrompere l'esecuzione dello script
    Sudo chmod -x /etc/grub.d/30_os-prober

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

Rimuovi Memtest86 + dal menu di Grub
Sudo chmod -x /etc/grub.d/20_memtest86+

  • Eseguire il comando update-grub per consentire l'incorporamento delle modifiche in grub.cfg

Source

Nota: Dopo gli aggiornamenti del kernel, una nuova voce viene aggiunta al menu GRUB. Se lo desideri, puoi rimuovere quella precedente. , gli utenti più esperti ti consiglieranno di conservare almeno una voce di riserva nel caso in cui qualcosa vada storto con un aggiornamento e devi avviare una versione del kernel precedente per la risoluzione dei problemi.

Modo alternativo per rimuovere le voci del kernel (prima del 10.04)

per GRUB non GRUB2

startupmanagerInstall startupmanager

Puoi trovarlo in Sistema >> Amministrazione >> alt text
alt text
Vedi nel secondo screenshot puoi selezionare quanti kernel mostrare? In genere lo mantengo solo su 1, ma quando ottengo un aggiornamento del kernel lo cambio sempre su 2 prima di riavviare in modo da poter selezionare il kernel più vecchio se il nuovo kernel ha problemi con il mio hardware. Una volta che so che il nuovo kernel funziona bene, lo cambio di nuovo a 1.

43
karthick87

Puramente a riga di comando, questo rimuoverà tutto tranne l'attuale e il secondo più attuale (tramite "-2" nel comando head in basso):

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
39
Kees Cook

Aggiornamento: purge-old-kernels è obsoleto al giorno d'oggi.

Ho realizzato una sceneggiatura per eliminare i kernel anche in condizioni difficili. Si chiama linux-purge e puoi trovarlo qui .

Se vuoi solo eliminare i kernel (e i relativi pacchetti) che sono più vecchi del kernel attualmente utilizzato, quando il sistema non è rotto, puoi usare questo script .

C'è anche una pagina di documentazione di Ubuntu che ho contribuito a rimuovere vecchi kernel qui .

34
jarno

È possibile seguire l'articolo utilizzando la sezione del pacchetto "aggiornamenti automatici" di Aggiornamenti automatici di sicurezza su Ubuntu Wiki per eseguire questa operazione.

È necessario modificare la seguente riga nel file /etc/apt/apt.conf.d/50unattended-upgrades ;

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

con

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

per rimuovere automaticamente i vecchi pacchetti, inclusi i kernel.

Rimuovi o commenta anche la riga

"^linux-image.*"; 

nella sezione "NeverAutoRemove" del file /etc/apt/apt.conf.d/01autoremove.

29
Qwerty

Il modo più rapido/semplice (applicabile almeno dal 12.04) possibile che già viene fornito con Ubuntu è apt-get. Se si desidera rimuovere tutte le versioni del kernel precedenti che non sono in uso, attenersi alla seguente procedura (ad eccezione di quella precedente che non si utilizza. In questo modo è possibile assicurarsi che se la versione del kernel corrente non riesce in qualche modo, è necessario procedere tornare a uno stato precedente). Fai quanto segue:

Sudo apt-get autoclean

Questo eliminerà tutti i vecchi file (comprese le versioni del kernel) che potresti avere. Nota che se hai molte vecchie versioni, ci vorrà un po 'di tempo poiché deve assicurarsi che la rimozione della versione del kernel non abbia problemi. Per me, la rimozione delle ultime 12 versioni del kernel ha richiesto circa 2 minuti. Puoi anche fare quanto segue:

Sudo apt-get clean

Ciò eliminerà tutto ciò che è stato scaricato e archiviato nella cartella cache di apt. Infine hai:

Sudo apt-get autoremove

che verificherebbe eventuali pacchetti non utilizzati e li rimuoverà se necessario. Questo è ottimo per quelle librerie e pacchetti di dipendenze che non sono più necessari a nessuna app installata.

27
Luis Alvarado

Per capire quali kernel e header sono installati usare

dpkg -l | grep linux-image

dpkg -l | grep linux-headers

Puoi quindi rimuoverli uno per uno o insieme, assicurati di mantenere il più recente.

Ci sono anche alcuni comandi e script utili per automatizzare la rimozione.

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

Le seguenti affermazioni per rimuovere tutti i kernel e le intestazioni inutilizzati:

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

(usa apt-get -y per rimuovere senza dubbio)

Ecco cosa succede quando eseguito il 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
25
mikewhatever

10.04 Metodo GUI

Computer Janitor può ripulire i vecchi kernel e credo che sia installato di default in Ubuntu (ma non in Kubuntu).

GRUB 1, se lo stai usando, ha un'opzione in /boot/grub/menu.lst per specificare quanti kernel dovrebbe mostrare al massimo. GRUB 2, per quanto ne so, non lo fa.

25
maco

Per rimuovere i kernel di immagini Linux meno recenti, eseguire prima l'avvio nel kernel che si desidera conservare.

Puoi anche controllare la versione del kernel usando il comando uname -r in modo da non rimuovere quella sbagliata per errore.

Ora vai al gestore di pacchetti sinaptici e cerca linux-image e rimuovi le versioni precedenti tranne quella mostrata dal comando superiore. In genere preferisco andare con l'ultimo.

Ora al riavvio vedrai un menu di grub più pulito.

16
anurag-jain

È possibile installare buntu-Tweak e quindi Vai a Applicazioni -> Strumento di sistema -> Ubuntu Tweak e

enter image description here fare clic su pacchetto detergente e kernel pulito. non mostra il kernel attualmente utilizzato, quindi sarai sempre al sicuro.

14
Lincity

Personalmente, mi piace usare Synaptic. Mi fa sentire più sicuro di ciò che sta succedendo. L'unica app che ho usato che ha un'opzione per rimuovere i vecchi kernel è buntu Tweak .

Come rimuovere i kernel che non stai utilizzando:

  • Apri UbuntuTweak
  • Fai clic su "Pulizia pacchetto" in "Applicazioni" nel riquadro di sinistra
  • Sul lato destro della "vista di pulizia" premi "Pulisci kernel"
  • Seleziona tutti i kernel - Penso che quello in uso non sia elencato ma, nel caso, controlla di eseguire uname -a in un terminale
8
Alan Featherston

Puoi disinstallare i vecchi kernel (pacchetti linux-image-...) usando Synaptic e ciò li rimuoverà dal menu di avvio. Fai attenzione a non rimuovere il kernel in esecuzione (puoi controllarne la versione con uname -r).

Tieni presente che avere una o due versioni precedenti può aiutarti a risolvere i problemi, se qualcosa dovesse andare storto.

In alternativa, è possibile modificare/rimuovere manualmente le voci (gksu gedit /boot/grub/grub.cfg), ma verranno rigenerate quando si aggiorna a un kernel più recente. Se stai pensando di rimuovere recovery mode opzioni, non farlo. Possono tornare utili se rompi qualcosa che ti impedisce l'avvio.


Fare riferimento a questa pagina.

6
evgeny

Questa è una pura soluzione da riga di comando.

Innanzitutto genera un elenco di tutte le versioni del kernel installate ad eccezione del kernel attualmente in esecuzione:

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

In alternativa, genera un elenco di tutte le versioni del kernel installate tranne le ultime due:

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

Esamina l'elenco. Assicurarsi che le versioni del kernel che si desidera conservare non facciano parte dell'elenco. Utilizzare il comando uname -r per visualizzare la versione del kernel attualmente in esecuzione.

Se sei soddisfatto dei risultati, puoi utilizzare apt-get per rimuovere i pacchetti.

Prima una corsa a secco (usando il primo generatore come esempio):

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

Quindi una vera corsa:

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 si desidera automatizzare il processo, aggiungere il parametro --yes:

Sudo apt-get --yes purge $(
  ...)
4
lesmana

Il vantaggio di questa risposta è che Ubuntu Bash nativo viene utilizzato senza installare applicazioni di terze parti. Gli utenti di kernel personalizzati che non hanno utilizzato apt o dpkg possono modificare questo script bash in base alle proprie esigenze. Questa risposta si basa su ( Come eliminare in modo selettivo i vecchi kernel contemporaneamente ).

Soluzione basata sullo Zenity

Zenity fornisce un'interfaccia grafica piacevole al terminale per elaborare un elenco e selezionare gli elementi con pulsanti di opzione :

rm-kernels 1

Poiché il titolo indica che il kernel corrente con cui hai avviato non può essere rimosso e non è incluso nell'elenco. La dimensione indicata è la quantità che verrà salvata nella directory /boot. Altro viene salvato sul disco perché i binari del kernel risiedono anche in altre aree. 27 luglio 2017 note: Sono ora incluse anche le directory /usr/src/*kernel_version* e /lib/modules/*kernel_version*.

La Data modificata viene rilevata utilizzando il comando stat. Nel mio sistema quella data è "toccata" ogni volta che il kernel viene avviato usando questo ( Come si fa a sapere quando è stata avviata l'ultima versione del kernel? =) cron script di riavvio. Tuttavia, sul tuo sistema la data sarà la data di rilascio del kernel, non l'ultima volta che l'hai avviata.

apt-get purge ti dà la possibilità di interrompere

Ti viene data un'ultima opportunità per visualizzare tutto ciò che verrà eliminato e vedere lo spazio su disco totale (in qualche modo fuorviante) che verrà recuperato:

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] 

Il codice

Copia questo codice in un file eseguibile chiamato 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: È necessaria l'autorizzazione Sudo per creare il file, quindi utilizzare:

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

Per rendere eseguibile il file utilizzare:

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

Versione del server

rm-kernels-server è la versione del server per eliminare selettivamente i kernel contemporaneamente. Invece di una finestra di dialogo GUI (grafica), viene utilizzata una finestra di dialogo basata su testo per selezionare i kernel da eliminare.

  • Prima di eseguire lo script è necessario installare la funzione di dialogo utilizzando:

    Sudo apt install dialog

La finestra di dialogo si trova nell'installazione predefinita di Ubuntu Desktop ma non in Ubuntu Server.

Schermata di esempio

rm-kernels-server 1

rm-kernels-server codice 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: Nella chiamata a dialog viene passata la direttiva --ascii-lines per sostituire il set di caratteri estesi del disegno di linea (che a ssh non piace) con "+ ----- +" per disegnare caselle. Se non ti piace questo aspetto, puoi usare la direttiva --no-lines per nessuna casella.


Aggiornamenti del 28 luglio 2017

La dimensione calcolata di ciascun kernel è stata presa da /boot/*kernel_version* che erano 5 file per un totale di ~ 50 MB. La formula è stata modificata per includere i file in /usr/src/*kernel_version* e /lib/modules/*kernel_version*. La dimensione calcolata per ciascun kernel è ora ~ 400 MB. Il codice precedente per rm-kernels e rm-kernels-server è stato aggiornato. Tuttavia, le schermate di esempio sopra non riflettono ancora queste modifiche.

L'impostazione predefinita è stimare la dimensione dei file per le intestazioni di Linux a 125 MB e l'immagine di Linux a 220 MB perché du può essere dolorosamente lento a meno che i file non siano nella cache. Per ottenere la dimensione reale utilizzando du, passare qualsiasi parametro allo script.

Il totale di tutte le dimensioni del kernel (esclusa l'attuale versione in esecuzione che non può essere rimossa) è ora mostrato nella barra del titolo.

La finestra di dialogo utilizzata per visualizzare la data di ultimo accesso di ciascun kernel . Questa data può essere sovrascritta in massa per tutti i kernel durante il backup o operazioni simili. La finestra di dialogo ora mostra invece Data modificata .

4
WinEunuuchs2Unix

La risposta accettata utilizzando sed per rimuovere i kernel più vecchi in modo permanente presenta alcuni difetti, se qualcuno non ha riavviato il computer dopo aver aggiornato il kernel il comando rimuoverà anche il kernel più recente.

Ecco una soluzione alternativa che prenderà in considerazione tutte le situazioni per rimuovere solo i kernel più vecchi:

#!/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 si dispone di una versione più recente di quella corrente, verrà visualizzato un avviso per riavviare prima il computer. Si noti inoltre che i kernel più vecchi vengono conservati a causa di una buona ragione che è se in qualche modo si confonde il kernel corrente rendendo il sistema instabile, quindi si dovrebbe essere in grado di avviare qualsiasi kernel più vecchio.

2
heemayl

Un modo semplice per sbarazzarsi di quasi tutti i pacchetti obsoleti, i pacchetti non più in alcun elenco di pacchetti, insieme ai kernel obsoleti è quello di effettuare una delle seguenti operazioni:

dpkg --purge $(aptitude search ?obsolete)

Tuttavia, questo mancherà i pacchetti che sono ancora raccomandati da altri pacchetti e l'argomento -R/- senza-raccomandazione non risolve questo problema.

dselect dopo aver cambiato la modalità di ordinamento con 'o' mostrerà tutti i pacchetti obsoleti inclusi quelli che mancano a aptitude, ma ad alcune persone non piace usarlo.

2
Chris Cheney

Ho una sceneggiatura per questo che non ha bisogno di un parsing molto elaborato.

Rimuovi le intestazioni e le immagini tranne quella corrente per liberare spazio

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)+
1
Paulo Santos

ailurus ha la funzione di rimuovere vecchi kernel e configurazioni inutilizzate. Lo rimuovo personalmente da Synaptic. È possibile installare ailurus da getdeb e ppa

1
sagarchalise

Basato su una risposta precedente di David Kemp, il seguente script eliminerà tutte le intestazioni e le immagini tranne le versioni ltime 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]\+\).*/\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

(usa apt-get -y per rimuovere senza dubbio)

1
Mark

Puoi usare ukuu - è tutta la GUI - per aggiornare ed eliminare i vecchi kernel. Per me va bene!

Basta ricordare di lasciare gli ultimi 2 installati e ovviamente il kernel 'in esecuzione'.

Puoi anche impostare ukuu per mostrare solo le versioni mainline, anche i kernel RC, le versioni point nascoste.

ukuu

Puoi trovare ukuu in Synaptic o le istruzioni sono qui:

Istruzioni per l'installazione di OMG! Ubuntu uk

1
sprocketoctopus

Dò due varianti più sicure dei metodi in altre risposte: uno usando synaptic manager e l'altro usando terminal .

Con queste variazioni rimuovi solo i pacchetti che il sistema identifica come rimovibili. Non vi è alcun rischio di rimuovere i kernel Linux attualmente utilizzati, come è successo a me alcune settimane fa ;

Utilizzando Synaptic Manager

Invece di cercare linux-image su tutti i pacchetti installati, selezionare i pacchetti rimovibili (Vedi rosso ellisse nella foto sotto). Ora da questo elenco rimuovi l'immagine linux che desideri.

--- (enter image description here

Utilizzando il terminale

Allo stesso modo, se stai rimuovendo i kernel sul terminale, mostra solo i kernel rimovibili eseguendo

 Sudo apt-get -s autoremove | grep linux-image

Quindi rimuovere qualsiasi kernel linux-image-x.x.x-x-generic che si desidera rimuovere dall'elenco indicato eseguendolo

 Sudo apt-get purge linux-image-x.x.x-x-generic 
0
loved.by.Jesus

Uso unattended-upgrades quindi mi è davvero piaciuto Qwerty's answer che lo configura per disinstallare automaticamente i vecchi pacchetti del kernel.

Tuttavia c'era un problema: dopo l'installazione di un nuovo kernel, questo processo avrebbe disinstallato il pacchetto per il kernel attualmente in esecuzione!

Ciò non rompe del tutto il sistema operativo. In effetti raramente ho notato che era successo, fino a quando non ho dovuto caricare a caldo un modulo (ad esempio collegando un dispositivo USB) e quindi non è stato possibile trovare il modulo.

Come soluzione a questo, ho creato uno script per generare un pacchetto virtuale currently-installed-kernel che blocca effettivamente il pacchetto kernel corrente fino all'avvio successivo.

Lo script si chiama pin-current-kernel-with-package.sh. Ecco ltima versione (probabilmente) e prima versione (sicuramente).

Basta salvare lo script da qualche parte e aggiungerlo al processo di avvio . Ad esempio, salvarlo in /root/bit/pin-current-kernel-with-package.sh e quindi modificare /etc/rc.local e aggiungere la seguente riga:

bash /root/bin/pin-current-kernel-with-package.sh

Ora il pacchetto del kernel in esecuzione non verrà mai disinstallato!

0
joeytwiddle

Se stai usando ansible per controllare le macchine, questo playbook potrebbe essere utile.

---
 - 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
0
flickerfly

La prossima volta, quando rimuovi i vecchi kernel, apri un Terminale e usa questo comando:

Sudo apt-get autoremove linux-headers-2.6.38-10-generic

È possibile utilizzare Synaptic per ottenere il nome esatto del kernel che si intende eliminare. Basta aprire Synaptic e cercare "linux-headers", quindi selezionare la voce del kernel che si desidera rimuovere. La voce pertinente verrà contrassegnata con "-generic" alla fine.

Per eliminare eventuali dipendenze non utilizzate (rimaste) in tutto il sistema, utilizzare questo comando da solo:

Sudo apt-get autoremove
0
Chad--24216

Sto usando un desktop KDE e l'opzione più semplice che ho trovato è stata usare l'applicazione kde-config-grub2 come suggerito qui: https://www.kubuntuforums.net/showthread.php?58075-remove-old -linux-version (che avevo già installato per impostare l'immagine di sfondo, l'opzione di avvio predefinita e simili). Accanto alla casella a discesa in cui è possibile scegliere la voce predefinita, è presente il pulsante "Rimuovi voci precedenti". Facendo clic su questo pulsante viene visualizzato un elenco di tutti i kernel installati e puoi selezionare quali rimuovere. Quando si applicano le modifiche, verrà utilizzato dpkg per rimuoverle effettivamente dal sistema, nonché dal menu GRUB.

0
Ben

La seguente stringa di comandi eliminerà qualsiasi kernel Linux installato tranne quello attualmente in esecuzione (grep -v uname -r) e l'ultimo kernel disponibile (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

Lo uso per mantenere i volumi di avvio del desktop relativamente puliti, ma in una situazione del server probabilmente vorresti espandere la logica e scrivere alcuni script aggiuntivi per mantenere un elenco degli ultimi kernel X che il server ha avviato.

Qualcosa come uno script di avvio che fa:

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

e quindi usa:

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
0

Prova questo. Eseguilo come root.

Salvare questo script come, ad esempio ./ keep-n-kernels.sh

Passa, come argomento della riga di comando, il numero dei kernel più recenti che desideri conservare.

    
 #!/bin/bash 
 
 # passa n come argomento della riga di comando e troverà tutti i kernel 
 installati e manterrà solo i n più quelli recenti => disinstalla tutti quelli più vecchi 
 
 # dpkg -l 'linux- *' | sed '/ ^ ii /! d; /' "$ (uname -r | sed" s /\(.*\)-\([^ 0-9]\+ \)/\ 1/")" '/ d; s/^ [^] * [^] *\([^] * \). */\ 1 /;/[0-9] /! d '
 # questo comando fornisce l'elenco di tutti i pacchetti TRANNE il kernel più recente. 
 # fonte: https://help.ubuntu.com/community/Lubuntu/Documentation/RemoveOldKernels[.____.×[.____.×n=$1
 
 # trova le versioni del kernel installate: 
 # dpkg-query -W -f = '$ {Version}\n' 'linux-image- *' | grep. | sort -n 
 # fornisce i numeri di versione, uno per ogni riga 
 # dpkg-query -W -f = '$ {Version}\n' 'linux-image- *' | grep. | sed 's /\...$// g' | grep -v '\ ... $' | sort -u 
 # fornisce solo quelli che appaiono nel suffisso linux-image 
 
 #, ad es. -generic-pae 
 # il tipo di kernel in cui si avvia il suffisso 
 = $ (uname -r | sed 's: ^ [0-9] \. [0-9] \. [ 0-9]\- [0-9]\{2 \} :: g ') 
 
 Command = "apt-get purge" 
 
 Per versione 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 - $ {versione} $ {suffisso} "
 fatto 
 
 $ comando 

Esempio di utilizzo:

 # ./keep-n-kernels.sh 4 # avvia il comando apt-get per rimuovere tutti tranne i 4 kernel più recenti 

Se si desidera [E AT IL PROPRIO RISCHIO], è possibile aggiungere un -y (o un flag di forza) al comando apt-get e renderlo non interattivo.

0
Sankalp

Installa synaptic package manager e vai alla scheda dei filtri (penso che i filtri, se non provi tutti e 5) e seleziona "local". Questo mostrerà i pacchetti orfani sul tuo sistema, come i kernel. Dopo averli disinstallati, eseguire update-grub. Tale comando aggiorna l'elenco delle opzioni di avvio per grub.

In caso contrario, puoi sempre provare apt-get remove linux-image-version-generic.

0
Relish

Per rimuovere i kernel che sono stati installati automaticamente tramite regolari aggiornamenti di sistema, aprire il terminale ed eseguire:

Sudo apt autoremove --purge

Per conoscere la tua attuale versione del kernel, esegui uname -r e puoi anche eseguire uname --help per leggere ulteriori informazioni su tutti i comandi uname

Puoi anche eseguire df -h per mostrarti i driver del file system, allo stesso modo puoi eseguire df --help per altro.

Per abilitare la rimozione automatica dei vecchi kernel: modifica il file di configurazione usando gksu

gksudo gedit /etc/apt/apt.conf.d/50unattended-upgrades

All'apertura del file, decommenta la seguente riga e modifica il valore in true :

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

Se devi installare gksu , puoi eseguire Sudo apt install gksu

Per cancellare i vecchi pacchetti possiamo usare Sudo apt-get clean

Per ulteriori informazioni, visitare http://ubuntuhandbook.org/index.php/2016/05/remove-old-kernels-ubuntu-16-04/

0
Abdallah Okasha

Solo per entrare, puoi anche emettere

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

come root e il lavoro sarà fatto.

0
Severo Raz

Come @ jarno e @ earcam menzionato nei loro commenti sulla domanda, si desidera innanzitutto assicurarsi che tutti i pacchetti del kernel Linux siano contrassegnati come installati automaticamente:

Sudo apt-mark auto '^linux-.*-4\.12\.0-12(-generic)?$'

Quindi il normale comando apt-get autoremove dovrebbe funzionare.

Sudo apt-get autoremove --purge

Leggi docs per maggiori dettagli.

0
hobs

ecco uno schema generale di ciò che ho fatto, attento poiché non sono un esperto di Linux, assicurati di sapere cosa stai facendo e di aver eseguito il backup di tutti i file che stai modificando.

gedit /boot/grub/grub.cfg

quindi trova le voci che desideri conservare, le evidenzeremo e le copieremo

cd /etc/grub.d
ls

vedrai un elenco di file come 10_linux e 30_os-prober

Sudo chmod -x 10_linux

questo si interromperà automaticamente aggiungendo tutte le voci di Linux nel menu di avvio di grub.

gksudo gedit 40_custom

apri il file del menu di avvio personalizzato, quindi torna a grub.cfg (che dovrebbe essere ancora aperto in gedit) e copia le voci che vuoi conservare ... come

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
}

incollali in 40_custom, quindi salvali.

Sudo chmod 755 40_custom

lo rende eseguibile, quindi finalmente aggiorniamo grub che cambierà il file grub.cfg:

Sudo update-grub

Ora, ATTENZIONE, se aggiorni il tuo kernel o sistema operativo, il tuo menu di avvio probabilmente non si aggiorna ... dovrai farlo manualmente. Ma fare questa procedura ti permetterà di personalizzare un po 'di più il menu di avvio, come rimuovere la versione del kernel e semplicemente inserire il nome ubuntu ... cioè Ubuntu Lucid 10.04, ecc ...

Spero che qualcuno lo trovi utile, dato che mi ci è voluto un po 'per capire ... non ho visto questa soluzione da nessuna parte ...

0
Joe

Piuttosto usa apt, il frontend di cli per gli umani, piuttosto che apt-get per eliminare le vecchie immagini del kernel:

$ Sudo apt autoremove --purge
...
The following packages will be REMOVED:
  linux-headers-4.4.0-51* linux-headers-4.4.0-51-generic* linux-image-4.4.0-51-generic* linux-image-extra-4.4.0-51-generic*
0
k0pernikus

Per avere un po 'più controllo sulle versioni da conservare, seleziona esplicitamente quelle che desideri rimuovere. Ad esempio, se si desidera rimuovere le versioni del kernel 3.2.0. [49-53], utilizzare un semplice ciclo for:

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

Modifica l'elenco delle versioni del kernel per adattarle.

0
NeilNjae