Problems installing 2.6.x kernel on upgraded systems

[Durand Hicks]

FYI,

If you have recently ran apt-get upgrade or dist-upgrade and then tried to compile and install a 2.6.4 kernel, you *may* encounter failure to successfully install the newest kernel from a knoppix/debian installed system.

Problem:
Installing the new 2.6.x kernel reports 2 modules missing; ide-disk, and ata-piix. Repeated attempts will stop at this point.

Solution:
This isn't for the faint of heart, you need to open a console as root, cd /usr/sbin, and edit the mkinitrd file. There is a section that points to these two files which need to be deleted and then saved. Re-run the dpkg -i command to install the kernel and it will be successful.

For those of you who do not want to edit the mkinitrd file, here is the full file itself, just copy and paste into the faulty mkinitrd file as root. Make sure you make a backup first and save it for future reference. Overwrite the mkinitrd file with this code:

#!/bin/sh
#
# mkinitrd - make an initrd image
#
# Copyright (C) 2001-2003 Herbert Xu <herbert@debian.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
# $Id: mkinitrd,v 1.163 2004/03/01 03:16:01 herbert Exp $

set -e

defaults() {
	MODULES=most
	DELAY=0
	ROOT=probe
	UMASK=022
	MKIMAGE='mkcramfs %s %s > /dev/null'
	BUSYBOX=
	PKGSCRIPTS=yes
	INITRD_LD_LIBRARY_PATH=$LD_LIBRARY_PATH
}

cleanse_bool() {
	eval "
		case \$$1 in
		[yY1]*)
			$1=yes
			;;
		*)
			$1=
			;;
		esac
	"
}

cleanse() {
	case "$MODULES" in
	all | most | dep | none)
		;;
	*)
		echo "$PROG: MODULES: Unknown value $MODULES" >&2
		exit 1
		;;
	esac

	if [ ${PROBE+1} ]; then
		echo "$PROG: warning: PROBE is obsolete" >&2
		if [ "$PROBE" != on ] && [ "$ROOT" = probe ]; then
			# Check conffile again.
			ROOT="$(
				unset ROOT
				. "$CONFDIR"/mkinitrd.conf
				echo "$ROOT"
			)"
		fi
	fi

	if [ -z "${DELAY##*[!0-9]*}" ]; then
		echo "$PROG: $DELAY: Illegal delay value" >&2
		exit 1
	fi

	cleanse_bool BUSYBOX
	cleanse_bool PKGSCRIPTS
}

initvars() {
	IDE_MODULE=
}

usage() {
	 revision='$Id: mkinitrd,v 1.163 2004/03/01 03:16:01 herbert Exp $'
	 cat >&2 << EOF

$revision

Usage: $PROG [OPTION]... <-o outfile> [moduledir]

Options:
  -d confdir  Specify an alternative configuration directory.
  -k          Keep temporary directory used to make the image.
  -m command  Set the command to make an initrd image.
  -o outfile  Write to outfile.
  -r root     Override ROOT setting in mkinitrd.conf.

See mkinitrd(8) for further details.
EOF
	exit 1
}

parseraidtab() {
	awk '
		BEGIN {
			oldmd = "/dev/md'$1'"
			newmd = "/dev/md/'$1'"
		}
		$1 == "raiddev" {
			if ($2 == oldmd || $2 == newmd) {
				start = 1
				print "echo " $2 " >&4"
				print "device=" $2
			} else if (start) {
				exit
			}
			next
		}
		!start {
			next
		}
		$1 == "persistent-superblock" {
			sb = $2
			next
		}
		$1 == "raid-level" {
			raidlevel = $2
			next
		}
		$1 == "device" {
			device = $2
		}
		$1 == "raid-disk" {
			print device >> "'$dir'/getroot"
		}
		END {
			if (raidlevel ~ /^[0-9]/) {
				print "echo raid" raidlevel
			} else {
				print "echo " raidlevel
			}
			if (start) {
				if (!raidlevel && !sb) {
					print "style=old"
				} else {
					print "style=new"
				}
			} else {
				print "style=bad"
			}
		}
	' /etc/raidtab
}

