15.0-alpha1

[gian_d]

è uno script che ho costruito io in base alle mie esigenze e configurazione. Questo è il codice:

Codice: Seleziona tutto

#!/bin/sh

echo "Avvio dell'aggiornamento del kernel ..."
cd /packages/current/kernel
VERSION=$( uname -r 2>/dev/null)
MAJOR=${VERSION%\.*\.*}
MINOR=${VERSION#*.}
MINOR=${MINOR%\.*}
PATCH=${VERSION##*.}
BUILD="0"
OLD=$MAJOR.$MINOR.$PATCH 
MAJOR=$((MAJOR - 3))
MINOR="0"
PATCH="0"
echo ""
echo "Rilevamento della versione corrente del kernel: "$OLD
echo ""
echo "Rilevamento della versione da installare ..."
until [ -f ./kernel-generic-$MAJOR*txz ]; do
	if [ -f ./kernel-generic-$MAJOR*txz ]; then
		echo "pirla"
	else
		MAJOR=$((MAJOR + 1))
	fi
done
until [ -f ./kernel-generic-$MAJOR.$MINOR.*txz ]; do
	if [ -f ./kernel-generic-$MAJOR.$MINOR.*txz ]; then
		echo "pirla"
	else
		MINOR=$((MINOR + 1))
	fi
done
until [ -f ./kernel-generic-$MAJOR.$MINOR.$PATCH-*txz ]; do
	if [ -f ./kernel-generic-$MAJOR.$MINOR.$PATCH-*txz ]; then
		echo "pirla"
	else
		PATCH=$((PATCH + 1))
	fi
done
until [ -f ./kernel-generic-$MAJOR.$MINOR.$PATCH-x86_64-$BUILD.txz ]; do
	if [ -f ./kernel-generic-$MAJOR.$MINOR.$PATCH-x86_64-$BUILD.txz ]; then
		echo "pirla"
	else
		BUILD=$((BUILD + 1))
	fi
done
echo ""
echo "Il kernel $OLD sarà aggiornato alla versione $MAJOR.$MINOR.$PATCH-$BUILD"

upgradepkg kernel-generic-$MAJOR.$MINOR.$PATCH-x86_64-$BUILD.txz

upgradepkg kernel-huge-$MAJOR.$MINOR.$PATCH-x86_64-$BUILD.txz

upgradepkg kernel-modules-$MAJOR.$MINOR.$PATCH-x86_64-$BUILD.txz

upgradepkg kernel-headers-$MAJOR.$MINOR.$PATCH-x86-$BUILD.txz

upgradepkg kernel-source-$MAJOR.$MINOR.$PATCH-noarch-$BUILD.txz

VERSION=$MAJOR.$MINOR.$PATCH

echo "Installazione dei nuovi pacchetti completata"
mv -v kernel *.txz ../done

echo "Uscita dalla directory /packages/current/kernel"
echo "Ingresso nella directory /boot"
cd /boot
echo ""
echo "Esecuzione di mkinitrd ..."
mkinitrd -c -k $VERSION -m ext4 -l it -o /boot/initrd-generic-$VERSION.gz

echo ""
echo "Rimozione del vecchio initial ramdisk ..."
rm -v /boot/initrd-generic-$OLD.gz

echo "Aggiornamento dei link simbolici"
rm initrd-generic
ln -s initrd-generic-$VERSION.gz initrd-generic 
rm vmlinuz-generic
ln -s vmlinuz-generic-$VERSION vmlinuz-generic

echo "Aggiornamento del kernel completato"
echo ""
echo "Uscita dalla directory /boot"
echo "Ingresso nella directory /packages/sbo/sistema/sbo/nvidia-kernel"
cd /packages/sbo/sistema/sbo/nvidia-kernel
echo ""
echo "Aggiornamento dei moduli del driver nvidia ..."
echo "Avvio dello slackbuild nvidia-kernel.SlackBuild"
KERNEL=$VERSION ./nvidia-kernel.SlackBuild
echo ""
echo "Aggiornamento del pacchetto nvidia-kernel ..."
upgradepkg /tmp/nvidia-kernel*tgz

echo ""
echo "Uscita dalla directory /packages/sbo/sistema/sbo/nvidia-kernel"
echo "Ingresso nella directory /packages/sbo/sistema/sbo/virtualbox-kernel"
cd ../virtualbox-kernel

echo ""
echo "Aggiornamento dei moduli di virtualbox ..."
echo "Avvio dello slackbuild virtualbox-kernel.SlackBuild"
KERNEL=$VERSION ./virtualbox-kernel.SlackBuild
echo ""
echo "Aggiornamento del pacchetto virtualbox-kernel ..."
upgradepkg /tmp/virtualbox-kernel*tgz

echo ""
echo "Rimozione dei pacchetti generati dalla directory /tmp ..."
rm -v /tmp/*kernel*tgz

echo ""
echo "Aggiornamento della configurazione del sistema completata"
echo "ATTENZIONE! Se il kernel è stato aggiornato ad una nuova MAJOR release o una nuova MINOR release"
echo "prima di riavviare il sistema aggiorna i template in /etc/grub.d, poi esegui grub-mkconfig "
echo "e grub-install per aggiornare la configurazione del bootloader."
echo "Al termine puoi riavviare il sistema."

stendi un velo pietoso sulle righe "echo pirla". Di solito uso quell'output per intercettare degli errori nei debug, poi mi sono dimenticato di rimuoverli

I percorsi che fanno capo alle directory /packages/current/kernel /packages/sbo/sistema/sbo/nvidia-kernel e /packages/sbo/sistema/sbo/virtualbox-kernel si devono al fatto che pacchetti e slackbuild li gestico e li conservo in una partizione dedicata che monto in una directory /packages

Le varie reiterate righe di output (echo) sono finalizzate a individuare agevolmente la fase in cui si verifica un eventuale intoppo imprevisto. In ogni caso lo sto usando ormai da parecchi mesi e ormai è ben collaudato. L'unico imprevisto che ho incontrato relativamente recente si è verificato in un caso in cui il nuovo kernel scaricato era in realtà una ricompilazione del kernel già installato. Si trattava di un'eventualità che non avevo previsto. Se non ricordo male l'avevo corretto, ma non sono sicuro. In ogni caso l'imprevisto portava alla rimozione del initial ramdisk appena installato

[uboot]

super .... grazie mille !

[conraid]

Se posso permettermi di dare un suggerimento, meglio non fare upgradepkg del kernel, se quello nuovo per qualche motivo non va ti ritrovi senza kernel funzionante.
Io faccio installpkg e mi ritrovo così anche il vecchio kernel installato. Faccio il boot con il nuovo, e se tutto è ok allora rimuovo il vecchio.

[ZeroUno]

Io ho preso un'altra strada.
In /boot ho messo un vmlinuz sicuramente funzionante così se mi dimentico qualsiasi pezzo su lilo o altro o se non funge il pacchetto o il penultimo kernel è fallato, comunque ho una release certificata (da me stesso)

Così non devo gestire duplicati in /var/log/packages

[conraid]

Facevo anche io così, ma ora ho smesso di ricompilarmi i kernel, mi bastano quelli di Pat, quindi faccio in quel modo. L'importante è avere sempre un kernel sicuramente funzionante

[ZeroUno]

In verità qui abbiamo tutti le competenze per fare ognuno il suo in attesa che Pat si decida a fare qualcosa. (per esempio, da tanti anni sul readme della distribuzione c'è scritto "usa il kernel-generic e fatti un initrd e non usare l'huge" ma di fatto l'installer mette l'huge; solo recentemente l'installer ha uno script per creare un initrd in automatico e fa puntare vmlinuz a generic sotto alcune condizioni; tuttavia un upgradepkg kernel* fa ripuntare vmlinuz ad huge e se non fai azioni manuali con quello ti ritrovi)

Personalmente ho passato diverse fasi. Una di queste prevedeva la modifica di mkinitrd.conf per l'iniezione di roba custom.
Da un po' di tempo mi affido al plugin zlookkernel di slackpkg+ per manutenere l'initrd.

Il vmlinuz certificato altro non è che una versione huge di quello di Pat rinominato in vmlinuz-funzionante con relativa entry statica in lilo.conf che non varia nel tempo così se faccio qualche upgrade fallato quello c'è. In lilo ho una sezione con kernel-generic (default), una con kernel-huge e una con kernel-funzionante

[conraid]

Vero, anche che slackpkg possa gestire una cosa simile. Ora si limita a consigliare di mettere in blacklist il kernel.

Comunque io ho questi script

/boot/initrd.sh

Codice: Seleziona tutto

#!/bin/bash
#
# Script to automate kernel compilation
#
# Place this script in /usr/src, chmod +x it to make it executable
# This script must be run as root
#
set -eu


if [ ${1:-""} ]; then
  KERNELVERSION=$1
else
  KERNELVERSION=$(ls -l /boot/vmlinuz-generic | cut -d">" -f2 | cut -d- -f3)
fi

if [ -x /usr/sbin/iucode_tool ]; then
 if ! [ -e /boot/intel-ucode.cpio ]; then
  iucode_tool -v --write-earlyfw=/boot/intel-ucode.cpio /lib/firmware/intel-ucode{,-with-caveats}
 fi
fi
mkinitrd -F -k $KERNELVERSION
mv /boot/initrd.gz /boot/initrd-$KERNELVERSION.gz
ln -s /boot/initrd-$KERNELVERSION.gz /boot/initrd.gz

grub-mkconfig -o /boot/grub/grub.cfg

installkernel.sh

Codice: Seleziona tutto

#!/bin/sh

set -eu


MIRROR="/mnt/hd/mirror/slackware/slackware64-current/slackware64"

if ! [ -d $MIRROR ]; then
  mount /mnt/hd
  if ! [ -d $MIRROR ]; then
    echo "/mnt/hd non è montata"
    exit
  fi
fi

KV=$(echo $MIRROR/a/kernel-generic-*-x86_64-*.txt | rev | cut -d- -f3 | rev)
KR=$(echo $MIRROR/a/kernel-generic-*-x86_64-*.txt | rev | cut -d- -f1 | rev | cut -d. -f1)

echo Installo KERNEL $KV-x86_64-$KR
sleep 2

if [ -f "/var/lib/pkgtools/packages/kernel-generic-$KV-x86_64-$KR" ]; then
  echo "Kernel già installato"
else
  installpkg "$MIRROR/a/kernel-*-$KV-x86_64-$KR.txz"
  /boot/initrd.sh "$KV"
fi

sleep 3


DIRKT=$( ls /mnt/hd/mirror/slackware/slackware64-current/testing/packages/linux-* 2> /dev/null | wc -l)

if [ "$DIRKT" = 0 ]; then
  echo "Testing KERNEL DIR non esiste"
  exit
fi

MIRRORT="/mnt/hd/mirror/slackware/slackware64-current/testing"

KVT=$(echo $MIRRORT/packages/linux-*/kernel-generic-*-x86_64-*.txt | rev | cut -d- -f3 | rev)
KRT=$(echo $MIRRORT/packages/linux-*/kernel-generic-*-x86_64-*.txt | rev | cut -d- -f1 | rev | cut -d. -f1)
DIRVER=$(echo $MIRRORT/packages/linux-* | rev | cut -d- -f1 | rev)

echo Installo KERNEL $KVT-x86_64-$KRT
sleep 2

if [ -f "/var/lib/pkgtools/packages/kernel-generic-$KVT-x86_64-$KRT" ]; then
  echo "Kernel testing già installato"
else
  installpkg "$MIRRORT/packages/linux-$DIRVER/kernel-*-$KVT-x86_64-$KRT.txz"
  /boot/initrd.sh "$KVT"
fi

come vedi sono molto personali, hanno i percorsi che uso io etc... ho modificato ultimamente da quando ha messo il nuovo kernel in testing

gli sleep ci sono per darmi tempo di annullare se vedo che c'è un errore

[ZeroUno]

Per la cronaca sono in fase di fixing / improvements di slackpkg+, quindi ogni suggerimento è ben accetto.

Mi è balzata pure in testa l'idea di supportare pacchetti duplicati in lista proprio per gestire un multikernel o cose così senza dover blacklistare e fare a mano.

Da capire - prima della fattibilità - se può essere utile.

Poi zlookkernel ora gestisce lilo ed elilo e nella prossima release sarà abilitabile in configurazione. Potrebbe essere utile metterci pure grub ma non me lo sono mai studiato