====== Ștergerea kernel-urilor vechi pe Linux ======

Pe măsură ce actualizezi sistemul, distribuțiile Linux păstrează automat versiunile anterioare ale kernel-ului ca măsură de siguranță: dacă o versiune nouă cauzează probleme, poți reveni la una mai veche din meniul GRUB. Dezavantajul este că, în timp, partiția ''/boot'' se poate umple, iar lista din bootloader devine lungă și greu de navigat. Tutorialul de față acoperă distribuțiile de bază - cele pe care sunt construite majoritatea celorlalte: Debian, Ubuntu, Arch, Fedora, openSUSE, Gentoo, Alpine și NixOS.

<WRAP important>
**Înainte de a șterge orice kernel**, asigură-te că ai pornit sistemul cu kernel-ul pe care vrei să-l păstrezi. Nu șterge niciodată kernel-ul activ. Verifică versiunea curentă cu:
<code bash>
uname -r
</code>
</WRAP>

<tab-group>
  <tab title="Debian">

==== Debian ====

Debian folosește ''apt'' ca manager de pachete. Kernel-urile sunt livrate ca pachete cu numele ''linux-image-X.Y.Z-amd64'' (sau arhitectura corespunzătoare).

=== Ștergere rapidă ===

Șterge toate kernel-urile vechi, păstrând versiunea activă și una de fallback:

<code bash>
sudo apt autoremove --purge
sudo update-grub
</code>

=== Verificare kernel activ și versiuni instalate ===

<code bash>
uname -r
</code>

<code bash>
dpkg --list | grep linux-image
</code>

Pachetele cu starea ''ii'' sunt instalate. Versiunea afișată de ''uname -r'' este cea activă - pe aceasta **nu** o șterge.

=== Ștergere manuală ===

Înlocuiește ''X.Y.Z-amd64'' cu versiunea exactă pe care vrei să o elimini:

<code bash>
sudo apt remove linux-image-X.Y.Z-amd64 linux-headers-X.Y.Z-amd64
sudo apt autoremove --purge
sudo update-grub
</code>

<WRAP tip>
Pe Debian **Stable**, kernel-urile noi apar rar (o dată la câțiva ani, odată cu o versiune majoră). Pe **Testing** și **Unstable** (Sid), actualizările sunt mai frecvente și ''autoremove'' devine mai util.
</WRAP>

  </tab>
  <tab title="Ubuntu">

==== Ubuntu ====

Ubuntu folosește ''apt'' ca manager de pachete, iar kernel-urile sunt livrate ca pachete cu nume de forma ''linux-image-X.Y.Z-generic''.

=== Ștergere rapidă ===

Șterge toate kernel-urile vechi, păstrând versiunea activă și una de fallback:

<code bash>
sudo apt autoremove --purge
sudo update-grub
</code>

=== Verificare kernel activ și versiuni instalate ===

<code bash>
uname -r
</code>

<code bash>
dpkg --list | grep linux-image
</code>

Caută pachetele cu starea ''ii'' (instalat). Versiunea afișată de ''uname -r'' este cea activă - pe aceasta **nu** o șterge.

=== Ștergere manuală ===

Înlocuiește ''X.Y.Z-generic'' cu versiunea exactă pe care vrei să o elimini:

<code bash>
sudo apt remove linux-image-X.Y.Z-generic linux-headers-X.Y.Z-generic linux-modules-X.Y.Z-generic
sudo apt autoremove --purge
sudo update-grub
</code>

<WRAP tip>
Pachetul ''linux-generic'' asigură că sistemul instalează automat cele mai recente kernel-uri. Dacă îl ai instalat, ''autoremove'' este suficient pentru întreținere curentă. Distribuțiile derivate din Ubuntu (Linux Mint, Zorin OS, Pop!_OS, elementaryOS etc.) urmează același procedeu.
</WRAP>

  </tab>
  <tab title="Arch Linux">

==== Arch Linux ====

Pe Arch Linux, kernel-urile sunt pachete obișnuite ''pacman''. Spre deosebire de alte distribuții, **Arch nu acumulează automat versiuni vechi** - la fiecare ''pacman -Syu'', kernel-ul este înlocuit, nu adăugat. Versiunile vechi apar doar dacă ai instalat explicit mai multe variante de kernel simultan.

=== Ștergere rapidă ===

Arch nu acumulează versiuni vechi în mod normal. Dacă ai instalat mai multe variante, șterge varianta de care nu mai ai nevoie:

<code bash>
sudo pacman -Rs linux-lts linux-lts-headers
</code>

Pentru curățarea cache-ului de pachete (inclusiv imaginile vechi de kernel stocate local):

<code bash>
sudo paccache -rk1
</code>

