kernel versie beheer

[Keeper of the Keys]

Hopelijk is de titel niet te onduidelijk.

Op RH gebaseerde systemen wordt voor zover ik weet (en heb gezien al heb ik geen vergaand onderzoek gedaan) als je een upgrade doet waarbij de kernel wordt bijgewerkt altijd de volgende kernels bewaard:
- Een versie voor de draaiende kernel
- De draaiende kernel
- De nieuwste versie van de nieuwere kernel

bvb:

code:

prev: -10
running: -11
new: -14 #(een tijd geen reboot gedaan)

Op Debian gebaseerde systemen gebeurt er voor zover ik heb gezien geen beheer, dat is geen ramp maar het betekent wel dat als je een server een hele tijd laat staan en hij wel automatische updates doet je /boot of / kan vollopen met al de overbodige kernel images (en headers).

Weten jullie of hier een "officiële" oplossing voor is (in de vorm van een of ander package), of dat er iemand al iets voor heeft geschreven? (anders ga ik zelf wel wat proberen)

[Hero of Time]

Ik draai zelf Debian Sid en als ik via aptitude zoek naar updates, dan komen oudere kernel images automatisch op de remove lijst of anders bij de Obsolete/Local packages. Nu werkt Debian wel wat anders dan Ubuntu met kernels. Daar waar Debian de packages zelf geen direct nieuwe versie geven, waardoor de bestaande dus vervangen wordt (bijvoorbeeld van kernel 3.2.20 naar 3.2.22). Als er een iets grotere wijziging is, dan krijgt het package een iets andere versie, bijvoorbeeld van 3.2.0-1 naar 3.2.0-2.

Ubuntu geeft packages dezelfde naam als de versie en de meta-package verandert alleen van versie om upgrades netjes te laten verlopen. Maar de oudere kernel blijft staan en kan idd zorgen voor een wat volle schijf. Maar ook hier worden ze automatisch op de removal lijst gezet, dus als je apt-get autoremove draait, dan schoon je die dingen weer op.

Wanneer bij beide systemen een kernel op de auto-remove lijst komt, durf ik niet te zeggen. Dit kan gelijk zijn aan de situatie die je schetst, je huidige en één of twee versies voor je laatst geïnstalleerde kernel.

Nu snap ik niet wat je vraag is en hoe het nou precies zit met RH en soortgelijken. Wat voor beheer heb je het over, wat doet het?

[Keeper of the Keys]

Ik gebruik eigenlijk altijd apt-get en niet aptitude en die zet meestal wel de headers in de lijst voor autoremove maar niet de oude images.

Voor zover ik het heb begrepen zorgen de update/beheer scripts van RH ervoor dat tenzij jij het expliciet aangeeft er nooit meer dan 3 kernel images tegelijk geïnstalleerd staan: vorige bootable image, huidig en nieuwer (indien beschikbaar).

Op zich wil ik het liefst ook zo'n situatie op mijn Debian & Ubuntu machines, want op dit moment moet ik na een kernel update nog met de hand alle oude kernel images gaan verwijdered (dpkg -l "linux*" | grep ^i en dan maar uitzoeken wat er weg moet).

[Hero of Time]

Hiervoor kan je beter aptitude gebruiken. die heeft een curses interface (als je geen optie/parameter meegeeft) en kan je via / zoeken. Dan even op image of headers zoeken, of zoals je grep naar linux, en hoppa, je hebt je zooitje kernels.

Ik vind aptitude zo veel lekkerder werken dan alle andere grafische package managers die op Debian/Ubuntu beschikbaar zijn. Alleen zo jammer dat ik met 11.10 en verder veel gezeik had met de werking ervan op Ubuntu. Ze hadden 't flink goed gesloopt. En dan denk je eindelijk dat het weer fatsoenlijk werkt, is het met een andere package update opeens weer stuk.
Daarom ben ik ook over naar Debian Sid, mede door het slopen van aptitude en het gevoel dat het net niet af is, te veel ruwe kantjes. En rolling release wilde ik, met in zekere zin bleeding edge .

[Keeper of the Keys]

Een curses interface vereist nog steeds de tussenkomst van een persoon om de oude images op te ruimen, ik wil naar een situatie waar zonder tussenkomst de oude images worden opgeruimd...

[Hero of Time]

Klopt, maar je ziet wel wat er gedaan wordt. Via aptitude auto-remove of apt-get autoremove wordt 't voor je gedaan. Apt zal NOOIT packages die met auto-remove verwijdert kunnen worden weggooien als je een apt-get upgrade doet.

Als je 't zonder user interactie wilt, dan kan je 't schedulen via een cronjob en mail het resultaat naar jezelf.

[Keeper of the Keys]

