Adding upstream version 3.0.13.upstream/3.0.13upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2670 insertions, 0 deletions

diff --git a/dkms.in b/dkms.in
new file mode 100644
index 0000000..55eced3
--- /dev/null
+++ b/dkms.in
@@ -0,0 +1,2670 @@
+#!/bin/bash
+#
+#  Dynamic Kernel Module Support (DKMS) <dkms-devel@dell.com>
+#  Copyright (C) 2003-2008 Dell, Inc.
+#  by Gary Lerhaupt, Matt Domsch, & Mario Limonciello
+#  Copyright (C) 2012 by Darik Horn <dajhorn@vanadac.com>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+
+shopt -s extglob
+
+# All of the variables we will accept from dkms.conf.
+# Does not include directives
+# The last group of variables has been deprecated
+readonly dkms_conf_variables="CLEAN PACKAGE_NAME
+   PACKAGE_VERSION POST_ADD POST_BUILD POST_INSTALL POST_REMOVE PRE_BUILD
+   PRE_INSTALL BUILD_DEPENDS BUILD_EXCLUSIVE_ARCH BUILD_EXCLUSIVE_CONFIG
+   BUILD_EXCLUSIVE_KERNEL BUILD_EXCLUSIVE_KERNEL_MIN BUILD_EXCLUSIVE_KERNEL_MAX
+   build_exclude OBSOLETE_BY MAKE MAKE_MATCH
+   PATCH PATCH_MATCH patch_array BUILT_MODULE_NAME
+   built_module_name BUILT_MODULE_LOCATION built_module_location
+   DEST_MODULE_NAME dest_module_name
+   DEST_MODULE_LOCATION dest_module_location
+   STRIP strip AUTOINSTALL NO_WEAK_MODULES
+   SIGN_FILE MOK_SIGNING_KEY MOK_CERTIFICATE
+
+   REMAKE_INITRD MODULES_CONF MODULES_CONF_OBSOLETES
+   MODULES_CONF_ALIAS_TYPE MODULES_CONF_OBSOLETE_ONLY"
+
+# All of the variables not related to signing we will accept from framework.conf.
+readonly dkms_framework_nonsigning_variables="source_tree dkms_tree install_tree tmp_location
+   verbose symlink_modules autoinstall_all_kernels
+   modprobe_on_install"
+# All of the signing related variables we will accept from framework.conf.
+readonly dkms_framework_signing_variables="sign_file mok_signing_key mok_certificate"
+
+# Some important regular expressions. Requires bash 3 or above.
+# Any poor souls still running bash 2 or older really need an upgrade.
+readonly mv_re='^([^/]*)/(.*)$'
+
+# Areas that will vary between Linux and other OS's
+_get_kernel_dir() {
+    if [[ -z $ksourcedir_fromcli ]]; then
+        KVER=$1
+        case ${current_os} in
+           Linux)          DIR="$install_tree/$KVER/build" ;;
+           GNU/kFreeBSD)   DIR="/usr/src/kfreebsd-headers-$KVER/sys" ;;
+        esac
+        echo $DIR
+    else
+        echo $kernel_source_dir
+    fi
+}
+
+_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 = Redirect command output to this file
+    # $4 = 'background' if you want to run the command asynchronously.
+    local exitval=0
+    local -r cmd=$([[ $3 ]] && echo "{ $1; } >> $3 2>&1" || echo "$1")
+
+    [[ $verbose ]] && echo -e "$cmd" || echo -en "$2..."
+    if [[ $4 = background && ! $verbose ]]; then
+        local pid progresspid
+        (eval "$cmd" >/dev/null 2>&1) & pid=$!
+        {
+            on_exit() {
+                kill $(jobs -p) 2>/dev/null
+                wait $(jobs -p) 2>/dev/null
+            }
+            trap on_exit EXIT
+            while /bin/kill --signal 0 $pid > /dev/null 2>&1; do
+                sleep 3 &
+                wait $!
+                echo -en "."
+            done
+        } & progresspid=$!
+        wait $pid 2>/dev/null
+        exitval=$?
+        kill $progresspid 2>/dev/null
+        wait $progresspid 2>/dev/null
+    else
+        eval "$cmd"; exitval=$?
+    fi
+    if (($exitval > 0)); then
+        echo -en "(bad exit status: $exitval)"
+        # Print the failing command without the clunky redirection
+        [[ ! $verbose ]] && echo -en "\nFailed command:\n$1"
+    fi
+    echo -en "\n"
+    return $exitval
+}
+
+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
+)
+
+deprecated() (
+    exec >&2
+    echo -n $"Deprecated feature: "
+    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
+}
+
+# Print a warning message and die with the passed error code.
+diewarn() {
+    # $1 = error code to return with
+    # rest = strings to print before we exit.
+    ret=$1
+    shift
+    warn "$@"
+    [[ $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 | unbuild | install | uninstall | match |"
+    echo $"               autoinstall | mktarball | ldtarball | status }"
+    echo $"  [options] = [-m module] [-v module-version] [-k kernel-version] [-a arch]"
+    echo $"              [-c dkms.conf-location] [-q] [--force] [--force-version-override] [--all]"
+    echo $"              [--templatekernel=kernel] [--directive='cli-directive=cli-value']"
+    echo $"              [--config=kernel-.config-location] [--archive=tarball-location]"
+    echo $"              [--kernelsourcedir=source-location] [--rpm_safe_upgrade]"
+    echo $"              [--dkmstree path] [--sourcetree path] [--installtree path]"
+    echo $"              [--binaries-only] [--source-only] [--verbose]"
+    echo $"              [--no-depmod] [--modprobe-on-install] [-j number] [--version]"
+}
+
+VER()
+{
+    # $1 = kernel version string
+
+    # Pad all numbers in $1 so that they have at least three digits, e.g.,
+    #   2.6.9-1cvs200409091247 => 002.006.009-001cvs200409091247
+    # 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'
+}
+
+# Find out how many CPUs there are so that we may pass an appropriate -j
+# option to make. Ignore hyperthreading for now.
+get_num_cpus()
+{
+    # use nproc(1) from coreutils 8.1-1+ if available, otherwise single job
+    if [[ -x /usr/bin/nproc ]]; then
+        nproc
+    else
+        echo "1"
+    fi
+}
+
+# Finds a .ko or .ko.xz based on a directory and module name
+# must call set_module_suffix first
+compressed_or_uncompressed()
+{
+    # module dir = $1
+    # module = $2
+    local test1="$1/$2$module_uncompressed_suffix"
+    local test2="$1/$2$module_uncompressed_suffix$module_compressed_suffix"
+    if [[ -e "$test1" ]]; then
+        echo "$test1"
+    elif [[ -e "$test2" ]]; then
+        echo "$test2"
+    fi
+}
+
+# Finds .ko or .ko.xz based on a tree and module name
+# must call set_module_suffix first
+find_module()
+{
+    # tree = $1
+    # module = $2
+    find "$1" -name "$2$module_uncompressed_suffix" -o -name "$2$module_suffix" -type f
+    return $?
+}
+
+
+# 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:-$(uname -r)}"
+    module_uncompressed_suffix=".ko"
+    grep -q '\.gz:' $install_tree/$kernel_test/modules.dep 2>/dev/null && module_compressed_suffix=".gz"
+    grep -q '\.xz:' $install_tree/$kernel_test/modules.dep 2>/dev/null && module_compressed_suffix=".xz"
+    grep -q '\.zst:' $install_tree/$kernel_test/modules.dep 2>/dev/null && module_compressed_suffix=".zst"
+    module_suffix="$module_uncompressed_suffix$module_compressed_suffix"
+}
+
+set_kernel_source_dir_and_kconfig()
+{
+    if [[ -z "${ksourcedir_fromcli}" ]]; then
+        # $1 = the kernel to base the directory on
+        kernel_source_dir="$(_get_kernel_dir "$1")"
+    fi
+    if [[ -z "${kconfig_fromcli}" ]]; then
+        kernel_config="${kernel_source_dir}/.config"
+    fi
+}
+
+check_all_is_banned()
+{
+    if [[ $all ]]; then
+        die 5 $"The action $1 does not support the --all parameter."
+    fi
+}
+
+# A little test function for DKMS commands that only work on one kernel.
+have_one_kernel() {
+    if (( ${#kernelver[@]} != 1 )); then
+        die 4 $"The action $1 does not support multiple kernel version parameters on the command line."
+    fi
+    check_all_is_banned $1
+}
+
+# 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()
+{
+    # If all is set, use dkms status to fill the arrays
+    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" | sort -V)
+    fi
+
+    # Set default kernel version and arch, if none set (but only --all isn't set)
+    if [[ $1 != status ]]; then
+        if [[ ! $kernelver && ! $all ]]; then
+            kernelver[0]=$(uname -r)
+        fi
+        if [[ ! $arch ]]; then
+            kernelver_rpm=$(rpm -qf "$install_tree/$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
+        if [[ ! $arch ]]; then
+            die 12 $"Could not determine architecture."
+        fi
+    fi
+
+    # If only one arch is specified, make it so for all the kernels
+    if ((${#arch[@]} == 1 && ${#kernelver[@]} > 1)); then
+        while ((${#arch[@]} < ${#kernelver[@]})); do
+            arch[${#arch[@]}]=$arch
+        done
+    fi
+
+    # Set global multi_arch
+    multi_arch=""
+    local i=0
+    for ((i=0; $i < ${#arch[@]}; i++)); do
+        [[ $arch != ${arch[$i]} ]] && {
+            multi_arch="true"
+            break
+        }
+    done
+}
+
+do_depmod()
+{
+    if [[ $no_depmod ]]; then
+        return
+    fi
+    # $1 = kernel version
+    if [[ ${current_os} != Linux ]] ; then
+        return
+    fi
+    if [[ ! -f $install_tree/$1/modules.dep ]]; then
+        # if the corresponding linux image $1 is not installed
+        # do not create modules.dep
+        echo "Skipping depmod because '$install_tree/$1/modules.dep' is missing."
+        return
+    fi
+    if [[ -f /boot/System.map-$1 ]]; then
+        depmod -a "$1" -F "/boot/System.map-$1"
+    else
+        depmod -a "$1"
+    fi
+    if [[ -f $install_tree/$1/modules.dep && ! -s $install_tree/$1/modules.dep ]]; then
+        # if modules.dep is empty, we just removed the last kernel module from
+        # no longer installed kernel $1, so do not leave stale depmod files around
+        rm -fv $install_tree/$1/modules.{alias,dep,devname,softdep,symbols,*.bin}
+        rmdir --ignore-fail-on-non-empty $install_tree/$1
+        [[ -d $install_tree/$1 ]] || echo $"removed directory $install_tree/$1"
+    fi
+}
+
+# Grab distro information from os-release.
+distro_version()
+{
+    for f in /etc/os-release /usr/lib/os-release; do
+        if [[ -e $f ]]; then
+            (
+                . "$f"
+                if [[ "$ID" = "ubuntu" ]]; then
+                    # ID_LIKE=debian in ubuntu
+                    echo $ID
+                elif [[ ${#ID_LIKE[@]} != 0 ]]; then
+                    echo ${ID_LIKE[0]}
+                else
+                    echo $ID
+                fi
+            )
+            return
+        fi
+    done
+    die 4 $"System is missing os-release file."
+}
+
+override_dest_module_location()
+{
+    local orig_location="$1"
+    [[ ${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
+    fedora* | rhel* | ovm*)
+        echo "/extra" && return
+        ;;
+    sles* | suse* | opensuse*)
+        echo "/updates" && return
+        ;;
+    debian* | ubuntu*)
+        echo "/updates/dkms" && return
+        ;;
+    arch*)
+        echo "/updates/dkms" && return
+        ;;
+    *)
+        ;;
+    esac
+    echo "$orig_location"
+}
+
+# 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 deliberately 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"
+
+    (( ${#REMAKE_INITRD[@]} )) && deprecated "REMAKE_INITRD ($to_source_file)"
+    (( ${#MODULES_CONF[@]} )) && deprecated "MODULES_CONF ($to_source_file)"
+    (( ${#MODULES_CONF_OBSOLETES[@]} )) && deprecated "MODULES_CONF_OBSOLETES ($to_source_file)"
+    (( ${#MODULES_CONF_ALIAS_TYPE[@]} )) && deprecated "MODULES_CONF_ALIAS_TYPE ($to_source_file)"
+    (( ${#MODULES_CONF_OBSOLETE_ONLY[@]} )) && deprecated "MODULES_CONF_OBSOLETE_ONLY ($to_source_file)"
+}
+
+# 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 installation 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="$dkms_tree/$module/$module_version/source/dkms.conf"
+
+    # Set variables supported in dkms.conf files (eg. $kernelver)
+    local kernelver="$1"
+    local arch="$2"
+    set_kernel_source_dir_and_kconfig "$1"
+
+
+    # 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: $read_conf_file 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\""
+    done
+
+    # Set variables
+    clean="$CLEAN"
+    package_name="$PACKAGE_NAME"
+    package_version="$PACKAGE_VERSION"
+    post_add="$POST_ADD"
+    post_build="$POST_BUILD"
+    post_install="$POST_INSTALL"
+    post_remove="$POST_REMOVE"
+    pre_build="$PRE_BUILD"
+    pre_install="$PRE_INSTALL"
+    obsolete_by="$OBSOLETE_BY"
+
+    # Fail if no PACKAGE_NAME
+    if [[ ! $package_name ]]; then
+        echo $"dkms.conf: Error! No 'PACKAGE_NAME' directive specified.">&2
+        return_value=1
+    fi
+
+    # Fail if no PACKAGE_VERSION
+    if [[ ! $package_version ]]; then
+        echo $"dkms.conf: Error! No 'PACKAGE_VERSION' directive specified.">&2
+        return_value=1
+    fi
+
+    # Set module naming/location arrays
+    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]}
+        case ${STRIP[$index]} in
+            [nN]*)
+                strip[$index]="no"
+                ;;
+            [yY]*)
+                strip[$index]="yes"
+                ;;
+            '')
+                strip[$index]=${strip[0]:-yes}
+                ;;
+        esac
+
+        # If unset, set by defaults
+        [[ ! ${built_module_name[$index]} ]] && \
+            ((array_size == 1)) && \
+            built_module_name[$index]=$PACKAGE_NAME
+        [[ ! ${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 distributions
+        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
+
+    # Warn if no modules are specified
+    if ((array_size == 0)); then
+        echo $"dkms.conf: Warning! Zero modules specified." >&2
+    fi
+
+    # Get the correct make command
+    [[ ${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
+    [[ ! $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"
+
+    # Check if clang was used to compile or lld was used to link the kernel.
+    if [[ -e $kernel_source_dir/vmlinux ]]; then
+      if  readelf -p .comment $kernel_source_dir/vmlinux | grep -q clang; then
+        make_command="${make_command} CC=clang"
+      fi
+      if  readelf -p .comment $kernel_source_dir/vmlinux | grep -q LLD; then
+        make_command="${make_command} LD=ld.lld"
+      fi
+    elif [[ -e "${kernel_config}" ]]; then
+      if grep -q CONFIG_CC_IS_CLANG=y "${kernel_config}"; then
+        make_command="${make_command} CC=clang"
+      fi
+      if grep -q CONFIG_LD_IS_LLD=y "${kernel_config}"; then
+        make_command="${make_command} LD=ld.lld"
+      fi
+    fi
+
+    # Set patch_array (including kernel specific patches)
+    count=0
+    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 build_exclude
+    [[ $BUILD_EXCLUSIVE_KERNEL && ! $1 =~ $BUILD_EXCLUSIVE_KERNEL ]] && build_exclude="yes"
+    [[ $BUILD_EXCLUSIVE_KERNEL_MIN && "$(VER "$1")" < "$(VER "$BUILD_EXCLUSIVE_KERNEL_MIN")" ]] && build_exclude="yes"
+    [[ $BUILD_EXCLUSIVE_KERNEL_MAX && "$(VER "$1")" > "$(VER "$BUILD_EXCLUSIVE_KERNEL_MAX")" ]] && build_exclude="yes"
+    [[ $BUILD_EXCLUSIVE_ARCH && ! $2 =~ $BUILD_EXCLUSIVE_ARCH ]] && build_exclude="yes"
+    if [[ $BUILD_EXCLUSIVE_CONFIG && -e "${kernel_config}" ]]; then
+        local kconf
+        for kconf in $BUILD_EXCLUSIVE_CONFIG ; do
+            case "$kconf" in
+                !*) grep -q "^${kconf#!}=[ym]" "${kernel_config}" && build_exclude="yes" ;;
+                *)  grep -q "^${kconf}=[ym]" "${kernel_config}" || build_exclude="yes" ;;
+            esac
+        done
+    fi
+
+    # Set 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
+}
+
+# Source specified variables from dkms framework configuration files.
+read_framework_conf() {
+    for i in /etc/dkms/framework.conf /etc/dkms/framework.conf.d/*.conf; do
+        [[ -e "$i" ]] && safe_source "$i" "$@"
+    done
+}
+
+# Little helper function for parsing the output of modinfo.
+get_module_verinfo(){
+    local ver
+    local srcver
+    local checksum
+    local vals=
+    while read -a vals; do
+    case "${vals[0]}" in
+        version:)
+            ver="${vals[1]}"
+            checksum="${vals[2]}"
+            ;;
+        srcversion:)
+            srcver="${vals[1]}"
+            ;;
+    esac
+    done < <(modinfo "$1")
+
+    echo -E "${ver}"
+    # Use obsolete checksum info if srcversion is not available
+    echo -E "${srcver:-$checksum}"
+}
+
+# Compare two modules' version
+# Output:
+#  "==": They are the same version and the same srcversion
+#  "=": They are the same version, but not the same srcversion
+#  ">": 1st one is newer than 2nd one
+#  "<": 1st one is older than 2nd one
+#  "?": Cannot determine
+# Returns 0 if same version, otherwise 1
+compare_module_version()
+{
+    readarray -t ver1 <<< "$(get_module_verinfo "$1")"
+    readarray -t ver2 <<< "$(get_module_verinfo "$2")"
+    if [[ "${ver1[0]}" = "${ver2[0]}" ]]; then
+        if [[ "${ver1[1]}" = "${ver2[1]}" ]]; then
+            echo "=="
+        else
+            echo "="
+        fi
+        return 0
+    elif [[ ! "$ver1" ]] || [[ ! "$ver2" ]]; then
+        echo "?"
+    elif [[ "$(VER "${ver1[0]}")" > "$(VER "${ver2[0]}")" ]]; then
+        echo ">"
+    else
+        echo "<"
+    fi
+    return 1
+}
+
+# Perform some module version sanity checking whenever we are installing
+# modules.
+check_version_sanity()
+{
+    # $1 = kernel_version
+    # $2 = arch
+    # $3 = obs by kernel version
+    # $4 = dest_module_name
+
+    local lib_tree="$install_tree/$1" res=
+    echo $"Running module version sanity check."
+    local i=0
+    if [[ -n $3 ]]; then
+        # 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
+    fi
+    set_module_suffix "$1"
+    read -a kernels_module < <(find_module "$lib_tree" "${4}")
+    [[ -z $kernels_module ]] && return 0
+
+    if [[ "$force_version_override" == "true" ]]; then
+        # Skip the following version checking code.
+        return 0
+    fi
+
+    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=$(compressed_or_uncompressed "$dkms_tree/$module/$module_version/$1/$2/module/" "${4}")
+
+    local cmp_res="$(compare_module_version "${kernels_module}" "${dkms_module}")"
+    if [[ "${cmp_res}" = ">" ]]; then
+        if [[ ! "$force" ]]; then
+            error $"Module version $(get_module_verinfo "${dkms_module}" | head -n 1) for $4${module_suffix}" \
+                $"is not newer than what is already found in kernel $1 ($(get_module_verinfo "${kernels_module}" | head -n 1))." \
+                $"You may override by specifying --force."
+            return 1
+        fi
+    elif [[ "${cmp_res}" = "==" ]]; then
+        if [[ ! "$force" ]]; then
+            # if the module has neither version nor srcversion/checksum, check the binary files instead
+            local verinfo="$(get_module_verinfo "${dkms_module}")"
+            if [[ "$(echo "$verinfo" | tr -d '[:space:]')" ]] || diff "${kernels_module}" "${dkms_module}" &>/dev/null; then
+                echo $"Module version $(echo "$verinfo" | head -n 1) 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
+        fi
+    fi
+    return 0
+}
+
+check_module_args() {
+    [[ $module && $module_version ]] && return
+    die 1 $"Arguments <module> and <module-version> are not specified." \
+        $"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: ${3:-$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
+}
+
+# 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()
+{
+    # 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
+    check_module_args add
+
+    # Do stuff for --rpm_safe_upgrade
+    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 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
+        die 2 $"Could not find module source directory." \
+            $"Directory: $source_tree/$module-$module_version does not exist."
+    fi
+
+    # Check the conf file for sanity
+    read_conf_or_die "$kernelver" "$arch" "$conf"
+
+    # Create the necessary dkms tree structure
+    echo $"Creating symlink $dkms_tree/$module/$module_version/source -> $source_tree/$module-$module_version"
+    mkdir -p "$dkms_tree/$module/$module_version/build"
+    ln -s "$source_tree/$module-$module_version" "$dkms_tree/$module/$module_version/source"
+
+    # Run the post_add script
+    run_build_script post_add "$post_add"
+}
+
+# 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
+
+    set_kernel_source_dir_and_kconfig "$1"
+
+    # Check that kernel-source exists
+    _check_kernel_dir "$1" || {
+        die 1 $"Your kernel headers for kernel $1 cannot be found at $install_tree/$1/build or $install_tree/$1/source." \
+            $"Please install the linux-headers-$1 package or use the --kernelsourcedir option to tell DKMS where it's located."
+    }
+}
+
+prepare_signing()
+{
+    do_signing=0
+
+    if [[ ! -f ${kernel_config} ]]; then
+        echo "Kernel config ${kernel_config} not found, modules won't be signed"
+        return
+    fi
+
+    if ! grep -q "^CONFIG_MODULE_SIG_HASH=" "${kernel_config}"; then
+        echo "The kernel is built without module signing facility, modules won't be signed"
+        return
+    fi
+
+    sign_hash=$(grep "^CONFIG_MODULE_SIG_HASH=" "${kernel_config}" | cut -f2 -d= | sed 's/"//g')
+
+    # Lazy source in signing related configuration
+    read_framework_conf $dkms_framework_signing_variables
+
+    if [[ ! ${sign_file} ]]; then
+        case "$running_distribution" in
+            debian* )
+                sign_file="/usr/lib/linux-kbuild-${kernelver%.*}/scripts/sign-file"
+                ;;
+            ubuntu* )
+                sign_file="$(command -v kmodsign)"
+                if [[ ! -x "${sign_file}" ]]; then
+                    sign_file="/usr/src/linux-headers-$kernelver/scripts/sign-file"
+                fi
+                ;;
+        esac
+        if [[ ! -f ${sign_file} ]]; then
+            sign_file="$install_tree/$kernelver/build/scripts/sign-file"
+        fi
+    fi
+    echo "Sign command: $sign_file"
+
+    if [[ ! -f ${sign_file} || ! -x ${sign_file} ]]; then
+        echo "Binary ${sign_file} not found, modules won't be signed"
+        return
+    fi
+
+    if [[ -z "${mok_signing_key}" ]]; then
+        # No custom key specified, use the default key created by update-secureboot-policy for Ubuntu
+        # Debian's update-secureboot-policy has no --new-key option
+        case "$running_distribution" in
+            ubuntu* )
+                mok_signing_key="/var/lib/shim-signed/mok/MOK.priv"
+                mok_certificate="/var/lib/shim-signed/mok/MOK.der"
+
+                if [[ ! -f ${mok_signing_key} || ! -f ${mok_certificate} ]]; then
+                    if [[ ! -x "$(command -v update-secureboot-policy)" ]]; then
+                        echo "Binary update-secureboot-policy not found, modules won't be signed"
+                        return
+                    fi
+                    # update-secureboot-policy won't create new key if $mok_certificate exists
+                    if [[ -f ${mok_certificate} ]]; then
+                        rm -f "${mok_certificate}"
+                    fi
+                    echo "Certificate or key are missing, generating them using update-secureboot-policy..."
+                    SHIM_NOTRIGGER=y update-secureboot-policy --new-key &>/dev/null
+                    update-secureboot-policy --enroll-key
+                fi
+
+                ;;
+        esac
+    fi
+
+    if [[ ! ${mok_signing_key} ]]; then
+        mok_signing_key="/var/lib/dkms/mok.key"
+    fi
+    echo "Signing key: $mok_signing_key"
+
+    if [[ ! ${mok_certificate} ]]; then
+        mok_certificate="/var/lib/dkms/mok.pub"
+    fi
+    echo "Public certificate (MOK): $mok_certificate"
+
+    # scripts/sign-file.c in kernel source also supports using "pkcs11:..." as private key
+    if [[ $mok_signing_key != "pkcs11:"* ]] && ( [[ ! -f $mok_signing_key || ! -f $mok_certificate ]] ); then
+        echo "Certificate or key are missing, generating self signed certificate for MOK..."
+        if ! command -v openssl >/dev/null; then
+            echo "openssl not found, can't generate key and certificate."
+            return
+        fi
+        openssl req -new -x509 -nodes -days 36500 -subj "/CN=DKMS module signing key" \
+            -newkey rsa:2048 -keyout "$mok_signing_key" \
+            -outform DER -out "$mok_certificate" > /dev/null 2>&1
+        if [[ ! -f ${mok_signing_key} ]]; then
+            echo "Key file ${mok_signing_key} not found and can't be generated, modules won't be signed"
+            return
+        fi
+    fi
+
+    if [[ ! -f ${mok_certificate} ]]; then
+        echo "Certificate file ${mok_certificate} not found and can't be generated, modules won't be signed"
+        return
+    fi
+
+    do_signing=1
+}
+
+# Get ready to build a module that has been registered with DKMS.
+prepare_build()
+{
+    # If the module has not been added, try to add it.
+    is_module_added "$module" "$module_version" || add_module
+
+    local -r base_dir="$dkms_tree/$module/$module_version/$kernelver/$arch"
+    local -r build_dir="$dkms_tree/$module/$module_version/build"
+    local -r source_dir="$dkms_tree/$module/$module_version/source"
+
+    # Check that the module has not already been built for this kernel
+    [[ -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"
+    read_conf_or_die "$kernelver" "$arch"
+
+    # Error out if build_exclude is set
+    [[ $build_exclude ]] && diewarn 77 \
+        $"The $base_dir/dkms.conf"\
+        $"for module $module includes a BUILD_EXCLUSIVE directive"\
+        $"which does not match this kernel/arch/config."\
+        $"This indicates that it should not be built."
+
+    # Error out if source_tree is basically empty (binary-only dkms tarball w/ --force check)
+    (($(ls $source_dir | wc -l | awk {'print $1'}) < 2)) && die 8 \
+        $"The directory $source_dir does not appear to have module source located within it."\
+        $"Build halted."
+
+    # Set up temporary build directory for build
+    rm -rf "$build_dir"
+    cp -a "$source_dir/" "$build_dir"
+
+    cd "$build_dir"
+
+    # Apply any patches
+    for p in "${patch_array[@]}"; do
+        [[ ! -e $build_dir/patches/$p ]] && \
+            report_build_problem 5 \
+            $" Patch $p as specified in dkms.conf cannot be" \
+            $"found in $build_dir/patches/."
+        invoke_command "patch -p1 < ./patches/$p" "applying patch $p" || \
+            report_build_problem 6 $"Application of patch $p failed." \
+            $"Check $build_dir for more information."
+    done
+
+    if [[ -f $kernel_source_dir/.kernelvariables ]]; then
+        export CC=$(echo -e "show-%:\n\t@echo \$(\$*)\ninclude $kernel_source_dir/.kernelvariables" | make -f - show-CC)
+    else
+        unset CC
+    fi
+
+    if [[ -e "${kernel_config}" ]]; then
+        local cc=$(sed -n 's|^CONFIG_CC_VERSION_TEXT="\([^ ]*\) .*"|\1|p' "${kernel_config}")
+        if command -v "$cc" >/dev/null; then
+            export CC="$cc"
+            export KERNEL_CC="$cc"
+        fi
+
+        if grep -q 'CONFIG_CC_IS_CLANG=y' "${kernel_config}"; then
+            local cc=clang
+            if command -v "$cc" >/dev/null; then
+                export CC="$cc"
+                export KERNEL_CC="$cc"
+            fi
+        fi
+
+        if grep -q 'CONFIG_LD_IS_LLD=y' "${kernel_config}"; then
+            local ld=ld.lld
+            if command -v "$ld" >/dev/null; then
+                export LD="$ld"
+                export KERNEL_LD="$ld"
+            fi
+        fi
+    fi
+
+    # Run the pre_build script
+    run_build_script pre_build "$pre_build"
+}
+
+# Build our previously prepared source tree.  prepare_build must be called
+# before calling this function.
+actual_build()
+{
+    local -r base_dir="$dkms_tree/$module/$module_version/$kernelver/$arch"
+    local -r build_dir="$dkms_tree/$module/$module_version/build"
+    local -r build_log="$build_dir/make.log"
+
+    echo $""
+    echo $"Building module:"
+
+    invoke_command "$clean" "Cleaning build area" '' background
+    echo $"DKMS make.log for $module-$module_version for kernel $kernelver ($arch)" >> "$build_log"
+    date >> "$build_log"
+    local the_make_command="${make_command/#make/make -j$parallel_jobs KERNELRELEASE=$kernelver}"
+
+    invoke_command "$the_make_command" "Building module(s)" "$build_log" background || \
+        report_build_problem 10 $"Bad return status for module build on kernel: $kernelver ($arch)" \
+        $"Consult $build_log for more information."
+
+    # Make sure all the modules built successfully
+    for ((count=0; count < ${#built_module_name[@]}; count++)); do
+        [[ -e ${built_module_location[$count]}${built_module_name[$count]}$module_uncompressed_suffix ]] && continue
+        report_build_problem 7 \
+            $" Build of ${built_module_name[$count]}$module_uncompressed_suffix failed for: $kernelver ($arch)" \
+            $"Make sure the name of the generated module is correct and at the root of the" \
+            $"build directory, or consult make.log in the build directory" \
+            $"$build_dir for more information."
+    done
+    cd - >/dev/null
+
+    # Build success, so create DKMS structure for a built module
+    mkdir -p "$base_dir/log"
+    [[ $kernel_config ]] && cp -f "$kernel_config" "$base_dir/log/"
+    mv -f "$build_log" "$base_dir/log/make.log" 2>/dev/null
+
+    # Save a copy of the new module
+    mkdir "$base_dir/module" >/dev/null
+    for ((count=0; count < ${#built_module_name[@]}; count++)); do
+        local the_module="$build_dir/${built_module_location[$count]}${built_module_name[$count]}"
+        local built_module="$the_module$module_uncompressed_suffix"
+        local compressed_module="$the_module$module_suffix"
+
+        [[ ${strip[$count]} != no ]] && strip -g "$built_module"
+
+        if (( do_signing )); then
+            echo "Signing module $built_module"
+            "$sign_file" "$sign_hash" "$mok_signing_key" "$mok_certificate" "$built_module"
+        fi
+
+        if [[ $module_compressed_suffix = .gz ]]; then
+            gzip -9f "$built_module" || compressed_module=""
+        elif [[ $module_compressed_suffix = .xz ]]; then
+            xz --check=crc32 --lzma2=dict=1MiB -f "$built_module" || compressed_module=""
+        elif [[ $module_compressed_suffix = .zst ]]; then
+            zstd -q -f -T0 -19 "$built_module" || compressed_module=""
+        fi
+        if [[ -n $compressed_module ]]; then
+            cp -f "$compressed_module" "$base_dir/module/${dest_module_name[$count]}$module_suffix" >/dev/null
+        else
+            cp -f "$built_module" "$base_dir/module/${dest_module_name[$count]}$module_uncompressed_suffix" >/dev/null
+        fi
+    done
+
+    # Run the post_build script
+    run_build_script post_build "$post_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
+
+    # Clean the build directory
+    rm -rf "$dkms_tree/$module/$module_version/build"
+}
+
+do_build()
+{
+    set_kernel_source_dir_and_kconfig "$kernelver"
+    prepare_kernel "$kernelver" "$arch"
+    prepare_signing
+    prepare_build
+    actual_build
+    clean_build
+}
+
+# Force the installation of a module if this is listed
+# in the files in $forced_modules_dir, if any
+force_installation()
+{
+    forced_modules_dir="/usr/share/dkms/modules_to_force_install"
+    to_force=""
+    if [[ -d $forced_modules_dir ]]; then
+        for elem in $forced_modules_dir/*; do
+            if [[ -e $elem ]]; then
+                to_force="$to_force $(cat $elem)"
+            fi
+        done
+
+        for elem in $to_force; do
+            if [[ ${1} = ${elem} ]]; then
+                echo "force"
+                return 0
+            elif [[ ${1}_version-override = ${elem} ]]; then
+                echo "version-override"
+                return 0
+            fi
+        done
+    fi
+    return 1
+}
+
+# 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.
+do_install()
+{
+    # If the module has not been built, try to build it first.
+    is_module_built "$module" "$module_version" "$kernelver" "$arch" || do_build
+    local base_dir="$dkms_tree/$module/$module_version/$kernelver/$arch"
+
+    # Save the status of $force
+    tmp_force="$force"
+
+    # If the module is set to be force-installed
+    local ret=$(force_installation $module)
+    if [[ "$ret" == "force" ]];then
+        force="true"
+        echo "Forcing installation of $module"
+    elif [[ "$ret" == "version-override" ]];then
+        force_version_override="true"
+        echo "Forcing version override of $module"
+    fi
+    # 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 any_module_installed
+    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 m=${dest_module_name[$count]}
+        local installed_modules=$(find_module "$lib_tree" "$m")
+        local module_count=${#installed_modules[@]}
+        echo $" - Original module"
+        local original_copy=$(compressed_or_uncompressed "$dkms_tree/$module/original_module/$kernelver/$arch" "$m")
+        if [[ -L $dkms_tree/$module/kernel-$kernelver-$arch &&
+            -n "$original_copy" ]]; then
+            echo $"   - An original module was already stored during a previous install"
+        elif ! [[ -L $dkms_tree/$module/kernel-$kernelver-$arch ]]; then
+            local archive_pref1=$(compressed_or_uncompressed "$lib_tree/extra" "$m")
+            local archive_pref2=$(compressed_or_uncompressed "$lib_tree/updates" "$m")
+            local archive_pref3=$(compressed_or_uncompressed "$lib_tree${dest_module_location[$count]}" "$m")
+            local archive_pref4=""
+            ((module_count == 1)) && archive_pref4=${installed_modules[0]}
+            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 $m$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_module "$lib_tree" "$m"); do
+                dup_tree="${module_dup#$lib_tree}";
+                dup_name="${module_dup##*/}"
+                dup_tree="${dup_tree/${dup_name}}"
+                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]}
+        [[ $symlink_modules ]] && symlink="-s"
+        local toinstall=$(compressed_or_uncompressed "$base_dir/module" "$m")
+        cp -f $symlink "$toinstall" "$install_tree/$kernelver${dest_module_location[$count]}/${toinstall##*/}"
+        any_module_installed=1
+
+    done
+
+    if ((${#built_module_name[@]} > 0)) && [[ ! "${any_module_installed}" ]]; then
+        die 6 $"Installation aborted."
+    fi
+
+    # 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 [[ -z $NO_WEAK_MODULES ]]; then
+        if [[ ${weak_modules} ]]; then
+            echo $"Adding any weak-modules"
+            list_each_installed_module "$module" "$kernelver" "$arch" | ${weak_modules} ${weak_modules_no_initrd} --add-modules
+        fi
+    fi
+
+    # Run the post_install script
+    run_build_script post_install "$post_install"
+
+    invoke_command "do_depmod $kernelver" "depmod" '' background || {
+        do_uninstall "$kernelver" "$arch"
+        die 6 $"Problems with depmod detected. Automatically uninstalling this module." \
+            $"Install Failed (depmod problems). Module rolled back to built state."
+        exit 6
+    }
+
+    if [[ $modprobe_on_install ]]; then
+        # Make the newly installed modules available immediately
+        find /sys/devices -name modalias -print0 | xargs -0 cat | sort -u | xargs modprobe -a -b -q
+        if [[ -f /lib/systemd/system/systemd-modules-load.service ]]; then
+            systemctl restart systemd-modules-load.service
+        fi
+    fi
+
+    # Restore the status of $force
+    force="$tmp_force"
+}
+
+# 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
+    local mod
+    for ((count=0; count < ${#built_module_name[@]}; count++)); do
+        real_dest_module_location="$(find_actual_dest_module_location $1 $count $2 $3)"
+        mod=$(compressed_or_uncompressed "$install_tree/$2${real_dest_module_location}" "${dest_module_name[$count]}")
+        echo "$mod"
+    done
+}
+
+# Check if either the module source, or the symlink pointing to it is missing
+# A module can only be in this broken state, if the user or a faulty program
+# messed up. The module then is considered volatile, because there is no reliable
+# way to tell if files in the source tree are still in a valid state.
+# Therefor any action (except 'add', if only the symlink is missing)
+# to operate on the module has to be refused.
+# Manual intervention by the user is required to return to a sane state.
+is_module_broken() {
+    [[ $1 && $2 ]] || return 1
+    [[ -d $dkms_tree/$1/$2 ]] || return 2
+    [[ -L $dkms_tree/$1/$2/source && ! -d $dkms_tree/$1/$2/source ]] && return
+    [[ ! -L $dkms_tree/$1/$2/source && -d $source_tree/$1-$2/ ]] && return
+}
+
+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 ]] || return 2
+}
+
+is_module_built() {
+    [[ $1 && $2 && $3 && $4 ]] || return 1
+    local d="$dkms_tree/$1/$2/$3/$4" m=''
+    [[ -d $d/module ]] || return 1
+    local default_conf="$dkms_tree/$1/$2/source/dkms.conf"
+    # If a custom dkms.conf was specified use it, otherwise use the default one.
+    local real_conf="${conf:-${default_conf}}"
+    read_conf_or_die "$3" "$4" "$real_conf"
+    set_module_suffix "$3"
+    for m in "${dest_module_name[@]}"; do
+        local t=$(compressed_or_uncompressed "$d/module" "$m")
+        test -n "$t" || 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" && {
+        if [[ "$force" = "true" ]]; then
+            do_unbuild "$3" "$4"
+        else
+            echo $"Module $1/$2 already built for kernel $3 ($4), skip." \
+                 $"You may override by specifying --force."
+            return 0
+        fi
+    }
+    module="$1" module_version="$2" kernelver="$3" arch="$4" do_build
+)
+
+maybe_install_module() (
+    is_module_installed "$1" "$2" "$3" "$4" && {
+        if [[ "$force" = "true" ]]; then
+            do_uninstall "$3" "$4"
+        else
+            echo $"Module $1/$2 already installed on kernel $3 ($4), skip." \
+                 $"You may override by specifying --force."
+            return 0
+        fi
+    }
+    module="$1" module_version="$2" kernelver="$3" arch="$4" do_install
+)
+
+build_module() {
+    local i=0
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+        maybe_build_module "$module" "$module_version" "${kernelver[$i]}" "${arch[$i]}"
+    done
+}
+
+install_module() {
+    local i=0
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+        maybe_install_module "$module" "$module_version" "${kernelver[$i]}" "${arch[$i]}"
+    done
+}
+
+possible_dest_module_locations()
+{
+    # $1 = count
+    # There are two places an installed module may really be:
+    # 1) "$install_tree/$kernelver/${dest_module_location[$count]}/${dest_module_name[$count]}$module_suffix"
+    # 2) "$install_tree/$kernelver/${DEST_MODULE_LOCATION[$count]}/${dest_module_name[$count]}$module_suffix"
+    # override_dest_module_location() is what controls whether or not they're the same.
+
+    local location
+    location[0]="${dest_module_location[$count]}"
+    [[ ${DEST_MODULE_LOCATION[$count]} != ${dest_module_location[$count]} ]] && \
+    location[1]="${DEST_MODULE_LOCATION[$count]}"
+
+    echo "${location[@]}"
+}
+
+find_actual_dest_module_location()
+{
+    local module="$1"
+    local count="$2"
+    local kernelver="$3"
+    local arch="$4"
+    local locations="$(possible_dest_module_locations $count)"
+    local l
+    local dkms_owned
+    local installed
+    dkms_owned=$(compressed_or_uncompressed "${dkms_tree}/${module}/kernel-${kernelver}-${arch}/module" "${dest_module_name[$count]}")
+
+    for l in $locations; do
+        installed=$(compressed_or_uncompressed "${install_tree}/${kernelver}${l}" "${dest_module_name[${count}]}")
+        if [[ -n "${installed}" ]] && compare_module_version "${dkms_owned}" "${installed}" &>/dev/null; then
+            echo "${l}"
+            return 0
+        fi
+    done
+
+}
+
+# Remove compiled DKMS modules from any kernels they are installed in.
+do_uninstall()
+{
+    # $1 = kernel version
+    # $2 = arch
+
+    echo $"Module $module-$module_version for kernel $1 ($2)."
+
+    set_module_suffix "$1"
+
+    # If kernel-<kernelver> symlink points to this module, check for original_module and put it back
+    local was_active=""
+    local kernel_symlink=$(readlink -f "$dkms_tree/$module/kernel-$1-$2")
+    local real_dest_module_location
+    if [[ $kernel_symlink = $dkms_tree/$module/$module_version/$1/$2 ]]; then
+        was_active="true"
+        echo $"Before uninstall, this module version was ACTIVE on this kernel."
+        # remove kabi-tracking if last instance removed
+        if [[ -z $NO_WEAK_MODULES ]]; then
+            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} ${weak_modules_no_initrd} --remove-modules
+            fi
+        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"
+            if [[ ${real_dest_module_location} ]]; then
+                echo $"   - Deleting from: $install_tree/$1${real_dest_module_location}/"
+                rm -f "$install_tree/$1${real_dest_module_location}/${dest_module_name[$count]}$module_uncompressed_suffix"*
+                dir_to_remove="${real_dest_module_location#/}"
+                while [[ ${dir_to_remove} != ${dir_to_remove#/} ]]; do
+                    dir_to_remove="${dir_to_remove#/}"
+                done
+                (if cd "$install_tree/$1"; then rpm -qf "${dir_to_remove}" >/dev/null 2>&1 || rmdir -p --ignore-fail-on-non-empty "${dir_to_remove}"; fi || true)
+            else
+                echo $"   - Module was not found within $install_tree/$1/"
+            fi
+            echo $" - Original module"
+            local origmod=$(compressed_or_uncompressed "$dkms_tree/$module/original_module/$1/$2" "${dest_module_name[$count]}")
+            if [[ -n $origmod ]]; 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 "$origmod" "$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."
+            fi
+        done
+        rm -f "$dkms_tree/$module/kernel-$1-$2"
+    else
+        echo $"This module version was INACTIVE for this kernel."
+    fi
+
+    # Run the post_remove script
+    run_build_script post_remove "$post_remove"
+
+    # Run depmod because we changed $install_tree
+    invoke_command "do_depmod $1" "depmod" '' background
+
+    # Delete the original_module if nothing for this kernel is installed anymore
+    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
+    [[ $(find $dkms_tree/$module/original_module/* -maxdepth 0 -type d 2>/dev/null) ]] || rm -rf "$dkms_tree/$module/original_module"
+}
+
+module_is_broken_and_die() {
+    is_module_broken "$module" "$module_version" && die 4 $"$module/$module_version is broken!"\
+        $"Missing the source directory or the symbolic link pointing to it."\
+        $"Manual intervention is required!"
+}
+
+module_is_added_or_die()
+{
+    is_module_added "$module" "$module_version" || die 3 \
+        $"The module/version combo: $module-$module_version is not located in the DKMS tree."
+}
+
+maybe_unbuild_module()
+{
+    is_module_built "$module" "$module_version" "$1" "$2" || {
+        echo $"Module $module $module_version is not built for kernel $1 ($2)."\
+            $"Skipping..."
+        return 0
+    }
+
+    do_unbuild "$1" "$2"
+}
+
+maybe_uninstall_module()
+{
+    is_module_installed "$module" "$module_version" "$1" "$2" || {
+        echo $"Module $module $module_version is not installed for kernel $1 ($2)."\
+            $"Skipping..."
+        return 0
+    }
+    do_uninstall "$1" "$2"
+}
+
+uninstall_module()
+{
+    local i
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+        maybe_uninstall_module "${kernelver[$i]}" "${arch[$i]}"
+    done
+}
+
+do_unbuild()
+{
+    # Delete or "unbuild" the $kernel_version/$arch_used part of the tree
+    rm -rf "$dkms_tree/$module/$module_version/$1/$2"
+    [[ $(find $dkms_tree/$module/$module_version/$1/* -maxdepth 0 -type d 2>/dev/null) ]] || \
+        rm -rf "$dkms_tree/$module/$module_version/$1"
+}
+
+# Remove the build module, w/o removing/unregistering it.
+# This uninstalls any installed modules along the way
+unbuild_module()
+{
+    local i
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+        maybe_uninstall_module "${kernelver[$i]}" "${arch[$i]}"
+        maybe_unbuild_module "${kernelver[$i]}" "${arch[$i]}"
+    done
+}
+
+# Unregister a DKMS module.  This uninstalls any installed modules along the way.
+remove_module()
+{
+    # 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 $"Remove cancelled because --rpm_safe_upgrade scenario detected."
+        done
+    fi
+
+    local i
+    for ((i=0; i < ${#kernelver[@]}; i++)); do
+        maybe_uninstall_module "${kernelver[$i]}" "${arch[$i]}"
+        maybe_unbuild_module "${kernelver[$i]}" "${arch[$i]}"
+    done
+
+    # Delete the $module_version part of the tree if no other $module_version/$kernel_version dirs exist
+    if ! find $dkms_tree/$module/$module_version/* -maxdepth 0 -type d 2>/dev/null | grep -Eqv "(build|tarball|driver_disk|rpm|deb|source)$"; then
+        echo $"Deleting module $module-$module_version completely from the DKMS tree."
+        rm -rf "$dkms_tree/$module/$module_version"
+    fi
+
+    # Get rid of any remnant directories if necessary
+    if (($(ls "$dkms_tree/$module" | wc -w | awk '{print $1}') == 0)); then
+        rm -rf "$dkms_tree/$module" 2>/dev/null
+    fi
+}
+
+# Given a kernel object, figure out which DKMS module it is from.
+find_module_from_ko()
+{
+    local ko="$1"
+    local basename_ko="${ko##*/}"
+    local module
+    local kernellink
+
+    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
+}
+
+# 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
+    [[ -z $NO_WEAK_MODULES ]] || return 1
+    [[ $weak_modules ]] || return 1
+    local m v k a kern 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
+        already_found[$m/$v/$kern/$a/$k]+=${weak_ko##*/}" "
+    done
+    # Check to see that all ko's are present for each module
+    for mod in ${!already_found[@]}; do
+        IFS=/ read m v k a kern <<< "$mod"
+        # ensure each module is weak linked
+        for installed_ko in $(find $dkms_tree/$m/$v/$kern/$a/module -type f); do
+            [[ ${already_found[$mod]} != *"$installed_ko"* ]] && continue 2
+        done
+        ret=0
+        echo "installed-weak $mod"
+    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" 2>/dev/null
+    [[ -d $dkms_tree/$1/original_module/$3/$4 ]] && echo -n " (original_module exists)"
+    for ((count=0; count < ${#dest_module_name[@]}; count++)); do
+        tree_mod=$(compressed_or_uncompressed "$dkms_tree/$1/$2/$3/$4/module" "${dest_module_name[$count]}")
+        if ! [[ -n "$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")"
+            real_dest_mod=$(compressed_or_uncompressed "$install_tree/$3${real_dest}" "${dest_module_name[$count]}")
+            if ! diff -q "$tree_mod" "$real_dest_mod" >/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 inconvenient.
+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_broken "$m" "$v" && { echo "broken $m/$v"; continue; }
+        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
+    # separate deprecation warnings from status output
+    local tmpfile=$(mktemp_or_die)
+    (module_status "$@") >"$tmpfile"
+    while read status mvka; do
+        IFS=/ read m v k a <<< "$mvka"
+        case $status in
+            broken)
+                echo "$m/$v: $status"
+                error $"$m/$v: Missing the module source directory or the symbolic link pointing to it."\
+                    $"Manual intervention is required!"
+                ;;
+            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 < "$tmpfile"
+    rm "$tmpfile"
+}
+
+# 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
+}
+
+make_tarball()
+{
+    # Read the conf file
+    read_conf_or_die "$kernelver" "$arch"
+
+    local -r temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
+    trap "rm -rf $temp_dir_name" EXIT
+    mkdir -p $temp_dir_name/dkms_main_tree
+
+    if [[ $source_only ]]; then
+    kernel_version_list="source-only"
+    else
+    local i
+    for ((i=0; i<${#kernelver[@]}; i++)); do
+        local -r intree_module_dir="$dkms_tree/$module/$module_version/${kernelver[$i]}/${arch[$i]}"
+        local -r temp_module_dir="$temp_dir_name/dkms_main_tree/${kernelver[$i]}"
+
+        if ! [[ -d "$intree_module_dir" ]]; then
+            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_module_dir"
+        cp -rf "$intree_module_dir" "$temp_module_dir"
+    done
+    fi
+
+    local -r source_dir="$dkms_tree/$module/$module_version/source"
+
+    # Copy the source_tree or make special binaries-only structure
+    if [[ $binaries_only ]]; then
+        local -r binary_only_dir="$temp_dir_name/dkms_binaries_only"
+
+        echo $""
+        echo $"Creating tarball structure to specifically accomodate binaries."
+
+        mkdir "$binary_only_dir"
+        echo "$module" > "$binary_only_dir/PACKAGE_NAME"
+        echo "$module_version" > "$binary_only_dir/PACKAGE_VERSION"
+        [[ ! $conf ]] && conf="$source_dir/dkms.conf"
+        cp -f $conf "$binary_only_dir/" 2>/dev/null
+    else
+        echo $""
+        echo $"Marking $source_dir for archiving..."
+        mkdir -p $temp_dir_name/dkms_source_tree
+        cp -rf $source_dir/* $temp_dir_name/dkms_source_tree
+    fi
+
+    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"
+    local tarball_dest="$dkms_tree/$module/$module_version/tarball/"
+
+    if [[ $archive_location ]]; then
+        tarball_name="${archive_location##*/}"
+        if [[ ${archive_location%/*} != $archive_location ]]; then
+            tarball_dest="${archive_location%/*}"
+        fi
+    fi
+
+    echo $""
+    echo $"Tarball location: $tarball_dest/$tarball_name"
+
+    if [[ ! -d $tarball_dest ]]; then
+        if ! mkdir -p "$tarball_dest" 2>/dev/null; then
+            die 9 $"Missing write permissions for $tarball_dest."
+        fi
+    fi
+
+    [[ -w $tarball_dest ]] || die 9 $"Missing write permissions for $tarball_dest."
+
+    if ! tar -C $temp_dir_name -caf $tarball_dest/$tarball_name . 2>/dev/null; then
+        die 6 $"Failed to make tarball."
+    fi
+}
+
+# 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()
+{
+    # Error out if $archive_location does not exist
+    if [[ ! -e $archive_location ]]; then
+        die 2 $"$archive_location does not exist."
+    fi
+
+    # 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
+
+    # Untar it into $tmp_location
+    local -r temp_dir_name=$(mktemp_or_die -d $tmp_location/dkms.XXXXXX)
+    trap "rm -rf $temp_dir_name" EXIT
+    tar -xaf $archive_location -C $temp_dir_name
+
+    if [[ ! -d $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
+        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. 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
+        # Success!
+        break
+    done
+
+    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
+                local -r source_dir="$dkms_tree/$module/$module_version/source"
+
+                echo $"Creating $source_dir"
+                mkdir -p "$source_dir"
+                echo $"Copying dkms.conf to $source_dir ..."
+                cp -rf "$temp_dir_name/dkms_binaries_only/dkms.conf" "$source_dir"
+            fi
+            ;;
+    esac
+
+    # 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.
+
+    # Load precompiled modules.
+    for directory in "$temp_dir_name/dkms_main_tree"/*/*; do
+        [[ -d $directory ]] || continue
+
+        local -r kernel_arch_to_load=${directory/*dkms_main_tree\/}
+        local -r 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
+
+    [[ $loc != dkms_binaries_only ]] || [[ -d $source_tree/$module-$module_version ]]
+}
+
+run_match()
+{
+    set_kernel_source_dir_and_kconfig "$kernelver"
+
+    # Error if $template_kernel is unset
+    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 ]]; 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=$(do_status '' '' $template_kernel $arch | grep ": installed")
+
+    # If $module is set, grep the status only for that 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 ($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 [[ ! $template_kernel_status ]]; then
+        echo $""
+        echo $"There is nothing to be done for this match."
+        return 0
+    fi
+
+    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 $"Module:  $template_module"
+        echo $"Version: $template_version"
+
+        # Continue if the status is broken, as there is nothing we can do
+        if is_module_broken "$template_module" "$template_version"; then
+            error $"$template_module/$template_version is broken!"\
+                $"Missing the source directory or the symbolic link pointing to it."\
+                $"Manual intervention is required!"
+            continue
+        fi
+        maybe_build_module "$template_module" "$template_version" "$kernelver" "$arch"
+        maybe_install_module "$template_module" "$template_version" "$kernelver" "$arch"
+    done < <(echo "$template_kernel_status")
+}
+
+report_build_problem()
+{
+    # If apport is on the system, files a build problem
+    if [[ -x /usr/share/apport/apport ]] && which python3 >/dev/null; then
+        python3 /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
+}
+
+# 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 convenient 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() {
+    [[ $(id -u) = 0 ]] && return
+    die 1 $"You must be root to use this command."
+}
+
+check_rw_dkms_tree() {
+    [[ -w "$dkms_tree" ]] && return
+    die 1 $"No write access to DKMS tree at ${dkms_tree}"
+}
+
+# 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"
+}
+
+# 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
+    local progress next_depends
+    local -a to_install=()
+    local -a next_install=()
+    local -a known_modules=()
+    local -a installed_modules=()
+    local -a skipped_modules=()
+    local -a failed_modules=()
+    local -A build_depends=()
+    local -A latest=()
+
+    # Walk through our list of installed and built modules, and create
+    # a list of modules and their latest version.
+    while read status mvka; do
+        IFS='/' read m v k a <<< "$mvka"
+        # If the module status is broken there is nothing that can be done
+        if [[ $status = broken ]]; then
+            error $"$m/$v is broken! Missing the source directory or the symbolic link pointing to it."\
+                $"Manual intervention is required!"
+            continue
+        fi
+        if [[ -z ${latest[$m]} ]]; then
+            known_modules[${#known_modules[@]}]="$m"
+            latest[$m]="$v"
+        elif [[ ("$(VER "$v")" > "$(VER "${latest["$m"]}")") ]]; then
+            latest["$m"]="$v"
+        fi
+    done < <(module_status)
+
+    # Walk through our list of known modules, and create
+    # a list of modules that need to be reinstalled.
+    for m in "${known_modules[@]}"; do
+        v="${latest["$m"]}"
+        # If the module is already installed or weak-installed, skip it.
+        if _is_module_installed "$m" "$v" "$kernelver" "$arch"; then
+            installed_modules[${#installed_modules[@]}]="$m"
+            continue
+        fi
+        if module_status_weak "$m" "$v" "$kernelver" "$arch" >/dev/null; then
+            installed_modules[${#installed_modules[@]}]="$m"
+            continue
+        fi
+        # If the module does not want to be autoinstalled, skip it.
+        read_conf_or_die "$kernelver" "$arch" "$dkms_tree/$m/$v/source/dkms.conf"
+        if [[ ! $AUTOINSTALL ]]; then
+            continue
+        fi
+        # Otherwise, autoinstall the latest version we have hanging around.
+        to_install[${#to_install[@]}]="$m/$v"
+        build_depends["$m"]="${BUILD_DEPENDS[@]}"
+    done
+
+    [[ $to_install ]] || return 0
+
+    while true; do
+        progress=0
+        next_install=( )
+
+        # Step 1: Remove installed modules from all dependency lists.
+        for m in ${!build_depends[@]}; do
+            next_depends=
+            for d in ${build_depends[$m]}; do
+                for i in ${installed_modules[@]} ${skipped_modules[@]}; do
+                    [[ "$d" = "$i" ]] && continue 2
+                done
+                next_depends+="$d "
+            done
+            build_depends[$m]="${next_depends%% }"
+        done
+
+        # Step 2: Install modules that have an empty dependency list.
+        for mv in "${to_install[@]}"; do
+            IFS=/ read m v <<< "$mv"
+            if [[ -z ${build_depends[$m]} ]]; then
+                (module="$m" module_version="$v" kernelver="$kernelver" arch="$arch" install_module)
+                status=$?
+                if (( status == 0 )); then
+                    installed_modules[${#installed_modules[@]}]="$m"
+                    progress=$(($progress +1))
+                elif (( status == 77 )); then
+                    skipped_modules[${#skipped_modules[@]}]="$m"
+                    progress=$(($progress +1))
+                else
+                    failed_modules[${#failed_modules[@]}]="$m($status)"
+                fi
+            else
+                next_install[${#next_install[@]}]="$mv"
+            fi
+        done
+
+        wait
+
+        # Step 3: Remove modules that install was attempted for
+        # during Step 2 from the job queue.
+        to_install=( "${next_install[@]}" )
+
+        # Step 4: Keep going if at least one module was installed during
+        # this iteration.
+        (( progress > 0 )) || break;
+
+    done
+
+    if (( ${#installed_modules[@]} > 0 )); then
+        echo "dkms autoinstall on $kernelver/$arch succeeded for ${installed_modules[@]}"
+    fi
+
+    if (( ${#skipped_modules[@]} > 0 )); then
+        echo "dkms autoinstall on $kernelver/$arch was skipped for ${skipped_modules[@]}"
+    fi
+
+    if (( ${#failed_modules[@]} > 0 )); then
+        echo "dkms autoinstall on $kernelver/$arch failed for ${failed_modules[@]}"
+    fi
+
+    for mv in "${to_install[@]}"; do
+        IFS=/ read m v <<< "$mv"
+        echo "$m/$v autoinstall failed due to missing dependencies: ${build_depends[$m]}"
+    done
+
+    if (( ${#failed_modules[@]} > 0 || ${#to_install[@]} > 0 )); then
+        die 11 $"One or more modules failed to install during autoinstall." \
+            $"Refer to previous errors for more information."
+    fi
+}
+
+#############################
+####                     ####
+#### Program Starts Here ####
+####                     ####
+#############################
+
+# Ensure files and directories we create are readable to anyone,
+# since we aim to build as a non-root user
+umask 022
+
+# Unset environment variables that may interfere with the build
+unset CC CXX CFLAGS CXXFLAGS LDFLAGS
+
+# Set important variables
+current_kernel=$(uname -r)
+current_os=$(uname -s)
+running_distribution=$(distro_version) || exit
+dkms_tree="/var/lib/dkms"
+source_tree="/usr/src"
+install_tree="@MODDIR@"
+tmp_location=${TMPDIR:-/tmp}
+verbose=""
+symlink_modules=""
+
+# Check that we can write temporary files
+tmpfile=$(mktemp_or_die)
+echo "Hello, DKMS!" > "$tmpfile"
+if [[ "$(cat "$tmpfile")" != "Hello, DKMS!" ]]; then
+    warn $"dkms will not function properly without some free space in \$TMPDIR ($tmp_location)."
+fi
+rm -f "$tmpfile"
+
+# These can come from the environment or the config file
+[[ ! ${ADDON_MODULES_DIR} && -e /etc/sysconfig/module-init-tools ]] && . /etc/sysconfig/module-init-tools
+addon_modules_dir="${ADDON_MODULES_DIR}"
+weak_modules="${WEAK_MODULES_BIN}"
+
+# Source in configuration not related to signing
+read_framework_conf $dkms_framework_nonsigning_variables
+
+
+# Clear out command line argument variables
+module=""
+module_version=""
+template_kernel=""
+conf=""
+kernel_config=""
+kconfig_fromcli=""
+archive_location=""
+kernel_source_dir=""
+ksourcedir_fromcli=""
+action=""
+force=""
+force_version_override=""
+binaries_only=""
+source_only=""
+all=""
+module_suffix=""
+module_uncompressed_suffix=""
+module_compressed_suffix=""
+rpm_safe_upgrade=""
+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'
+no_depmod=""
+
+action_re='^(remove|(auto|un)?install|match|mktarball|(un)?build|add|status|ldtarball)$'
+
+# Parse command line arguments
+while (($# > 0)); do
+    case $1 in
+        --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"
+            ;;
+        --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 $"@RELEASE_STRING@"
+            exit 0
+            ;;
+        --no-initrd)
+            # This is an old option, consume and warn
+            deprecated $"--no-initrd"
+            ;;
+        --no-clean-kernel)
+            # This is an old option, consume and warn
+            deprecated $"--no-clean-kernel"
+            ;;
+        --no-prepare-kernel)
+            # This is an old option, consume and warn
+            deprecated $"--no-prepare-kernel"
+            ;;
+        --binaries-only)
+            binaries_only="binaries-only"
+            ;;
+        --source-only)
+            source_only="source-only"
+            ;;
+        --force)
+            force="true"
+            ;;
+        --force-version-override)
+            force_version_override="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
+            ;;
+        --symlink-modules)
+            symlink_module="true"
+            ;;
+        --config*)
+            read_arg kernel_config "$1" "$2" || shift
+            kconfig_fromcli="true"
+            ;;
+        --archive*)
+            read_arg archive_location "$1" "$2" || shift
+            ;;
+        --arch*|-a)
+            read_arg _aa "$1" "$2" || shift
+            arch[${#arch[@]}]="$_aa"
+            ;;
+        --kernelsourcedir*)
+            read_arg kernel_source_dir "$1" "$2" || shift
+            ksourcedir_fromcli="true"
+            ;;
+        --directive*)
+            read_arg _da "$1" "$2" || shift
+            directive_array[${#directive_array[@]}]="$_da"
+            ;;
+        --no-depmod)
+            no_depmod="true"
+            ;;
+        --modprobe-on-install)
+            modprobe_on_install="true"
+            ;;
+        --debug)
+            export PS4='${BASH_SOURCE}@${LINENO}(${FUNCNAME[0]}): '
+            set -x
+            ;;
+        -j)
+            read_arg parallel_jobs "$1" "$2" || shift
+            ;;
+        -*)
+            error $" Unknown option: $1"
+            show_usage
+            exit 2
+            ;;
+        *)
+            if [[ $1 =~ $action_re ]]; then
+                [[ $action ]] && die 4 $"Cannot specify more than one 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
+
+# The <(cmd) idiom does not work if /proc is not mounted
+read line < <(echo "Hello, DKMS!")
+if [[ $line != "Hello, DKMS!" ]]; then
+    warn $"dkms will not function properly if /proc is not mounted."
+fi
+
+# 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
+
+# Since initramfs/initrd rebuild is not requested, skip it with Redhat's weak-modules
+if [[ $weak_modules ]]; then
+    weak_modules_no_initrd="--no-initramfs"
+fi
+
+# Default to -j<number of CPUs>
+parallel_jobs=${parallel_jobs:-$(get_num_cpus)}
+
+# Make sure we're not passing -j0 to make; treat -j0 as just "-j"
+[[ "$parallel_jobs" = 0 ]] && parallel_jobs=""
+
+setup_kernels_arches "$action"
+case "$action" in
+remove | unbuild | uninstall)
+    check_module_args $action
+    module_is_broken_and_die
+    module_is_added_or_die
+    [[ $action = uninstall ]] && check_root || check_rw_dkms_tree
+    ${action}_module
+    ;;
+add | build | install)
+    check_all_is_banned $action # TODO: fix/enable --all
+    [[ $action != add ]] && module_is_broken_and_die
+    [[ $action = install ]] && check_root || check_rw_dkms_tree
+    ${action}_module
+    ;;
+autoinstall)
+    check_root && autoinstall
+    ;;
+match)
+    check_root && have_one_kernel "match" && run_match
+    ;;
+mktarball)
+    check_module_args mktarball
+    module_is_broken_and_die
+    module_is_added_or_die
+    make_tarball
+    ;;
+status)
+    show_status
+    ;;
+ldtarball) # Make sure they're root if we're using --force
+    if [[ $(id -u) != 0 ]] && [[ $force = true ]]; then
+        die 1 $"You must be root to use this command with the --force option."
+    fi
+    load_tarball && add_module
+    ;;
+*)
+    error $"Unknown action specified: \"$action\""
+    show_usage
+    ;;
+esac