=== Kernel-uri disponibile ===

Arch oferă mai multe variante oficiale, instalabile simultan:

^ Pachet              ^ Descriere                                       ^
| ''linux''           | Kernel stabil, actualizat frecvent              |
| ''linux-lts''       | Kernel LTS, mai conservator                     |
| ''linux-zen''       | Optimizat pentru desktop și gaming              |
| ''linux-hardened''  | Cu patch-uri de securitate suplimentare         |

=== Verificare versiuni instalate ===

<code bash>
uname -r
</code>

<code bash>
pacman -Q | grep linux
</code>

=== Actualizare GRUB după ștergere ===

<code bash>
sudo grub-mkconfig -o /boot/grub/grub.cfg
</code>

Dacă folosești ''systemd-boot'':

<code bash>
sudo bootctl update
</code>

=== Curățarea cache-ului pacman ===

''pacman'' stochează versiunile vechi ale pachetelor în ''/var/cache/pacman/pkg/''. ''paccache'' se găsește în pachetul ''pacman-contrib'':

<code bash>
sudo pacman -S pacman-contrib
sudo paccache -rk2
</code>

Comanda păstrează ultimele **2** versiuni din cache pentru fiecare pachet. Folosește ''-rk1'' pentru a păstra doar ultima versiune.

<WRAP important>
Dacă folosești un singur kernel (''linux''), **nu ai nimic de șters** - există o singură versiune activă în orice moment. Distribuțiile derivate din Arch (Manjaro, EndeavourOS, Garuda etc.) urmează același procedeu, cu mici diferențe de bootloader.
</WRAP>

  </tab>
  <tab title="Fedora">

==== Fedora ====

Fedora folosește ''dnf'' ca manager de pachete. Kernel-urile sunt pachete cu numele ''kernel'', ''kernel-core'' și ''kernel-modules''. Distribuțiile derivate (RHEL, AlmaLinux, Rocky Linux, CentOS Stream) urmează același procedeu.

=== Ștergere rapidă ===

Metoda 1 - cu ''package-cleanup'' din pachetul ''dnf-utils'' (păstrează ultimele 2 versiuni):

<code bash>
sudo dnf install dnf-utils
sudo package-cleanup --oldkernels --count=2
</code>

Metoda 2 - nativă cu ''dnf repoquery'':

<code bash>
sudo dnf remove $(sudo dnf repoquery --installonly --latest-limit=-1 -q)
</code>

=== Verificare kernel activ și versiuni instalate ===

<code bash>
uname -r
</code>

<code bash>
dnf list installed kernel
</code>

=== Configurarea numărului de kernel-uri păstrate ===

''dnf'' are o opțiune nativă în ''/etc/dnf/dnf.conf'' care controlează câte versiuni sunt reținute automat la fiecare upgrade. Valoarea implicită este **3**:

<code>
installonly_limit=2
</code>

Cu valoarea ''2'', la fiecare actualizare ''dnf'' va păstra automat doar kernel-ul curent și unul de fallback. Valoarea minimă admisă este **2**.

=== Ștergere manuală ===

<code bash>
sudo dnf remove kernel-X.Y.Z kernel-core-X.Y.Z kernel-modules-X.Y.Z
</code>

Înlocuiește ''X.Y.Z'' cu versiunea exactă afișată de ''dnf list installed kernel''.

=== Actualizare GRUB ===

Pe sisteme cu BIOS:

<code bash>
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
</code>

Pe sisteme UEFI:

<code bash>
sudo grub2-mkconfig -o /boot/efi/EFI/fedora/grub.cfg
</code>

<WRAP tip>
Pe Fedora, kernel-ul nou este marcat automat ca implicit după instalare. Pe RHEL/AlmaLinux/Rocky Linux, înlocuiește calea UEFI cu ''/boot/efi/EFI/redhat/grub.cfg'' sau ''/boot/efi/EFI/rocky/grub.cfg'', după caz.
</WRAP>

  </tab>
  <tab title="openSUSE">

==== openSUSE ====

openSUSE (Leap și Tumbleweed) folosește ''zypper'' și ''rpm''. Spre deosebire de alte distribuții, openSUSE are un mecanism dedicat de gestionare a versiunilor multiple de kernel, configurat direct în ''/etc/zypp/zypp.conf''.

=== Ștergere rapidă ===

Aplică politica definită în ''zypp.conf'' și șterge automat versiunile în surplus:

<code bash>
sudo zypper purge-kernels
</code>

=== Verificare kernel activ și versiuni instalate ===

<code bash>
uname -r
</code>

<code bash>
rpm -q kernel-default
</code>

=== Configurarea politicii de retenție ===

În ''/etc/zypp/zypp.conf'', variabila ''multiversion.kernels'' controlează ce versiuni sunt păstrate:

<code>
multiversion.kernels = latest,running,latest-1
</code>

^ Valoare      ^ Semnificație                              ^
| ''latest''   | Cea mai recentă versiune instalată        |
| ''running''  | Versiunea activă curentă                  |
| ''latest-1'' | Penultima versiune (fallback)             |
| ''latest-2'' | Antepenultima versiune                    |

Configurația de mai sus păstrează 3 versiuni. Pentru a păstra doar 2:

<code>
multiversion.kernels = latest,running
</code>

=== Ștergere manuală ===

Dacă preferi să ștergi o versiune specifică:

<code bash>
sudo zypper remove kernel-default-X.Y.Z
</code>

=== Actualizare GRUB ===

Bootloader-ul este actualizat automat la ''purge-kernels''. Dacă vrei să forțezi regenerarea manual:

<code bash>
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
</code>

<WRAP tip>
Pe **openSUSE Tumbleweed** (rolling release), kernel-urile se actualizează frecvent. Configurarea ''multiversion.kernels'' este esențială pentru a preveni acumularea versiunilor. Pe **Leap** actualizările sunt mai rare, dar mecanismul este același.
</WRAP>

  </tab>
  <tab title="Gentoo">

==== Gentoo ====

Pe Gentoo, kernel-ul este compilat local din surse. Nu există un mecanism automat de ștergere - kernel-urile vechi rămân pe disc până când le elimini manual sau folosești instrumentul dedicat ''eclean-kernel''.

=== Ștergere rapidă ===

Instalează și folosește ''eclean-kernel'' din pachetul ''app-admin/eclean-kernel'' - șterge automat kernel-urile vechi, inclusiv sursele, imaginile din ''/boot'' și modulele:

<code bash>
sudo emerge app-admin/eclean-kernel
sudo eclean-kernel -n 1
</code>

Flag-ul ''-n 1'' păstrează doar cel mai nou kernel și șterge tot restul. Folosește ''-n 2'' pentru a păstra și un fallback. Rulează cu ''-p'' (pretend) mai întâi pentru a vedea ce urmează să fie șters:

<code bash>
sudo eclean-kernel -n 2 -p
</code>

=== Ștergere manuală ===

Dacă preferi să nu folosești ''eclean-kernel'', procesul manual implică mai mulți pași.

Verifică kernel-ul activ și versiunile instalate:

<code bash>
uname -r
equery list 'sys-kernel/*'
ls /boot/vmlinuz-* /boot/initramfs-*
</code>

Dezinstalează sursele kernel-ului vechi:

<code bash>
sudo emerge --unmerge sys-kernel/gentoo-sources:X.Y.Z
</code>

Șterge fișierele rămase din ''/boot'':

<code bash>
sudo rm /boot/vmlinuz-X.Y.Z-gentoo
sudo rm /boot/initramfs-X.Y.Z-gentoo.img
sudo rm /boot/System.map-X.Y.Z-gentoo
sudo rm /boot/config-X.Y.Z-gentoo
</code>

Șterge sursele și modulele:

<code bash>
sudo rm -rf /usr/src/linux-X.Y.Z-gentoo
sudo rm -rf /lib/modules/X.Y.Z-gentoo
</code>

=== Actualizare GRUB ===

<code bash>
sudo grub-mkconfig -o /boot/grub/grub.cfg
</code>

<WRAP important>
Pe Gentoo, symlink-ul ''/usr/src/linux'' trebuie să pointeze întotdeauna către sursele kernel-ului activ. Verifică înainte de ștergere:
<code bash>
ls -la /usr/src/linux
</code>
Dacă pointează către versiunea pe care vrei să o ștergi, actualizează symlink-ul mai întâi:
<code bash>
sudo eselect kernel list
sudo eselect kernel set <numărul versiunii active>
</code>
</WRAP>

  </tab>
  <tab title="Alpine Linux">

==== Alpine Linux ====

Alpine Linux folosește ''apk'' ca manager de pachete. Kernel-urile sunt livrate ca pachete ''linux-lts'', ''linux-stable'' (înlocuiește ''linux-edge'' începând cu Alpine 3.23) sau ''linux-virt'' (pentru mașini virtuale).

=== Ștergere rapidă ===

Alpine nu acumulează versiuni vechi în mod normal - ''apk upgrade'' înlocuiește kernel-ul în loc să adauge unul nou. Dacă ai instalat mai multe variante, elimină varianta nedorită:

<code bash>
sudo apk del linux-stable
</code>

Curăță fișierele reziduale din ''/boot'' dacă au rămas după un upgrade:

<code bash>
sudo rm /boot/vmlinuz-X.Y.Z-alpine
sudo rm /boot/initramfs-X.Y.Z-alpine
sudo rm /boot/System.map-X.Y.Z-alpine
</code>

=== Verificare versiuni instalate ===

<code bash>
uname -r
</code>

<code bash>
apk info | grep linux
</code>

=== Actualizare bootloader ===

Alpine folosește ''extlinux'' (BIOS) sau GRUB (UEFI) în funcție de modul de instalare.

Pentru ''extlinux'':

<code bash>
sudo update-extlinux
</code>

Pentru GRUB:

<code bash>
sudo grub-mkconfig -o /boot/grub/grub.cfg
</code>

<WRAP tip>
Pe Alpine rulat **în containere** (Docker, LXC), nu există bootloader și nu există kernel propriu - containerul folosește kernel-ul gazdei. Gestionarea kernel-ului se aplică doar instalărilor bare-metal sau VM-urilor cu Alpine ca sistem de operare complet.
</WRAP>

  </tab>
  <tab title="NixOS">

==== NixOS ====

NixOS are o abordare fundamental diferită față de toate celelalte distribuții. Kernel-ul face parte din **configurația declarativă** a sistemului, definită în ''/etc/nixos/configuration.nix''. Fiecare actualizare creează o nouă **generație** - un snapshot complet al sistemului - iar generațiile vechi, inclusiv kernel-urile lor, sunt păstrate automat până la o colectare de gunoi (garbage collection).

=== Ștergere rapidă ===

Șterge toate generațiile vechi (păstrează doar cea curentă):

<code bash>
sudo nix-collect-garbage -d
</code>

<WRAP important>
''nix-collect-garbage -d'' șterge **toate** generațiile vechi fără posibilitate de recuperare. Dacă ai o actualizare recentă care nu funcționează corect, nu rula această comandă - mai întâi revino la o generație stabilă din meniul GRUB, apoi rulează garbage collection.
</WRAP>

=== Verificare kernel activ și generații instalate ===

<code bash>
uname -r
</code>

<code bash>
sudo nix-env --list-generations --profile /nix/var/nix/profiles/system
</code>

=== Configurarea kernel-ului în ''configuration.nix'' ===

Kernel-ul se specifică în ''/etc/nixos/configuration.nix''. Implicit este folosit ''linuxPackages'', dar poți alege explicit:

<code nix>
boot.kernelPackages = pkgs.linuxPackages_latest;  # cel mai recent kernel
# sau
boot.kernelPackages = pkgs.linuxPackages_lts;     # kernel LTS
</code>

Aplică modificarea cu:

<code bash>
sudo nixos-rebuild switch
</code>

=== Ștergere selectivă a generațiilor ===

Șterge generațiile mai vechi de 30 de zile:

<code bash>
sudo nix-collect-garbage --delete-older-than 30d
</code>

Șterge generații specifice după număr:

<code bash>
sudo nix-env --delete-generations 5 6 7 --profile /nix/var/nix/profiles/system
sudo nix-collect-garbage
</code>

=== Verificarea spațiului în ''/nix/store'' ===

<code bash>
sudo nix store gc
df -h /nix
</code>

<WRAP tip>
Pe NixOS, menținerea mai multor generații este o **funcție de siguranță**, nu o problemă. Rollback-ul la o versiune anterioară a întregului sistem (inclusiv kernel) se face dintr-o singură comandă sau direct din GRUB. Rulează ''nix-collect-garbage'' periodic, nu înainte de fiecare update.
</WRAP>

  </tab>
</tab-group>

===== Verificarea spațiului recuperat =====

După ștergere, verifică spațiul liber pe partiția ''/boot'' (și pe ''/nix'' în cazul NixOS):

<code bash>
df -h /boot
</code>

===== Referințe =====

  * [[https://manpages.debian.org/bookworm/apt/apt.8.en.html|apt(8) man page]]
  * [[https://dnf.readthedocs.io/en/latest/conf_ref.html|DNF Configuration Reference]]
  * [[https://documentation.suse.com/sles/15-SP5/html/SLES-all/cha-tuning-multikernel.html|openSUSE - Multiversion kernels]]
  * [[https://wiki.archlinux.org/title/Kernel|Arch Wiki - Kernel]]
  * [[https://wiki.gentoo.org/wiki/Kernel/Removal|Gentoo Wiki - Kernel Removal]]
  * [[https://wiki.alpinelinux.org/wiki/Kernels|Alpine Wiki - Kernels]]
  * [[https://wiki.nixos.org/wiki/Linux_kernel|NixOS Wiki - Linux Kernel]]

{{tag>kernel linux debian ubuntu arch fedora opensuse gentoo alpine nixos administrare-sistem boot grub apt dnf apk nix}}