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


701

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

So che posso cercare manualmente tra i pacchetti installati e rimuoverli.

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


10
C'è un comando ubuntu chiamato purge-old-kernels per fare il lavoro. Vedi la mia risposta per ulteriori informazioni.
jarno,

29
sudo apt-get autoremovedovrebbe fare il trucco su Ubuntu 14.04+
piani cottura

1
L'accumulo di vecchi kernel è un bug, con correzione in corso: bugs.launchpad.net/bugs/1357093 . Quando viene rilasciata la correzione, i kernel più vecchi verranno rimossi automaticamente per impostazione predefinita.
user535733

1
@hobs Il comando non fa il trucco per me in Ubuntu Studio 14.04, se i kernel non sono stati installati automaticamente, ma tramite Software Updater.
jarno,

1
Continuo a tornare a questa pagina ... il commento di @hobs funziona solo se i tuoi kernel sono stati installati automaticamente - tuttavia fai sudo apt-get autoremove --purge la risposta seguendo i apt-markconsigli su https://help.ubuntu.com/community/RemoveOldKernels
earcam

Risposte:


602

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 installate su Ubuntu visualizzano automaticamente l'ultimo kernel e nascondono i kernel più vecchi che potresti aver installato.

GNU GRUB

Se non vedi il tuo grub - ricordati di premere Shiftdurante l'avvio.

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

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

GNU GRUB Versioni precedenti

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 l'immagine di Linux , fai clic con il pulsante destro del mouse su un kernel e scegli la rimozione completa e infine fai clic sul pulsante Applica per eliminare il kernel.

Gestore pacchetti Synaptic

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

Synaptic, tuttavia, 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 lasciandoti con un Ubuntu non avviabile !

Ricorda di controllare quale kernel stai usando:

uname -r

Il risultato sarebbe simile a:

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