getraid_mdadm() {
	mdadm=$(mdadm -D "$device") || {
		echo "$PROG: mdadm -D $device failed" >&2
		exit 1
	}
	eval "$(
		echo "$mdadm" | awk '
			$1 == "UUID" { print "uuid=" $3; next }
			$1 == "Raid" && $2 == "Level" { print "echo " $4; next }
			$5 == "active" { devices = devices " " $7; next }
			END { print "devices='\''" devices "'\''" }
		'
	)"

	printf '%s\n' $devices > $dir/getroot
	echo mdadm -A /devfs/md/$minor -R -u $uuid $devices \
		> $dir/md$minor-script
	echo /sbin/mdadm >&6
}

getraid_raidtools() {
	if [ ! -f /etc/raidtab ]; then
		echo "$PROG: RAID support requires raidtools2" >&2
		exit 1
	fi
	{
		echo "/etc/raidtab"
	} >&4
	eval "$(parseraidtab "$minor")"
	case $style in
	new)
		echo raidstart $device > $dir/md$minor-script
		echo /sbin/raidstart >&6
		;;
	old)
		echo raid0run $device > $dir/md$minor-script
		echo /sbin/raid0run >&6
		;;
	*)
		echo "$PROG: $device: Device not listed in raidtab" >&2
		exit 1
		;;
	esac
}

