Request 326 (accepted)

Overview

Request 326 (accepted)

update to 2.2.0.3

Created by etamPL over 10 years ago
In state accepted

Submit dkms

Submit package home:etamPL:branc...0:branches:Extra / dkms to package Extra / dkms

dkms.changes Changed

dkms.spec Changed

@@ -1,35 +1,44 @@
 #
-# spec file for package dkms (Version 2.1.1.2)
+# spec file for package dkms
 #
 # norootforbuild
 #
 
-Summary:	Dynamic Kernel Module Support Framework
-Name:		dkms
-Version:	2.1.1.2
-Release:	0
-License:	GPLv2+
-Group:		System/Kernel
-BuildArch:	noarch
-Requires:	sed gawk findutils modutils tar cpio gzip grep mktemp
-Requires:	bash > 1.99 
-URL:		http://linux.dell.com/dkms
-Source0:	http://linux.dell.com/dkms/permalink/dkms-%{version}.tar.bz2
-Source100:	%{name}.changes
-Source101:	%{name}.rpmlintrc
-Patch0:		%{name}-add_remote_fs_to_init_script.diff
-BuildRoot:	%{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
-%if 0%{?suse_version} <= 1100
-PreReq:		coreutils /bin/sed /usr/bin/grep 
+Summary:   Dynamic Kernel Module Support Framework
+Name:      dkms
+Version:   2.2.0.3
+Release:   0.1
+License:   GPLv2+
+Group:     System/Kernel
+BuildArch: noarch
+Requires:  sed gawk findutils modutils tar cpio gzip grep mktemp
+Requires:  bash > 1.99
+# because Mandriva calls this package dkms-minimal
+Provides:  dkms-minimal = %{version}
+URL:       http://linux.dell.com/dkms
+Source0:   http://linux.dell.com/dkms/permalink/dkms-%{version}.tar.bz2
+Source100: %{name}.changes
+Source101: %{name}.rpmlintrc
+BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}
+%if 0%{?suse_version}
+Patch0:    %{name}-compat_suse_init_script.diff
+Requires:  kernel-devel
+%endif
+%if 0%{?fedora}
+Requires:  kernel-devel
 %endif
 
 %description
-This package contains the framework for the Dynamic Kernel Module Support (DKMS) method 
-for installing modules (or module packages as RPMs/DEBs/etc.) as originally developed by Dell.
+This package contains the framework for the Dynamic
+Kernel Module Support (DKMS) method for installing
+module RPMS as originally developed by Dell.
 
 %prep
 %setup -q
-%patch0 -p0
+%if 0%{?suse_version}
+%patch0 -p1
+%endif
+
 
 %build
 
@@ -89,8 +98,15 @@
     BASHDIR=$RPM_BUILD_ROOT%{_sysconfdir}/bash_completion.d \
     LIBDIR=$RPM_BUILD_ROOT%{_prefix}/lib/%{name}
 
+%if 0%{?suse_version}
 # create rcdkms_autoinstaller symlink for openSUSE
-ln -sf /etc/init.d/dkms_autoinstaller $RPM_BUILD_ROOT/usr/sbin/rcdkms_autoinstaller 
+%if 0%{?suse_version} < 1130
+%define	_initddir	/etc/init.d
+%endif
+mkdir -p $RPM_BUILD_ROOT/%{_initddir}
+mv $RPM_BUILD_ROOT/etc/rc.d/init.d/dkms_autoinstaller $RPM_BUILD_ROOT/%{_initddir}/dkms_autoinstaller 
+ln -sf %{_initddir}/dkms_autoinstaller $RPM_BUILD_ROOT/usr/sbin/rcdkms_autoinstaller 
+%endif
 
 %clean
 rm -rf $RPM_BUILD_ROOT
@@ -98,36 +114,43 @@
 %files
 %defattr(-,root,root)
 %{_sbindir}/%{name}
+%if 0%{?suse_version}
 %{_sbindir}/rcdkms_autoinstaller
+%endif
 %{_localstatedir}/lib/%{name}
-%{_sysconfdir}/init.d/dkms_autoinstaller
 %{_prefix}/lib/%{name}
 %{_mandir}/*/*
 %config(noreplace) %{_sysconfdir}/%{name}
 %doc sample.spec sample.conf AUTHORS COPYING README.dkms
 %doc sample-suse-9-mkkmp.spec sample-suse-10-mkkmp.spec
 # these dirs are for plugins - owned by other packages
-%dir %{_sysconfdir}/kernel
-%dir %{_sysconfdir}/kernel/postinst.d
-%dir %{_sysconfdir}/kernel/prerm.d
+%{_initddir}/dkms_autoinstaller
 %{_sysconfdir}/kernel/postinst.d/%{name}
 %{_sysconfdir}/kernel/prerm.d/%{name}
 %config %{_sysconfdir}/bash_completion.d/%{name}
-%dir %{_datadir}/apport/
-%dir %{_datadir}/apport/package-hooks/
-%{_datadir}/apport/package-hooks/dkms.py
+
+%if 0%{?suse_version}
+# suse doesnt yet support /etc/kernel/{prerm.d,postinst.d}, but will fail build
+# with unowned dirs if we dont own them ourselves
+# when opensuse *does* add this support, we will need to BuildRequires kernel
+%dir %{_sysconfdir}/kernel
+%dir %{_sysconfdir}/kernel/postinst.d
+%dir %{_sysconfdir}/kernel/prerm.d
+%endif
+
 
 %post
 [ -e /sbin/dkms ] && mv -f /sbin/dkms /sbin/dkms.old 2>/dev/null
 # enable on initial install
 [ $1 -lt 2 ] && /sbin/chkconfig dkms_autoinstaller on ||:
 
+%postun
+%insserv_cleanup
+%restart_on_update
+
 %preun
 # remove on uninstall
 [ $1 -lt 1 ] && /sbin/chkconfig dkms_autoinstaller off ||:
 %stop_on_removal
 
-%postun
-%insserv_cleanup
-
 %changelog

dkms-add_remote_fs_to_init_script.diff Deleted

dkms-compat_suse_init_script.diff Added

dkms-2.1.1.2.tar.bz2/AUTHORS -> dkms-2.2.0.3.tar.bz2/AUTHORS Changed

dkms-2.1.1.2.tar.bz2/Makefile -> dkms-2.2.0.3.tar.bz2/Makefile Changed

@@ -1,8 +1,8 @@
-RELEASE_DATE := "16-Feb-2009"
+RELEASE_DATE := "07-December-2011"
 RELEASE_MAJOR := 2
-RELEASE_MINOR := 1
-RELEASE_SUBLEVEL := 1
-RELEASE_EXTRALEVEL := .2
+RELEASE_MINOR := 2
+RELEASE_SUBLEVEL := 0
+RELEASE_EXTRALEVEL := .3
 RELEASE_NAME := dkms
 RELEASE_VERSION := $(RELEASE_MAJOR).$(RELEASE_MINOR).$(RELEASE_SUBLEVEL)$(RELEASE_EXTRALEVEL)
 RELEASE_STRING := $(RELEASE_NAME)-$(RELEASE_VERSION)
@@ -14,6 +14,7 @@
 VAR = $(DESTDIR)/var/lib/dkms
 MAN = $(DESTDIR)/usr/share/man/man8
 INITD = $(DESTDIR)/etc/init.d
+INITD_RH = $(DESTDIR)/etc/rc.d/init.d 
 LIBDIR = $(DESTDIR)/usr/lib/dkms
 BASHDIR = $(DESTDIR)/etc/bash_completion.d
 KCONF = $(DESTDIR)/etc/kernel
@@ -35,11 +36,9 @@
 	mkdir -m 0755 -p $(VAR) $(SBIN) $(MAN) $(ETC) $(BASHDIR) $(SHAREDIR) $(LIBDIR)
 	sed -e "s/\[INSERT_VERSION_HERE\]/$(RELEASE_VERSION)/" dkms > dkms.versioned
 	mv -f dkms.versioned dkms
-	mkdir   -p -m 0755 $(SHAREDIR)/apport/package-hooks
 	install -p -m 0755 dkms_common.postinst $(LIBDIR)/common.postinst
 	install -p -m 0755 dkms $(SBIN)
 	install -p -m 0755 dkms_autoinstaller $(LIBDIR)
-	install -p -m 0755 dkms_apport.py $(SHAREDIR)/apport/package-hooks/dkms.py
 	install -p -m 0644 dkms_framework.conf $(ETC)/framework.conf
 	install -p -m 0644 dkms_dbversion $(VAR)
 	install -p -m 0644 dkms.bash-completion $(BASHDIR)/dkms
@@ -58,18 +57,21 @@
 	chmod 0644 $(DOCFILES)
 
 install-redhat: install doc-perms
-	mkdir -m 0755 -p  $(INITD)
+	mkdir -m 0755 -p  $(INITD_RH)
 	install -p -m 0755 dkms_mkkerneldoth $(LIBDIR)/mkkerneldoth
 	install -p -m 0755 dkms_find-provides $(LIBDIR)/find-provides
 	install -p -m 0755 lsb_release $(LIBDIR)/lsb_release
 	install -p -m 0644 template-dkms-mkrpm.spec $(ETC)
-	install -p -m 0755 dkms_autoinstaller $(INITD)
+	install -p -m 0644 template-dkms-redhat-kmod.spec $(ETC)
+	install -p -m 0755 dkms_autoinstaller $(INITD_RH)
 
 install-doc:
 	mkdir -m 0755 -p $(DOCDIR)
 	install -p -m 0644 $(DOCFILES) $(DOCDIR)
 
 install-debian: install install-doc
+	mkdir   -p -m 0755 $(SHAREDIR)/apport/package-hooks
+	install -p -m 0755 dkms_apport.py $(SHAREDIR)/apport/package-hooks/dkms_packages.py
 	mkdir   -p -m 0755 $(KCONF)/header_postinst.d
 	install -p -m 0755 kernel_postinst.d_dkms $(KCONF)/header_postinst.d/dkms
 	mkdir   -p -m 0755 $(ETC)/template-dkms-mkdeb/debian
@@ -88,7 +90,7 @@
 
 $(TARBALL):
 	mkdir -p $(deb_destdir)
-	tmp_dir=`mktemp -d /tmp/dkms.XXXXXXXX` ; \
+	tmp_dir=`mktemp -d --tmpdir dkms.XXXXXXXX` ; \
 	cp -a ../$(RELEASE_NAME) $${tmp_dir}/$(RELEASE_STRING) ; \
 	sed -e "s/\[INSERT_VERSION_HERE\]/$(RELEASE_VERSION)/" dkms > $${tmp_dir}/$(RELEASE_STRING)/dkms ; \
 	sed -e "s/\[INSERT_VERSION_HERE\]/$(RELEASE_VERSION)/" dkms.spec > $${tmp_dir}/$(RELEASE_STRING)/dkms.spec ; \
@@ -105,7 +107,7 @@
 
 
 rpm: $(TARBALL) dkms.spec
-	tmp_dir=`mktemp -d /tmp/dkms.XXXXXXXX` ; \
+	tmp_dir=`mktemp -d --tmpdir dkms.XXXXXXXX` ; \
 	mkdir -p $${tmp_dir}/{BUILD,RPMS,SRPMS,SPECS,SOURCES} ; \
 	cp $(TARBALL) $${tmp_dir}/SOURCES ; \
 	sed "s/\[INSERT_VERSION_HERE\]/$(RELEASE_VERSION)/" dkms.spec > $${tmp_dir}/SPECS/dkms.spec ; \
@@ -129,7 +131,7 @@
 	cd -
 
 debs:
-	tmp_dir=`mktemp -d /tmp/dkms.XXXXXXXX` ; \
+	tmp_dir=`mktemp -d --tmpdir dkms.XXXXXXXX` ; \
 	make debmagic DEB_TMP_BUILDDIR=$${tmp_dir} DIST=$(DIST); \
 	rm -rf $${tmp_dir}

dkms-2.1.1.2.tar.bz2/README.dkms -> dkms-2.2.0.3.tar.bz2/README.dkms Changed

dkms-2.1.1.2.tar.bz2/dkms -> dkms-2.2.0.3.tar.bz2/dkms Changed

@@ -19,54 +19,116 @@
 #    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #
 
-function invoke_command ()
+
+# All of the variables we will accept from dkms.conf.
+# Does not include directives
+readonly dkms_conf_variables="CLEAN REMAKE_INITRD remake_initrd PACKAGE_NAME
+       PACKAGE_VERSION POST_ADD POST_INSTALL POST_REMOVE PRE_BUILD
+       PRE_INSTALL BUILD_EXCLUSIVE_KERNEL BUILD_EXCLUSIVE_ARCH
+       build_exclude OBSOLETE_BY MAKE MAKE_MATCH MODULES_CONF
+       modules_conf_array PATCH PATCH_MATCH patch_array BUILT_MODULE_NAME
+       built_module_name BUILT_MODULE_LOCATION built_module_location
+       DEST_MODULE_NAME dest_module_name MODULES_CONF_OBSOLETES
+       DEST_MODULE_LOCATION dest_module_location
+       modules_conf_obsoletes MODULES_CONF_ALIAS_TYPE
+       modules_conf_alias_type STRIP strip MODULES_CONF_OBSOLETE_ONLY
+       modules_conf_obsolete_only AUTOINSTALL"
+
+# Some important regular expressions.  Requires bash 3 or above.
+# Any poor souls still running bash 2 or older really need an upgrade.
+readonly y_re='^(Y|y)'
+readonly mv_re='^([^/]*)/(.*)$'
+readonly rh_kernels='(debug|summit|smp|enterprise|bigmem|hugemem|BOOT|vmnix)'
+
+#Areas that will vary between Linux and other OS's
+_get_kernel_dir() {
+    KVER=$1
+    case ${current_os} in
+       Linux)          DIR="/lib/modules/$KVER/build" ;;
+       GNU/kFreeBSD)   DIR="/usr/src/kfreebsd-headers-$KVER/sys" ;;
+    esac
+    echo $DIR
+}
+
+_check_kernel_dir() {
+    DIR=$(_get_kernel_dir $1)
+    case ${current_os} in
+       Linux)          test -e $DIR/include ;;
+       GNU/kFreeBSD)   test -e $DIR/kern && test -e $DIR/conf/kmod.mk ;;
+       *)              return 1 ;;
+    esac
+    return $?
+}
+
+# Run a command that we may or may not want to be detailed about.
+invoke_command()
 {
+    # $1 = command to be executed using eval.
+    # $2 = Description of command to run
+    # $3 = 'background' if you want to run the command asynchronously.
     local exitval=0
-    local exitval_file=`mktemp $tmp_location/dkms.XXXXXX`
-    [ -z "$verbose" ] && echo -en "$2..." || echo -e "$1"
-    if [ "$3" == background ] && [ -z "$verbose" ]; then
-        (eval $1 >/dev/null 2>&1; echo "exitval=$?" >> "$exitval_file") &
-        while [ -e "$exitval_file" ] && ! [ -s "$exitval_file" ]; do
-            sleep 3
-            echo -en "."
-        done
-        . "$exitval_file"
+    [[ $verbose ]] && echo -e "$1" || echo -en "$2..."
+    if [[ $3 = background && ! $verbose ]]; then
+	local exitval_file=$(mktemp_or_die $tmp_location/dkms.XXXXXX)
+	(eval "$1" >/dev/null 2>&1; echo "exitval=$?" >> "$exitval_file") &
+	while [[ -e $exitval_file && ! -s $exitval_file ]]; do
+	    sleep 3
+	    echo -en "."
+	done
+	. "$exitval_file"
+	rm -f "$exitval_file"
     else
-        eval $1; exitval=$?
+	eval "$1"; exitval=$?
     fi
-    [ $exitval -gt 0 ] && echo -en "(bad exit status: $exitval)"
-    rm -f "$exitval_file"
+    (($exitval > 0)) && echo -en "(bad exit status: $exitval)"
     echo -en "\n"
     return $exitval
 }
 
-function show_usage ()
+error() (
+    exec >&2
+    echo -n $"Error! "
+    for s in "$@"; do echo "$s"; done 
+)
+
+warn() (
+    exec >&2
+    echo -n "$Warning: "
+    for s in "$@"; do echo "$s"; done
+)
+
+# Print an error message and die with the passed error code.
+die() {
+    # $1 = error code to return with
+    # rest = strings to print before we exit.
+    ret=$1
+    shift
+    error "$@"
+    [[ $die_is_fatal = yes ]] && exit $ret || return $ret
+}
+
+mktemp_or_die() {
+    local t
+    t=$(mktemp "$@") && echo "$t" && return
+    [[ $* = *-d* ]] && die 1 $"Unable to make temporary directory"
+    die 1 "Unable to make temporary file."
+}
+
+show_usage()
 {
     echo $"Usage: $0 [action] [options]"
-    echo $"  [action]  = { add | remove | build | install | uninstall | match"
+    echo $"  [action]  = { add | remove | build | install | uninstall | match | autoinstall"
     echo $"               | mkdriverdisk | mktarball | ldtarball | mkrpm | mkkmp | mkdeb | status }"
     echo $"  [options] = [-m module] [-v module-version] [-k kernel-version] [-a arch]"
     echo $"              [-d distro] [-c dkms.conf-location] [-q] [--force] [--all]"
     echo $"              [--templatekernel=kernel] [--directive='cli-directive=cli-value']"
     echo $"              [--config=kernel-.config-location] [--archive=tarball-location]"
-    echo $"              [--kernelsourcedir=source-location] [--no-prepare-kernel]"
+    echo $"              [--kernelsourcedir=source-location] [--no-prepare-kernel] [--no-initrd]"
     echo $"              [--binaries-only] [--source-only] [-r release (SuSE)] [--verbose]"
     echo $"              [--size] [--spec=specfile] [--media=floppy|iso|tar] [--legacy-postinst=0|1]"
 }
 
-function readlink()
-{
-    # $1 = the symlink to read
-    read_link=""
-    if [ -L "$1" ]; then
-        read_link="$1"
-        while [ -L "$read_link" ]; do
-            read_link=`ls -l $read_link | sed 's/.*-> //'`
-        done
-    fi
-}
-
-function VER()
+VER()
 {
     # $1 = kernel version string
 
@@ -75,446 +137,351 @@
     # The result should compare correctly as a string.
 
     echo $1 | sed -e 's:$[^0-9]$$[0-9]$:\1 \2:g' \
-                  -e 's:$[0-9]$$[^0-9]$:\1 \2:g' \
-                  -e 's:$.*$: \1 :' \
-                  -e 's: $[0-9]$ : 00\1 :g' \
-                  -e 's: $[0-9][0-9]$ : 0\1 :g' \
-                  -e 's: ::g'
+		  -e 's:$[0-9]$$[^0-9]$:\1 \2:g' \
+		  -e 's:$.*$: \1 :' \
+		  -e 's: $[0-9]$ : 00\1 :g' \
+		  -e 's: $[0-9][0-9]$ : 0\1 :g' \
+		  -e 's: ::g'
 }
 
-function set_module_suffix ()
+# Figure out the correct module suffix for the kernel we are currently
+# dealing with, which may or may not be the currently installed kernel.
+set_module_suffix()
 {
     # $1 = the kernel to base the module_suffix on
-    kernel_test="$1"
-    [ -z "$kernel_test" ] && kernel_test=`uname -r`
-
-    if [[ $(VER $kernel_test) < $(VER 2.5) ]]; then
-        module_suffix=".o"
-    else
-        module_suffix=".ko"
-    fi
+    kernel_test="${1-:$(uname -r)}"
+    module_suffix=".ko"
+    [[ $(VER $kernel_test) < $(VER 2.5) ]] && module_suffix=".o"
 }
 
-function set_kernel_source_dir ()
+set_kernel_source_dir()
 {
     # $1 = the kernel to base the directory on
-    if [ -z "$kernel_source_dir" ] && [ -d "$install_tree/$1/build" ]; then
-        kernel_source_dir="$install_tree/$1/build"
-    fi
+    kernel_source_dir="$(_get_kernel_dir "$1")"
 }
 
-function setup_kernels_arches ()
+# A little test function for DKMS commands that only work on one kernel.
+have_one_kernel() {
+    (( ${#kernelver[@]} > 1 )) && \
+	die 4 $"The action $1 does not support multiple kernel version" \
+	$"parameters on the command line."
+    [[ $all ]] && die 5 $"The action $1 does not support the --all" \
+	$"parameter."
+}
+
+# Set up the kernelver and arch arrays.  You must have a 1:1 correspondence --
+# if there is an entry in kernelver[$i], there must also be an entry in arch[$i]
+# Note the special casing for the status action -- the status functions just
+# report on what we already have, and will break with the preprocessing that
+# this function provides.
+setup_kernels_arches()
 {
-    # Error if # of arches doesn't match # of kernels
-    if [ ${#kernelver_array[@]} -ne ${#arch_array[@]} ] && [ ${#arch_array[@]} -gt 1 ]; then
-        echo $"" >&2
-        echo $"Error!  If more than one arch is specified on the command line, then there" >&2
-        echo $"must be an equal number of kernel versions also specified (1:1 relationship)." >&2
-        exit 1
-    fi
-
-    # Check that kernel version and all aren't both set simultaneously
-    if [ -n "${kernelver_array[0]}" ] && [ -n "$all" ]; then
-        echo $"" >&2
-        echo $"Error!  You cannot specify a kernel version and also specify" >&2
-        echo $"--all on the command line." >&2
-        exit 2
-    fi
-
-    # Check that arch and all aren't both set simultaneously
-    if [ -n "${arch_array[0]}" ] && [ -n "$all" ]; then
-        echo $"" >&2
-        echo $"Error!  You cannot specify an arch and also specify" >&2
-        echo $"--all on the command line." >&2
-        exit 3
-    fi
-
-    # Check that the actions supports multiple kernels
-    case "$1" in
-    add | build | install | match | uninstall | mkkmp )
-        if [ ${#kernelver_array[@]} -gt 1 ]; then
-            echo $"" >&2
-            echo $"Error! The action $1 does not support multiple kernel version" >&2
-            echo $"parameters on the command line." >&2
-            exit 4
-        fi
-        if [ -n "$all" ]; then
-            echo $"" >&2
-            echo $"Error! The action $1 does not support the --all" >&2
-            echo $"parameter." >&2
-            exit 5
-        fi
-        ;;
-    esac
-
     # If all is set, use dkms status to fill the arrays
-    if [ -n "$all" ] && [ "$1" != "status" ]; then
-        local i=0
-        while read line; do
-            # (I would leave out the delimiters in the status output
-            #  in the first place.)
-            kernelver_array[$i]=`echo $line | awk {'print $3'} | sed 's/,$//'`
-            arch_array[$i]=`echo $line | awk {'print $4'} | sed 's/:$//'`
-            i=$(($i + 1))
-        done < <($0 status -m "$module" -v "$module_version" 2>/dev/null | \
-            egrep "built|installed" | egrep -v 'installed-weak')
+    if [[ $all && $1 != status ]]; then
+	local i=0
+	while read line; do
+	    line=${line#*/}; line=${line#*/};
+	    # (I would leave out the delimiters in the status output
+	    #  in the first place.)
+	    kernelver[$i]=${line%/*}
+	    arch[$i]=${line#*/}
+	    i=$(($i + 1))
+	done < <(module_status_built "$module" "$module_version")
     fi
 
     # Set default kernel version and arch, if none set (but only --all isn't set)
-    if [ "$1" != "status" ]; then
-        [ -z "${kernelver_array[0]}" ] && [ -z "$all" ] && kernelver_array[0]=`uname -r`
-        if [ -z "${arch_array[0]}" ] && [ -n "${kernelver_array[0]}" ]; then
-            kernelver_rpm=`rpm -qf "/lib/modules/${kernelver_array[0]}" 2>/dev/null | grep -v "not owned by any package" | grep kernel | head -n 1`
-            if ! arch_array[0]=`rpm -q --queryformat "%{ARCH}" "$kernelver_rpm" 2>/dev/null`; then
-                arch_array[0]=`uname -m`
-                if [ ${arch_array[0]} == "x86_64" ] && \
-                    grep -q Intel /proc/cpuinfo && \
-                    ls $install_tree/${kernelver_array[0]}/build/configs \
-                    2>/dev/null | grep -q "ia32e"; then
-                    arch_array[0]="ia32e"
-                fi
-            fi
-        fi
+    if [[ $1 != status ]]; then
+	if [[ ! $kernelver && ! $all ]]; then
+	    kernelver[0]=$(uname -r)
+	    kernels_arches_default="yes"
+	fi
+	if [[ ! $arch ]]; then
+	    kernelver_rpm=$(rpm -qf "/lib/modules/$kernelver" 2>/dev/null | \
+		grep -v "not owned by any package" | grep kernel | head -n 1)
+	    if ! arch[0]=$(rpm -q --queryformat "%{ARCH}" "$kernelver_rpm" 2>/dev/null); then
+		arch[0]=$(uname -m)
+		if [[ $arch = x86_64 ]] && \
+		    grep -q Intel /proc/cpuinfo && \
+		    ls $install_tree/$kernelver/build/configs \
+		    2>/dev/null | grep -q "ia32e"; then
+		    arch[0]="ia32e"
+		fi
+	    fi
+	fi
     fi
 
     # If only one arch is specified, make it so for all the kernels
-    if [ ${#arch_array[@]} -eq 1 ] && [ ${#kernelver_array[@]} -gt 1 ]; then
-        while [ ${#arch_array[@]} -lt ${#kernelver_array[@]} ]; do
-            arch_array[${#arch_array[@]}]=${arch_array[0]}
-        done
+    if ((${#arch[@]} == 1 && ${#kernelver[@]} > 1)); then
+	while ((${#arch[@]} < ${#kernelver[@]})); do
+	    arch[${#arch[@]}]=$arch
+	done
     fi
 
     # Set global multi_arch
     multi_arch=""
     local i=0
-    while [ $i -lt ${#arch_array[@]} ]; do
-        [ "${arch_array[0]}" != "${arch_array[$i]}" ] && multi_arch="true"
-        i=$(($i + 1))
+    for ((i=0; $i < ${#arch[@]}; i++)); do
+	[[ $arch != ${arch[$i]} ]] && {
+	    multi_arch="true"
+	    break
+	}
     done
 }
 
-function do_depmod()
-{
-    # $1 = kernel version
-    /sbin/depmod -au "$1" -F "/boot/System.map-$1"
-}
-
-function remake_initrd()
+do_depmod()
 {
     # $1 = kernel version
-    # $2 = arch
-
-    local exitval="0"
-    local mkinitrd='mkinitrd'
-
-
-    # Support initramfs distributions (Debian/Ubuntu).
-    if [ -x "/usr/sbin/update-initramfs" ]; then
-        mkinitrd='update-initramfs'
+    if [ "${current_os}" != "Linux" ] ; then
+        return
     fi
-
-    $mkinitrd --version >/dev/null 2>&1
-    if [ "$?" -eq 0 ]; then
-        echo $""
-        initrd_dir="/boot"
-        [ "$2" == "ia64" ] && [ -d "/boot/efi/efi/redhat" ] && initrd_dir="/boot/efi/efi/redhat"
-        echo $"Saving old initrd as $initrd_dir/initrd-$1_old.img"
-        cp -f "$initrd_dir/initrd-$1.img" "$initrd_dir/initrd-$1_old.img"
-        echo $"Making new initrd as $initrd_dir/initrd-$1.img"
-        echo $"(If next boot fails, revert to the _old initrd image)"
-        invoke_command "$mkinitrd -f $initrd_dir/initrd-$1.img $1" "$mkinitrd" background
-        exitval="$?"
-    elif [ -e /etc/SuSE-release ] || [ -d /etc/SuSEconfig ]; then
-        echo $""
-        initrd_dir="/boot"
-        kernel_file="vmlinuz"
-        if [ ! -f "$initrd_dir/$kernel_file-$1" ]; then
-            kernel_file="vmlinux"
-            if [ ! -f "$initrd_dir/$kernel_file-$1" ]; then
-                echo $"Error! Unable to find valid kernel file under " >&2
-                echo $"$initrd_dir for kernel version $1" >&2
-                echo $"" >&2
-                return 1;
-            fi
-        fi
-        echo $"Saving old initrd as $initrd_dir/initrd-$1_old"
-        cp -f "$initrd_dir/initrd-$1" "$initrd_dir/initrd-$1_old"
-        echo $"Making new initrd as $initrd_dir/initrd-$1"
-        echo $"(If next boot fails, revert to the _old initrd image)"
-        invoke_command "$mkinitrd -k $kernel_file-$1 -i initrd-$1" "$mkinitrd" background
-        exitval="$?"
-    elif [ -e /etc/debian_version ]; then
-        echo $""
-        initrd_dir="/boot"
-        echo $"Updating initrd"
-        echo $"Making new initrd as $initrd_dir/initrd.img-$1"
-        echo $"(If next boot fails, revert to the .bak initrd image)"
-        if [ "$mkinitrd" == "update-initramfs" ]; then
-            invoke_command "$mkinitrd -u" "$mkinitrd" background
-        else
-            echo $"Saving old initrd as $initrd_dir/initrd.img-$1.bak"
-            # we use the same convention as update-initramfs, so that we just
-            # print the warning once
-            cp -f "$initrd_dir/initrd.img-$1" "$initrd_dir/initrd.img-$1.bak"
-            invoke_command "$mkinitrd -o $initrd_dir/initrd.img-$1 $1" "$mkinitrd" background
-        fi
-        exitval="$?"
+    if [[ -f /boot/System.map-$1 ]]; then
+	/sbin/depmod -a "$1" -F "/boot/System.map-$1"
     else
-        echo $""
-        echo $"Calling $mkinitrd (bad exit status 9 may occur)"
-        invoke_command "$mkinitrd" "$mkinitrd" background
-        exitval="$?"
+	/sbin/depmod -a "$1"
     fi
-
-    return $exitval
 }
 
-function distro_version_rpm()
+# This function is a little hairy -- every distro has slightly different tools
+# and naming conventions for creating initial ramdisks.  It should probably
+# be split out into one function per distro, with make_initrd left as a stub.
+make_initrd()
 {
-    local whatprovides_redhat
-    local whatprovides_suse
-    local whatprovides_sles
-    local whatprovides_ovm
-    local DISTRO
-    local VER
-    local dist=unknown
-
-    if ! which rpm > /dev/null 2>&1 ; then
-        echo "${dist}"
-        return
-    fi
-
-    whatprovides_redhat=$(rpm -q --whatprovides redhat-release)
-    if [ $? -eq 0 ]; then
-        case "${whatprovides_redhat}" in
-        redhat*)     DISTRO=redhat ;;
-        centos*)     DISTRO=centos ;;
-        enterprise*) DISTRO=oel ;; # Oracle Enterprise Linux
-        sl*)         DISTRO=sl ;;  # Scientific Linux
-        fedora*)     DISTRO=fedora ;;
-        *) ;;
-        esac
-    fi
-    whatprovides_sles=$(rpm -q --whatprovides sles-release)
-    [ $? -eq 0 ] && DISTRO=sles
-    whatprovides_suse=$(rpm -q --whatprovides suse-release)
-    [ $? -eq 0 ] && DISTRO=suse
-    whatprovides_ovm=$(rpm -q --whatprovides ovs-release)
-    [ $? -eq 0 ] && DISTRO=ovm
-
-    case "${DISTRO}" in
-    redhat)
-        VER=$(rpm -q --qf "%{version}\n" ${whatprovides_redhat})
-        # format is 3AS, 4AS, 5Desktop...
-        VER=$(echo "${VER}" | sed -e 's/^$[[:digit:]]*$.*/\1/g')
-        dist=el${VER}
-        ;;
-    centos)
-        VER=$(rpm -q --qf "%{version}\n" ${whatprovides_redhat})
-        # format is 3, 4, ...
-        dist=el${VER}
-        ;;
-    oel)
-        VER=$(rpm -q --qf "%{version}\n" ${whatprovides_redhat})
-        # format is 3, 4, ...
-        dist=el${VER}
-        ;;
-    ovm)
-        VER=$(rpm -q --qf "%{version}\n" ${whatprovides_ovm})
-        # format is 2.1
-        dist=ovm${VER}
-        ;;
-    sl)
-        VER=$(rpm -q --qf "%{version}\n" ${whatprovides_redhat})
-        # format is 4.7, 5.3
-        VER=$(echo "${VER}" | sed -e 's/^$[[:digit:]]*$.*/\1/g')
-        dist=el${VER}
-        ;;
-    fedora)
-        VER=$(rpm -q --qf "%{version}\n" ${whatprovides_redhat})
-        dist=fc${VER}
-        ;;
-    sles)
-        VER=$(rpm -q --qf "%{version}\n" ${whatprovides_sles})
-        dist=sles${VER}
-        ;;
-    suse)
-        VER=$(rpm -q --qf "%{version}\n" ${whatprovides_suse})
-        dist=suse${VER}
-        ;;
-    *)
-        dist=unknown
-        ;;
-    esac
-    echo "$dist"
-}
-
-function distro_version()
+    # $1 = kernel version
+    # $2 = arch
+    [[ $no_initrd ]] && return
+    local mkinitrd kernel_file initrd_dir="/boot"
+    for mkinitrd in dracut update-initramfs mkinitrd ''; do
+	[[ $mkinitrd ]] && which "$mkinitrd" >/dev/null 2>&1 && break
+    done
+
+    # no mkinitrd? Just return.
+    [[ $mkinitrd ]] || return 0
+
+    # back up our current initrd
+    echo $""
+    [[ $2 = ia64 && -d /boot/efi/efi/redhat ]] && initrd_dir="/boot/efi/efi/redhat"
+    # find out what the proper filename will be
+    for initrd in "initrd-$1.img" "initramfs-$1.img" "initrd.img-$1" "initrd-$1" ''; do
+	[[ $initrd && -f $initrd_dir/$initrd ]] && break
+    done
+    if ! [[ $initrd ]]; then
+	# Return if we cannot find an initrd.
+	warn $"Unable to find an initial ram disk that I know how to handle." \
+	    $"Will not try to make an initrd."
+	return 0
+    fi
+    echo $"Backing up $initrd to $initrd_dir/$initrd.old-dkms"
+    cp -f "$initrd_dir/$initrd" "$initrd_dir/$initrd.old-dkms"
+    echo $"Making new $initrd"
+    echo $"(If next boot fails, revert to $initrd.old-dkms image)"
+
+    if [[ $mkinitrd = dracut ]]; then
+	invoke_command "$mkinitrd $1" "$mkinitrd" background
+    elif [[ $mkinitrd = update-initramfs ]]; then
+	invoke_command "$mkinitrd -u" "$mkinitrd" background
+    elif $mkinitrd --version >/dev/null 2>&1; then
+	invoke_command "$mkinitrd -f $initrd_dir/$initrd $1" "$mkinitrd" background
+    elif [[ -e /etc/SuSE-release || -d /etc/SuSEconfig ]]; then
+	for kernel_file in vmlinuz vmlinux ''; do
+	    [[ $kernel_file && -f $initrd_dir/$kernel_file ]] && break
+	done
+	if [[ ! $kernel_file ]]; then
+	    error $"Unable to find valid kernel file under " \
+		$"$initrd_dir for kernel version $1" 
+	    return 1;
+	fi
+	invoke_command "$mkinitrd -k $kernel_file-$1 -i $initrd" "$mkinitrd" background
+    elif [[ -e /etc/debian_version ]]; then
+	invoke_command "$mkinitrd -o $initrd_dir/$initrd $1" "$mkinitrd" background
+    else
+	echo $""
+	echo $"Calling $mkinitrd (bad exit status 9 may occur)"
+	invoke_command "$mkinitrd" "$mkinitrd" background
+    fi
+    return
+}
+
+# Grab our distro information from RPM-based distros.
+distro_version_rpm()
+{
+    which rpm > /dev/null 2>&1 || { echo unknown; return; }
+    local r wp ver dist
+
+    for r in redhat-release sles-release suse-release ovs-release; do
+	wp=$(rpm -q --whatprovides "$r") || continue
+	ver=$(rpm -q --qf "%{version}\n" ${wp})
+	case $r in
+	    sles*) echo sles${ver};;
+	    suse*) echo suse${ver};;
+	    ovs*)  echo ovm${ver};;
+	    redhat*)
+		case $wp in
+		    redhat*|sl*)
+			ver=$(echo $ver | \
+			sed -e 's/^$[[:digit:]]*$.*/\1/g')
+			echo el${ver};;
+		    centos*|enterprise*) echo el${ver};;
+		    fedora*) echo fc${ver};;
+		    *) echo unknown ;;
+		esac
+	       ;;
+	    *) echo unknown;;
+	esac
+	return
+    done
+    echo unknown
+}
+
+# Grab distro information from LSB compliant distros.
+# Falls back to distro_version_rpm if needed.
+distro_version()
 {
-# What distribution are we running?
-    local LSB_RELEASE
-    local LSB_DESCRIPTION
-    local DISTRIB_ID
-    local DISTRIB_RELEASE
-    local VER
-    local dist=unknown
+    # What distribution are we running?
+    local LSB_DESCRIPTION DISTRIB_ID DISTRIB_RELEASE ver
 
-# try the LSB-provided strings first
+    # try the LSB-provided strings first
     if [ -r /etc/lsb-release ]; then
-        . /etc/lsb-release
-        LSB_RELEASE=1
+	. /etc/lsb-release
     elif type lsb_release >/dev/null 2>&1; then
-        DISTRIB_ID=$(lsb_release -i -s)
-        DISTRIB_RELEASE=$(lsb_release -r -s)
-        LSB_RELEASE=1
-    fi
-
-    case "${DISTRIB_ID}" in
-    Fedora)     dist=fc${DISTRIB_RELEASE} ;;
-    RedHatEnterprise*)  # OEL also reports as such
-        # format is 4.7, 5.3
-        VER=$(echo "${DISTRIB_RELEASE}" | sed -e 's/^$[[:digit:]]*$.*/\1/g')
-        dist=el${VER}
-        ;;
-    CentOS)
-        # format is 4.7, 5.3
-        VER=$(echo "${DISTRIB_RELEASE}" | sed -e 's/^$[[:digit:]]*$.*/\1/g')
-        dist=el${VER}
-        ;;
-    ScientificSL)
-        # format is 4.7, 5.3
-        VER=$(echo "${DISTRIB_RELEASE}" | sed -e 's/^$[[:digit:]]*$.*/\1/g')
-        dist=el${VER}
-        ;;
-    SUSE*)
-        LSB_DESCRIPTION="$(lsb_release -d -s)"
-        if echo "${LSB_DESCRIPTION}" | grep Enterprise > /dev/null 2>&1; then
-            dist=sles${DISTRIB_RELEASE}
-        else
-            dist=suse${DISTRIB_RELEASE}
-        fi
-        ;;
-    *)
-        if [ -n "${LSB_RELEASE}" -a -n "${DISTRIB_ID}" -a -n "${DISTRIB_RELEASE}" ]; then
-            dist="${DISTRIB_ID}${DISTRIB_RELEASE}"
-        fi
-        ;;
-    esac
-
-    if [ "${dist}" == "unknown" ]; then
-        dist=$(distro_version_rpm)
+	DISTRIB_ID=$(lsb_release -i -s)
+	DISTRIB_RELEASE=$(lsb_release -r -s)
     fi
-    echo "$dist"
+
+    case ${DISTRIB_ID} in
+	Fedora)     echo fc${DISTRIB_RELEASE} ;;
+	RedHatEnterprise*|CentOS|ScientificSL)  # OEL also reports as such
+	# format is 4.7, 5.3
+	    ver=$(echo "${DISTRIB_RELEASE}" | \
+		sed -e 's/^$[[:digit:]]*$.*/\1/g')
+	    echo el${ver}
+	    ;;
+	SUSE*)
+	    if [[ $(lsb_release -d -s) =~ Enterprise ]]; then
+		echo sles${DISTRIB_RELEASE}
+	    else
+		echo suse${DISTRIB_RELEASE}
+	    fi
+	    ;;
+	*)
+	    if [[ ${DISTRIB_ID} && ${DISTRIB_RELEASE} ]]; then
+		echo "${DISTRIB_ID}${DISTRIB_RELEASE}"
+	    else
+		distro_version_rpm
+	    fi
+	    ;;
+    esac
 }
 
-function override_dest_module_location()
+override_dest_module_location()
 {
     local orig_location="$1"
-    [ -n "${addon_modules_dir}" ] && echo "/${addon_modules_dir}" && return
+    [[ ${addon_modules_dir} ]] && echo "/${addon_modules_dir}" && return
+
+    if [ "$current_os" = "GNU/kFreeBSD" ] ; then
+	# Does not support subdirs, regardless of distribution
+	echo "" && return
+    fi
 
     case "$running_distribution" in
-    fc[12345]) ;;
-    el[1234]) ;;
-    sles[123456789]) ;;
-    suse[123456789]) ;;
-    suse10\.[01]) ;;
-    fc*) echo "/extra" && return ;;
-    el*) echo "/extra" && return ;;
-    ovm*) echo "/extra" && return ;;
-    sles*) echo "/updates" && return ;;
-    suse*) echo "/updates" && return ;;
-    Ubuntu*) echo "/updates/dkms" && return ;;
-    Debian*) echo "/updates/dkms" && return ;;
-    *) ;;
+	fc[12345]) ;;
+	el[1234]) ;;
+	sles[123456789]) ;;
+	suse[123456789]) ;;
+	suse10\.[01]) ;;
+	fc*) echo "/extra" && return ;;
+	el*) echo "/extra" && return ;;
+	ovm*) echo "/extra" && return ;;
+	sles*) echo "/updates" && return ;;
+	suse*) echo "/updates" && return ;;
+	Ubuntu*) echo "/updates/dkms" && return ;;
+	Debian*) echo "/updates/dkms" && return ;;
+	*) ;;
     esac
     echo "$orig_location"
 }
 
-function read_conf ()
+# Source a file safely.
+# We want to ensure that the .conf file we source does not stomp all over
+# parts of the environment we don't want them to.  This makes it so that
+# it is harder to accidentally corrupt our environment.  conf files can
+# still deliberatly trash the environment by abusing dkms_directive env
+# variables or by crafting special values that will make eval do evil things.
+safe_source() {
+    # $1 = file to source
+    # $@ = environment variables to echo out
+    local to_source_file="$1"; shift
+    declare -a -r export_envs=("$@")
+    local tmpfile=$(mktemp_or_die)
+    ( exec >"$tmpfile"
+	. "$to_source_file" >/dev/null
+	# This is really ugly, but a neat hack
+	# Remember, in bash 2.0 and greater all variables are really arrays.
+	for _export_env in "${export_envs[@]}"; do
+	    for _i in $(eval echo \${!$_export_env[@]}); do
+		eval echo '$_export_env[$_i]=\"${'$_export_env'[$_i]}\"'
+	    done
+	done
+
+	# handle DKMS_DIRECTIVE stuff specially.
+	for directive in $(set | grep ^DKMS_DIRECTIVE | cut -d = -f 2-3); do
+	    directive_name=${directive%%=*}
+	    directive_value=${directive#*=}
+	    echo "$directive_name=\"$directive_value\""
+	done
+    )
+    . "$tmpfile"
+    rm "$tmpfile"
+}
+
+# Source a dkms.conf file and perform appropriate postprocessing on it.
+# Do our best to not repeatedly source the same .conf file -- this can happen
+# when chaining module installtion functions or autoinstalling.
+read_conf()
 {
     # $1 kernel version (required)
     # $2 arch (required)
     # $3 dkms.conf location (optional)
 
     local return_value=0
-    local read_conf_file
-
-    # Find which conf file to check
-    if [ -n "$3" ]; then
-        read_conf_file="$3"
-    elif [ -n "$conf" ]; then
-        read_conf_file="$conf"
-    else
-        read_conf_file="$dkms_tree/$module/$module_version/source/dkms.conf"
-    fi
-
-    # Clear variables
-    MAKE=""
-    CLEAN=""
-    REMAKE_INITRD=""
-    remake_initrd=""
-    PACKAGE_NAME=""
-    PACKAGE_VERSION=""
-    POST_ADD=""
-    POST_BUILD=""
-    POST_INSTALL=""
-    POST_REMOVE=""
-    PRE_BUILD=""
-    PRE_INSTALL=""
-    BUILD_EXCLUSIVE_KERNEL=""
-    BUILD_EXCLUSIVE_ARCH=""
-    build_exclude=""
-    OBSOLETE_BY=""
-
-    # Clear arrays
-    unset MAKE
-    unset MAKE_MATCH
-    unset MODULES_CONF
-    unset modules_conf_array
-    unset PATCH
-    unset PATCH_MATCH
-    unset patch_array
-    unset BUILT_MODULE_NAME
-    unset built_module_name
-    unset BUILT_MODULE_LOCATION
-    unset built_module_location
-    unset DEST_MODULE_NAME
-    unset dest_module_name
-    unset DEST_MODULE_LOCATION
-    unset dest_module_location
-    unset MODULES_CONF_OBSOLETES
-    unset modules_conf_obsoletes
-    unset MODULES_CONF_ALIAS_TYPE
-    unset modules_conf_alias_type
-    unset MODULES_CONF_OBSOLETE_ONLY
-    unset modules_conf_obsolete_only
-    unset STRIP
-    unset strip
+    local read_conf_file="$dkms_tree/$module/$module_version/source/dkms.conf"
 
     # Set variables supported in dkms.conf files (eg. $kernelver)
-    kernelver="$1"
-    arch="$2"
+    local kernelver="$1"
+    local arch="$2"
     set_kernel_source_dir "$1"
 
-    # Source in the dkms.conf
-    . $read_conf_file 2>/dev/null
 
-    # check environment for directives
-    # You can't have an array of variables exported
-    # so look for DKMS_DIRECTIVE0, DKMS_DIRECTIVE1, ...
-    for directive in `set | grep ^DKMS_DIRECTIVE | cut -d = -f 2-3`; do
-        directive_name=${directive%%=*}
-        directive_value=${directive#*=}
-        export $directive_name="$directive_value"
-        echo $"DIRECTIVE: $directive_name=\"$directive_value\""
+    # Find which conf file to check
+    [[ $conf ]] && read_conf_file="$conf"
+    [[ $3 ]] && read_conf_file="$3"
+
+    [[ -r $read_conf_file ]] || die 4 $"Could not locate dkms.conf file." \
+	$"File: $conf does not exist."
+
+    [[ $last_mvka = $module/$module_version/$1/$2 && \
+	$last_mvka_conf = $(readlink -f $read_conf_file) ]] && return
+
+
+    # Clear variables and arrays
+    for var in $dkms_conf_variables; do
+	unset $var
+    done
+
+    # Source in the dkms.conf.
+    # Allow for user-specified overrides in order of specificity.
+    local _conf_file
+    for _conf_file in "$read_conf_file" "/etc/dkms/$module.conf" \
+        "/etc/dkms/$module-$module_version.conf" "/etc/dkms/$module-$module_version-$1.conf" \
+        "/etc/dkms/$module-$module_version-$1-$2.conf"; do
+        [ -e "$_conf_file" ] && safe_source "$_conf_file" $dkms_conf_variables
     done
 
     # Source in the directive_array
     for directive in "${directive_array[@]}"; do
-        directive_name=${directive%%=*}
-        directive_value=${directive#*=}
-        export $directive_name="$directive_value"
-        echo $"DIRECTIVE: $directive_name=\"$directive_value\""
+	directive_name=${directive%%=*}
+	directive_value=${directive#*=}
+	export $directive_name="$directive_value"
+	echo $"DIRECTIVE: $directive_name=\"$directive_value\""
     done
 
     # Set variables
@@ -530,342 +497,341 @@
     obsolete_by="$OBSOLETE_BY"
 
     # Set module naming/location arrays
-    local index=0
-    array_size=`echo -e "${#BUILT_MODULE_NAME[@]}\n${#BUILT_MODULE_LOCATION[@]}\n${#DEST_MODULE_NAME[@]}\n${#DEST_MODULE_LOCATION[@]}\n" | sort -n | tail -n 1`
-    while [ "$index" -lt "$array_size" ]; do
-        # Set values
-        built_module_name[$index]=${BUILT_MODULE_NAME[$index]}
-        built_module_location[$index]=${BUILT_MODULE_LOCATION[$index]}
-        dest_module_name[$index]=${DEST_MODULE_NAME[$index]}
-        dest_module_location[$index]=${DEST_MODULE_LOCATION[$index]}
-        modules_conf_obsoletes[$index]=${MODULES_CONF_OBSOLETES[$index]}
-        modules_conf_alias_type[$index]=${MODULES_CONF_ALIAS_TYPE[$index]}
-        case "${MODULES_CONF_OBSOLETE_ONLY[$index]}" in
-        [yY]*)
-            modules_conf_obsolete_only[$index]="yes"
-            ;;
-        esac
-        case "${STRIP[$index]}" in
-        [nN]*)
-            strip[$index]="no"
-            ;;
-        *)
-            strip[$index]="yes"
-            ;;
-        esac
-
-        # If unset, set by defaults
-        [ -z "${built_module_name[$index]}" ] && [ ${#DEST_MODULE_LOCATION[@]} -eq 1 ] && built_module_name[$index]=$module
-        [ -z "${dest_module_name[$index]}" ] && dest_module_name[$index]=${built_module_name[$index]}
-        if [ -n "${built_module_location[$index]}" ] && \
-           [ "${built_module_location[$index]:(-1)}" != "/" ]; then
-            built_module_location[$index]="${built_module_location[$index]}/"
-        fi
-
-        # FAIL if no built_module_name
-        if [ -z "${built_module_name[$index]}" ]; then
-            echo $"dkms.conf: Error! No 'BUILT_MODULE_NAME' directive specified for record #$index." >&2
-            return_value=1
-        fi
-
-        # FAIL if built_module_name ends in .o or .ko
-        case "${built_module_name[$index]}" in
-        *.o | *.ko)
-            echo $"dkms.conf: Error! 'BUILT_MODULE_NAME' directive ends in '.o' or '.ko' in record #$index." >&2
-            return_value=1
-            ;;
-        esac
-
-        # FAIL if dest_module_name ends in .o or .ko
-        case "${dest_module_name[$index]}" in
-        *.o | *.ko)
-            echo $"dkms.conf: Error! 'DEST_MODULE_NAME' directive ends in '.o' or '.ko' in record #$index." >&2
-            return_value=1
-            ;;
-        esac
-
-        # Override location for specific kernels
-        dest_module_location[$index]="$(override_dest_module_location ${dest_module_location[$index]})"
-
-        # Fail if no DEST_MODULE_LOCATION
-        if [ -z "${DEST_MODULE_LOCATION[$index]}" ]; then
-            echo $"dkms.conf: Error! No 'DEST_MODULE_LOCATION' directive specified for record #$index.">&2
-            return_value=1
-        fi
-            # Fail if bad DEST_MODULE_LOCATION
-        case "${DEST_MODULE_LOCATION[$index]}" in
-        /kernel*) ;;
-        /updates*) ;;
-        /extra*) ;;
-        *)
-            echo $"dkms.conf: Error! Directive 'DEST_MODULE_LOCATION' does not begin with">&2
-            echo $"'/kernel', '/updates', or '/extra' in record #$index.">&2
-            return_value=1
-            ;;
-        esac
-
-        index=$(($index+1))
+    local index array_size=0 s
+    for s in ${#BUILT_MODULE_NAME[@]} \
+	${#BUILT_MODULE_LOCATION[@]} \
+	${#DEST_MODULE_NAME[@]} \
+	${#DEST_MODULE_LOCATION[@]}; do
+	((s > array_size)) && array_size=$s
+    done
+    for ((index=0; index < array_size; index++)); do
+	# Set values
+	built_module_name[$index]=${BUILT_MODULE_NAME[$index]}
+	built_module_location[$index]=${BUILT_MODULE_LOCATION[$index]}
+	dest_module_name[$index]=${DEST_MODULE_NAME[$index]}
+	dest_module_location[$index]=${DEST_MODULE_LOCATION[$index]}
+	modules_conf_obsoletes[$index]=${MODULES_CONF_OBSOLETES[$index]}
+	modules_conf_alias_type[$index]=${MODULES_CONF_ALIAS_TYPE[$index]}
+	case ${MODULES_CONF_OBSOLETE_ONLY[$index]} in
+	    [yY]*) modules_conf_obsolete_only[$index]="yes";;
+	esac
+	case ${STRIP[$index]} in
+	    [nN]*) strip[$index]="no";;
+	    *)     strip[$index]="yes";;
+	esac
+
+	# If unset, set by defaults
+	[[ ! ${built_module_name[$index]} ]] && \
+	    ((${#DEST_MODULE_LOCATION[@]} == 1)) && \
+	    built_module_name[$index]=$module
+	[[ ! ${dest_module_name[$index]} ]] && \
+	    dest_module_name[$index]=${built_module_name[$index]}
+	[[ ${built_module_location[$index]} && \
+	    ${built_module_location[$index]:(-1)} != / ]] && \
+	    built_module_location[$index]="${built_module_location[$index]}/"
+
+	# FAIL if no built_module_name
+	if [[ ! ${built_module_name[$index]} ]]; then
+	    echo $"dkms.conf: Error! No 'BUILT_MODULE_NAME' directive specified for record #$index." >&2
+	    return_value=1
+	fi
+
+	# FAIL if built_module_name ends in .o or .ko
+	case ${built_module_name[$index]} in
+	*.o|*.ko)
+	    echo $"dkms.conf: Error! 'BUILT_MODULE_NAME' directive ends in '.o' or '.ko' in record #$index." >&2
+	    return_value=1
+	    ;;
+	esac
+
+	# FAIL if dest_module_name ends in .o or .ko
+	case ${dest_module_name[$index]} in
+	*.o|*.ko)
+	    echo $"dkms.conf: Error! 'DEST_MODULE_NAME' directive ends in '.o' or '.ko' in record #$index." >&2
+	    return_value=1
+	    ;;
+	esac
+
+	# Override location for specific kernels
+	dest_module_location[$index]="$(override_dest_module_location ${dest_module_location[$index]})"
+
+	# Fail if no DEST_MODULE_LOCATION
+	if [[ ! ${DEST_MODULE_LOCATION[$index]} ]]; then
+	    echo $"dkms.conf: Error! No 'DEST_MODULE_LOCATION' directive specified for record #$index.">&2
+	    return_value=1
+	fi
+	    # Fail if bad DEST_MODULE_LOCATION
+	case ${DEST_MODULE_LOCATION[$index]} in
+	    /kernel*) ;;
+	    /updates*) ;;
+	    /extra*) ;;
+	    *)
+		echo $"dkms.conf: Error! Directive 'DEST_MODULE_LOCATION' does not begin with">&2
+		echo $"'/kernel', '/updates', or '/extra' in record #$index.">&2
+		return_value=1
+		;;
+	esac
     done
 
     # Get the correct make command
-    index=0
-    [ -z "${MAKE_MATCH[0]}" ] && make_command="${MAKE[0]}"
-    while [ "$index" -lt ${#MAKE[@]} ]; do
-        if [ -n "${MAKE[$index]}" ] && \
-            [ -n "${MAKE_MATCH[$index]}" ] && \
-            echo $1 | egrep -q "${MAKE_MATCH[$index]}"; then
-            make_command="${MAKE[$index]}"
-        fi
-        index=$(($index+1))
+    [[ ${MAKE_MATCH[0]} ]] || make_command="${MAKE[0]}"
+    for ((index=0; index < ${#MAKE[@]}; index++)); do
+	[[ ${MAKE[$index]} && ${MAKE_MATCH[$index]} && \
+	    $1 =~ ${MAKE_MATCH[$index]} ]] && \
+	    make_command="${MAKE[$index]}"
     done
 
     # Use the generic make and make clean commands if not specified
     if [[ $(VER $1) < $(VER 2.6.6) ]]; then
-        if [ -z "$make_command" ]; then
-            make_command="make -C $kernel_source_dir SUBDIRS=$dkms_tree/$module/$module_version/build modules"
-        fi
-        if [ -z "$clean" ]; then
-            clean="make -C $kernel_source_dir SUBDIRS=$dkms_tree/$module/$module_version/build clean"
-        fi
-    else
-        if [ -z "$make_command" ]; then
-            make_command="make -C $kernel_source_dir M=$dkms_tree/$module/$module_version/build"
-        fi
-        if [ -z "$clean" ]; then
-            clean="make -C $kernel_source_dir M=$dkms_tree/$module/$module_version/build clean"
-        fi
+	[[ ! $make_command ]] && \
+	    make_command="make -C $kernel_source_dir SUBDIRS=$dkms_tree/$module/$module_version/build modules"
+	[[ ! $clean ]] && \
+	    clean="make -C $kernel_source_dir SUBDIRS=$dkms_tree/$module/$module_version/build clean"
+    else
+	[[ ! $make_command ]] && \
+	    make_command="make -C $kernel_source_dir M=$dkms_tree/$module/$module_version/build"
+	 [[ ! $clean ]] && \
+	     clean="make -C $kernel_source_dir M=$dkms_tree/$module/$module_version/build clean"
     fi
 
     # Set modules_conf_array
-    index=0
-    while [ "$index" -lt ${#MODULES_CONF[@]} ]; do
-        [ -n "${MODULES_CONF[$index]}" ] && modules_conf_array[$index]="${MODULES_CONF[$index]}"
-        index=$(($index+1))
+    for ((index=0; index < ${#MODULES_CONF[@]}; index++)); do
+	[[ ${MODULES_CONF[$index]} ]] && modules_conf_array[$index]="${MODULES_CONF[$index]}"
     done
 
     # Set patch_array (including kernel specific patches)
-    index=0
     count=0
-    while [ "$index" -lt ${#PATCH[@]} ]; do
-        if [ -n "${PATCH[$index]}" ]; then
-            if [ -z "${PATCH_MATCH[$index]}" ] || \
-                echo $1 | egrep -q "${PATCH_MATCH[$index]}"; then
-                patch_array[$count]="${PATCH[$index]}"
-                count=$(($count+1))
-            fi
-        fi
-        index=$(($index+1))
+    for ((index=0; index < ${#PATCH[@]}; index++)); do
+	if [[ ${PATCH[$index]} && (! ${PATCH_MATCH[$index]} || \
+		$1 =~ ${PATCH_MATCH[$index]}) ]]; then
+	    patch_array[$count]="${PATCH[$index]}"
+	    count=$(($count+1))
+	fi
     done
 
     # Set remake_initrd
-    [ `echo "$REMAKE_INITRD" | grep -ic "^y"` -gt 0 ] && remake_initrd="yes"
+    [[ $REMAKE_INITRD =~ $y_re ]] && remake_initrd="yes"
 
     # Set build_exclude
-    if [ -n "$BUILD_EXCLUSIVE_KERNEL" ]; then
-        echo $1 | egrep -q "$BUILD_EXCLUSIVE_KERNEL" || build_exclude="yes"
-    fi
-    if [ -n "$BUILD_EXCLUSIVE_ARCH" ]; then
-        echo $2 | egrep -q "$BUILD_EXCLUSIVE_ARCH" || build_exclude="yes"
-    fi
+    [[ $BUILD_EXCLUSIVE_KERNEL && ! $1 =~ $BUILD_EXCLUSIVE_KERNEL ]] && \
+       build_exclude="yes"
+    [[ $BUILD_EXCLUSIVE_ARCH && ! $2 =~ $BUILD_EXCLUSIVE_ARCH ]] && \
+	build_exclude="yes"
 
     # Fail if absolutely no DEST_MODULE_LOCATION
-    if [ ${#dest_module_location[@]} -eq 0 ]; then
-        echo $"dkms.conf: Error! No 'DEST_MODULE_LOCATION' directive specified." >&2
-        return_value=1
+    if ((${#dest_module_location[@]} == 0)); then
+	echo $"dkms.conf: Error! No 'DEST_MODULE_LOCATION' directive specified." >&2
+	return_value=1
     fi
 
     # Fail if no PACKAGE_NAME
-    if [ -z "$package_name" ]; then
-        echo $"dkms.conf: Error! No 'PACKAGE_NAME' directive specified.">&2
-        return_value=1
+    if [[ ! $package_name ]]; then
+	echo $"dkms.conf: Error! No 'PACKAGE_NAME' directive specified.">&2
+	return_value=1
     fi
 
     # Fail if no PACKAGE_VERSION
-    if [ -z "$package_version" ]; then
-        echo $"dkms.conf: Error! No 'PACKAGE_VERSION' directive specified.">&2
-        return_value=1
+    if [[ ! $package_version ]]; then
+	echo $"dkms.conf: Error! No 'PACKAGE_VERSION' directive specified.">&2
+	return_value=1
     fi
 
     # Set clean
-    [ -z "$clean" ] && clean="make clean"
+    [[ $clean ]] || clean="make clean"
 
+    ((return_value == 0)) && last_mvka="$module/$module_version/$1/$2" && \
+	last_mvka_conf="$(readlink -f "$read_conf_file")"
     return $return_value
 }
 
+# Little helper function for parsing the output of modinfo.
+get_module_verinfo(){
+    local vals=
+    while read -a vals; do
+	case ${vals[0]} in
+	    version:) res[0]=${vals[1]}; res[2]=${vals[2]};;
+	    srcversion:) res[1]=${vals[1]};;
+	esac
+    done < <(modinfo $1)
+}
 
-function check_version_sanity ()
+# Perform some module version sanity checking whenever we are installing
+# or removing modules.
+check_version_sanity()
 {
     # $1 = kernel_version
     # $2 = arch
     # $3 = obs by kernel version
     # $4 = dest_module_name
 
-    local lib_tree="$install_tree/$1"
+    local lib_tree="$install_tree/$1" res=
     echo $"Running module version sanity check."
-    local module_count=`find $lib_tree -name ${4}$module_suffix | wc -l | awk {'print $1'}`
-    if [ $module_count -gt 1 ]; then
-        echo $"Warning! Cannot do version sanity checking because multiple ${4}$module_suffix" >&2
-        echo $"modules were found in kernel $1." >&2
-    elif [ $module_count -eq 1 ]; then
-        local kernels_module=`find $lib_tree -name ${4}$module_suffix`
-        local kernels_ver_string=`modinfo $kernels_module | grep "^version:"`
-        local kernels_ver_value=`echo $kernels_ver_string | awk {'print $2'}`
-        local dkms_module="$dkms_tree/$module/$module_version/$1/$2/module/${4}$module_suffix"
-        local dkms_ver_string=`modinfo $dkms_module | grep "^version:"`
-        local dkms_ver_value=`echo $dkms_ver_string | awk {'print $2'}`
-
-        # there are 2 possible srcversion checksums
-        # one in the 'srcversion' tag alone (preferred)
-        # and one following the version field in the 'version' tag (deprecated)
-        local kernels_ver_checksum=`modinfo $kernels_module | awk '/^srcversion:/ {print $2}'`
-        local dkms_ver_checksum=`modinfo $dkms_module | awk '/^srcversion:/ {print $2}'`
-        if [ -z "$kernels_ver_checksum" -a -z "$dkms_ver_checksum" ]; then
-            kernels_ver_checksum=`echo $kernels_ver_string | awk {'print $3'}`
-            dkms_ver_checksum=`echo $dkms_ver_string | awk {'print $3'}`
-        fi
-
-        if [ -n "$kernels_ver_checksum" -a -n "$dkms_ver_checksum" -a \
-            "$kernels_ver_checksum" == "$dkms_ver_checksum" -a -z "$force" ]; then
-            echo $"" >&2
-            echo $"Good news! Module version $dkms_ver_value for ${4}$module_suffix" >&2
-            echo $"exactly matches what is already found in kernel $1." >&2
-            echo $"DKMS will not replace this module." >&2
-            echo $"You may override by specifying --force." >&2
-            return 1
-        fi
-
-        if [ -n "$kernels_ver_value" -a -n "$dkms_ver_value" ]; then
-            if [[ ! ( $(VER $dkms_ver_value) > \
-                      $(VER $kernels_ver_value) ) && -z "$force" ]]; then
-                echo $"" >&2
-                echo $"Error! Module version $dkms_ver_value for ${4}$module_suffix" >&2
-                echo $"is not newer than what is already found in kernel $1 ($kernels_ver_value)." >&2
-                echo $"You may override by specifying --force." >&2
-                return 1
-            fi
-        fi
-
-        local obs_upstream=`echo $3 | cut -d- -f 1`
-        local obs_local=`echo $3 | cut -d- -f 2`
-        local my_upstream=`echo $1 | cut -d- -f 1`
-        local my_local=`echo $1 | cut -d- -f 2`
-        local obsolete=0
-        if [ -n "$obs_upstream" -a -n "$my_upstream" ]; then
-            if [[ ( $(VER $obs_upstream) == $(VER $my_upstream) ) && -z "$force" ]]; then
-            #they get obsoleted possibly in this kernel release
-                if [ -z "$obs_local" ]; then
-                #they were obsoleted in this upstream kernel
-                    obsolete=1
-                elif [[ ( $(VER $my_local) > $(VER $obs_local) ) ]]; then
-                #they were obsoleted in an earlier ABI bump of the kernel
-                    obsolete=1
-                elif [[ ( $(VER $my_local) = $(VER $obs_local) ) ]]; then
-                #they were obsoleted in this ABI bump of the kernel
-                    obsolete=1
-                fi
-            elif [[ ( $(VER $my_upstream) > $(VER $obs_upstream) ) && -z "$force" ]]; then
-            #they were obsoleted in an earlier kernel release
-                obsolete=1
-            fi
-        fi
-
-        if [ "$obsolete" == 1 ]; then
-            echo $"" >&2
-            echo $"Module has been obsoleted due to being included" >&2
-            echo $"in kernel $3.  We will avoid installing" >&2
-            echo $"for future kernels above $3." >&2
-            echo $"You may override by specifying --force." >&2
-            return 1
-        fi
+    local i=0
+    local -a kernels_info dkms_info
+    set_module_suffix
+    read -a kernels_module < <(find $lib_tree -name ${4}$module_suffix)
+    [[ $kernels_module ]] || return 0
+    if [[ ${kernels_module[1]} ]]; then
+	warn $"Warning! Cannot do version sanity checking because multiple ${4}$module_suffix" \
+	    $"modules were found in kernel $1."
+	return 0
+    fi
+    local dkms_module="$dkms_tree/$module/$module_version/$1/$2/module/${4}$module_suffix"
+    get_module_verinfo $kernels_module; kernels_info=("${res[@]}")
+    get_module_verinfo $dkms_module; dkms_info=("${res[@]}")
+    if [[ ! ${dkms_info[1]} && ${kernels_info[1]} ]]; then
+	# use obsolete checksum info
+	dkms_info[1]=${dkms_info[2]}
+	kernels_info[1]=${kernels_info[2]}
+    fi
+
+    if [[ ${kernels_info[1]} && ${dkms_info[1]} && \
+	${kernels_info[1]} = ${dkms_info[1]} && ! $force ]]; then
+	echo $"" >&2
+	echo $"Good news! Module version $dkms_info for ${4}$module_suffix" >&2
+	echo $"exactly matches what is already found in kernel $1." >&2
+	echo $"DKMS will not replace this module." >&2
+	echo $"You may override by specifying --force." >&2
+	return 1
+    fi
+
+    if [[ $kernels_info && $dkms_info && \
+	! ( $(VER $dkms_info) > $(VER $kernels_info) ) && ! $force ]]; then
+	error $"Module version $dkms_info for ${4}$module_suffix" \
+	    $"is not newer than what is already found in kernel $1 ($kernels_info)." \
+	    $"You may override by specifying --force."
+	return 1
+    fi
+
+    # magic split into array syntax saves trivial awk and cut calls.
+    local -a obs=(${3//-/ })
+    local -a my=(${1//-/ })
+    local obsolete=0
+    if [[ ${obs} && ${my} ]]; then
+	if [[ $(VER ${obs}) == $(VER ${my}) && ! $force ]]; then
+	    #they get obsoleted possibly in this kernel release
+	    if [[ ! ${obs[1]} ]]; then
+		#they were obsoleted in this upstream kernel
+		obsolete=1
+	    elif [[ $(VER ${my[1]}) > $(VER ${obs[1]}) ]]; then
+		#they were obsoleted in an earlier ABI bump of the kernel
+		obsolete=1
+	    elif [[ $(VER ${my[1]}) = $(VER ${obs[1]}) ]]; then
+		#they were obsoleted in this ABI bump of the kernel
+		obsolete=1
+	    fi
+	elif [[ $(VER ${my}) > $(VER ${obs}) && ! $force ]]; then
+	    #they were obsoleted in an earlier kernel release
+	    obsolete=1
+	fi
+    fi
+
+    if ((obsolete == 1)); then
+	echo $"" >&2
+	echo $"Module has been obsoleted due to being included" >&2
+	echo $"in kernel $3.  We will avoid installing" >&2
+	echo $"for future kernels above $3." >&2
+	echo $"You may override by specifying --force." >&2
+	return 1
     fi
     return 0
 }
 
+moduleconfig_update_obsoletes()
+{
+    # $@ = files to process
+    # do nothing if we have no obsoletes
+    [[ ${modules_conf_obsoletes[@]} ]] || return 0
+    # generate sed args to remove obsolete modules
+    local mod_diff
+    for ((index=0; index < ${#dest_module_name[@]}; index++)); do
+	[[ ${modules_conf_obsoletes[$index]} ]] || continue
+	for obsolete_module in ${modules_conf_obsoletes[$index]//,/ }; do
+	    # for module.conf style syntax
+	    sa_mc_o[${#sa_mc_o[@]}]="-e"
+	    sa_mc_o[${#sa_mc_o[@]}]="s/$alias ${modules_conf_alias_type[$index]}[0-9]*$ $obsolete_module$/\1 ${dest_module_name[$index]}/g"
+
+	    # for /etc/sysconfig/kernel style syntax
+	    sa_sck_o[${#sa_sck_o[@]}]="-e"
+	    sa_sck_o[${#sa_sck_o[@]}]="s/$INITRD_MODULES.*$$obsolete_module\b$.*$/\1${dest_module_name[$index]}\2/"
+	done
+    done
+
+    # do all the changes at once, record the diffs for posterity
+    for file in "$@"; do
+	[[ $file && -w $file ]] || continue
+	if [[ $file = /etc/sysconfig/kernel ]]; then
+	    sed "${sa_sck_o[@]}" "$file" > "$temp_dir_name/${file##*/}.new"
+	else
+	    sed "${sa_mc_o[@]}" "$file" > "$temp_dir_name/${file##*/}.new"
+	fi
+	if ! mod_diff=$(diff -u "$temp_dir_name/${file##*/}.new" "$file"); then
+	    echo $"$file updated to replace obsoleted module references:"
+	    echo "$mod_diff"
+	    cp -fp "$temp_dir_name/${file##*/}.new" "$file"
+	    rm -f "$temp_dir_name/${file##*/}.new"
+	fi
+    done
+}
 
-function moduleconfig_add ()
+moduleconfig_add()
 {
     # $1 = kernel version
 
-    local temp_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
-    modconfig_files=""
-    [ -e /etc/modprobe.d/dkms.conf ] && modconfig_files="/etc/modprobe.d/dkms.conf"
-    [ -e /etc/modprobe.d/dkms ] && modconfig_files="/etc/modprobe.d/dkms"
-    [ -e /etc/modules.conf ] && modconfig_files="$modconfig_files /etc/modules.conf"
-    [ -e /etc/modprobe.conf ] && modconfig_files="$modconfig_files /etc/modprobe.conf"
-    [ -e /etc/modprobe.d/$package_name.conf ] && modconfig_files="/etc/modprobe.d/$package_name.conf"
-
-    if [ -z "$modconfig_files" ]; then
-        modconfig_files="/etc/modprobe.d/$package_name.conf"
-    fi
+    local temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
+    local -a sa_mc_o=() sa_sck_o=()
+    modconfig_files="/etc/modprobe.d/dkms.conf
+		     /etc/modprobe.d/dkms
+		     /etc/modules.conf
+		     /etc/modprobe.conf
+		     /etc/modprobe.d/$package_name.conf
+		     /etc/sysconfig/kernel"
 
+    moduleconfig_update_obsoletes $modconfig_files
 
     for moduleconfig in $modconfig_files; do
-        local index=0
-        while [ $index -lt ${#dest_module_name[@]} ]; do
-            # Replace obsolete references in module-config-file with the new module name
-            if [ -n "${modules_conf_obsoletes[$index]}" ]; then
-                for obsolete_module in ${modules_conf_obsoletes[$index]//,/ }; do
-                    sed "s/$alias ${modules_conf_alias_type[$index]}[0-9]*$ $obsolete_module$/\1 ${dest_module_name[$index]}/g" $moduleconfig > $temp_dir_name/moduleconfig.new
-                    if ! diff $moduleconfig $temp_dir_name/moduleconfig.new >/dev/null 2>&1; then
-                        cp -fp $temp_dir_name/moduleconfig.new $moduleconfig 2>/dev/null
-                        rm -f $temp_dir_name/moduleconfig.new 2>/dev/null
-                        echo $"$moduleconfig: obsolete alias '$obsolete_module' changed to '${dest_module_name[$index]}'"
-                    fi
-                    if [ -e /etc/sysconfig/kernel ]; then
-                       sed -e "s/$INITRD_MODULES.*$$obsolete_module\b$.*$/\1${dest_module_name[$index]}\2/" /etc/sysconfig/kernel > $temp_dir_name/kernel.new
-                       if ! diff $temp_dir_name/kernel.new /etc/sysconfig/kernel >/dev/null 2>&1; then
-                           cp -fp $temp_dir_name/kernel.new /etc/sysconfig/kernel 2>/dev/null
-                           rm -f $temp_dir_name/kernel.new 2>/dev/null
-                           echo $"/etc/sysconfig/kernel: obsolete alias '$obsolete_module' changed to '${dest_module_name[$index]}'"
-                       fi
-                    fi
-                done
-            fi
-
-            # Only add it if it can't be found already in config file
-            if [ -n "${modules_conf_alias_type[$index]}" ] && \
-               ! grep -qs "alias ${modules_conf_alias_type[$index]}[0-9]* ${dest_module_name[$index]}\b" $moduleconfig && \
-               [ "${modules_conf_obsolete_only[$index]}" != "yes" ]; then
-                if [ "$modconfig_files" == "/etc/modprobe.d/$package_name.conf" ] && \
-                    [ ! -e /etc/modprobe.d/$package_name.conf ]; then
-                    touch /etc/modprobe.d/$package_name.conf
-                    echo $"created /etc/modprobe.d/$package_name.conf.">&2
-                fi
-                aliases=$(awk "/^alias ${modules_conf_alias_type[$index]}/ {print \$2}" $moduleconfig)
-                if [ -n "$aliases" ]; then
-                    alias_number=$(($(echo "$aliases" | sed "s/${modules_conf_alias_type[$index]}//" | sort -n | tail -n 1) + 1))
-                else
-                    alias_number=0
-                fi
-                echo -e "alias ${modules_conf_alias_type[$index]}${alias_number} ${dest_module_name[$index]}" >> $moduleconfig
-                echo $"$moduleconfig: added alias reference for '${dest_module_name[$index]}'"
-            fi
+	[[ -e $moduleconfig ]] || continue
+	for ((index=0; index < ${#dest_module_name[@]}; index++)); do
 
-            index=$(($index+1))
-        done
-
-        # Add anything else
-        index=0
-        while [ $index -lt ${#modules_conf_array[@]} ]; do
-            if [ -n "${modules_conf_array[$index]}" ] && \
-            ! grep -q "${modules_conf_array[$index]}" "$moduleconfig"; then
-            echo -e $"$moduleconfig: added '${modules_conf_array[$index]}'"
-            echo -e "${modules_conf_array[$index]}" >> $moduleconfig
-            fi
-            index=$(($index+1))
-        done
+	    # Only add it if it can't be found already in config file
+	    if [[ ${modules_conf_alias_type[$index]} ]] && \
+	       ! grep -qs "alias ${modules_conf_alias_type[$index]}[0-9]* ${dest_module_name[$index]}\b" $moduleconfig && \
+	       [[ ${modules_conf_obsolete_only[$index]} != yes ]]; then
+		if [[ $modconfig_files = /etc/modprobe.d/$package_name.conf ]] && \
+		    [[ ! -e /etc/modprobe.d/$package_name.conf ]]; then
+		    touch /etc/modprobe.d/$package_name.conf
+		    echo $"created /etc/modprobe.d/$package_name.conf.">&2
+		fi
+		aliases=$(awk "/^alias ${modules_conf_alias_type[$index]}/ {print \$2}" $moduleconfig)
+		if [[ $aliases ]]; then
+		    alias_number=$(($(echo "$aliases" | sed "s/${modules_conf_alias_type[$index]}//" | sort -n | tail -n 1) + 1))
+		else
+		    alias_number=0
+		fi
+		echo -e "alias ${modules_conf_alias_type[$index]}${alias_number} ${dest_module_name[$index]}" >> $moduleconfig
+		echo $"$moduleconfig: added alias reference for '${dest_module_name[$index]}'"
+	    fi
+	done
+
+	# Add anything else
+	for ((index=0; index < ${#modules_conf_array[@]}; index++)); do
+	    if [ -n "${modules_conf_array[$index]}" ] && \
+	    ! grep -q "${modules_conf_array[$index]}" "$moduleconfig"; then
+	    echo -e $"$moduleconfig: added '${modules_conf_array[$index]}'"
+	    echo -e "${modules_conf_array[$index]}" >> $moduleconfig
+	    fi
+	done
     done
 
     # Delete the temp dir
     rm -rf $temp_dir_name
 }
 
-
-function moduleconfig_remove ()
+moduleconfig_remove()
 {
     # $1 = kernel version
 
-    local temp_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
+    local temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
     modconfig_files=""
     [ -e /etc/modprobe.d/dkms.conf ] && modconfig_files="/etc/modprobe.d/dkms.conf"
     [ -e /etc/modprobe.d/dkms ] && modconfig_files="/etc/modprobe.d/dkms"
@@ -874,152 +840,150 @@
     [ -e /etc/modprobe.d/$package_name.conf ] && modconfig_files="/etc/modprobe.d/$package_name.conf"
 
     for moduleconfig in $modconfig_files; do
-        index=0
-        while [ $index -lt ${#dest_module_name[@]} ]; do
-
-            # Remove/Replace aliases (maybe)
-            if [ -n "${modules_conf_alias_type[$index]}" ] && [ `find $install_tree/$1/ -name "${dest_module_name[$index]}.*" 2>/dev/null | wc -l | awk '{print $1}'` -eq 0 ]; then
-
-                local conf_replacement=""
-                for obsolete_module in ${modules_conf_obsoletes[$index]//,/ }; do
-                    if [ `find $install_tree/$1/ -name "$obsolete_module.*" 2>/dev/null | wc -l | awk '{print $1}'` -gt 0 ] && [ -z "$conf_replacement" ]; then
-                        conf_replacement=$obsolete_module
-                    fi
-                done
-
-                if [ -n "$conf_replacement" ] && \
-                    grep -q "alias ${modules_conf_alias_type[$index]}[0-9]* ${dest_module_name[$index]}$" $moduleconfig; then
-                    sed "s/$alias ${modules_conf_alias_type[$index]}[0-9]*$ ${dest_module_name[$index]}$/\1 $conf_replacement/g" $moduleconfig > $temp_dir_name/moduleconfig.new
-                    mv -f $temp_dir_name/moduleconfig.new $moduleconfig
-                    echo $"$moduleconfig: alias for '${dest_module_name[$index]}' changed back to '$conf_replacement'"
-                elif [ -z "$conf_replacement" ]; then
-                    grep -v "alias ${modules_conf_alias_type[$index]}[0-9]* ${dest_module_name[$index]}" $moduleconfig > $temp_dir_name/moduleconfig.new
-                    mv -f $temp_dir_name/moduleconfig.new $moduleconfig
-                    echo $"$moduleconfig: removed alias for '${dest_module_name[$index]}'"
-                    if [ "$modconfig_files" == "/etc/modprobe.d/$package_name.conf" ]; then
-                        rm -f /etc/modprobe.d/$package_name.conf
-                        echo $"$moduleconfig: deleted /etc/modprobe.d/$package_name.conf file"
-                    fi
-                fi
-            fi
-
-            index=$(($index+1))
-        done
-
-        # Remove static conf entries
-        index=0
-        while [ $index -lt ${#modules_conf_array[@]} ]; do
-            if [ -n "${modules_conf_array[$index]}" ]; then
-            grep -v "${modules_conf_array[$index]}" "$moduleconfig" > $temp_dir_name/moduleconfig.new
-            echo $"$moduleconfig: removed '${modules_conf_array[$index]}'"
-            mv -f $temp_dir_name/moduleconfig.new $moduleconfig
-            fi
-            index=$(($index+1))
-        done
+	for ((index=0; index < ${#dest_module_name[@]}; index++)); do
+	    # Remove/Replace aliases (maybe)
+	    [[ ${modules_conf_alias_type[$index]} ]] || continue
+	    find "$install_tree/$1/" -name "${dest_module_name[$index]}.*" -quit 2>/dev/null && continue
+
+	    local conf_replacement=""
+	    for obsolete_module in ${modules_conf_obsoletes[$index]//,/ }; do
+		find $install_tree/$1/ -name "$obsolete_module.*" -quit 2>/dev/null || continue
+		conf_replacement=$obsolete_module
+		break
+	    done
+
+	    if [[ ! $conf_replacement ]]; then
+		grep -v "alias ${modules_conf_alias_type[$index]}[0-9]* ${dest_module_name[$index]}" $moduleconfig > $temp_dir_name/moduleconfig.new
+		mv -f $temp_dir_name/moduleconfig.new $moduleconfig
+		echo $"$moduleconfig: removed alias for '${dest_module_name[$index]}'"
+		if [[ $modconfig_files = /etc/modprobe.d/$package_name.conf ]]; then
+		    rm -f /etc/modprobe.d/$package_name.conf
+		    echo $"$moduleconfig: deleted /etc/modprobe.d/$package_name.conf file"
+		fi
+	    elif grep -q "alias ${modules_conf_alias_type[$index]}[0-9]* ${dest_module_name[$index]}$" $moduleconfig; then
+		sed "s/$alias ${modules_conf_alias_type[$index]}[0-9]*$ ${dest_module_name[$index]}$/\1 $conf_replacement/g" $moduleconfig > $temp_dir_name/moduleconfig.new
+		mv -f $temp_dir_name/moduleconfig.new $moduleconfig
+		echo $"$moduleconfig: alias for '${dest_module_name[$index]}' changed back to '$conf_replacement'"
+	    fi
+	done
+
+	# Remove static conf entries
+	for ((index=0; index < ${#modules_conf_array[@]}; index++)); do
+	    [[ ${modules_conf_array[$index]} ]] || continue
+	    grep -v "${modules_conf_array[$index]}" "$moduleconfig" > $temp_dir_name/moduleconfig.new
+	    echo $"$moduleconfig: removed '${modules_conf_array[$index]}'"
+	    mv -f $temp_dir_name/moduleconfig.new $moduleconfig
+	done
     done
 
     # Delete the temp dir
     rm -rf $temp_dir_name
 }
 
-# Does string word exist as a word in string list?
-# returns 0 if word present, 1 if word not present
-function is_word_in_list ()
-{
-    for l in $2; do
-        [ "$1" = "${l}" ] && return 0
-    done
-    return 1
-}
+etc_sysconfig_kernel_modify()
+(
+    [[ -e /etc/sysconfig/kernel && $remake_initrd ]] || return 0
 
-function etc_sysconfig_kernel_modify ()
-{
     # Make a temp directory to store files
-    local temp_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
-
-    if [ -e "/etc/sysconfig/kernel" ] && [ -n "$remake_initrd" ]; then
-        # Make /etc/sysconfig/kernel changes as necessary
-        if [ "$1" == "add" ]; then
-            unset INITRD_MODULES
-            eval `grep ^INITRD_MODULES= /etc/sysconfig/kernel`
-            for module_name_after in "${dest_module_name[@]}"; do
-                if ! is_word_in_list "${module_name_after}" "${INITRD_MODULES}"; then
-                    sed -e "s/INITRD_MODULES=\"$.*$\"/INITRD_MODULES=\"\1 $module_name_after\"/" /etc/sysconfig/kernel > $temp_dir_name/kernel.new
-                    mv $temp_dir_name/kernel.new /etc/sysconfig/kernel
-                fi
-            done
-        unset INITRD_MODULES
-
-        # Remove /etc/sysconfig/kernel entries
-        elif [ "$1" == "delete" ]; then
-            for module_name_after in "${dest_module_name[@]}"; do
-                sed -e "s/$INITRD_MODULES.*$$module_name_after\b$.*$/\1\2/" /etc/sysconfig/kernel > $temp_dir_name/kernel.new
-                mv $temp_dir_name/kernel.new /etc/sysconfig/kernel
-            done
-        fi
+    local temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
+    if [[ $1 = add ]]; then
+	. /etc/sysconfig/kernel
+	for m in "${dest_module_name[@]}"; do
+	    for l in "${INITRD_MODULES}"; do
+		[[ $m = $l ]] && continue 2
+	    done
+	    sed -e "s/INITRD_MODULES=\"$.*$\"/INITRD_MODULES=\"\1 $m\"/" /etc/sysconfig/kernel > $temp_dir_name/kernel.new
+	    mv $temp_dir_name/kernel.new /etc/sysconfig/kernel
+	done
+    # Remove /etc/sysconfig/kernel entries
+    elif [[ $1 = delete ]]; then
+	for m in "${dest_module_name[@]}"; do
+	    sed -e "s/$INITRD_MODULES.*$$m\b$.*$/\1\2/" /etc/sysconfig/kernel > $temp_dir_name/kernel.new
+	    mv $temp_dir_name/kernel.new /etc/sysconfig/kernel
+	done
     fi
-
     # Delete the temp dir
     rm -rf $temp_dir_name
+)
+
+check_module_args() {
+    [[ $module && $module_version ]] && return
+    die 1 $"Invalid number of arguments passed." \
+        $"Usage: $1 <module>/<module-version> or" \
+        $"       $1 -m <module>/<module-version> or" \
+	$"       $1 -m <module> -v <module-version>"
+}
+
+read_conf_or_die() {
+    read_conf "$@" && return
+    die 8 $"Bad conf file." $"File: $conf" \
+	$"does not represent a valid dkms.conf file."
+}
+
+run_build_script() {
+    # $1 = script type
+    # $2 = script to run
+    local script_type run
+    [[ $2 ]] || return 0
+    case "$1" in
+        pre_build|post_build) script_type='build';;
+        *) script_type='source'
+    esac
+    run="$dkms_tree/$module/$module_version/$script_type/$2"
+    if [[ -x ${run%% *} ]]; then
+        echo $""
+        echo $"Running the $1 script:"
+        (
+            cd "$dkms_tree/$module/$module_version/$script_type/"
+            exec $run
+        )
+    else
+        echo $""
+        warn $"The $1 script is not executable."
+    fi
 }
 
-function add_module ()
+# Register a DKMS-ified source tree with DKMS.
+# This function is smart enough to register the module if we
+# passed a source tree or a tarball instead of relying on the source tree
+# being unpacked into /usr/src/$module-$module_version.
+add_module()
 {
-    setup_kernels_arches "add"
+    # if $archive is set and $module and $module_version are not,
+    # try loading the tarball passed first.
+    if [[ $archive_location && ! $module && ! $module_version ]]; then
+	load_tarball
+    elif [[ $try_source_tree && ! $module && ! $module_version ]]; then
+	add_source_tree "$try_source_tree"
+    fi
 
     # Check that we have all the arguments
-    if [ -z "$module" ] || [ -z "$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of arguments passed." >&2
-        echo $"Usage: add -m <module> -v <module-version>" >&2
-        exit 1
-    fi
+    check_module_args add
 
-    if [ -z "$conf" ]; then
-        conf="$source_tree/$module-$module_version/dkms.conf"
+    # Check that this module-version hasn't already been added
+    if is_module_added "$module" "$module_version"; then
+	die 3 $"DKMS tree already contains: $module-$module_version" \
+	    $"You cannot add the same module/version combo more than once."
     fi
 
+    [[ $conf ]] || conf="$source_tree/$module-$module_version/dkms.conf"
+
     # Check that /usr/src/$module-$module_version exists
-    if ! [ -d "$source_tree/$module-$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! Could not find module source directory." >&2
-        echo $"Directory: $source_tree/$module-$module_version does not exist." >&2
-        exit 2
+    if ! [[ -d $source_tree/$module-$module_version ]]; then
+	die 2 $"Could not find module source directory." \
+	    $"Directory: $source_tree/$module-$module_version does not exist."
     fi
 
     # Do stuff for --rpm_safe_upgrade
-    if [ -n "$rpm_safe_upgrade" ]; then
-        local pppid=`sed -ne 's/PPid:[ \t]*//p' /proc/$PPID/status`
-        local temp_dir_name=`mktemp $tmp_location/dkms_rpm_safe_upgrade_lock.$pppid.XXXXXX 2>/dev/null`
-        echo "$module-$module_version" >> $temp_dir_name
-        ps -o lstart --no-headers -p $pppid 2>/dev/null >> $temp_dir_name
-    fi
-
-    # Check that this module-version hasn't already been added
-    if [ -d "$dkms_tree/$module/$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! DKMS tree already contains: $module-$module_version" >&2
-        echo $"You cannot add the same module/version combo more than once." >&2
-        exit 3
-    fi
-
-    # Check that the conf file exists or any other script specified
-    if ! [ -e "$conf" ]; then
-        echo $"" >&2
-        echo $"Error! Could not locate dkms.conf file." >&2
-        echo $"File: $conf does not exist." >&2
-        exit 4
+    if [[ $rpm_safe_upgrade ]]; then
+	local pppid=$(awk '/PPid:/ {print $2}' /proc/$PPID/status)
+	local lock_name=$(mktemp_or_die $tmp_location/dkms_rpm_safe_upgrade_lock.$pppid.XXXXXX)
+	echo "$module-$module_version" >> $lock_name
+	ps -o lstart --no-headers -p $pppid 2>/dev/null >> $lock_name
     fi
 
     # Check the conf file for sanity
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}" "$conf"
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"File: $conf" >&2
-        echo $"does not represent a valid dkms.conf file." >&2
-        exit 8
-    fi
+    read_conf_or_die "$kernelver" "$arch" "$conf"
 
     # Create the necessary dkms tree structure
     echo $""
@@ -1029,17 +993,16 @@
     ln -s "$source_tree/$module-$module_version" "$dkms_tree/$module/$module_version/source"
 
     # Run the post_add script
-    if [ -n "$post_add" ] && [ -x `echo "$dkms_tree/$module/$module_version/source/$post_add" | sed 's/ .*//'` ]; then
-        echo $""
-        echo $"Running the post_add script:"
-        $dkms_tree/$module/$module_version/source/$post_add
-    fi
+    run_build_script post_add "$post_add"
 
     echo $""
-    echo $"DKMS: add Completed."
+    echo $"DKMS: add completed."
 }
 
-function prepare_kernel()
+# Prepare a kernel source or include tree for compiling a module.
+# Most modern-ish distros do not require this function at all,
+# so it will be removed in a future release.
+prepare_kernel()
 {
     # $1 = kernel version to prepare
     # $2 = arch to prepare
@@ -1047,33 +1010,27 @@
     set_kernel_source_dir "$1"
 
     # Check that kernel-source exists
-    if ! [ -e "$kernel_source_dir/include" ]; then
-        echo $"" >&2
-        echo $"Error! Your kernel headers for kernel $1 cannot be found at" >&2
-        echo $"/lib/modules/$1/build or /lib/modules/$1/source." >&2
-        echo -n $"You can use the --kernelsourcedir option to tell DKMS where it's located"
-        case "$running_distribution" in
-        Debian* | Ubuntu* )
-            echo $", or you could install the linux-headers-$1 package."
-            ;;
-        * )
-            echo $"."
-            ;;
-        esac
-        exit 1
-    fi
+    _check_kernel_dir "$1" || {
+	case "$running_distribution" in
+	    Debian* | Ubuntu* )
+		die 1 $"Your kernel headers for kernel $1 cannot be found." \
+		    $"Please install the linux-headers-$1 package," \
+		    $"or use the --kernelsourcedir option to tell DKMS where it's located";;
+	    * ) die 1 echo $"Your kernel headers for kernel $1 cannot be found at" \
+		$"/lib/modules/$1/build or /lib/modules/$1/source."
+		$"You can use the --kernelsourcedir option to tell DKMS where it's located."
+	esac
+    }
 
-    if [ -n "$no_prepare_kernel" ]; then
-        return
-    fi
+    [[ $no_prepare_kernel ]] && return
 
-    if [[ (! ( $(VER $1) < $(VER 2.6.5) ) || (-d /etc/SuSEconfig)) && \
+    if [[ (! ( $(VER $1) < $(VER 2.6.5) ) || -d /etc/SuSEconfig) && \
        -d "$kernel_source_dir" && \
        -z "$ksourcedir_fromcli" ]]; then
-        echo $""
-        echo $"Kernel preparation unnecessary for this kernel.  Skipping..."
-        no_clean_kernel="no-clean-kernel"
-        return 1
+	echo $""
+	echo $"Kernel preparation unnecessary for this kernel.  Skipping..."
+	no_clean_kernel="no-clean-kernel"
+	return 1
     fi
 
     # Prepare kernel for module build
@@ -1081,540 +1038,473 @@
     echo $"Preparing kernel $1 for module build:"
     echo $"(This is not compiling a kernel, just preparing kernel symbols)"
     cd $kernel_source_dir
-    config_contents=`cat .config 2>/dev/null`
-    [ -n "$config_contents" ] && echo $"Storing current .config to be restored when complete"
+    [[ -r .config ]] && {
+	config_contents=$(cat .config)
+	echo $"Storing current .config to be restored when complete"
+    }
 
     # Set kernel_config
-    if [ -e /etc/redhat-release ] || [ -e /etc/fedora-release ]; then
-        # Note this also applies to VMware 3.x
-        if [ -z "$kernel_config" ] && [ -d "$kernel_source_dir/configs" ]; then
-            local kernel_trunc=`echo $1 | sed 's/-.*//'`
-            for config_type in debug summit smp enterprise bigmem hugemem BOOT vmnix; do
-                [ `echo "$1" | grep "$config_type"` ] && kernel_config="$kernel_source_dir/configs/kernel-$kernel_trunc-$2-$config_type.config"
-                [ ! -e "$kernel_config" ] && kernel_config=""
-            done
-            [ -z "$kernel_config" ] && kernel_config="$kernel_source_dir/configs/kernel-$kernel_trunc-$2.config"
-            [ ! -e "$kernel_config" ] && kernel_config=""
-        fi
-    elif [ -e /etc/SuSE-release ] || [ -d /etc/SuSEconfig ]; then
-        if [ -z "$kernel_config" ] && [ -d "$kernel_source_dir/arch" ]; then
-            local kernel_trunc=`echo $1 | sed 's/-.*//'`
-            if [ "$2" == "i586" ] || [ "$2" == "i686" ]; then
-                config_arch="i386"
-            else
-                config_arch=$2
-            fi
-            for config_type in default smp bigsmp; do
-                [ `echo "$1" | grep "$config_type"` ] && kernel_config="$kernel_source_dir/arch/$config_arch/defconfig.$config_type"
-                [ ! -e "$kernel_config" ] && kernel_config=""
-            done
-            [ -z "$kernel_config" ] && kernel_config="$kernel_source_dir/arch/$config_arch/defconfig.default"
-            [ ! -e "$kernel_config" ] && kernel_config=""
-        fi
+    if [[ -e /etc/redhat-release || -e /etc/fedora-release ]]; then
+	# Note this also applies to VMware 3.x
+	if [[ -z $kernel_config && -d $kernel_source_dir/configs ]]; then
+	    local kernel_trunc=${1%%-*}
+	    # Try a .config specific to whatever kernel we are running
+	    if [[ $1 =~ $rh_kernels && \
+		-e $kernel_source_dir/configs/kernel-$kernel_trunc-$2-${BASH_REMATCH[1]}.config ]]; then
+		kernel_config="$kernel_source_dir/configs/kernel-$kernel_trunc-$2-${BASH_REMATCH[1]}.config"
+	    elif [[ -e $kernel_source_dir/configs/kernel-$kernel_trunc-$2.config ]]; then
+		# If that one does not exist, try a generic one.
+		kernel_config="$kernel_source_dir/configs/kernel-$kernel_trunc-$2.config"
+	    else
+		# If that does not exist, fall back to no config file
+		kernel_config=""
+	    fi
+	fi
+    elif [[ (-e /etc/SuSE-release || -d /etc/SuSEconfig) && \
+	-z $kernel_config && -d $kernel_source_dir/arch ]]; then
+	    local kernel_trunc=${1%%-*}
+	    case $2 in
+		i586|i686) config_arch="i386";;
+		*) config_arch=$2;;
+	    esac
+	    for config_type in default smp bigsmp; do
+		[[ $1 =~ $config_type ]] && kernel_config="$kernel_source_dir/arch/$config_arch/defconfig.$config_type"
+		[[ -e $kernel_config ]] || kernel_config=""
+	    done
+	    [[ $kernel_config ]] || kernel_config="$kernel_source_dir/arch/$config_arch/defconfig.default"
+	    [[ -e $kernel_config ]] || kernel_config=""
     fi
 
     # Do preparation
     if [ -e /boot/vmlinuz.version.h ]; then
-        echo $"Running UnitedLinux preparation routine"
-        local kernel_config="/boot/vmlinuz.config"
-        invoke_command "make mrproper" "make mrproper" background
-        [ -n "$config_contents" ] && echo "$config_contents" > .config
-        invoke_command "cp /boot/vmlinuz.version.h include/linux/version.h" "using /boot/vmlinux.version.h"
-        invoke_command "cp -f $kernel_config .config" "using $kernel_config"
-        invoke_command "make KERNELRELEASE=$1 cloneconfig" "make cloneconfig" background
-        invoke_command "make CONFIG_MODVERSIONS=1 KERNELRELEASE=$1 dep" "make CONFIG_MODVERSIONS=1 dep" background
+	echo $"Running UnitedLinux preparation routine"
+	local kernel_config="/boot/vmlinuz.config"
+	invoke_command "make mrproper" "make mrproper" background
+	[[ $config_contents ]] && echo "$config_contents" > .config
+	invoke_command "cp /boot/vmlinuz.version.h include/linux/version.h" "using /boot/vmlinux.version.h"
+	invoke_command "cp -f $kernel_config .config" "using $kernel_config"
+	invoke_command "make KERNELRELEASE=$1 cloneconfig" "make cloneconfig" background
+	invoke_command "make CONFIG_MODVERSIONS=1 KERNELRELEASE=$1 dep" "make CONFIG_MODVERSIONS=1 dep" background
     elif grep -q rhconfig.h $kernel_source_dir/include/linux/{modversions,version}.h 2>/dev/null; then
-        echo $"Running Red Hat style preparation routine"
-        invoke_command "make clean" "make clean" background
-        [ -n "$config_contents" ] && echo "$config_contents" > .config
-
-        if [ -n "$kernel_config" ]; then
-            echo $"using $kernel_config"
-            cp -f "$kernel_config" .config
-        elif [ -e .config ]; then
-            echo $"using $kernel_source_dir/.config"
-            echo $"(I hope this is the correct config for this kernel)"
-        else
-            echo $""
-            echo $"Warning! Cannot find a .config file to prepare your kernel with." >&2
-            echo $"Try using the --config option to specify where one can be found." >&2
-            echo $"Your build will likely fail because of this." >&2
-        fi
-
-        # Hack to workaround broken tmp_include_depends for Red Hat
-        if grep -q "/usr/src/build" $kernel_source_dir/tmp_include_depends 2>/dev/null; then
-            sed 's/\/usr\/src\/build\/.*\/install//g' $kernel_source_dir/tmp_include_depends > $kernel_source_dir/tmp_include_depends.new
-            mv -f $kernel_source_dir/tmp_include_depends.new $kernel_source_dir/tmp_include_depends
-        fi
-
-        invoke_command "make KERNELRELEASE=$1 oldconfig" "make oldconfig" background
-        kerneldoth_contents=`cat /boot/kernel.h 2>/dev/null`
-        invoke_command "/usr/lib/dkms/mkkerneldoth --kernelver $1 --targetarch $2 --output /boot/kernel.h" "running mkkerneldoth" background
-    else
-        echo $"Running Generic preparation routine"
-        invoke_command "make mrproper" "make mrproper" background
-        [ -n "$config_contents" ] && echo "$config_contents" > .config
-
-        if [ -n "$kernel_config" ]; then
-            echo $"using $kernel_config"
-            cp -f "$kernel_config" .config
-        elif [ -e .config ]; then
-            echo $"using $kernel_source_dir/.config"
-            echo $"(I hope this is the correct config for this kernel)"
-        else
-            echo $""
-            echo $"Warning! Cannot find a .config file to prepare your kernel with." >&2
-            echo $"Try using the --config option to specify where one can be found." >&2
-            echo $"Your build will likely fail because of this." >&2
-        fi
-
-        invoke_command "make KERNELRELEASE=$1 oldconfig" "make oldconfig" background
-        if [[ $(VER $1) < $(VER 2.5) ]]; then
-            invoke_command "make KERNELRELEASE=$1 dep" "make dep" background
-        else
-            invoke_command "make KERNELRELEASE=$1 prepare-all scripts" "make prepare-all" background
-        fi
+	echo $"Running Red Hat style preparation routine"
+	invoke_command "make clean" "make clean" background
+	[[ $config_contents ]] && echo "$config_contents" > .config
+
+	if [[ $kernel_config ]]; then
+	    echo $"using $kernel_config"
+	    cp -f "$kernel_config" .config
+	elif [[ -e .config ]]; then
+	    warn $"Using $kernel_source_dir/.config" \
+		$"(I hope this is the correct config for this kernel)"
+	else
+	    warn $"Cannot find a .config file to prepare your kernel with." \
+		$"Try using the --config option to specify where one can be found." \
+		$"Your build will likely fail because of this."
+	fi
+
+	# Hack to workaround broken tmp_include_depends for Red Hat
+	if grep -q "/usr/src/build" $kernel_source_dir/tmp_include_depends 2>/dev/null; then
+	    sed 's/\/usr\/src\/build\/.*\/install//g' $kernel_source_dir/tmp_include_depends > $kernel_source_dir/tmp_include_depends.new
+	    mv -f $kernel_source_dir/tmp_include_depends.new $kernel_source_dir/tmp_include_depends
+	fi
+
+	invoke_command "make KERNELRELEASE=$1 oldconfig" "make oldconfig" background
+	kerneldoth_contents=$(cat /boot/kernel.h 2>/dev/null)
+	invoke_command "/usr/lib/dkms/mkkerneldoth --kernelver $1 --targetarch $2 --output /boot/kernel.h" "running mkkerneldoth" background
+    else
+	echo $"Running Generic preparation routine"
+	invoke_command "make mrproper" "make mrproper" background
+	[[ $config_contents ]] && echo "$config_contents" > .config
+
+	if [[ $kernel_config ]]; then
+	    echo $"using $kernel_config"
+	    cp -f "$kernel_config" .config
+	elif [[ -e .config ]]; then
+	    warn $"using $kernel_source_dir/.config" \
+		$"(I hope this is the correct config for this kernel)"
+	else
+	    warn $"Warning! Cannot find a .config file to prepare your kernel with." \
+		$"Try using the --config option to specify where one can be found." \
+		$"Your build will likely fail because of this."
+	fi
+
+	invoke_command "make KERNELRELEASE=$1 oldconfig" "make oldconfig" background
+	if [[ $(VER $1) < $(VER 2.5) ]]; then
+	    invoke_command "make KERNELRELEASE=$1 dep" "make dep" background
+	else
+	    invoke_command "make KERNELRELEASE=$1 prepare-all scripts" "make prepare-all" background
+	fi
     fi
     cd - >/dev/null
 }
 
-function list_each_installed_module ()
+# Get ready to build a module that has been registered with DKMS.
+prepare_build()
 {
-    # $1 = module
-    # $2 = kernel version
-    # $3 = arch
-    local count=0
-    local real_dest_module_location
-    while [ "$count" -lt "${#built_module_name[@]}" ]; do
-        real_dest_module_location="$(find_actual_dest_module_location $1 $count $2 $3)"
-        echo "$install_tree/$2${real_dest_module_location}/${dest_module_name[$count]}$module_suffix"
-        count=$(($count + 1))
-    done
-}
-
-function set_weak_modules()
-{
-    [ -n "${weak_modules}" ] && return
-    [ -x /sbin/weak-modules ] && weak_modules='/sbin/weak-modules'
-    [ -x /usr/lib/module-init-tools/weak-modules ] && weak_modules='/usr/lib/module-init-tools/weak-modules'
-}
-
-function install_module()
-{
-    setup_kernels_arches "install"
-    local base_dir="$dkms_tree/$module/$module_version/${kernelver_array[0]}/${arch_array[0]}"
-
-    # Check that the right arguments were passed
-    if [ -z "$module" ] || [ -z "$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed." >&2
-        echo $"Usage: install -m <module> -v <module-version>" >&2
-        exit 1
-    fi
-
-    # Check that $module-$module_version exists by checking the source symlink
-    if ! [ -d "$dkms_tree/$module/$module_version/source" ]; then
-        echo $"" >&2
-        echo $"Error! DKMS tree does not contain: $module-$module_version" >&2
-        echo $"Build cannot continue without the proper tree." >&2
-        exit 2
-    fi
-
-    # Make sure that kernel exists to install into
-    if ! [ -e "$install_tree/${kernelver_array[0]}" ]; then
-        echo $"" >&2
-        echo $"Error! The directory $install_tree/${kernelver_array[0]} doesn't exist." >&2
-        echo $"You cannot install a module onto a non-existant kernel." >&2
-        exit 6
-    fi
-
-    # Read the conf file
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}"
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"Your dkms.conf is not valid." >&2
-        exit 3
-    fi
-
-    # Make sure the $module_name_after exists
-    set_module_suffix "${kernelver_array[0]}"
-    for module_name_after in "${dest_module_name[@]}"; do
-        if ! [ -e "$base_dir/module/$module_name_after$module_suffix" ]; then
-            echo $"" >&2
-            echo $"Error! Could not locate $module_name_after$module_suffix for module $module in the DKMS tree." >&2
-            echo $"You must run a dkms build for kernel ${kernelver_array[0]} (${arch_array[0]}) first." >&2
-            exit 4
-        fi
-    done
+    # If the module has not been added, try to add it.
+    is_module_added "$module" "$module_version" || add_module
 
-    # Check that its not already installed (kernel symlink)
-    readlink "$dkms_tree/$module/kernel-${kernelver_array[0]}-${arch_array[0]}"
-    kernel_symlink="$read_link"
-    if [ "$kernel_symlink" == "$module_version/${kernelver_array[0]}/${arch_array[0]}" ]; then
-        echo $"" >&2
-        echo $"Error! This module/version combo is already installed" >&2
-        echo $"for kernel: ${kernelver_array[0]} (${arch_array[0]})" >&2
-        exit 5
-    fi
-
-    # if upgrading using rpm_safe_upgrade, go ahead and force the install
-    # else we can wind up with the first half of an upgrade failing to install anything,
-    # while the second half of the upgrade, the removal, then succeeds, leaving us with
-    # nothing installed.
-    if [ -n "$rpm_safe_upgrade" ]; then
-        force="true"
-    fi
-
-    # Save the original_module if one exists, none have been saved before, and this is the first module for this kernel
-    local lib_tree="$install_tree/${kernelver_array[0]}"
-    local count=0
-    while [ "$count" -lt ${#built_module_name[@]} ]; do
-        echo $""
-        echo $"${dest_module_name[$count]}$module_suffix:"
-        # Check this version against what is already in the kernel
-        if ! check_version_sanity "${kernelver_array[0]}" "${arch_array[0]}" "$obsolete_by" "${dest_module_name[$count]}"; then
-            count=$(($count + 1))
-            continue
-        fi
-
-        if [ "$count" -eq 0 ]; then
-            # Run the pre_install script
-            if [ -n "$pre_install" ] && [ -x `echo "$dkms_tree/$module/$module_version/source/$pre_install" | sed 's/ .*//'` ]; then
-                echo $""
-                echo $"Running the pre_install script:"
-                $dkms_tree/$module/$module_version/source/$pre_install
-                if [ "$?" -ne 0 -a -z "$force" ]; then
-                    echo $"pre_install failed, aborting install." >&2
-                    echo $"You may override by specifying --force." >&2
-                    exit 101
-                fi
-            fi
-        fi
-        local module_count=`find $lib_tree -name ${dest_module_name[$count]}$module_suffix -type f | wc -l | awk {'print $1'}`
-        echo $" - Original module"
-        if ! [ -L "$dkms_tree/$module/kernel-${kernelver_array[0]}-${arch_array[0]}" ]; then
-            local archive_pref1="$lib_tree/extra/${dest_module_name[$count]}$module_suffix"
-            local archive_pref2="$lib_tree/updates/${dest_module_name[$count]}$module_suffix"
-            local archive_pref3="$lib_tree${dest_module_location[$count]}/${dest_module_name[$count]}$module_suffix"
-            local archive_pref4=""
-            [ "$module_count" -eq 1 ] && archive_pref4="`find $lib_tree -name ${dest_module_name[$count]}$module_suffix -type f`"
-            local original_module=""
-            local found_orginal=""
-            for original_module in $archive_pref1 $archive_pref2 $archive_pref3 $archive_pref4; do
-                if [ -f "$original_module" ]; then
-                    case "$running_distribution" in
-                        Debian* | Ubuntu* ) ;;
-                        *)
-                            echo $"   - Found $original_module"
-                            echo $"   - Storing in $dkms_tree/$module/original_module/${kernelver_array[0]}/${arch_array[0]}/"
-                            echo $"   - Archiving for uninstallation purposes"
-                            mkdir -p "$dkms_tree/$module/original_module/${kernelver_array[0]}/${arch_array[0]}"
-                            mv -f "$original_module" "$dkms_tree/$module/original_module/${kernelver_array[0]}/${arch_array[0]}/"
-                            ;;
-                    esac
-                    found_original="yes"
-                    break
-                fi
-            done
-            if [ -z "$found_original" ] && [ "$module_count" -gt 1 ]; then
-                echo $"   - Multiple original modules exist but DKMS does not know which to pick"
-                echo $"   - Due to the confusion, none will be considered during a later uninstall"
-            elif [ -z "$found_original" ]; then
-                echo $"   - No original module exists within this kernel"
-            fi
-        elif [ -L "$dkms_tree/$module/kernel-${kernelver_array[0]}-${arch_array[0]}" ] && [ -e "$dkms_tree/$module/original_module/${kernelver_array[0]}/${arch_array[0]}/${dest_module_name[$count]}$module_suffix" ]; then
-            echo $"   - An original module was already stored during a previous install"
-        else
-            echo $"   - This kernel never originally had a module by this name"
-        fi
-
-        if [ "$module_count" -gt 1 ]; then
-            echo $" - Multiple same named modules!"
-            echo $"   - $module_count named ${dest_module_name[$count]}$module_suffix in $lib_tree/"
-            case "$running_distribution" in
-            Debian* | Ubuntu* ) ;;
-            *)
-                echo $"   - All instances of this module will now be stored for reference purposes ONLY"
-                echo $"   - Storing in $dkms_tree/$module/original_module/${kernelver_array[0]}/${arch_array[0]}/collisions/"
-                ;;
-            esac
-            for module_dup in `find $lib_tree -name ${dest_module_name[$count]}$module_suffix -type f`; do
-                dup_tree=`echo $module_dup | sed "s#^$lib_tree##" | sed "s#${dest_module_name[$count]}$module_suffix##"`
-                case "$running_distribution" in
-                Debian* | Ubuntu* ) ;;
-                *)
-                   echo $"     - Stored $module_dup"
-                   mkdir -p "$dkms_tree/$module/original_module/${kernelver_array[0]}/${arch_array[0]}/collisions/$dup_tree"
-                   mv -f $module_dup "$dkms_tree/$module/original_module/${kernelver_array[0]}/${arch_array[0]}/collisions/$dup_tree"
-                   ;;
-                esac
-            done
-        fi
-
-        # Copy module to its location
-        echo $" - Installation"
-        echo $"   - Installing to $install_tree/${kernelver_array[0]}${dest_module_location[$count]}/"
-        mkdir -p $install_tree/${kernelver_array[0]}${dest_module_location[$count]}
-        cp -f "$base_dir/module/${dest_module_name[$count]}$module_suffix" "$install_tree/${kernelver_array[0]}${dest_module_location[$count]}/${dest_module_name[$count]}$module_suffix"
-
-        count=$(($count + 1))
-    done
-
-    # Create the kernel-<kernelver> symlink to designate this version as active
-    rm -f "$dkms_tree/$module/kernel-${kernelver_array[0]}-${arch_array[0]}" 2>/dev/null
-    ln -s "$module_version/${kernelver_array[0]}/${arch_array[0]}" "$dkms_tree/$module/kernel-${kernelver_array[0]}-${arch_array[0]}" 2>/dev/null
-
-    # add to kabi-tracking
-    set_weak_modules
-    if [ -n "${weak_modules}" ]; then
-        echo $"Adding any weak-modules"
-        list_each_installed_module "$module" "${kernelver_array[0]}" "${arch_array[0]}" | ${weak_modules} --add-modules
-    fi
-
-    # Run the post_install script
-    if [ -n "$post_install" ] && [ -x `echo "$dkms_tree/$module/$module_version/source/$post_install" | sed 's/ .*//'` ]; then
-        echo $""
-        echo $"Running post_install:"
-        $dkms_tree/$module/$module_version/source/$post_install
-    fi
-
-    # Make modules.conf changes as necessary
-    echo $""
-    moduleconfig_add "${kernelver_array[0]}"
-    etc_sysconfig_kernel_modify "add"
-
-    invoke_command "do_depmod ${kernelver_array[0]}" "depmod" background
-    if [ "$?" -ne 0 ]; then
-        local unresolved_symbols="$(do_depmod ${kernelver_array[0]} 2>&1)"
-        local count=0
-        while [ "$count" -lt "${#built_module_name[@]}" ]; do
-            if echo "$unresolved_symbols" | grep -q "${dest_module_name[$count]}$module_suffix$"; then
-                echo $""
-                echo $"Problems with depmod detected.  Automatically uninstalling this module."
-                sleep 2
-                do_uninstall "${kernelver_array[0]}" "${arch_array[0]}"
-                echo $""
-                echo $"DKMS: Install Failed (depmod problems).  Module rolled back to built state."
-                exit 6
-            fi
-            count=$(($count + 1))
-        done
-    fi
-
-    # Do remake_initrd things (save old initrd)
-    if [ -n "$remake_initrd" ]; then
-        remake_initrd "${kernelver_array[0]}" "${arch_array[0]}"
-        if [ "$?" -ne 0 ]; then
-            echo $"Problems with mkinitrd detected.  Automatically uninstalling this module."
-            sleep 2
-            do_uninstall "${kernelver_array[0]}" "${arch_array[0]}"
-            echo $""
-            echo $"DKMS: Install Failed (mkinitrd problems).  Module rolled back to built state."
-            exit 7
-        fi
-    fi
-
-    echo $""
-    echo $"DKMS: install Completed."
-}
-
-
-function prepare_build()
-{
-    setup_kernels_arches "build"
-    set_kernel_source_dir "${kernelver_array[0]}"
-    local base_dir="$dkms_tree/$module/$module_version/${kernelver_array[0]}/${arch_array[0]}"
+    set_kernel_source_dir "$kernelver"
+    local base_dir="$dkms_tree/$module/$module_version/$kernelver/$arch"
 
     # Check that the right arguments were passed
-    if [ -z "$module" ] || [ -z "$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed." >&2
-        echo $"Usage: build -m <module> -v <module-version>" >&2
-        exit 1
-    fi
-
-    # Check that source symlink works
-    if ! [ -d "$dkms_tree/$module/$module_version/source" ]; then
-        echo $"" >&2
-        echo $"Error! DKMS tree does not contain: $module-$module_version" >&2
-        echo $"Build cannot continue without the proper tree." >&2
-        exit 2
-    fi
+    check_module_args build
 
     # Check that the module has not already been built for this kernel
-    if [ -d "$base_dir" ]; then
-        echo $"" >&2
-        echo $"Error! This module/version has already been built on: ${kernelver_array[0]}" >&2
-        echo $"Directory: $base_dir" >&2
-        echo $"already exists.  Use the dkms remove function before trying to build again." >&2
-        exit 3
-    fi
+    [[ -d $base_dir ]] && die 3 \
+	$"This module/version has already been built on: $kernelver" \
+	$"Directory: $base_dir" \
+	$"already exists.  Use the dkms remove function before trying to build again."
 
     # Read the conf file
-    set_module_suffix "${kernelver_array[0]}"
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}"
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"Your dkms.conf is not valid." >&2
-        exit 4
-    fi
+    set_module_suffix "$kernelver"
+    read_conf_or_die "$kernelver" "$arch"
 
     # Error out if build_exclude is set
-    if [ -n "$build_exclude" ]; then
-        echo "" >&2
-        echo "Error!  The dkms.conf for this module includes a BUILD_EXCLUSIVE directive which" >&2
-        echo "does not match this kernel/arch.  This indicates that it should not be built." >&2
-        exit 9
-    fi
+    [[ $build_exclude ]] && die 9 \
+	$" The dkms.conf for this module includes a BUILD_EXCLUSIVE directive which" \
+	$"does not match this kernel/arch.  This indicates that it should not be built."
 
     # Error out if source_tree is basically empty (binary-only dkms tarball w/ --force check)
-    if [ `ls $dkms_tree/$module/$module_version/source | wc -l | awk {'print $1'}` -lt 2 ]; then
-        echo "" >&2
-        echo $"Error! The directory $dkms_tree/$module/$module_version/source/" >&2
-        echo $"does not appear to have module source located within it.  Build halted." >&2
-        exit 8
-    fi
+    (($(ls $dkms_tree/$module/$module_version/source | wc -l | awk {'print $1'}) < 2)) && die 8 \
+	$"The directory $dkms_tree/$module/$module_version/source/" \
+	$"does not appear to have module source located within it.  Build halted."
 
-    prepare_kernel "${kernelver_array[0]}" "${arch_array[0]}"
+    prepare_kernel "$kernelver" "$arch"
 
     # Set up temporary build directory for build
     rm -rf "$dkms_tree/$module/$module_version/build"
     cp -rf "$dkms_tree/$module/$module_version/source/" "$dkms_tree/$module/$module_version/build"
 
-    # Run the pre_build script
-    if [ -n "$pre_build" ] && [ -x `echo "$dkms_tree/$module/$module_version/source/$pre_build" | sed 's/ .*//'` ]; then
-        echo $""
-        echo $"Running the pre_build script:"
-        $dkms_tree/$module/$module_version/source/$pre_build
-    fi
-
     cd "$dkms_tree/$module/$module_version/build"
 
     # Apply any patches
-    local index=0
-    while [ $index -lt ${#patch_array[@]} ]; do
-        if ! [ -e "$dkms_tree/$module/$module_version/build/patches/${patch_array[$index]}" ]; then
-            echo $"" >&2
-            echo $"Error!  Patch ${patch_array[$index]} as specified in dkms.conf cannot be" >&2
-            echo $"found in $dkms_tree/$module/$module_version/build/patches/." >&2
-            exit 5
-        fi
-        invoke_command "patch -p1 < ./patches/${patch_array[$index]}" "applying patch ${patch_array[$index]}"
-        if [ "$?" -ne 0 ]; then
-            echo $"" >&2
-            echo $"Error! Application of patch ${patch_array[$index]} failed." >&2
-            echo $"Check $dkms_tree/$module/$module_version/build/ for more information." >&2
-                report_build_problem
-            exit 6
-        fi
-        index=$(($index+1))
+    for p in "${patch_array[@]}"; do
+	[[ ! -e $dkms_tree/$module/$module_version/build/patches/$p ]] && \
+	    report_build_problem 5 \
+	    $" Patch $p as specified in dkms.conf cannot be" \
+	    $"found in $dkms_tree/$module/$module_version/build/patches/."
+	invoke_command "patch -p1 < ./patches/$p" "applying patch $p" || \
+	    report_build_problem 6 $"Application of patch $p failed." \
+	    $"Check $dkms_tree/$module/$module_version/build/ for more information."
     done
+
+    # Run the pre_build script
+    run_build_script pre_build "$pre_build"
 }
 
-function do_build()
+# Build our previously prepared source tree.  prepare_build must be called
+# before calling this function.
+do_build()
 {
-    local base_dir="$dkms_tree/$module/$module_version/${kernelver_array[0]}/${arch_array[0]}"
+    local base_dir="$dkms_tree/$module/$module_version/$kernelver/$arch"
     echo $""
     echo $"Building module:"
 
     invoke_command "$clean" "cleaning build area" background
-    echo $"DKMS make.log for $module-$module_version for kernel ${kernelver_array[0]} (${arch_array[0]})" >> "$dkms_tree/$module/$module_version/build/make.log"
-    echo $"`date`" >> "$dkms_tree/$module/$module_version/build/make.log"
-    local the_make_command=`echo $make_command | sed "s/^make/make KERNELRELEASE=${kernelver_array[0]}/"`
-
-    invoke_command "$the_make_command >> $dkms_tree/$module/$module_version/build/make.log 2>&1" "$the_make_command" background
-
-    # Make sure good return status
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad return status for module build on kernel: ${kernelver_array[0]} (${arch_array[0]})" >&2
-        echo $"Consult the make.log in the build directory" >&2
-        echo $"$dkms_tree/$module/$module_version/build/ for more information." >&2
-        if grep -ic "gcc: Command not found" "$dkms_tree/$module/$module_version/build/make.log"; then
-            echo $"" >&2
-            echo $"DO YOU HAVE gcc INSTALLED???" >&2
-        fi
-        if grep -ic "make: command not found" "$dkms_tree/$module/$module_version/build/make.log"; then
-            echo $"" >&2
-            echo $"DO YOU HAVE make INSTALLED???" >&2
-        fi
-        report_build_problem
-        exit 10
-    fi
+    echo $"DKMS make.log for $module-$module_version for kernel $kernelver ($arch)" >> "$dkms_tree/$module/$module_version/build/make.log"
+    date >> "$dkms_tree/$module/$module_version/build/make.log"
+    local the_make_command="${make_command/#make/make KERNELRELEASE=$kernelver}"
+
+    invoke_command "{ $the_make_command; } >> $dkms_tree/$module/$module_version/build/make.log 2>&1" "$the_make_command" background || \
+	report_build_problem 10 $"Bad return status for module build on kernel: $kernelver ($arch)" \
+	$"Consult $dkms_tree/$module/$module_version/build/make.log for more information."
 
     # Make sure all the modules built successfully
-    local count=0
-    while [ "$count" -lt "${#built_module_name[@]}" ]; do
-        if ! [ -e "${built_module_location[$count]}${built_module_name[$count]}$module_suffix" ]; then
-            echo $"" >&2
-            echo $"Error!  Build of ${built_module_name[$count]}$module_suffix failed for: ${kernelver_array[0]} (${arch_array[0]})" >&2
-            echo $"Consult the make.log in the build directory" >&2
-            echo $"$dkms_tree/$module/$module_version/build/ for more information." >&2
-            report_build_problem
-            exit 7
-        fi
-        count=$(($count+1))
+    for ((count=0; count < ${#built_module_name[@]}; count++)); do
+	[[ -e ${built_module_location[$count]}${built_module_name[$count]}$module_suffix ]] && continue
+	report_build_problem 7 \
+	    $" Build of ${built_module_name[$count]}$module_suffix failed for: $kernelver ($arch)" \
+	    $"Consult the make.log in the build directory" \
+	    $"$dkms_tree/$module/$module_version/build/ for more information."
     done
     cd - >/dev/null
 
     # Build success, so create DKMS structure for a built module
     mkdir -p "$base_dir/log"
-    [ -n "$kernel_config" ] && cp -f "$kernel_config" "$base_dir/log/"
+    [[ $kernel_config ]] && cp -f "$kernel_config" "$base_dir/log/"
     mv -f "$dkms_tree/$module/$module_version/build/make.log" "$base_dir/log/make.log" 2>/dev/null
 
     # Save a copy of the new module
     mkdir "$base_dir/module" >/dev/null
-    local count=0
-    while [ "$count" -lt "${#built_module_name[@]}" ]; do
-        [ "${strip[$count]}" != "no" ] && strip -g "$dkms_tree/$module/$module_version/build/${built_module_location[$count]}${built_module_name[$count]}$module_suffix"
-        cp -f "$dkms_tree/$module/$module_version/build/${built_module_location[$count]}${built_module_name[$count]}$module_suffix" "$base_dir/module/${dest_module_name[$count]}$module_suffix" >/dev/null
-        count=$(($count+1))
+    for ((count=0; count < ${#built_module_name[@]}; count++)); do
+	[[ ${strip[$count]} != no ]] && strip -g "$dkms_tree/$module/$module_version/build/${built_module_location[$count]}${built_module_name[$count]}$module_suffix"
+	cp -f "$dkms_tree/$module/$module_version/build/${built_module_location[$count]}${built_module_name[$count]}$module_suffix" "$base_dir/module/${dest_module_name[$count]}$module_suffix" >/dev/null
     done
 
     # Run the post_build script
-    if [ -n "$post_build" ] && [ -x `echo "$dkms_tree/$module/$module_version/source/$post_build" | sed 's/ .*//'` ]; then
-        echo $""
-        echo $"Running the post_build script:"
-        $dkms_tree/$module/$module_version/source/$post_build
-    fi
+    run_build_script post_build "$post_build"
 }
 
-function clean_build()
+# Clean up after a build.
+clean_build()
 {
     # Run the clean commands
     cd "$dkms_tree/$module/$module_version/build"
     invoke_command "$clean" "cleaning build area" background
     cd - >/dev/null
 
-    if [[ ! ( $(VER ${kernelver_array[0]}) < $(VER 2.6.6) ) && \
-       -d "$kernel_source_dir" && \
-       ! -h "$kernel_source_dir" && \
-       -z "$ksourcedir_fromcli" ]]; then
-        echo $"Kernel cleanup unnecessary for this kernel.  Skipping..."
-    elif [ -z "$no_clean_kernel" ]; then
-        cd "$kernel_source_dir"
-        [ -z "$kerneldoth_contents" ] && invoke_command "make mrproper" "cleaning kernel tree (make mrproper)" background
-        [ -n "$config_contents" ] && echo "$config_contents" > .config
-        [ -n "$kerneldoth_contents" ] && echo "$kerneldoth_contents" > /boot/kernel.h
-        cd - >/dev/null
+    if [[ ! ( $(VER $kernelver) < $(VER 2.6.6) ) && \
+       -d $kernel_source_dir && \
+       ! -h $kernel_source_dir && \
+       ! $ksourcedir_fromcli ]]; then
+	echo $"Kernel cleanup unnecessary for this kernel.  Skipping..."
+    elif [[ ! $no_clean_kernel ]]; then
+	cd "$kernel_source_dir"
+	[[ $kerneldoth_contents ]] || invoke_command "make mrproper" "cleaning kernel tree (make mrproper)" background
+	[[ $config_contents ]] || echo "$config_contents" > .config
+	[[ $kerneldoth_contents ]] && echo "$kerneldoth_contents" > /boot/kernel.h
+	cd - >/dev/null
     fi
 
     # Clean the build directory
     rm -rf "$dkms_tree/$module/$module_version/build/*"
 }
 
-function build_module()
+build_module()
 {
     prepare_build
     do_build
     clean_build
     echo $""
-    echo $"DKMS: build Completed."
+    echo $"DKMS: build completed."
 }
 
-function possible_dest_module_locations()
+# Install a previously built module
+# There are huge swaths of code here that special-case for various distros.
+# They should be split into their own functions.
+install_module()
+{
+    # If the module has not been built, try to build it first.
+    is_module_built "$module" "$module_version" "$kernelver" "$arch" || build_module
+    local base_dir="$dkms_tree/$module/$module_version/$kernelver/$arch"
+    check_module_args install
+
+    # Make sure that kernel exists to install into
+    [[ -e $install_tree/$kernelver ]] || die 6 \
+	$"The directory $install_tree/$kernelver doesn't exist." \
+	$"You cannot install a module onto a non-existant kernel."
+
+    # Read the conf file
+    read_conf_or_die "$kernelver" "$arch"
+
+    # Check that its not already installed (kernel symlink)
+    is_module_installed "$module" "$module_version" "$kernelver" "$arch" && die 5 \
+	$"This module/version combo is already installed" \
+	$"for kernel: $kernelver ($arch)"
+
+    # if upgrading using rpm_safe_upgrade, go ahead and force the install
+    # else we can wind up with the first half of an upgrade failing to install anything,
+    # while the second half of the upgrade, the removal, then succeeds, leaving us with
+    # nothing installed.
+    [[ $rpm_safe_upgrade ]] && force="true"
+
+    # Save the original_module if one exists, none have been saved before, and this is the first module for this kernel
+    local lib_tree="$install_tree/$kernelver"
+    local count
+    for ((count=0; count < ${#built_module_name[@]}; count++)); do
+	echo $""
+	echo $"${dest_module_name[$count]}$module_suffix:"
+	# Check this version against what is already in the kernel
+	check_version_sanity "$kernelver" "$arch" \
+	    "$obsolete_by" "${dest_module_name[$count]}" || continue
+
+	if ((count == 0)) && ! run_build_script pre_install "$pre_install" && \
+	    ! [[ $force ]]; then
+	    die 101 $"pre_install failed, aborting install." \
+		$"You may override by specifying --force."
+	fi
+	local module_count=$(find $lib_tree -name ${dest_module_name[$count]}$module_suffix -type f | wc -l | awk {'print $1'})
+	echo $" - Original module"
+	if [[ -L $dkms_tree/$module/kernel-$kernelver-$arch && \
+	    -e $dkms_tree/$module/original_module/$kernelver/$arch/${dest_module_name[$count]}$module_suffix ]]; then
+	    echo $"   - An original module was already stored during a previous install"
+	elif ! [[ -L $dkms_tree/$module/kernel-$kernelver-$arch ]]; then
+	    local archive_pref1="$lib_tree/extra/${dest_module_name[$count]}$module_suffix"
+	    local archive_pref2="$lib_tree/updates/${dest_module_name[$count]}$module_suffix"
+	    local archive_pref3="$lib_tree${dest_module_location[$count]}/${dest_module_name[$count]}$module_suffix"
+	    local archive_pref4=""
+	    ((module_count == 1)) && archive_pref4=$(find $lib_tree -name ${dest_module_name[$count]}$module_suffix -type f)
+	    local original_module=""
+	    local found_orginal=""
+	    for original_module in $archive_pref1 $archive_pref2 $archive_pref3 $archive_pref4; do
+		[[ -f $original_module ]] || continue
+		case "$running_distribution" in
+		    Debian* | Ubuntu* ) ;;
+		    *)
+			echo $"   - Found $original_module"
+			echo $"   - Storing in $dkms_tree/$module/original_module/$kernelver/$arch/"
+			echo $"   - Archiving for uninstallation purposes"
+			mkdir -p "$dkms_tree/$module/original_module/$kernelver/$arch"
+			mv -f "$original_module" "$dkms_tree/$module/original_module/$kernelver/$arch/"
+			;;
+		esac
+		found_original="yes"
+		break
+	    done
+	    if [[ ! $found_original ]] && ((module_count > 1)); then
+		echo $"   - Multiple original modules exist but DKMS does not know which to pick"
+		echo $"   - Due to the confusion, none will be considered during a later uninstall"
+	    elif [[ ! $found_original ]]; then
+		echo $"   - No original module exists within this kernel"
+	    fi
+	else
+	    echo $"   - This kernel never originally had a module by this name"
+	fi
+
+	if ((module_count > 1)); then
+	    echo $" - Multiple same named modules!"
+	    echo $"   - $module_count named ${dest_module_name[$count]}$module_suffix in $lib_tree/"
+	    case "$running_distribution" in
+		Debian* | Ubuntu* ) ;;
+		*)
+		    echo $"   - All instances of this module will now be stored for reference purposes ONLY"
+		    echo $"   - Storing in $dkms_tree/$module/original_module/$kernelver/$arch/collisions/"
+		    ;;
+	    esac
+	    for module_dup in $(find $lib_tree -name ${dest_module_name[$count]}$module_suffix -type f); do
+		dup_tree="${module_dup#$lib_tree}";
+		dup_tree="${dup_tree/${dest_module_name[$count]}$module_suffix}"
+		case "$running_distribution" in
+		Debian* | Ubuntu* ) ;;
+		*)
+		   echo $"     - Stored $module_dup"
+		   mkdir -p "$dkms_tree/$module/original_module/$kernelver/$arch/collisions/$dup_tree"
+		   mv -f $module_dup "$dkms_tree/$module/original_module/$kernelver/$arch/collisions/$dup_tree"
+		   ;;
+		esac
+	    done
+	fi
+
+	# Copy module to its location
+	echo $" - Installation"
+	echo $"   - Installing to $install_tree/$kernelver${dest_module_location[$count]}/"
+	mkdir -p $install_tree/$kernelver${dest_module_location[$count]}
+	cp -f "$base_dir/module/${dest_module_name[$count]}$module_suffix" "$install_tree/$kernelver${dest_module_location[$count]}/${dest_module_name[$count]}$module_suffix"
+
+    done
+
+    # Create the kernel-<kernelver> symlink to designate this version as active
+    rm -f "$dkms_tree/$module/kernel-$kernelver-$arch" 2>/dev/null
+    ln -s "$module_version/$kernelver/$arch" "$dkms_tree/$module/kernel-$kernelver-$arch" 2>/dev/null
+
+    # add to kabi-tracking
+    if [[ ${weak_modules} ]]; then
+	echo $"Adding any weak-modules"
+	list_each_installed_module "$module" "$kernelver" "$arch" | ${weak_modules} --add-modules
+    fi
+
+    # Run the post_install script
+    run_build_script post_install "$post_install"
+
+    # Make modules.conf changes as necessary
+    echo $""
+    moduleconfig_add "$kernelver"
+    etc_sysconfig_kernel_modify "add"
+
+    invoke_command "do_depmod $kernelver" "depmod" background || {
+	do_uninstall "$kernelver" "$arch"
+	die 6 $"Problems with depmod detected.  Automatically uninstalling this module." \
+	    $"DKMS: Install Failed (depmod problems).  Module rolled back to built state."
+	    exit 6
+    }
+
+    # Do remake_initrd things (save old initrd)
+    [[ $remake_initrd ]] && ! make_initrd "$kernelver" "$arch" && {
+	do_uninstall "$kernelver" "$arch"
+	die 7 $"Problems with mkinitrd detected.  Automatically uninstalling this module." \
+	    $"DKMS: Install Failed (mkinitrd problems).  Module rolled back to built state."
+    }
+    echo $""
+    echo $"DKMS: install completed."
+}
+
+# List each kernel object that has been installed for a particular module.
+list_each_installed_module()
+{
+    # $1 = module
+    # $2 = kernel version
+    # $3 = arch
+    local count
+    local real_dest_module_location
+    for ((count=0; count < ${#built_module_name[@]}; count++)); do
+	real_dest_module_location="$(find_actual_dest_module_location $1 $count $2 $3)"
+	echo "$install_tree/$2${real_dest_module_location}/${dest_module_name[$count]}$module_suffix"
+    done
+}
+
+is_module_added() {
+    [[ $1 && $2 ]] || return 1
+    [[ -d $dkms_tree/$1/$2 ]] || return 2
+    [[ -L $dkms_tree/$1/$2/source || -d $dkms_tree/$1/$2/source ]];
+}
+
+is_module_built() {
+    [[ $1 && $2 && $3 && $4 ]] || return 1
+    local d="$dkms_tree/$1/$2/$3/$4" m=''
+    [[ -d $d/module ]] || return 1
+    read_conf_or_die "$3" "$4" "$dkms_tree/$1/$2/source/dkms.conf"
+    for m in "${dest_module_name[@]}"; do
+	[[ -f $d/module/$m.ko || -f $d/module/$m.o ]] || return 1
+    done
+}
+
+# This assumes we have already checked to see if the module has been built.
+_is_module_installed() {
+    [[ $1 && $2 && $3 && $4 ]] || return 1
+    local d="$dkms_tree/$1/$2/$3/$4"
+    local k="$dkms_tree/$1/kernel-$3-$4"
+    [[ -L $k && $(readlink -f $k) = $d ]]
+}
+
+# This does not.
+is_module_installed() { is_module_built "$@" && _is_module_installed "$@"; }
+
+maybe_add_module() (
+    is_module_added "$1" "$2" && {
+	echo $"Module $1/$2 already added."
+	return 0
+    }
+    module="$1" module_version="$2" add_module
+)
+
+maybe_build_module() (
+    is_module_built "$1" "$2" "$3" "$4" && {
+	echo $"Module $1/$2 already built for kernel $3/4"
+	return 0
+    }
+    module="$1" module_version="$2" kernelver="$3" arch="$4" build_module
+)
+
+maybe_install_module() (
+    is_module_installed "$1" "$2" "$3" "$4" && {
+	echo $"Module $1/$2 already installed on kernel $3/$4"
+	return 0
+    }
+    module="$1" module_version="$2" kernelver="$3" arch="$4" install_module
+)
+
+build_modules() {
+    local i=0
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+	maybe_build_module "$module" "$module_version" "${kernelver[$i]}" "${arch[$i]}"
+    done
+}
+
+install_modules() {
+    local i=0
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+	maybe_install_module "$module" "$module_version" "${kernelver[$i]}" "${arch[$i]}"
+    done
+}
+
+check_module_exists() {
+    is_module_added "$module" "$module_version" && return
+    die 2 $"DKMS tree does not contain: $module-$module_version" \
+	$"Build cannot continue without the proper tree."
+}
+
+possible_dest_module_locations()
 {
     # $1 = count
     # There are two places an installed module may really be:
@@ -1624,13 +1514,13 @@
 
     local location
     location[0]="${dest_module_location[$count]}"
-    [ "${DEST_MODULE_LOCATION[$count]}" != "${dest_module_location[$count]}" ] && \
+    [[ ${DEST_MODULE_LOCATION[$count]} != ${dest_module_location[$count]} ]] && \
     location[1]="${DEST_MODULE_LOCATION[$count]}"
 
-    echo "${location[0]} ${location[1]}"
+    echo "${location[@]}"
 }
 
-function find_actual_dest_module_location()
+find_actual_dest_module_location()
 {
     local module="$1"
     local count="$2"
@@ -1643,16 +1533,17 @@
     dkms_owned="${dkms_tree}/${module}/kernel-${kernelver}-${arch}/module/${dest_module_name[$count]}${module_suffix}"
 
     for l in $locations; do
-        installed="${install_tree}/${kernelver}${l}/${dest_module_name[${count}]}${module_suffix}"
-        if [ -f "${installed}" ] && diff "${dkms_owned}" "${installed}" > /dev/null 2>&1; then
-            echo "${l}"
-            return 0
-        fi
+	installed="${install_tree}/${kernelver}${l}/${dest_module_name[${count}]}${module_suffix}"
+	if [[ -f ${installed} ]] && diff "${dkms_owned}" "${installed}" > /dev/null 2>&1; then
+	    echo "${l}"
+	    return 0
+	fi
     done
 
 }
 
-function do_uninstall()
+# Remove compiled DKMS modules from any kernels they are installed in.
+do_uninstall()
 {
     # $1 = kernel version
     # $2 = arch
@@ -1668,440 +1559,347 @@
 
     # If kernel-<kernelver> symlink points to this module, check for original_module and put it back
     local was_active=""
-    readlink "$dkms_tree/$module/kernel-$1-$2"
-    local kernel_symlink="$read_link"
+    local kernel_symlink=$(readlink -f "$dkms_tree/$module/kernel-$1-$2")
     local real_dest_module_location
-    if [ "$kernel_symlink" == "$module_version/$1/$2" ]; then
-        was_active="true"
-        echo $""
-        echo $"Status: Before uninstall, this module version was ACTIVE on this kernel."
-        # remove kabi-tracking if last instance removed
-        set_weak_modules
-        if [ -n "${weak_modules}" ] &&
-            [ `$0 status -m $module -v $module_version | grep -v "installed-weak" | grep -c "installed"` -eq 1 ]; then
-            echo $"Removing any linked weak-modules"
-            list_each_installed_module "$module" "$1" "$2" | ${weak_modules} --remove-modules
-        fi
-
-        count=0
-        while [ "$count" -lt "${#built_module_name[@]}" ]; do
-            real_dest_module_location="$(find_actual_dest_module_location $module $count $1 $2)"
-            echo $""
-            echo $"${dest_module_name[$count]}$module_suffix:"
-            echo $" - Uninstallation"
-            echo $"   - Deleting from: $install_tree/$1${real_dest_module_location}/"
-            rm -f "$install_tree/$1${real_dest_module_location}/${dest_module_name[$count]}$module_suffix"
-            echo $" - Original module"
-            if [ -e "$dkms_tree/$module/original_module/$1/$2/${dest_module_name[$count]}$module_suffix" ]; then
-                case "$running_distribution" in
-                Debian* | Ubuntu* ) ;;
-                *)
-                    echo $"   - Archived original module found in the DKMS tree"
-                    echo $"   - Moving it to: $install_tree/$1${DEST_MODULE_LOCATION[$count]}/"
-                    mkdir -p "$install_tree/$1${DEST_MODULE_LOCATION[$count]}/"
-                    mv -f "$dkms_tree/$module/original_module/$1/$2/${dest_module_name[$count]}$module_suffix" \
-                        "$install_tree/$1${DEST_MODULE_LOCATION[$count]}/" 2>/dev/null
-                    ;;
-                esac
-            else
-                echo $"   - No original module was found for this module on this kernel."
-                echo $"   - Use the dkms install command to reinstall any previous module version."
-
-                # Remove modules_conf entries from /etc/modules.conf if remake_initrd is set or if this is last instance removed
-                if [ -n "$remake_initrd" ] || \
-                    [ `$0 status -m $module -v $module_version | \
-                    grep -c "installed"` -eq 1 ]; then
-                    echo $""
-                    moduleconfig_remove "$1"
-                fi
-            fi
-            count=$(($count+1))
-        done
-        rm -f "$dkms_tree/$module/kernel-$1-$2"
+    if [[ $kernel_symlink = $dkms_tree/$module/$module_version/$1/$2 ]]; then
+	was_active="true"
+	echo $""
+	echo $"Status: Before uninstall, this module version was ACTIVE on this kernel."
+	# remove kabi-tracking if last instance removed
+	if [[ ${weak_modules} ]] && \
+	    (module_status_built $module $module_version |grep -q "installed"); then
+	    echo $"Removing any linked weak-modules"
+	    list_each_installed_module "$module" "$1" "$2" | ${weak_modules} --remove-modules
+	fi
+
+	for ((count=0; count < ${#built_module_name[@]}; count++)); do
+	    real_dest_module_location="$(find_actual_dest_module_location $module $count $1 $2)"
+	    echo $""
+	    echo $"${dest_module_name[$count]}$module_suffix:"
+	    echo $" - Uninstallation"
+	    echo $"   - Deleting from: $install_tree/$1${real_dest_module_location}/"
+	    rm -f "$install_tree/$1${real_dest_module_location}/${dest_module_name[$count]}$module_suffix"
+	    echo $" - Original module"
+	    if [[ -e $dkms_tree/$module/original_module/$1/$2/${dest_module_name[$count]}$module_suffix ]]; then
+		case "$running_distribution" in
+		Debian* | Ubuntu* ) ;;
+		*)
+		    echo $"   - Archived original module found in the DKMS tree"
+		    echo $"   - Moving it to: $install_tree/$1${DEST_MODULE_LOCATION[$count]}/"
+		    mkdir -p "$install_tree/$1${DEST_MODULE_LOCATION[$count]}/"
+		    mv -f "$dkms_tree/$module/original_module/$1/$2/${dest_module_name[$count]}$module_suffix" \
+			"$install_tree/$1${DEST_MODULE_LOCATION[$count]}/" 2>/dev/null
+		    ;;
+		esac
+	    else
+		echo $"   - No original module was found for this module on this kernel."
+		echo $"   - Use the dkms install command to reinstall any previous module version."
+
+		# Remove modules_conf entries from /etc/modules.conf if remake_initrd is set or if this is last instance removed
+		if [[ $remake_initrd ]] || \
+		    (do_status $module $module_version | grep -q "installed"); then
+		    echo $""
+		    moduleconfig_remove "$1"
+		fi
+	    fi
+	done
+	rm -f "$dkms_tree/$module/kernel-$1-$2"
     else
-        echo $""
-        echo $"Status: This module version was INACTIVE for this kernel."
+	echo $""
+	echo $"Status: This module version was INACTIVE for this kernel."
     fi
 
     # Run the post_remove script
-    if [ -n "$post_remove" ] && [ -x `echo "$dkms_tree/$module/$module_version/source/$post_remove" | sed 's/ .*//'` ]; then
-        echo $""
-        echo $"Running the post_remove script:"
-        $dkms_tree/$module/$module_version/source/$post_remove
-    fi
+    run_build_script post_remove "$post_remove"
 
     # Run depmod because we changed /lib/modules
     invoke_command "do_depmod $1" "depmod" background
 
     # Do remake_initrd things (remake initrd)
-    if [ -n "$remake_initrd" ] && [ -n "$was_active" ]; then
-        remake_initrd "$1" "$2"
-        if [ "$?" -ne 0 ]; then
-            echo $""
-            echo $"WARNING! WARNING! WARNING!"
-            echo $"There was a problem remaking your initrd.  You must manually remake it"
-            echo $"before booting into this kernel."
-            echo $""
-        fi
+    if [[ $remake_initrd && $was_active ]] && ! make_initrd "$1" "$2"; then
+	warn $"There was a problem remaking your initrd.  You must manually remake it" \
+	    $"before booting into this kernel."
     fi
 
     # Delete the original_module if nothing for this kernel is installed anymore
-    if [ -n "$was_active" ] && [ -d "$dkms_tree/$module/original_module/$1/$2" ] && ! [ -d "$dkms_tree/$module/original_module/$1/$2/collisions" ]; then
-        echo $""
-        echo $"Removing original_module from DKMS tree for kernel $1 ($2)"
-        rm -rf "$dkms_tree/$module/original_module/$1/$2" 2>/dev/null
-        [ -z "`find $dkms_tree/$module/original_module/$1/* -maxdepth 0 -type d 2>/dev/null`" ] && rm -rf "$dkms_tree/$module/original_module/$1"
-    elif [ -n "$was_active" ] && [ -d "$dkms_tree/$module/original_module/$1/$2/collisions" ]; then
-        echo $""
-        echo $"Keeping directory $dkms_tree/$module/original_module/$1/$2/collisions/"
-        echo $"for your reference purposes.  Your kernel originally contained multiple"
-        echo $"same-named modules and this directory is now where these are located."
+    if [[ $was_active && -d $dkms_tree/$module/original_module/$1/$2 && \
+	! -d $dkms_tree/$module/original_module/$1/$2/collisions ]]; then
+	echo $""
+	echo $"Removing original_module from DKMS tree for kernel $1 ($2)"
+	rm -rf "$dkms_tree/$module/original_module/$1/$2" 2>/dev/null
+	[[ $(find $dkms_tree/$module/original_module/$1/* -maxdepth 0 -type d 2>/dev/null) ]] || rm -rf "$dkms_tree/$module/original_module/$1"
+    elif [[ $was_active && -d $dkms_tree/$module/original_module/$1/$2/collisions ]]; then
+	echo $""
+	echo $"Keeping directory $dkms_tree/$module/original_module/$1/$2/collisions/"
+	echo $"for your reference purposes.  Your kernel originally contained multiple"
+	echo $"same-named modules and this directory is now where these are located."
     fi
-    [ -z "`find $dkms_tree/$module/original_module/* -maxdepth 0 -type d 2>/dev/null`" ] && rm -rf "$dkms_tree/$module/original_module"
+    [[ $(find $dkms_tree/$module/original_module/* -maxdepth 0 -type d 2>/dev/null) ]] || rm -rf "$dkms_tree/$module/original_module"
 
     # Re-add entries to modules.conf if this module/version is still installed on another kernel
     # But only do this if it was just ACTIVE on the kernel we just uninstalled from
-    [ -n "$was_active" ] && [ -n "$remake_initrd" ] && $0 status -m $module -v $module_version | grep -q "installed" && moduleconfig_add "$1"
+    [[ $was_active && $remake_initrd ]] && do_status $module $module_version | grep -q "installed" && moduleconfig_add "$1"
 
     echo $""
-    echo $"DKMS: uninstall Completed."
+    echo $"DKMS: uninstall completed."
 }
 
-function uninstall_module ()
+# Check our preconditions, and then let do_install do all the hard work.
+uninstall_module()
 {
-    setup_kernels_arches "uninstall"
-
     # Check that the right arguments were passed
-    if [ -z "$module" ] || [ -z "$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed." >&2
-        echo $"Usage: uninstall -m <module> -v <module-version>" >&2
-        echo $"   or: uninstall -m <module> -v <module-version> -k <kernel-version>" >&2
-        exit 1
-    fi
+    check_module_args uninstall
 
     # Check that $module is in the dkms tree
-    if ! [ -d "$dkms_tree/$module" ]; then
-        echo $"" >&2
-        echo $"Error! There are no instances of module: $module" >&2
-        echo $"located in the DKMS tree." >&2
-        exit 2
-    fi
+    [[ -d $dkms_tree/$module ]] || die 2 \
+	$"There are no instances of module: $module" \
+	$"located in the DKMS tree."
 
     # Make sure that its installed in the first place
-    if ! [ -d "$dkms_tree/$module/$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! The module/version combo: $module-$module_version" >&2
-        echo $"is not located in the DKMS tree." >&2
-        exit 3
-    fi
+    [[ -d $dkms_tree/$module/$module_version ]] || die 3 \
+	$"The module/version combo: $module-$module_version" \
+	$"is not located in the DKMS tree."
 
     # Read the conf file
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}"
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"Your dkms.conf is not valid." >&2
-        exit 4
-    fi
+    read_conf_or_die "$kernelver" "$arch"
 
     # Only do stuff if module/module version is currently installed
-    readlink "$dkms_tree/$module/kernel-${kernelver_array[0]}-${arch_array[0]}"
-    local kernel_symlink="$read_link"
-    if [ "$kernel_symlink" == "$module_version/${kernelver_array[0]}/${arch_array[0]}" ]; then
-        do_uninstall "${kernelver_array[0]}" "${arch_array[0]}"
-    else
-        echo $"" >&2
-        echo $"Error! The module $module $module_version is not currently installed." >&2
-        echo $"This module is not currently ACTIVE for kernel ${kernelver_array[0]} (${arch_array[0]})." >&2
-        exit 5
-    fi
+    local kernel_symlink=$(readlink -f "$dkms_tree/$module/kernel-$kernelver-$arch")
+    [[ $kernel_symlink = $dkms_tree/$module/$module_version/$kernelver/$arch ]] || die 5 \
+	    $"The module $module $module_version is not currently installed." \
+	    $"This module is not currently ACTIVE for kernel $kernelver ($arch)."
+    do_uninstall "$kernelver" "$arch"
 }
 
-function remove_module ()
+# Unregister a DKMS module.  This uninstalls any installed modules along the way.
+remove_module()
 {
-    # Check that the right arguments were passed (must be done before setup_kernels_arches)
-    if [ -z "$module" ] || [ -z "$module_version" ] || $([ -z "${kernelver_array[0]}" ] && [ -z "$all" ]); then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed." >&2
-        echo $"Usage: remove -m <module> -v <module-version> --all" >&2
-        echo $"   or: remove -m <module> -v <module-version> -k <kernel-version>" >&2
-        exit 1
+    # Check that the right arguments were passed
+    if [[ ! ($module && $module_version) || $kernels_arches_default  ]]; then
+	die 1 $"Invalid number of parameters passed." \
+	    $"Usage: remove <module>/<module-version> --all" \
+	    $"   or: remove <module>/<module-version> -k <kernel-version>"
     fi
 
-    setup_kernels_arches "remove"
-
     # Check that $module is in the dkms tree
-    if ! [ -d "$dkms_tree/$module/$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! There are no instances of module: $module" >&2
-        echo $"$module_version located in the DKMS tree." >&2
-        exit 3
-    fi
-
-    local i=0
-    while [ $i -lt ${#kernelver_array[@]} ]; do
-
-        # make sure its there first before removing
-        if ! [ -d "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}" ]; then
-            echo $"" >&2
-            echo $"Error! There is no instance of $module $module_version" >&2
-            echo $"for kernel ${kernelver_array[$i]} (${arch_array[$i]}) located in the DKMS tree." >&2
-            exit 4
-        fi
-
-        # Do --rpm_safe_upgrade check (exit out and don't do remove if inter-release RPM upgrade scenario occurs)
-        if [ -n "$rpm_safe_upgrade" ]; then
-            local pppid=`cat /proc/$PPID/status | grep PPid: | awk {'print $2'}`
-            local time_stamp=`ps -o lstart --no-headers -p $pppid 2>/dev/null`
-            for lock_file in `ls $tmp_location/dkms_rpm_safe_upgrade_lock.$pppid.* 2>/dev/null`; do
-                lock_head=`head -n 1 $lock_file 2>/dev/null`
-                lock_tail=`tail -n 1 $lock_file 2>/dev/null`
-                if [ "$lock_head" == "$module-$module_version" ] && [ "$lock_tail" == "$time_stamp" ] && [ -n "$time_stamp" ]; then
-                    echo $""
-                    echo $"DKMS: Remove cancelled because --rpm_safe_upgrade scenario detected."
-                    rm -f $lock_file
-                    exit 0
-                fi
-            done
-        fi
-
-        # Read the conf file
-        read_conf "${kernelver_array[$i]}" "${arch_array[$i]}"
-        if [ "$?" -ne 0 ]; then
-            echo $"" >&2
-            echo $"Error! Bad conf file." >&2
-            echo $"File: $dkms_tree/$module/$module_version/source/dkms.conf does not represent" >&2
-            echo $"a valid dkms.conf file." >&2
-            exit 5
-        fi
-
-        do_uninstall "${kernelver_array[$i]}" "${arch_array[$i]}"
-
-        # Delete the $kernel_version/$arch_used part of the tree
-        rm -rf "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}"
-        [ -z "`find $dkms_tree/$module/$module_version/${kernelver_array[$i]}/* -maxdepth 0 -type d 2>/dev/null`" ] && rm -rf "$dkms_tree/$module/$module_version/${kernelver_array[$i]}"
-
-        i=$(($i + 1))
+    if ! [[ -d $dkms_tree/$module/$module_version ]]; then
+	die 3 $"There are no instances of module: $module" \
+	    $"$module_version located in the DKMS tree."
+    fi
+
+    local i
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+	# make sure its there first before removing
+	if ! [[ -d $dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]} ]]; then
+	    die 4 $"There is no instance of $module $module_version" \
+		$"for kernel ${kernelver[$i]} (${arch[$i]}) located in the DKMS tree."
+	fi
+
+	# Do --rpm_safe_upgrade check (exit out and don't do remove if inter-release RPM upgrade scenario occurs)
+	if [[ $rpm_safe_upgrade ]]; then
+	    local pppid=$(awk '/PPid:/ {print $2}' /proc/$PPID/status)
+	    local time_stamp=$(ps -o lstart --no-headers -p $pppid 2>/dev/null)
+	    for lock_file in $tmp_location/dkms_rpm_safe_upgrade_lock.$pppid.*; do
+		[[ -f $lock_file ]] || continue
+		lock_head=$(head -n 1 $lock_file 2>/dev/null)
+		lock_tail=$(tail -n 1 $lock_file 2>/dev/null)
+		[[ $lock_head = $module-$module_version && $time_stamp && $lock_tail = $time_stamp ]] || continue
+		rm -f $lock_file
+		die 0 $"DKMS: Remove cancelled because --rpm_safe_upgrade scenario detected."
+	    done
+	fi
+
+	# Read the conf file
+	read_conf_or_die "${kernelver[$i]}" "${arch[$i]}"
+
+	do_uninstall "${kernelver[$i]}" "${arch[$i]}"
+
+	# Delete the $kernel_version/$arch_used part of the tree
+	rm -rf "$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}"
+	[[ $(find $dkms_tree/$module/$module_version/${kernelver[$i]}/* \
+	    -maxdepth 0 -type d 2>/dev/null) ]] || \
+	    rm -rf "$dkms_tree/$module/$module_version/${kernelver[$i]}"
     done
 
     # Delete the $module_version part of the tree if no other $module_version/$kernel_version dirs exist
-    if [ -z "$(find $dkms_tree/$module/$module_version/* -maxdepth 0 -type d 2>/dev/null | egrep -v "(build|tarball|driver_disk|rpm|deb|source)$")"  ]; then
-        echo $""
-        echo $"------------------------------"
-        echo $"Deleting module version: $module_version"
-        echo $"completely from the DKMS tree."
-        echo $"------------------------------"
-        rm -rf "$dkms_tree/$module/$module_version"
-        echo $"Done."
+    if ! find $dkms_tree/$module/$module_version/* -maxdepth 0 -type d 2>/dev/null | egrep -qv "(build|tarball|driver_disk|rpm|deb|source)$"; then
+	echo $""
+	echo $"------------------------------"
+	echo $"Deleting module version: $module_version"
+	echo $"completely from the DKMS tree."
+	echo $"------------------------------"
+	rm -rf "$dkms_tree/$module/$module_version"
+	echo $"Done."
     fi
 
     # Get rid of any remnant directories if necessary
-    if [ `ls "$dkms_tree/$module" | wc -w | awk '{print $1}'` -eq 0 ]; then
-        rm -rf "$dkms_tree/$module" 2>/dev/null
+    if (($(ls "$dkms_tree/$module" | wc -w | awk '{print $1}') == 0)); then
+	rm -rf "$dkms_tree/$module" 2>/dev/null
 
-        # Its now safe to completely remove references in /etc/sysconfig/kernel for SuSE
-        etc_sysconfig_kernel_modify "delete"
+	# Its now safe to completely remove references in /etc/sysconfig/kernel for SuSE
+	etc_sysconfig_kernel_modify "delete"
     fi
 }
 
-function find_module_from_ko()
+# Given a kernel object, figure out which DKMS module it is from.
+find_module_from_ko()
 {
-    local depth="$1"
-    local ko="$2"
-    local basename_ko=$(basename "${ko}")
+    local ko="$1"
+    local basename_ko="${ko##*/}"
     local module
     local kernellink
 
-    for kernellink in $(find $dkms_tree -maxdepth $depth -mindepth $depth -name kernel-\* -type l); do
-        module=$(echo "$kernellink" | awk -F / '{print $(NF-1)}')
-        diff "$kernellink/module/${basename_ko}" "${ko}" >/dev/null 2>&1 && echo "$module" && break
-    done
-    echo ""
-}
-
-# be careful.  string_array is global
-declare -a string_array
-function add_string_to_array_unique()
-{
-    # string="$1"
-    local count=0
-    local found=0
-    while [ "$count" -lt "${#string_array[@]}" ]; do
-        if [ "$1" == "${string_array[$count]}" ]; then
-            found=1
-            break
-        fi
-        count=$(($count + 1))
-    done
-    if [ "${found}" -eq 0 ]; then
-        string_array[${#string_array[@]}]="$1"
-    fi
-}
-
-function print_string_array()
-{
-    local count=0
-    while [ "$count" -lt "${#string_array[@]}" ]; do
-        echo "${string_array[$count]}"
-        count=$(($count + 1))
+    for kernellink in "$dkms_tree"/*/kernel-*; do
+	[[ -L $kernellink ]] || continue
+	module=${kernellink#$dkms_tree/}
+	module=${module%/kernel-*}
+	diff "$kernellink/module/${basename_ko}" "${ko}" >/dev/null 2>&1 || continue
+	rest=$(readlink $kernellink)
+	echo "$module/$rest"
+	return 0
     done
+    return 1
 }
 
-function do_status_weak ()
-{
-    # these are the requested mod/ver/kern/arch fields
-    local r_mod="$1"; shift
-    local r_ver="$1"; shift
-    local r_kern="$1"; shift
-    local r_arch="$1"; shift
-    local installedkern
-    local ko
-    local basename_ko
-    local installed_ko
-    local tree_ver
-    local tree_kern
-    local tree_arch
-    local f
-    local depth=1
-    [ -z "$r_mod" ] && depth=2
-    # recognize weak modules.  These are in $kern/weak-updates but are symlinks to another $kern/extra file.
-
-    for installedkern in $(find "$install_tree" -maxdepth 1 -mindepth 1 -type d 2>/dev/null); do
-        for ko in $(find "$installedkern/weak-updates" -type l 2>/dev/null); do
-            installedkernver=$(basename $installedkern)
-            basename_ko=$(basename $ko)
-            readlink $ko
-            installed_ko="$read_link"
-            if [ ! -e "$installed_ko" ]; then
-                # dangling symlink, ouch, but is somebody else's problem so ignore it
-                continue
-            fi
-            # remember, installed_ko is probably a relative path, so $kernelversion isn't present in its link
-            # is $installed_ko in /var/lib/dkms as installed?  Find which module has it
-            for f in $(find $dkms_tree/$r_mod -maxdepth $depth -mindepth $depth -name kernel-\* -type l 2>/dev/null); do
-                if [ -z "$r_mod" ]; then
-                    mod=$(find_module_from_ko "$depth" "$ko")
-                else
-                    mod="$r_mod"
-                fi
-                readlink "$f"
-                tree_ver=$(echo "$read_link" | awk -F / '{print $1}')
-                tree_kern=$(echo "$read_link" | awk -F / '{print $2}')
-                tree_arch=$(echo "$read_link" | awk -F / '{print $3}')
-                if diff $dkms_tree/$mod/$tree_ver/$tree_kern/$tree_arch/module/$basename_ko  \
-                    $installed_ko >/dev/null 2>&1; then
-                    if [ "$r_mod" == "$mod" -o -z "$r_mod" ] && \
-                        [ "$r_ver" == "$tree_ver" -o -z "$r_ver" ] && \
-                        [ "$r_kern" == "$installedkernver" -o -z "$r_kern" ] && \
-                        [ "$r_arch" == "$tree_arch" -o -z "$r_arch" ]; then
-                        add_string_to_array_unique "$mod, $tree_ver, $installedkernver, $tree_arch: installed-weak from $tree_kern"
-                    fi
-                fi
-            done
-        done
-    done
-    print_string_array
-}
-
-do_status ()
-{
-    local mod="$1"; shift
-    local ver="$1"; shift
-    local kern="$1"; shift
-    local arch="$1"; shift
-    local tree_depth="$1"; shift
-
-    local next
-    local working_dir
-    [ $tree_depth -eq 0 ] && next="mod"  && working_dir="$dkms_tree"
-    [ $tree_depth -eq 1 ] && next="ver"  && working_dir="$dkms_tree/$mod"
-    [ $tree_depth -eq 2 ] && next="kern" && working_dir="$dkms_tree/$mod/$ver"
-    [ $tree_depth -eq 3 ] && next="arch" && working_dir="$dkms_tree/$mod/$ver/$kern"
-    [ $tree_depth -eq 4 ] && next="done" && working_dir="$dkms_tree/$mod/$ver/$kern/$arch"
-
-    if [ -n "${!next}" ] && [ "$next" != "done" ]; then
-        do_status "$mod" "$ver" "$kern" "$arch" "$(($tree_depth + 1))"
-    elif [ "$next" != "done" ]; then
-        local keep_traversing="no"
-        for directory in `find "$working_dir" -type d -maxdepth 1 -mindepth 1 2>/dev/null`; do
-            local next_value=`echo $directory | sed "s#$working_dir/##"`
-            if ! echo "build original_module tarball driver_disk rpm" | grep -q "$next_value\b"; then
-                keep_traversing="yes"
-                [ "$next" == "mod" ]  && mod=$next_value
-                [ "$next" == "ver" ]  && ver=$next_value
-                [ "$next" == "kern" ] && kern=$next_value
-                [ "$next" == "arch" ] && arch=$next_value
-                do_status "$mod" "$ver" "$kern" "$arch" "$(($tree_depth + 1))"
-            fi
-        done
-    fi
-
-    if [ "$keep_traversing" == "no" ] && [ $tree_depth -eq 2 ] && [ -z "$arch" ] || [ "$next" == "done" ]; then
-        local state="added" && stat_display="$mod, $ver:"
-        [ -d "$working_dir/module" ] && state="built" && stat_display="$mod, $ver, $kern, $arch:"
-        if [ -h "$dkms_tree/$mod/kernel-$kern-$arch" ]; then
-            readlink "$dkms_tree/$mod/kernel-$kern-$arch"
-            [ "$read_link" == "$ver/$kern/$arch" ] && state="installed"
-        fi
-
-        if [ "$state" == "built" ] || [ "$state" == "installed" ]; then
-            set_module_suffix "$kern"
-            local extra_status=""
-            conf="$dkms_tree/$mod/$ver/source/dkms.conf"
-            read_conf "$kern" "$arch" "$conf"
-            [ -d "$dkms_tree/$mod/original_module/$kern/$arch" ] && extra_status="(original_module exists)"
-            local count=0
-            local real_dest_module_location
-            while [ "$count" -lt "${#dest_module_name[@]}" ]; do
-                tree_mod="$dkms_tree/$mod/$ver/$kern/$arch/module/${dest_module_name[$count]}$module_suffix"
-                if ! [ -e "$tree_mod" ]; then
-                    extra_status="$extra_status (WARNING! Missing some built modules!)"
-                elif [ "$state" == "installed" ]; then
-                    real_dest_module_location="$(find_actual_dest_module_location $mod $count $kern $arch)"
-                    if ! diff -q "$tree_mod" "$install_tree/$kern${real_dest_module_location}/${dest_module_name[$count]}$module_suffix" >/dev/null 2>&1; then
-                        extra_status="$extra_status (WARNING! Diff between built and installed module!)"
-                    fi
-                fi
-                count=$(($count+1))
-            done
-        fi
-
-        [ -d "$working_dir" ] && echo "$stat_display $state $extra_status"
-    fi
-}
-
-show_status ()
-{
-    setup_kernels_arches "status"
-
-    local j=0
-    if [ ${#kernelver_array[@]} -eq 0 ]; then
-        do_status "$module" "$module_version" "${kernelver_array[0]}" "${arch_array[0]}" 0
-        do_status_weak "$module" "$module_version" "${kernelver_array[0]}" "${arch_array[0]}"
-    else
-        while [ $j -lt ${#kernelver_array[@]} ]; do
-            do_status "$module" "$module_version" "${kernelver_array[$j]}" "${arch_array[$j]}" 0
-            do_status_weak "$module" "$module_version" "${kernelver_array[$j]}" "${arch_array[$j]}"
-            j=$(($j + 1))
-        done
+# Check to see if modules meeting the passed parameters are weak-installed.
+# This function's calling convention is different from the usual DKMS status
+# checking functions -- the kernel version we usually have is the one we are currently
+# running on, not necessarily the one we compiled the module for.
+module_status_weak() {
+    # $1 = module, $2 = module version, $3 = kernel version weak installed to,
+    # $4 = kernel arch, $5 = kernel version built for
+    [[ $weak_modules ]] || return 1
+    local weak_ko mod installed_ko f ret=1 oifs=$IFS
+    local -a already_found
+    for weak_ko in "$install_tree/"*/weak-updates/*; do
+	[[ -e $weak_ko ]] || continue
+	[[ -L $weak_ko ]] && installed_ko="$(readlink -f "$weak_ko")" || continue
+	IFS=/ read m v k a < <(IFS=$oifs find_module_from_ko "$weak_ko") || continue
+	kern=${weak_ko#$install_tree/}
+	kern=${kern%/weak-updates/*}
+	[[ $m = ${1:-*} && $v = ${2:-*} && $k = ${5:-*} && \
+	    $a = ${4:-*} && $kern = ${3:-*} ]] || \
+	    continue
+	ret=0
+	for f in "${already_found[@]}"; do
+	    [[ $f = $m/$v/$kern/$a/$k ]] && continue 2
+	done
+	already_found[${#already_found[@]}]="$m/$v/$kern/$a/$k"
+	echo "installed-weak $m/$v/$kern/$a/$k"
+    done
+    return $ret
+}
+
+# Print the requested status lines for weak-installed modules.
+do_status_weak()
+{
+    local mvka m v k a kern status
+    while read status mvka; do
+	IFS=/ read m v k a kern <<< "$mvka"
+	echo "$m, $v, $k, $a: installed-weak from $kern"
+    done < <(module_status_weak "$@")
+}
+
+# Spit out all the extra status information that people running DKMS are
+# interested in, but that the DKMS internals do not usually care about.
+module_status_built_extra() (
+    set_module_suffix "$3"
+    read_conf "$3" "$4" "$dkms_tree/$1/$2/source/dkms.conf"
+    [[ -d $dkms_tree/$1/original_module/$3/$4 ]] && echo -n " (original_module exists)"
+    for ((count=0; count < ${#dest_module_name[@]}; count++)); do
+	tree_mod="$dkms_tree/$1/$2/$3/$4/module/${dest_module_name[$count]}$module_suffix"
+	if ! [[ -e $tree_mod ]]; then
+	    echo -n " (WARNING! Missing some built modules!)"
+	elif _is_module_installed "$@"; then
+	    real_dest="$(find_actual_dest_module_location "$1" $count "$3" "$4")"
+	    if ! diff -q "$tree_mod" "$install_tree/$3${real_dest}/${dest_module_name[$count]}$module_suffix" >/dev/null 2>&1; then
+		echo -n " (WARNING! Diff between built and installed module!)"
+	    fi
+	fi
+    done
+)
+
+# Return a list of all the modules that are either built or installed.
+# This and module_status do some juggling of $IFS to ensure that
+# we do not get word splitting where it would be inconvienent.
+module_status_built() {
+    local ret=1 directory ka k a state oifs="$IFS" IFS=''
+    for directory in "$dkms_tree/$1/$2/"${3:-[0-9].*}/${4:-*}; do
+	IFS="$oifs"
+	ka="${directory#$dkms_tree/$1/$2/}"
+	k="${ka%/*}"
+	a="${ka#*/}"
+	is_module_built "$1" "$2" "$k" "$a" || continue
+	ret=0
+	state="built"
+	_is_module_installed "$1" "$2" "$k" "$a" && \
+	    state="installed"
+	echo "$state $1/$2/$k/$a"
+	IFS=''
+    done
+    IFS="$oifs"
+    return $ret
+}
+
+# Return the status of all modules that have been added, built, or installed.
+module_status() {
+    local oifs="$IFS" IFS='' mv m v directory ret=1
+    for directory in "$dkms_tree/"${1:-*}/${2:-*}; do
+	IFS="$oifs"
+	mv="${directory#$dkms_tree/}"
+	m="${mv%/*}"
+	v="${mv#*/}"
+	is_module_added "$m" "$v" || continue
+	ret=0
+	module_status_built "$m" "$v" "$3" "$4" || echo "added $m/$v"
+	IFS=''
+    done
+    IFS="$oifs"
+    return $ret
+}
+
+# Print out the status in the format that people who call DKMS expect.
+# Internal callers should use the module_status functions, as their output
+# is easier to parse.
+do_status() {
+    local status mvka m v k a
+    while read status mvka; do
+	IFS=/ read m v k a <<< "$mvka"
+	case $status in
+	    added) echo "$m, $v: $status";;
+	    built|installed) echo -n "$m, $v, $k, $a: $status"
+		module_status_built_extra "$m" "$v" "$k" "$a"
+		echo;;
+	esac
+    done < <(module_status "$@")
+}
+
+# Show all our status in the format that external callers expect, even
+# though it is slightly harder to parse.
+show_status()
+{
+    local j state_array
+    if ((${#kernelver[@]} == 0)); then
+	do_status "$module" "$module_version" "$kernelver" "$arch"
+	do_status_weak "$module" "$module_version" "$kernelver" "$arch"
+    else
+	for ((j=0; j < ${#kernelver[@]}; j++)); do
+	    do_status "$module" "$module_version" "${kernelver[$j]}" "${arch[$j]}"
+	    do_status_weak "$module" "$module_version" "${kernelver[$j]}" "${arch[$j]}"
+	done
     fi
 }
 
-function create_temporary_trees ()
+create_temporary_trees()
 {
-    if [ -n "$module" ] || [ -n "$module_version" ]; then
-        return
-    fi
-
-    [ -r dkms.conf ] || return
+    [[ $module || $module_version || ! -r dkms.conf ]] && return 0
 
     . dkms.conf
     module="$PACKAGE_NAME"
     module_version="$PACKAGE_VERSION"
 
-    source_tree=`mktemp -d`
-    dkms_tree=`mktemp -d`
+    source_tree=$(mktemp_or_die -d)
+    dkms_tree=$(mktemp_or_die -d)
 
     local source_tree_dir="$source_tree/$PACKAGE_NAME-$PACKAGE_VERSION"
     mkdir -p "$source_tree_dir"
@@ -2110,131 +1908,46 @@
     temporary_trees_del_command="rm -rf $source_tree $dkms_tree"
 }
 
-function delete_temporary_trees ()
+delete_temporary_trees()
 {
+    [[ $temporary_trees_del_command ]] || return 0
     $temporary_trees_del_command
-    if [ -n "$temporary_trees_del_command" ]; then
-        module=
-        module_version=
-        source_tree=
-        dkms_tree=
-        temporary_trees_del_command=
-    fi
+    module=
+    module_version=
+    source_tree=
+    dkms_tree=
+    temporary_trees_del_command=
 }
 
-function in_temporary_trees ()
-{
-    [ -n "$temporary_trees_del_command" ]
-    return $?
-}
+in_temporary_trees() { [[ $temporary_trees_del_command ]] ;}
 
 media_valid()
 {
-    if [ "$media" == "floppy" ] ||
-        [ "$media" == "iso"   ] ||
-        [ "$media" == "tar" ]; then
-        return 0
-    fi
-    return 1
-}
-
-make_driver_disk ()
-{
-    setup_kernels_arches "mkdriverdisk"
-
-    # Check that the right arguments were passed
-    if [ -z "$module" ] || [ -z "$module_version" ] || [ -z "$distro" ] || [ -z "${kernelver_array[0]}" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed." >&2
-        echo $"Usage: mkdriverdisk -d <distro> -m <module> -v <module-version> -k <kernelver> [--media floppy|iso|tar]" >&2
-        exit 1
-    fi
-
-    # default to floppy media
-    [ -z "$media" ] && media="floppy"
-    media_valid
-    if [ $? -eq 1 ]; then
-        echo $"" >&2
-        echo "$Error! Media $media is invalid." >&2
-        echo $"Usage: mkdriverdisk -d <distro> -m <module> -v <module-version> -k <kernelver> [--media floppy|iso|tar]" >&2
-        exit 1
-    fi
-
-    # Check that source symlink works
-    if ! [ -d "$dkms_tree/$module/$module_version/source" ]; then
-        echo $"" >&2
-        echo $"Error! DKMS tree does not contain: $module-$module_version" >&2
-        echo $"Build cannot continue without the proper tree." >&2
-        exit 2
-    fi
-
-    # Confirm that distro is supported
-    case "$distro" in
-    redhat | redhat[12] | suse | UnitedLinux | ubuntu)
-        ;;
-    *)
-        echo $"" >&2
-        echo $"Error! Invalid distro argument. Currently, the distros" >&2
-        echo $"supported are: redhat, redhat1, redhat2, suse, UnitedLinux" >&2
-        echo $"               ubuntu" >&2
-        exit 3
-        ;;
-    esac
-
-    # Read the conf file
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}"
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"Your dkms.conf is not valid." >&2
-        exit 4
-    fi
-
-    case "$distro" in
-    redhat*)
-        make_redhat_driver_disk
-        ;;
-    ubuntu)
-        make_ubuntu_driver_disk
-        ;;
-    *)
-        make_suse_driver_disk
-        ;;
-    esac
+    local mrx='^(floppy|iso|tar)$'
+    [[ $media =~ $mrx ]]
 }
 
-
 make_driver_disk_floppy()
 {
     local image_name="$1"
     local source_dir="$2"
     local file
     local fs='ext2'
-    case "$distro" in
-    redhat*)
-        fs='vfat'
-        ;;
-    esac
+    [[ $distro = redhat* ]] && fs='vfat'
 
     rm -f "$image_name"
     invoke_command "dd if=/dev/zero of=$image_name bs=$(($size/20))k count=20" "making a blank floppy image" background
-    if [ "$fs" == 'vfat' ]; then
-        invoke_command "mkdosfs $image_name" "mkdosfs" background
-    elif [ "$fs" == 'ext2' ]; then
-        invoke_command "mke2fs -F $image_name" "mke2fs" background
-    fi
+    case $fs in
+	vfat) invoke_command "mkdosfs $image_name" "mkdosfs" background;;
+	ext2) invoke_command "mke2fs -F $image_name" "mke2fs" background;;
+    esac
 
-    local mntdir=`mktemp -d $tmp_location/dkms.XXXXXX`
-    if [ -z "$mntdir" ]; then
-        echo $""
-        echo $"Error: Could not create a temporary directory, failing."
-        return
-    fi
+    local mntdir=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
     invoke_command "mount -o loop -t $fs $image_name $mntdir >/dev/null 2>&1" "loopback mounting disk image"
-    [ -d "$mntdir/lost+found" ] && rmdir "$mntdir/lost+found"
+    [[ -d $mntdir/lost+found ]] && rmdir "$mntdir/lost+found"
     invoke_command "cp -r $source_dir/* $mntdir/" "  copying files to floppy disk image"
     invoke_command "umount $mntdir" "unmounting disk image"
-    rm -rf $mntdir
+    rm -rf "$mntdir"
 }
 
 make_driver_disk_isotar()
@@ -2243,129 +1956,95 @@
     local image_name="$2"
     local source_dir="$3"
     local file
-    if [ "$type" == "iso" ]; then
-        invoke_command "mkisofs -v -r -J -pad -V $module -o $image_name ." "mkisofs" background
-    elif [ "$type" == "tar" ]; then
-        invoke_command "tar cvf $image_name ." "tar" background
-    fi
+    case $type in
+	iso) invoke_command "mkisofs -v -r -J -pad -V $module -o $image_name ." "mkisofs" background;;
+	tar) invoke_command "tar cvf $image_name ." "tar" background;;
+    esac
 }
 
 make_driver_disk_media()
 {
     echo "Copying files $2"
 
-    case "$media" in
-    floppy*)
-        make_driver_disk_floppy "$1" "$2"
-        ;;
-    iso*)
-        make_driver_disk_isotar "iso" "$1" "$2"
-        ;;
-    tar*)
-        make_driver_disk_isotar "tar" "$1" "$2"
-        ;;
+    case $media in
+	floppy*) make_driver_disk_floppy "$1" "$2";;
+	iso*) make_driver_disk_isotar "iso" "$1" "$2";;
+	tar*) make_driver_disk_isotar "tar" "$1" "$2";;
     esac
 }
 
 driver_disk_suffix()
 {
-    local suffix
-    case "$media" in
-    floppy*)
-        suffix="img"
-        ;;
-    iso*)
-        suffix="iso"
-        ;;
-    tar*)
-        suffix="tar"
-        ;;
+    case $media in
+	floppy*) echo "img";;
+	iso*) echo "iso";;
+	tar*) echo "tar";;
     esac
-    echo $suffix
 }
 
 make_redhat_driver_disk()
 {
+    local i count
     # kludge to allow redhat1 driver disks with BOOT kernel modules (arch i386)
-    if [ "$distro" == "redhat1" ] && [ "$multi_arch" == "true" ]; then
-        local i=0
-        local redhat1_okay="true"
-        local other_arch=""
-        while [ $i -lt ${#kernelver_array[@]} ]; do
-            if [ "${arch_array[$i]}" != "i386" ] && [ "$other_arch" != "${arch_array[$i]}" ] && [ -n "$other_arch" ]; then
-                redhat1_okay="false"
-            elif [ "${arch_array[$i]}" != "i386" ] && [ "$other_arch" != "${arch_array[$i]}" ] && [ -z "$other_arch" ]; then
-                other_arch="${arch_array[$i]}"
-            fi
-            i=$(($i+1))
-        done
-        if [ "$redhat1_okay" == "false" ]; then
-            echo $"" >&2
-            echo $"Error! You have specified a Red Hat version 1 driver disk, but have also"  >&2
-            echo $"specified multiple architectures.  Version 1 does not support this." >&2
-            echo $"Use 'redhat2' instead (only OSes >= RHEL3, FC1 support version 2)." >&2
-            exit 3
-        fi
-    fi
-
-    if [ "$distro" == "redhat2" ] || [ "$multi_arch" == "true" ] && [ -z "$redhat1_okay" ]; then
-        echo $"Creating Red Hat v2 driver disk (arch support)."
-        echo $""
-        local rhdd_filename="rhdd"
-    else
-        echo $"Creating Red Hat v1 driver disk."
-        echo $""
-        local rhdd_filename="rhdd-6.1"
-    fi
-
-    cpioarchive_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
-    if [ -z "$cpioarchive_dir_name" ]; then
-        echo $""
-        echo $"Error: Could not create a temporary directory, failing."
-        return
-    fi
-
-    local i=0
-    while [ $i -lt ${#kernelver_array[@]} ]; do
-        set_module_suffix "${kernelver_array[$i]}"
-        local count=0
-
-        local dd_prefix="${kernelver_array[$i]}"
-        [ "$distro" == "redhat2" ] && dd_prefix="${kernelver_array[$i]}/${arch_array[$i]}"
-        [ "$multi_arch" == "true" ] && [ -z "$redhat1_okay" ] && dd_prefix="${kernelver_array[$i]}/${arch_array[$i]}"
-
-        while [ "$count" -lt "${#dest_module_name[@]}" ]; do
-            if ! [ -e "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix" ]; then
-                echo $"" >&2
-                echo $"Error! Cannot find module ${dest_module_name[$count]}$module_suffix for kernel ${kernelver_array[$i]} (${arch_array[$i]})." >&2
-                echo $"Module/version must be in built state before making a driver disk." >&2
-                rm -rf $cpioarchive_dir_name
-                exit 5
-            fi
-            # FIXME: add check for KMP binary RPMs to include in the driver disk
-            if [ -z "$kernel_version_list" ]; then
-                kernel_version_list="kernel${kernelver_array[$i]}-${arch_array[$i]}"
-            else
-                kernel_version_list="$kernel_version_list-kernel${kernelver_array[$i]}-${arch_array[$i]}"
-            fi
-            mkdir -p $cpioarchive_dir_name/$dd_prefix
-            echo "Marking ${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix..."
-            cp "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix" "$cpioarchive_dir_name/$dd_prefix/"
-
-            modules_cgz_list="$dd_prefix/${dest_module_name[$count]}$module_suffix\n${modules_cgz_list}"
-            count=$(($count+1))
-        done
+    if [[ $distro = redhat1 && $multi_arch = true ]]; then
+	local redhat1_okay="true"
+	local other_arch=""
+	for ((i=0; i < ${#kernelver[@]}; i++)); do
+	    if [[ ${arch[$i]} != i386 && $other_arch != ${arch[$i]} && $other_arch ]]; then
+		die 3 $"You have specified a Red Hat version 1 driver disk, but have also" \
+		    $"specified multiple architectures.  Version 1 does not support this." \
+		    $"Use 'redhat2' instead (only OSes >= RHEL3, FC1 support version 2)."
+	    elif [[ ${arch[$i]} != i386 && $other_arch != ${arch[$i]} && ! $other_arch ]]; then
+		other_arch="${arch[$i]}"
+	    fi
+	done
+    fi
+    if [ "$distro" == "redhat2" ]  && [ -z "$redhat1_okay" ]; then
+	echo $"Creating Red Hat v2 driver disk (arch support)."
+	echo $""
+	local rhdd_filename="rhdd"
+    elif [ "$distro" == "redhat3" ] && [ -z "$redhat1_okay" ]; then
+        echo $"Creating Red Hat v3 driver disk."
+	echo $""
+	make_redhat3_driver_disk
+	return
+    else
+	echo $"Creating Red Hat v1 driver disk."
+	echo $""
+	local rhdd_filename="rhdd-6.1"
+    fi
+
+    cpioarchive_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
+
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+	set_module_suffix "${kernelver[$i]}"
+
+	local dd_prefix="${kernelver[$i]}"
+	[[ $distro = redhat2 ]] && dd_prefix="${kernelver[$i]}/${arch[$i]}"
+	[[ $multi_arch = true && -z $redhat1_okay ]] && dd_prefix="${kernelver[$i]}/${arch[$i]}"
+	maybe_build_module "$module" "$module_version" "${kernelver[$i]}" "${arch[$i]}" || {
+	    rm -rf "$cpioarchive_dir_name"
+	    die 5 $"Cannot build $module/$module_version for redhat driver disk."
+	}
+	
+	# FIXME: add check for KMP binary RPMs to include in the driver disk
+	if [[ ! $kernel_version_list ]]; then
+	    kernel_version_list="kernel${kernelver[$i]}-${arch[$i]}"
+	else
+	    kernel_version_list="$kernel_version_list-kernel${kernelver[$i]}-${arch[$i]}"
+	fi
+	mkdir -p $cpioarchive_dir_name/$dd_prefix
+	for f in "$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}/module/"*"$module_suffix"; do
+	    [[ -f $f ]] || continue
+	    echo "Marking ${f#$dkms_tree/$module/$module_version/}..."
+	    cp "$f" "$cpioarchive_dir_name/$dd_prefix/"
+	    modules_cgz_list="$dd_prefix/${f##*/} ${modules_cgz_list}"
+	done
 
-        i=$(($i + 1))
     done
 
     # Create directory and necessary files
-    driver_disk_dir=`mktemp -d $tmp_location/dkms.XXXXXX`
-    if [ -z "$driver_disk_dir" ]; then
-        echo $""
-        echo $"Error: Could not create a temporary directory, failing."
-        return
-    fi
+    driver_disk_dir=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
 
     # Copy files for the driver disk (or warn if not present)
     local files_for_driverdisk="modinfo disk-info modules.dep pcitable modules.pcimap pci.ids"
@@ -2375,18 +2054,18 @@
 
     local files_into_driverdisk="modules.cgz $rhdd_filename modules.alias"
     for file in $files_for_driverdisk; do
-        if ! [ -e "$dkms_tree/$module/$module_version/source/redhat_driver_disk/$file" ]; then
-            echo $"Warning! File: $file not found in $dkms_tree/$module/$module_version/source/redhat_driver_disk/" >&2
-        else
-            files_into_driverdisk="$file $files_into_driverdisk"
-            cp -f "$dkms_tree/$module/$module_version/source/redhat_driver_disk/$file" "$driver_disk_dir/" 2>/dev/null
-        fi
+	if [[ -e $dkms_tree/$module/$module_version/source/redhat_driver_disk/$file ]]; then
+	    files_into_driverdisk="$file $files_into_driverdisk"
+	    cp -f "$dkms_tree/$module/$module_version/source/redhat_driver_disk/$file" "$driver_disk_dir/" 2>/dev/null
+	else
+	    warn $"File: $file not found in $dkms_tree/$module/$module_version/source/redhat_driver_disk/"
+	fi
     done
     echo "$module-$module_version driver disk" > "$driver_disk_dir/$rhdd_filename"
 
     # Make sure the kernel_version_list is not too long
-    if [ `echo $kernel_version_list | wc -m | awk {'print $1'}` -gt 200 ]; then
-        kernel_version_list="manykernels"
+    if (( $(echo $kernel_version_list | wc -m | awk {'print $1'}) > 200 )); then
+	kernel_version_list="manykernels"
     fi
 
     local suffix="$(driver_disk_suffix)"
@@ -2395,23 +2074,22 @@
     echo $""
     echo $"Creating driver disk on $media media:"
     cd "$cpioarchive_dir_name"
-    invoke_command "echo -e '$modules_cgz_list' | cpio -oH crc 2>/dev/null | gzip -9 > ./modules.cgz" "compressing modules.cgz" background
+    invoke_command "echo '$modules_cgz_list' | cpio -oH crc 2>/dev/null | gzip -9 > ./modules.cgz" "compressing modules.cgz" background
     cp -f ./modules.cgz "$driver_disk_dir/"
 
     # generate modules.alias file
     # On 2.4 kernels and kernels with no aliases. this won't yield anything.
     touch ./modules.alias
-    for f in $(echo -e ${modules_cgz_list}); do
-        module_wo_suffix=$(basename ${f} ${module_suffix})
-        tmp_alias="./modules.alias.${module_wo_suffix}"
-        f="./${f}"
-        depmod -n ${f} 2>/dev/null | grep ^alias > ${tmp_alias}
-        if [ -s ${tmp_alias} ]; then
-            cat ${tmp_alias} >> ./modules.alias
-        fi
+    for f in ${modules_cgz_list}; do
+	module_wo_suffix=$(basename ${f} ${module_suffix})
+	tmp_alias="./modules.alias.${module_wo_suffix}"
+	f="./${f}"
+	depmod -n ${f} 2>/dev/null | grep ^alias > ${tmp_alias}
+	if [[ -s ${tmp_alias} ]]; then
+	    cat "${tmp_alias}" >> ./modules.alias
+	fi
     done
-    [ -e ./modules.alias ] && cp -f ./modules.alias "$driver_disk_dir/"
-
+    [[ -e ./modules.alias ]] && cp -f ./modules.alias "$driver_disk_dir/"
     # FIXME: add rpms/ directory, copy in KMP RPMs, run createrepo --pretty
 
     cd - >/dev/null
@@ -2428,59 +2106,80 @@
     echo $""
     echo $"Disk image location: $image_dir/$image_name"
     echo $""
-    echo $"DKMS: mkdriverdisk Completed."
+    echo $"DKMS: mkdriverdisk completed."
+}
+
+make_driver_disk()
+{
+    # Check that the right arguments were passed
+    if ! [[ $module && $module_version && $distro && $kernelver ]]; then
+	die 1 $"Invalid number of parameters passed." \
+	$"Usage: mkdriverdisk <module>/<module-version> -d <distro> -k <kernelver> [--media floppy|iso|tar]"
+    fi
+
+    # default to floppy media
+    [[ $media ]] || media="floppy"
+    if ! media_valid; then
+	die 1 $"Media $media is invalid." \
+	    $"Usage: mkdriverdisk <module>/<module-version> -d <distro> -k <kernelver> [--media floppy|iso|tar]"
+    fi
+
+    # Check that source symlink works
+    check_module_exists
+
+    # Confirm that distro is supported
+    case $distro in
+	redhat | redhat[123] | suse | UnitedLinux | ubuntu) ;;
+	*) die 3 $"Invalid distro argument. Currently, the distros" \
+		$"supported are: redhat, redhat1, redhat2, redhat3, suse, UnitedLinux" \
+		$"               ubuntu";;
+    esac
+
+    # Read the conf file
+    read_conf_or_die "$kernelver" "$arch"
+
+    case $distro in
+	redhat*) make_redhat_driver_disk;;
+	ubuntu) make_ubuntu_driver_disk;;
+	*) make_suse_driver_disk;;
+    esac
 }
 
 find_external_dependencies()
 {
-    local mod deps
-    local count=0
-    local i=0
+    local mod count i
+    local -a deps
 
     # find all module dependencies
-    while [ "$count" -lt "${#dest_module_name[@]}" ]; do
-        i=0
-        while [ "$i" -lt "${#kernelver_array[@]}" ]; do
-            set_module_suffix "${kernelver_array[$i]}"
-            mod="$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix"
-            deps=(${deps[@]} $(modinfo "$mod" | sed -n 's/,/ /g; s/^depends: *//p'))
-            i=$(($i+1))
-        done
-        count=$(($count+1))
+    for ((count=0; count < ${#dest_module_name[@]}; count++)); do
+	for ((i=0; i < ${#kernelver[@]}; i++)); do
+	    set_module_suffix "${kernelver[$i]}"
+	    mod="$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}/module/${dest_module_name[$count]}$module_suffix"
+	    deps=(${deps[@]} $(modinfo "$mod" | sed -n 's/,/ /g; s/^depends: *//p'))
+	done
     done
 
     # prune internally satisfied dependencies
-    i=0
-    while [ "$i" -lt "${#deps[@]}" ]; do
-        for mod in ${dest_module_name[@]}; do
-            [ "${deps[i]}" == "$mod" ] && deps[i]=
-        done
-        i=$(($i+1))
+
+    for ((i=0; i < ${#deps[@]}; i++)); do
+	for mod in ${dest_module_name[@]}; do
+	    [[ ${deps[i]} = $mod ]] && deps[i]=
+	done
     done
 
-    i=0
-    while [ "$i" -lt "${#deps[@]}" ]; do
-        echo "${deps[i]}"
-        i=$(($i+1))
+    for dep in "${deps[@]}"; do
+	echo $dep
     done | sort -u
 }
 
 make_suse_driver_disk()
 {
-    if [ -z "$release" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed for suse/UnitedLinux driver disk." >&2
-        echo $"Usage: mkdriverdisk -d <distro> -m <module> -v <module-version> -k <kernelver>" >&2
-        echo $"                    -r <release-number>" >&2
-        exit 3
-    fi
+    [[ $release ]] || die 3 \
+	$"Invalid number of parameters passed for suse/UnitedLinux driver disk." \
+	$"Usage: mkdriverdisk <module>/<module-version> -d <distro> -k <kernelver>" \
+	$"                    -r <release-number>"
 
-    local driver_disk_dir=`mktemp -d $tmp_location/dkms.XXXXXX`
-    if [ -z "$driver_disk_dir" ]; then
-        echo $""
-        echo $"Error: Could not create a temporary directory, failing."
-        return
-    fi
+    local driver_disk_dir=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
     local suffix="$(driver_disk_suffix)"
     local image_dir="$dkms_tree/$module/$module_version/driver_disk"
     local image_name="$module-$module_version-$distro-$release-dd.$suffix"
@@ -2491,112 +2190,100 @@
     local deps="$(find_external_dependencies)"
 
     local offset=0
-    if [ -n "${deps[*]}" ]; then
-        # reserve a place for dependencies
-        local offset=1
-    fi
-
-    local count=0
-    while [ "$count" -lt "${#dest_module_name[@]}" ]; do
-
-        local i=0
-        local topdir=`printf "%02d" $(($count+1+offset))`
-        while [ "$i" -lt "${#kernelver_array[@]}" ]; do
-            set_module_suffix "${kernelver_array[$i]}"
-
-            if ! [ -e "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix" ]; then
-                echo $"" >&2
-                echo $"Error! Cannot find module ${dest_module_name[$count]}$module_suffix for kernel ${kernelver_array[$i]} (${arch_array[$i]})." >&2
-                echo $"Module/version must be in built state before making a driver disk." >&2
-                rm -rf $temp_dir_name
-                exit 5
-            fi
-                        # FIXME: add check for KMP binary RPMs to include in the driver disk
-            suse_arch=${arch_array[$i]}
-            case $suse_arch in
-            i?86)
-                    suse_arch=i386
-                    ;;
-            esac
-
-            echo "Marking ${kernelver_array[$i]}/${arch_array[$i]}/modules/${dest_module_name[$count]}$module_suffix..."
-            mkdir -p "$driver_disk_dir/$topdir/$suse_arch-$release/install/lib/modules/${kernelver_array[$i]}${dest_module_location[$count]}"
-            cp "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix" "$driver_disk_dir/$topdir/$suse_arch-$release/install/lib/modules/${kernelver_array[$i]}${dest_module_location[$count]}/"
-
-            case ${kernelver_array[$i]} in
-                *-default)
-                    mkdir -p "$driver_disk_dir/$topdir/$suse_arch-$release/modules/"
-                    cp "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix" "$driver_disk_dir/$topdir/$suse_arch-$release/modules/"
-                    ;;
-            esac
-
-            # create directory for dependency information
-            [ -n "${deps[*]}" ] && mkdir -p "$driver_disk_dir/01/linux/$distro/$suse_arch-$release/modules"
-
-            i=$(($i+1))
-        done
-
-        # ---
-        for arch_release in `find $driver_disk_dir/$topdir -maxdepth 1 -mindepth 1 -type d | sed "s#$driver_disk_dir\/$topdir\/##"`; do
-            cd "$driver_disk_dir/$topdir/$arch_release/install/"
-            invoke_command "tar cvzf update.tar.gz lib/" "making update.tar.gz for $arch_release" background
-            cd - >/dev/null
-
-            mkdir -p "$driver_disk_dir/$topdir/linux/$distro/$arch_release/install"
-            mkdir -p "$driver_disk_dir/$topdir/linux/$distro/$arch_release/modules"
-
-            echo $"  copying update.tar.gz for $arch_release to disk image..."
-            cp -f "$driver_disk_dir/$topdir/$arch_release/install/update.tar.gz" "$driver_disk_dir/$topdir/linux/$distro/$arch_release/install/"
-
-            i=0
-            postkernels=
-            archtest=`echo ${arch_release} | sed 's/-.*//'`
-            while [ "$i" -lt "${#kernelver_array[@]}" ]; do
-                if [ "${arch_array[$i]}" = "${archtest}" ]; then
-                    postkernels="${postkernels} ${kernelver_array[$i]}"
-                fi
-                i=$(($i+1))
-            done
-
-            if [ -n "${postkernels}" ]; then
-                dstfile="$driver_disk_dir/$topdir/linux/$distro/$arch_release/install/update.post"
-                echo $"  creating update.post for $arch_release..."
-                (cat << EOF
+    # reserve a place for dependencies
+    [[ ${deps[@]} ]] && offset=1
+    
+    local count
+    for ((count=0; count < ${#dest_module_name[@]}; count++)); do
+	local i
+	local topdir=$(printf "%02d" $(($count+1+offset)))
+	for ((i=0; i < ${#kernelver[@]}; i++)); do
+	    set_module_suffix "${kernelver[$i]}"
+
+	    if ! [[ -e $dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}/module/${dest_module_name[$count]}$module_suffix ]]; then
+		rm -rf $temp_dir_name
+		die 5 \
+		    $"Cannot find module ${dest_module_name[$count]}$module_suffix for kernel ${kernelver[$i]} (${arch[$i]})." \
+		    $"Module/version must be in built state before making a driver disk."
+	    fi
+	    # FIXME: add check for KMP binary RPMs to include in the driver disk
+	    suse_arch=${arch[$i]}
+	    case $suse_arch in
+		i?86) suse_arch=i386;;
+	    esac
+
+	    echo "Marking ${kernelver[$i]}/${arch[$i]}/modules/${dest_module_name[$count]}$module_suffix..."
+	    mkdir -p "$driver_disk_dir/$topdir/$suse_arch-$release/install/lib/modules/${kernelver[$i]}${dest_module_location[$count]}"
+	    cp "$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}/module/${dest_module_name[$count]}$module_suffix" "$driver_disk_dir/$topdir/$suse_arch-$release/install/lib/modules/${kernelver[$i]}${dest_module_location[$count]}/"
+
+	    case ${kernelver[$i]} in
+		*-default)
+		    mkdir -p "$driver_disk_dir/$topdir/$suse_arch-$release/modules/"
+		    cp "$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}/module/${dest_module_name[$count]}$module_suffix" "$driver_disk_dir/$topdir/$suse_arch-$release/modules/"
+		    ;;
+	    esac
+
+	    # create directory for dependency information
+	    [[ ${deps[@]} ]] && mkdir -p "$driver_disk_dir/01/linux/$distro/$suse_arch-$release/modules"
+
+	done
+
+	# ---
+	for arch_release in $(find $driver_disk_dir/$topdir -maxdepth 1 -mindepth 1 -type d | sed "s#$driver_disk_dir\/$topdir\/##"); do
+	    cd "$driver_disk_dir/$topdir/$arch_release/install/"
+	    invoke_command "tar cvzf update.tar.gz lib/" "making update.tar.gz for $arch_release" background
+	    cd - >/dev/null
+
+	    mkdir -p "$driver_disk_dir/$topdir/linux/$distro/$arch_release/install"
+	    mkdir -p "$driver_disk_dir/$topdir/linux/$distro/$arch_release/modules"
+
+	    echo $"  copying update.tar.gz for $arch_release to disk image..."
+	    cp -f "$driver_disk_dir/$topdir/$arch_release/install/update.tar.gz" "$driver_disk_dir/$topdir/linux/$distro/$arch_release/install/"
+
+	    postkernels=
+	    archtest=${arch_release/-*}
+	    for ((i=0; i<${#kernelver[@]}; i++)); do
+		[[ ${arch[$i]} = ${archtest} ]] && \
+		    postkernels="${postkernels} ${kernelver[$i]}"
+	    done
+
+	    if [[ ${postkernels} ]]; then
+		dstfile="$driver_disk_dir/$topdir/linux/$distro/$arch_release/install/update.post"
+		echo $"  creating update.post for $arch_release..."
+		(cat << EOF
 #!/bin/sh
 
-EOF
-                 echo "kernlist=\"${postkernels}\""
-                 echo
-                 echo 'for kernel in ${kernlist}; do'
-                 echo '	if [ -e /boot/System.map-${kernel} ]; then'
-                 echo '		depmod -a -F /boot/System.map-${kernel} ${kernel}'
-                 echo '	fi'
-                 echo 'done'
-                ) > ${dstfile}
-                chmod a+x ${dstfile}
-            fi
+kernlist="${postkernels}"
 
-            if [ -d "$driver_disk_dir/$topdir/$arch_release/modules/" ]; then
-                echo $"  copying kernel modules for installation kernel to disk image..."
-                cp -f $driver_disk_dir/$topdir/$arch_release/modules/* $driver_disk_dir/$topdir/linux/$distro/$arch_release/modules/ 2>/dev/null
-            else
-                echo $"  Warning! No kernel modules found for -default kernel."
-            fi
+for kernel in \${kernlist}; do
+    if [ -e /boot/System.map-\${kernel} ]; then
+	depmod -a -F /boot/System.map-\${kernel} \${kernel}
+    fi
+done
 
-            rm -fr "$driver_disk_dir/$topdir/$arch_release"
-        done
+EOF
+		) > ${dstfile}
+		chmod a+x ${dstfile}
+	    fi
+
+	    if [[ -d $driver_disk_dir/$topdir/$arch_release/modules/ ]]; then
+		echo $"  copying kernel modules for installation kernel to disk image..."
+		cp -f $driver_disk_dir/$topdir/$arch_release/modules/* $driver_disk_dir/$topdir/linux/$distro/$arch_release/modules/ 2>/dev/null
+	    else
+		warn $"No kernel modules found for -default kernel."
+	    fi
 
-        # ---
-        count=$(($count+1))
+	    rm -fr "$driver_disk_dir/$topdir/$arch_release"
+	done
     done
 
     local dir
-    if [ -n "${deps[*]}" ]; then
-        for dir in "$driver_disk_dir/01/linux/$distro/"*"/modules"; do
-            for dep in ${deps[@]}; do
-                echo $dep >> "$dir/module.order"
-            done
-        done
+    if [[ ${deps[@]} ]]; then
+	for dir in "$driver_disk_dir/01/linux/$distro/"*"/modules"; do
+	    for dep in "${deps[@]}"; do
+		echo $dep >> "$dir/module.order"
+	    done
+	done
     fi
 
     # FIXME: add suse-equivalent rpms/ directory, copy in KMP RPMs, run createrepo --pretty
@@ -2611,7 +2298,7 @@
     echo $""
     echo $"Disk image location: $dkms_tree/$module/$module_version/driver_disk/$image_name"
     echo $""
-    echo $"DKMS: mkdriverdisk Completed."
+    echo $"DKMS: mkdriverdisk completed."
 }
 
 make_ubuntu_driver_disk()
@@ -2620,58 +2307,40 @@
     local image_dir="$dkms_tree/$module/$module_version/driver_disk"
     local image_name="$module-$module_version-$distro-dd.$suffix"
 
-    local tempdir=`mktemp -d $tmp_location/dkms.XXXXXX`
-    if [ -z "$tempdir" ]; then
-        echo $""
-        echo $"Error: Could not create a temporary directory, failing."
-        return
-    fi
+    local tempdir=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
 
    # Check that the dh_make command is present
    if ! which dpkg-deb >/dev/null 2>&1 ; then
-        echo $"" >&2
-        echo $"Error! dpkg-deb not present." >&2
-        echo $"Install the dpkg-dev package." >&2
-        exit 1
+	die 1 $"dpkg-deb not present." \
+	    $"Install the dpkg-dev package."
    fi
 
-   local i=0
-   while [ $i -lt ${#kernelver_array[@]} ]; do
-      set_module_suffix "${kernelver_array[$i]}"
+   local i
+   for ((i=0; i < ${#kernelver[@]}; i++)); do
+      set_module_suffix "${kernelver[$i]}"
       # Driver disks only recognize i386 as package arch
-      local arch=$(echo ${arch_array[$i]} | sed -e 's/i.86/i386/')
-      local kvers=$(echo ${kernelver_array[$i]} | sed -e 's/[-_].*//')
+      local karch=${arch[$i]/i?86/i386}
+      local kvers=${kernelver[$i]/-/_}; kvers=${kvers%%_*}
        # ubuntu-drivers/<kver>/*_<debarch>.deb
       local dd_prefix="ubuntu-drivers/$kvers"
-      local dd_suffix="_${arch}.deb"
-      local count=0
-      while [ "$count" -lt "${#dest_module_name[@]}" ]; do
-        if ! [ -e "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix" ]; then
-            echo $"" >&2
-            echo $"Error! Cannot find module ${dest_module_name[$count]}$module_suffix for kernel ${kernelver_array[$i]} (${arch_array[$i]})." >&2
-            echo $"Module/version must be in built state before making a driver disk." >&2
-            rm -rf "$tempdir"
-            exit 5
-         fi
-
-         mkdir -p "$tempdir/$dd_prefix"
-         echo "Marking ${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix..."
-
-         local deb_dir="$tempdir/$dd_prefix/debian"
-         local deb_lib_dir="$deb_dir/lib/modules/${kernelver_array[$i]}/updates/dkms"
-         mkdir -p "$deb_lib_dir"
-         cp "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}/module/${dest_module_name[$count]}$module_suffix" "$deb_lib_dir"
-         count=$(($count+1))
-       done
-
-       pushd "$deb_dir" > /dev/null 2>&1
-       mkdir DEBIAN
-       cat > DEBIAN/control <<EOF
-Package: ${module}-modules-${kernelver_array[$i]}
+      local dd_suffix="_${karch}.deb"
+      maybe_build_module "$module" "$module_version" "${kernelver[$i]}" "${arch[$i]}" || {
+	  rm -rf "$tempdir"
+	  die 5 $"Unable to build $module/$module_version for Ubuntu driver disk."
+      }
+      mkdir -p "$tempdir/$dd_prefix"
+      local deb_dir="$tempdir/$dd_prefix/debian"
+      local deb_lib_dir="$deb_dir/lib/modules/${kernelver[$i]}/updates/dkms"
+      mkdir -p "$deb_lib_dir"
+      cp "$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}/module/"*"$module_suffix" "$deb_lib_dir"
+      pushd "$deb_dir" > /dev/null 2>&1
+      mkdir DEBIAN
+      cat > DEBIAN/control <<EOF
+Package: ${module}-modules-${kernelver[$i]}
 Version: ${module_version}-1
 Section: misc
 Priority: optional
-Architecture: $arch
+Architecture: $karch
 Depends:
 Maintainer: DKMS <dkms-devel@dell.com>
 Description: DKMS packaged binary driver update
@@ -2683,19 +2352,17 @@
        # Generate the DEBIAN/preinst file.
        # This is tricky as we need some parts evaluated now
        # and some parts evaluated at runtime
-       echo '#!/bin/bash' > DEBIAN/preinst
-       echo -n '[ "$(uname -r)" == ' >> DEBIAN/preinst
-       echo -n "\"${kernelver_array[$i]}\"" >> DEBIAN/preinst
-       echo  ' ] || exit 1' >> DEBIAN/preinst
-       echo 'exit 0' >> DEBIAN/preinst
-
+cat >DEBIAN/preinst <<EOF
+#!/bin/bash
+[[ \$(uname -r) = ${kernelver[$i]} ]] || exit 1
+exit 0
+EOF
        chmod 0775 DEBIAN/preinst
        cd "$tempdir/$dd_prefix"
        dpkg-deb --build debian
-       mv debian.deb "${module}_${module_version}-${kernelver_array[$i]}${dd_suffix}"
+       mv debian.deb "${module}_${module_version}-${kernelver[$i]}${dd_suffix}"
        rm -rf debian
        popd > /dev/null 2>&1
-       i=$(($i+1))
    done
 
    echo "Copying source..."
@@ -2711,79 +2378,48 @@
    echo $""
    echo $"Disk image location: $dkms_tree/$module/$module_version/driver_disk/$image_name"
    echo $""
-   echo $"DKMS: mkdriverdisk Completed."
+   echo $"DKMS: mkdriverdisk completed."
 }
 
 make_tarball()
 {
-    setup_kernels_arches "mktarball"
-
     make_common_test "mktarball"
 
     # Check for dkms_dbversion
-    if ! [ -e "$dkms_tree/dkms_dbversion" ]; then
-        echo $"" >&2
-        echo $"Could not find the file $dkms_tree/dkms_dbversion." >&2
-        echo $"Creating w/ default contents." >&2
-        echo "2.0.0" > $dkms_tree/dkms_dbversion
-    fi
-
-    # Error out if archive_location is set and contains a "/" in it
-    case "$archive_location" in
-        */*)
-        echo $"" >&2
-        echo $"Error!  The name you have specified for your tarball contains a '/'." >&2
-        echo $"You may only specify a simple filename with no preceding path."
-        exit 7
-        ;;
-    esac
-
-    # Error out if binaries-only is set and source-only is set
-    if [ -n "$binaries_only" ] && [ -n "$source_only" ]; then
-        echo $"" >&2
-        echo $"Error!  You have specified both --binaries-only and --source-only." >&2
-        echo $"You cannot do this." >&2
-        exit 8
+    if ! [[ -e $dkms_tree/dkms_dbversion ]]; then
+	echo $"" >&2
+	echo $"Could not find the file $dkms_tree/dkms_dbversion." >&2
+	echo $"Creating w/ default contents." >&2
+	echo "2.0.0" > $dkms_tree/dkms_dbversion
     fi
 
     # Read the conf file
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}"
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"Your dkms.conf is not valid." >&2
-        exit 5
-    fi
+    read_conf_or_die "$kernelver" "$arch"
 
-    temp_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
+    temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
     mkdir -p $temp_dir_name/dkms_main_tree
 
-    if [ -n "$source_only" ]; then
-    kernel_version_list="source-only"
+    if [[ $source_only ]]; then
+	kernel_version_list="source-only"
     else
-    local i=0
-    while [ $i -lt ${#kernelver_array[@]} ]; do
-
-        if ! [ -d "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}" ]; then
-            echo $"" >&2
-            echo $"Error! No modules built for ${kernelver_array[$i]} (${arch_array[$i]})." >&2
-            echo $"Modules must already be in the built state before using mktarball." >&2
-            rm -rf "$temp_dir_name" 2>/dev/null
-            exit 6
-        fi
-
-        set_module_suffix "${kernelver_array[$i]}"
-
-        echo "Marking modules for ${kernelver_array[$i]} (${arch_array[$i]}) for archiving..."
-        if [ -z "$kernel_version_list" ]; then
-            kernel_version_list="kernel${kernelver_array[$i]}-${arch_array[$i]}"
-        else
-            kernel_version_list="${kernel_version_list}-kernel${kernelver_array[$i]}-${arch_array[$i]}"
-        fi
-        mkdir -p "$temp_dir_name/dkms_main_tree/${kernelver_array[$i]}/${arch_array[$i]}"
-        cp -rf "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}" "$temp_dir_name/dkms_main_tree/${kernelver_array[$i]}"
-
-        i=$(($i + 1))
+	local i
+	for ((i=0; i<${#kernelver[@]}; i++)); do
+	    if ! [[ -d $dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]} ]]; then
+		rm -rf "$temp_dir_name" 2>/dev/null
+		die 6  $"No modules built for ${kernelver[$i]} (${arch[$i]})." \
+		    $"Modules must already be in the built state before using mktarball."
+	    fi
+
+	    set_module_suffix "${kernelver[$i]}"
+
+	    echo "Marking modules for ${kernelver[$i]} (${arch[$i]}) for archiving..."
+	    if [[ ! $kernel_version_list ]]; then
+		kernel_version_list="kernel${kernelver[$i]}-${arch[$i]}"
+	    else
+		kernel_version_list="${kernel_version_list}-kernel${kernelver[$i]}-${arch[$i]}"
+	    fi
+	    mkdir -p "$temp_dir_name/dkms_main_tree/${kernelver[$i]}/${arch[$i]}"
+	    cp -rf "$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}" "$temp_dir_name/dkms_main_tree/${kernelver[$i]}"
     done
     fi
 
@@ -2791,469 +2427,431 @@
     cp -f "$dkms_tree/dkms_dbversion" "$temp_dir_name/dkms_main_tree/"
 
     # Copy the source_tree or make special binaries-only structure
-    if [ -z "$binaries_only" ]; then
-        echo $""
-        echo $"Marking $dkms_tree/$module/$module_version/source for archiving..."
-        mkdir -p $temp_dir_name/dkms_source_tree
-        cp -rf $dkms_tree/$module/$module_version/source/* $temp_dir_name/dkms_source_tree
-    else
-        echo $""
-        echo $"Creating special tarball structure to accomodate only binaries."
-        mkdir $temp_dir_name/dkms_binaries_only
-        echo "$module" > $temp_dir_name/dkms_binaries_only/PACKAGE_NAME
-        echo "$module_version" > $temp_dir_name/dkms_binaries_only/PACKAGE_VERSION
-        [ -z "$conf" ] && conf="$dkms_tree/$module/$module_version/source/dkms.conf"
-        cp -f $conf $temp_dir_name/dkms_binaries_only/ 2>/dev/null
+    if [[ $binaries_only ]]; then
+	echo $""
+	echo $"Creating tarball structure to specifically accomodate binaries."
+	mkdir $temp_dir_name/dkms_binaries_only
+	echo "$module" > $temp_dir_name/dkms_binaries_only/PACKAGE_NAME
+	echo "$module_version" > $temp_dir_name/dkms_binaries_only/PACKAGE_VERSION
+	[[ ! $conf ]] && conf="$dkms_tree/$module/$module_version/source/dkms.conf"
+	cp -f $conf $temp_dir_name/dkms_binaries_only/ 2>/dev/null
+    else
+	echo $""
+	echo $"Marking $dkms_tree/$module/$module_version/source for archiving..."
+	mkdir -p $temp_dir_name/dkms_source_tree
+	cp -rf $dkms_tree/$module/$module_version/source/* $temp_dir_name/dkms_source_tree
     fi
 
-    # Make the tarball
-    cd $temp_dir_name
-    if [ `echo $kernel_version_list | wc -m | awk {'print $1'}` -gt 200 ]; then
-        kernel_version_list="manykernels"
+    if (( $(echo $kernel_version_list | wc -m | awk {'print $1'}) > 200 )); then
+	kernel_version_list="manykernels"
     fi
+
     local tarball_name="$module-$module_version-$kernel_version_list.dkms.tar.gz"
-    [ -n "$archive_location" ] && tarball_name="$archive_location"
-    tar -czf $temp_dir_name/$tarball_name ./* 2>/dev/null
-    cd - >/dev/null
-    if [ "$?" -eq 0 ]; then
-        echo $""
-        mkdir -p $dkms_tree/$module/$module_version/tarball 2>/dev/null
-        mv -f $temp_dir_name/$tarball_name $dkms_tree/$module/$module_version/tarball/
-        echo $""
-        echo $"Tarball location: $dkms_tree/$module/$module_version/tarball/$tarball_name"
-        echo $""
-        echo $"DKMS: mktarball Completed."
-        rm -rf $temp_dir_name
-    else
-        echo $"" >&2
-        echo $"Error! Failed to make tarball." >&2
-        rm -rf $temp_dir_name
-        exit 6
+    local tarball_dest="$dkms_tree/$module/$module_version/tarball/"
+
+    # Die if we will not be able to create the tarball due to permissions.
+    if [[ $archive_location ]]; then
+	tarball_name="${archive_location##*/}"
+        if [[ ${archive_location%/*} != $archive_location && \
+            -d ${archive_location%/*} && -w ${archive_location%/*} ]]; then
+            tarball_dest="${archive_location%/*}"
+        elif [[ ${archive_location%/*} != $archive_location ]] && ! mkdir -p $tarball_dest; then
+	    die 9 $"Will not be able to create $archive_location due to a permissions problem."
+	fi
     fi
+    if [ ! -d $tarball_dest ]; then
+	mkdir -p "$dkms_tree/$module/$module_version/tarball/"
+    fi
+
+    echo $""
+    echo $"Tarball location: $tarball_dest/$tarball_name"
+
+    local tarball_ext=${tarball_name##*.}
+    [[ $tarball_ext = tar ]] || tarball_name=${tarball_name%.$tarball_ext}
+
+    # Make the tarball
+    cd $temp_dir_name
+    if tar -cf $temp_dir_name/$tarball_name ./* 2>/dev/null; then
+	cd - >/dev/null
+	echo $""
+	mv -f "$temp_dir_name/$tarball_name" "$tarball_dest/$tarball_name"
+	rm -rf $temp_dir_name
+    else
+	cd - >/dev/null
+	rm -rf $temp_dir_name
+	die 6 $"Failed to make tarball."
+    fi
+    case $tarball_ext in
+	gz) gzip -9 "$tarball_dest/$tarball_name";;
+	bz2) bzip2 -9 "$tarball_dest/$tarball_name";;
+	xz) xz -9 "$tarball_dest/$tarball_name";;
+    esac
+    echo $""
+    echo $"DKMS: mktarball completed."
+}
+
+# A tiny helper function to make sure dkms.conf describes a valid package.
+get_pkginfo_from_conf() {
+    [[ -f $1 && $1 = *dkms.conf ]] || return
+    read_conf_or_die "$kernelver" "$arch" "$1"
+    [[ $PACKAGE_NAME && $PACKAGE_VERSION ]]
 }
 
+# Unpack a DKMS tarball from a few different supported formats.
+# We expect $archive_location to have been passed either as a raw argument or
+# with --archive.
 load_tarball()
 {
-    setup_kernels_arches "mktarball"
-
-    # Error out of --archive was not set with the tarball location
-    if [ -z "$archive_location" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed." >&2
-        echo $"Usage: ldtarball --archive=<tarball-location>" >&2
-        exit 1
+    # Error out if $archive_location does not exist
+    if [[ ! -e $archive_location ]]; then
+	die 2 $"$archive_location does not exist."
     fi
 
-    # Error out if $archive_location does not exist
-    if ! [ -e "$archive_location" ]; then
-        echo $"" >&2
-        echo $"Error! Cannot locate $archive_location." >&2
-        echo $"File does not exist." >&2
-        exit 2
+    # If it is an .rpm file. install it with rpm, run an autoinstall, and then exit.
+    if [[ $archive_location = *.rpm ]]; then
+       if rpm -Uvh "$archive_location"; then
+           autoinstall
+           exit $?
+       else
+           die 9 $"Unable to install $archive_location using rpm." \
+               $"Check to ensure that your system can install .rpm files."
+       fi
     fi
 
     # Figure out what kind of archive it is (tar.gz, tar, tar.bz, etc)
+    # Note that this does not depend on the extensions being correct.
     local tar_options=""
-    if `gzip -t $archive_location 2>/dev/null`; then
-        tar_options="${tar_options}z"
-    fi
-    if `bzip2 -t $archive_location 2>/dev/null`; then
-        tar_options="${tar_options}j"
-    fi
+    for xpand in gzip bzip xz; do
+	$xpand -t $archive_location 2>/dev/null || continue
+	case $xpand in
+	    gzip) tar_options=z;;
+	    bzip2) tar_options=j;;
+	    xz) tar_options=J;;
+	esac
+	break
+    done
 
     # Untar it into $tmp_location
-    local temp_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
+    local temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
+    trap 'rm -rf $temp_dir_name' EXIT
     tar -${tar_options}xf $archive_location -C $temp_dir_name
 
-    # Check that dkms_dbversion is not a future version
-    db_from_tarball="`cat $temp_dir_name/dkms_main_tree/dkms_dbversion 2>/dev/null`"
-    db_from_dkms="`cat $dkms_tree/dkms_dbversion 2>/dev/null`"
-    if [ -n "$db_from_tarball" ] && [ -n "$db_from_dkms" ]; then
-        if [[ $(VER "$db_from_tarball") > $(VER "$db_from_dkms") ]]; then
-            echo $"" >&2
-            echo $"Error! The tarball you are trying to load indicates it is database version" >&2
-            echo $"$db_from_tarball.  This version of DKMS only supports $db_from_dkms or lower.">&2
-            rm -rf $temp_dir_name
-            exit 9
-        fi
+    if [[ ! $temp_dir_name/dkms_main_tree ]]; then
+	# Tarball was not generated from mktarball.
+	# Just find the dkms.conf file and load the source.
+	conf=$(find $temp_dir_name/ -name dkms.conf 2>/dev/null | head -n 1)
+	if [[ ! $conf ]]; then
+	    rm -rf $temp_dir_name
+	    die 3 $"Tarball does not appear to be a correctly formed" \
+		$"DKMS archive. No dkms.conf found within it."
+	fi
+	add_source_tree "${conf%dkms.conf}"
+	return
     fi
 
-    # Make sure its a sane tarball
-    PACKAGE_NAME=""
-    PACKAGE_VERSION=""
-    local is_from_mktarball=""
-    local is_binaries_only=""
-    local is_not_arch_aware=""
-    if ! [ -d "$temp_dir_name/dkms_main_tree" ]; then
-        conf=`find $temp_dir_name/ -name dkms.conf 2>/dev/null | head -n 1`
-        if [ -z "$conf" ]; then
-            echo $"" >&2
-            echo $"Error! Tarball does not appear to be a correctly formed" >&2
-            echo $"DKMS archive. No dkms.conf found within it." >&2
-            rm -rf $temp_dir_name
-            exit 3
-        fi
-        read_conf "${kernelver_array[0]}" "${arch_array[0]}" "$conf"
-        if [ "$?" -ne 0 ]; then
-            echo $"" >&2
-            echo $"Error! Bad conf file." >&2
-            echo $"File: $conf does not represent a valid dkms.conf file" >&2
-            rm -rf $temp_dir_name
-            exit 4
-        fi
-        tarball_source_tree_name=`echo $conf | sed "s#$temp_dir_name\/##" | sed 's/dkms.conf//' | sed 's/\/$//'`
-    elif ! [ -d "$temp_dir_name/dkms_source_tree" ] && [ -d "$temp_dir_name/dkms_binaries_only" ]; then
-        PACKAGE_NAME=`cat $temp_dir_name/dkms_binaries_only/PACKAGE_NAME 2>/dev/null`
-        PACKAGE_VERSION=`cat $temp_dir_name/dkms_binaries_only/PACKAGE_VERSION 2>/dev/null`
-        if [ -z "$PACKAGE_NAME" ] || [ -z "$PACKAGE_VERSION" ]; then
-            echo $"" >&2
-            echo $"Error! Tarball does not appear to be a correctly formed" >&2
-            echo $"DKMS archive." >&2
-            rm -rf $temp_dir_name
-            exit 5
-        fi
-        if [ "`$0 status -m $PACKAGE_NAME -v $PACKAGE_VERSION 2>/dev/null`" == "" ]; then
-            if [ -e "$temp_dir_name/dkms_binaries_only/dkms.conf" ]; then
-            echo $""
-            echo $"Binaries-only DKMS tarball to be loaded for $PACKAGE_NAME-$PACKAGE_VERSION"
-            echo $"even though source for this module is not added to the DKMS tree.  "
-                    echo $"<<<<WARNING>>>>"
-            echo $"This will allow you to install the pre-built binaries contained within this"
-            echo $"tarball, but will prevent you from building new modules for other kernels."
-            echo $""
-            . $temp_dir_name/dkms_binaries_only/dkms.conf 2>/dev/null
-            else
-            echo $"" >&2
-            echo $"Binaries-only DKMS tarball does not seem to contain a dkms.conf file for" >&2
-            echo $"this module.  Unable to load this tarball into the DKMS tree." >&2
-            exit 7
-            fi
-        fi
-        is_from_mktarball="true"
-        is_binaries_only="true"
-    elif [ -d "$temp_dir_name/dkms_source_tree" ]; then
-        . $temp_dir_name/dkms_source_tree/dkms.conf 2>/dev/null
-        if [ -z "$PACKAGE_NAME" ] || [ -z "$PACKAGE_VERSION" ]; then
-            echo $"" >&2
-            echo $"Error! Tarball does not appear to be a correctly formed" >&2
-            echo $"DKMS archive." >&2
-            rm -rf $temp_dir_name
-            exit 8
-        fi
-        is_from_mktarball="true"
-        tarball_source_tree_name="dkms_source_tree"
-    else
-        echo $"" >&2
-        echo $"Error! Tarball does not appear to be a correctly formed" >&2
-        echo $"DKMS archive." >&2
-        rm -rf $temp_dir_name
-        exit 8
-    fi
+    # Check that dkms_dbversion is not a future version
+    # As far as I can tell, the only reason we bother with this is for detecting
+    # whether we have arch support or not, which we can also determine by examining
+    # the structure of the tarball.
+    db_from_tarball=$(cat $temp_dir_name/dkms_main_tree/dkms_dbversion 2>/dev/null)
+    db_from_dkms=$(cat $dkms_tree/dkms_dbversion 2>/dev/null)
+    if [[ $db_from_tarball && $db_from_dkms && \
+	$(VER "$db_from_tarball") > $(VER "$db_from_dkms") ]]; then
+	die 9 \
+	    $"The tarball you are trying to load indicates it is database version" \
+	    $"$db_from_tarball.  This version of DKMS only supports $db_from_dkms or lower."
+    fi
+
+    # Make sure its a sane tarball. Sane ones will have one of the two
+    # directories we test for.
+    for loc in dkms_source_tree dkms_binaries_only ''; do
+	if [[ ! $loc ]]; then
+	    die 7 $"No valid dkms.conf in dkms_source_tree or dkms_binaries_only." \
+		$"$archive_location is not a valid DKMS tarball."
+	fi
+	local conf="$temp_dir_name/$loc/dkms.conf"
+	[[ -f $conf ]] || continue
+	if ! get_pkginfo_from_conf "$conf"; then
+	    echo >&2
+	    echo $"Malformed dkms.conf, refusing to load." >&2
+	    continue
+	fi
+	if is_module_added "$PACKAGE_NAME" "$PACKAGE_VERSION" && \
+	    [[ ! $force ]]; then
+	    die 8  $"$PACKAGE_NAME-$PACKAGE_VERSION is already added!" \
+		$"Aborting."
+	fi
+	module="$PACKAGE_NAME"; module_version="$PACKAGE_VERSION"
+	echo $""
+	echo $"Loading tarball for $module-$module_version"
+	case $loc in
+	    dkms_source_tree)
+		add_source_tree "$temp_dir_name/dkms_source_tree";;
+	    dkms_binaries_only)
+		#if there is a source tree on the system already, don't build a binaries stub
+		if [[ ! -d $source_tree/$module-$module_version ]]; then
+			echo $"Creating $dkms_tree/$module/$module_version/source"
+			mkdir -p "$dkms_tree/$module/$module_version/source"
+			echo $"Copying dkms.conf to $dkms_tree/$module/$module_version/source..."
+			cp -rf "$temp_dir_name/dkms_binaries_only/dkms.conf" "$dkms_tree/$module/$module_version/source"
+		fi;;
+	    *)  die 8 $"$FUNCNAME:$LINENO: Cannot happen." \
+		$"Report this error to dkms-devel@dell.com";;
+	esac
+	break
+    done
+
+    # at this point, the source has been copied to the appropriate location
+    # and registered with dkms, or a binary-only config has been noted.
+    # Now, add any included precompiled modules.
 
     # Is tarball from before DKMS 2.0 (prior to arch support)
-    if [ "$is_from_mktarball" == "true" ] && ! [ -e "$temp_dir_name/dkms_main_tree/dkms_dbversion" ]; then
-        is_not_arch_aware="true"
-        echo $"" >&2
-        echo $"Warning!  This tarball was created with dkms < 2.0 and contains" >&2
-        echo $"no arch info. DKMS will assume the arch: ${arch_array[0]}" >&2
+    if [[ ! -e $temp_dir_name/dkms_main_tree/dkms_dbversion ]]; then
+	[[ $loc = dkms_binaries_only ]] && rm -rf "$dkms_tree/$module/$module_version/source"
+	die 10 $" This tarball was created with dkms < 2.0 and contains" \
+	    $"no arch info. DKMS is refusing to install precompiled modules."
     fi
 
-    # Make sure we got what we needed from the tarball
-    module="$PACKAGE_NAME"
-    module_version="$PACKAGE_VERSION"
-
-    echo $""
-    echo $"Loading tarball for module: $module / version: $module_version"
-    echo $""
-
-    # Load the source from the tarball or build it's structure (for binaries only)
-    if [ -z "$is_binaries_only" ]; then
-        if [ "`$0 status -m $module -v $module_version 2>/dev/null`" != "" ] && [ -z "$force" ]; then
-            echo $"Warning! Source for $module-$module_version already exists.  Skipping..." >&2
-        else
-            echo $"Loading $source_tree/$module-$module_version..."
-            rm -rf $source_tree/$module-$module_version
-            mkdir -p $source_tree/$module-$module_version
-            cp -rf $temp_dir_name/$tarball_source_tree_name/* $source_tree/$module-$module_version
-        fi
-
-        mkdir -p $dkms_tree/$module/$module_version
-    else
-        echo $"Creating $dkms_tree/$module/$module_version/source"
-        mkdir -p $dkms_tree/$module/$module_version/source
-        echo $"Copying dkms.conf to $dkms_tree/$module/$module_version/source..."
-        cp -rf $temp_dir_name/dkms_binaries_only/dkms.conf $dkms_tree/$module/$module_version/source
-    fi
-
-    # Load kernel directories
-    [ -n "$is_not_arch_aware" ] && dirs_to_load=`find $temp_dir_name/dkms_main_tree -type d -maxdepth 1 -mindepth 1 2>/dev/null`
-    [ -z "$is_not_arch_aware" ] && dirs_to_load=`find $temp_dir_name/dkms_main_tree -type d -maxdepth 2 -mindepth 2 2>/dev/null`
-    for directory in $dirs_to_load; do
-        dirs_to_parse=`echo $directory | sed "s#.*dkms_main_tree/##"`
-        kernel_to_load=`echo $dirs_to_parse | sed "s#/.*##"`
-        # arch_to_load="${arch_array[0]##*/}"
-        [ `echo $dirs_to_parse | grep -c "/"` -gt 0 ] && arch_to_load=`echo $dirs_to_parse | sed "s#.*/##"` || arch_to_load="${arch_array[0]}"
-
-        dkms_dir_location="$dkms_tree/$module/$module_version/$kernel_to_load/$arch_to_load"
-
-
-        dkms_dir_location="$dkms_tree/$module/$module_version/$kernel_to_load/$arch_to_load"
-        if [ -d "$dkms_dir_location" ] && [ -z "$force" ]; then
-            echo $"Warning! $dkms_dir_location already exists.  Skipping..." >&2
-        else
-            echo $"Loading $dkms_dir_location..."
-            rm -rf $dkms_dir_location
-            mkdir -p $dkms_dir_location
-            cp -rf $directory/* $dkms_dir_location/
-        fi
+    # Load precompiled modules.
+    for directory in "$temp_dir_name/dkms_main_tree"/*/*; do
+	[[ -d $directory ]] || continue
+	kernel_arch_to_load=${directory/*dkms_main_tree\/}
+	dkms_dir_location="$dkms_tree/$module/$module_version/$kernel_arch_to_load"
+	if [[ -d $dkms_dir_location && ! $force ]]; then
+	    warn $"$dkms_dir_location already exists.  Skipping..."
+	else
+	    echo $"Loading $dkms_dir_location..."
+	    rm -rf $dkms_dir_location
+	    mkdir -p $dkms_dir_location
+	    cp -rf $directory/* $dkms_dir_location/
+	fi
     done
 
-    # Create source symlink (if there isn't a real directory there)
-    if [ ! -h "$dkms_tree/$module/$module_version/source" ] && \
-       [ ! -d "$dkms_tree/$module/$module_version/source" ] || [ ! -z "$force" ]; then
-        echo $"Creating $dkms_tree/$module/$module_version/source symlink..."
-        rm -f "$dkms_tree/$module/$module_version/source"
-        ln -s "$source_tree/$module-$module_version" "$dkms_tree/$module/$module_version/source"
-    fi
-
-    # Clean up /tmp
-    rm -rf $temp_dir_name
-
     echo $""
-    echo $"DKMS: ldtarball Completed."
+    echo $"DKMS: ldtarball completed."
+    [[ $loc != dkms_binaries_only ]] || [[ -d $source_tree/$module-$module_version ]]
 }
 
-run_match ()
+run_match()
 {
-    setup_kernels_arches "match"
-    set_kernel_source_dir "${kernelver_array[0]}"
+    set_kernel_source_dir "$kernelver"
 
     # Error if $template_kernel is unset
-    if [ -z "$template_kernel" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed." >&2
-        echo $"Usage: match --templatekernel=<kernel-version> -k <kernel-version>" >&2
-        echo $"   or: match --templatekernel=<kernel-version> -k <kernel-version> -m <module>" >&2
-        exit 1
+    if [[ ! $template_kernel ]]; then
+	die 1 $"Invalid number of parameters passed." \
+	    $"Usage: match --templatekernel=<kernel-version> -k <kernel-version>" \
+	    $"   or: match --templatekernel=<kernel-version> -k <kernel-version> <module>"
     fi
 
     # Error out if $template_kernel = $kernel_version
-    if [ "$template_kernel" == "${kernelver_array[0]}" ]; then
-        echo $"" >&2
-        echo $"Error! The templatekernel and the specified kernel version are the same." >&2
-        exit 2
+    if [[ $template_kernel = $kernelver ]]; then
+	die 2 $"The templatekernel and the specified kernel version are the same."
     fi
 
     # Read in the status of template_kernel
-    local template_kernel_status=`$0 status -k $template_kernel -a ${arch_array[0]} | grep ": installed"`
+    local template_kernel_status=$(do_status '' '' $template_kernel $arch | grep ": installed")
 
     # If $module is set, grep the status only for that module
-    if [ -n "$module" ]; then
-
-        # Make sure that its installed in the first place
-        if ! [ -d "$dkms_tree/$module/" ]; then
-            echo $"" >&2
-            echo $"Error! The module: $module is not located in the DKMS tree." >&2
-            exit 3
-        fi
-
-        template_kernel_status=`echo "$template_kernel_status" | grep "^$module,"`
+    if [[ $module ]]; then
+	# Make sure that its installed in the first place
+	if ! [[ -d $dkms_tree/$module/ ]]; then
+	    die 3 $"The module: $module is not located in the DKMS tree."
+	fi
+	template_kernel_status=$(echo "$template_kernel_status" | grep "^$module,")
     fi
 
     echo $""
-    echo $"Matching modules in kernel: ${kernelver_array[0]} (${arch_array[0]})"
-    echo $"to the configuration of kernel: $template_kernel (${arch_array[0]})"
+    echo $"Matching modules in kernel: $kernelver ($arch)"
+    echo $"to the configuration of kernel: $template_kernel ($arch)"
 
     # Prepare the kernel just once but only if there is actual work to do
-    if [ -z "$template_kernel_status" ]; then
-        echo $""
-        echo $"There is nothing to be done for this match."
-    else
-        prepare_kernel "${kernelver_array[0]}" "${arch_array[0]}"
-
-        # Iterate over the kernel_status and match kernel to the template_kernel
-        while read template_line; do
-            template_module=`echo "$template_line" | awk {'print $1'} | sed 's/,$//'`
-            template_version=`echo "$template_line" | awk {'print $2'} | sed 's/,$//'`
-
-            # Print out a match header
-            echo $""
-            echo $"---- Match Beginning ----"
-            echo $"Module:  $template_module"
-            echo $"Version: $template_version"
-            echo $"-------------------------"
-
-            # Figure out what to do from here
-            if $0 status -m "$template_module" -v "$template_version" -k "${kernelver_array[0]}" -a "${arch_array[0]}" 2>/dev/null | grep -q ": installed"; then
-                echo $""
-                echo $"This module/version combo is already installed.  Nothing to be done."
-            elif $0 status -m "$template_module" -v "$template_version" -k "${kernelver_array[0]}" -a "${arch_array[0]}" 2>/dev/null | grep -q ": built"; then
-                echo $""
-                echo $"This module/version combo is built.  Installing it:"
-                module="$template_module"
-                module_version="$template_version"
-                install_module
-            else
-                echo $""
-                echo $"Building & Installing this module/version:"
-                module="$template_module"
-                module_version="$template_version"
-                build_module
-                install_module
-            fi
-        done < <(echo "$template_kernel_status")
-
-        # Clean up the kernel tree
-        if [[ ! ( $(VER ${kernelver_array[0]}) < $(VER 2.6.6) ) && \
-            -d "$kernel_source_dir" && \
-            ! -h "$kernel_source_dir" && \
-            -z "$ksourcedir_fromcli" ]]; then
-            echo $"Kernel cleanup unnecessary for this kernel.  Skipping..."
-        elif [ -z "$no_clean_kernel" ]; then
-            cd "$kernel_source_dir"
-            [ -z "$kerneldoth_contents" ] && invoke_command "make mrproper" "cleaning kernel tree (make mrproper)" background
-            [ -n "$config_contents" ] && echo "$config_contents" > .config
-            [ -n "$kerneldoth_contents" ] && echo "$kerneldoth_contents" > /boot/kernel.h
-            cd - >/dev/null
-        fi
+    if [[ ! $template_kernel_status ]]; then
+	echo $""
+	echo $"There is nothing to be done for this match."
+    else
+	prepare_kernel "$kernelver" "$arch"
+
+	# Iterate over the kernel_status and match kernel to the template_kernel
+	while read template_line; do
+	    template_module=`echo "$template_line" | awk {'print $1'} | sed 's/,$//'`
+	    template_version=`echo "$template_line" | awk {'print $2'} | sed 's/,$//'`
+
+	    # Print out a match header
+	    echo $""
+	    echo $"---- Match Beginning ----"
+	    echo $"Module:  $template_module"
+	    echo $"Version: $template_version"
+	    echo $"-------------------------"
+
+	    # Figure out what to do from here
+	    if show_status "$template_module" "$template_version" "$kernelver" "$arch" 2>/dev/null | grep -q ": installed"; then
+		echo $""
+		echo $"This module/version combo is already installed.  Nothing to be done."
+	    elif show_status "$template_module" "$template_version" "$kernelver" "$arch" 2>/dev/null | grep -q ": built"; then
+		echo $""
+		echo $"This module/version combo is built.  Installing it:"
+		module="$template_module"
+		module_version="$template_version"
+		install_module
+	    else
+		echo $""
+		echo $"Building & Installing this module/version:"
+		module="$template_module"
+		module_version="$template_version"
+		build_module
+		install_module
+	    fi
+	done < <(echo "$template_kernel_status")
+
+	# Clean up the kernel tree
+	if [[ ! ( $(VER $kernelver) < $(VER 2.6.6) ) && \
+	    -d "$kernel_source_dir" && \
+	    ! -h "$kernel_source_dir" && \
+	    -z "$ksourcedir_fromcli" ]]; then
+	    echo $"Kernel cleanup unnecessary for this kernel.  Skipping..."
+	elif [[ ! $no_clean_kernel ]]; then
+	    cd "$kernel_source_dir"
+	    [[ $kerneldoth_contents ]] || invoke_command "make mrproper" "cleaning kernel tree (make mrproper)" background
+	    [[ $config_contents ]] && echo "$config_contents" > .config
+	    [[ $kerneldoth_contents ]] && echo "$kerneldoth_contents" > /boot/kernel.h
+	    cd - >/dev/null
+	fi
     fi
 
     # Done
     echo $""
-    echo $"DKMS: match Completed."
+    echo $"DKMS: match completed."
 }
 
 make_rpm()
 {
-    setup_kernels_arches "mkrpm"
-
     make_common_test "mkrpm"
 
     # Check that the rpmbuild command is present
     if ! which rpmbuild >/dev/null 2>&1 ; then
-        echo $"" >&2
-        echo $"Error! rpmbuild not present." >&2
-        echo $"Install the rpm-build package." >&2
-        exit 1
+	die 1 $"rpmbuild not present." \
+	    $"Install the rpm-build package."
     fi
 
     # Read the conf file
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}"
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"Your dkms.conf is not valid." >&2
-        exit 4
-    fi
+    read_conf_or_die "$kernelver" "$arch"
 
     local rpm_basedir="$dkms_tree/$module/$module_version/rpm"
 
     echo $""
-    if [ -e "$dkms_tree/$module/$module_version/source/$module-dkms-mkrpm.spec" ]; then
-        echo $"Using $dkms_tree/$module/$module_version/source/$module-dkms-mkrpm.spec"
-        SPECFILE="$dkms_tree/$module/$module_version/source/$module-dkms-mkrpm.spec"
-    elif [ -e "/etc/dkms/template-dkms-mkrpm.spec" ]; then
-        echo $"Using /etc/dkms/template-dkms-mkrpm.spec"
-        SPECFILE="/etc/dkms/template-dkms-mkrpm.spec"
-    else
-        echo $"" >&2
-        echo $"Cannot find /etc/dkms/template-dkms-mkrpm.spec which is needed by" >&2
-        echo $"DKMS in order use mkrpm." >&2
-        exit 5
-    fi
-
-    # Error out if binaries-only is set and source-only is set
-    if [ -n "$binaries_only" ] && [ -n "$source_only" ]; then
-        echo $"" >&2
-        echo $"Error!  You have specified both --binaries-only and --source-only." >&2
-        echo $"You cannot do this." >&2
-        exit 8
+    local sp
+    for sp in "$dkms_tree/$module/$module_version/source/$module-dkms-mkrpm.spec" \
+	"/etc/dkms/template-dkms-mkrpm.spec"; do
+	[[ -e $sp ]] || continue
+	SPECFILE="$sp"
+	break
+    done
+    if [[ ! $SPECFILE ]]; then
+	die 5 $"Cannot find $sp which is needed by" \
+	    $"DKMS in order use mkrpm."
     fi
 
     # Run a dkms mktarball for use in the rpm
     local mktarball_line
-    if [ ! -n "$source_only" ] || [ -n "$binaries_only" ]; then
-        mktarball_line="--binaries-only"
-        local i=0
-        echo $""
-        while [ $i -lt ${#kernelver_array[@]} ]; do
-            if ! [ -d "$dkms_tree/$module/$module_version/${kernelver_array[$i]}/${arch_array[$i]}" ]; then
-            echo $"" >&2
-            echo $"You do not seem to have $module $module_version built for" >&2
-            echo $"${kernelver_array[$i]} (${arch_array[$i]}).  All modules must be in" >&2
-            echo $"the built state before you can use mkrpm." >&2
-            exit 5
-            fi
-            echo $"Marking ${kernelver_array[$i]} (${arch_array[$i]}) for RPM..."
-            mktarball_line="-k ${kernelver_array[$i]} -a ${arch_array[$i]} $mktarball_line"
-            i=$(($i + 1))
-        done
+    if [[ ! $source_only || $binaries_only ]]; then
+	mktarball_line="--binaries-only"
+	local i
+	echo $""
+	for ((i=0; i<${#kernelver[@]}; i++)); do
+	    if ! [[ -d $dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]} ]]; then
+	    die 5 $"You do not seem to have $module $module_version built for" \
+		$"${kernelver[$i]} (${arch[$i]}).  All modules must be in" \
+		$"the built state before you can use mkrpm."
+	    fi
+	    echo $"Marking ${kernelver[$i]} (${arch[$i]}) for RPM..."
+	    mktarball_line="-k ${kernelver[$i]} -a ${arch[$i]} $mktarball_line"
+	done
     else
-        mktarball_line="none"
+	mktarball_line="none"
     fi
 
-    local RC=0
-    local temp_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
+    local temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
     trap 'rm -rf $temp_dir_name' EXIT HUP TERM
     mkdir -p ${temp_dir_name}/{BUILD,RPMS,SRPMS,SPECS,SOURCES}
     cp ${SPECFILE} ${temp_dir_name}/SPECS/dkms_mkrpm.spec
 
     #if using legacy mode, install common postinst
-    if [ "$legacy_postinst" != "0" ]; then
-        invoke_command "cp '$PREFIX/usr/lib/dkms/common.postinst' '${temp_dir_name}/SOURCES'" "copying legacy postinstall template"
+    if ((legacy_postinst != 0)); then
+	invoke_command "cp '$PREFIX/usr/lib/dkms/common.postinst' '${temp_dir_name}/SOURCES'" "copying legacy postinstall template"
     fi
 
     #Copy in the source tree
-    if [ ! -n "$binaries_only" ]; then
-        invoke_command "cp -Lpr '$dkms_tree/$module/$module_version/source' '${temp_dir_name}/SOURCES/$module-$module_version'" "Copying source tree"
+    if [[ ! $binaries_only ]]; then
+	invoke_command "cp -Lpr '$dkms_tree/$module/$module_version/source' '${temp_dir_name}/SOURCES/$module-$module_version'" "Copying source tree"
     fi
 
-    invoke_command "LC_ALL=C rpmbuild --define \"_topdir ${temp_dir_name}\" --define \"version $module_version\" --define \"module_name $module\" --define \"kernel_versions ${kernelver_array[*]}\" --define \"mktarball_line $mktarball_line\" --define \"__find_provides  /usr/lib/dkms/find-provides\" --define \"_use_internal_dependency_generator 0\" -ba ${temp_dir_name}/SPECS/dkms_mkrpm.spec > ${temp_dir_name}/rpmbuild.log 2>&1" "rpmbuild"
-    if [ "$?" -eq 0 ]; then
-        mkdir -p ${rpm_basedir}
-        cp -a ${temp_dir_name}/SRPMS/* ${temp_dir_name}/RPMS/*/* ${rpm_basedir}/
-        echo $""
-        cat ${temp_dir_name}/rpmbuild.log | grep ^Wrote | sed -e "s:${temp_dir_name}/:${rpm_basedir}/:" -e 's:SRPMS/::' -e 's:RPMS/.*/::'
-        echo $""
-        echo $"DKMS: mkrpm Completed."
+    if invoke_command "LC_ALL=C rpmbuild --define \"_topdir ${temp_dir_name}\" --define \"version $module_version\" --define \"module_name $module\" --define \"kernel_versions ${kernelver[*]}\" --define \"mktarball_line $mktarball_line\" --define \"__find_provides  /usr/lib/dkms/find-provides\" --define \"_use_internal_dependency_generator 0\" -ba ${temp_dir_name}/SPECS/dkms_mkrpm.spec > ${temp_dir_name}/rpmbuild.log 2>&1" "rpmbuild"; then
+	mkdir -p ${rpm_basedir}
+	cp -a ${temp_dir_name}/SRPMS/* ${temp_dir_name}/RPMS/*/* ${rpm_basedir}/
+	echo $""
+	cat ${temp_dir_name}/rpmbuild.log | grep ^Wrote | sed -e "s:${temp_dir_name}/:${rpm_basedir}/:" -e 's:SRPMS/::' -e 's:RPMS/.*/::'
+	echo $""
+	echo $"DKMS: mkrpm completed."
     else
-        echo $"" >&2
-        echo $"Error! There was a problem creating your rpm." >&2
-        cat ${temp_dir_name}/rpmbuild.log >&2
-        RC=7
+	cat ${temp_dir_name}/rpmbuild.log >&2
+	die 7 $"There was a problem creating your rpm."
     fi
     rm -rf $temp_dir_name
     trap > /dev/null 2>&1
-    [ ${RC} -ne 0 ] && exit ${RC}
 }
 
-function preproc_file()
+preproc_file()
 {
     local date_str="$(date -R)"
     echo "modifying $1..."
     sed -e "s/DEBIAN_PACKAGE/$debian_package/g" \
-        -e "s/MODULE_NAME/$module/g" \
-        -e "s/MODULE_VERSION/$module_version/g" \
-        -e "s/DATE_STAMP/$date_str/" "$1" > "$1.dkms-pp"
+	-e "s/MODULE_NAME/$module/g" \
+	-e "s/MODULE_VERSION/$module_version/g" \
+	-e "s/DATE_STAMP/$date_str/" "$1" > "$1.dkms-pp"
     mv "$1.dkms-pp" "$1"
 }
 
-function make_debian_test_depends()
+# Install a package on a debian system.
+debian_install()
 {
-    INSTALL_PACKAGES=""
-    # Check that the fakeroot command is present
-    if ! which fakeroot >/dev/null 2>&1 ; then
-        INSTALL_PACKAGES="fakeroot $INSTALL_PACKAGES"
-    fi
-
-    # Check that the dh_make command is present
-    if ! which dpkg-buildpackage >/dev/null 2>&1 ; then
-        INSTALL_PACKAGES="dpkg-dev $INSTALL_PACKAGES"
+    local getroot  tmpfile i
+    local -a packages=("$@")
+    for ((i=0; i < ${#packages[@]}; i++)); do
+	dpkg-query -s "${packages[$i]}"| egrep -q '^Status:.* installed$' || continue
+	unset package[$i]
+    done
+    # if they are already installed, we are OK.
+    [[ ${package[@]} ]] || return
+    if ((UID != 0)); then
+	# figure out how to get root
+	for getroot in su-to-root gksudo kdesu sudo; do
+	    which $getroot >/dev/null 2>&1 || continue
+	    case $getroot in
+		su-to-root) getroot="$getroot -c";;
+		gksudo) [[ $DISPLAY ]] || continue
+		    getroot="$getroot --description 'DKMS Debian package builder' ";;
+		kdesu) [[ $DISPLAY ]] || continue;;
+	    esac
+	    break
+	done
+    fi
+    if [[ -x /usr/sbin/synaptic && $DISPLAY ]] && tmpfile=$(mktemp_or_die); then
+	# Pretty GUI install.
+	trap 'rm -f "$tmpfile"' EXIT
+	for ((i=0; i=${#packages[@]}; i++)); do
+	    [[ ${packages[$i]} ]] && echo "install ${packages[$i]}" >>$tmpfile
+	done
+	$getroot "sh -c '/usr/sbin/synaptic --set-selections --non-interactive --hide-main-window < $tmpfile'"
+    else
+	$getroot apt-get -y install "${packages[@]}"
+    fi
+    if (( $? != 0)); then
+	die 4 $"Missing ${packages[@]}" \
+	    $"and unable to install.  Please ask an admin to install for you."
     fi
-    echo "$INSTALL_PACKAGES"
 }
 
-function make_debian()
+make_debian()
 {
     create_type="$1"
 
@@ -3262,115 +2860,58 @@
 
     make_common_test "mk${create_type}"
 
-    debian_package=$(echo $module | sed s/_/-/g)
-
-    SYNAPTIC=""
-    #Synaptic availablity
-    if [ -x /usr/sbin/synaptic ]; then
-        SYNAPTIC="TRUE"
-    fi
-
-    #test who we are
-    ROOT=""
-    if [ "$USER" != "root" ]; then
-        if [ -x /usr/sbin/su-to-root ]; then
-            ROOT="/usr/sbin/su-to-root -c"
-        elif [ -x /usr/bin/gksudo ] && [ ! -z "$DISPLAY" ]; then
-            ROOT="/usr/bin/gksudo --description 'DKMS Debian package builder' "
-        elif [ -x /usr/bin/kdesu ] && [ ! -z "$DISPLAY" ]; then
-            ROOT="/usr/bin/kdesu"
-        elif [ -x /usr/bin/sudo ]; then
-            ROOT="/usr/bin/sudo"
-        fi
-    fi
+    debian_package=${module//_/-}
 
     # Read the conf file
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}"
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"Your dkms.conf is not valid." >&2
-        exit 4
-    fi
-
-    #test if we are missing dependencies that are needed during package build
-    INSTALL_PACKAGES="`make_debian_test_depends`"
-    if [ ! -z "$INSTALL_PACKAGES" ]; then
-        if [ -z "$ROOT" ]; then
-            echo $"" >&2
-            echo $"Error! Missing $INSTALL_PACKAGES" >&2
-            echo $"and unable to install.  Please ask an admin to install for you." >&2
-            exit 4
-        fi
-        if [ ! -z "$SYNAPTIC" ] && [ ! -z "$DISPLAY" ]; then
-            local TEMPFILE=`/bin/tempfile`
-            echo $INSTALL_PACKAGES | sed 's/|/\ install\/g' > $TEMPFILE
-            $ROOT "sh -c '/usr/sbin/synaptic --set-selections --non-interactive --hide-main-window < $TEMPFILE'"
-            trap "rm -f $TEMPFILE; delete_temporary_trees" EXIT HUP TERM
-        else
-            $ROOT apt-get -y install $INSTALL_PACKAGES
-        fi
-
-        INSTALL_PACKAGES="`make_debian_test_depends`"
-        #Retest packages
-        if [ ! -z "$INSTALL_PACKAGES" ]; then
-            echo $"" >&2
-            echo $"Error! Missing $INSTALL_PACKAGES" >&2
-            echo $"and unable to install.  Please ask an admin to install for you." >&2
-            exit 4
-        fi
-    fi
+    read_conf_or_die "$kernelver" "$arch"
+    debian_install fakeroot dpkg-dev debhelper
 
     #skeleton to load templates from
     local system_mk="$dkms_tree/$module/$module_version/source/$module-dkms-mk${create_type}"
     local local_mk="/etc/dkms/template-dkms-mk${create_type}"
-    if [ -e "${system_mk}" ]; then
-        echo $"Using ${system_mk}"
-        DEBDIR=${system_mk}
-    elif [ -e "${local_mk}" ]; then
-        echo $"Using ${local_mk}"
-        DEBDIR=${local_mk}
+    if [[ -e ${system_mk} ]]; then
+	echo $"Using ${system_mk}"
+	DEBDIR=${system_mk}
+    elif [[ -e ${local_mk} ]]; then
+	echo $"Using ${local_mk}"
+	DEBDIR=${local_mk}
     else
-        echo $"" >&2
-        echo $"Cannot find ${local_mk} which is needed by" >&2
-        echo $"DKMS in order to use mk${create_type}." >&2
-        exit 5
+	die 5 $"Cannot find ${local_mk} which is needed by" \
+	    $"DKMS in order to use mk${create_type}."
     fi
 
     #prepare build directory and copy template
-    local temp_dir=`mktemp -d $tmp_location/dkms.XXXXXX`
+    local temp_dir=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
     trap "rm -rf $temp_dir; delete_temporary_trees" EXIT HUP TERM
     local temp_dir_debian="$temp_dir/$debian_package-dkms-$module_version"
     invoke_command "cp -ar '$DEBDIR/' '$temp_dir_debian'" "copying template"
     pushd "$temp_dir_debian" > /dev/null 2>&1
     for file in debian/*; do
-        preproc_file "$file"
-        chmod 755 "$file"
+	preproc_file "$file"
+	chmod 755 "$file"
     done
     popd > /dev/null 2>&1
 
-    #if using legacy mode, install common postinst
-    if [ "$legacy_postinst" != "0" ]; then
-        invoke_command "cp '$PREFIX/usr/lib/dkms/common.postinst' '$temp_dir_debian'" "copying legacy postinstall template"
+     #if using legacy mode, install common postinst
+    if ((legacy_postinst != 0)); then
+	invoke_command "cp '$PREFIX/usr/lib/dkms/common.postinst' '$temp_dir_debian'" "copying legacy postinstall template"
     fi
 
     #Copy in the source tree
-    if [ ! -n "$binaries_only" ]; then
-        invoke_command "cp -Lpr '$dkms_tree/$module/$module_version/source' '$temp_dir_debian/$module-$module_version'" "Copying source tree"
+    if [[ ! $binaries_only ]]; then
+	invoke_command "cp -Lpr '$dkms_tree/$module/$module_version/source' '$temp_dir_debian/$module-$module_version'" "Copying source tree"
     fi
 
     #Only if we are shipping binary modules, make a .tgz for the deb
-    local archive_location="$module-$module_version.dkms.tar.gz"
-    if [ ! -n "$source_only" ]; then
-        binaries_only="binaries-only"
-        invoke_command "make_tarball" "Gathering binaries"
-        if [ -f $dkms_tree/$module/$module_version/tarball/$archive_location ]; then
-            invoke_command "cp '$dkms_tree/$module/$module_version/tarball/$archive_location' '$temp_dir_debian'" "Copying DKMS tarball into DKMS tree"
-        else
-            echo $"" >&2
-            echo $"Error! Unable to find created tarball." >&2
-            exit 12
-        fi
+    local archive_location="$dkms_tree/$module/$module_version/tarball/$module-$module_version.dkms.tar.gz"
+    if [[ ! $source_only ]]; then
+	binaries_only="binaries-only"
+	invoke_command "make_tarball" "Gathering binaries"
+	if [[ -f $archive_location ]]; then
+	    invoke_command "cp '$archive_location' '$temp_dir_debian'" "Copying DKMS tarball into DKMS tree"
+	else
+	    die 12 $"Unable to find created tarball."
+	fi
     fi
 
     #calculate destination directory
@@ -3380,100 +2921,52 @@
     #create deb
     pushd "$temp_dir_debian" > /dev/null 2>&1
     case "$create_type" in
-        dsc)
-            invoke_command "dpkg-buildpackage -S -us -uc 1>/dev/null" "Building source package"
-            if [ "$?" -eq 0 ]; then
-                echo $""
-                echo $"DKMS: mk${create_type} Completed."
-            else
-                echo $"" >&2
-                echo $"Error! There was a problem creating your ${create_type}." >&2
-                exit 7
-            fi
-            invoke_command "mv '$temp_dir/${debian_package}-dkms_${module_version}.dsc' '$temp_dir/${debian_package}-dkms_${module_version}.tar.gz' '$deb_basedir'" "Moving built files to $deb_basedir"
-            ;;
-        deb)
-            invoke_command "dpkg-buildpackage -rfakeroot -d -b -us -uc 1>/dev/null" "Building binary package"
-            if [ "$?" -eq 0 ]; then
-                echo $""
-                echo $"DKMS: mk${create_type} Completed."
-            else
-                echo $"" >&2
-                echo $"Error! There was a problem creating your ${create_type}." >&2
-                exit 7
-            fi
-
-            invoke_command "mv '$temp_dir/${debian_package}-dkms_${module_version}_all.deb' '$deb_basedir'" "Moving built files to $deb_basedir"
-            ;;
+	dsc)
+	    invoke_command "dpkg-buildpackage -S -us -uc 1>/dev/null" "Building source package" || \
+		die 7 $"There was a problem creating your ${create_type}."
+	    echo $""
+	    echo $"DKMS: mk${create_type} completed."
+	    invoke_command "mv '$temp_dir/${debian_package}-dkms_${module_version}_source.changes' '$temp_dir/${debian_package}-dkms_${module_version}.dsc' '$temp_dir/${debian_package}-dkms_${module_version}.tar.gz' '$deb_basedir'" "Moving built files to $deb_basedir"
+	    ;;
+	deb)
+	    invoke_command "dpkg-buildpackage -rfakeroot -d -b -us -uc 1>/dev/null" "Building binary package" || \
+		die 7 $"There was a problem creating your ${create_type}."
+	    echo $""
+	    echo $"DKMS: mk${create_type} completed."
+	    invoke_command "mv '$temp_dir/${debian_package}-dkms_${module_version}_all.deb' '$deb_basedir'" "Moving built files to $deb_basedir"
+	    ;;
     esac
     popd > /dev/null 2>&1
 
     if in_temporary_trees; then
-        echo "Copying built files to "`pwd`"/.." >&2
-        cp "$dkms_tree/$module/$module_version/deb/"* ..
+	echo "Copying built files to "`pwd`"/.." >&2
+	cp "${deb_basedir}/"* ..
     fi
 
     #cleanup
     invoke_command "rm $temp_dir -fr" "Cleaning up temporary files"
-    delete_temporary_trees
-
-    #done
-    if [ "$?" -ne 0 ]; then
-        echo $"" >&2
-        echo $"Error! There was a problem cleaning up temporary files." >&2
-        exit 7
-    fi
+    delete_temporary_trees || \
+	die 7 $"There was a problem cleaning up temporary files."
 }
 
-function make_common_test()
+make_common_test()
 {
     local create_type=$1
     # Error if $module_version is set but $module is not
-    if [ -z "$module" ] || [ -z "$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! Invalid number of parameters passed." >&2
-        echo $"Usage: $create_type -m <module> -v <module-version>" >&2
-        exit 1
-    fi
+    check_module_args $create_type
 
     # Check that source symlink works
-    if ! [ -d "$dkms_tree/$module/$module_version/source" ]; then
-        echo $"" >&2
-        echo $"Error! DKMS tree does not contain: $module-$module_version" >&2
-        echo $"Build cannot continue without the proper tree." >&2
-        exit 2
-    fi
+    check_module_exists
 
     # Make sure that its installed in the first place
-    if ! [ -d "$dkms_tree/$module/$module_version" ]; then
-        echo $"" >&2
-        echo $"Error! The module/version combo: $module-$module_version" >&2
-        echo $"is not located in the DKMS tree." >&2
-        exit 3
-    fi
-
-    # Error out if archive_location is set and contains a "/" in it
-    case "$archive_location" in
-        */*)
-        echo $"" >&2
-        echo $"Error!  The name you have specified for your archive contains a '/'." >&2
-        echo $"You may only specify a simple filename with no preceding path."
-        exit 7
-        ;;
-    esac
-
-    # Error out if binaries-only is set and source-only is set
-    if [ -n "$binaries_only" ] && [ -n "$source_only" ]; then
-        echo $"" >&2
-        echo $"Error!  You have specified both --binaries-only and --source-only." >&2
-        echo $"You cannot do this." >&2
-        exit 8
-    fi
+    [[ -d $dkms_tree/$module/$module_version ]] ||
+	die 3 $"The module/version combo: $module-$module_version" \
+	    $"is not located in the DKMS tree."
 }
 
-function make_kmp_srpm()
+make_kmp_srpm()
 {
-    local temp_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
+    local temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
     trap 'rm -rf $temp_dir_name' EXIT HUP TERM
     mkdir -p $temp_dir_name/{BUILD,RPMS,SRPMS,SPECS,SOURCES}
     pushd "$dkms_tree/$module/$module_version" > /dev/null 2>&1
@@ -3484,16 +2977,16 @@
     rm -rf ${module}-${module_version}
     popd > /dev/null 2>&1
     pushd "$temp_dir_name" > /dev/null 2>&1
-    invoke_command "rpmbuild --define \"_topdir ${temp_dir_name}\" --target=${arch_array[0]} -bs ${SPECFILE} > ${temp_dir_name}/rpmbuild.log 2>&1" "rpmbuild"
+    invoke_command "rpmbuild --define \"_topdir ${temp_dir_name}\" --target=$arch -bs ${SPECFILE} > ${temp_dir_name}/rpmbuild.log 2>&1" "rpmbuild"
     grep ^Wrote $temp_dir_name/rpmbuild.log > /dev/null 2>&1
     local RC="$?"
-    if [ "${RC}" -eq 0 ]; then
-        local kmp_basedir="$dkms_tree/$module/$module_version/rpm"
-        mkdir -p $kmp_basedir
-        RPMS=`LANG=C cp -va ${temp_dir_name}/SRPMS/* $kmp_basedir | awk '{print $NF}'`
+    if ((RC == 0)); then
+	local kmp_basedir="$dkms_tree/$module/$module_version/rpm"
+	mkdir -p $kmp_basedir
+	RPMS=$(LANG=C cp -va ${temp_dir_name}/SRPMS/* $kmp_basedir | awk '{print $NF}')
     else
-        echo $"rpmbuild error log:"
-        cat $temp_dir_name/rpmbuild.log
+	echo $"rpmbuild error log:"
+	cat $temp_dir_name/rpmbuild.log
     fi
     popd > /dev/null 2>&1
     rm -rf $temp_dir_name
@@ -3501,60 +2994,335 @@
     return ${RC}
 }
 
-function report_build_problem()
+report_build_problem()
 {
     #If apport is on the system, files a build problem
     if [ -x /usr/share/apport/apport ] && which python>/dev/null; then
-        python /usr/share/apport/package-hooks/dkms.py -m $module -v $module_version
+	python /usr/share/apport/package-hooks/dkms_packages.py -m $module -v $module_version -k ${kernelver[0]}
     fi
+    die "$@"
 }
 
+# Little helper function for reading args from the commandline.
+# it automatically handles -a b and -a=b variants, and returns 1 if
+# we need to shift $3.
+read_arg() {
+    # $1 = arg name
+    # $2 = arg value
+    # $3 = arg parameter
+    local rematch='^[^=]*=(.*)$'
+    if [[ $2 =~ $rematch ]]; then
+	read "$1" <<< "${BASH_REMATCH[1]}"
+    else
+	read "$1" <<< "$3"
+	# There is no way to shift our callers args, so
+	# return 1 to indicate they should do it instead.
+	return 1
+    fi
+}
 
-function make_kmp()
-{
-    setup_kernels_arches "mkkmp"
+# A couple of helper functions for parsing out our most common arguments.
+# This one allows you to pass -k kernel.version-extra/arch instead of
+# -k kernel-version.extra -a arch.
+# This makes it harder to pass mismatching numbers of kernel/arch pairs, because
+# they are all passed at the same time.
+parse_kernelarch(){
+    if [[ $1 =~ $mv_re ]]; then
+	kernelver[${#kernelver[@]}]="${BASH_REMATCH[1]}"
+	arch[${#arch[@]}]="${BASH_REMATCH[2]}"
+    else
+	kernelver[${#kernelver[@]}]="$1"
+    fi
+}
+
+# This allows you to pass module and module_version information on the commandline
+# in a more convienent form.  Instead of the mostly mandatory and annoying
+# -m module -v module_version, you can use either -m module/module_version, 
+# or just a raw module/module_version with no -m parameter.  
+# This vastly improves readability and discoverability of
+# commands on the commandline.
+parse_moduleversion(){
+    if [[ $1 =~ $mv_re ]]; then
+	module="${BASH_REMATCH[1]}"
+	module_version="${BASH_REMATCH[2]}"
+    else
+	module="$1"
+    fi
+}
+
+check_root() {
+    ((UID == 0)) && return
+    die 1 $"You must be root to use this command."
+}
+
+# Add a passed source tree to the default source location.
+# We will check the dkms.conf file to make sure it is valid
+# beforehand.
+add_source_tree() {
+    local from=$(readlink -f $1)
+    if ! [[ $from && -f $from/dkms.conf ]]; then
+	die 9 $"$1 must contain a dkms.conf file!"
+    fi
+    check_root
+    setup_kernels_arches
+    if ! get_pkginfo_from_conf "$from/dkms.conf" ; then
+	die 10 $"Malformed dkms.conf file. Cannot load source tree."
+    fi
+    module="$PACKAGE_NAME"
+    module_version="$PACKAGE_VERSION"
+    if [[ $force && -d $source_tree/$module-$module_version ]]; then
+	echo >&2
+	echo $"Forcing install of $module-$module_version"
+	rm -rf "$source_tree/$module-$module_version"
+    fi
 
+    # We are already installed, just return.
+    case $from in
+	"$source_tree/$module-$module_version") return;;
+	"$dkms_tree/$module/$version/source") return;;
+	"$dkms_tree/$module/$version/build") return;;
+    esac
+    mkdir -p "$source_tree/$module-$module_version"
+    cp -fr "$from"/* "$source_tree/$module-$module_version"
+}
+
+make_kmp()
+{
     make_common_test "mkkmp"
 
     # Read the conf file
-    read_conf "${kernelver_array[0]}" "${arch_array[0]}"
-    if [ "$?" -ne 0 ]; then
+    read_conf_or_die "$kernelver" "$arch"
+
+    echo $""
+    if [[ $specfile && -e $dkms_tree/$module/$module_version/source/$specfile ]]; then
+	echo $"Using $dkms_tree/$module/$module_version/source/$specfile"
+	SPECFILE="$dkms_tree/$module/$module_version/source/$specfile"
+    elif [[ -e $dkms_tree/$module/$module_version/source/$module-kmp.spec ]]; then
+	echo $"Using $dkms_tree/$module/$module_version/source/$module-kmp.spec"
+	SPECFILE="$dkms_tree/$module/$module_version/source/$module-kmp.spec"
+    else
+	die 5 $"Cannot find a suitable spec file which is needed by" \
+	    $"DKMS in order use mkkmp.  Please specify --spec=specfile."
+    fi
+
+    prepare_build
+    make_kmp_srpm
+    RC=$?
+    clean_build
+
+    if ((RC == 0)); then
+	echo $""
+	echo $"KMP SRPM location: $RPMS"
+	echo $""
+	echo $"DKMS: mkkmp completed."
+    else
+	die 7 $"There was a problem creating your KMP source rpm."
+    fi
+    # FIXME: hand SRPM to mock or build system to build
+}
+
+# This code used to be in dkms_autoinstaller.
+# Moving it into the main dkms script gets rid of a fair amount of duplicate
+# functionality, and makes it much easier to reinstall DKMS kernel modules
+# by hand if dkms_autoinstaller is not used.
+autoinstall() {
+    local status mv mvka m v k a last_v last_m tenative
+    local -a to_install=()
+    # Walk through our list of installed and built modules, and create
+    # a list of modules that need to be reinstalled.
+    while read status mvka; do
+        IFS='/' read m v k a <<< "$mvka"
+        [[ ! $last_m ]] && last_m="$m"
+        # If the module is already installed or weak-installed, skip it.
+        _is_module_installed "$m" "$v" "$kernelver" "$arch" && continue
+        module_status_weak "$m" "$v" "$kernelver" "$arch" >/dev/null && continue
+        # if the module does not want to be autoinstalled, skip it.
+        read_conf_or_die "$k" "$a" "$dkms_tree/$m/$v/source/dkms.conf"
+        if [[ ! $AUTOINSTALL ]]; then
+            continue
+        # otherwise, only autoinstall the latest version we have hanging around.
+        elif [[ $last_m != $m ]]; then
+            last_m="$m"
+            last_v='0'
+            [[ $tenative ]] && to_install[${#to_install[@]}]="$tenative"
+            tenative=''
+        fi
+        if [[ ($(VER $v) > $(VER $last_v)) ]]; then
+            last_v="$v"
+            tenative="$m/$v"
+        fi
+    done < <(module_status)
+    # We may have exited the loop with $tenative set.  If it is,
+    # it contains something that should be updated.
+    [[ $tenative ]] && to_install[${#to_install[@]}]="$tenative"
+    [[ $to_install ]] || return 0
+    # Install modules that need to be updated in parallel.
+    for mv in "${to_install[@]}"; do
+        IFS=/ read m v <<< "$mv"
+        (module="$m"; module_version="$v"; install_module) &
+    done
+    wait
+}
+
+function make_redhat3_driver_disk ()
+{
+    # Check that the rpmbuild command is present
+    if ! which rpmbuild >/dev/null 2>&1 ; then
+        echo $"" >&2
+        echo $"Error! rpmbuild not present." >&2
+        echo $"Install the rpm-build package." >&2
+        exit 1
+    fi
+
+    local kmodtool=$(rpm -ql redhat-rpm-config | grep kmodtool)
+    #Check that the kmodtool is present
+    if [ -z "$kmodtool" ]; then
+        echo $"Error! kmodtool not present." >&2
+        echo $"Install redhat-rpm-config package." >&2
+        exit 1
+    fi
+
+    # Check that the createrepo command is present
+    if ! which createrepo >/dev/null 2>&1 ; then
         echo $"" >&2
-        echo $"Error! Bad conf file." >&2
-        echo $"Your dkms.conf is not valid." >&2
-        exit 4
+        echo $"Error! createrepo not present." >&2
+        echo $"Install the createrepo package." >&2
+        exit 1
     fi
 
     echo $""
     if [ -n "$specfile" -a -e "$dkms_tree/$module/$module_version/source/$specfile" ]; then
         echo $"Using $dkms_tree/$module/$module_version/source/$specfile"
         SPECFILE="$dkms_tree/$module/$module_version/source/$specfile"
-    elif [ -e "$dkms_tree/$module/$module_version/source/$module-kmp.spec" ]; then
-        echo $"Using $dkms_tree/$module/$module_version/source/$module-kmp.spec"
-        SPECFILE="$dkms_tree/$module/$module_version/source/$module-kmp.spec"
+    elif [ -e "/etc/dkms/template-dkms-redhat-kmod.spec" ]; then
+        echo $"Using /etc/dkms/template-dkms-redhat-kmod.spec"
+        SPECFILE="/etc/dkms/template-dkms-redhat-kmod.spec"
     else
         echo $"" >&2
-        echo $"Cannot find a suitable spec file which is needed by" >&2
-        echo $"DKMS in order use mkkmp.  Please specify --spec=specfile." >&2
+        echo $"Cannot find /etc/dkms/template-dkms-redhat-kmod.spec which is needed by" >&2
+        echo $"DKMS in order to make Redhat driver disk v3." >&2
         exit 5
     fi
+    # Set up temporary build directory for build
+    rm -rf "$dkms_tree/$module/$module_version/build"
+    cp -rf "$dkms_tree/$module/$module_version/source/" "$dkms_tree/$module/$module_version/build"
 
-    prepare_build
-    make_kmp_srpm
-    RC=$?
-    clean_build
+    cd "$dkms_tree/$module/$module_version/build"
 
-    if [ "$RC" -eq 0 ]; then
-        echo $""
-        echo $"KMP SRPM location: $RPMS"
+    # Run the pre_build script
+    if [ -n "$pre_build" ] && [ -x `echo "$dkms_tree/$module/$module_version/source/$pre_build" | sed 's/ .*//'` ]; then
         echo $""
-        echo $"DKMS: mkkmp Completed."
-    else
-        echo $"" >&2
-        echo $"Error! There was a problem creating your KMP source rpm." >&2
-        exit 7
+        echo $"Running the pre_build script:"
+        $dkms_tree/$module/$module_version/build/$pre_build
     fi
-    # FIXME: hand SRPM to mock or build system to build
+
+    # Apply any patches
+    local index=0
+    while [ $index -lt ${#patch_array[@]} ]; do
+        if ! [ -e "$dkms_tree/$module/$module_version/build/patches/${patch_array[$index]}" ]; then
+            echo $"" >&2
+            echo $"Error!  Patch ${patch_array[$index]} as specified in dkms.conf cannot be" >&2
+            echo $"found in $dkms_tree/$module/$module_version/build/patches/." >&2
+            exit 5
+        fi
+        invoke_command "patch -p1 < ./patches/${patch_array[$index]}" "applying patch ${patch_array[$index]}"
+        if [ "$?" -ne 0 ]; then
+            echo $"" >&2
+            echo $"Error! Application of patch ${patch_array[$index]} failed." >&2
+            echo $"Check $dkms_tree/$module/$module_version/build/ for more information." >&2
+                report_build_problem
+            exit 6
+        fi
+        index=$(($index+1))
+    done
+    # Create temp dirs and copy files for build
+    local temp_dir_name=`mktemp -d $tmp_location/dkms.XXXXXX`
+    trap 'rm -rf $temp_dir_name' EXIT HUP TERM
+    mkdir -p ${temp_dir_name}/{disk,BUILD,RPMS,SRPMS,SPECS,SOURCES}
+    cp ${SPECFILE} ${temp_dir_name}/SPECS/$module.spec
+    cp -rax $dkms_tree/$module/$module_version/build/ $temp_dir_name/SOURCES/$module-$module_version/
+    # Clean the build directory
+    rm -rf "$dkms_tree/$module/$module_version/build/*"
+    cd $temp_dir_name/SOURCES
+    invoke_command "tar -jcvf $temp_dir_name/SOURCES/$module-$module_version.tar.bz2 $module-$module_version/" "creating source tarball"
+    local i=0
+    #Build RPMS
+    while [ $i -lt ${#kernelver[@]} ]; do
+        invoke_command "LC_ALL=C rpmbuild --define \"_topdir ${temp_dir_name}\" --define \"version $module_version\" --define \"module_name $module\" --define \"kernel_version ${kernelver[$i]}\" -bb --target ${arch[$i]} ${temp_dir_name}/SPECS/$module.spec > ${temp_dir_name}/rpmbuild.log 2>&1" "rpmbuild"
+        if [ "$?" -ne 0 ]; then
+            echo $"" >&2
+            echo $"Error! There was a problem creating your kmod." >&2
+            cat ${temp_dir_name}/rpmbuild.log >&2
+            exit 7
+        fi
+        local kabi_whitelist=`rpm -ql kabi-whitelists | grep ${arch[$i]}`
+        if [ $kabi_whitelist ]; then
+            local module_file=`rpm -qlp ${temp_dir_name}/RPMS/${arch[$i]}/kmod-${module}-${module_version}* | grep ${module}.ko`
+            cd ${temp_dir_name}/
+            rpm2cpio ${temp_dir_name}/RPMS/${arch[$i]}/kmod-${module}-${module_version}* | cpio -id --quiet .${module_file}
+            cd - > /dev/null
+            local mod_symbols=( $(modprobe --dump-modversions ${temp_dir_name}/${module_file} | cut -f2) )
+            local miss_sym_count=0
+            local missing_symbols
+            for ((i=0; i < "${#mod_symbols[@]}"; i++))
+            do
+               if [ -z "`grep -o ${mod_symbols[${i}]} ${kabi_whitelist}`" ]; then
+                   missing_symbols[$miss_sym_count]="${mod_symbols[${i}]}"
+                   miss_sym_count=$(($miss_sym_count+1))
+               fi
+            done
+            if [ $miss_sym_count -ne 0 ]; then
+                echo $"" >&2
+                echo $"WARNING: ${module}-${module_version} is using following kernel symbols that are not in the ABI whitelist:"
+                echo $"----------------------------------"
+                for missing_symbol in ${missing_symbols[*]}
+                do
+                    echo "$missing_symbol"
+                done
+                echo $"----------------------------------"
+                echo $"" >&2
+            else
+                echo $"NOTICE: ${module}-${module_version} module seems to use only official Red Hat ABI."
+            fi
+        else
+            echo $"WARNING:${module}-${module_version} module is not checked against Red Hat ABI whitelist."
+            echo $"Install 'kabi-whitelists' package and build driver disk again to run the ABI compliance test."
+        fi    
+        i=$(($i + 1))
+    done
+
+    i=0
+    while [ $i -lt ${#arch[@]} ]; do
+        invoke_command "createrepo --pretty ${temp_dir_name}/RPMS/${arch[$i]}" "creating repo"
+        if [ "$?" -ne 0 ]; then
+            echo $"" >&2
+            echo $"Error! There was a problem creating repository." >&2
+            exit 7
+        fi
+        i=$(($i + 1))
+    done
+
+    echo "$module-$module_version driver disk" > "${temp_dir_name}/disk/rhdd3"
+    mkdir ${temp_dir_name}/disk/rpms
+    cp -rax ${temp_dir_name}/RPMS/* ${temp_dir_name}/disk/rpms/
+
+    local suffix="$(driver_disk_suffix)"
+    local image_dir="$dkms_tree/$module/$module_version/driver_disk"
+    local image_name="$module-$module_version-dd.$suffix"
+    echo $""
+    echo $"Creating driver disk on $media media:"
+    cd "${temp_dir_name}/disk"
+    mkdir -p "$image_dir"
+    rm -f "$image_dir/$image_name"
+    make_driver_disk_media "$image_dir/$image_name" "${temp_dir_name}/disk"
+    rm -rf $temp_dir_name
+
+    echo $""
+    echo $"Disk image location: $image_dir/$image_name"
+    echo $""
+    echo $"DKMS: mkdriverdisk completed."
+    
+    trap > /dev/null 2>&1
 }
 
 #############################
@@ -3563,22 +3331,8 @@
 ####                     ####
 #############################
 
-# Set Path
-case ":$PATH:" in
-:/usr/sbin:)
-    ;;
-*)
-    PATH="$PATH:/usr/sbin"
-    ;;
-esac
-case ":$PATH:" in
-:/sbin:)
-    ;;
-*)
-    PATH="$PATH:/sbin"
-    ;;
-esac
-PATH="$PATH:/usr/lib/dkms"
+# Set a standard path
+PATH="/bin:/sbin:/usr/bin:/usr/sbin:/usr/lib/dkms"
 
 # Ensure files and directories we create are readable to anyone,
 # since we aim to build as a non-root user
@@ -3588,22 +3342,23 @@
 unset CC CXX CFLAGS CXXFLAGS LDFLAGS
 
 # Set important variables
-current_kernel=`uname -r`
+current_kernel=$(uname -r)
+current_os=$(uname -s)
 dkms_tree="/var/lib/dkms"
 source_tree="/usr/src"
 install_tree="/lib/modules"
-tmp_location="/tmp"
+tmp_location=${TMPDIR:-/tmp}
 verbose=""
 dkms_frameworkconf="/etc/dkms/framework.conf"
 
 # these can come from the environment or the config file
-[ -z "${ADDON_MODULES_DIR}" -a -e /etc/sysconfig/module-init-tools ] && . /etc/sysconfig/module-init-tools
+[[ ! ${ADDON_MODULES_DIR} && -e /etc/sysconfig/module-init-tools ]] && . /etc/sysconfig/module-init-tools
 addon_modules_dir="${ADDON_MODULES_DIR}"
-[ -z "${addon_modules_dir}" ] && running_distribution="$(distro_version)"
+[[ ! ${addon_modules_dir} ]] && running_distribution="$(distro_version)"
 weak_modules="${WEAK_MODULES_BIN}"
 
 # Source in /etc/dkms_framework.conf
-. $dkms_frameworkconf 2>/dev/null
+[ -e $dkms_frameworkconf ] && . $dkms_frameworkconf 2>/dev/null
 
 # Clear out command line argument variables
 module=""
@@ -3629,304 +3384,135 @@
 size="1440";
 specfile=""
 legacy_postinst="1"
-unset directive_array
-unset kernelver_array
-unset arch_array
+declare -a directive_array=() kernelver=() arch=()
+weak_modules=''
+last_mvka=''
+last_mvka_conf=''
+try_source_tree=''
+die_is_fatal="yes"
+[ -x /sbin/weak-modules ] && weak_modules='/sbin/weak-modules'
+[ -x /usr/lib/module-init-tools/weak-modules ] && weak_modules='/usr/lib/module-init-tools/weak-modules'
+
+action_re='^(remove|(auto|un)?install|match|mk(driverdisk|tarball|rpm|deb|dsc|kmp)|build|add|status|ldtarball)$'
 
 # Parse command line arguments
-while [ $# -gt 0 ]; do
+while (($# > 0)); do
     case $1 in
-    --dkmsframework*)
-        if echo $1 | grep '=' >/dev/null ; then
-            dkms_frameworkconf=`echo $1 | sed 's/^.*=//'`
-        else
-            dkms_frameworkconf="$2"
-            shift
-        fi
-        #immediately load this config
-        . $dkms_frameworkconf 2> /dev/null
-        ;;
-    --module*|-m)
-        if echo $1 | grep '=' >/dev/null ; then
-            module=`echo $1 | sed 's/^.*=//'`
-        else
-            module="$2"
-            shift
-        fi
-        ;;
-    -v)
-        if echo $1 | grep '=' >/dev/null ; then
-            module_version=`echo $1 | sed 's/^.*=//'`
-        else
-            module_version="$2"
-            shift
-        fi
-        ;;
-    --kernelver*|-k)
-        if echo $1 | grep '=' >/dev/null ; then
-            kernelver_array[${#kernelver_array[@]}]=`echo $1 | sed 's/^.*=//'`
-        else
-            kernelver_array[${#kernelver_array[@]}]="$2"
-            shift
-        fi
-        ;;
-    --distro*|-d)
-        if echo $1 | grep '=' >/dev/null ; then
-            distro=`echo $1 | sed 's/^.*=//'`
-        else
-            distro="$2"
-            shift
-        fi
-        ;;
-    --media*)
-        if echo $1 | grep '=' >/dev/null ; then
-            media=`echo $1 | sed 's/^.*=//'`
-        else
-            media="$2"
-            shift
-        fi
-        ;;
-    --release*|-r)
-        if echo $1 | grep '=' >/dev/null ; then
-            release=`echo $1 | sed 's/^.*=//'`
-        else
-            release="$2"
-            shift
-        fi
-        ;;
-    --templatekernel*)
-        if echo $1 | grep '=' >/dev/null ; then
-            template_kernel=`echo $1 | sed 's/^.*=//'`
-        else
-            template_kernel="$2"
-            shift
-        fi
-        ;;
-    -c)
-        if echo $1 | grep '=' >/dev/null ; then
-            conf=`echo $1 | sed 's/^.*=//'`
-        else
-            conf="$2"
-            shift
-        fi
-        ;;
-    --quiet|-q)
-        exec >/dev/null 2>&1
-        ;;
-    --version|-V)
-        echo $"dkms: 2.1.1.2"
-        exit 0
-        ;;
-    --no-prepare-kernel)
-        no_prepare_kernel="no-prepare-kernel"
-        ;;
-    --no-clean-kernel)
-        no_clean_kernel="no-clean-kernel"
-        ;;
-    --binaries-only)
-        binaries_only="binaries-only"
-        ;;
-    --source-only)
-        source_only="source-only"
-        ;;
-    --force)
-        force="true"
-        ;;
-    --all)
-        all="true"
-        ;;
-    --verbose)
-        verbose="true"
-        ;;
-    --rpm_safe_upgrade)
-        rpm_safe_upgrade="true"
-        ;;
-    --dkmstree*)
-        if echo $1 | grep '=' >/dev/null ; then
-            dkms_tree=`echo $1 | sed 's/^.*=//'`
-        else
-            dkms_tree="$2"
-            shift
-        fi
-        ;;
-    --sourcetree*)
-        if echo $1 | grep '=' >/dev/null ; then
-            source_tree=`echo $1 | sed 's/^.*=//'`
-        else
-            source_tree="$2"
-            shift
-        fi
-        ;;
-    --installtree*)
-        if echo $1 | grep '=' >/dev/null ; then
-            install_tree=`echo $1 | sed 's/^.*=//'`
-        else
-            install_tree="$2"
-            shift
-        fi
-        ;;
-    --config*)
-        if echo $1 | grep '=' >/dev/null ; then
-            kernel_config=`echo $1 | sed 's/^.*=//'`
-        else
-            kernel_config="$2"
-            shift
-        fi
-        ;;
-    --archive*)
-        if echo $1 | grep '=' >/dev/null ; then
-            archive_location=`echo $1 | sed 's/^.*=//'`
-        else
-            archive_location="$2"
-            shift
-        fi
-        ;;
-    --legacy-postinst*)
-        if echo $1 | grep "=" >/dev/null ; then
-            legacy_postinst=`echo $1 | sed 's/^.*=//'`
-        else
-            legacy_postinst="$2"
-            shift
-        fi
-        ;;
-    --arch*|-a)
-        if echo $1 | grep '=' >/dev/null ; then
-            arch_array[${#arch_array[@]}]=`echo $1 | sed 's/^.*=//'`
-        else
-            arch_array[${#arch_array[@]}]="$2"
-            shift
-        fi
-        ;;
-    --size*)
-        if echo $1 | grep '=' >/dev/null ; then
-            size=`echo $1 | sed 's/^.*=//'`
-        else
-            size="$2"
-            shift
-        fi
-        ;;
-    --kernelsourcedir*)
-        if echo $1 | grep '=' >/dev/null ; then
-            kernel_source_dir=`echo $1 | sed 's/^.*=//'`
-        else
-            kernel_source_dir="$2"
-            shift
-        fi
-        ksourcedir_fromcli="true"
-        ;;
-    --directive*)
-        if echo $1 | grep '=' >/dev/null ; then
-            directive_array[${#directive_array[@]}]=`echo $1 | sed 's/[^=]\+=//'`
-        else
-            directive_array[${#directive_array[@]}]="$2"
-            shift
-        fi
-        ;;
-    --spec*)
-        if echo $1 | grep '=' >/dev/null ; then
-            specfile=`echo $1 | sed 's/^.*=//'`
-        else
-            specfile="$2"
-            shift
-        fi
-        ;;
-    -*|--*)
-        echo $"" >&2
-        echo $"Error!  Unknown option: $1" >&2
-        show_usage
-        exit 2
-        ;;
-    *)
-        action="$action $1"
-        ;;
+	--dkmsframework*)    read_arg dkms_frameworkconf "$1" "$2" || shift
+			     #immediately load this config
+			     . $dkms_frameworkconf 2> /dev/null;;
+	--module*|-m)        read_arg _mv "$1" "$2" || shift
+			     parse_moduleversion "$_mv";;
+	-v)                  read_arg module_version "$1" "$2" || shift;;
+	--kernelver*|-k)     read_arg _ka "$1" "$2" || shift
+			     parse_kernelarch "$_ka";;
+	--distro*|-d)        read_arg distro "$1" "$2" || shift;;
+	--media*)            read_arg media "$1" "$2" ||shift;;
+	--release*|-r)       read_arg release "$1" "$2" || shift;;
+	--templatekernel*)   read_arg template_kernel "$1" "$2" || shift;;
+	-c)                  read_arg conf "$1" "$2" || shift;;
+	--quiet|-q)          exec >/dev/null 2>&1;;
+	--version|-V)        echo $"dkms: 2.2.0.3"
+			     exit 0;;
+	--no-prepare-kernel) no_prepare_kernel="no-prepare-kernel";;
+	--no-clean-kernel)   no_clean_kernel="no-clean-kernel";;
+	--no-initrd)         no_initrd="no-initrd";;
+	--binaries-only)     binaries_only="binaries-only";;
+	--source-only)       source_only="source-only";;
+	--force)             force="true";;
+	--all)               all="true";;
+	--verbose)           verbose="true";;
+	--rpm_safe_upgrade)  rpm_safe_upgrade="true";;
+	--dkmstree*)         read_arg dkms_tree "$1" "$2" || shift;;
+	--sourcetree*)       read_arg source_tree "$1" "$2" || shift;;
+	--installtree*)      read_arg install_tree "$1" "$2" || shift;;
+	--config*)           read_arg kernel_config "$1" "$2" || shift;;
+	--archive*)          read_arg archive_location "$1" "$2" || shift;;
+	--legacy-postinst*)  read_arg legacy_postinst "$1" "$2" || shift;;
+	--arch*|-a)          read_arg _aa "$1" "$2" || shift
+			     arch[${#arch[@]}]="$_aa";;
+	--size*)             read_arg size "$1" "$2" || shift;;
+	--kernelsourcedir*)  read_arg kernel_source_dir "$1" "$2" || shift
+			     ksourcedir_fromcli="true";;
+	--directive*)        read_arg _da "$1" "$2" || shift
+			     directive_array[${#directive_array[@]}]="$_da";;
+	--spec*)             read_arg specfile "$1" "$2" || shift;;
+	--debug)
+	    export PS4='${BASH_SOURCE}@${LINENO}(${FUNCNAME[0]}): '
+	    set -x;;
+	-*|--*)              error $" Unknown option: $1"
+			     show_usage
+			     exit 2;;
+	*) if [[ $1 =~ $action_re ]]; then
+	    action="$action $1" # Add actions to the action list
+	    elif [[ -f $1 && $1 = *dkms.conf ]]; then
+	    try_source_tree="${1%dkms.conf}./" # Flag as a source tree
+	    elif [[ -d $1 && -f $1/dkms.conf ]]; then
+	    try_source_tree="$1" # ditto
+	    elif [[ -f $1 ]]; then
+	    archive_location="$1" # It is a file, assume it is an archive.
+	    elif [[ ! $module ]]; then
+	    parse_moduleversion "$1" # Assume it is a module/version pair.
+	    else
+	    warn $"I do not know how to handle $1."
+	    fi;;
     esac
     shift
 done
 
+# Sanity checking
+
+# Error out if binaries-only is set and source-only is set
+if [[ $binaries_only && $source_only ]]; then
+    die 8 $" You have specified both --binaries-only and --source-only." \
+	$"You cannot do this."
+fi
+
+# Error if # of arches doesn't match # of kernels
+if (( ${#kernelver[@]} != ${#arch[@]} && \
+    ${#arch[@]} > 1 )); then
+    die 1 $" If more than one arch is specified on the command line, then there" \
+	$"must be an equal number of kernel versions also specified (1:1 relationship)."
+fi
+
+# Check that kernel version and all aren't both set simultaneously
+if [[ $kernelver && $all ]]; then
+    die 2 $" You cannot specify a kernel version and also specify" \
+	$"--all on the command line."
+fi
+
+# Check that arch and all aren't both set simultaneously
+if [[ $arch && $all ]]; then
+    die 3 $" You cannot specify an arch and also specify" \
+	$"--all on the command line."
+fi
+
 # Run the specified action
 for action_to_run in $action; do
+    setup_kernels_arches "$action_to_run"
     case "$action_to_run" in
-    add)
-        add_module
-        ;;
-    remove)
-        # Make sure they're root
-        if [ `id -u` -ne 0 ]; then
-        echo $"You must be root to use this command." >&2
-        exit 1
-        fi
-        remove_module
-        ;;
-    build)
-        build_module
-        ;;
-    install)
-            # Make sure they're root
-        if [ `id -u` -ne 0 ]; then
-        echo $"You must be root to use this command." >&2
-        exit 1
-        fi
-        install_module
-        ;;
-    match)
-        # Make sure they're root
-        if [ `id -u` -ne 0 ]; then
-        echo $"You must be root to use this command." >&2
-        exit 1
-        fi
-        run_match
-        ;;
-    uninstall)
-        # Make sure they're root
-        if [ `id -u` -ne 0 ]; then
-        echo $"You must be root to use this command." >&2
-        exit 1
-        fi
-        uninstall_module
-        ;;
-    mkdriverdisk)
-        # Make sure they're root
-        if [ `id -u` -ne 0 ]; then
-        echo $"You must be root to use this command." >&2
-        exit 1
-        fi
-        make_driver_disk
-        ;;
-    mktarball)
-        make_tarball
-        ;;
-    mkrpm)
-        make_rpm
-        ;;
-    mkdeb)
-        make_debian "deb"
-        ;;
-    mkdsc)
-        make_debian "dsc"
-        ;;
-    mkkmp)
-        make_kmp
-        ;;
-    ldtarball)
-        # Make sure they're root if we're using --force
-        if [ `id -u` -ne 0 ] && [ "$force" == "true" ]; then
-        echo $"You must be root to use this command with the --force option." >&2
-        exit 1
-        fi
-        load_tarball
-        ;;
-    status)
-        show_status
-        ;;
-    "")
-        echo "" >&2
-        echo $"Error! No action was specified.">&2
-        show_usage
-        ;;
-    *)
-        echo "" >&2
-        echo $"Error! Unknown action specified: $action_to_run" >&2
-        show_usage
-        ;;
+	remove)       check_root && remove_module;;
+	install)      check_root && install_modules;;
+	autoinstall)  check_root && autoinstall;;
+	match)        check_root && have_one_kernel && run_match;;
+	uninstall)    check_root && have_one_kernel && uninstall_module;;
+	mkdriverdisk) check_root && make_driver_disk;;
+	build)        build_modules;;
+	add)          add_module;;
+	mktarball)    make_tarball;;
+	mkrpm)        make_rpm;;
+	mkdeb)        make_debian "deb";;
+	mkdsc)        make_debian "dsc";;
+	mkkmp)        have_one_kernel && make_kmp;;
+	status)       show_status;;
+	ldtarball) # Make sure they're root if we're using --force
+	    if ((UID != 0)) && [[ $force = true ]]; then
+		die 1 $"You must be root to use this command with the --force option."
+	    fi
+	    load_tarball && add_module;;
+	'') error $"No action was specified."
+	    show_usage;;
+	*)  error $"Unknown action specified: $action_to_run"
+	    show_usage;;
     esac
 done

dkms-2.1.1.2.tar.bz2/dkms.8 -> dkms-2.2.0.3.tar.bz2/dkms.8 Changed

@@ -3,46 +3,108 @@
 .SH NAME
 dkms \- Dynamic Kernel Module Support
 .SH SYNOPSIS
-.B dkms
-.I [action] [options]
+.SY dkms
+.OP action 
+.OP options
+.OP module/module-version
+.OP /path/to/source-tree
+.OP /path/to/tarball.tar
+.OP /path/to/driver.rpm
+.YS
 .SH DESCRIPTION
 .B dkms
 is a framework which allows kernel modules to be dynamically built
 for each kernel on your system in a simplified and organized fashion.
 .SH ACTIONS
-.TP
-.B add
-Adds a module/version combination to the tree for builds and installs.
-Requires source in
+.SY add
+.OP module/module\-version
+.OP /path/to/source\-tree
+.OP /path/to/tarball.tar
+.YS
+.IP "" 4
+Adds a module/module\-version combination to the tree for builds and installs.
+If module/module\-version, \-m module/module\-version, or \-m module\ \-v version are passed as options, this command
+requires source in
 .I /usr/src/<module>\-<module\-version>/
 as well as a properly
 formatted
 .I dkms.conf
-file.
-.TP
-.B remove
-Removes a module/version or module/version/kernel combination from the
-tree.  If the modules is currently installed, it first uninstalls it
+file. If 
+.I /path/to/source\-tree
+is passed as an option, and source-tree contains a 
+.I dkms.conf
+file, it will copy 
+.I /path/to/source\-tree
+to
+.I /usr/src/module\-module\-version.
+If 
+.I /path/to/tarball.tar
+is passed, this command behaves like the
+.B ldtarball
+command.
+.SY remove
+.OP module/module\-version
+.OP -k kernel/arch
+.OP \-\-all
+.YS
+.IP "" 4
+Removes a module/version or module/version/kernel/arch combination from the
+tree.  If the module is currently installed, it first uninstalls it
 and if applicable, will replace it with its original_module.  Use the
 .B \-\-all
 option in order to remove all instances for every kernel at once.
-.TP
-.B build
-Builds the specified module/version combo for the specified kernel. If
-no kernel is specified it builds for the currently running kernel.  All builds
+.SY build
+.OP module/module\-version
+.OP -k kernel/arch
+.YS
+.IP "" 4
+Builds the specified module/version combo for the specified kernel/arch. If
+the
+.I \-k
+option is not specified it builds for the currently running kernel and arch..  All builds
 occur in the directory
-.I /var/lib/dkms/<module>/<module\-version>/build/.
-.TP
-.B install
+.I /var/lib/dkms/<module>/<module\-version>/build/. 
+If the module/module\-version combo has not been added, dkms will try to add it, and in that
+case 
+.B build 
+can take the same arguments that 
+.B add
+can.
+.SY install
+.OP module/module\-version
+.OP -k kernel/arch
+.OP /path/to/driver.rpm
+.YS
+.IP "" 4
 Installs a built module/version combo onto the kernel it was built for. If
 the kernel option is not specified it assumes the currently running kernel.
-.TP
-.B uninstall
-Uninstalls an installed module/version combo from the kernel it was installed
+If the module has not been built, dkms will try to build it.
+If the module has not been added, dkms will try to add it.  In both cases, the
+.B install
+command can then take the same arguments as the
+.B build
+or
+.B add
+commands.
+If you pass a .rpm file, dkms will try to install that file with
+.B rpm -Uvh
+, and it will perform an
+.B autoinstall
+action to mesure that everything is built for your kernel if the RPM installed sucessfully.
+.SY uninstall
+.OP module/module\-version
+.OP -k kernel/arch
+.YS
+.IP "" 4
+Uninstalls an installed module/module\-version combo from the kernel/arch passed in the -k option, or the
+current kernel if the -k option was not passed.
 upon.  After uninstall completion, the driver will be left in the built state.
 To completely remove a driver, the remove action should be utilized.
-.TP
-.B match
+.SY match
+.OP --templatekernel kernel/arch
+.OP -k kernel/arch
+.YS
+.IP "" 4
 Match installs modules onto the specified kernel by looking at the
 configuration of the specified
 .B templatekernel.
@@ -51,8 +113,14 @@
 within
 .B dkms
 is then installed on that specified kernel.
-.TP
-.B mkdriverdisk
+.SY mkdriverdisk
+.OP -d distro
+.OP -r release
+.OP --media mediatype
+.OP -k kernel/arch
+.OP module/version
+.YS
+.IP "" 4
 Creates a floppy driver disk image for use when updated drivers are needed
 to install an OS.  Currently, the supported distributions are redhat, suse
 and UnitedLinux. For Red Hat driver disks, necessary driver disk files are
@@ -61,7 +129,7 @@
 must specify the distro while using this action.  Driver disks can be made
 for single kernels or can be made to support multiple kernels.  To create
 a driver disk image with modules for multiple kernels, just specify multiple
-\-k parameters on the command line (\-k kernel1 \-k kernel2 \-a arch1 \-a arch2).
+\-k parameters on the command line (\-k kernel1/arch1 \-k kernel2/arch2).
 
 Red Hat began supporting multi-arched driver disks in RHEL3.  To force creation
 of a driver disk with arch information, specify
@@ -77,6 +145,13 @@
 allows for this, and as such you can create a redhat1 style driver disk if the
 only other arch is i386 and the kernel name ends in BOOT.
 
+Red Hat introduced DDv3 starting with RHEL6. To create Red Hat DDv3, specify
+.B \-d redhat3
+and specify the specfile to use with
+.I \-\-spec=specfile.
+If no specfile is specified, DKMS will use
+.I /etc/dkms/template\-dkms\-redhat\-kmod.spec
+
 See
 .I http://people.redhat.com/dledford
 for more information on the Red Hat driver
@@ -97,28 +172,32 @@
 
 You may have more content than will fit on a floppy.  Therefore, DKMS
 can now generate image files of different types.
-.B \-\-media=floppy (default)
+.B \-\-media floppy (default)
 to generate a floppy disk image, or
-.B \-\-media=iso
+.B \-\-media iso
 to generate a CD-ROM ISO file, or
-.B \-\-media=tar
+.B \-\-media tar
 to generate a tar file.
 
 You may copy the floppy or ISO image file to a USB key to be used with
 OS installer.
-
-
-.TP
-.B mktarball
+.SY mktarball
+.OP module/module\-version
+.OP -k kernel/arch
+.OP --archive /path/to/tarball.tar
+.OP --source-only
+.OP --binaries-only
+.YS
+.IP "" 4
 Creates a tarball archive for the specified module/version of all files
 in the DKMS tree for that module/version combination.  This includes
 the source and any built modules for kernels in the tree (as specified).
 Otherwise, you can specify
 a singular kernel to archive only, or multiple kernels to archive
-(\-k kernel1 \-k kernel2 \-a arch1 \-a arch2).  Optionally, you can use
+(\-k kernel1/arch1 \-k kernel2/arch2).  Optionally, you can use
 .B \-\-archive
-to specify the name (with no preceding path) that you would like this
-tarball to have.  You can also specify
+to specify the file that you would like to save this
+tarball to.  You can also specify
 .B \-\-binaries\-only
 if you want the resultant tarball not to include the module source.  Likewise,
 .B \-\-source-only
@@ -130,13 +209,14 @@
 .B ldtarball
 on all of your other systems to get the same built modules loaded
 without having to wait for anything to compile.
-.TP
-.B ldtarball
+.SY ldtarball
+.OS /path/to/tarball.tar
+.OS --force
+.YS
+.IP "" 4
 This takes a tarball made from the
-.B mktarball
-command and specified with the
-.B \-\-archive
-option and loads it into your DKMS tree.  This will leave any
+.B mktarball 
+command and loads it into your DKMS tree.  This will leave any
 newly added modules in the built state and
 .B dkms install
 should then be called to install any of them.  If files already
@@ -145,8 +225,13 @@
 is attempting to place them, it will warn and not copy over them.  The
 .B \-\-force
 option should be used to override this.
-.TP
-.B mkrpm
+.SY mkrpm
+.OP module/module\-version
+.OP -k kernel/arch
+.OP --source-only
+.OP --binaries-only
+.YS
+.IP "" 4
 This action allows you to create an RPM package for a specified module / version.
 It uses a template .spec file found in
 .I /etc/dkms/template\-dkms\-mkrpm.spec
@@ -159,7 +244,13 @@
 .B \-\-source\-only
 in the mkrpm command.
 .TP
-.B mkdeb
+.SY mkdeb
+.OP module/module\-version
+.OP -k kernel/arch
+.OP --binaries-only
+.OP --source-only
+.YS
+.IP "" 4
 This action allows you to create a debian binary package for a specified module / version.
 It uses a template debian directory found in
 .I /etc/dkms/template\-dkms\-mkdeb
@@ -171,8 +262,13 @@
 not want your debian package to contain any prebuilt binaries, be sure to specify
 .B \-\-source\-only
 in the mkdeb command.
-.TP
-.B mkdsc
+.SY mkdsc
+.OP module/module\-version
+.OP -k kernel/arch
+.OP --binaries-only
+.OP --source-only
+.YS
+.IP "" 4
 This action allows you to create a debian source package for a specified module / version.
 It will create a .tar.gz, and a .dsc.  All options supported by
 .B mkdeb
@@ -184,8 +280,11 @@
 contain any prebuilt binaries, be sure to specify
 .B \-\-source\-only
 in the mkdsc command.
-.TP
-.B mkkmp
+.SY mkkmp
+.OP module/module\-version
+.OP --spec specfile
+.YS
+.IP "" 4
 This action allows you to create an Kernel Module Package source RPM for a specified module / version.
 It uses the .spec file specified by
 .I \-\-spec=specfile
@@ -194,28 +293,45 @@
 as the basis for the RPM.  The generated source RPM may then be built using SuSE's build.rpm or
 Fedora/RHEL's mock chroot environments.  See http://kerneldrivers.org/ for
 more details on KMPs.
-.TP
-.B status
+.SY status
+.OP module/module\-version
+.OP -k kernel/arch
+.YS
+.IP "" 4
 Returns the current status of modules, versions and kernels within
 the tree as well as whether they have been added, built or installed.
 Status can be shown for just a certain module, a certain kernel,
 a module/version combination or a module/version/kernel combination.
+.SY autoinstall
+.YS
+.IP "" 4
+Attempt to install the latest revision of all modules that have been installed for other kernel revisions.
+dkms_autoinstaller is a stub that uses this action to perform its work.
 .SH OPTIONS
 .TP
-.B \-m <module>
-The name of the module.
+.B \-m <module>/<module\-version>
+The name of the module and module version you wnat to operate on. The
+.B \-m
+part of this option is optional, and can be omitted in virtually all circumstances.
 .TP
 .B \-v <module\-version>
-The version of the module to execute the specified action upon.
+The version of the module to execute the specified action upon.  This option only has to be specified 
+if you pass a 
+.B \-m
+option without a <module\-version> component of its own.
 .TP
-.B \-k <kernel\-version>
-The kernel to perform the action upon.  You can specify multiple kernel versions
-on the command line by repeating the \-k argument with a different kernel name.
+.B \-k <kernel\-version>/<arch>
+The kernel and arch to perform the action upon.  You can specify multiple kernel version/arch pairs
+on the command line by repeating the \-k argument with a different kernel version and arch.
 However, not all actions support multiple kernel versions (it will error out
 in this case).
+The arch part can be omitted, and DKMS will assume you want it to be the arch of the currently running
+system.
 .TP
 .B \-a, \-\-arch
-The system architecture to perform the action upon.  If not specified, it assumes
+The system architecture to perform the action upon.  It is optional if you pass it as part of the
+.B \-k
+option. If not specified, it assumes
 the arch of the currently running system (`uname \-m`).  You can specify multiple
 arch parameters on the same command line by repeating the \-a argument with a
 different arch name.  When multiple architectures are specified, there must
@@ -286,7 +402,9 @@
 This option is used during a
 .B ldtarball
 action to specify the location of the tarball you wish to load into
-your DKMS tree.
+your DKMS tree.  You only have to specify the
+.B --archive
+part of this option if <tarball\-location> does not already exist as a file.
 .TP
 .B \-\-templatekernel <kernel\-version>
 This option is required for the action:
@@ -477,6 +595,9 @@
 will be used to build your module. If no MAKE directive is specified or if no
 MAKE_MATCH matches the kernel being built for, DKMS
 will attempt to use a generic MAKE command to build your module.
+
+KERNELRELEASE will be automatically appended to MAKE[#].  If you want to
+suppress this behavior, you can quote the make command: 'make'.
 .TP
 .B MAKE_MATCH[#]=
 See the above entry on
@@ -783,6 +904,17 @@
 , unless otherwise specified with the
 .B \-\-kernelsourcedir
 option.
+.SH DKMS.CONF OVERRIDES
+You can override the module-provided
+.I dkms.conf
+files. Every time after a  dkms.conf file is read, dkms will look for and read the following files in order:
+
+.I /etc/dkms/<module>.conf\p
+.I /etc/dkms/<module>\-<module\-version>.conf\p
+.I /etc/dkms/<module>\-<module\-version>\-<kernel>.conf\p
+.I /etc/dkms/<module>\-<module\-version>\-<kernel>\-<arch>.conf
+
+You can use these files to override settings in the module-provided dkms.conf files.
 .SH /etc/dkms/framework.conf
 This configuration file controls how the overall DKMS framework handles.  It is sourced
 in every time the dkms command is run.  Mainly it can currently be used to set different

dkms-2.1.1.2.tar.bz2/dkms.bash-completion -> dkms-2.2.0.3.tar.bz2/dkms.bash-completion Changed

dkms-2.1.1.2.tar.bz2/dkms.spec -> dkms-2.2.0.3.tar.bz2/dkms.spec Changed

dkms-2.1.1.2.tar.bz2/dkms_apport.py -> dkms-2.2.0.3.tar.bz2/dkms_apport.py Changed

@@ -24,35 +24,72 @@
 import sys
 import subprocess, optparse
 
+from datetime import datetime
+
 optparser = optparse.OptionParser('%prog [options]')
 optparser.add_option('-m', help="Specify the DKMS module to find the package for",
                      action='store', type='string', dest='module')
 optparser.add_option('-v', help="Specify the DKMS version to find the package for",
                      action='store', type='string', dest='version')
+optparser.add_option('-k', help="Specify the kernel version",
+                     action='store', type='string', dest='kernel')
 options=optparser.parse_args()[0]
 
 if not options.module or not options.version:
-    print >> sys.stderr, 'ERROR, both -m and -v are required'
+    print >> sys.stderr, 'ERROR (dkms apport): both -m and -v are required'
     sys.exit(2)
 
 package=packaging.get_file_package('/usr/src/' + options.module + '-' + options.version)
 if package is None:
-    print >> sys.stderr, 'ERROR: binary package for %s: %s not found' % (options.module,options.version)
+    print >> sys.stderr, 'ERROR (dkms apport): binary package for %s: %s not found' % (options.module,options.version)
     sys.exit(1)
 
+if options.kernel:
+    # TODO: Ubuntu specific
+    kernel_package = "linux-headers-" + options.kernel
+
+    try:
+        apport.packaging.is_distro_package(kernel_package)
+    except ValueError, e:
+        if e == 'package does not exist':
+            print >> sys.stderr, 'ERROR (dkms apport): kernel package %s is not supported' % (kernel_package)
+            sys.exit(1)
+
 make_log=os.path.join('/var','lib','dkms',options.module,options.version,'build','make.log')
 
 report = apport.Report('Package')
 report['Package'] = package
-report['SourcePackage'] = apport.packaging.get_source(package)
-report['ErrorMessage'] = "%s kernel module failed to build" % options.module
+try:
+    report['SourcePackage'] = apport.packaging.get_source(package)
+except ValueError:
+    print >> sys.stderr, 'ERROR (dkms apport): unable to determine source package for %s' % package
+    sys.exit(3)
 try:
     version = packaging.get_version(package)
 except ValueError:
-    version = 'N/A'
+    version = '(not installed)'
 if version is None:
-    version = 'N/A'
+    version = '(not installed)'
+
+if report['SourcePackage'] == 'fglrx-installer':
+    fglrx_make_log = os.path.join('/var','lib','dkms',options.module,options.version,'build','make.sh.log')
+    attach_file_if_exists(report, fglrx_make_log, 'FglrxBuildLog')
+
 report['PackageVersion'] = version
+report['Title'] = "%s %s: %s kernel module failed to build" % (package, version, options.module)
 attach_file_if_exists(report, make_log, 'DKMSBuildLog')
-report.write(open(apport.fileutils.make_report_path(report), 'w'))
+if 'DKMSBuildLog' in report:
+    this_year = str(datetime.today().year)
+    if 'Segmentation fault' in report['DKMSBuildLog']:
+        print >> sys.stderr, 'ERROR (dkms apport): There was a segmentation fault when trying to build the module'
+        sys.exit(1)
+    dupe_sig = ''
+    for line in report['DKMSBuildLog'].split('\n'):
+        if line.endswith(this_year):
+            continue
+        dupe_sig += line + '\n'
+    report['DuplicateSignature'] = dupe_sig
 
+if options.kernel:
+    report['DKMSKernelVersion'] = options.kernel
+report.write(open(apport.fileutils.make_report_path(report), 'w'))

dkms-2.1.1.2.tar.bz2/dkms_autoinstaller -> dkms-2.2.0.3.tar.bz2/dkms_autoinstaller Changed

@@ -17,139 +17,30 @@
 
 test -f /usr/sbin/dkms || exit 0
 
-#We only have these functions on debian/ubuntu
-# so on other distros just stub them out
 if [ -f /lib/lsb/init-functions ]; then
     . /lib/lsb/init-functions
-    if [ ! -f /etc/debian_version ]; then
-        alias log_daemon_msg=echo
-        log_end_msg() { if [ "$1" = "0" ]; then echo " Done. "; else echo " Failed. "; fi }
-        alias log_action_begin_msg=log_daemon_msg
-        alias log_action_end_msg=log_end_msg
-    fi
+fi
+#We only have these functions on debian/ubuntu
+# so on other distros just stub them out
+if [ ! -f /etc/debian_version ]; then
+    alias log_daemon_msg=/bin/echo
+    log_end_msg() { if [ "$1" = "0" ]; then echo " Done. "; else echo " Failed. "; fi }
+    alias log_action_begin_msg=log_daemon_msg
+    alias log_action_end_msg=log_end_msg
 fi
 
-invoke_command ()
-{
-    local exitval=0
-    local exitval_file=`mktemp /tmp/dkms.XXXXXX`
-    if [ "$3" = background ] && [ -z "$verbose" ]; then
-        (eval $1 >/dev/null 2>&1; echo "exitval=$?" >> "$exitval_file") &
-        while [ -e "$exitval_file" ] && ! [ -s "$exitval_file" ]; do
-            sleep 3
-        done
-        . "$exitval_file"
-    else
-        eval $1; exitval=$?
-    fi
-    [ $exitval -gt 0 ] && logger -t dkms_autoinstaller "(bad exit status: $exitval)"
-    rm -f "$exitval_file"
-    return $exitval
-}
-
-# Set Variables
-uname=`uname -mr`
-[ -n "$2" ] && kernel=$2
-arch=${uname#* }
-kernel_preparation_done=""
-dkms_tree="/var/lib/dkms"
-. /etc/dkms/framework.conf 2>/dev/null
+if [ -n "$2" ]; then
+    kernel="$2"
+else
+    kernel=`uname -r`
+fi
 
 # See how we were called.
 case "$1" in
   start)
-    log_daemon_msg "Running DKMS auto installation service for kernel $kernel"
-
-    if [ -z "$kernel" ]; then
-        if [ -L /vmlinuz -a -e /vmlinuz ]; then
-            linktarget="$(basename "$(readlink /vmlinuz)")"
-            kernel="${linktarget##vmlinuz-}"
-        else
-            kernel=${uname% *}
-        fi
-    fi
-
-    # Iterate over the modules
-    for modulepath in $(find "$dkms_tree" -maxdepth 1 -mindepth 1 -type d); do
-
-        module_in_tree=${modulepath##*/}
-        # Determine which versions to show status for
-        do_autoinstall=""
-        version_count=0
-        already_installed=""
-        already_installed_version=""
-        for versioned_path in $(find "$modulepath" -maxdepth 1 -mindepth 1 -type d -a -not -name original_module); do
-            version_count=$(($version_count + 1))
-            version_in_tree="${versioned_path##*/}"
-
-            if [ -f $versioned_path/source/dkms.conf ]; then
-                do_autoinstall=$(sed -n -e 's/^$str  *$\?AUTOINSTALL=$.*$$/\2/gp;'  $versioned_path/source/dkms.conf)
-            else
-                current_state="broken"
-                continue
-            fi
-
-            # Get the current state
-            # a mod can be both built and installed-weak (stupid, but could be)
-            # but installed-weak comes last, so use tail
-            current_state=`dkms status -m $module_in_tree -v $version_in_tree -k $kernel -a $arch 2>/dev/null | awk {'print $5'} | tail -n 1`
-            [ "$current_state" = "installed" -o "$current_state" = "installed-weak" ] && already_installed="true" && already_installed_version=$version_in_tree
-        done
-
-        log_action_begin_msg " $module_in_tree ($version_in_tree)"
-
-        # Based on what we know, either do it or not
-        if [ "$current_state" = "broken" ]; then
-            logger -t dkms_autoinstaller "$module_in_tree ($version_in_tree): Unable to locate $versioned_path/source/dkms.conf"
-            logger -t dkms_autoinstaller " DKMS tree must be manually fixed"
-            log_action_end_msg 1
-            continue
-        elif [ -n "$already_installed" ]; then
-            log_action_end_msg 0
-        elif [ -z "$do_autoinstall" ]; then
-            logger -t dkms_autoinstaller "$module_in_tree ($version_in_tree): AUTOINSTALL not set in its dkms.conf."
-            log_action_end_msg 0
-        elif [ -n "$do_autoinstall" ] && [ "$version_count" -gt 1 ]; then
-            logger -t dkms_autoinstaller "$module_in_tree: Multiple versions in DKMS. Unsure what to do. Resolve manually."
-            log_action_end_msg 1
-        else
-            logger -t dkms_autoinstaller "$module_in_tree ($version_in_tree): Installing module on kernel $kernel."
-            if [ "$current_state" != "built" ] && ! [ -e /lib/modules/$kernel/build/include ]; then
-                logger -t dkms_autoinstaller "  Kernel headers for $kernel are not installed.  Cannot install this module."
-                logger -t dkms_autoinstaller "  Try installing linux-headers-$kernel or equivalent."
-                log_action_end_msg 1
-            elif [ "$current_state" != "built" ] && [ -e /lib/modules/$kernel/build/include ]; then
-                return_status=""
-                if [ -z "$kernel_preparation_done" ]; then
-                    invoke_command "dkms build -m $module_in_tree -v $version_in_tree -k $kernel -a $arch -q --no-clean-kernel" "." background
-                    return_status="$?"
-                    kernel_preparation_done="true"
-                else
-                    invoke_command "dkms build -m $module_in_tree -v $version_in_tree -k $kernel -a $arch --no-prepare-kernel --no-clean-kernel -q" "." background
-                    return_status="$?"
-                fi
-                if [ "$return_status" -eq 0 ]; then
-                    invoke_command "dkms install -m $module_in_tree -v $version_in_tree -k $kernel -a $arch" "." background
-                    log_action_end_msg 0
-                else
-                    logger -t dkms_autoinstaller "  Build failed.  Installation skipped."
-                    log_action_end_msg 1
-                fi
-            else
-                invoke_command "dkms install -m $module_in_tree -v $version_in_tree -k $kernel -a $arch -q" "." background
-                return_status=$?
-                if [ "$return_status" -eq 101 ]; then
-                    logger -t dkms_autoinstaller "  A newer module version than this already exists in kernel."
-                    logger -t dkms_autoinstaller "  Skipping install... (you can manually install later with --force)"
-                elif [ "$return_status" -ne 0 ]; then
-                    logger -t dkms_autoinstaller "  Installation failed!"
-                fi
-            fi
-        fi
-    done
-    if [ -z "$modules_needing_status" ]; then
-        log_end_msg 0
-    fi
+    log_daemon_msg "dkms: running auto installation service for kernel $kernel"
+    dkms autoinstall --kernelver $kernel
+    log_end_msg $?
     ;;
   stop|restart|force-reload|status|reload)
     # ignore

dkms-2.1.1.2.tar.bz2/dkms_common.postinst -> dkms-2.2.0.3.tar.bz2/dkms_common.postinst Changed

@@ -6,11 +6,32 @@
 
 set -e
 
+uname_s=$(uname -s)
+
+_get_kernel_dir() {
+    KVER=$1
+    case ${uname_s} in
+	Linux)		DIR="/lib/modules/$KVER/build" ;;
+	GNU/kFreeBSD)	DIR="/usr/src/kfreebsd-headers-$KVER/sys" ;;
+    esac
+    echo $DIR
+}
+
+_check_kernel_dir() {
+    DIR=$(_get_kernel_dir $1)
+    case ${uname_s} in
+	Linux)		test -e $DIR/include ;;
+	GNU/kFreeBSD)	test -e $DIR/kern && test -e $DIR/conf/kmod.mk ;;
+	*)		return 1 ;;
+    esac
+    return $?
+}
+
 # Check the existence of a kernel named as $1
 _is_kernel_name_correct() {
     CORRECT="no"
     KERNEL_NAME=$1
-    
+
     for kernel in /boot/config-*; do
         KERNEL=${kernel#*-}
         if [ "${KERNEL}" = "${KERNEL_NAME}" ]; then
@@ -30,7 +51,7 @@
     NEWEST_KERNEL=
     NEWEST_VERSION=
     NEWEST_ABI=
-    
+
     for kernel in /boot/config-*; do
         KERNEL=${kernel#*-}
         KERNEL_VERSION=${KERNEL%%-*}
@@ -44,7 +65,7 @@
             # Get the biggest version
             COMPARE_TO="$NEWEST_VERSION-$NEWEST_ABI"
         fi
-            
+
         # if $kernel is greater than $COMPARE_TO
         if [ `dpkg --compare-versions "$KERNEL_VERSION-$ABI" gt "$COMPARE_TO" && echo "yes" || \
               echo "no"` = "yes" ]; then
@@ -61,7 +82,7 @@
 # is the most recent kernel then the function will print a null string.
 _get_newest_kernel_rhel() {
     NEWEST_KERNEL=
-    
+
     LAST_INSTALLED_KERNEL=$(rpm -q --whatprovides kernel  --last | grep kernel -m1 | cut -f1 -d' ')
 
     LIK_FORMATTED_NAME=$(rpm -q $LAST_INSTALLED_KERNEL --queryformat="%{VERSION}-%{RELEASE}.%{ARCH}\n")
@@ -71,7 +92,7 @@
         NEWEST_KERNEL=$LIK_FORMATTED_NAME
     else
         # Hack for Mandriva where $LIK_FORMATTED_NAME is broken
-        LIK_NAME=$(rpm -q $LAST_INSTALLED_KERNEL --queryformat="%{NAME}\n") 
+        LIK_NAME=$(rpm -q $LAST_INSTALLED_KERNEL --queryformat="%{NAME}\n")
         LIK_TYPE=${LIK_NAME#kernel-}
         LIK_TYPE=${LIK_TYPE%%-*}
         LIK_STRIPPED=${LIK_NAME#kernel-}
@@ -99,7 +120,7 @@
         CURRENT_ABI=${CURRENT_ABI%%-*}
         NEWEST_KERNEL=$(_get_newest_kernel_debian "$CURRENT_VERSION-$CURRENT_ABI")
 
-    elif [ `which rpm &>/dev/null` ]; then
+    elif [ `which rpm >/dev/null` ]; then
         # If RPM based
         NEWEST_KERNEL=$(_get_newest_kernel_rhel)
     fi
@@ -135,11 +156,6 @@
 fi
 
 #Load new files, by source package and by tarball
-echo "Loading new $NAME-$VERSION DKMS files..."
-if [ -d "/usr/src/$NAME-$VERSION" ]; then
-    dkms add -m $NAME -v $VERSION > /dev/null
-fi
-
 if [ -f "$TARBALL_ROOT/$NAME-$VERSION.dkms.tar.gz" ]; then
     if ! dkms ldtarball --archive "$TARBALL_ROOT/$NAME-$VERSION.dkms.tar.gz"; then
         echo ""
@@ -151,8 +167,11 @@
         echo " - Corrupt distribution specific archive"
         echo ""
         echo ""
-        exit 2 
+        exit 2
     fi
+elif [ -d "/usr/src/$NAME-$VERSION" ]; then
+    echo "Loading new $NAME-$VERSION DKMS files..."
+    dkms add -m $NAME -v $VERSION > /dev/null
 fi
 
 # On 1st installation, let us look for a directory
@@ -160,10 +179,10 @@
 # is found it is possible that buildd is being used
 # and that uname -r is giving us the name of the
 # kernel used by the buildd machine.
-# 
+#
 # If this is the case we try to build the kernel
-# module for each kernel which has a directory in 
-# /lib/modules. Furthermore we will have to tell 
+# module for each kernel which has a directory in
+# /lib/modules. Furthermore we will have to tell
 # DKMS which architecture it should build the module
 # for (e.g. if the buildd machine is using a
 # 2.6.24-23-xen 64bit kernel).
@@ -188,13 +207,26 @@
 # current kernel.
 NEWEST_KERNEL=$(get_newest_kernel "$KERNELS")
 
-if [ -n "$NEWEST_KERNEL" ] && [ ${CURRENT_KERNEL} != ${NEWEST_KERNEL} ]; then
-    echo "Building for $CURRENT_KERNEL and $NEWEST_KERNEL"
-    KERNELS="$KERNELS $NEWEST_KERNEL"
+# If the current kernel doesn't come from the host of a chroot
+if [ `_is_kernel_name_correct $CURRENT_KERNEL` = "yes" ]; then
+    # See if it's worth building the module for both the newest kernel
+    # and for the current kernel
+    if [ -n "$NEWEST_KERNEL" ] && [ ${CURRENT_KERNEL} != ${NEWEST_KERNEL} ]; then
+        echo "Building for $CURRENT_KERNEL and $NEWEST_KERNEL"
+        KERNELS="$CURRENT_KERNEL $NEWEST_KERNEL"
+    else
+        echo "Building only for $CURRENT_KERNEL"
+    fi
+# The current kernel is not useful as it's the host's
 else
-    echo "Building only for $CURRENT_KERNEL"
-fi
+    echo "It is likely that $CURRENT_KERNEL belongs to a chroot's host"
 
+    # Let's use only the newest kernel
+    if [ -n "$NEWEST_KERNEL" ]; then
+        KERNELS="$NEWEST_KERNEL"
+        echo "Building only for $NEWEST_KERNEL"
+    fi
+fi
 
 if [ -n "$ARCH" ]; then
     if which lsb_release >/dev/null && [ $(lsb_release -s -i) = "Ubuntu" ]; then
@@ -229,10 +261,24 @@
             echo " since the package source was not provided"
             continue
         fi
-        if [ -e /lib/modules/$KERNEL/build/include ]; then
+        if _check_kernel_dir $KERNEL; then
             echo "Building initial module for $KERNEL"
+            set +e
             dkms build -m $NAME -v $VERSION -k $KERNEL $ARCH > /dev/null
-            echo "Done."
+            case $? in
+            9)
+                set -e
+                echo "Skipped."
+                continue
+                ;;
+            0)
+                set -e
+                echo "Done."
+                ;;
+            *)
+                exit $?
+                ;;
+            esac
             dkms_status=`dkms status -m $NAME -v $VERSION -k $KERNEL $ARCH`
         else
             echo "Module build for the currently running kernel was skipped since the"

dkms-2.1.1.2.tar.bz2/dkms_find-provides -> dkms-2.2.0.3.tar.bz2/dkms_find-provides Changed

dkms-2.1.1.2.tar.bz2/dkms_upgrade_add_arch_support.sh -> dkms-2.2.0.3.tar.bz2/dkms_upgrade_add_arch_support.sh Changed

@@ -8,70 +8,62 @@
 #
 # DKMS v2.0 will be the first stable release to have arch support.
 
+# bail if no dkms
+dkms_version=$(dkms -V 2>/dev/null) || exit
+dkms_version=(${dkms_version//./ })
 
-function readlink()
-{
-    # $1 = the symlink to read
-    read_link=""
-    if [ -L "$1" ]; then
-        read_link="$1"
-        while [ -L "$read_link" ]; do
-            read_link=`ls -l $read_link | sed 's/.*-> //'`
-        done
-    fi
-}
+# do nothing if we are already new enough
+((${dkms_version[2]} > 1 || \
+    (${dkms_version[2]} == 1 && ${dkms_version[3]} >= 90) )) && exit
+
+mv /var/dkms /var/lib/dkms
+arch_used=$(uname -m)
+[[ $arch_used = x86_64 ]] && (($(grep -c "Intel" /proc/cpuinfo > 0 && \
+    $(ls /lib/modules/$kernel_test/build/configs 2>/dev/null | \
+    grep -c "ia32e") > 0)) && arch_used="ia32e"
 
-dkms_version=`dkms -V 2>/dev/null`
-if [ -n "$dkms_version" ]; then
-	version_major=`echo $dkms_version | awk {'print $2'} | cut -d '.' -f 1-1`
-	version_minor=`echo $dkms_version | awk {'print $2'} | cut -d '.' -f 2-2`
-	if [ "$version_major" -lt 2 ] && [ "$version_minor" -lt 90 ] || [ "$version_major" -eq 0 ]; then
-		mv /var/dkms /var/lib/dkms
-		arch_used=""
-		[ `uname -m` == "x86_64" ] && [ `cat /proc/cpuinfo | grep -c "Intel"` -gt 0 ] && [ `ls /lib/modules/$kernel_test/build/configs 2>/dev/null | grep -c "ia32e"` -gt 0 ] && arch_used="ia32e" || arch_used=`uname -m`
-		echo ""
-		echo "ALERT! ALERT! ALERT!"
-		echo ""
-		echo "You are using a version of DKMS which does not support multiple system"
-		echo "architectures.  Your DKMS tree will now be modified to add this support."
-		echo ""
-		echo "The upgrade will assume all built modules are for arch: $arch_used"
+echo ""
+echo "ALERT! ALERT! ALERT!"
+echo ""
+echo "You are using a version of DKMS which does not support multiple system"
+echo "architectures.  Your DKMS tree will now be modified to add this support."
+echo ""
+echo "The upgrade will assume all built modules are for arch: $arch_used"
 
-		# Set important variables
-		current_kernel=`uname -r`
-		dkms_tree="/var/lib/dkms"
-		source_tree="/usr/src"
-		tmp_location="/tmp"
-		dkms_frameworkconf="/etc/dkms_framework.conf"
+# Set important variables
+current_kernel=$(uname -r)
+dkms_tree="/var/lib/dkms"
+source_tree="/usr/src"
+tmp_location="/tmp"
+dkms_frameworkconf="/etc/dkms_framework.conf"
 
-		# Source in /etc/dkms_framework.conf
-		. $dkms_frameworkconf 2>/dev/null
+# Source in /etc/dkms_framework.conf
+. $dkms_frameworkconf 2>/dev/null
 
-		# Add the arch dirs
-		echo ""
-		echo "Fixing directories."
-		for directory in `find $dkms_tree -type d -name "module" -mindepth 3 -maxdepth 4`; do
-			dir_to_fix=`echo $directory | sed 's#/module$##'`
-			echo "Creating $dir_to_fix/$arch_used..."
-			mkdir $dir_to_fix/$arch_used
-			mv -f $dir_to_fix/* $dir_to_fix/$arch_used 2>/dev/null
-		done
+# Add the arch dirs
+echo ""
+echo "Fixing directories."
+for directory in $(find $dkms_tree -type d -name "module" -mindepth 3 -maxdepth 4); do
+    dir_to_fix=${directory%module}
+    echo "Creating $dir_to_fix/$arch_used..."
+    mkdir $dir_to_fix/$arch_used
+    mv -f $dir_to_fix/* $dir_to_fix/$arch_used 2>/dev/null
+done
 
-		# Fix symlinks
-		echo ""
-		echo "Fixing symlinks."
-		for symlink in `find $dkms_tree -type l -name "kernel*" -mindepth 2 -maxdepth 2`; do
-			symlink_kernelname=`echo $symlink | sed 's#.*/kernel-##'`
-			dir_of_symlink=`echo $symlink | sed 's#/kernel-.*$##'`
-			cd $dir_of_symlink
-			readlink $symlink
-			if [ `echo $read_link | sed 's#/# #g' | wc -w | awk {'print $1'}` -lt 3 ]; then
-				echo "Updating $symlink..."
-				ln -sf $read_link/$arch_used kernel-$symlink_kernelname-$arch_used
-				rm -f $symlink
-			fi
-			cd -
-		done
-		echo ""
-	fi
-fi
+# Fix symlinks
+echo ""
+echo "Fixing symlinks."
+for symlink in $(find $dkms_tree -type l -name "kernel*" -mindepth 2 -maxdepth 2); do
+    symlink_kernelname=${symlink/*\/kernel-//}
+    dir_of_symlink=${symlink/\/kernel-*//}
+    cd $dir_of_symlink
+    split_symlink=$(readlink -e "$symlink")
+    split_symlink=(${split_symlink//\// })
+    if ((${#split_symlink[@]} < 3)); then
+	echo "Updating $symlink..."
+	ln -sf $read_link/$arch_used kernel-$symlink_kernelname-$arch_used
+	rm -f $symlink
+    fi
+    cd -
+done
+echo ""
\ No newline at end of file

dkms-2.1.1.2.tar.bz2/kernel_postinst.d_dkms -> dkms-2.2.0.3.tar.bz2/kernel_postinst.d_dkms Changed

@@ -3,6 +3,44 @@
 # We're passed the version of the kernel being installed
 inst_kern=$1
 
+uname_s=$(uname -s)
+
+_get_kernel_dir() {
+    KVER=$1
+    case ${uname_s} in
+       Linux)          DIR="/lib/modules/$KVER/build" ;;
+       GNU/kFreeBSD)   DIR="/usr/src/kfreebsd-headers-$KVER/sys" ;;
+    esac
+    echo $DIR
+}
+
+_check_kernel_dir() {
+    DIR=$(_get_kernel_dir $1)
+    case ${uname_s} in
+       Linux)          test -e $DIR/include ;;
+       GNU/kFreeBSD)   test -e $DIR/kern && test -e $DIR/conf/kmod.mk ;;
+       *)              return 1 ;;
+    esac
+    return $?
+}
+
+case "${uname_s}" in
+    Linux)
+        header_pkg="linux-headers-$inst_kern"
+        kernel="Linux"
+    ;;
+    GNU/kFreeBSD)
+        header_pkg="kfreebsd-headers-$inst_kern"
+        kernel="kFreeBSD"
+    ;;
+esac
+
 if [ -x /usr/lib/dkms/dkms_autoinstaller ]; then
     exec /usr/lib/dkms/dkms_autoinstaller start $inst_kern > /dev/null
 fi
+
+if ! _check_kernel_dir $inst_kern ; then
+    echo "dkms: WARNING: $kernel headers are missing, which may explain the above failures." >&2
+    echo "      please install the $header_pkg package to fix this." >&2
+fi
+

dkms-2.1.1.2.tar.bz2/kernel_prerm.d_dkms -> dkms-2.2.0.3.tar.bz2/kernel_prerm.d_dkms Changed

dkms-2.1.1.2.tar.bz2/template-dkms-mkdeb/debian/postinst -> dkms-2.2.0.3.tar.bz2/template-dkms-mkdeb/debian/postinst Changed

dkms-2.2.0.3.tar.bz2/template-dkms-redhat-kmod.spec Added

@@ -0,0 +1,48 @@
+%{?!module_name: %{error: You did not specify a module name (%%module_name)}}
+%{?!version: %{error: You did not specify a module version (%%version)}}
+Name:		%{module_name}
+Version:	%{version}
+Release:	1%{?dist}
+Summary:	%{module_name}-%{version} RHEL6 Driver Update Program package
+
+Group:		System/Kernel
+License:	Unkown
+Source0:	%{module_name}-%{version}.tar.bz2
+BuildRoot:	%(mktemp -ud %{_tmppath}/%{module_name}-%{version}-%{release}-XXXXXX)
+BuildRequires:	%kernel_module_package_buildreqs
+
+%kernel_module_package default
+
+%description
+%{module_name}-%{version} RHEL6 Driver Update package.
+
+%prep
+%setup
+set -- *
+mkdir source
+mv "$@" source/
+mkdir obj
+
+%build
+for flavor in %flavors_to_build; do
+	rm -rf obj/$flavor
+	cp -r source obj/$flavor
+	make -C %{kernel_source $flavor} M=$PWD/obj/$flavor
+done
+
+%install
+export INSTALL_MOD_PATH=$RPM_BUILD_ROOT
+export INSTALL_MOD_DIR=extra/%{name}
+for flavor in %flavors_to_build ; do
+	make -C %{kernel_source $flavor} modules_install \
+		M=$PWD/obj/$flavor
+done
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%changelog
+* Sun Jun 15 2010 Prudhvi Tella <prudhvi_tella@dell.com>
+- DKMS template for RHEL6 Driver Update package.
+* Sun Mar 28 2010 Jon Masters <jcm@redhat.com>
+- Example RHEL6 Driver Update package.

dkms.rpmlintrc Changed

Build Results
RPM Lint

Refresh

Comments for request 326 0

Request History

etamPL created request over 10 years ago

update to 2.2.0.3

mrdocs accepted request over 11 years ago

Thanks. Looks good to me!