automatic import of kmod

8 files changed, 1612 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..b140e66 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/kmod-33.tar.xz
diff --git a/0001-Module-replace-the-module-with-new-module.patch b/0001-Module-replace-the-module-with-new-module.patch
new file mode 100644
index 0000000..0cbc3fa
--- /dev/null
+++ b/0001-Module-replace-the-module-with-new-module.patch
@@ -0,0 +1,108 @@
+From 0eac0869e201a08170cb2255b623eab9d78072f8 Mon Sep 17 00:00:00 2001
+From: Jason Luan <luanjianhai@huawei.com>
+Date: Wed, 16 Sep 2020 01:21:50 +0000
+Subject: [PATCH 1/2] Module: replace the module with new module
+
+Signed-off-by: fu.lin <fu.lin10@huawei.com>
+---
+ libkmod/libkmod-module.c | 3 +++
+ libkmod/libkmod.h        | 6 ++++++
+ shared/missing.h         | 7 +++++++
+ tools/insmod.c           | 7 ++++++-
+ 4 files changed, 22 insertions(+), 1 deletion(-)
+
+diff --git a/libkmod/libkmod-module.c b/libkmod/libkmod-module.c
+index c095e63..4c0f159 100644
+--- a/libkmod/libkmod-module.c
++++ b/libkmod/libkmod-module.c
+@@ -873,8 +873,11 @@ static int do_finit_module(struct kmod_module *mod, unsigned int flags,
+ 		kernel_flags |= MODULE_INIT_IGNORE_VERMAGIC;
+ 	if (flags & KMOD_INSERT_FORCE_MODVERSION)
+ 		kernel_flags |= MODULE_INIT_IGNORE_MODVERSIONS;
++	if (flags & KMOD_INSERT_REPLACE)
++		kernel_flags |= MODULE_REPLACE_MODULE;
+ 
+ 	err = finit_module(kmod_file_get_fd(mod->file), args, kernel_flags);
++
+ 	if (err < 0)
+ 		err = -errno;
+ 
+diff --git a/libkmod/libkmod.h b/libkmod/libkmod.h
+index f3376f5..ef1576f 100644
+--- a/libkmod/libkmod.h
++++ b/libkmod/libkmod.h
+@@ -140,6 +140,9 @@ enum kmod_remove {
+ enum kmod_insert {
+ 	KMOD_INSERT_FORCE_VERMAGIC = 0x1,
+ 	KMOD_INSERT_FORCE_MODVERSION = 0x2,
++
++	/* custom flag */
++	KMOD_INSERT_REPLACE = 0x1000,
+ };
+ 
+ /* Flags to kmod_module_probe_insert_module() */
+@@ -151,6 +154,9 @@ enum kmod_probe {
+ 	KMOD_PROBE_DRY_RUN =			0x00010,
+ 	KMOD_PROBE_FAIL_ON_LOADED =		0x00020,
+ 
++	/* custom flag */
++	KMOD_PROBE_REPLACE =			0x01000,
++
+ 	/* codes below can be used in return value, too */
+ 	KMOD_PROBE_APPLY_BLACKLIST_ALL =	0x10000,
+ 	KMOD_PROBE_APPLY_BLACKLIST =		0x20000,
+diff --git a/shared/missing.h b/shared/missing.h
+index 7df6235..3bd0cfa 100644
+--- a/shared/missing.h
++++ b/shared/missing.h
+@@ -19,6 +19,13 @@
+ # define MODULE_INIT_COMPRESSED_FILE 4
+ #endif
+ 
++#ifndef MODULE_REPLACE_MODULE
++# define MODULE_REPLACE_MODULE 0x1000
++#else
++_Static_assert(MODULE_REPLACE_MODULE == 0x1000,
++		 "MODULE_REPLACE_MODULE != 0x1000, change `KMOD_INSERT_REPLACE` and `KMOD_PROBE_REPLACE` defination");
++#endif
++
+ #ifndef __NR_finit_module
+ # define __NR_finit_module -1
+ #endif
+diff --git a/tools/insmod.c b/tools/insmod.c
+index 4a1d11d..7e58ed3 100644
+--- a/tools/insmod.c
++++ b/tools/insmod.c
+@@ -15,9 +15,10 @@
+ 
+ #include "kmod.h"
+ 
+-static const char cmdopts_s[] = "psfVh";
++static const char cmdopts_s[] = "psfVrh";
+ static const struct option cmdopts[] = {
+ 	{"version", no_argument, 0, 'V'},
++	{"replace", no_argument, 0, 'r'},
+ 	{"help", no_argument, 0, 'h'},
+ 	{NULL, 0, 0, 0}
+ };
+@@ -28,6 +29,7 @@ static void help(void)
+ 		"\t%s [options] filename [args]\n"
+ 		"Options:\n"
+ 		"\t-V, --version     show version\n"
++		"\t-r, --replace     replace module\n"
+ 		"\t-h, --help        show this help\n",
+ 		program_invocation_short_name);
+ }
+@@ -76,6 +78,9 @@ static int do_insmod(int argc, char *argv[])
+ 		case 'h':
+ 			help();
+ 			return EXIT_SUCCESS;
++		case 'r':
++			flags |= KMOD_INSERT_REPLACE;
++			break;
+ 		case 'V':
+ 			puts(PACKAGE " version " VERSION);
+ 			puts(KMOD_FEATURES);
+-- 
+2.46.0
+
diff --git a/0002-Module-suspend-the-module-by-rmmod-r-option.patch b/0002-Module-suspend-the-module-by-rmmod-r-option.patch
new file mode 100644
index 0000000..d84410e
--- /dev/null
+++ b/0002-Module-suspend-the-module-by-rmmod-r-option.patch
@@ -0,0 +1,91 @@
+From 3466b9698c4372ec81ed71384e1845898b7044d0 Mon Sep 17 00:00:00 2001
+From: Ruidong Cao <caoruidong@huawei.com>
+Date: Fri, 25 Sep 2020 03:00:25 -0400
+Subject: [PATCH 2/2] Module: suspend the module by rmmod r option
+
+Signed-off-by: Ruidong Cao <caoruidong@huawei.com>
+Signed-off-by: fu.lin <fu.lin10@huawei.com>
+---
+ libkmod/libkmod-module.c | 2 +-
+ libkmod/libkmod.h        | 3 +++
+ shared/missing.h         | 2 +-
+ tools/rmmod.c            | 7 ++++++-
+ 4 files changed, 11 insertions(+), 3 deletions(-)
+
+diff --git a/libkmod/libkmod-module.c b/libkmod/libkmod-module.c
+index fd9861a..96f462a 100644
+--- a/libkmod/libkmod-module.c
++++ b/libkmod/libkmod-module.c
+@@ -846,7 +846,7 @@ KMOD_EXPORT int kmod_module_remove_module(struct kmod_module *mod,
+ 		return -ENOENT;
+ 
+ 	/* Filter out other flags and force ONONBLOCK */
+-	flags &= KMOD_REMOVE_FORCE;
++	flags &= KMOD_REMOVE_FORCE | KMOD_REMOVE_REPLACE;
+ 	flags |= KMOD_REMOVE_NOWAIT;
+ 
+ 	err = delete_module(mod->name, flags);
+diff --git a/libkmod/libkmod.h b/libkmod/libkmod.h
+index a56e5b4..78d11b3 100644
+--- a/libkmod/libkmod.h
++++ b/libkmod/libkmod.h
+@@ -147,6 +147,9 @@ enum kmod_remove {
+ 	KMOD_REMOVE_NOWAIT = O_NONBLOCK, /* always set */
+ 	/* libkmod-only defines, not passed to kernel */
+ 	KMOD_REMOVE_NOLOG = 1,
++
++	/* custom flag */
++	KMOD_REMOVE_REPLACE = 0x1000,
+ };
+ 
+ /* Insertion flags */
+diff --git a/shared/missing.h b/shared/missing.h
+index 4d2253b..19fb36f 100644
+--- a/shared/missing.h
++++ b/shared/missing.h
+@@ -19,7 +19,7 @@
+ # define MODULE_REPLACE_MODULE 0x1000
+ #else
+ _Static_assert(MODULE_REPLACE_MODULE == 0x1000,
+-		 "MODULE_REPLACE_MODULE != 0x1000, change `KMOD_INSERT_REPLACE` and `KMOD_PROBE_REPLACE` defination");
++		 "MODULE_REPLACE_MODULE != 0x1000, change `KMOD_INSERT_REPLACE`, `KMOD_REMOVE_REPLACE` and `KMOD_PROBE_REPLACE` defination");
+ #endif
+ 
+ #ifndef __NR_finit_module
+diff --git a/tools/rmmod.c b/tools/rmmod.c
+index 3942e7b..1278234 100644
+--- a/tools/rmmod.c
++++ b/tools/rmmod.c
+@@ -36,9 +36,10 @@
+ static int verbose = DEFAULT_VERBOSE;
+ static int use_syslog;
+ 
+-static const char cmdopts_s[] = "fsvVwh";
++static const char cmdopts_s[] = "frsvVwh";
+ static const struct option cmdopts[] = {
+ 	{"force", no_argument, 0, 'f'},
++	{"replace", no_argument, 0, 'r'},
+ 	{"syslog", no_argument, 0, 's'},
+ 	{"verbose", no_argument, 0, 'v'},
+ 	{"version", no_argument, 0, 'V'},
+@@ -54,6 +55,7 @@ static void help(void)
+ 		"\t-f, --force       forces a module unload and may crash your\n"
+ 		"\t                  machine. This requires Forced Module Removal\n"
+ 		"\t                  option in your kernel. DANGEROUS\n"
++		"\t-r, --replace     replace module\n"
+ 		"\t-s, --syslog      print to syslog, not stderr\n"
+ 		"\t-v, --verbose     enables more messages\n"
+ 		"\t-V, --version     show version\n"
+@@ -120,6 +122,9 @@ static int do_rmmod(int argc, char *argv[])
+ 		case 'f':
+ 			flags |= KMOD_REMOVE_FORCE;
+ 			break;
++		case 'r':
++			flags |= KMOD_REMOVE_REPLACE;
++			break;
+ 		case 's':
+ 			use_syslog = 1;
+ 			break;
+-- 
+2.35.1
+
diff --git a/depmod.conf.dist b/depmod.conf.dist
new file mode 100644
index 0000000..b9cb5e9
--- /dev/null
+++ b/depmod.conf.dist
@@ -0,0 +1,6 @@
+#
+# depmod.conf
+#
+
+# override default search ordering for kmod packaging
+search updates extra external built-in weak-updates
diff --git a/kmod.changes b/kmod.changes
new file mode 100644
index 0000000..c5288bd
--- /dev/null
+++ b/kmod.changes
@@ -0,0 +1,97 @@
+%changelog
+* Sun Feb 02 2025 Funda Wang <fundawang@yeah.net> - 33-1
+- update to version 33
+- python binding removed in 32
+
+* Tue May 07 2024 guoqinglan <guoqinglan@kylinsec.com.cn> - 30-3
+- Reinitialize libtool to remove Rpath
+
+* Fri Sep 02 2022 fu.lin <fulin10@huawei.com> - 30-2
+- fit the old patch
+
+* Tue Jul 26 2022 Qingqing Li <liqingqing3@huawei.com> - 30-1
+- upgrade to kmod-30
+
+* Wed Jun 29 2022 luhuaxin <luhuaxin1@huawei.com> - 29-5
+- support to display sm3 sig_hashalgo
+
+* Thu Feb 24 2022 Yang Yanchao <yangyanchao6@huawei.com> - 29-4
+- add package python3-kmod.
+
+* Fri Jan 7 2022 zhouwenpei <zhouwenpei1@huawei.com> - 29-3
+- kmod-devel: add requires on kmod-libs
+
+* Thu Dec 9 2021 Jiangfeng Xiao <xiaojiangfeng@huawei.com> - 29-2
+- kmod: revert "depmod: Do not unlinkat orig depfile and add fync"
+
+* Fri Dec 3 2021 zhouwenpei <zhouwenpei1@huawei.com> - 29-1
+- update kmod to 29
+
+* Mon Nov 29 2021 Yang Yanchao <yangyanchao6@huawei.com> - 27-8
+- kmod: don't check module's refcnt when rmmod with -r
+  Module: replace the module with new module
+  Module: suspend the module by rmmod r option
+
+* Wed Nov 24 2021 Yang Yanchao <yangyanchao6@huawei.com> - 27-7
+- Precisely filters ko files in "/lib/modules/$kernel/extra" 
+  to avoid creating unnecessary symbols.
+
+* Tue Nov 9 2021 Yang Yanchao <yangyanchao6@huawei.com> - 27-6
+- Sync the weak-modules script from the 20.03-LTS-SP1
+- use -V to sort kernel version in weak-modules
+
+* Fri Jun 18 2021 hushiyuan <hushiyuan@huawei.com> - 27-5
+- libkmod-module: check "new_from_name" return value in get_builtin
+- libkmod:fix double free for modinfo in modules.buildin.modinfo
+- libkmod:fix an overflow with wrong modules.builtin.modinfo
+- libkmod-config:fix a memory leak when kmod_list_append failes
+- Fix "modinfo -F always shows name for build-ins"
+
+* Thu Jan 14 2021 xinghe <xinghe1@huawei.com> - 27-4
+- fix memory leak in kmodinfo and build warning
+
+* Fri Sep 04 2020 xinghe <xinghe1@huawei.com> - 27-3
+- backport patch to deal with lspci -v error report
+
+* Fri Aug 21 2020 Wang Shuo<wangshuo_1994@foxmail.com> - 27-2
+- remove unnecessary message
+
+* Fri Apr 17 2020 Wang Shuo<wangshuo47@huawei.com> - 27-1
+- Type:enhancement
+- ID:NA
+- SUG:NA
+- DESC: update kmod to 27
+
+* Wed Feb 26 2020 Wang Shuo<wangshuo47@huawei.com> - 25-6
+- Type:enhancement
+- ID:NA
+- SUG:NA
+- DESC: move libs files to libs package
+
+* Sat Apr 6 2019 luochunsheng<luochunsheng@huawei.com> - 25-5
+- Type:enhancement
+- ID:NA
+- SUG:NA
+
+* Fri Mar 22 2019 kangenbo<kangenbo@huawei.com> - 25-4
+- Type:enhancement
+- ID:NA
+- SUG:NA
+- DESC: backport patches from communities
+
+* Tue Mar 19 2019 hexiaowen<hexiaowen@huawei.com> - 25-3
+- Type:enhancement
+- ID:NA
+- SUG:NA
+- DESC: add /etc/depmod.d/dist.conf
+
+* Fri Jan 25 2019 Xiaoqi Guo<guoxiaoqi2@huawei.com> - 25-2
+- Type:bugfix
+- ID:NA
+- SUG:NA
+- DESC:add patches, include
+       bugfix-kmod-20-8-depmod-Don-t-unlinkat-orig-depfile-and-add-fsync.patch
+
+* Thu Jan 24 2019 openEuler Buildteam <buildteam@openeuler.org> - 25-1
+- Package init
+
diff --git a/kmod.spec b/kmod.spec
new file mode 100644
index 0000000..a4662c6
--- /dev/null
+++ b/kmod.spec
@@ -0,0 +1,98 @@
+Name:           kmod
+Version:        33
+Release:        1
+Summary:        Kernel module management
+License:        GPL-2.0-or-later
+URL:            https://git.kernel.org/?p=utils/kernel/kmod/kmod.git;a=summary
+Source0:        https://www.kernel.org/pub/linux/utils/kernel/kmod/%{name}-%{version}.tar.xz
+Source1:        weak-modules
+Source2:        depmod.conf.dist
+Source3:        kmod.changes
+
+BuildRequires:  gcc chrpath zlib-devel xz-devel scdoc openssl-devel libtool gtk-doc
+
+Provides:       module-init-tools = 4.0-1
+Provides:       /sbin/modprobe
+Patch0001:	0001-Module-replace-the-module-with-new-module.patch
+Patch0002:	0002-Module-suspend-the-module-by-rmmod-r-option.patch
+
+%description
+The kmod package provides several commands to manage the kernel modules,
+such as insmod to load and rmmod to unload the modules.
+
+%package libs
+Summary:    Libraries to handle kernel module loading and unloading
+License:    LGPL-2.1-or-later
+
+%description libs
+The kmod-libs package provides runtime libraries for any application that
+wishes to load or unload Linux kernel modules from the running system.
+
+%package devel
+Summary:        Header files for kmod development
+License:        LGPL-2.1-or-later
+Requires:       %{name} = %{version}-%{release}
+Requires:       %{name}-libs = %{version}-%{release}
+
+%description devel
+The kmod-devel package provides header files used for loading or unloading
+kernel modules.
+
+%package_help
+
+%prep
+%autosetup -n %{name}-%{version} -p1
+
+%build
+# Reinitialize libtool to remove Rpath
+autoreconf -vif
+%configure --with-openssl --with-zlib --with-xz
+%make_build
+
+%install
+%make_install
+%delete_la
+pushd $RPM_BUILD_ROOT/%{_mandir}/man5
+ln -s modprobe.d.5 modprobe.conf.5
+popd
+
+mkdir -p $RPM_BUILD_ROOT%{_sbindir}
+for i in $RPM_BUILD_ROOT%{_sbindir}/modprobe $RPM_BUILD_ROOT%{_sbindir}/modinfo $RPM_BUILD_ROOT%{_sbindir}/insmod \
+         $RPM_BUILD_ROOT%{_sbindir}/rmmod $RPM_BUILD_ROOT%{_sbindir}/depmod $RPM_BUILD_ROOT%{_sbindir}/lsmod
+do
+    ln -sf ../bin/kmod $i
+done
+
+mkdir -p $RPM_BUILD_ROOT%{_sysconfdir}/modprobe.d
+mkdir -p $RPM_BUILD_ROOT%{_sysconfdir}/depmod.d
+mkdir -p $RPM_BUILD_ROOT%{_prefix}/lib/modprobe.d
+mkdir -p $RPM_BUILD_ROOT/sbin
+
+install -m 755 %{SOURCE1} $RPM_BUILD_ROOT%{_sbindir}/weak-modules
+install -m 0644 %{SOURCE2} $RPM_BUILD_ROOT%{_sysconfdir}/depmod.d/dist.conf
+
+%files
+%dir %{_sysconfdir}/*.d
+%dir %{_prefix}/lib/modprobe.d
+
+%{_bindir}/kmod
+%{_sbindir}/*
+%{_datadir}/bash-completion/
+%{_sysconfdir}/depmod.d/dist.conf
+
+%files libs
+%license COPYING
+%{_libdir}/libkmod.so.*
+
+%files devel
+%{_includedir}/libkmod.h
+%{_libdir}/pkgconfig/libkmod.pc
+%{_libdir}/libkmod.so
+
+%files help
+%attr(0644,root,root) %{_mandir}/man5/*.5*
+%attr(0644,root,root) %{_mandir}/man8/*.8*
+
+%doc TODO NEWS README.md
+
+%include %{SOURCE3}
diff --git a/sources b/sources
new file mode 100644
index 0000000..cf253a0
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+c451c4aa61521adbe8af147f498046f8  kmod-33.tar.xz
diff --git a/weak-modules b/weak-modules
new file mode 100644
index 0000000..76523a7
--- /dev/null
+++ b/weak-modules
@@ -0,0 +1,1210 @@
+#!/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="/usr/bin/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 || exit
+    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 || exit
+
+    decompress_initramfs "$new_initramfs" "$tmpdir/new_initramfs.img"
+    pushd "$tmpdir/new_initramfs" >/dev/null || exit
+    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 || exit
+
+    # 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
+    local module_krel_escaped
+
+    module_krel="$(krel_of_module "$module")"
+    module_krel_escaped=$(echo "$module_krel" | \
+                              sed 's/\([.+?^$\/\\|()\[]\|\]\)/\\\0/g')
+    subpath=$(echo $module | sed -nre "s:$BASEDIR(/usr)?/lib/modules/$module_krel_escaped/([^/]*)/(.*):\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"
+
+    find_symvers_file "$krel" > /dev/null &&
+        find_systemmap_file "$krel" > /dev/null
+}
+
+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"
+}
+
+# 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
+}
+
+# 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
+}
+
+# Auxiliary functions to find symvers file
+make_kernel_file_names() {
+    local krel="$1"
+    shift
+    local file="$1"
+    shift
+
+    for suffix in "$@"; do
+        echo "${BASEDIR}/boot/${file}-${krel}${suffix}"
+        echo "${BASEDIR}/lib/modules/${krel}/${file}${suffix}"
+    done
+}
+
+find_kernel_file() {
+    local krel="$1"
+    shift
+    local file="$1"
+    shift
+    local print="$1"
+    shift
+    local i
+
+    if [[ "$print" != "" ]]; then
+        make_kernel_file_names "$krel" "$file" "$@"
+        return 0
+    fi
+
+    for i in  $(make_kernel_file_names "$krel" "$file" "$@"); do
+        if [[ -r "$i" ]]; then
+            echo "$i"
+            return 0
+        fi
+    done
+
+    return 1
+}
+
+# find_symvers_file:
+# Since /boot/ files population process is now controlled by systemd'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's also check for /lib/modules/$kver/symvers.gz, since that'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="$1"
+    local print="$2"
+
+    find_kernel_file "$krel" symvers "$print" .xz .gz
+}
+
+# find_systemmap_file:
+# Same as above but for System.map
+find_systemmap_file() {
+    local krel="$1"
+    local print="$2"
+    local no_suffix=""
+
+    find_kernel_file "$krel" System.map "$print" "$no_suffix"
+}
+
+#### 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"
+
+    is_kernel_installed "$krel" || 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 [[ "${#modules[@]}" -eq 0 ]]; then
+        finish_sandbox $krel
+        return
+    fi
+
+    $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
+    local cat_prog
+
+    tmp=$(mktemp -p $tmpdir)
+    compatible_modules=()
+
+    if ! [[ -e $tmpdir/symvers-$krel ]]; then
+        local symvers_path=$(find_symvers_file "$krel")
+
+        [[ -n "$symvers_path" ]] || return
+        cat_prog="cat"
+        case "$symvers" in
+        *.gz) cat_prog="zcat" ;;
+        *.xz) cat_prog="xzcat" ;;
+        esac
+        "$cat_prog" "$symvers_path" > $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
+
+            set -- $(echo $line | awk '/disagrees about version of symbol/{print $3 " " $NF}')
+            modpath=$1
+            symbol=$2
+            if [[ -n "$modpath" ]]; then
+                symbols[$modpath]="${symbols[$modpath]} $symbol"
+                continue
+            fi
+        done < $tmp
+
+        # loop through all the weak links from the list of incompatible
+        # modules and remove them. Skips non-weak incompatibilities
+        for modpath in "${!symbols[@]}"; do
+            is_weak_link $modpath $krel || continue
+
+            target=$(readlink $modpath)
+            module_krel=$(krel_of_module $target)
+
+            remove_weak_link_quiet "$modpath" "$krel"
+
+            pr_verbose "Module $(module_short_name $modpath) from kernel $module_krel is not compatible with kernel $krel in symbols: ${symbols[$modpath]}"
+            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 "${modules[@]}"; do
+        is_weak_for_module_valid $module $krel || continue
+
+        weak_link="$(module_weak_link $module $krel)"
+        target="$(readlink $weak_link)"
+        module_krel=$(krel_of_module $target)
+
+        if [[ "$module" == "$target" ]]; then
+            short_name="$(module_short_name "$module")"
+            compatible_modules+=([$short_name]="$module")
+
+            pr_verbose "Module ${module##*/} from kernel $module_krel is compatible with kernel $krel"
+        fi
+    done
+    return $is_configuration_valid
+}
+
+# global_link_state_save:
+# Takes kernel release
+# Saves the given kernel's weak symlinks state into the global array
+# weak_modules_before[] for later processing
+global_link_state_save() {
+    local krel="$1"
+    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="$1"
+    local link
+    local target
+
+    pr_verbose "Falling back weak-modules state for kernel $krel"
+
+    ( cd "$(weak_updates_dir $krel)" 2>/dev/null && rm -rf * )
+
+    for link in "${!weak_modules_before[@]}"; do
+        target=${weak_modules_before[$link]}
+
+        mkdir -p "$(dirname $link)"
+        ln -sf $target $link
+    done
+}
+
+# global_link_state_announce_changes:
+# Takes kernel release
+# Reads the given kernel'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="$1"
+    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
+        [[ "$target" == "$new_target" ]] || module_has_changed $new_target $krel
+    done
+
+    for link in "${!weak_modules_before[@]}"; do
+        target=${weak_modules_before[$link]}
+        new_target=${weak_modules_after[$link]}
+
+        # report change of existing link and disappearing of an old link
+        [[ "$target" == "$new_target" ]] && continue
+        module_has_changed $target $krel
+        [[ -n "$new_target" ]] ||
+            pr_verbose "Removing compatible module $(module_short_name $target) from kernel $krel"
+    done
+}
+
+# remove_modules:
+# Read in a list of modules from stdinput and process them for removal.
+# Parameter (noreplace) is deprecated, acts always as "noreplace".
+# There is no sense in the "replace" 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=""
+
+    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="$1"
+    local group_name
+    local mod
+    declare -a mods
+
+    while read i; do
+        read -a mods <<< "$i"
+
+        echo "${mods[0]}" |grep -q "extra/" || continue
+
+        # if the module already met, then its dependencies already counted
+        module_group="${grouped_modules[${mods[0]}]}"
+        [[ -n $module_group ]] && continue
+
+        # new group
+        group_name="${mods[0]}"
+
+        for mod in "${mods[@]}"; do
+            echo "$mod" |grep -q "extra/" || 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't matter, since later (in add_kernel())
+            # it is expanded without quotes
+            groups[$group_name]+=" $mod"
+            grouped_modules[$mod]=$group_name
+        done
+    done < $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 'BEGIN { pr = 1 } /^#/{ pr = 0 } pr == 1 {sub(":",""); print $0}'
+}
+
+# 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="$1"
+    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 "$i" |grep -q "extra/" || continue
+
+        read -a mods <<< "$i"
+        for j in "${!mods[@]}"; do
+            mod="${mods[$j]}"
+
+            [[ ${mod:0:1} == "/" ]] || mod="$BASEDIR/lib/modules/$kver/$mod"
+            mods[$j]="$mod"
+        done
+        echo "${mods[@]}"
+    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="$1"
+    local tmp2=$(mktemp -p $tmpdir)
+    local basedir=${BASEDIR:+-b $BASEDIR}
+
+    groups=()
+    grouped_modules=()
+
+    $depmod -n $basedir $k 2>/dev/null |
+        cut_depmod_deps | filter_extra_absoluted $k > $tmp2
+
+    do_make_groups $tmp2
+
+    rm -f $tmp2
+}
+
+add_kernel() {
+    local krel=${1:-$(uname -r)}
+    local tmp
+    local no_force_update=""
+    local num
+
+    tmp=$(mktemp -p $tmpdir)
+
+    if ! find_symvers_file "$krel" > /dev/null; then
+        echo "Symvers dump file is not found in" \
+             $(find_symvers_file "$krel" print) >&2
+        exit 1
+    fi
+
+    for k in $(find_kernels_with_extra | rpmsort -r); do
+        [[ "$krel" == "$k" ]] && continue
+        find_modules $k extra > $tmp
+
+        is_empty_file "$tmp" || 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 > $tmp
+        for g in "${groups[@]}"; do
+	    num="$(echo "$g" | wc -w)"
+	    [ "$num" -gt 1 ] && continue
+
+            printf '%s\n' $g >> $tmp
+	done
+        # to avoid subshell, see the read_modules_list comment
+        read_modules_list < $tmp
+        update_modules_for_krel $krel add_weak_links force_update
+
+        for g in "${groups[@]}"; do
+	    num="$(echo "$g" | wc -w)"
+	    [ "$num" -eq 1 ] && continue
+
+            printf '%s\n' $g > $tmp
+            read_modules_list < $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="$(weak_updates_dir $remove_krel)"
+    module_has_changed $weak_modules $remove_krel
+
+    # Remove everything beneath the weak-updates directory
+    ( cd "$weak_modules" && 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: -- "$@"`
+
+[ $? -eq 0 ] || usage 1
+
+eval set -- "$options"
+
+while :; do
+    case "$1" 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 "--delete-modules is deprecated, no effect"
+        ;;
+    --basedir)
+        BASEDIR="$2"
+        shift
+        ;;
+    --dracut)
+        dracut="$2"
+        shift
+        ;;
+    --check-initramfs-prog)
+        CHECK_INITRAMFS="$2"
+        shift
+        ;;
+    -h|--help)
+        usage 0
+        ;;
+    --)
+        shift
+        break
+        ;;
+    esac
+    shift
+done
+
+if [ ! -x "$dracut" ]
+then
+    echo "weak-modules: could not find dracut at $dracut"
+    exit 1
+fi
+
+initramfs_prefix="$BASEDIR/${default_initramfs_prefix#/}"
+
+if [ -n "$do_add_modules" ]; then
+    add_modules
+
+elif [ -n "$do_remove_modules" ]; then
+    remove_modules
+
+elif [ -n "$do_add_kernel" ]; then
+    kernel=${1:-$(uname -r)}
+    add_kernel $kernel
+
+elif [ -n "$do_remove_kernel" ]; 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 "Skipping depmod for non-installed kernel $krel"
+    fi
+done
+
+for krel in ${!changed_initramfs_*}; do
+    krel=${!krel}
+
+    if [ ! -n "$no_initramfs" ]; then
+        ${CHECK_INITRAMFS:-check_initramfs} $krel
+    fi
+done