lvmdetect1() {
	minor0=$(printf %02d $minor)
	lv=$(grep -l "^device: *$major:$minor0" /proc/lvm/VGs/*/LVs/*)
	vg=${lv%/*/*}
	devices=$(
		sed -n 's/^device: *0*\(..*\):0*\(..*\)/getroot \1 \2/p' \
			$vg/PVs/*
	)
	root=/dev/${vg##*/}/${lv##*/}
}

lvmdetect2() {
	eval "$(vgdisplay -v | awk '
		found < 1 {
			if (/^ *LV Name/) {
				lvname = $3
				next
			}
			if (/^ *Block device/ && $3 == "'$major:$minor'") {
				found++
				root = lvname
			}
			next
		}
		found < 2 { if (/^ *--- Physical volumes/) found++; next }
		/^PV Name \(#\)/ { devices = devices "\ngetroot " $4; next }
		/^ *PV Name/ { devices = devices "\ngetroot " $3 }
		/^$/ { exit }
		END {
			print "devices='\''" devices "'\''"
			print "root=" root
			if (found < 2)
				print "false"
		}
	')"
}

lvm() {
	iopver=$(lvmiopversion)
	if [ "$iopver" -lt 200 ]; then
		lvmdetect1
	else
		lvmdetect2
	fi || {
		echo "$PROG: $device: Cannot find LVM device" >&2
		exit 1
	}
	eval "$devices"

	vg=${root#/dev/}
	vg=${vg%/*}
	DEVLINKS="$DEVLINKS $vg"

	if
		[ ! -f "$MODULEDIR/kernel/drivers/md/dm-mod.$o" ] ||
		[ ! -d /lib/lvm-200 ]
	then
		if [ ! -d /lib/lvm-10 ]; then
			echo "$PROG: $device: LVM1 is required" >&2
			exit 1
		fi

		echo lvm-mod
		echo /dev/lvm >&4
		{
			echo ROOT=$root
			echo '[ -c /dev/lvm ] || mknod /dev/lvm c 109 0'
			echo mount -nt tmpfs tmpfs /etc
			echo vgscan
			echo vgchange -a y
			echo umount -n /etc
		} >&5
		{
			echo /lib/lvm-10/vgchange
			echo /lib/lvm-10/vgscan
			echo /sbin/vgchange
			echo /sbin/vgscan
		} >&6
	else
		if [ ! -d /lib/lvm-200 ]; then
			echo "$PROG: $device: LVM2 is required" >&2
			exit 1
		fi

		echo dm_mod
		{
			echo ROOT=$root
			echo mkdir /devfs/$vg
			echo mount -nt tmpfs tmpfs /etc
			echo mount -nt tmpfs tmpfs /var
			echo vgchange -a y
			echo umount -n /var
			echo umount -n /etc
		} >&5
		{
			echo /bin/mkdir
			echo /lib/lvm-200/vgchange
			echo /sbin/vgchange
		} >&6
	fi
}

dm() {
	if [ ! -d /dev/evms ]; then
		lvm
	fi
}

print_ide_modules() {
	if [ -n "$IDE_MODULE" ]; then
		return
	fi

	IDE_MODULE=none
	for i in ide-probe-mod ide-detect; do
		if [ -f "$MODULEDIR/kernel/drivers/ide/$i.$o" ]; then
			IDE_MODULE=$i
			break
		fi
	done

	IDE_PCI_MODULES=
	if [ -d "$MODULEDIR/kernel/drivers/ide/pci" ]; then
		IDE_PCI_MODULES=$(
			find "$MODULEDIR/kernel/drivers/ide/pci" \
				-name "*.$o" -printf '%f\n' |
				sed 's%\.'$o'$%%'
		)
	fi

	case $IDE_MODULE in
	ide-probe-mod)
		echo ide-mod
		;;
	ide-detect)
		echo ide-core
		;;
	esac

	if [ -n "$IDE_PCI_MODULES" ]; then
		printf '%s > /dev/null 2>&1\n' $IDE_PCI_MODULES
		echo unload_unused_ide "'$oldstyle'" $IDE_PCI_MODULES >&5
	fi

	if [ $IDE_MODULE != none ]; then
		echo $IDE_MODULE
	fi
}

getroot() {
	local major minor

	if [ $# -eq 2 ]; then
		device=$1:$2
		major=$1
		minor=$2
	elif [ ! -e "$1" ]; then
		case "$1" in
		/*)
			echo "$PROG: constituent device $1 does not exist" >&2
			exit 1
			;;
		esac

		# Assume label or UUID.
		eval "$(
			awk 'NR > 2 { printf "getroot %d %d\n", $1, $2 }' \
				/proc/partitions
		)"
		return
	else
		device=$(readlink -f "$1")
		eval "$(stat -c 'major=$((0x%t)); minor=$((0x%T))' "$device")"
	fi

	run_probe $major $minor
	if [ $ok ]; then
		return
	fi

	case $major in
	9)
		device=/dev/md/$minor
		[ -b $device ] || device=/dev/md$minor
		[ -b $device ] || {
			echo "$PROG: Cannot find /dev/md/$minor" >&2
			exit 1
		}
		if command -v mdadm > /dev/null 2>&1; then
			getraid_mdadm
		else
			getraid_raidtools
		fi
		cat $dir/getroot >&4
		eval "$(sed 's/^/getroot /' $dir/getroot)"
		cat $dir/md$minor-script >&5
		;;
	8 | 11)
		if [ ! -d /proc/scsi ]; then
			echo "$PROG: Cannot determine SCSI module" >&2
			exit 1
		fi
		find /proc/scsi -type d -mindepth 1 -maxdepth 1 \
			-printf "%f\n" | sed '
				/^ide-scsi$/d
				s/^aac$/aacraid/; t
				s/^am53c974$/AM53C974/; t
				s/^eata2x$/eata/; t
				s/^isp1020$/qlogicisp/; t
				s/^isp2x00$/qlogicfc/; t
				s/^ncr53c7xx$/53c7,8xx/; t
				s/^ncr53c8xx$/sym53c8xx/; t
				s/^A2091$/a2091/; t
				s/^A3000$/a3000/; t
				s/^Amiga7xx$/amiga7xx/; t
				s/^Atari$/atari_scsi/; t
				s/^BVME6000$/bvme6000/; t
				s/^cpqfcTS$/cpqfc/; t
				s/^dtc3x80$/dtc/; t
				s/^GVP11$/gvp11/; t
				s/^INI9100U$/initio/; t
				s/^INIA100$/inia100/; t
				s/^mac5380$/mac_scsi/; t
				s/^MVME147$/mvme147/; t
				s/^MVME16x$/mvme16x/; t
				s/^SGIWD93$/sgiwd93/; t
				s/^Sun3 5380 SCSI$/sun3_scsi/; t
				s/^esp-blz1230$/blz1230/; t
				s/^esp-blz2060$/blz2060/; t
				s/^esp-cyberstorm$/cyberstorm/; t
				s/^esp-cyberstormII$/cyberstormII/; t
				s/^esp$/dec_esp\
esp\
jazz_esp\
mac_esp\
mca_53c9x\
sun3x_esp/; t
				s/^esp-fastlane$/fastlane/; t
				s/^GVP11$/gvp11/; t
				s/^53c94$/mac53c94/; t
				s/^esp-oktagon$/octagon_esp/
			' | tac
			echo sd_mod
		;;
	7[2-9])
		echo cpqarray
		;;
	4[89] | 5[0-5])
		echo DAC960
		;;
	10[4-9] | 11[01])
		echo cciss
		;;
	11[4-9] | 12[0-9])
		print_ide_modules
		echo hptraid
		echo pdcraid
		;;
	2)
		echo floppy
		;;
	3 | 22 | 3[34] | 5[67] | 8[89] | 9[01])
		print_ide_modules
		;;
	58)
		lvm
		;;
	*)
		type=
		case $(awk '
			!block { if (/^Block devices/) block++; next }
			$1 == '$major' { print $2; exit }
		' /proc/devices) in
		device-mapper)
			dm
			return
			;;
		esac
		{
			echo "$PROG: $device: Unknown root device"
			printf "%$((${#PROG} + 2))s%s\n" \
				' ' 'Please refer to the manual page.'
		} >&2
		exit 1
		;;
	esac >&3
}

run_probe() {
	ok=
	for i in $PROBE_FUNCTIONS; do
		$i "$@"
		if [ $ok ]; then
			return
		fi
	done
}

register_probe() {
	PROBE_FUNCTIONS="$PROBE_FUNCTIONS $1"
}

probe() {
	PROBE_FUNCTIONS=

	for i in /usr/share/initrd-tools/probe.d/*; do
		case ${i##*/} in
		*[!A-Za-z0-9_-]*)
			continue
			;;
		esac
		. $i
	done

	set -f
	set +f -- $ROOT
	device=$1
	type=$2
	if [ "$device" = probe ]; then
		script='
			/^#/ { next }
			$2 == "/" { print $1 " " $3 " " $4; exit }
		'
		root=$(awk "$script" /etc/fstab)
		if [ -z "$root" ]; then
			echo "$PROG: Cannot determine root device" >&2
			exit 1
		fi
		set -f
		set +f -- $root
		device=$1
	fi

	if [ -z "$type" ]; then
		set -- $(awk -F '	' '!$1 { print $2 }' /proc/filesystems)
		if [ $# -eq 0 ]; then
			echo "$PROG: Cannot determine root file system" >&2
			exit 1
		fi
	else
		FSTYPES=$type
		set --
	fi

	noext3=
	cramfs=

	for fs; do
		case $fs in
		ext2)
			if [ $noext3 ]; then
				FSTYPES=${FSTYPES:+$FSTYPES,}ext2
			else
				FSTYPES=${FSTYPES:+$FSTYPES,}ext3,ext2
				noext3=yes
			fi
			;;
		ext3)
			if ! [ $noext3 ]; then
				FSTYPES=${FSTYPES:+$FSTYPES,}ext3
				noext3=yes
			fi
			;;
		cramfs)
			cramfs=yes
			;;
		*)
			FSTYPES=${FSTYPES:+$FSTYPES,}$fs
			;;
		esac
	done

	if [ $cramfs ]; then
		FSTYPES=${FSTYPES:+$FSTYPES,}cramfs
	fi

	IDE_MODULE=
	getroot "$device"
}

