Add possibility to add kernel drivers to initrd

Before this change there was no possibility for developers to specify what
kernel drivers should be included in the upgrade/target initramfs. This
includes third-party drivers, which are necessary for system upgrades in some
spefic use cases.

Changes include:
 - A new model `KernelModule` (analogous to the `DracutModule` model) has been
   created, to handle kernel drivers.
 - Added an `include_kernel_drivers` field in the `UpgradeInitramfsTasks` model
   to handle a list of these drivers.
 - Data in the `include_kernel_drivers` field is processed correctly to detect
   conflicting paths.
 - Modified the `generate-iniram.sh` script to accept and process the new data
 - Added checks for kernel drivers, in the `CheckInitramfsTasks` actor.
 - Updated the unit-tests accordingly.

Author: dkubek

repos/system_upgrade/common/actors/commonleappdracutmodules/libraries/modscan.py

@@ -31,6 +31,7 @@
     'kernel-core',
     'kernel-modules',
     'keyutils',
+    'kmod',
     'lldpad',
     'lvm2',
     'mdadm',

repos/system_upgrade/common/actors/initramfs/checkinitramfstasks/libraries/checkinitramfstasks.py

@@ -6,11 +6,11 @@
 from leapp.models import TargetInitramfsTasks, UpgradeInitramfsTasks
 
 DRACUT_MOD_DIR = '/usr/lib/dracut/modules.d/'
-SUMMARY_DRACUT_FMT = (
-    'The requested dracut modules for the initramfs are in conflict.'
-    ' At least one dracut module is specified to be installed from'
-    ' multiple paths. The list of conflicting dracut module names'
-    ' with paths is listed below: {}'
+SUMMARY_FMT = (
+    'The requested {kind} modules for the initramfs are in conflict.'
+    ' At least one {kind} module is specified to be installed from'
+    ' multiple paths. The list of conflicting {kind} module names'
+    ' with paths is listed below: {conflicts}'
 )
 
 
@@ -22,51 +22,72 @@ def _printable_modules(conflicts):
     return ''.join(output)
 
 
-def _treat_path(dmodule):
+def _treat_path_dracut(dmodule):
     """
     In case the path is not set, set the expected path of the dracut module.
     """
+
     if not dmodule.module_path:
         return os.path.join(DRACUT_MOD_DIR, dmodule.name)
     return dmodule.module_path
 
 
-def _detect_dracut_modules_conflicts(msgtype):
+def _treat_path_kernel(kmodule):
+    """
+    In case the path of a kernel module is not set, indicate that the module is
+    taken from the current system.
+    """
+
+    if not kmodule.module_path:
+        return kmodule.name + ' (system)'
+    return kmodule.module_path
+
+
+def _detect_modules_conflicts(msgtype, kind):
     """
     Return dict of modules with conflicting tasks
 
-    In this case when a dracut module should be applied but different
-    sources are specified. E.g.:
-       include dracut modules X where,
+    In this case when a module should be applied but different sources are
+    specified. E.g.:
+       include modules X where,
          msg A)  X
          msg B)  X from custom path
     """
-    dracut_modules = defaultdict(set)
+
+    modules_map = {
+        'dracut': {
+            'msgattr': 'include_dracut_modules',
+            'treat_path_fn': _treat_path_dracut,
+        },
+        'kernel': {
+            'msgattr': 'include_kernel_modules',
+            'treat_path_fn': _treat_path_kernel
+        },
+    }
+
+    modules = defaultdict(set)
     for msg in api.consume(msgtype):
-        for dmodule in msg.include_dracut_modules:
-            dracut_modules[dmodule.name].add(_treat_path(dmodule))
-    return {key: val for key, val in dracut_modules.items() if len(val) > 1}
+        for module in getattr(msg, modules_map[kind]['msgattr']):
+            treat_path_fn = modules_map[kind]['treat_path_fn']
+            modules[module.name].add(treat_path_fn(module))
+    return {key: val for key, val in modules.items() if len(val) > 1}
+
+
+def report_conflicts(msgname, kind, msgtype):
+    conflicts = _detect_modules_conflicts(msgtype, kind)
+    if not conflicts:
+        return
+    report = [
+        reporting.Title('Conflicting requirements of {kind} modules for the {msgname} initramfs'.format(
+            kind=kind, msgname=msgname)),
+        reporting.Summary(SUMMARY_FMT.format(kind=kind, conflicts=_printable_modules(conflicts))),
+        reporting.Severity(reporting.Severity.HIGH),
+        reporting.Groups([reporting.Groups.SANITY, reporting.Groups.INHIBITOR]),
+    ]
+    reporting.create_report(report)
 
 
 def process():
-    conflicts = _detect_dracut_modules_conflicts(UpgradeInitramfsTasks)
-    if conflicts:
-        report = [
-            reporting.Title('Conflicting requirements of dracut modules for the upgrade initramfs'),
-            reporting.Summary(SUMMARY_DRACUT_FMT.format(_printable_modules(conflicts))),
-            reporting.Severity(reporting.Severity.HIGH),
-            reporting.Groups([reporting.Groups.SANITY]),
-            reporting.Groups([reporting.Groups.INHIBITOR]),
-        ]
-        reporting.create_report(report)
-
-    conflicts = _detect_dracut_modules_conflicts(TargetInitramfsTasks)
-    if conflicts:
-        report = [
-            reporting.Title('Conflicting requirements of dracut modules for the target initramfs'),
-            reporting.Summary(SUMMARY_DRACUT_FMT.format(_printable_modules(conflicts))),
-            reporting.Severity(reporting.Severity.HIGH),
-            reporting.Groups([reporting.Groups.SANITY]),
-            reporting.Groups([reporting.Groups.INHIBITOR]),
-        ]
-        reporting.create_report(report)
+    report_conflicts('upgrade', 'kernel', UpgradeInitramfsTasks)
+    report_conflicts('upgrade', 'dracut', UpgradeInitramfsTasks)
+    report_conflicts('target', 'dracut', TargetInitramfsTasks)

repos/system_upgrade/common/actors/initramfs/checkinitramfstasks/tests/unit_test_checkinitramfstasks.py

@@ -6,15 +6,16 @@
 from leapp.libraries.actor import checkinitramfstasks
 from leapp.libraries.common.testutils import create_report_mocked, CurrentActorMocked
 from leapp.libraries.stdlib import api
-from leapp.models import DracutModule, Report, TargetInitramfsTasks, UpgradeInitramfsTasks
+from leapp.models import DracutModule, KernelModule, TargetInitramfsTasks, UpgradeInitramfsTasks
 from leapp.utils.report import is_inhibitor
 
 
 def gen_UIT(modules):
     if not isinstance(modules, list):
         modules = [modules]
     dracut_modules = [DracutModule(name=i[0], module_path=i[1]) for i in modules]
-    return UpgradeInitramfsTasks(include_dracut_modules=dracut_modules)
+    kernel_modules = [KernelModule(name=i[0], module_path=i[1]) for i in modules]
+    return UpgradeInitramfsTasks(include_dracut_modules=dracut_modules, include_kernel_modules=kernel_modules)
 
 
 def gen_TIT(modules):
@@ -71,9 +72,57 @@ def gen_TIT(modules):
         TargetInitramfsTasks,
     ),
 ])
