Après la restauration du système avec les images, il faut recompiler le noyau.
Deux cas de figures peuvent se passer.
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.
vgchange -ay
Créer le dossier de montage.
mkdir /mnt/destination
Monter les deux volumes suivants.
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
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.
chroot /mnt/destination /bin/bash
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.
mv /root/sd* /dev
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.
mount /boot
Exécuter ensuite une procédure standard de compilation noyau.
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.
cd /usr/src/linux
Copie du .config dans /root.
cp .config /root/config.orig
make mrproper
Recopier le .config sauvegardé.
cp /root/config.orig ./.config
make menuconfig
Vérifier et activer les modules suivants.
Conserver le .config généré.
La configuration sera positionnée dans /usr/src/linux/arch/i386/boot/bzImage.
make dep clean bzImage (noyau 2.4) make clean bzImage (noyau 2.6)
2 fichiers créés.
setup (c’est le System.map) system
Le kernel se situe dans : arch/i386/boot/bzImage.
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)
make modules
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.
make modules_install
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).
depmod –ae –F /boot/System.map-2.6.22.8 2.6.22.8
Le dernier paramètre correspond au nom du dossier dans lequel se trouve les modules du kernel Linux (/lib/modules/2.6.22.8).
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
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.
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.
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
Sortir du chroot et rebooter.
exit reboot
Installer le GRUB.
Modifier le fichier /boot/grub/menu.lst en ajoutant les lignes nécessaires pour booter sur le nouveau noyau.
grub-install /dev/sda reboot
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
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
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.
mount /proc
On recompile le noyau.
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
Vérifier /etc/modules.conf (en particulier modules carte réseau et le bonding + fiber channel a mettre ( ?) en commentaire).
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
Réinstaller le chargeur de démarrage.
ALT+F2 ->umount /mnt/image/boot ALT+F1->mount /boot ALT+F1->grub-install /dev/sda
Vérifier les droits sur /tmp (drwxrwxrwt sinon les positionner avec chmod 777 /tmp)
chmod o+t /tmp
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.
/etc/init.d/kudzu start /etc/init.d/kudzu stop rm /dev/cdrom1
enlever la ligne du cdrom1 dans /etc/fstab.
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.
cd /var/www grep –R "#serveur_" *
Et remplacer l’occurence par l’information demandée.
mv ifenslave ifenslave.old mv ifenslave ifenslave
On demonte tout et on redémarre.
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
et enlever le cdrom ^^.
Je pars du principe qu'on est dans /usr/src et qu'on a déjà récupéré les sources du noyau.
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.
Ensuite on lance la compilation. Le fichier .config est utilisé à ce moment. C'est la partie suivante.
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/.
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.
Enfin :
dpkg --install linux-image-2.6.26-i2ldebian_1_i386.deb #installe le noyau et met grub à jour.
Procédure standard de la compilation d'un noyau.
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
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.
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 :
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
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
modprobe nommodule. lsmod #pour vérifier.
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.
rmmod nommodule #suppression en live. blacklist nommodule #à mettre dans /etc/modprobe.d/blacklist pour supprimer de manière pérenne.
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.
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.
patch -p1 < /chemin/vers/le/patch
La lecture de man patch est recommandée.
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.
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.
#!/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
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.
apt-get -y dist-upgrade #mise à jour y compris le kernel (par défaut le kernel n'est pas pris en compte).
C'est certainement la méthode la plus simple même si peut-être pas forcément la plus optimisée…