xldd() {
	i=$1

	set +e
	if [ $oldstyle ]; then
		x=$(
			LD_LIBRARY_PATH=$INITRD_LD_LIBRARY_PATH \
			LD_ASSUME_KERNEL=2.4 ldd "$i"
		)
	else
		x=$(
			LD_LIBRARY_PATH=$INITRD_LD_LIBRARY_PATH \
			ldd "$i"
		)
	fi
	err=$?
	set -e

	case $err in
	0)
		;;
	1)
		[ -n "$x" ] || return
		set -f
		set +f -- $x
		[ "$*" = 'not a dynamic executable' ]
		return
		;;
	*)
		return $err
		;;
	esac
	echo "$x"
}

add_modules_most() {
	if [ -d "$MODULEDIR/boot" ]; then
		find "$MODULEDIR/boot" -type f
	fi
	if [ -d "$MODULEDIR/kernel" ]; then
		set "$MODULEDIR"/kernel/drivers/video/fb*.$o
		[ -e "$1" ] && printf '%s\n' "$@"
		set "$MODULEDIR"/kernel/drivers/video/cfb*.$o
		[ -e "$1" ] && printf '%s\n' "$@"
		set "$MODULEDIR"/kernel/drivers/video/console/f*.$o
		[ -e "$1" ] && printf '%s\n' "$@"
		for i in \
			"$MODULEDIR/kernel/drivers/block" \
			"$MODULEDIR/kernel/drivers/ide" \
			"$MODULEDIR/kernel/drivers/md" \
			"$MODULEDIR/kernel/drivers/scsi" \
			"$MODULEDIR/kernel/fs" \
			"$MODULEDIR/kernel/unix"
		do
			[ -d "$i/" ] || continue
			find "$i/" -type f
		done > $dir/tmp1
		< $dir/tmp1 awk "
			!/fs\/binfmt_[^\/]*\$/ &&
			!/fs\/autofs.*\/[^\/]*\$/ &&
			!/fs\/coda\/[^\/]*\$/ &&
			!/fs\/intermezzo\/[^\/]*\$/ &&
			!/fs\/lockd\/[^\/]*\$/ &&
			!/fs\/ncpfs.*\/[^\/]*\$/ &&
			!/fs\/nfs.*\/[^\/]*\$/ &&
			!/fs\/nls\/[^\/]*\$/ &&
			!/fs\/ramfs\/[^\/]*\$/ &&
			!/fs\/smbfs\/[^\/]*\$/ &&
			!/drivers\/block\/loop\.$o\$/ &&
			!/drivers\/block\/nbd\.$o\$/ &&
			!/drivers\/block\/paride\/[^\/]*\$/ &&
			!/drivers\/ide\/ide-cs\.$o\$/ &&
			!/drivers\/ide\/ide-tape\.$o\$/ &&
			!/drivers\/scsi\/ide-scsi\.$o\$/ &&
			!/drivers\/scsi\/osst\.$o\$/ &&
			!/drivers\/scsi\/pcmcia\/[^\/]*\$/ &&
			!/drivers\/scsi\/ppa\.$o\$/ &&
			!/drivers\/scsi\/scsi_debug\.$o\$/ &&
			!/drivers\/scsi\/s[gt]\.$o\$/ {
				print
			}
		"
		for i in \
			"$MODULEDIR/kernel/drivers/message/fusion/mptbase".* \
			"$MODULEDIR/kernel/drivers/message/fusion/mptscsih".*
		do
			[ -f "$i" ] || continue
			echo "$i"
		done
	else
		for i in \
			"$MODULEDIR/block" \
			"$MODULEDIR/fs" \
			"$MODULEDIR/scsi"
		do
			[ -d "$i/" ] || continue
			find "$i/" -type f
		done
		[ -f "$MODULEDIR/misc/unix.$o" ] &&
			echo "$MODULEDIR/misc/unix.$o"
	fi | tee $dir/modules.most |
		sed 's%.*/%%; s/\.'$o'$//; s/^/. /' > $dir/modules.2
	cat $dir/modules.most
	:
}