Ik zal aptitude maar eens proberen, met apt heb ik linux-image-* nooit in de autoremove lijst gezien, wel linux-header-*

[avatar]

Het volgende script doet precies wat jij wilt. Huidige + voorlaatste kernel + nieuwste kernel laten staan. De rest wordt bij elke apt-get actie verwijderd.

Een apt-hook toevoegen:

Bash: /etc/apt/apt.conf.d/88purgekernels

DPkg::Post-Invoke { "/usr/sbin/purgekernels"; };

Het purgekernels script

Perl: /usr/sbin/purgekernels

#!/usr/bin/perl -wT
BEGIN { $ENV{PATH} = "/bin:/sbin:/usr/bin:/usr/sbin"; }
use strict;
use IPC::Open3;
use Data::Dumper;
sub isnewer ($$);   # prototype for sort{} usage
#
# Run as Post-Invoke:
# $ cat /etc/apt/apt.conf.d/88local
# DPkg::Post-Invoke { "/usr/local/sbin/purgekernels --debug"; };
#
# Or manual:
# root@host:~# /usr/sbin/purgekernels --debug
#
my $debug = 0;
$debug++ if grep(/--debug/, @ARGV);
print "$0: cleaning up kernels ..\n";

my $kernels = {};
my $kernel_version = "";
my $current_kernel_version = "";

# Installed kernels
my $dpkg = `dpkg -l linux-image-\*`;
dprint("cmd out: '$dpkg'");
while ($dpkg =~ m#^[ri][ci]\s+(linux\-image\-\d+\.\d+\.\d+\-\d+(?:\-\w+)+)\s#gm) {
    my $package_name = $1;
    $package_name =~ m#^linux\-image\-(\d+\.\d+\.\d+\-\d+)(?:\-\w+)+$#gm;
    $kernel_version = $1;
    $$kernels{$kernel_version} = $package_name;
    dprint("found installed $kernel_version");
}

die "parsing failed? no kernels installed?\n" if not scalar(keys(%$kernels));

# Current kernel
my $uname = `uname -r`; chomp($uname);
dprint("cmd out: '$uname'");
($current_kernel_version) = $uname =~ m#(\d+\.\d+\.\d+\-\d+)\-#;
dprint("currently running $current_kernel_version");

# Rinse dem proper
my @sorted_kernels = reverse sort { isnewer($a, $b) } keys %$kernels;

dprint("---- \$kernels ----");
dprint("".Dumper($kernels));
dprint("---- \@sorted_kernels -----");
dprint("".Dumper(@sorted_kernels));

# Strip off the top three, keeping these installed.                                                                                     [7/90]
my $keep1 = shift @sorted_kernels; # at least one kernel should be installed
my $keep2 = shift @sorted_kernels; $keep2 ||= "";
my $keep3 = shift @sorted_kernels; $keep3 ||= "";
dprint("keeping [$keep1]  [$keep2]  [$keep3]");
print("reboot to activate newer kernel $keep1\n") if isnewer($keep1, $current_kernel_version);

# Current kernel could be in the remainder of the list!
foreach my $remove_kernel_version (@sorted_kernels) {
    if ($remove_kernel_version eq $current_kernel_version) {
        print "not removing current kernel.\n";
        next;
    }

    print "\n\nremoving $remove_kernel_version\n";

    my @cmd = ("/usr/bin/dpkg", "--purge", $$kernels{$remove_kernel_version});
    system(@cmd) == 0 or warn "Forking dpkg failed: $!\n";
    if ($? == -1) {
        print "failed to execute: $!\n";
    } elsif ($? & 127) {
        printf "child died with signal %d, %s coredump\n", ($? & 127),  ($? & 128) ? 'with' : 'without';
    } else {
        printf "child exited with value %d\n", $? >> 8;
    }

    print "done.\n";
}

print "$0: done.\n";
exit 0;

##  ##
# ## #
#bwub#
######

sub dprint {
    my ($msg, $level) = @_;
    return if not $debug;
    $level ||= 1;
    $msg =~ s/\n+$//;
    print $msg . "\n" if $level <= $debug;
}

sub isnewer ($$) {
    my ($astr, $bstr) = @_;

    $astr =~ s/-/./g; my ($aver, $amaj, $amin, $arev) = split /\./, $astr;
    $bstr =~ s/-/./g; my ($bver, $bmaj, $bmin, $brev) = split /\./, $bstr;

    return 1 if $aver > $bver; return -1 if $bver > $aver;
    return 1 if $amaj > $bmaj; return -1 if $bmaj > $amaj;
    return 1 if $amin > $bmin; return -1 if $bmin > $amin;
    return 1 if $arev > $brev; return -1 if $brev > $arev;
    return 0;
}

[Keeper of the Keys]

Heel erg bedankt, ga ik morgen even goed doornemen.