add method to resolve some kernel module names from modules.alias

this works in some cases, an important thing to note is that the "cache"
made at _KMOD_ALIASES is tied to the `kernel_version` at the time it's
first read. This should generally be fine, as the kernel_version should
only be set once at runtime, and this should run after it's set

Signed-off-by: Zen <[email protected]>

Author: desultory

src/ugrd/kmod/kmod.py

@@ -1,25 +1,23 @@
 __author__ = "desultory"
-__version__ = "3.5.0"
+__version__ = "3.6.0"
 
 from pathlib import Path
 from platform import uname
+from re import search
 from struct import error as StructError
 from struct import unpack
 from subprocess import run
 from typing import Union
 
 from ugrd.exceptions import AutodetectError, ValidationError
-from ugrd.kmod import (
-    BuiltinModuleError,
-    DependencyResolutionError,
-    IgnoredModuleError,
-    MissingModuleError,
-)
+from ugrd.kmod import BuiltinModuleError, DependencyResolutionError, IgnoredModuleError, MissingModuleError
 from zenlib.util import colorize as c_
 from zenlib.util import contains, unset
 
+_KMOD_ALIASES = {}
 MODULE_METADATA_FILES = ["modules.order", "modules.builtin", "modules.builtin.modinfo"]
 
+
 def _normalize_kmod_name(self, module: Union[str, list]) -> str:
     """Replaces -'s with _'s in a kernel module name.
     ignores modules defined in kmod_no_normalize.
@@ -34,6 +32,43 @@ def _normalize_kmod_name(self, module: Union[str, list]) -> str:
     return module.replace("-", "_")
 
 
+def _get_kmod_aliases(self):
+    """Returns a processed dictionary of kernel module aliases."""
+    if _KMOD_ALIASES:
+        return _KMOD_ALIASES
+
+    if not self.get("kernel_version"):
+        raise AutodetectError("Kernel version is not set, cannot resolve kernel module aliases.")
+
+    alias_file = Path("/lib/modules") / self["kernel_version"] / "modules.alias"
+    if not alias_file.exists():
+        raise FileNotFoundError(f"Kernel module alias file does not exist: {c_(alias_file, 'red', bold=True)}")
+
+    for line in alias_file.read_text().splitlines():
+        _, alias, module = line.strip().split(" ", 2)
+        # Strip bus type
+        alias = alias.split(":", 1)[-1]
+        alias = alias.split(",", 1)[-1]
+        _KMOD_ALIASES[alias] = _normalize_kmod_name(self, module)
+    return _KMOD_ALIASES
+
+
+def _resolve_kmod_alias(self, module: str) -> str:
+    """Attempts to resolve a kernel module alias to a module name.
+    Uses  /lib/modules/<kernel_version>/modules.alias to find the module name.
+    normalizes - to _ then replaces _ with [_-] to allow for both _ and - in the module name.
+    """
+    module = module.replace("-", "_")
+    module = module.replace("_", "[_-]")  # Allow for both _ and - in the module name
+    aliases = _get_kmod_aliases(self)
+    for alias, kmod in aliases.items():
+        if search(module, alias):
+            self.logger.debug(f"Resolved kernel module alias: {c_(alias, 'green')} -> {c_(kmod, 'cyan')}")
+            return kmod
+
+    raise MissingModuleError(f"Failed to resolve kernel module alias: {module}")
+
+
 def _process_kernel_modules_multi(self, module: str) -> None:
     """Adds kernel modules to self['kernel_modules']."""
     module = _normalize_kmod_name(self, module)
@@ -98,7 +133,13 @@ def _get_kmod_info(self, module: str):
         raise DependencyResolutionError("[%s] Failed to run modinfo command: %s" % (module, " ".join(args))) from e
 
     if not cmd.stdout and cmd.stderr:
-        raise DependencyResolutionError("[%s] Modinfo returned no output." % module)
+        try:
+            resolved_module = _resolve_kmod_alias(self, module)
+            return _get_kmod_info(self, resolved_module)
+        except MissingModuleError:
+            raise DependencyResolutionError(
+                "[%s] Modinfo returned no output and alias name could no be resolved." % module
+            )
 
     module_info = {}
     for line in cmd.stdout.decode().split("\n"):
@@ -159,7 +200,9 @@ def _autodetect_modules_lsmod(self) -> None:
         modules = [line.split()[0] for line in f.readlines()]
 
     if len(modules) > 25:
-        self.logger.warning(f"[{len(modules)}] More than 25 kernel modules were autodetected from the running kernel. If lsmod detection is required for your use case, please file a bug report so more appropriate detection methods can be implemented.")
+        self.logger.warning(
+            f"[{len(modules)}] More than 25 kernel modules were autodetected from the running kernel. If lsmod detection is required for your use case, please file a bug report so more appropriate detection methods can be implemented."
+        )
     for module in modules:
         self["_kmod_auto"] = module.split()[0]
 
@@ -477,7 +520,9 @@ def _process_optional_modules(self) -> None:
             self.logger.debug(f"Optional kmod_init module is built-in, skipping: {c_(kmod, 'yellow')}")
             continue
         except DependencyResolutionError as e:
-            self.logger.warning(f"[{c_(kmod, 'yellow', bold=True)}] Failed to process optional kernel module dependencies: {e}")
+            self.logger.warning(
+                f"[{c_(kmod, 'yellow', bold=True)}] Failed to process optional kernel module dependencies: {e}"
+            )
 
 
 @unset("no_kmod", "no_kmod is enabled, skipping.", log_level=30)
@@ -486,6 +531,11 @@ def process_modules(self) -> None:
     _process_optional_modules(self)
     self.logger.debug("Processing kernel modules: %s" % self["kernel_modules"])
     for kmod in self["kernel_modules"].copy():
+        """ Process all kernel modules
+        for kmod_init modules, log an error if info can't be retreived, but continue processing.
+        in successful cases, continue, if he module processing fails, add to the ignore list.
+        Later, when ignored modules are processed, an exception is raised if the module is required.
+        """
         self.logger.debug("Processing kernel module: %s" % kmod)
         try:
             _process_kmod_dependencies(self, kmod)
@@ -507,6 +557,7 @@ def process_modules(self) -> None:
         self["kmod_ignore"] = kmod
 
     for kmod in self["_kmod_auto"]:
+        """ Do similar for automatic modules, but log warnings insead of errors if dependencies are missing. """
         if kmod in self["kernel_modules"]:
             self.logger.debug("Autodetected module is already in kernel_modules: %s" % kmod)
             continue