add_modules_dep() {
	find "$MODULEDIR/" -maxdepth 1 -name 'modules.*'

	if [ $oldstyle ] && [ $oldkernel ]; then
		add_modules_dep_2_4
		return
	elif ! [ $oldstyle ]; then
		case $MODULEDIR in
		/lib/modules/*/*)
			;;
		/lib/modules/?*)
			add_modules_dep_2_5 ${MODULEDIR#/lib/modules/}
			return
			;;
		esac
	fi

	if [ $1 ]; then
		return
	fi

	echo "$PROG: MODULES=dep cannot be done due to version conflict" >&2
	echo "$PROG: using MODULES=most instead" >&2
	add_modules_most
	return
}

add_modules_dep_2_4() {
	cat <<- EOF > $dir/modules.conf
		depfile=$MODULEDIR/modules.dep
		path[toplevel]=$MODULEDIR
		$(egrep -v '^(depfile|path\[toplevel\])=' /etc/modules.conf)
	EOF

	IFS=,
	set -- $FSTYPES
	unset IFS

	if [ $# -gt 0 ]; then
		printf '. %s\n' "$@"
	fi | cat - $dir/modules.? |
		awk '{ print "modprobe -C '$dir/modules.conf' -nv " $2 }' |
		sh 2> /dev/null | awk ' /^\/sbin\/insmod /{
			for (i = 2; i <= NF; i++) {
				if ($i ~ /^\//) {
					print $i
					next
				}
			}
		}'
}

add_modules_dep_2_5() {
	ver=$1
	IFS=,
	set -- $FSTYPES
	unset IFS

	if [ $# -gt 0 ]; then
		printf '. %s 2> /dev/null\n' "$@"
	fi | cat - $dir/modules.? |
		awk '
			BEGIN {
				cmd = \
					"modprobe --set-version '$ver' " \
					"--show-depends "
			}
			$2 == "cramfs" || $2 == "ext2" { next }
			{ $1 = ""; print cmd $0 " >&3" }
		' | sh 2> $dir/modprobe.err 3>&1 |
		sed -n 's%^insmod \([^ ]\+\).*%\1%p'
	if [ -s $dir/modprobe.err ]; then
		echo "$PROG: add_modules_dep_2_5: modprobe failed" >&2
		cat $dir/modprobe.err >&2
		exit 1
	fi
}

add_command() {
	if [ -h $dir/initrd/"$1" ]; then
		return
	fi
	echo "$1"
	xldd "$1" >&3
}

checkpkg() {
	err=$(dpkg -s $1) || {
		echo "$PROG: checkpkg: dpkg -s $1 failed" >&2
		exit 1
	}

	eval "$(echo "$err" | awk '
		/^Status:/ && !/installed/ { exit }
		/^Version:/ { gsub(/[ \t]/, ""); version = substr($0, 9) }
		END { print "err=" version }
	')"

	if dpkg --compare-versions "$err" lt $2; then
		err="$1 >= $2 is required"
		return 1
	fi
}

gendir() {
	dir=$1

	if [ ! -d "$MODULEDIR" ]; then
		if [ "$MODULES" != none ]; then
			echo "$PROG: $MODULEDIR: Not a directory" >&2
			echo "$PROG: MODULES needs to be set to none?" >&2
			exit 1
		fi
		mkdir $dir/empty
		MODULEDIR=$dir/empty
	fi

	oldstyle=yes
	o=o
	insmod='/sbin/modprobe /sbin/rmmod'
	if [ -n "$(find "$MODULEDIR/" -name '*.ko')" ]; then
		unset oldstyle
		o=ko

		if ! checkpkg module-init-tools 0.9.13; then
			unset insmod
		fi
	else
		if [ -f /sbin/modprobe.modutils ]; then
			insmod="$insmod /sbin/modprobe.modutils"
			insmod="$insmod /sbin/insmod.modutils"
			insmod="$insmod /sbin/rmmod.modutils"
		else
			insmod="$insmod /sbin/insmod /sbin/rmmod"
		fi

		if ! checkpkg modutils 2.3.13; then
			unset insmod
		fi
	fi

	if ! [ ${insmod:+y} ] && [ "$MODULES" != none ]; then
		echo "$PROG: $err" >&2
		exit 1
	fi

	oldkernel=yes
	if dpkg --compare-versions $(uname -r) gt 2.5; then
		unset oldkernel
	fi

	DEVLINKS=

	exec \
		3> $dir/modules 4> $dir/files 5> $dir/script 6> $dir/exe

	{
		if [ -d "$MODULEDIR/initrd" ]; then
			set "$MODULEDIR"/initrd/*
		else
			set "$MODULEDIR"/boot/*
		fi
		[ -e "$1" ] || set --
		fbcon=
		for i; do
			i=${i##*/}
			i=${i%.*}
			case $i in
			*fb)
				echo "$i > /dev/null 2>&1"
				fbcon=yes
				continue
				;;
			esac
			echo "$i"
		done
		if [ $fbcon ]; then
			echo 'fbcon 2> /dev/null'
		fi
		echo 'unix 2> /dev/null'
	} >&3
	FSTYPES=
	[ -z "$ROOT" ] || probe

	exec 3>&- 4>&- 5>&- 6>&-

	mkdir $dir/initrd

	shell=/bin/dash
	[ -f $shell ] || shell=/bin/ash

	egrep -v '^(#.*)?$' "$CONFDIR"/modules | cat -n - $dir/modules |
		sort -u -k 2 | sort -n -k 1,1 > $dir/modules.1

	{
		set "$CONFDIR/files"
		[ -f "$1" ] || set --
		cat "$@" $dir/files

		case $MODULES in
		all)
			find "$MODULEDIR/" -type f
			add_modules_dep maybe
			;;
		most)
			add_modules_most
			add_modules_dep maybe
			;;
		dep)
			add_modules_dep
			;;
		none)
			find "$MODULEDIR/" -maxdepth 1 -name 'modules.*'
			;;
		esac

		exec 3> $dir/tmp2
		if [ $BUSYBOX ]; then
			bb=$(command -v busybox)
			add_command "$bb"
			for i in $(
				busybox 2>&1 |
				sed -n 's/^Curr.*//;tn;b;:n;s/,//g;p;n;bn'
			); do
				[ "$i" != busybox ] || continue
				for j in /usr/bin /sbin /usr/sbin /bin; do
					if [ -x $j/$i ]; then
						break
					fi
				done
				pdir=$dir/initrd$j
				[ -d $pdir ] || mkdir -p $pdir
				ln -s $bb $pdir/$i
			done
		fi

		set "$CONFDIR/exe"
		[ -f "$1" ] || set --
		for i in \
			$([ $DELAY -gt 0 ] && echo /bin/sleep) \
			$insmod $shell \
			/bin/mount /bin/umount \
			/sbin/pivot_root /bin/cat /bin/mknod \
			/usr/sbin/chroot \
			`cat "$@" $dir/exe`
		do
			add_command $i
		done
		exec 3>&-
		< $dir/tmp2 sed 's/.*=>[[:blank:]]*\([^[:blank:]]*\).*/\1/'

		echo /dev/console
		echo /dev/null
		if [ ${insmod:+y} ]; then
			if [ $oldstyle ]; then
				echo /etc/modules.conf
			else
				echo /etc/modprobe.conf
				echo /lib/modules/modprobe.conf
				if [ -f /etc/modprobe.devfs ]; then
					echo /etc/modprobe.devfs
				fi
			fi
		fi
	} > $dir/tmp3
	< $dir/tmp3 sort -u | cpio -pLd --quiet $dir/initrd

	ln -sf ${shell##*/} $dir/initrd/bin/sh
	if ! [ -h $dir/initrd/bin/echo ]; then
		install /usr/share/initrd-tools/echo $dir/initrd/bin
	fi
	install /usr/share/initrd-tools/init $dir/initrd/sbin
	install /usr/share/initrd-tools/linuxrc $dir/initrd
	{
		echo DELAY=$DELAY
		echo BUSYBOX=$BUSYBOX
		[ -z "$ROOT" ] || echo "FSTYPES=$FSTYPES"
		cat /usr/share/initrd-tools/version
	} > $dir/initrd/linuxrc.conf
	< $dir/modules.1 \
		awk '{ $1 = "modprobe -k "; print }' > $dir/initrd/loadmodules
	mv $dir/script $dir/initrd
	cd $dir/initrd
	mkdir -p dev2 devfs etc mnt proc scripts sys tmp var

	devices=
	for i in \
		cciss ide scsi md mapper $DEVLINKS
	do
		[ -e dev/$i ] || [ -h dev/$i ] ||
			devices="$devices ../devfs/$i"
	done
	if [ -n "$devices" ]; then
		printf '%s\n' $devices | sort -u |
			xargs ln -s --target-directory=dev
	fi

	cd - > /dev/null

	if [ $PKGSCRIPTS ]; then
		INITRDDIR=$dir/initrd MODULEDIR=$MODULEDIR \
			run-parts /usr/share/initrd-tools/scripts
	fi
	INITRDDIR=$dir/initrd MODULEDIR=$MODULEDIR \
		run-parts "$CONFDIR"/scripts
}

