utils_kernel_module: filter out not applicable module parameters

When reading kernel module parameters from sysfs, some parameters may
return the string "not required" if they are not applicable, for
example module kvm_intel parameter vmentry_l1d_flush. Previously,
these values were included in the parameter string passed to
modprobe when retoring the module, which leads to module
loading failure.
This change introduces new parameters "kvm_module_ignore_vals_list"
and "kvm_probe_module_ignore_vals_list" to skip parameters with the value
in list.

Signed-off-by: Liang Cong <lcong@redhat.com>

Author: liang-cong-red-hat

virttest/shared/cfg/base.cfg

@@ -1225,3 +1225,19 @@ uuid_dimm = ""
 # enable_igvm = no
 # igvm_path = /usr/share/coconut-svsm
 # igvm_filename = coconut-qemu.igvm
+
+# KVM Module Reload/Restore Settings for Test Pre-processing and Post-processing
+# ---------------------------------------------------------
+# Force reload KVM module
+#kvm_module_force_load = yes
+# Force reload vendor-specific module (kvm_intel/kvm_amd)
+#kvm_probe_module_force_load = yes
+# Parameters for KVM module (e.g., "nested=1")
+#kvm_module_parameters = "nested=1"
+# Parameters for vendor-specific module (e.g., "tdx=1")
+#kvm_probe_module_parameters = "tdx=1"
+# Values to ignore when backing up/restoring KVM module params
+#kvm_module_ignore_vals_list = ["not required"]
+# Values to ignore when backing up/restoring vendor-specific module (kvm_intel/kvm_amd) params
+#kvm_probe_module_ignore_vals_list = ["not required"]
+

virttest/test_setup/kernel.py

@@ -17,8 +17,11 @@ def setup(self):
             module_parameters = self.params.get(
                 "%s_module_parameters" % param_prefix, ""
             )
+            module_ignore_vals_list = eval(
+                self.params.get("%s_module_ignore_vals_list" % param_prefix, "[]")
+            )
             module_handler = utils_kernel_module.reload(
-                module, module_force_load, module_parameters
+                module, module_force_load, module_parameters, module_ignore_vals_list
             )
             if module_handler is not None:
                 self.kvm_module_handlers.append(module_handler)

virttest/utils_kernel_module.py

@@ -53,19 +53,21 @@ def __init__(self, module_name, reason):
         super(KernelModuleRestoreError, self).__init__("restore", module_name, reason)
 
 
-def reload(module_name, force, params=""):
+def reload(module_name, force, params="", ignore_values=None):
     """
     Convenience method that creates a KernelModuleHandler instance
     and reloads the module only if any action will is required.
 
     :param module_name: name of kernel module to be handled
     :param force: if to force load with params in any case, e.g. True
     :param params: parameters to load with, e.g. 'key1=param1 ...'
+    :param ignore_values: list of module parameter values to be ignored
     :return: instance if module was loaded
     """
-
+    if ignore_values is None:
+        ignore_values = []
     if params != "" or force:
-        handler = KernelModuleHandler(module_name)
+        handler = KernelModuleHandler(module_name, ignore_values)
         handler.reload_module(force, params)
         return handler
     return None
@@ -74,7 +76,7 @@ def reload(module_name, force, params=""):
 class KernelModuleHandler(object):
     """Class handling Linux kernel modules"""
 
-    def __init__(self, module_name):
+    def __init__(self, module_name, ignore_values):
         """Create kernel module handler"""
 
         self._module_name = module_name
@@ -86,6 +88,7 @@ def __init__(self, module_name):
         self._module_holders = self.module_holders
         self._was_loaded = None
         self._config_backup = None
+        self._ignore_values = ignore_values
         self._backup_config()
 
     def unload_module(self):
@@ -254,13 +257,21 @@ def _get_serialized_config(self):
         params = os.listdir(self._module_params_path)
         for param in params:
             with open(os.path.join(self._module_params_path, param), "r") as param_file:
-                mod_params[param] = param_file.read().strip()
+                mod_param_val = param_file.read().strip()
+                if mod_param_val in self._ignore_values:
+                    LOG.debug(
+                        "Module param '%s' with value '%s' is ignored",
+                        param,
+                        mod_param_val,
+                    )
+                    continue
+                mod_params[param] = mod_param_val
         return " ".join("%s=%s" % _ for _ in mod_params.items())
 
     @property
     def module_holders(self):
         """Find out which modules use this module."""
         if os.path.exists(self._module_holders_path):
             module_used_by = os.listdir(self._module_holders_path)
-            return [KernelModuleHandler(module) for module in module_used_by]
+            return [KernelModuleHandler(module, self._ignore_values) for module in module_used_by]
         return []