My-kernel-2.6
From LUGUM
Dieses Script ermöglicht ein einfaches kompillieren von einem Kernel sowie dem Nvidia Modul und nimmt alle Arbeiten bis auf das konfigurieren ab. Es funktioniert sowohl unter Debian Sarge als auch unter Debian Sid. Unter Debian Etch wurde es von mir noch nicht getestet.
#!/bin/bash
# author: Andreas Kraus <lug@ak1301.de>
# $Revision: 0.5.2 $
#
# licence: GPL
# http://www.gnu.org/licenses/gpl.html
#
# Soll nach Nvidia und lilo gefragt werden
ASK_LILO=1
ASK_NVIDIA=1
LANG=C
KERNEL_ORG='kernel.org'
FTP_KERNEL_ORG="ftp.${KERNEL_ORG}"
WWW_KERNEL_ORG="www.${KERNEL_ORG}"
KERNEL_ORG_PATH="/pub/linux/kernel"
LINUX_ALT='/linux_alt'
LYNX=/usr/bin/lynx
GPG=/usr/bin/gpg
WGET=/usr/bin/wget
DIALOG=/usr/bin/dialog
PERL=/usr/bin/perl
SRC_ROOT='/usr/src'
ARCHIV='/kernelsource' # Ordner wo die Heruntergeladenen Kernelsources abgelegt werden
MAKE_KPKG=/usr/bin/make-kpkg
now=`date +%Y%m%d`
NCURSES=libncurses5-dev
PATCHES="${SRC_ROOT}/patches"
LABEL=" --no-label Nein --yes-label Ja"
GPG_WAIT=10
DMIDECODE=/usr/sbin/dmidecode
if [ ! $UID -eq 0 ]; then
echo "Sie muessen dieses Script als Root ausfuehren."
exit 1
fi
if [ ! $# -ne 1 ]; then
clear
cat << EOF
my-kernel-2.6 Version 0.5
Es werden diverse Ordner zum leichteren Installieren angelegt.
Verzeichnisstrucktur:
kernelsource
Hier werden die Quellpaktete automatisch abgelegt oder von
Hand wenn man keine Internet Verbindung hat
linux
Linux Source
linux_alt
Alte Versionen von linux
pakete
Fertige Debian Pakete
patches
Alle Patches in diesem Ordner werden auf die Kernelquellen angewendet.
Wenn sie in einer bestimmten Reihenfolge angewendet werden muessen, bitte
eine Zahl zur Reihenfolge vor den Patch stellen.
EOF
exit 0
fi
FEHLT=""
for f in $WGET $LYNX $DIALOG $MAKE_KPKG $GPG $PERL $DMIDECODE ; do
if ! [ -x $f ]; then
FEHLT="$FEHLT $f,"
fi
done
if [ "$FEHLT" ]; then
echo "Das Programm/ Die Programme $FEHLT ist/sind nicht installiert oder ist nicht ausfuerbar, bitte erst Installieren"
exit 1
fi
for f in $NCURSES; do
dpkg -s $f | grep -q "^Status: install ok installed" 2> /dev/null
installed=$?
if [ $installed -eq 1 ]; then
echo ""
echo "Achtung!"
echo "Das Paket $f ist nicht installiert, bitte erst Installieren"
echo ""
exit 1
fi
done
debian_version () {
grep -qE "3.1" /etc/debian_version
if [ $? -ne 0 ]; then
PAKETNAME=linux-image-${real_version}${append_to_version}_${real_version}${append_to_version}-10.00.Custom_i386.deb
PAKETNAME_HEADERS=linux-headers-${real_version}${append_to_version}_${real_version}${append_to_version}-10.00.Custom_i386.deb
PAKETNAME_NVIDIA=nvidia-kernel-${real_version}${append_to_version}_`dpkg -s nvidia-kernel-source | grep Version | cut -f 2 -d " "`+${real_version}${append_to_version}-10.00.Custom_i386.deb
else
PAKETNAME=kernel-image-${real_version}${append_to_version}_10.00.Custom_i386.deb
PAKETNAME_HEADERS=kernel-headers-${real_version}${append_to_version}_10.00.Custom_i386.deb
PAKETNAME_NVIDIA=nvidia-kernel-${real_version}${append_to_version}_`dpkg -s nvidia-kernel-source | grep Version | cut -f 2 -d " "`+10.00.Custom_i386.deb
fi
}
# Patcht den kernel mit allen Dateien die in /usr/src/patches/ liegen
own_patches (){
if [ ! -d $PATCHES ]; then
mkdir -p $PATCHES
fi
$DMIDECODE | grep "Product Name: Precision M70" > /dev/null 2>&1
IS_PRECISION=$?
if [ $IS_PRECISION -eq 0 ]; then
$PERL -pi -e "s/undef ATA_ENABLE_PATA/define ATA_ENABLE_PATA/" ${SRC_ROOT}/linux/include/linux/libata.h
# vi ${SRC_ROOT}/linux/include/linux/libata.h +44
fi
if [ -d $PATCHES ]; then
cd ${SRC_ROOT}/linux
for f in $PATCHES/*; do
patch -p1 < $f
done
fi
}
# Fragt den Kerneltree ab
ask_kernel_tree(){
KERNELTREE=`$DIALOG --title 'Kernel Version' --stdout --nocancel --menu 'Welcher Kernel soll kompiliert werden?' 9 70 2 2.6 Kerneltree 2.4 Kerneltree`
if [ "$KERNELTREE" = "2.6" ]; then
VERSION=`$LYNX -source http://www.kernel.org/kdist/finger_banner | awk '/latest stable/ { print $10 }'`
fi
if [ "$KERNELTREE" = "2.4" ]; then
VERSION=`$LYNX -source http://www.kernel.org/kdist/finger_banner | awk '/latest 2.4/ { print $10 }'`
fi
}
# Fragt ob der Kernel installiert werden soll, ansonsten bricht das Script ab
ask_install_kernel() {
$DIALOG --title 'Installieren?' --stdout $LABEL --yesno "Soll der Kernel $VERSION installiert werden?" 5 70
if ! [ $? -eq 0 ]; then
echo "Abbruch"
exit 1
fi
}
# Fragt ab, welche Append_to_Version angehängt werden soll
append_to_version (){
APPEND_TO_VERSION=`$DIALOG --stdout --inputbox "Bitte die Append_to_Version angeben" 8 70`
}
# Fragt nach ob man Online ist, ansonsten werden die bereits heruntergeladenen Pakete verwendet.
ask_online () {
# are we online?
dialog --title 'Internet' --stdout --no-cancel $LABEL --yesno "Besteht eine Internet Verbindung zum Online Update der Quellen?" 5 70
if [ $? -eq 0 ]; then
online=1
else
online=0
fi
}
# Fragt ob die Lilo Automatisch geschrieben werden soll.
ask_lilo () {
$DIALOG --title 'Lilo' --stdout --no-cancel $LABEL --yesno "Soll die Lilo Config Automatisch geschrieben werden" 5 70
if [ $? -eq 0 ]; then
lilo=0
$DIALOG --title 'Lilo' --stdout --no-cancel $LABEL --yesno "Soll der aktuelle Kernel als default gebootet werden?" 5 70
if [ $? -eq 0 ]; then
lilo_default=0
else
lilo_default=1
fi
else
lilo=1
fi
}
# Liest die aktuelle Version in /usr/src/linux aus
read_this_version () {
makefile_version=`grep "^VERSION" ${SRC_ROOT}/linux/Makefile | head -n 1 | cut -d "=" -f 2 | awk '{print $1}'`
makefile_patchlevel=`grep "^PATCHLEVEL" ${SRC_ROOT}/linux/Makefile | head -n 1 | cut -d "=" -f 2 | awk '{print $1}'`
makefile_sublevel=`grep "^SUBLEVEL" ${SRC_ROOT}/linux/Makefile | head -n 1 | cut -d "=" -f 2 | awk '{print $1}'`
makefile_extraversion=`grep "^EXTRAVERSION" ${SRC_ROOT}/linux/Makefile | head -n 1 | cut -d "=" -f 2 | awk '{print $1}'`
version=${makefile_version}.${makefile_patchlevel}.${makefile_sublevel}${makefile_extraversion}
}
# Laed den Public Key herunter, falls benoetigt.
get_public_key () {
$GPG --fingerprint 0x517D0F0E > /dev/null 2>&1
result=$?
if [ $result -ne 0 ]; then
if [ $online -ne 1 ]; then
L1="Um den \"Linux Kernel Archives Verification Key\" herunterzuladen, benoetigen wir eine Internetverbindung!\n\n"
L2="Ohne diesen Schluessel koennen wir die Kernel-Signatur nicht ueberpruefen."
$DIALOG --title 'Achtung !' --msgbox "${L1}${L2}" 8 85
else
$GPG --keyserver wwwkeys.de.pgp.net --recv-keys 0x517D0F0E
fi
fi
$GPG --fingerprint 0x517D0F0E | grep -q "C75D C40A 11D7 AF88 9981 ED5B C86B A06A 517D 0F0E"
if [ $? -ne 0 ]; then
L1="Der Fingerprint vom \"Linux Kernel Archives Verification Key\"\nist nicht"
L2="Gueltig oder nicht Installiert.\n\nSoll abgebrochen werden?"
$DIALOG --title 'Fehler' --stdout --no-cancel $LABEL --yesno "${L1}${L2}" 8 70
if [ $? -eq 0 ]; then
echo "Abbruch ..."
exit 1
fi
fi
}
# Laed den kernel runter, und packt ihn nach /usr/src/linux aus
download_kernel(){
if [ ! -d ${SRC_ROOT}${ARCHIV} ]; then
mkdir -p ${SRC_ROOT}${ARCHIV}
fi
cd ${SRC_ROOT}${ARCHIV}
$DIALOG --title 'Download' --infobox "Die Kernelquellen werden Heruntergeladen (${VERSION})\n\nEinen Augenblick bitte." 5 80
if [ ! -f "linux-${VERSION}.tar.bz2" ]; then
$WGET "ftp://${FTP_KERNEL_ORG}/pub/linux/kernel/v${KERNELTREE}/linux-${VERSION}.tar.bz2"
if ! [ $? -eq 0 ]; then
echo "Download ist Fehlgeschlagen"
exit 1
fi
fi
if [ ! -f "linux-${VERSION}.tar.bz2.sign" ]; then
$WGET "ftp://${FTP_KERNEL_ORG}/pub/linux/kernel/v${KERNELTREE}/linux-${VERSION}.tar.bz2.sign"
if ! [ $? -eq 0 ]; then
echo "Download ist Fehlgeschlagen"
exit 1
fi
fi
}
# Fragt nach ob Nvidia installiert werden soll, und installiert es
ask_install_nvidia() {
$DIALOG --title 'Install' --stdout $LABEL --yesno "Soll das Nvidia Treiber Paket erstellt werden?" 6 70
if [ $? -eq 0 ]; then
nvidia=0
dpkg -s nvidia-kernel-source | grep -q "^Status: install ok installed" 2> /dev/null
nvidia_kernel_source=$?
if [ $nvidia_kernel_source -eq 1 ]; then
apt-get install nvidia-kernel-source
if ! [ $? -eq 0 ]; then
echo "Installieren der Nvidia-Kernel-Quellen ist Fehlgeschlagen"
exit 1
fi
fi
fi
}
# Fragt nach ob der Kernel gepatcht werden soll und unterbricht das Script bis gepatcht ist
ask_patches() {
$DIALOG --title 'Patches' --stdout $LABEL --yesno "Soll der Kernel gepatcht werden?\nDu bekommst spaeter Zeit dazu." 6 70
if [ $? -eq 0 ]; then
APPLY_PATCH=1
else
APPLY_PATCH=0
fi
}
# Wartet bis der Benutzer gepatcht hat
do_patches () {
if [ $APPLY_PATCH -ne 0 ]; then
$DIALOG --title 'Patches' --no-cancel --msgbox "Jetzt ist es Zeit den Kernel zu Patchen\nDruecke OK wenn alle Patches eingespielt sind" 6 70
fi
}
# Kompilliert den Kernel
build_kernel () {
cd ${SRC_ROOT}/linux
cp /boot/config-`uname -r` ./.config
$MAKE_KPKG clean
$MAKE_KPKG --config menuconfig --append-to-version "${APPEND_TO_VERSION}" --bzimage configure kernel_image kernel_headers
$MAKE_KPKG --append-to-version "${APPEND_TO_VERSION}" debian modules_image --initrd
if ! [ $? -eq 0 ]; then
echo "Kompillieren hat abgebrochen"
exit 1
fi
}
# Liest die wirkliche Version aus die sich durch das Patchen aendern kann.
get_real_version () {
real_version=`grep "^VERSION" ${SRC_ROOT}/linux/conf.vars | head -n 1 | awk '{print $3}'`
real_patchlevel=`grep "^PATCHLEVEL" ${SRC_ROOT}/linux/conf.vars | head -n 1 | awk '{print $3}'`
real_sublevel=`grep "^SUBLEVEL" ${SRC_ROOT}/linux/conf.vars | head -n 1 | awk '{print $3}'`
real_extraversion=`grep "^EXTRAVERSION" ${SRC_ROOT}/linux/conf.vars | head -n 1 | awk '{print $3}'`
real_append_to_version=`grep "^APPEND_TO_VERSION" ${SRC_ROOT}/linux/conf.vars | head -n 1 | awk '{print $3}'`
real_version=${real_version}.${real_patchlevel}.${real_sublevel}${real_extraversion}${real_append_to_version}
}
# Schreibt die Optionen fuer den neuen Kernel in die Lilo.conf
prepare_lilo_conf () {
label_version=`echo ${real_version}${append_to_version} | cut -b 1-15`
echo "image=/boot/vmlinuz-${real_version}${append_to_version}" >> /etc/lilo.conf
echo " label=${label_version}" >> /etc/lilo.conf
echo " read-only" >> /etc/lilo.conf
if [ $IS_PRECISION -eq 0 ]; then
echo " append=\"libata.atapi_enabled=1\"" >> /etc/lilo.conf
fi
}
# Erstellt einen Ordner und kopiert die aktuell erstellten Pakete hinein
consolidate_files () {
cd ${SRC_ROOT}
test -d ${SRC_ROOT}/pakete/${VERSION}-deb-${now} || mkdir -p ${SRC_ROOT}/pakete/${VERSION}-deb-${now}
mv *.deb ${SRC_ROOT}/pakete/${VERSION}-deb-${now}/
cp ${SRC_ROOT}/linux/.config ${SRC_ROOT}/pakete/${VERSION}-deb-${now}/config
}
# Fragt ob der Kernel Installiert werden soll
ask_install_kernel_package() {
$DIALOG --title 'Install' --stdout $LABEL --yesno "Soll der Kernel Installiert werden?" 6 70
if [ $? -eq 0 ]; then
dpkg -i ${SRC_ROOT}/pakete/${VERSION}-deb-${now}/$PAKETNAME
if ! [ $? -eq 0 ]; then
exit 1
fi
fi
}
# Fragt nach ob das Nvidia Paket installiert werden soll
ask_install_nvidia_package() {
$DIALOG --title 'Install' --stdout $LABEL --yesno "Soll das Nvidia Treiber Paket Installiert werden?" 6 70
if [ $? -eq 0 ]; then
dpkg -i ${SRC_ROOT}/pakete/${VERSION}-deb-${now}/${PAKETNAME_NVIDIA}
if ! [ $? -eq 0 ]; then
exit 1
fi
depmod -a ${real_version}${append_to_version}
fi
}
# Aendert den Standard Kernel von Lilo
change_lilo() {
$PERL -pi -e "s/^default=.*/default=${label_version}/g;" /etc/lilo.conf
}
select_modules () {
cd ${SRC_ROOT}
my_modules=""
m=""
for f in `ls *.tar.gz | grep -v nvidia-kernel-source.tar.gz | sort`; do
tar tfz ${f} | grep -q "^modules/"
result=$?
if [ $result -eq 0 ]; then
m="$m `basename $f .tar.gz` "
p=`dpkg -S $PWD/$f | cut -d : -f 1`
if [ $p ]; then
dsc=`dpkg -s $p | grep "^Description:" | cut -c 14-`
if [ "$dsc" ]; then
m="$m \"$dsc\" off"
else
m="$m $f off"
fi
else
m="$m $f off"
fi
fi
done
if [ "$m" ]; then
tmpfile=`mktemp`
m="dialog --title 'Module' --nocancel --stdout --checklist 'Welche module sollen installiert werden?' 20 70 14 $m"
echo $m > $tmpfile
chmod 755 $tmpfile
result=`$tmpfile | sed -e 's/"//g'`
rm $tmpfile
my_modules=$result
fi
}
prepare_modules () {
cd ${SRC_ROOT}
rm -rf modules
for f in $my_modules; do
test -f ${f}.tar.gz && tar xfz ${f}.tar.gz;
test -f ${f}.tgz && tar xfz ${f}.tgz;
test -f ${f}.tar.bz2 && tar xfj ${f}.tar.bz2;
done
}
# Fragt ab welcher Kernel im Offline modus installiert werden soll
select_kernel () {
cd ${SRC_ROOT}${ARCHIV}
m=''
for kernel in `ls linux-[0-9]*.[0-9]*.*.tar.bz2 | sort -r`; do
VERSION=`echo ${kernel} | tail -n 1 | cut -d '-' -f 2- | sed -e s/.tar.bz2// `
m="${m} ${VERSION} ${kernel}"
done
VERSION=`dialog --title 'Kernel' --stdout --nocancel --menu 'Welcher Kernel?' 20 70 14 ${m}`
if [ ! $VERSION ]; then
dialog --title 'Error' --infobox "Kernelpaket Fehlt!\nEs gibt keinen Kernelpaket im Verzeichnis ${SRC_ROOT}${ARCHIV}/" 4 70
exit 1
fi
}
# Entpacke Nvidia
prepare_nvidia() {
cd /usr/src
tar -xzf nvidia-kernel-source.tar.gz
if ! [ $? -eq 0 ]; then
exit 1
fi
}
# Ueberprueft die Signatur vom kernelpaket
check_signature(){
$GPG --verify ${SRC_ROOT}${ARCHIV}/linux-${VERSION}.tar.bz2.sign ${SRC_ROOT}${ARCHIV}/linux-${VERSION}.tar.bz2 > /dev/null 2>&1
result=$?
sig=`$GPG --verify ${SRC_ROOT}${ARCHIV}/linux-${VERSION}.tar.bz2.sign ${SRC_ROOT}${ARCHIV}/linux-${VERSION}.tar.bz2 2>&1`
echo $sig
dialog --title 'Teste Kernel Signatur' --infobox "$sig" 16 70
sleep $GPG_WAIT
if [ $result -ne 0 ]; then
dialog --title 'Fehler' --stdout --no-cancel $LABEL --yesno "Die Kernel Signatur ist nicht in Ordnung.\nSoll ich abbrechen?" 6 85
if [ $? -eq 0 ]; then
echo "Abbruch ..."
exit 1
fi
fi
}
# Enpacke den kernel
prepare_kernel() {
if [ -L ${SRC_ROOT}/linux ]; then
rm ${SRC_ROOT}/linux
fi
if ! [ -d ${SRC_ROOT}${LINUX_ALT} ]; then
mkdir ${SRC_ROOT}${LINUX_ALT}
fi
if [ -d ${SRC_ROOT}/linux ]; then
read_this_version
mv ${SRC_ROOT}/linux/ ${SRC_ROOT}${LINUX_ALT}/linux-${version}-`date +%Y%m%d%H%M%S`
if ! [ $? -eq 0 ]; then
echo "Verschieben ist Fehlgeschlagen"
exit 1
fi
fi
cd ${SRC_ROOT}
if [ -d ${SRC_ROOT}/linux ]; then
rm -r ${SRC_ROOT}/linux
fi
$DIALOG --title 'Entpacken' --infobox "Die Kernelquellen (${VERSION}) werden Entpackt\n\nEinen Augenblick bitte." 5 80
tar xjf ${SRC_ROOT}${ARCHIV}/linux-${VERSION}.tar.bz2
if ! [ $? -eq 0 ]; then
echo "Entpacken ist Fehlgeschlagen"
exit 1
fi
mv ${SRC_ROOT}/linux-${VERSION} linux
}
feddisch (){
$DIALOG --title 'Fertig' --infobox "\n Die Installation war erfolgreich ... Have a lot of fun" 5 80
}
################################################################
### main
################################################################
cd ${SRC_ROOT}
ask_online
get_public_key
if [ $online -eq 0 ]; then
select_kernel
else
ask_kernel_tree
ask_install_kernel
download_kernel
fi
if [ $ASK_NVIDIA -eq 1 ]; then
ask_install_nvidia
fi
check_signature
prepare_kernel
append_to_version
select_modules
ask_patches
own_patches
do_patches
prepare_modules
if [ $nvidia -eq 0 ]; then
prepare_nvidia
fi
build_kernel
cd ${SRC_ROOT}
get_real_version
debian_version
if [ $ASK_LILO -eq 1 ]; then
ask_lilo
if [ $lilo -eq 0 ]; then
prepare_lilo_conf
fi
if [ $lilo_default -eq 0 ]; then
change_lilo
fi
fi
consolidate_files
ask_install_kernel_package
if [ $nvidia -eq 0 ]; then
ask_install_nvidia_package
fi
feddisch