ORIGDIR=`pwd`
PROG="$0"

CONFDIR=/etc/mkinitrd
unset keep croot cmkimage out || :

while getopts "d:km:o:r:" flag; do
	case $flag in
	d)
		CONFDIR="$OPTARG"
		if [ ! -d "$CONFDIR" ]; then
			echo "$PROG: $CONFDIR: Not a directory" >&2
			exit 1
		fi
		[ -z "${CONFDIR##/*}" ] || CONFDIR="$ORIGDIR/$CONFDIR"
		;;
	k)
		keep=yes
		;;
	m)
		cmkimage=$OPTARG
		;;
	o)
		exec > "$OPTARG"
		out=yes
		;;
	r)
		croot=$OPTARG
		;;
	*)
		usage
		;;
	esac
done
shift $(($OPTIND - 1))

if ! [ $out ] || [ $# -gt 1 ]; then
	usage
fi

MODULEDIR="${1-/lib/modules/$(uname -r)}"
case $MODULEDIR in
[^/]*)
	MODULEDIR=$ORIGDIR/$MODULEDIR
	;;
esac

if [ ! -f "$CONFDIR"/mkinitrd.conf ]; then
	echo "$PROG: $CONFDIR/mkinitrd.conf: Configuration file not found" >&2
	exit 1
fi

defaults
. "$CONFDIR"/mkinitrd.conf
cleanse
initvars

ROOT=${croot-$ROOT}
MKIMAGE=${cmkimage-$MKIMAGE}

[ -d /dev/fd ] || {
	echo "$PROG: /dev/fd does not exist" >&2
	exit 1
}

DSIG=
exittrap='if [ $DSIG ]; then trap - "$DSIG"; kill -s $DSIG $$; fi'
trap "$exittrap" EXIT
for i in HUP INT TERM; do
	trap "DSIG=$i; exit" $i
done

workdir=${TMPDIR:-/tmp}/mkinitrd.$$
eval "$(
	trap '' HUP INT TERM
	if ! mkdir $workdir; then
		echo "$PROG: $workdir: Cannot create temporary directory" >&2
		echo exit 1
		exit
	fi
	if [ $keep ]; then
		echo "$PROG: The working directory $workdir will be kept." >&2
	else
		echo trap "'rm -r $workdir; $exittrap'" EXIT
	fi
)"

umask "$UMASK"
gendir $workdir
eval "$(printf "$MKIMAGE" $workdir/initrd /dev/fd/3)" 3>&1 >&2

HTH,

Durand