====== Compilation noyau =====

===== Généralités =====
[[http://fr.wikipedia.org/wiki/Noyau_Linux|Noyau Linux]].

===== Compilation Noyau =====

Après la restauration du système avec les images, il faut recompiler le noyau.

Deux cas de figures peuvent se passer.
  * Le système ne peut ne pas se lancer à cause d'une mauvaise reconnaissance matérielle, il faudra donc recompiler le noyau à partir du SRCD. Dans mon cas, la résolution utilisée par le système n’était pas supportée par mon écran ou le chipset graphique avait changé et je n'avais pas d'affichage. J'ai donc du utiliser le SRCD.
  * Le système boot correctement, on a accès à la console, on peut donc recompiler directement à partir du système. 

==== Le système ne demarre pas : Compilation à partir du SRCD ====

Lancer le SystemRescueCD (SRCD) sur le serveur en appuyant sur entrée.

Monter les volumes logiques correspondant à ''/usr'' et ''/boot'' avec les manipulations suivantes.
Activer le groupe de volume LVM nommé Mon_Linux.
<code>
vgchange -ay
</code>

Créer le dossier de montage.
<code>
mkdir /mnt/destination
</code>

Monter les deux volumes suivants.
<code>
mount -t ext3 /dev/Mon_Linux/Ma_Racine /mnt/destination/.
mount -t ext3 /dev/Mon_Linux/Mes_Programmes /mnt/destination/usr
mount -t ext3 /dev/Mon_Linux/Mon_Temporaire /mnt/destination/tmp
mount -t ext3 /dev/Mon_Linux/Mes_Logs /mnt/destination/var
</code>

Après ces manipulations, on peut se positionner en chroot sur le système installé sur le disque dur C’est à dire qu’on change de racine. On va faire les opérations comme si on était sur le système qui vient d’être restauré. A l’inverse, on ne veut pas que les commandes s’exécutent sur le CD Live.
<code>
chroot /mnt/destination /bin/bash
</code>

Le prompt en couleur du SRCD doit laisser place à un prompt de couleur blanche sur fond noir. A partir de maintenant, les conséquences des commandes ne sont plus répercutées sur le SRCD.
<code>
mv /root/sd* /dev
</code>
On est obligé de récupérer le descripteur de disque car il n’y a pas de daemon udev de lancé pour le système sur le disque avec un système live. Il faut donc récupérer le fichier correspondant au device du système stocké au préalable dans /root après la restauration). Un fichier sda1 doit être présent dans /root. Il a été ajouté après la procédure de restauration.
<code>
mount /boot
</code>

Exécuter ensuite une procédure standard de compilation noyau.

==== Procédure standard de compilation ====

Si le système boot ou si vous venez de l’étape précédente, voici ce qu’il faut réaliser pour compiler le noyau Linux.
<code>
cd /usr/src/linux
</code>

Copie du .config dans ''/root''.
<code>
cp .config /root/config.orig
</code>

=== Nettoyage profond des sources ===

<code>
make mrproper
</code>

Recopier le .config sauvegardé.
<code>
cp /root/config.orig ./.config
</code>

=== Paramétrage de la configuration noyau ===

<code>
make menuconfig
</code>

Vérifier et activer les modules suivants.
  * Processor type and features
    * SMP ?
    * Processor family (P4, Xeon…)
    * Max CPU
    * Memoire high Memory (4 Go ou jusqu’à 64 Go)

  * Device drivers
    * ATA/ATAPI
    * SCSI device support
      * SCSI low-level drivers
        * QLAxxx
        * LSI
    * SATA
    * Fusion MPT device support
      * Support LSI 
    * Device Drivers
      * Network device support
        * Ethernet (10 or 100Mbit)
          * VIA Rhine support (Carte réseau D-Link DFE-530TX)
        * Fibre Channel driver support
    * Character device (tout AGP)
      * /dev/agpgart
    * Graphics support
      * Display device support
        * Display panel/monitor support
      * VGA 16-color graphics support
      * Console display driver support 
        * Framebuffer console support

Conserver le ''.config'' généré.

=== Générer le noyau ===

La configuration sera positionnée dans ''/usr/src/linux/arch/i386/boot/bzImage''.
<code> 
make dep clean bzImage (noyau 2.4)
make clean bzImage (noyau 2.6)
</code>

2 fichiers créés.
<code>
setup (c’est le System.map)
system
</code>

Le kernel se situe dans : ''arch/i386/boot/bzImage''.

=== Copier les fichiers générés en conservant les anciens ===

<code>
mv /boot/System.map-2.6.22.8 /boot/System.map-ancien (renommer)
cp System.map /boot/System.map-2.6.22.8
mv /boot/vmlinuz-2.6.22.8 /boot/vmlinuz-ancien (renommer)
cp arch/i386/boot/bzImage /boot/vmlinuz-2.6.22.8 (écraser l’ancien. Changer i386 par l’architecture ex : x86_64)
</code>

=== Compiler les modules ===

<code>
make modules
</code>

La commande compile les modules qui ne sont pas cochés comme intégrés au noyau mais noté en module (M). Elle les positionne dans ''/usr/src/linux/lib/''. Elle créée les.ko.

=== Installer les modules. ===

<code>
make modules_install
</code>

Il fait une simple copie des modules de ''/usr/src/linux/lib/'' dans ''/lib/modules/nomnoyau''.

Vérifier ''/etc/modules.conf'' ou ''/etc/modprobe.conf'' sur les noyaux récents (en particulier modules carte réseau et le bonding + fiber channel a mettre (?) en commentaire).

=== Résoudre les dépendances des modules du noyau ===

<code>
depmod –ae –F /boot/System.map-2.6.22.8 2.6.22.8
</code>
Le dernier paramètre correspond au nom du dossier dans lequel se trouve les modules du kernel Linux (''/lib/modules/2.6.22.8'').

=== Créer le fichier de ramdisk ===

<code>
mv /boot/initrd-2.6.22.8.img /boot/initrd.img-ancien (renommer)
mkinitrd /boot/initrd-2.6.22.8.img 2.6.22.8
</code>
Le dernier paramètre correspond au nom du dossier dans lequel se trouve les modules du kernel Linux (''/lib/modules/2.6.22.8'').
Ce fichier contient les modules bas niveaux nécessaires au démarrage de la machine. Par exemple si on utilise LVM, il faut qu’il soit intégré au démarrage pour pouvoir monter les volumes. De même que le module SCSI doit être présent si on dispose de disque SCSI.

Il ne reste plus que l’installation de GRUB avant de redémarrer pour tester.

=== Installation GRUB via SRCD ===

Uniquement si compilation à partir du SRCD.

Installer le GRUB.
Modifier le fichier ''/boot/grub/menu.lst'' en ajoutant les lignes nécessaires pour booter sur le nouveau noyau.
<code>
grub-install /dev/sda
umount /boot
mv /dev/sda* /root #ceci car il n’y a pas de daemon udev de lancé pour le système sur le disque avec un système live
</code>
Sortir du chroot et rebooter.
<code>
exit
reboot
</code>

=== Installation GRUB sur un système normalement booté ===

Installer le GRUB.
Modifier le fichier ''/boot/grub/menu.lst'' en ajoutant les lignes nécessaires pour booter sur le nouveau noyau.
<code>
grub-install /dev/sda
reboot
</code>

===== Récapitulatif des commandes de compilation noyau =====

==== Installation noyau methode debian ====

<code>
uname -a
uname -r
uname -v
df -h
cd /usr/src/
ll
dpkg -l binutils
apt-get install binutils bzip2
dpkg -l binutils
dpkg -l bzip2
dpkg -l | grep kernel
cat /etc/group
cat /etc/group | less
cat /proc/cpuinfo 
apt-cache search ^linux-source
apt-cache search ^kernel-source
apt-cache search ^linux-source
apt-get install lshw
lshw > /root/infos.txt
vi /root/infos.txt 
apt-cache search ^linux-source
apt-get install linux-source-2.6.26
tar jxvf linux-source-2.6.26.tar.bz2 
chmod 700 linux-source-2.6.26
apt-get remove linux-source-2.6.26
df -hT
apt-get clean
df -hT
ln -s /usr/src/linux-source-2.6.26/ linux
vi /usr/src/linux/Documentation/Changes 
apt-get install gcc make binutils util-linux module-init-tools oprofile e2fsprogs procps udev libncurses5-dev kernel-package initramfs-tools cramfsprogs debconf-utils build-essential
cd linux
ls -a
apt-get clean
man apt-get
cp -i /boot/config-2.6.24-1-686 .
ll
make menuconfig
diff /boot/config-2.6.24-1-686 .config 
cp .config /root/saveconfig
mv /root/saveconfig /root/config-2.6.26
ll /root/
make-kpkg --initrd --revision1 --append-to-version=-i2ldebian kernel-image
make-kpkg --initrd --revision 1 --append-to-version=-i2ldebian kernel-image
cd ..
dpkg --install linux-image-2.6.26-i2ldebian_1_i386.deb 
cd linux
make-kpkg clean
cd arch/x86/boot/
uname -a
reboot
uname -a
cp /usr/src/linux/.config /root/saveconfigOK-2.6.26
cd
cp /usr/src/linux-image-2.6.26-i2ldebian_1_i386.deb /root/
cd
du -sh *
mkdir noyau
mv linux-image-2.6.26-i2ldebian_1_i386.deb noyau/
mv saveconfigOK-2.6.26 noyau/
mv config_i2ldebian_2.6.26 noyau/
reboot
vi infos.txt 
uname -a
lsmod
cd noyau/
reboot
cd noyau/
cd /usr/src/linux/arch/x86/boot/
du -sh *
cd ..
du -sh *
du -sh boot/
vi boot/install.sh 
htop 
vi /boot/grub/menu.lst
vi /etc/fstab 
du -sh boot/
ll boot/
ll /lib/modules/
ll /lib/modules/
cd /usr/src/
cd linux
vi Makefile 
cd /boot/
rm config-2.6.26-i2lmain 
rm vmlinuz-2.6.26-i2lmain 
rm System.map-2.6.26-i2lmain 
cd noyau/
cd ..
cd /usr/src/
cd linux
cd
</code>

==== Installation noyau manuelle ====

<code>
apt-get remove --purge linux-image-2.6.26-i2ldebian_1_i386.deb
apt-get remove --purge linux-image-2.6.26-i2ldebian_1
uname -a
apt-cache search linux-image
apt-get remove --purge linux-image-2.6.26-i2ldebian
vi /boot/grub/menu.lst
cd /usr/src/linux
ll .config 
make mrproper
cp /root/noyau/saveconfigOK-2.6.26 ./.config
ll .config 
vi Makefile 
make menuconfig
cd ..
du -sh *
rm linux-image-2.6.26-i2ldebian_1_i386.deb 
du -sh *
cd linux
ll arch/x86/boot/
ll drivers/
make
make modules_install
ll /lib/modules/
du -sh /usr/src/linux/arch/x86/boot/
du -sh /usr/src/linux/arch/x86/boot/*
ll /boot/
cp -i arch/x86/boot/bzImage /boot/vmlinuz-2.6.26-i2ldebian
cp -i System.map /boot/System.map-2.6.26-i2ldebian
cp -i .config /boot/config-2.6.26-i2ldebian
mkinitramfs -o /boot/initrd.img-2.6.26-i2ldebian /lib/modules/2.6.26-i2ldebian
cd /
mv vmlinuz vmlinuz.old 
ln -si boot/vmlinuz-2.6.26-i2ldebian vmlinuz
mv initrd.img initrd.img.old 
ln -si boot/initrd.img-2.6.26-i2ldebian initrd.img
ln -si boot/System.map-2.6.26-i2ldebian System.map
cd /boot/grub/
cp menu.lst menu.lst.orig
vi menu.lst
update-grub  //ajoute le mode single-user automatiquement tant qu'on ecrit au-dessus de ###END DEBIAN
vi menu.lst
uname -a
reboot
uname -a
cd /boot/
cd
history > noyau/lstcdes.txt
</code>

===== Création noyau d’un master (méthode succincte et incomplète) =====

On laisse la restauration se finir c’est l’heure de prendre le café.

On change la racine sur le terminal 1 ''chroot /mnt/image /bin/bash''. La racine de ce terminal devient la racine du systeme que l’on vient de restaurer. 

On monte le pseudo systeme de fichier ''/proc''.
<code>
mount /proc
</code>

On recompile le noyau.
<code>
cd /usr/src/linux
make menuconfig
Vérifier les options processeur (mémoire haute type et nombre de processeurs).
Vérifier le support du port parallèle
Vérifier le support de la disquette.
Vérifier le support des disques IDE  + chipset IDE (lspci –v)
Vérifier le nombre de disque et CDROM SCSI + le driver low level scsi (attention qlogic ce n’est pas la cf fusion). 
Vérifier les cartes réseau et le bonding
Le type de souris /clavier (ps2/usb)
Verifier Carte son chipset graphique
Verifier support usb
Sauvergarder la config
make dep clean bzImage
cp System.map /boot/System.map-2.4.32
cp arch/i386/boot/bzImage /boot/vmlinuz-2.4.32
make modules
make modules_install
</code>

Vérifier ''/etc/modules.conf'' (en particulier modules carte réseau et le bonding + fiber channel a mettre ( ?) en commentaire).
<code>
depmod –ae –F /boot/System.map-2.4.32 2.4.32
rm /boot/initrd-2.4.32.img
mkinitrd /boot/initrd-2.4.32.img 2.4.32
</code>

Réinstaller le chargeur de démarrage.
<code>
ALT+F2 ->umount /mnt/image/boot
ALT+F1->mount /boot
ALT+F1->grub-install /dev/sda 
</code>

Vérifier les droits sur ''/tmp'' (''drwxrwxrwt'' sinon les positionner avec chmod 777 /tmp) 
<code>
chmod o+t /tmp
</code>

Vérification du fichier ''/etc/fstab'' (en particulier la partition de boot). Sauvegarder et vérifier ce que pointe ''/dev/cdrom'' du fichier (''ls –al /dev/cdrom''). Si on utilise l’emulation scsi-ide il devra etre un lien symbolique vers ''/dev/scd0'' si on ne l’utilise pas (Fedora Core) un lien vers ''/dev/hd(a|b|c|d)'' en fonction du controleur.

Vérification du fichier ''/etc/grub.conf'' en particulier le cdrom avec le module ide-scsi (hdx=ide-scsi) dans la ligne du kernel de la legacy pour une RH9.

Vérfication du fichier ''/boot/grub/device.map'' (périphérique disque dur a positionner en scsi (ligne (hd0) /dev/sdxy)).

Vérification du fichier ''/etc/sysconfig/grub'' (idem que précédemment).

Utiliser Kudzu pour le matériel.
<code>
/etc/init.d/kudzu start
/etc/init.d/kudzu stop
rm /dev/cdrom1
</code>
enlever la ligne du cdrom1 dans ''/etc/fstab''.

<code>
cd /etc/
grep –R "#serveur_" *
Et remplacer toutes occurrences par les informations demandées
ATTENTION A LA CASSE sur ''/etc/krb5.conf'' et config authentification radius apache.
</code>

<code>
cd /var/www
grep –R "#serveur_" *
</code>
Et remplacer l’occurence par l’information demandée.

<code>
mv ifenslave ifenslave.old
mv ifenslave ifenslave
</code>

On demonte tout et on redémarre.
<code>
umount /boot
umount /proc
exit (on sort du chroot)
umount /mnt/image/var
umount /mnt/image/tmp
umount /mnt/image/opt
umount /mnt/image/home
umount/mnt/image/data
umount /mnt/usbstor1
umount /mnt/image
reboot
</code>

et enlever le cdrom ^^.

===== Commandes pour intégrer des modules/drivers additionnels lors de la compilation et l'installation du noyau =====

==== Méthode Debian et méthode manuelle ====

Je pars du principe qu'on est dans ''/usr/src'' et qu'on a déjà récupéré les sources du noyau.
<code>
tar jxvf linux-source-2.6.26.tar.bz2 #extraire les sources du noyau.
ln -s /usr/src/linux-source-2.6.26/ linux #lier linux à nos sources.
vi /usr/src/linux/Documentation/Changes #vérifier qu'on a tout ce qui faut pour compiler en vérifiant la section "requirements".
cp -i /boot/config-2.6.24-1-686 ./.config #récupérer si possible une configuration déjà faite. Sinon, moi j'installe lshw pour connaître le matériel et je configure le noyau avec l'aide de cet outil.
zcat /proc/config.gz > /usr/src/linux/.config #récupérer configuration actuel du noyau.
make menuconfig #outils de personnalisation du fichier .config pour sélectionner les parties qu'on veut intégrer au noyau en dur, en tant que module, ou pas du tout.

vi Makefile #Mettre une valeur à EXTRAVERSION pour positionner les modules dans une autre arborescence de dossier que celle en cours.
</code>

Ensuite on lance la compilation. Le fichier ''.config'' est utilisé à ce moment. C'est la partie suivante.

=== Méthode Debian ===

Compilation avec ajout de module externe à son noyau (module nvidia, module de son...)
Récupérer la source du module via apt ou à la main et extraire le contenu du module dans ''/usr/src/modules/''.
<code>
make-kpkg --initrd --revision 1 --append-to-version=-i2ldebian kernel-image --added_modules=nommodule #compile le noyau avec le module externe et création du paquet .deb.
</code>

Enfin :
<code>
dpkg --install linux-image-2.6.26-i2ldebian_1_i386.deb #installe le noyau et met grub à jour.
</code>

=== Méthode manuelle ===

Procédure standard de la compilation d'un noyau.
<code>
make #compilation du noyau.
make modules_install #installation des modules dans /lib/modules/nomkernel.
cp -i arch/x86/boot/bzImage /boot/vmlinuz-2.6.26-i2ldebian #copie du noyau.
cp -i System.map /boot/System.map-2.6.26-i2ldebian #copie du fichier de mapping.
cp -i .config /boot/config-2.6.26-i2ldebian #copie de la configuration pour la sauvegarder.
mkinitramfs -o /boot/initrd.img-2.6.26-i2ldebian /lib/modules/2.6.26-i2ldebian #création du fichier de RAM disque.
vi /boot/grub/menu.lst #modifier le grub en fonction d'un exemple (changer uniquement les versions noyau en général).
update-grub #mettre à jour grub
</code>

On ne peut ajouter un module pendant l'installation. C'est seulement après l'avoir fait qu'on gère l'ajout d'un module supplémentaire. C'est la partie suivante.

===== Intégrer des modules/drivers additionnels mais de manière séparée en supposant le noyau déjà compilé =====

==== Méthode Debian et manuelle ====

Le noyau est déjà compilé (avec les commandes make, make modules_install...) mais on veut ajouter un module qui n'est pas présent (très souvent pour supporter un matériel particulier).

Procédure classique de compilation d'un module (détaillé dans les fichiers README ou INSTALL avec les sources).
Récupérer le module du constructeur du module sur son site officiel par exemple.
En utilisateur de base :
<code>
tar xvp archive
./configure --help //voir les options de configurations
./configure --prefix=endroit_ou_installer
make //compiler les sources
su -c root 'make install' //installation
</code>

Les commandes précédentes vont ajouter le module automatiquement dans l'arborescence des modules du noyau ''/lib/modules/2.6.26...../kernel/drivers/categorie_modules....''

Une fois cette opération réalisée, on peut charger le module avec la commande 
<code>
modprobe nommodule.
lsmod #pour vérifier.
</code>

Si tout fonctionne bien, on peut faire en sorte que le module soit chargé au démarrage en ajoutant le nom du module au fichier ''/etc/modprobe.conf'' (qui a remplacé le fichier ''/etc/modules'' mais pas dans toutes les distributions).

Il est intéressant aussi de pouvoir enlever un ancien module qui ne fonctionne pas bien.
<code>
rmmod nommodule #suppression en live.
blacklist nommodule #à mettre dans /etc/modprobe.d/blacklist pour supprimer de manière pérenne.
</code>

De plus en plus, les modules externes sont fournis avec le système DKMS (Dynamic Kernel Module Support) pour la gestion dynamique des modules.
Ce système développé par l'équipe Dell permet de conserver un module additionnel d'un noyau dans les autres noyaux. Ainsi, à chaque mise à jour ou compilation d'un nouveau noyau le module additionnel fait partie du nouveau noyau obtenu. On utilise cet outil via le gestionnaire de paquet de la distribution ce qui limite les manipulations manuelles et simplifie l'installation.

===== Méthode/outils pour ajouter un patch au noyau =====

==== Méthode Debian et méthode manuelle ====

Récupérer le patch.
Le décompresser avec tar.
Ensuite, patcher un noyau requière de se placer à la racine des sources du noyau (/usr/src/linux) puis d'entrer la commande patch.
<code>
patch -p1 < /chemin/vers/le/patch
</code>
La lecture de man patch est recommandée.


===== Est-il possible d'automatiser de manière périodiques toutes les étapes précédentes (détection de l'apparition d'une nouvelle version ou d'un nouveau patch du noyau, récupération des sources, configuration (basé sur l'ancienne configuration par exemple), compilation et éventuellement installation ? L'installation ne sera pas automatiquement lancée par soucis de stabilité du système =====

==== Méthode Debian et manuelle ====

Il est bien sûr possible d'automatiser toutes les tâches sans exception notamment à l'aide d'un script bash. Pour une partie des tâches c'est intéressant (récupération automatique des nouvelles sources, position dans le bon dossier, pourquoi pas alerte mail lorsque ceci est fait...) mais l'installation automatique est selon moi très peu intéressante, surtout sur un système en production.

===== Si des outils libres (scripts, paquets) existent, préciser l'URL permettant d'y accéder et joignez une copie de la page html relative à l'URL à votre compte-rendu =====

Voici un script shell qui simplifie la compilation kernel. Il utilise un mode graphique d'ailleurs nommé Xdialog. Le script suivant aurait besoin d'une modification pour prendre en compte la récupération des sources de manière automatique et on pourrait supprimer la gestion graphique et l'interactivité mise en place. Ensuite, on peut l'exécuter périodiquement à l'aide d'une tâche cron.
<code>
#!/bin/sh

# This little script is aimed at easing the Linux kernel compilation and
# installation. No guarantee is given on its suitability to your own system
# though.

function check_error() {
        ret=$?
        if (( $ret != 0 )) ; then
                echo "Error while building the kernel..."
                exit $ret
        fi
}

TITLE="Linux kernel compilation"
MAKE="/tmp/make.$$"
TEMP="/tmp/kernel-compilation.log"

echo >$TEMP
/bin/ln -s /usr/bin/make $MAKE
check_error

(
/bin/sleep 1

cd /usr/src/linux
check_error

Xdialog --title "$TITLE" --yesno "make mrproper first ?" 0 0
if (( $? == 0 )) ; then
        echo "--------------------------------------------------------------------------"
        echo "Making mrproper..."
        echo "--------------------------------------------------------------------------"
        $MAKE mrproper 2>&1
        check_error
fi

if [ -f /usr/src/linux/.config ] ; then
        Xdialog --title "$TITLE" --yesno "Configure the kernel ?" 0 0
        if (( $? == 0 )) ; then
                echo "--------------------------------------------------------------------------"
                echo "Making xconfig..."
                echo "--------------------------------------------------------------------------"
                $MAKE xconfig 2>&1
                check_error
        fi
else
        echo "--------------------------------------------------------------------------"
        echo "Making xconfig..."
        echo "--------------------------------------------------------------------------"
        $MAKE xconfig 2>&1
        check_error
fi
echo "--------------------------------------------------------------------------"
echo "Making depends..."
echo "--------------------------------------------------------------------------"
$MAKE dep 2>&1
check_error
echo "--------------------------------------------------------------------------"
echo "Cleaning up..."
echo "--------------------------------------------------------------------------"
$MAKE clean 2>&1
check_error
echo "--------------------------------------------------------------------------"
echo "Making kernel..."
echo "--------------------------------------------------------------------------"
$MAKE bzImage 2>&1
check_error
echo "--------------------------------------------------------------------------"
echo "Making modules..."
echo "--------------------------------------------------------------------------"
$MAKE modules 2>&1
check_error
echo "--------------------------------------------------------------------------"
echo "Installing modules..."
echo "--------------------------------------------------------------------------"
$MAKE modules_install 2>&1
check_error

VERSION=`/bin/grep UTS_RELEASE /usr/src/linux/include/linux/version.h | /bin/awk --source '{ print $3 }'`
echo -n "VERSION=" >/tmp/version.$$
echo $VERSION >>/tmp/version.$$
. /tmp/version.$$
/bin/rm -f /tmp/version.$$
echo "--------------------------------------------------------------------------"
echo "Installing kernel v$VERSION... "
echo "--------------------------------------------------------------------------"
/bin/cp -f /usr/src/linux/.config /boot/config-$VERSION 2>&1
/bin/cp -f /usr/src/linux/System.map /boot/System.map-$VERSION 2>&1
/bin/cp -f /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-$VERSION 2>&1
if [ -f /boot/module-info-`uname -r` ] && ! [ -f /boot/module-info-$VERSION ] ; then
        /bin/cp -f /boot/module-info-`uname -r` /boot/module-info-$VERSION 2>&1
fi
Xdialog --title "$TITLE" --yesno "Make the new kernel the current one ?" 0 0
if (( $? == 0 )) ; then
        echo "--------------------------------------------------------------------------"
        echo "Making v$VERSION the current kernel... "
        echo "--------------------------------------------------------------------------"
        /bin/ln -sf /boot/System.map-$VERSION /boot/System.map 2>&1
        /bin/ln -sf /boot/vmlinuz-$VERSION /boot/vmlinuz 2>&1
        if [ -f /boot/module-info-$VERSION ] ; then
                /bin/ln -sf /boot/module-info-$VERSION /boot/module-info 2>&1
        fi
        if [ -f /boot/map ] && [ -f /sbin/lilo ] && [ -f /etc/lilo.conf ] ; then
                Xdialog --title "$TITLE" --yesno "Install the new kernel with lilo ?" 0 0
                if (( $? == 0 )) ; then
                        echo "--------------------------------------------------------------------------"
                        echo "Running lilo... "
                        echo "--------------------------------------------------------------------------"
                        /sbin/lilo 2>&1
                fi
        fi
fi
echo ""
echo "done !"
) | /bin/cat >$TEMP &

PID=$!

Xdialog --title "$TITLE" --no-button --smooth --tailbox $TEMP 40 80
/usr/bin/killall $MAKE 2>/dev/null
kill $PID 2>/dev/null
/bin/rm -f $MAKE
echo >$TEMP
</code>

Lien d'accès : http://www.google.com/codesearch?hl=fr&q=kernel+compil+show:L1u61kgVIDo:CC5wg5RO01Q:HQ0-r8RknkI&sa=N&cd=3&ct=rc&cs_p=http://gentoo.osuosl.org/distfiles/Xdialog-2.2.1.tar.bz2&cs_f=Xdialog-2.2.1/samples/kernel

Si on n'utilise pas cette architecture de script, il existe toujours la méthode classique d'un script shell qui utilise le gestionnaire de paquetage (apt-get sous Debian) pour récupérer et installer le dernier noyau automatiquement. Il récupérera tout seul l'ancienne configuration déjà présente. 
<code>
apt-get -y dist-upgrade #mise à jour y compris le kernel (par défaut le kernel n'est pas pris en compte).
</code>
C'est certainement la méthode la plus simple même si peut-être pas forcément la plus optimisée...