3
Rimuovere i vecchi pacchetti "linux-image *" usando synaptic, ha funzionato bene anche con 10.04. (Lo
cito

4
l' -yinterruttore alla fine della apt-getlinea è necessario, altrimenti apt-get chiede solo conferma e poiché l'ingresso è una pipe, si interrompe e basta. Quindi dovrebbe concludersi tra:| xargs sudo apt-get purge -y
Josh il

37
Rimozione di circa 20 versioni di 4,5 GB di spazio libero linux-imagee vecchio linux-headerssul mio computer.
Andrew Mao,

16
Questo metodo funziona bene, ma la cancellazione di ogni kernel rigenera eccessivamente grub.cfg, il che richiede tempo. Esiste un modo per disabilitare questo per l'eliminazione batch, quindi rigenerarlo una volta?
spaziatore

15
Secondo la domanda di @spacediver: questo è un processo pazzesco quando hai 38 kernel non necessari, poiché quando ognuno viene disinstallato passa attraverso tutti i rimanenti mentre genera un nuovo grub.cfg. Questo è ciò che chiamiamo un'operazione N ^ 2: elabora un kernel circa (38 ^ 2/2) = 722 volte ed è molto lento. Sicuramente Ubuntu può
inventare

384

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


34
Durante questa operazione in 10.04 e 12.04, ho scoperto che update-grub veniva eseguito automaticamente durante il processo di eliminazione.
Aidan il

93
È possibile utilizzare l' espansione del rinforzo di bash , ad es. sudo apt-get purge linux-image-3.2.0-3{0..5}-generic(rimuove 30,31, .., 35)
ajo

12
Non è necessario riavviare il sistema in seguito. In effetti, dovresti riavviare il sistema prima di eseguire questi passaggi, per assicurarti di utilizzare l'ultima versione del kernel che probabilmente hai appena scaricato e installato (hai fatto un apt-get update && apt-get upgrade prima di questo, giusto ??)
Ricket,

4
Potresti anche voler disinstallare i linux-signed-imagepacchetti che possono essere installati nei sistemi UEFI: sudo apt-get purge linux-signed-image-3.11.0-{12,14,24}-genericche rimuoverà 12, 14 e 24
devius

1
@jarno Non so se sto usando un kernel firmato o no, ma uname -rnon ho nessuna signedstringa sul mio sistema. Io sembrano avere un'immagine firmato installato e l'output di tale lscomando è: /boot/vmlinuz-3.19.0-16-generic.efi.signed.
devius,

283

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

Svolgere l' sedinvocazione:

  • -ndice seddi stare zitto
  • `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/qdice stop quando abbini 'qualcosa' (in questo caso, viene emesso qualcosa uname -r) - il /surround è un'espressione regolare
  • p è la stampa
  • il ;è il comando separtor, così /something/q;pdice smettere quando si corrispondono qualcosa, altrimenti la stampa

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

Se sei paranoico (come me), puoi creare l'ultima parte in xargs echo sudo apt-get -y purgemodo 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' sedinvocazione è stata modificata. "$(uname -r | sed "s/\([0-9.-]*\)-\([^0-9]\+\)/\1/")"estrae solo la versione (es. "3.2.0-44"), senza "-generic" o simile dauname -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

1
Nota che è un po 'pericoloso abbinare l'attuale versione del kernel come espressione regolare del genere: I punti corrispondono a qualsiasi carattere e 3.1.2-23 corrisponde a 3.1.2-2 (o è il contrario). Vedi anche la mia risposta .
jarno,

19
Ecco una versione all-in-one ottimizzata: sudo apt-get purge $(for tag in "linux-image" "linux-headers"; do dpkg-query -W -f'${Package}\n' "$tag-[0-9]*.[0-9]*.[0-9]*" | sort -V | awk 'index($0,c){exit} //' c=$(uname -r | cut -d- -f1,2); done)vedi anche la mia risposta .
jarno,

1
@jarno che mi ha aiutato in grande misura ... Complimenti per il tuo one liner
Clain Dsilva

5
A causa di dipendenze non soddisfatte, ho dovuto usarlo con dkpg -Pinvece. Ecco la versione completa: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 dpkg -P
Sebastian Sastre,

3
NON FARE QUESTO! "Quell'atleta sembra un po 'pericoloso, ma sicuramente 220 utenti non possono sbagliarsi!" Ho pensato a me stesso e incollato alla cieca. Riavviato, direttamente su GRUB. Quel comando ha cancellato tutti i miei kernel, incluso quello che stavo usando. Forse stavo eseguendo un kernel in tempo reale, non ricordo nemmeno. Attualmente sto cercando a casa mia una chiavetta USB per installare Ubuntu Live CD su :(
Andreas Jansson,

60

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

1
Quel comando è uno script di shell, la cui posizione è possibile trovare which purge-old-kernels.
jarno,

Sono contento che abbiano reso tutto molto più semplice in 16.04! Spero che questa risposta continui a farsi strada ...
Toby J

Su Ubuntu 16.04 ho purge-old-kernelssenza il pacchetto bikeshed ( strumenti utili casuali che non hanno ancora una casa permanente ) o uno qualsiasi. Evitare di usare l' apt-get -yopzione, è come chiudere gli occhi e sperare che tutto vada bene. Anche qui è come autoremove decide quanti vecchi kernel conservare.
Pablo A

2
In 16.04 purge-old-kernels è fornito dal pacchetto byobu (suggerimento:) apt-file search purge-old-kernels. D'accordo apt-get -y, lo rimuoverò.
bmaupin,

1
@Dan poiché non uso versioni non LTS non ero sicuro esattamente quando è iniziato. Ma posso dire con certezza che sudo apt-get autoremovenon rimuove i kernel in 14.04. Sentiti libero di aggiornare la risposta con la versione specifica se sai di cosa si tratta!
bmaupin,

43

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 normalmente non deve essere modificato.

Troppi kernel?

  • Se non si è sicuri del kernel attualmente in uso, in un terminale digitare 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.

Rimuovere le voci del 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.

Rimuovere 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

fonte

Nota: dopo gli aggiornamenti del kernel viene aggiunta una nuova voce al menu di GRUB. Se lo si desidera, è possibile rimuovere quella più vecchia.Tuttavia, gli utenti più esperti ti consiglieranno di conservare almeno una voce di riserva nel caso in cui qualcosa vada storto con un aggiornamento e tu è necessario 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

startupmanager Installa startupmanager

Puoi trovarlo in Sistema >> Amministrazione >> testo alternativo
testo alternativo
Vedi nella seconda schermata 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.


2
In realtà, startupmanager dint mi dà una finestra come questa su Ubuntu 10.04, invece ha appena dato una finestra con due schede -> Opzioni di avvio e Avanzate .. e in avanzata ha l'opzione di limitare il numero di kernel. Quindi, per favore, aggiorna la risposta per Ubuntu 10.04. (Ed è per questo che ho votato verso il basso questo ..)
Sen

qualche idea di come "numero di kernel da mantenere" può essere definito su una macchina su cui non è installata la GUI (server)?
sylvainulg,

startupmanager è obsoleto. Vedi grup-customizer
muhasturk,

39

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

9
da una dpkg -l linux-* | awk '/^ii/{ print $2}' | grep -v -e `uname -r | cut -f1,2 -d"-"` | grep -e [0-9] | xargs sudo apt-get -y purge
riga

@DmitryPaskal, dovresti aggiungere questo come una nuova risposta.
saji89,

10
@DmitryPaskal Come sempre, non copiarli e incollarli senza capirli. Sulla mia macchina questo one-liner corrisponde anche a quello linux-libc-dev:amd64che non dovrebbe essere rimosso.
jamesadney,

1
@Kees Cook, l'argomento awk non dovrebbe essere racchiuso tra virgolette singole? Se il tuo intento è anteporre "linux-image-" alle linee di piping, questo sembra funzionare solo se lo usi awk '{print "linux-image-" $0}'.
Segna il

questo non funziona per me, include il mio kernel installato personalizzato (Ubuntu 14.04 con 3.17)
Alex R

35

Aggiornamento: oggi purge-old-kernelsè obsoleto .

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

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

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


Sembra che purge-old-kernelsnon sia nella versione precisa (1.22) di bikeshed. Esiste un modo ragionevole / sicuro per ottenere un ciclismo più recente per la precisione? O sarebbe più semplice / sicuro installare lo script? Preferirei usare un repository, nonostante la lunga lista di dipendenze ..
drevicko

1
@drevicko Vedi qui .
jarno,

1
@drevicko, certo,dlocate -lsbin bikeshed
jarno il

1
@drevicko, vedi anche un'altra domanda
jarno,

1
@ChrisW sì, c'è. Ho appena apportato un piccolo miglioramento allo script, quindi è meglio usare l'ultima versione.
jarno,

29

È possibile seguire il Utilizzando la sezione pacchetto "unattended-upgrades" di aggiornamenti per la protezione automatica articolo su Ubuntu Wiki per eseguire questa.

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


2
L'ho fatto ma stava ancora raccogliendo 3+ kernel vecchi che consumavano centinaia di MB. Quindi ho aggiunto apt-get autoremoveal mio lavoro cron giornaliero che effettivamente esegue gli aggiornamenti, dal momento che non passa sempre attraverso update-manager integrato.
Marcos,

Penso che questo funzioni in Trusty solo per i kernel che sono stati installati automaticamente.
jarno,

Questo è ottimo per prevenire l'accumulo di vecchi kernel durante l'aggiornamento automatico dei pacchetti, ad es. Con aggiornamenti automatici. Tuttavia, se non si riavvia, è possibile che il pacchetto per il kernel attualmente in esecuzione sia stato disinstallato! Un problema che ciò può causare: i nuovi dispositivi che si collegano potrebbero non funzionare, perché il modulo per loro non può essere caricato a caldo, perché non è più sul disco. (Una soluzione rapida per questo è solo per installare nuovamente il pacchetto del kernel, quindi scollegare e ricollegare il dispositivo.)
joeytwiddle

Ho creato una soluzione automatizzata al problema di cui sopra. Se pensi che sia un buon approccio, sentiti libero di aggiungerlo alla risposta di Qwerty.
joeytwiddle,

27

Il modo più veloce / 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.


1
Suppongo che questo sia cambiato nelle versioni più recenti in quanto in 14.04 questo pulisce semplicemente la cache dei pacchetti e non influisce sui pacchetti installati o su grub.
jarno,

2
Posso confermare che sudo apt-get autoremoverimuove i kernel vecchi (più di una versione fa) in 14.04. Potrebbe essere necessario eseguirlo prima e dopo l'aggiornamento del kernel. Quando ho eseguito prima dell'aggiornamento, ho rimosso solo la versione generica del vecchio kernel. Quindi, dopo aver aggiornato il mio kernel, ha rimosso anche la versione a bassa latenza del vecchio kernel.
tekNorah,

Intendevo il sudo apt-get autocleancomando. @tekNorah ho installato un paio di kernel più vecchi e da allora sudo apt-get autoremovein poi ho eseguito Ubuntu Studio 14.04. Non ha rimosso alcun kernel. Ho installato solo kernel a bassa latenza. Perché hai installato i kernel -generic e -lowlatency?
jarno,

5
Sì, questo ha funzionato magnificamente per me, ha ripulito correttamente tutti i vecchi kernel e non si basa su pazzi script di una riga! Consigliato, vorrei poterlo votare più di una volta!
Jeff Atwood,

1
@JeffAtwood bene, potrebbe rimuovere più kernel sicuri. Vedi segnalazione bug
jarno

25

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 /boot/grub/menu.lstper specificare quanti kernel dovrebbe mostrare al massimo. GRUB 2, per quanto ne so, non lo fa.


4
Computer Janitor non dovrebbe essere usato : è difettoso e ora è stato eliminato come applicazione predefinita in natty / oneiric / precise.
Fossfreedom

2
Piuttosto, installa "Ubuntu Tweak" come descritto in un'altra risposta (il suo ppa), che ha il suo "bidello del computer" (da non confondere con il "bidello del computer" che era temporaneamente disponibile nelle versioni precedenti di Ubuntu)
michael

25

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

(usare apt-get -yper 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

Lo script che hai trovato nel forum è difettoso. Potrebbe non rimuovere alcuni pacchetti di intestazione desiderati (se ti capita di usare un kernel vecchio-pae), e d'altra parte, potrebbe rimuovere alcuni pacchetti che vuoi conservare.
jarno,

Grazie per il commento. Lo script potrebbe non essere perfetto, tuttavia, lo sto usando da anni, principalmente su 12.04 e 14.04, 32 e 64 bit, e non ho avuto problemi. ... e sì, linux-libc-devè installato.
mikewhatever,

Suppongo quindi che il numero di versione delle linux-libc-devcorrispondenze corrisponda al numero di versione del kernel corrente. Qui dpkg -l linux-libc-dev | sed '/^ii/!d;s/^[^ ]* [^ ]* \([^ ]*\).*/\1/;/[0-9]/!d'stampa linux-libc-dev: amd64
jarno,

Non riesco ancora a riprodurre i tuoi risultati, tuttavia, per essere al sicuro, ho modificato il comando aggiungendo un filtro aggiuntivo - grep -E "(image|headers)".
mikewhatever,

1
Per prima cosa prova senza la -ybandiera con l'eliminazione per favore ..!
danger89,

16

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 in uname -rmodo da non rimuovere quella sbagliata per errore.

Ora vai al gestore di pacchetti sinaptici e cerca linux-imagee 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.


Questo è probabilmente il metodo più semplice che sarà per gli utenti che hanno installazioni senza Computer Janitor.
Broam,

1
Da Ubuntu 11.04 il menu di grub mostra solo il kernel corrente per impostazione predefinita, i kernel più vecchi sono nascosti nel menu "Kernel precedenti". Questo metodo funzionerà comunque per ripulire quelli più vecchi.
Andy,

14

È possibile installare Ubuntu-Tweak e quindi andare su Applicazioni -> Strumento di sistema -> Ubuntu Tweak e

inserisci qui la descrizione dell'immaginefare clic su pacchetto più pulito e kernel pulito. non mostra il kernel attualmente utilizzato, quindi sarai sempre al sicuro.


8

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 è Ubuntu 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 che funzioni uname -ain un terminale

In Synaptic puoi filtrare su "Componenti" -> "Kernel e moduli", che includono tutti i kernel. E ordina per la prima colonna: 'S' (Stato), in modo da ottenere tutti i kernel installati in cima. Anzi update-grubè consigliato.
danger89,

6

Puoi disinstallare i vecchi kernel ( linux-image-...pacchetti) usando Synaptic e questo li rimuoverà dal menu di avvio. Fare attenzione a non rimuovere il kernel in esecuzione (è possibile verificarne 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 le voci manualmente ( gksu gedit /boot/grub/grub.cfg), ma verranno rigenerate quando si aggiorna a un kernel più recente. Se stai pensando di rimuovere le recovery modeopzioni, non farlo. Possono tornare utili se rompi qualcosa che ti impedisce l'avvio.


Fare riferimento a questa pagina.


Grub2 ora crea la sua voce grub ogni volta che viene installato un nuovo kernel. con la update-grubquale riscriverò tutti quei kernel.
Marco Ceppi

4

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 -rper visualizzare la versione del kernel attualmente in esecuzione.

Se sei soddisfatto dei risultati, puoi utilizzare apt-getper 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 --yesparametro:

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

@jarno Apprezzo il tuo impegno nel combinare e ottimizzare la mia riga di comando. Ho rimosso la tua riga di comando perché preferisco la leggibilità e la semplicità. Ho deliberatamente adattato il mio comando per la leggibilità e la semplicità. Almeno leggibile e semplice per il mio cervello. Pubblica la tua riga di comando come commento o nella tua risposta.
lesmana,

1
Questo combina due obiettivi: mantenere gli ultimi due kernel e mantenerli più nuovi di quello attuale sudo apt-get purge -- $(ls -1U /boot/vmlinuz* | cut -d- -f2,3 | sort -uV | head -n -2 | awk -v c=$(uname -r | cut -d- -f1,2) '($0==c){exit} //' | sed -r -e 's/\./\\./g' -e 's/.*/-&($|-)/'). Non è necessario dpkg-querypoiché apt-getpuò gestire espressioni regolari. Nota come sfuggo ai punti e aggiungo prefisso e suffisso nell'espressione regolare. Usando lo script nella mia risposta puoi anche mantenere alcuni kernel più vecchi di quello attuale.
jarno,

4

Il vantaggio di questa risposta è che Ubuntu Bash nativo viene utilizzato senza installare applicazioni di terze parti. Utenti di kernel personalizzati che non hanno utilizzato apto dpkgpossono modificare questo script bash in base alle proprie esigenze. Questa risposta si basa su ( Come eliminare selettivamente i vecchi kernel contemporaneamente ).

Soluzione basata sullo Zenity

Zenity fornisce una bella interfaccia GUI al terminale per elaborare un elenco e selezionare gli elementi con i pulsanti di opzione :

rm-kernel 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 /bootdirectory. Altro viene salvato sul disco perché i binari del kernel risiedono anche in altre aree. Nota del 27 luglio 2017: le directory /usr/src/*kernel_version*e /lib/modules/*kernel_version*ora sono incluse anche.

La data modificata viene rilevata utilizzando il statcomando. Sul mio sistema quella data viene "toccata" ogni volta che il kernel viene avviato usando questo ( come si fa a sapere quando è stata avviata l'ultima versione del kernel? ) Cron reboot script. 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 totale su disco (un po '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 denominato rm-kernelsin /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: per creare il file è necessaria l'autorizzazione sudo, 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 usando:

    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 alla dialogdirettiva --ascii-linesviene passata la sostituzione del set di caratteri esteso di disegno (che sshnon piace) con "+ ----- +" per le caselle di disegno. Se non ti piace questo aspetto, puoi utilizzare la --no-linesdirettiva per nessuna casella.


Aggiornamenti del 28 luglio 2017

Sono state prese le dimensioni calcolate di ciascun kernel da /boot/*kernel_version*cui 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-kernelse 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é dupuò essere dolorosamente lento a meno che i file non siano nella cache. Per ottenere la dimensione reale usando dupassare 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 dell'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 la data modificata .


2

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.


Il comando dato non cancella i vecchi kernel né influisce sul menu di grub nella mia esperienza.
jarno,

2

La risposta accettata che utilizza sedper rimuovere permanentemente i kernel più vecchi 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.


Ciò non rimuoverà i kernel a bassa latenza o i noccioli di sapore diverso da quelli generici.
jarno,

Suppongo che ti riferisca a queste sed soluzioni.
jarno,

@jarno: che ne dici di sostituire grep -Po "^linux-image-[^-]+-[^-]+-generic\b"con grep -Eo "^linux-(image|headers|tools)-[^-]+-[^-]+(|-generic)\s" | sed -e "s/\s//g"e grep -Po ".*(?=-[a-z]*$)"con grep -Eo "^[0-9]+\.[0-9]+\.[0-9]+-[0-9]+"e grep -Po "[0-9].*(?=-[a-z]*)"con grep -Eo "[0-9]+\.[0-9]+\.[0-9]+-[0-9]+"?
Sadi,

@Sadi, wel, non troverei nemmeno i kernel a bassa latenza.
jarno,

1
Grazie. Altri metodi non hanno funzionato per me. Il tuo ha fatto il lavoro.
Philippe Delteil,

1

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


"Ailurus è uno strumento per il backup di un elenco di nomi di software installato. ... In passato Ailurus ha molte funzioni. Ora ha solo una funzione. Perché penso che una funzione davvero utile sia migliore di dozzine di funzioni meno utili."
jarno,

1

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

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 in modo da 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 ukuu


1

Basato su una precedente risposta di David Kemp, il seguente script eliminerà tutte le intestazioni e le immagini tranne le ultime 2 versioni.

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

(usare apt-get -yper rimuovere senza dubbio)


Qualche motivo per cui questo è stato downvoted? Non ha funzionato per qualcuno? Quando copi / incolli, assicurati di non avvolgere le linee lunghe quando incolli. Non ho avuto problemi con il suo funzionamento.
Mark

La versione più recente del kernel nella mia macchina è 3.13.0-43-lowlatency. Questo script eliminerebbe linux-headers-3.13.0-43-lowlatency.
jarno,

@jarno come l'hai determinato? per provarlo senza effettivamente fare nulla, aggiungere un flag "-s" al comando apt-get (o semplicemente rimuovere del | xargs sudo apt-get -y purgetutto). Se stampa 3.13.0-43-lowlatency, allora forse hai alcune versioni successive rispetto a quella installata sul tuo sistema.
Mark

Ho provato la simulazione. No, ma ho rimosso alcune versioni precedenti del kernel, ma non sono state eliminate e i rispettivi pacchetti di intestazione sono stati eliminati.
jarno,

Comunque, ho sviluppato una sceneggiatura basata sull'idea della risposta di Sankalp.
jarno,

0

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 40_custome poi 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 di Ubuntu ... cioè Ubuntu Lucid 10.04, ecc ...

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


3
Questa risposta sembra eccessiva. È meglio rimuovere solo i vecchi kernel.
Scott Severance

Avevo letto che i kernel extra possono essere utili in caso di situazioni di recupero. Inoltre, questo è un modo semplice per modificare il testo della voce di avvio. Quindi piuttosto che dire "Ubuntu, kernel Linux xxxx-yy --text1 -text2 -t3 -t4 --t5 etc etc etc" (dove le voci --text indicano solo alcune opzioni / parametri che non capisco) puoi cambiare su "Ubuntu xx.yy" sebbene avessi una parentesi "{" di cui non potevo liberarmi.
Joe

1
Tengo in giro il kernel precedente immediato fino a quando non ho verificato che il kernel più recente funzioni correttamente. Se funziona, non smetterà di funzionare. Quindi, dopo aver verificato il kernel più recente (dopo circa una settimana o giù di lì), non ho motivo di tenere in giro il vecchio kernel. Se non funziona, allora ho l'ultimo kernel noto a cui tornare. In realtà, sto attualmente eseguendo un vecchio kernel a causa di un bug showstopper nei kernel attuali. Ma ciò non cambia la mia politica generale. Hai solo bisogno di un noto kernel noto.
Scott Severance,

0

Installa il gestore di pacchetti sinaptici 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, esegui update-grub. Tale comando aggiorna l'elenco delle opzioni di avvio per grub.

Se fallisce, puoi sempre provare apt-get remove linux-image-version-generic.


In Synaptic puoi filtrare su "Componenti" -> "Kernel e moduli", che includono tutti i kernel. E ordina per la prima colonna: 'S' (Stato), in modo da ottenere tutti i kernel installati in cima. Anzi update-grubè consigliato.
danger89,

0

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

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

Regola l'elenco delle versioni del kernel per adattarle.


0

Prova questo. Eseguilo come root.

Salvare questo script come, diciamo ./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à tutto ciò che è installato
# kernel e mantieni solo i n più 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 EXCEPT per l'ultimo kernel.
# fonte: https://help.ubuntu.com/community/Lubuntu/Documentation/RemoveOldKernels

n = $ 1

# trova le versioni del kernel installate:
# dpkg-query -W -f = '$ {Versione} \ n' 'linux-image- *' | grep. | ordina -n
# fornisce i numeri di versione, uno in ogni riga
# dpkg-query -W -f = '$ {Versione} \ n' 'linux-image- *' | grep. | sed 's /\...$// g' | grep -v '\ ... $' | ordina -u
# fornisce solo quelli che appaiono in linux-image

# suffisso, ad esempio -generic-pae
# il tipo di kernel in cui si avvia
suffisso = $ (uname -r | sed 's: ^ [0-9] \. [0-9] \. [0-9] \ - [0-9] \ {2 \} :: g')

command = "apt-get purge"

per la versione in $ (dpkg-query -W -f = '$ {Version} \ n' 'linux-image- *' | grep. | sed 's /\...$// g' | grep -v ' \ ... $ '| sort -u | head -n - $ {n})
fare
    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 A PROPRIO RISCHIO], è possibile aggiungere un -y (o un flag force) al comando apt-get e renderlo non interattivo.


Rimuove tutti i kernel, se si esegue ./keep-n-kernels.sh 0. Il rilevamento della stringa del suffisso non funziona; Penso che il suffisso = $ (uname -r | sed -r 's / ^ [0-9.] * (- [0-9.] +) * //') o il suffisso = $ (uname -r | egrep - -only-matching - '- [[: alpha:] -] + $') farebbe.
jarno,

Ma penso che l'idea sia carina. Ho lavorato per migliorare la sceneggiatura e forse la posterò qui qualche volta, quando penso che sia abbastanza pronto.
jarno,

Per favore, condividi, @jarno. Sono contento di sapere che l'idea sembra utile.
Sankalp,

Ok,
eccolo qui

0

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-versions (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 e dal menu di GRUB.


0

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

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.