#!/bin/bash

#

# weak-modules - determine which modules are kABI compatible with installed

#                kernels and set up the symlinks in /lib/*/weak-updates.

#

unset LANG LC_ALL LC_COLLATE

tmpdir=$(mktemp -td ${0##*/}.XXXXXX)

trap "rm -rf $tmpdir" EXIT

unset ${!changed_modules_*} ${!changed_initramfs_*}

unset BASEDIR

unset CHECK_INITRAMFS

weak_updates_dir_override=""

default_initramfs_prefix="/boot" # will be combined with BASEDIR

dracut="/sbin/dracut"

depmod="/sbin/depmod"

depmod_orig="$depmod"

declare -a modules

declare -A module_krels

declare -A weak_modules_before

declare -A groups

declare -A grouped_modules

# output of validate_weak_links, one iteration

# short_name -> path

declare -A compatible_modules

# state for update_modules_for_krel (needed for add_kernel case)

# short_name -> path

declare -A installed_modules

# doit:

# A wrapper used whenever we're going to perform a real operation.

doit() {

    [ -n "$verbose" ] && echo "$@"

    [ -n "$dry_run" ] || "$@"

}

# pr_verbose:

# print verbose -- wrapper used to print extra messages if required

pr_verbose() {

    [ -n "$verbose" ] && echo "$@"

}

# pr_warning:

# print warning

pr_warning() {

    echo "WARNING: $*"

}

# rpmsort: The sort in coreutils can't sort the RPM list how we want it so we

# instead transform the list into a form it will sort correctly, then sort.

rpmsort() {

    local IFS=$' '

    REVERSE=""

    rpmlist=($(cat))

    if [ "-r" == "$1" ];

    then

        REVERSE="-r"

    fi

    echo ${rpmlist[@]} | \

        sed -e 's/-/../g' | \

        sort ${REVERSE} -n -t"." -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 -k6,6 -k7,7 \

             -k8,8 -k9,9 -k10,10 | \

        sed -e 's/\.\./-/g'

}

# krel_of_module:

# Compute the kernel release of a module.

krel_of_module() {

    local module="$1"

    if [ x"${module_krels[$module]+set}" = x"set" ]; then

        # version cached in the array already

        echo "${module_krels[$module]}"

    elif [ -f "$module" ]; then

        krel_of_module_modinfo "$module"

    else

        # Try to extract the kernel release from the path

        # delete case, the .ko already deleted

        set -- "${module#*/lib/modules/}"

        echo "${1%%/*}"

    fi

}

# krel_of_module_modinfo:

# Fetches module version from internal module info

krel_of_module_modinfo() {

    local module="$1"

    /sbin/modinfo -F vermagic "$module" | awk '{print $1}'

}

# weak_updates_dir:

# gives the root directory for the weak-updates

# We need some flexibility here because of dry-run.

weak_updates_dir() {

    local krel="$1"

    if [[ -z "$weak_updates_dir_override" ]]; then

        echo "$BASEDIR/lib/modules/$krel/weak-updates"

    else

        echo "$weak_updates_dir_override"

    fi

}

# read_modules_list:

# Read in a list of modules from standard input. Convert the filenames into

# absolute paths and compute the kernel release for each module (either using

# the modinfo section or through the absolute path.

# If used with input redirect, should be used as read_module_list < input,

# not input | read_modules_list, the latter spawns a subshell

# and the arrays are not seen in the caller

read_modules_list() {

    local IFS=$'\n'

    modules=($(cat))

    for ((n = 0; n < ${#modules[@]}; n++)); do

        if [ ${modules[n]:0:1} != '/' ]; then

            modules[n]="$PWD/${modules[n]}"

        fi

        module_krels["${modules[n]}"]=$(krel_of_module ${modules[n]})

    done

}

decompress_initramfs() {

    local input=$1

    local output=$2

    # First, check if this is compressed at all

    if cpio -i -t < "$input" > /dev/null 2>/dev/null; then

        # If this archive contains a file early_cpio, it's a trick. Strip off

        # the early cpio archive and try again.

        if cpio -i -t < "$input" 2>/dev/null | grep -q '^early_cpio$' ; then

            /usr/lib/dracut/skipcpio "$input" > "${tmpdir}/post_early_cpio.img"

            decompress_initramfs "${tmpdir}/post_early_cpio.img" "$output"

            retval="$?"

            rm -f "${tmpdir}/post_early_cpio.img"

            return $retval

        fi

        cp "$input" "$output"

        return 0

    fi

    # Try gzip

    if gzip -cd < "$input" > "$output" 2>/dev/null ; then

        return 0

    fi

    # Next try xz

    if xz -cd < "$input" > "$output" 2>/dev/null ; then

        return 0

    fi

    echo "Unable to decompress $input: Unknown format" >&2

    return 1

}

# List all module files and modprobe configuration that could require a new

# initramfs. The current directory must be the root of the uncompressed

# initramfs. The unsorted list of files is output to stdout.

list_module_files() {

    find . -iname \*.ko -o -iname '*.ko.xz' -o -iname '*.ko.gz' 2>/dev/null

    find etc/modprobe.d usr/lib/modprobe.d -name \*.conf 2>/dev/null

}

# read_old_initramfs:

compare_initramfs_modules() {

    local old_initramfs=$1

    local new_initramfs=$2

    rm -rf "$tmpdir/old_initramfs"

    rm -rf "$tmpdir/new_initramfs"

    mkdir "$tmpdir/old_initramfs"

    mkdir "$tmpdir/new_initramfs"

    decompress_initramfs "$old_initramfs" "$tmpdir/old_initramfs.img"

    pushd "$tmpdir/old_initramfs" >/dev/null

    cpio -i < "$tmpdir/old_initramfs.img" 2>/dev/null

    rm "$tmpdir/old_initramfs.img"

    n=0; for i in `list_module_files|sort`; do

        old_initramfs_modules[n]="$i"

        n=$((n+1))

    done

    popd >/dev/null

    decompress_initramfs "$new_initramfs" "$tmpdir/new_initramfs.img"

    pushd "$tmpdir/new_initramfs" >/dev/null

    cpio -i < "$tmpdir/new_initramfs.img" 2>/dev/null

    rm "$tmpdir/new_initramfs.img"

    n=0; for i in `list_module_files|sort`; do

        new_initramfs_modules[n]="$i"

        n=$((n+1))

    done

    popd >/dev/null

    # Compare the length and contents of the arrays

    if [ "${#old_initramfs_modules[@]}" == "${#new_initramfs_modules[@]}" -a \

         "${old_initramfs_modules[*]}" == "${new_initramfs_modules[*]}" ];

    then

        # If the file lists are the same, compare each file to find any that changed

        for ((n = 0; n < ${#old_initramfs_modules[@]}; n++)); do

            if ! cmp "$tmpdir/old_initramfs/${old_initramfs_modules[n]}" \

                     "$tmpdir/new_initramfs/${new_initramfs_modules[n]}" \

                     >/dev/null 2>&1

            then

                return 1

            fi

        done

    else

        return 1

    fi

    return 0

}

# check_initramfs:

# check and possibly also update the initramfs for changed kernels

check_initramfs() {

    local kernel=$1

    # If there is no initramfs already we will not make one here.

    if [ -e "$initramfs_prefix/initramfs-$kernel.img" ];

    then

        old_initramfs="$initramfs_prefix/initramfs-$kernel.img"

        tmp_initramfs="$initramfs_prefix/initramfs-$kernel.tmp"

        new_initramfs="$initramfs_prefix/initramfs-$kernel.img"

        $dracut -f "$tmp_initramfs" "$kernel"

        if ! compare_initramfs_modules "$old_initramfs" "$tmp_initramfs";

        then

            doit mv "$tmp_initramfs" "$new_initramfs"

        else

            rm -f "$tmp_initramfs"

        fi

    fi

}

usage() {

    echo "Usage: ${0##*/} [options] {--add-modules|--remove-modules}"

    echo "${0##*/} [options] {--add-kernel|--remove-kernel} {kernel-release}"

    cat <<'EOF'

--add-modules

        Add a list of modules read from standard input. Create

        symlinks in compatible kernel's weak-updates/ directory.

        The list of modules is read from standard input.

--remove-modules

        Remove compatibility symlinks from weak-updates/ directories

        for a list of modules.  The list of modules is read from

        standard input. Note: it doesn't attempt to locate any

        compatible modules to replace those being removed.

--add-kernel

        Add compatibility symlinks for all compatible modules to the

        specified or running kernel.

--remove-kernel

        Remove all compatibility symlinks for the specified or current

        kernel.

--no-initramfs

        Do not generate an initramfs.

--verbose

        Print the commands executed.

--dry-run

        Do not create/remove any files.

EOF

    exit $1

}

# module_has_changed:

# Mark if an actual change occured that we need to deal with later by calling

# depmod or mkinitramfs against the affected kernel.

module_has_changed() {

    declare module=$1 krel=$2

    declare orig_module=$module

    module=${module%.ko}

    [[ $module == $orig_module ]] && module=${module%.ko.xz}

    [[ $module == $orig_module ]] && module=${module%.ko.gz}

    module=${module##*/}

    eval "changed_modules_${krel//[^a-zA-Z0-9]/_}=$krel"

    eval "changed_initramfs_${krel//[^a-zA-Z0-9]/_}=$krel"

}

# module_weak_link:

# Generate a weak link path for the module.

# Takes module file name and the target kernel release as arguments

# The way of generation intentionally left from the initial version

module_weak_link() {

    local module="$1"

    local krel="$2"

    local module_krel

    local subpath

    module_krel="$(krel_of_module "$module")"

    subpath=$(echo $module | sed -nre "s:$BASEDIR(/usr)?/lib/modules/$module_krel/([^/]*)/(.*):\3:p")

    if [[ -z $subpath ]]; then

        # module is not in /lib/modules/$krel?

        # It's possible for example for Oracle ACFS compatibility check

        # Install it with its full path as a /lib/modules subpath

        subpath="$module"

    fi

    echo "$(weak_updates_dir $krel)/${subpath#/}"

}

# module_short_name:

# 'basename' version purely in bash, cuts off path from the filename

module_short_name() {

    echo "${1##*/}"

}

#### Helper predicates

# is_weak_for_module_valid:

# Takes real module filename and target kernel as arguments.

# Calculates weak symlink filename for the corresponding module

# for the target kernel,

# returns 'true' if the symlink filename is a symlink

# and the symlink points to a readable file

# EVEN if it points to a different filename

is_weak_for_module_valid() {

    local module="$1"

    local krel="$2"

    local weak_link

    weak_link="$(module_weak_link $module $krel)"

    [[ -L "$weak_link" ]] && [[ -r "$weak_link" ]]

}

# is_weak_link:

# Takes a filename and a kernel release.

# 'true' if the filename is symlink under weak-updates/ for the kernel.

# It doesn't matter, if it's a valid symlink (points to a real file) or not.

is_weak_link() {

    local link="$1"

    local krel="$2"

    echo $link | grep -q "$(weak_updates_dir $krel)" || return 1

    [[ -L $link ]]

}

# is_extra_exists:

# Takes a module filename, the module's kernel release and target kernel release.

# The module filename should be a real, not a symlink, filename (i.e. in extra/).

# Returns 'true' if the same module exists for the target kernel.

is_extra_exists() {

    local module="$1"

    local module_krel="$2"

    local krel="$3"

    local subpath="${module#*/lib/modules/$module_krel/extra/}"

    [[ -f $BASEDIR/lib/modules/$krel/extra/$subpath ]]

}

is_kernel_installed() {

    local krel="$1"

    [[ -f "$BASEDIR/boot/symvers-$krel.gz" ]]

}

is_empty_file() {

    local file="$1"

    [[ "$(wc -l "$file" | cut -f 1 -d ' ')" == 0 ]]

}

#### Helpers

# find_modules:

# Takes kernel release and a list of subdirectories.

# Produces list of module files in the subdirectories for the kernel

find_modules() {

    local krel="$1"

    shift

    local dirs="$*"

    for dir in $dirs; do

        find $BASEDIR/lib/modules/$krel/$dir \

             -name '*.ko' -o -name '*.ko.xz' -o -name '*.ko.gz' \

             2>/dev/null

    done

}

# find_modules_dirs:

# Takes a list of directories.

# Produces list of module files in the subdirectories

find_modules_dirs() {

    local dirs="$*"

    for dir in $dirs; do

        find $dir -name '*.ko' -o -name '*.ko.xz' -o -name '*.ko.gz' \

             2>/dev/null

    done

}

# find_installed_kernels:

# Produces list of kernels, which modules are still installed

find_installed_kernels() {

    ls $BASEDIR/lib/modules/

}

# find_kernels_with_extra:

# Produces list of kernels, where exists extra/ directory

find_kernels_with_extra() {

    local krel

    local extra_dir

    for krel in $(find_installed_kernels); do

        extra_dir="$BASEDIR/lib/modules/$krel/extra"

        [[ -d "$extra_dir" ]] || continue

        echo "$krel"

    done

}

# remove_weak_link_quiet:

# Takes symlink filename and target kernel release.

# Removes the symlink and the directory tree

# if it was the last file in the tree

remove_weak_link_quiet() {

    local link="$1"

    local krel="$2"

    local subpath="${link#*$(weak_updates_dir $krel)}"

    rm -f $link

    ( cd "$(weak_updates_dir $krel)" && \

          rmdir --parents --ignore-fail-on-non-empty "$(dirname "${subpath#/}")" 2>/dev/null )

}

# prepare_sandbox:

# Takes kernel release, creates temporary weak-modules directory for it

# and depmod config to operate on it.

# Sets the global state accordingly

prepare_sandbox() {

    local krel="$1"

    local orig_dir

    local dir

    local conf="$tmpdir/depmod.conf"

    #directory

    orig_dir=$(weak_updates_dir $krel)

    dir="$tmpdir/$krel/weak-updates"

    mkdir -p "$dir"

    # the orig_dir can be empty

    cp -R "$orig_dir"/* "$dir" 2>/dev/null

    weak_updates_dir_override="$dir"

    #config

    echo "search external extra built-in weak-updates" >"$conf"

    echo "external * $dir" >>"$conf"

    depmod="$depmod_orig -C $conf"

}

# finish_sandbox:

# restore global state after sandboxing

# copy configuration to the kernel directory if not dry run

finish_sandbox() {

    local krel="$1"

    local override="$weak_updates_dir_override"

    local wa_dir

    weak_updates_dir_override=""

    depmod="$depmod_orig"

    [[ -n "$dry_run" ]] && return

    wa_dir="$(weak_updates_dir $krel)"

    rm -rf "$wa_dir"

    mkdir -p "$wa_dir"

    cp -R "${override}"/* "$wa_dir" 2>/dev/null

}

# discard_installed:

# remove installed_modules[] from modules[]

discard_installed()

{

    local short_name

    for m in "${!modules[@]}"; do

        short_name="$(module_short_name "${modules[$m]}")"

        [[ -z "${installed_modules[$short_name]}" ]] && continue

        unset "modules[$m]"

    done

}

# update_installed:

# add compatible_modules[] to installed_modules[]

update_installed()

{

    for m in "${!compatible_modules[@]}"; do

        installed_modules[$m]="${compatible_modules[$m]}"

    done

}

#### Main logic

# update_modules_for_krel:

# Takes kernel release and "action" function name.

# Skips kernel without symvers,

# otherwise triggers the main logic of modules installing/removing

# for the given kernel, which is:

# - save current state of weak modules symlinks

# - install/remove the symlinks for the given (via stdin) list of modules

# - validate the state and remove invalid symlinks

#   (for the modules, which are not compatible (became incompatible) for

#   the given kernel)

# - check the state after validation to produce needed messages

#   and trigger initrd regeneration if the list changed.

#

update_modules_for_krel() {

    local krel="$1"

    local func="$2"

    local force_update="$3"

    [[ -r "$BASEDIR/boot/symvers-$krel.gz" ]] || return

    prepare_sandbox $krel

    global_link_state_save $krel

    # remove already installed from modules[]

    discard_installed

    # do not run heavy validation procedure if no modules to install

    [[ "${#modules[@]}" -eq 0 ]] && return

    $func $krel

    if ! validate_weak_links $krel && [[ -z "$force_update" ]]; then

        global_link_state_restore $krel

    fi

    # add compatible to installed

    update_installed

    global_link_state_announce_changes $krel

    finish_sandbox $krel

}

# update_modules:

# Common entry point for add/remove modules command

# Takes the "action" function, the module list is supplied via stdin.

# Reads the module list and triggers modules update for all installed

# kernels.

# Triggers initrd rebuild for the kernels, which modules are installed.

update_modules() {

    local func="$1"

    local force_update="$2"

    local module_krel

    declare -a saved_modules

    read_modules_list || exit 1

    [[ ${#modules[@]} -gt 0 ]] || return

    saved_modules=("${modules[@]}")

    for krel in $(find_installed_kernels); do

        update_modules_for_krel $krel $func $force_update

        modules=("${saved_modules[@]}")

        installed_modules=()

    done

    for module in "${modules[@]}"; do

        # Module was built against this kernel, update initramfs.

        module_krel="${module_krels[$module]}"

        module_has_changed $module $module_krel

    done

}

# add_weak_links:

# Action function for the "add-modules" command

# Takes the kernel release, where the modules are added

# and the modules[] and module_krels[] global arrays.

# Install symlinks for the kernel with minimal checks

# (just filename checks, no symbol checks)

add_weak_links() {

    local krel="$1"

    local module_krel

    local weak_link

    for module in "${modules[@]}"; do

        module_krel="$(krel_of_module $module)"

        case "$module" in

            $BASEDIR/lib/modules/$krel/*)

                # Module already installed to the current kernel

                continue ;;

        esac

        if is_extra_exists $module $module_krel $krel; then

            pr_verbose "found $(module_short_name $module) for $krel while installing for $module_krel, update case?"

        fi

        if is_weak_for_module_valid $module $krel; then

            pr_verbose "weak module for $(module_short_name $module) already exists for kernel $krel, update case?"

            # we should update initrd in update case,

            # the change is not seen by the symlink detector

            # (global_link_state_announce_changes())

            module_has_changed $module $krel

        fi

        weak_link="$(module_weak_link $module $krel)"

        mkdir -p "$(dirname $weak_link)"

        ln -sf $module $weak_link

    done

}

# remove_weak_links:

# Action function for the "remove-modules" command

# Takes the kernel release, where the modules are removed

# and the modules[] and module_krels[] global arrays.

# Removes symlinks from the given kernel if they are installed

# for the modules in the list.

remove_weak_links() {

    local krel="$1"

    local weak_link

    local target

    local module_krel

    for module in "${modules[@]}"; do

        module_krel="$(krel_of_module $module)"

        weak_link="$(module_weak_link $module $krel)"

        target="$(readlink $weak_link)"

        if [[ "$module" != "$target" ]]; then

            pr_verbose "Skipping symlink $weak_link"

            continue

        fi

        # In update case the --remove-modules call is performed

        # after --add-modules (from postuninstall).

        # So, we shouldn't really remove the symlink in this case.

        # But in the remove case the actual target already removed.

        if ! is_weak_for_module_valid "$module" "$krel"; then

            remove_weak_link_quiet "$weak_link" "$krel"

        fi

    done

}

# validate_weak_links:

# Takes kernel release.

# Checks if all the weak symlinks are suitable for the given kernel.

# Uses depmod to perform the actual symbol checks and parses the output.

# Since depmod internally creates the module list in the beginning of its work

# accroding to the priority list in its configuration, but without symbol

# check and doesn't amend the list during the check, the function runs it

# in a loop in which it removes discovered incompatible symlinks

#

# Returns 0 (success) if proposal is fine or

#         1 (false) if some incompatible symlinks were removed

# initializes global hashmap compatible_modules with all the valid ones

validate_weak_links() {

    local krel="$1"

    local basedir=${BASEDIR:+-b $BASEDIR}

    local tmp

    declare -A symbols

    local is_updates_changed=1

    local module

    local module_krel

    local target

    local modpath

    local symbol

    local weak_link

    # to return to caller that original proposal is not valid

    # here 0 is true, 1 is false, since it will be the return code

    local is_configuration_valid=0

    tmp=$(mktemp -p $tmpdir)

    compatible_modules=()

    if ! [[ -e $tmpdir/symvers-$krel ]]; then

        [[ -e $BASEDIR/boot/symvers-$krel.gz ]] || return

        zcat $BASEDIR/boot/symvers-$krel.gz > $tmpdir/symvers-$krel

    fi

    while ((is_updates_changed)); do

        is_updates_changed=0

        # again $tmp because of subshell, see read_modules_list() comment

        # create incompatibility report by depmod

        # Shorcut if depmod finds a lot of incompatible modules elsewhere,

        # we care only about weak-updates

        $depmod $basedir -naeE $tmpdir/symvers-$krel $krel 2>&1 1>/dev/null | \

            grep "$(weak_updates_dir $krel)" 2>/dev/null >$tmp

        # parse it into symbols[] associative array in form a-la

        #   symbols["/path/to/the/module"]="list of bad symbols"

        while read line; do

            set -- $(echo $line | awk '/needs unknown symbol/{print $3 " " $NF}')

            modpath=$1

            symbol=$2

            if [[ -n "$modpath" ]]; then

                symbols[$modpath]="${symbols[$modpath]} $symbol"

                continue

            fi