From c62209c195b9794e863282bfd9fb7412926e6de1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20=C5=A0abata?= Date: Thu, 15 Oct 2020 15:03:55 +0200 Subject: [PATCH] RHEL 9.0.0 Alpha bootstrap The content of this branch was automatically imported from Fedora ELN with the following as its source: https://src.fedoraproject.org/rpms/kmod#bddd48bb1f02b70118e3a0b652848567edac13b0 --- .gitignore | 21 + ...-depmod-do-not-output-.bin-to-stdout.patch | 53 + kmod.spec | 322 +++++ sources | 1 + tests/libkmod/Makefile | 46 + tests/libkmod/runtest.sh | 36 + tests/libkmod/test-libkmod.c | 79 ++ tests/sanity/Makefile | 79 ++ tests/sanity/PURPOSE | 4 + tests/sanity/_env | 8 + tests/sanity/lib.sh | 258 ++++ tests/sanity/parse_taint.sh | 70 + tests/sanity/runtest.sh | 134 ++ tests/tests.yml | 18 + weak-modules | 1199 +++++++++++++++++ 15 files changed, 2328 insertions(+) create mode 100644 0001-depmod-do-not-output-.bin-to-stdout.patch create mode 100644 kmod.spec create mode 100644 sources create mode 100644 tests/libkmod/Makefile create mode 100755 tests/libkmod/runtest.sh create mode 100644 tests/libkmod/test-libkmod.c create mode 100644 tests/sanity/Makefile create mode 100644 tests/sanity/PURPOSE create mode 100644 tests/sanity/_env create mode 100755 tests/sanity/lib.sh create mode 100755 tests/sanity/parse_taint.sh create mode 100755 tests/sanity/runtest.sh create mode 100644 tests/tests.yml create mode 100644 weak-modules diff --git a/.gitignore b/.gitignore index e69de29..f339cc1 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1,21 @@ +/kmod-7.tar.xz +/kmod-8.tar.xz +/kmod-9.tar.xz +/kmod-10.tar.xz +/kmod-11.tar.xz +/kmod-12.tar.xz +/kmod-13.tar.xz +/kmod-14.tar.xz +/kmod-15.tar.xz +/kmod-16.tar.xz +/kmod-17.tar.xz +/kmod-18.tar.xz +/kmod-19.tar.xz +/kmod-20.tar.xz +/kmod-21.tar.xz +/kmod-22.tar.xz +/kmod-23.tar.xz +/kmod-24.tar.xz +/kmod-25.tar.xz +/kmod-26.tar.xz +/kmod-27.tar.xz diff --git a/0001-depmod-do-not-output-.bin-to-stdout.patch b/0001-depmod-do-not-output-.bin-to-stdout.patch new file mode 100644 index 0000000..1461006 --- /dev/null +++ b/0001-depmod-do-not-output-.bin-to-stdout.patch @@ -0,0 +1,53 @@ +From 53b30aeba2dedae9f5558f560231d9462e063dfc Mon Sep 17 00:00:00 2001 +From: Lucas De Marchi +Date: Thu, 5 Mar 2020 13:33:10 -0800 +Subject: [PATCH] depmod: do not output .bin to stdout + +index_write() relies on fseek/ftell to manage the position to which we +are write and thus needs the file stream to support it. + +Right now when trying to write the index to stdout we fail with: + + depmod: tools/depmod.c:416: index_write: Assertion `initial_offset >= 0' failed. + Aborted (core dumped) + +We have no interest in outputting our index to stdout, so just skip it +like is done with other indexes. + +While at it, add/remove some newlines to improve readability. + +Reported-by: Yanko Kaneti +Fix: b866b2165ae6 ("Lookup aliases in the modules.builtin.modinfo") +--- + tools/depmod.c | 6 +++++- + 1 file changed, 5 insertions(+), 1 deletion(-) + +diff --git a/tools/depmod.c b/tools/depmod.c +index fbbce10eb0db..875e31480818 100644 +--- a/tools/depmod.c ++++ b/tools/depmod.c +@@ -2408,8 +2408,10 @@ static int output_builtin_alias_bin(struct depmod *depmod, FILE *out) + struct index_node *idx; + struct kmod_list *l, *builtin = NULL; + +- idx = index_create(); ++ if (out == stdout) ++ return 0; + ++ idx = index_create(); + if (idx == NULL) { + ret = -ENOMEM; + goto fail; +@@ -2456,7 +2458,9 @@ static int output_builtin_alias_bin(struct depmod *depmod, FILE *out) + + if (count) + index_write(idx, out); ++ + index_destroy(idx); ++ + fail: + if (builtin) + kmod_module_unref_list(builtin); +-- +2.25.0 + diff --git a/kmod.spec b/kmod.spec new file mode 100644 index 0000000..a136dd9 --- /dev/null +++ b/kmod.spec @@ -0,0 +1,322 @@ +Name: kmod +Version: 27 +Release: 3%{?dist} +Summary: Linux kernel module management utilities + +License: GPLv2+ +URL: http://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 +Exclusiveos: Linux + +Patch01: 0001-depmod-do-not-output-.bin-to-stdout.patch + +BuildRequires: gcc +BuildRequires: chrpath +BuildRequires: zlib-devel +BuildRequires: xz-devel +BuildRequires: libxslt +BuildRequires: openssl-devel + +Provides: module-init-tools = 4.0-1 +Obsoletes: module-init-tools < 4.0-1 +Provides: /sbin/modprobe + +%description +The kmod package provides various programs needed for automatic +loading and unloading of modules under 2.6, 3.x, and later kernels, as well +as other module management programs. Device drivers and filesystems are two +examples of loaded and unloaded modules. + +%package libs +Summary: Libraries to handle kernel module loading and unloading +License: LGPLv2+ + +%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 +Requires: %{name}-libs%{?_isa} = %{version}-%{release} + +%description devel +The kmod-devel package provides header files used for development of +applications that wish to load or unload Linux kernel modules. + +%prep +%autosetup -p1 + +%build +%configure \ + --with-openssl \ + --with-zlib \ + --with-xz + +%{make_build} V=1 + +%install +%{make_install} + +pushd $RPM_BUILD_ROOT/%{_mandir}/man5 +ln -s modprobe.d.5.gz modprobe.conf.5.gz +popd + +find %{buildroot} -type f -name "*.la" -delete + +mkdir -p $RPM_BUILD_ROOT%{_sbindir} +ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/modprobe +ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/modinfo +ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/insmod +ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/rmmod +ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/depmod +ln -sf ../bin/kmod $RPM_BUILD_ROOT%{_sbindir}/lsmod + +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 + +%files +%dir %{_sysconfdir}/depmod.d +%dir %{_sysconfdir}/modprobe.d +%dir %{_prefix}/lib/modprobe.d +%{_bindir}/kmod +%{_sbindir}/modprobe +%{_sbindir}/modinfo +%{_sbindir}/insmod +%{_sbindir}/rmmod +%{_sbindir}/lsmod +%{_sbindir}/depmod +%{_sbindir}/weak-modules +%{_datadir}/bash-completion/ +%attr(0644,root,root) %{_mandir}/man5/*.5* +%attr(0644,root,root) %{_mandir}/man8/*.8* +%doc NEWS README TODO + +%files libs +%license COPYING +%{_libdir}/libkmod.so.* + +%files devel +%{_includedir}/libkmod.h +%{_libdir}/pkgconfig/libkmod.pc +%{_libdir}/libkmod.so + +%changelog +* Tue Jul 28 2020 Fedora Release Engineering - 27-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Wed Mar 25 2020 Yauheni Kaliuta - 27-2 +- add 0001-depmod-do-not-output-.bin-to-stdout.patch + Resolves: rhbz#1808430 + +* Thu Feb 20 2020 Peter Robinson - 27-1 +- New upstream v27 + +* Mon Jan 20 2020 Yauheni Kaliuta - 26-5 +- weak-modules: sync with RHEL + +* Thu Jul 25 2019 Fedora Release Engineering - 26-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Mon Feb 25 2019 Yauheni Kaliuta - 26-3 +- weak-modules: sync with RHEL + +* Sun Feb 24 2019 Yauheni Kaliuta - 26-2 +- add PKCS7/openssl support (rhbz 1320921) + +* Sun Feb 24 2019 Yauheni Kaliuta - 26-1 +- Update to version 26 (rhbz 1673749) + +* Fri Feb 01 2019 Fedora Release Engineering - 25-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Mon Oct 29 2018 James Antill - 25-4 +- Remove ldconfig scriptlet, now done via. transfiletrigger in glibc (rhbz 1644063) + +* Fri Jul 13 2018 Fedora Release Engineering - 25-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Wed Feb 07 2018 Fedora Release Engineering - 25-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Tue Jan 09 2018 Josh Boyer - 25-1 +- Update to version 25 (rhbz 1532597) + +* Thu Aug 03 2017 Fedora Release Engineering - 24-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 24-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Fri Feb 24 2017 Josh Boyer - 24-1 +- Update to version 24 (rhbz 1426589) + +* Fri Feb 10 2017 Fedora Release Engineering - 23-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Fri Jul 22 2016 Josh Boyer - 23-1 +- Update to version 23 + +* Thu Feb 25 2016 Peter Robinson 22-4 +- Add powerpc patch to fix ToC on 4.5 ppc64le kernel + +* Thu Feb 04 2016 Fedora Release Engineering - 22-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Thu Jan 07 2016 Josh Boyer - 22-2 +- Fix path to dracut in weak-modules (rhbz 1295038) + +* Wed Nov 18 2015 Josh Boyer - 22-1 +- Update to version 22 + +* Wed Jun 17 2015 Fedora Release Engineering - 21-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Mon Jun 15 2015 Ville Skyttä - 21-2 +- Own bash completion dirs not owned by anything in dep chain + +* Tue Jun 09 2015 Josh Boyer - 21-1 +- Update to verion 21 + +* Mon Mar 02 2015 Josh Boyer - 20.1 +- Update to version 20 + +* Sat Feb 21 2015 Till Maas - 19-2 +- Rebuilt for Fedora 23 Change + https://fedoraproject.org/wiki/Changes/Harden_all_packages_with_position-independent_code + +* Sun Nov 16 2014 Josh Boyer - 19-1 +- Update to version 19 + +* Wed Oct 29 2014 Josh Boyer - 18-4 +- Backport patch to fix device node permissions (rhbz 1147248) + +* Sun Aug 17 2014 Fedora Release Engineering - 18-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Sat Jul 12 2014 Tom Callaway - 18-2 +- fix license handling + +* Tue Jun 24 2014 Josh Boyer - 18-1 +- Update to version 18 + +* Sun Jun 08 2014 Fedora Release Engineering - 17-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Wed Apr 09 2014 Josh Boyer - 17-1 +- Update to version 17 + +* Thu Jan 02 2014 Václav Pavlín - 16-1 +- Update to version 16 + +* Thu Aug 22 2013 Josh Boyer - 15-1 +- Update to version 15 + +* Sat Aug 03 2013 Fedora Release Engineering - 14-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild + +* Fri Jul 05 2013 Josh Boyer - 14-1 +- Update to version 14 + +* Fri Apr 19 2013 Václav Pavlín - 13-2 +- Main package should require -libs + +* Wed Apr 10 2013 Josh Boyer - 13-1 +- Update to version 13 + +* Wed Mar 20 2013 Weiping Pan - 12-3 +- Pull in weak-modules for kABI from Jon Masters + +* Mon Mar 18 2013 Josh Boyer +- Add patch to make rmmod understand built-in modules (rhbz 922187) + +* Thu Feb 14 2013 Fedora Release Engineering - 12-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Thu Dec 06 2012 Josh Boyer +- Update to version 12 + +* Thu Nov 08 2012 Josh Boyer +- Update to version 11 + +* Fri Sep 07 2012 Josh Boyer +- Update to version 10 + +* Mon Aug 27 2012 Josh Boyer +- Update to version 9 + +* Thu Jul 19 2012 Fedora Release Engineering - 8-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Wed May 23 2012 Josh Boyer - 8-2 +- Provide modprobe.conf(5) (rhbz 824552) + +* Tue May 08 2012 Josh Boyer - 8-1 +- Update to version 8 + +* Mon Mar 19 2012 Kay Sievers - 7-1 +- update to version 7 + - fix issue with --show-depends, where built-in + modules of the running kernel fail to include + loadable modules of the kernel specified + +* Sun Mar 04 2012 Kay Sievers - 6-1 +- update to version 6 +- remove all patches, they are included in the release + +* Fri Feb 24 2012 Kay Sievers - 5-8 +- try to address brc#771285 + +* Sun Feb 12 2012 Kay Sievers - 5-7 +- fix infinite loop with softdeps + +* Thu Feb 09 2012 Harald Hoyer 5-6 +- add upstream patch to fix "modprobe --ignore-install --show-depends" + otherwise dracut misses a lot of modules, which are already loaded + +* Wed Feb 08 2012 Harald Hoyer 5-5 +- add "lsmod" + +* Tue Feb 7 2012 Kay Sievers - 5-4 +- remove temporarily added fake-provides + +* Tue Feb 7 2012 Kay Sievers - 5-3 +- temporarily add fake-provides to be able to bootstrap + the new udev which pulls the old udev into the buildroot + +* Tue Feb 7 2012 Kay Sievers - 5-1 +- Update to version 5 +- replace the module-init-tools package and provide all tools + as compatibility symlinks + +* Mon Jan 16 2012 Kay Sievers - 4-1 +- Update to version 4 +- set --with-rootprefix= +- enable zlib and xz support + +* Thu Jan 05 2012 Jon Masters - 3-1 +- Update to latest upstream (adds new depmod replacement utility) +- For the moment, use the "kmod" utility to test the various functions + +* Fri Dec 23 2011 Jon Masters - 2-6 +- Update kmod-2-with-rootlibdir patch with rebuild automake files + +* Fri Dec 23 2011 Jon Masters - 2-5 +- Initial build for Fedora following package import + +* Thu Dec 22 2011 Jon Masters - 2-4 +- There is no generic macro for non-multilib "/lib", hardcode like others + +* Thu Dec 22 2011 Jon Masters - 2-3 +- Update package incorporating fixes from initial review feedback +- Cleaups to SPEC, rpath, documentation, library and binary locations + +* Thu Dec 22 2011 Jon Masters - 2-2 +- Update package for posting to wider test audience (initial review submitted) + +* Thu Dec 22 2011 Jon Masters - 2-1 +- Initial Fedora package for module-init-tools replacement (kmod) library diff --git a/sources b/sources new file mode 100644 index 0000000..47c908a --- /dev/null +++ b/sources @@ -0,0 +1 @@ +SHA512 (kmod-27.tar.xz) = e0513094935333fca1fb4c3e3493b232507a579ab00a6457cc9ed3e928363d05aad80634fb65a8287a336bf9895194c7be8ddc41bb088a6c2cca44fc1bfbdb6c diff --git a/tests/libkmod/Makefile b/tests/libkmod/Makefile new file mode 100644 index 0000000..cc53a81 --- /dev/null +++ b/tests/libkmod/Makefile @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: LGPL-2.1+ +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Makefile of /CoreOS/libkmod +# Description: Test if libkmod working ok +# Author: Susant Sahani +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +export TEST=/CoreOS/libkmod +export TESTVERSION=1.0 + +OBJS = test-libkmod.c +CFLAG = -Wall -g3 +CC = gcc +LIBS = -lkmod -lcmocka + +test-libkmod:${OBJ} + ${CC} ${CFLAGS} ${INCLUDES} -o $@ ${OBJS} ${LIBS} + +run: test-libkmod + ./runtest.sh +clean: + -rm -f test-libkmod + +.c.o: + ${CC} ${CFLAGS} ${INCLUDES} -c $< + +CC = gcc + +include /usr/share/rhts/lib/rhts-make.include +$(METADATA): Makefile + @echo "Owner: Susant Sahani" > $(METADATA) + @echo "Name: $(TEST)" >> $(METADATA) + @echo "TestVersion: $(TESTVERSION)" >> $(METADATA) + @echo "Path: $(TEST_DIR)" >> $(METADATA) + @echo "Description: Test libkmod works ok" >> $(METADATA) + @echo "Type: Sanity" >> $(METADATA) + @echo "TestTime: 5m" >> $(METADATA) + @echo "RunFor: libkmod" >> $(METADATA) + @echo "Requires: libkmod libkmod-devel" >> $(METADATA) + @echo "Priority: Normal" >> $(METADATA) + @echo "License: GPLv2" >> $(METADATA) + @echo "Confidential: no" >> $(METADATA) + @echo "Destructive: no" >> $(METADATA) + @echo "Releases: -Fedora 29" >> $(METADATA) + rhts-lint $(METADATA) diff --git a/tests/libkmod/runtest.sh b/tests/libkmod/runtest.sh new file mode 100755 index 0000000..1ef013c --- /dev/null +++ b/tests/libkmod/runtest.sh @@ -0,0 +1,36 @@ +#!/bin/bash +# SPDX-License-Identifier: LGPL-2.1+ +# ~~~ +# runtest.sh of libkmod +# Description: Tests for libkmod. +# +# Author: Susant Sahani +# Copyright (c) 2018 Red Hat, Inc. +# ~~~ + +# Include Beaker environment +. /usr/share/beakerlib/beakerlib.sh || exit 1 + +PACKAGE="kmod-devel" +IPIP="/usr/lib/modules/$(uname -r)/kernel/net/ipv4/ipip.ko.xz" + +rlJournalStart + rlPhaseStartSetup + rlAssertRpm $PACKAGE + rlAssertExists "$IPIP" + rlRun "cp test-libkmod /usr/bin/" + rlPhaseEnd + + rlPhaseStartTest + rlLog "Starting libkmod tests ..." + rlRun "/usr/bin/test-libkmod" + rlPhaseEnd + + rlPhaseStartCleanup + rlRun "rm /usr/bin/test-libkmod" + rlLog "libkmod tests done" + rlPhaseEnd +rlJournalPrintText +rlJournalEnd + +rlGetTestState diff --git a/tests/libkmod/test-libkmod.c b/tests/libkmod/test-libkmod.c new file mode 100644 index 0000000..507e581 --- /dev/null +++ b/tests/libkmod/test-libkmod.c @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: LGPL-2.1+ +# ~~~ +# Description: Tests libkmod +# +# Author: Susant Sahani +# Copyright (c) 2018 Red Hat, Inc. +# ~~~ +*/ + +#include +#include +#include +#include +#include +#include +#include + +static int load_module(void **state) { + struct kmod_list *list = NULL; + struct kmod_ctx *ctx = NULL; + struct kmod_list *l; + int r; + + assert_non_null((ctx = kmod_new(NULL, NULL))); + assert_return_code(kmod_module_new_from_lookup(ctx, "ipip", &list), 0); + + kmod_list_foreach(l, list) { + struct kmod_module *mod = NULL; + + mod = kmod_module_get_module(l); + assert_non_null(mod); + + assert_return_code(kmod_module_probe_insert_module(mod, 0, NULL, NULL, NULL, NULL), 0); + } + + free(ctx); + + return 0; +} + +static int remove_module(void **state) { + struct kmod_list *list = NULL; + struct kmod_ctx *ctx = NULL; + struct kmod_list *l; + int r; + + assert_non_null((ctx = kmod_new(NULL, NULL))); + assert_return_code(kmod_module_new_from_lookup(ctx, "ipip", &list), 0); + + kmod_list_foreach(l, list) { + struct kmod_module *mod = NULL; + + mod = kmod_module_get_module(l); + assert_non_null(mod); + + assert_return_code(kmod_module_remove_module(mod, 0), 0); + } + + free(ctx); + + return 0; +} + +void test_load_module(void **state) { + load_module(NULL); +} + +void test_remove_module(void **state) { + remove_module(NULL); +} + +int main(int argc, char *argv[]) { + const struct CMUnitTest libmod_tests[] = { + cmocka_unit_test_teardown(test_load_module, remove_module), + cmocka_unit_test_setup(test_remove_module, load_module), + }; + + return cmocka_run_group_tests(libmod_tests, NULL, NULL); +} diff --git a/tests/sanity/Makefile b/tests/sanity/Makefile new file mode 100644 index 0000000..e422f7f --- /dev/null +++ b/tests/sanity/Makefile @@ -0,0 +1,79 @@ +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Makefile of general/kmod/sanity +# Description: kmod test +# +# 2016-07-31 +# Author: Chunyu Hu +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Copyright (c) 2016 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing +# to use, modify, copy, or redistribute it subject to the terms +# and conditions of the GNU General Public License version 2. +# +# This program is distributed in the hope that it will be +# useful, but WITHOUT ANY WARRANTY; without even the implied +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +# PURPOSE. See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public +# License along with this program; if not, write to the Free +# Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +# Boston, MA 02110-1301, USA. +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +TENV=_env +ifeq ($(PKG_TOP_DIR),) + export PKG_TOP_DIR := $(shell p=$$PWD; while :; do \ + [ -e $$p/env.mk -o -z "$$p" ] && { echo $$p; break; }; p=$${p%/*}; done) + export _TOP_DIR := $(shell p=$$PWD; while :; do \ + [ -d $$p/.git -o -z "$$p" ] && { echo $$p; break; }; p=$${p%/*}; done) + -include $(PKG_TOP_DIR)/env.mk +endif +include $(TENV) +ifeq ($(_TOP_DIR),) + _TOP_DIR=/mnt/tests/$(TOPLEVEL_NAMESPACE) +endif + +export TESTVERSION=1.0 + +BUILT_FILES= + +FILES=$(TENV) $(METADATA) _env runtest.sh Makefile PURPOSE lib.sh + +.PHONY: all install download clean + +run: $(FILES) build + ( set +o posix; . /usr/bin/rhts_environment.sh; \ + . /usr/share/beakerlib/beakerlib.sh; \ + . runtest.sh ) + +build: $(BUILT_FILES) + test -x runtest.sh || chmod a+x runtest.sh + +clean: + rm -fr *~ $(BUILT_FILES) + +include /usr/share/rhts/lib/rhts-make.include + +$(METADATA): Makefile + @echo "Owner: Chunyu Hu " > $(METADATA) + @echo "Name: $(TEST)" >> $(METADATA) + @echo "TestVersion: $(TESTVERSION)" >> $(METADATA) + @echo "Path: $(TEST_DIR)" >> $(METADATA) + @echo "Description: kmod kernel module check from kernel modules tools">> $(METADATA) + @echo "Type: Regression" >> $(METADATA) + @echo "TestTime: 1h" >> $(METADATA) + @echo "RunFor: kernel" >> $(METADATA) + @echo "Requires: kernel" >> $(METADATA) + @echo "Requires: sysstat perf trace-cmd" >> $(METADATA) + @echo "Requires: $(PACKAGE_NAME) python rpm wget" >> $(METADATA) + @echo "Priority: Normal" >> $(METADATA) + @echo "License: GPLv2" >> $(METADATA) + @echo "Confidential: no" >> $(METADATA) + @echo "Destructive: no" >> $(METADATA) + rhts-lint $(METADATA) diff --git a/tests/sanity/PURPOSE b/tests/sanity/PURPOSE new file mode 100644 index 0000000..5950e75 --- /dev/null +++ b/tests/sanity/PURPOSE @@ -0,0 +1,4 @@ +Defaults to testing currently running kernel modules tools on all architectures. + +The test runs on any architecture, check normal kernel modules and compressed kernel modules for sanity + diff --git a/tests/sanity/_env b/tests/sanity/_env new file mode 100644 index 0000000..9f69344 --- /dev/null +++ b/tests/sanity/_env @@ -0,0 +1,8 @@ +#This file was generated automatically,do not manually change it. +export TOPLEVEL_NAMESPACE=kernel +export PKG_NAMESPACE=kernel/general +export RELATIVE_PATH=kmod/sanity +export PACKAGE=general +export PACKAGE_NAME=general +export PKG_LIST= +export TEST=/kernel/general/kmod/sanity diff --git a/tests/sanity/lib.sh b/tests/sanity/lib.sh new file mode 100755 index 0000000..d9a6c33 --- /dev/null +++ b/tests/sanity/lib.sh @@ -0,0 +1,258 @@ +#!/bin/bash + +dir_extra=/usr/lib/modules/$(uname -r)/extra +dir_updates=/usr/lib/modules/$(uname -r)/updates +dir_weak_updates=/usr/lib/modules/$(uname -r)/weak-updates +kmods=(base kmod_test_force kmod_test) + +function kmod_log_warn() +{ + echo "WARN: $*" +} + + +function kmod_log_pass() +{ + echo "PASS: $*" +} + +function kmod_log_fail() +{ + echo "FAIL: $*" +} + +function kmod_log_info() +{ + echo "INFO: $*" +} + +function kmod_log_err() +{ + echo "ERR: $*" +} + +function kmod_verify_exist() +{ + local files=$* + local ret=0 + local msg=0 + local f= + for f in $files; do + if ! test -f $f; then + ret=$((ret + 1)) + continue + fi + done + return $ret +} + +function kmod_verify_loaded() +{ + local kmods=$* + local ret=$? + for kmod in $kmods; do + lsmod | grep -w ${kmod/.ko/} + if [ $? -ne 0 ]; then + ret=$((ret+1)) + continue + fi + done + return $ret +} + +# tainted should be shown +function kmod_verify_dmesg() +{ + local str="$1" + dmesg | grep -i "$str" + return $? +} + +function kmod_verify_tainted() +{ + local kmod=$1 + shift + local taint_expect=$* + local ret=0 + local checker=./parse_taint.sh + local tainted=$(cat /proc/sys/kernel/tainted) + kmod_log_info "Kernel taint value: $tainted" + local flag= + for flag in $taint_expect; do + $checker $tainted | grep -we $flag || ret=$((ret + 1)) + done + return $ret +} + +function kmod_verify_tainted_module() +{ + local kmod=$1 + shift + local taint_expect="$*" + local ret=0 + + if ! test -f /sys/module/$kmod/taint; then + kmod_log_info "Kmod taint value on module $kmod not supported" + kmod_log_info "$(ls /sys/module/$kmod/)" + return 0 + fi + + local kmod_tainted=$(cat /sys/module/$kmod/taint) + ret=$(( $ret + 1 )) + kmod_log_info "Kmod taint value: $kmod_tainted" + + local flag= + local grep_exec="grep" + for flag in $*; do + grep_exec+=" -e $flag" + done + + echo "$kmod_tainted" | $grep_exec + ret=$? + return $ret +} + +function kmod_check_result() +{ + local opt=$1 + shift 1 + local dir=$1 + shift 1 + local files=$* + case $opt in + compile) + for f in $files; do + if kmod_verify_exist $dir/$f; then + kmod_log_pass "File exist: $dir/$f" + else + kmod_log_fail "File does not exist: $dir/$f" + return 1 + fi + done + ;; + load) + for f in $files; do + if kmod_verify_loaded $f; then + kmod_log_fail $f not loaded + return 1 + else + kmod_log_pass $f loaded + fi + done + ;; + unload) + for f in $files; do + if ! kmod_verify_loaded $f; then + kmod_log_fail $f unloaded + return 1 + else + kmod_log_pass $f not loaded + fi + done + ;; + *) + ;; + esac + return 0 +} + +# Locate the compiled kmods into several dirs for different +# tests. +function kmod_locate_extra() +{ + local ret=0 + if ! test -d $dir_extra; then + kmod_log_warn "$dir_extra does not exist." + return 1 + fi + local f= + for f in $*; do + cp -f $f $dir_extra || ret=$((ret + 1)) + done + depmod || ret=$((ret+1)) + return $ret +} + +function kmod_locate_updates() +{ + local ret=0 + if ! test -d $dir_updates; then + kmod_log_warn "$dir_updates does not exist." + return 1 + fi + for f in $*; do + cp -f $f $dir_updates || ret=$((ret + 1)) + done + depmod || ret=$((ret+1)) + return $ret +} + +function kmod_locate_weak_updates() +{ + local ret=0 + if ! test -d $dir_weak_updates; then + kmod_log_warn "$dir_weak_updates does not exist." + return 1 + fi + for f in $*; do + cp -f $f $dir_weak_updates || ret=$((ret + 1)) + done + depmod || ret=$((ret+1)) + return $ret +} + +function kmod_cleanup_all() +{ + local ret=$? + for ko in ${kmod[*]}; do + test -f $dir_extra/${ko}.ko && rm -r $dir_extra/${ko}.ko + test -f $dir_weak_updates/${ko}.ko && rm -r $dir_weak_updates/${ko}.ko + test -f $dir_updates/${ko}.ko && rm -r $dir_extra/${ko}.ko + done +} + +# The kmods should be loaded now. +function kmod_check_all_loaded() +{ + local ret=$? + lsmod | grep base -w + ret=$(($ret + $?)) + lsmod | grep -w kmod_test_dependency + ret=$(($ret + $?)) + lsmod | grep -w kmod_test_force + ret=$(($ret + $?)) + return $ret +} + +function kmod_unload_all() +{ + local ret=0 + lsmod | grep -w kmod_test_force && rmmod kmod_test_force + lsmod | grep -w base && rmmod base + ! lsmod | grep -w base + ret=$(($ret | $?)) + ! lsmod | grep -w kmod_test_force + ret=$(($ret | $?)) + return $ret +} + + +function kmod_load_all() +{ + local kmod= + kmod_unload_all || return $? + for kmod in $*; do + modprobe $kmod || return $? + done +} + +function kmod_load_all_force() +{ + local kmod= + kmod_unload_all || return $? + for kmod in $*; do + modprobe -f $kmod || return $? + dmesg | tail -n 10 + done +} + diff --git a/tests/sanity/parse_taint.sh b/tests/sanity/parse_taint.sh new file mode 100755 index 0000000..72ddf24 --- /dev/null +++ b/tests/sanity/parse_taint.sh @@ -0,0 +1,70 @@ +# /bin/bash +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# Copyright (c) 2015 Red Hat, Inc. +# +# This copyrighted material is made available to anyone wishing +# to use, modify, copy, or redistribute it subject to the terms +# and conditions of the GNU General Public License version 2. +# +# This program is distributed in the hope that it will be +# useful, but WITHOUT ANY WARRANTY; without even the implied +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +# PURPOSE. See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public +# License along with this program; if not, write to the Free +# Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +# Boston, MA 02110-1301, USA. +# +# Author: Chunyu Hu +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +taint_mask=( + [0]="P (G=Gnu)TAINT_PROPRIETARY_MODULE" + [1]="F TAINT_FORCED_MODULE" + [2]="S TAINT_UNSAFE_SMP" + [3]="R TAINT_FORCED_RMMOD" + [4]="M TAINT_MACHINE_CHECK" + [5]="B TAINT_BAD_PAGE" + [6]="U TAINT_USER" + [7]="D TAINT_DIE" + [8]="A TAINT_OVERRIDDEN_ACPI_TABLE" + [9]="W TAINT_WARN" + [10]="C TAINT_CRAP" + [11]="I TAINT_FIRMWARE_WORKAROUND" + [12]="O TAINT_OOT_MODULE [RHEL7 ONLY]" + [13]="E TAINT_UNSIGNED_MODULE" + [14]="L TAINT_SOFTLOCKUP" + [15]="K TAINT_LIVEPATCH" + [16]="? TAINT_16" + [17]="? TAINT_17" + [18]="? TAINT_18" + [19]="? TAINT_19" + [20]="? TAINT_20" + [21]="? TAINT_21" + [22]="? TAINT_22" + [23]="? TAINT_23" + [24]="? TAINT_24" + [25]="? TAINT_25" + [26]="? TAINT_26" + [27]="? TAINT_BIT_BY_ZOMBIE" + [28]="H TAINT_HARDWARE_UNSUPPORTED" + [29]="T TAINT_TECH_PREVIEW" + [30]="? TAINT_RESERVED30" + [31]="? TAINT_RESERVED31" +) + +function parse_taint(){ + for mask in ${!taint_mask[*]};do + if (( ((1< +# Author: Chunyu Hu +# Update: Ziqian SUN +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +# +# Copyright (c) 2015 Red Hat, Inc. +# +# This program is free software: you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation, either version 2 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be +# useful, but WITHOUT ANY WARRANTY; without even the implied +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +# PURPOSE. See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see http://www.gnu.org/licenses/. +# +# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +# Include Beaker environment +. /usr/share/beakerlib/beakerlib.sh || exit 1 +. lib.sh + +PACKAGE="kmod" +if [ -z $TESTARGS ]; then +export TESTARGS=$(rpm -q --queryformat '%{version}-%{release}\n' -qf /boot/config-$(uname -r)) +fi +name=kernel +version=$(echo $TESTARGS | awk 'BEGIN {FS="-"} {print $1 }') +release=$(echo $TESTARGS | awk 'BEGIN {FS="-"} {print $2 }') +DEBUG=0 +result=FAIL +FAIL=0 +PASS=0 +arch=`uname -m` + +export TESTS=${TESTS:-kmod_load_insmod kmod_load_modprobe kmod_modinfo} + +# Functions +function kmod_load_insmod() +{ + local m + for m in ${existed_unloaded}; do + #local m_name=$(basename ${m//.ko}) won't work for compressed kmod + local m_name=$(basename ${m} | sed "s/.ko//;s/.xz//;s/.gz//") + rlRun "insmod $mod_path/$m" + rlRun "lsmod | grep ${m_name}" + rlRun "rmmod ${m_name}" + rlRun "lsmod | grep ${m_name}" 1-255 + done +} + +function kmod_load_modprobe() +{ + rlRun "modprobe tun" + rlRun "modprobe -r tun" +} + +function kmod_modinfo() +{ + for m in ${existed_unloaded}; do + local m_name=$(basename ${m} | sed "s/.ko//;s/.xz//;s/.gz//") + rlRun "modinfo -l $m_name" + done +} + +RunKmod() { + local tests + for tests in $@; do + rlPhaseStartTest $tests + case $tests in + load_unload_kernel_modules) + load_unload_kernl_modules_func + ;; + load_unload_compressed_kernel_modules) + load_unload_compressed_kernel_module_func + ;; + *) + $tests + ;; + esac + rlPhaseEnd + done +} + +rlJournalStart + rlPhaseStartSetup + mod_list="/kernel/net/ipv4/udp_tunnel.ko /kernel/net/wireless/lib80211.ko /kernel/net/wireless/ath/ath9k/ath9k.ko /kernel/net/ipv4/udp_tunnel.ko.xz /kernel/net/wireless/lib80211.ko.xz /kernel/net/wireless/ath/ath9k/ath9k.ko.xz" + if [[ -L /lib && -d /lib ]]; then + mod_path=/usr/lib/modules/`uname -r`/ + else + mod_path=/lib/modules/`uname -r`/ + fi + existed_unloaded="" + local m + for m in ${mod_list}; do + test -f $mod_path/$m && existed_unloaded+="$m " + done + [ -z "$existed_unloaded" ] && rlDie "There is no right module path to use : $mod_list" + rlPhaseEnd + + rlPhaseStartTest + RunKmod $TESTS + rlPhaseEnd + + if ! (lsmod | grep gre) + then + wparam="gre" + elif ! (lsmod | grep uwb) + then + wparam="uwb" + else + wparam="atm" + fi + rlPhaseStartTest "Modprobe with wrong parameter" + rlRun -l "modprobe $wparam BADPARAM=this_should_fail" 0-1 + rlRun -l "dmesg | grep -i 'Unknown parameter' | grep 'BADPARAM' | grep '$wparam'" + rlPhaseEnd + + rlPhaseStartCleanup + rlPhaseEnd + + rlJournalPrintText +rlJournalEnd diff --git a/tests/tests.yml b/tests/tests.yml new file mode 100644 index 0000000..828a27a --- /dev/null +++ b/tests/tests.yml @@ -0,0 +1,18 @@ +- hosts: localhost + tags: + - classic + roles: + - role: standard-test-beakerlib + tests: + - sanity + - libkmod + required_packages: + - kernel + - perf + - sysstat + - trace-cmd + - kmod + - kmod-devel + - gcc + - libcmocka + - libcmocka-devel diff --git a/weak-modules b/weak-modules new file mode 100644 index 0000000..65806d0 --- /dev/null +++ b/weak-modules @@ -0,0 +1,1199 @@ +#!/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 + 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 + 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" + local file="$2" + local suffix="$3" + + echo "${BASEDIR}/boot/${file}-${krel}${suffix}" + echo "${BASEDIR}/lib/modules/${krel}/${file}${suffix}" +} + +find_kernel_file() { + local krel="$1" + local file="$2" + local suffix="$3" + local print="$4" + local i + + if [[ "$print" != "" ]]; then + make_kernel_file_names "$krel" "$file" "$suffix" + return 0 + fi + + for i in $(make_kernel_file_names "$krel" "$file" "$suffix"); 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 .gz "$print" +} + +# 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 "$no_suffix" "$print" +} + +#### 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 + + tmp=$(mktemp -p $tmpdir) + compatible_modules=() + + if ! [[ -e $tmpdir/symvers-$krel ]]; then + local symvers_path=$(find_symvers_file "$krel") + + [[ -n "$symvers_path" ]] || return + zcat "$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 + 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 + + 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