-def test_conflict_detection(monkeypatch, expected_res, input_msgs, test_msg_type):
+def test_dracut_conflict_detection(monkeypatch, expected_res, input_msgs, test_msg_type):
     monkeypatch.setattr(api, 'current_actor', CurrentActorMocked(msgs=input_msgs))
-    res = checkinitramfstasks._detect_dracut_modules_conflicts(test_msg_type)
+    res = checkinitramfstasks._detect_modules_conflicts(test_msg_type, 'dracut')
+    assert res == expected_res
+
+
+@pytest.mark.parametrize('expected_res,input_msgs,test_msg_type', [
+    (
+        {},
+        [],
+        UpgradeInitramfsTasks,
+    ),
+    (
+        {},
+        [gen_UIT([('modA', 'pathA'), ('modB', 'pathB')])],
+        UpgradeInitramfsTasks,
+    ),
+    (
+        {},
+        [gen_UIT([('modA', 'pathA'), ('modA', 'pathA')])],
+        UpgradeInitramfsTasks,
+    ),
+    (
+        {'modA': {'pathA', 'pathB'}},
+        [gen_UIT([('modA', 'pathA'), ('modA', 'pathB')])],
+        UpgradeInitramfsTasks,
+    ),
+    (
+        {'modA': {'pathA', 'pathB'}},
+        [gen_UIT(('modA', 'pathA')), gen_UIT(('modA', 'pathB'))],
+        UpgradeInitramfsTasks,
+    ),
+    (
+        {'modA': {'pathA', 'pathB'}},
+        [gen_UIT([('modA', 'pathA'), ('modA', 'pathB'), ('modB', 'pathC')])],
+        UpgradeInitramfsTasks,
+    ),
+    (
+        {'modA': {'modA (system)', 'pathB'}},
+        [gen_UIT([('modA', None), ('modA', 'pathB')])],
+        UpgradeInitramfsTasks,
+    ),
+    (
+        {},
+        [gen_UIT([('modA', 'pathA'), ('modA', 'pathB')])],
+        TargetInitramfsTasks,
+    ),
+])
+def test_kernel_conflict_detection(monkeypatch, expected_res, input_msgs, test_msg_type):
+    monkeypatch.setattr(api, 'current_actor', CurrentActorMocked(msgs=input_msgs))
+    res = checkinitramfstasks._detect_modules_conflicts(test_msg_type, 'kernel')
     assert res == expected_res
 
 

repos/system_upgrade/common/actors/initramfs/upgradeinitramfsgenerator/files/generate-initram.sh

@@ -67,6 +67,15 @@ build() {
         DRACUT_MODULES_ADD=$(echo "--add $LEAPP_ADD_DRACUT_MODULES" | sed 's/,/ --add /g')
     fi
 
+    KERNEL_MODULES_ADD=""
+    if [[ -n "$LEAPP_ADD_KERNEL_MODULES" ]]; then
+        depmod "${KERNEL_VERSION}" -a
+        KERNEL_MODULES_ADD=$(
+            echo "--add-drivers $LEAPP_ADD_KERNEL_MODULES" | 
+            sed 's/,/ --add-drivers /g'
+            )
+    fi
+
     DRACUT_INSTALL="systemd-nspawn"
     if [[ -n "$LEAPP_DRACUT_INSTALL_FILES" ]]; then
         DRACUT_INSTALL="$DRACUT_INSTALL $LEAPP_DRACUT_INSTALL_FILES"
@@ -89,6 +98,7 @@ build() {
         --confdir "$DRACUT_CONF_DIR" \
         --install "$DRACUT_INSTALL" \
         $DRACUT_MODULES_ADD \
+        $KERNEL_MODULES_ADD \
         "$DRACUT_MDADMCONF_ARG" \
         "$DRACUT_LVMCONF_ARG" \
         --no-hostonly \