[gelöst] yavdr-ansible: /usr/local/bin/module-helper unload der DVB Treiber schlägt fehl

mahil · 3. Mai 2022

Hallo,

habe wie hier geschildert meinen Standby konfiguriert. Das hat leider nicht direkt funktioniert. Bei der Fehlersuche bin ich dann auf die Ursache in /usr/local/bin/module-helper gestoßen. Die bei meiner Hardware beteiligten Treiber lassen sich so anzeigen:

Code

# lsmod | egrep 'smipcie|m88ds3103|dvb_core'
m88ds3103              32768  2
i2c_mux                16384  1 m88ds3103
smipcie                24576  0
dvb_core              139264  2 smipcie,m88ds3103
rc_core                53248  4 rc_dvbsky,smipcie,ir_rc5_decoder
mc                     53248  1 dvb_core
i2c_algo_bit           16384  2 smipcie,i915

Daraus baut dann der module-helper ein Array der zu löschenden Module auf mit dem Inhalt/Reihenfolge "['m88ds3103', 'smipcie', 'dvb_core']". Es wird also zuerst "m88ds3103" entfernt. Das führt aber leider zu einem Fehler:

Code

# rmmod m88ds3103
rmmod: ERROR: Module m88ds3103 is in use

Der module-helper müsste zuerst den "smipcie" Treiber entfernen. Dann lassen sich auch "m88ds3103" und zuletzt "dvb_core" ohne Probleme entfernen. Hab ich manuell so erfolgreich ausprobiert. Ich vermute mal der module-helper müsste bei der Reihenfolge der Treiberliste die Reihenfolge in der Spalte "used_by" bei dem Treiber dvb_core beachten. Deshalb habe ich in /usr/local/bin/module-helper noch folgendes ergänzt:

Code: /usr/local/bin/module-helper

# diff -c /usr/local/bin/module-helper.ori /usr/local/bin/module-helper
*** /usr/local/bin/module-helper.ori    2022-01-19 18:44:43.890325362 +0100
--- /usr/local/bin/module-helper        2022-05-03 13:44:56.947919512 +0200
***************
*** 35,40 ****
--- 35,41 ----
              if len(values) > 3:
                  #print("module {} depends on {}".format(values[0], values[3]))
                  dependency_map[values[0]] = values[3].split(',')
+                 dependency_map[values[0]].reverse()


  def run_command_on_module_list(command, module_list):

Alles anzeigen

Dadurch werden die Treiber in der richtigen Reihenfolge (['smipcie', 'm88ds3103', 'dvb_core']) entfernt und das System kommt nach dem Standby wieder richtig hoch.

Ob diese Änderung negative Auswirkungen bei anderen Installation zeigen würde, kann ich leider nicht beurteilen. Aus meiner Sicht wäre es jedenfalls wünschenswert die Anpassung bei zukünftigen Versionen des module-helpers zu berücksichtigen. Evtl. lässt sich das auch schöner lösen, bin kein Python Entwickler.

davie2000 · 3. Mai 2022

Ein Tipp ins Blaue: ich würde die Werte der dritten Spalte sortieren und von 0 nach 4 "abarbeiten"/beenden.

seahawk1986 · 3. Mai 2022

Ich fürchte das ist komplexer als die Logik, die ich damals aus dem Skript von e-tobi übernommen hatte - ich habe das gerade noch mal mit den snd_* Modulen auf meinem System durchgespielt:

Code

$ lsmod | grep snd
snd_hda_codec_hdmi     73728  1
snd_hda_codec_realtek   151552  1
snd_hda_codec_generic   102400  1 snd_hda_codec_realtek
ledtrig_audio          16384  1 snd_hda_codec_generic
snd_hda_intel          53248  0
snd_intel_dspcfg       28672  1 snd_hda_intel
snd_intel_sdw_acpi     20480  1 snd_intel_dspcfg
snd_hda_codec         155648  4 snd_hda_codec_generic,snd_hda_codec_hdmi,snd_hda_intel,snd_hda_codec_realtek
snd_hda_core          110592  5 snd_hda_codec_generic,snd_hda_codec_hdmi,snd_hda_intel,snd_hda_codec,snd_hda_codec_realtek
snd_hwdep              16384  1 snd_hda_codec
snd_pcm               139264  4 snd_hda_codec_hdmi,snd_hda_intel,snd_hda_codec,snd_hda_core
snd_seq_midi           20480  0
snd_seq_midi_event     16384  1 snd_seq_midi
snd_rawmidi            49152  1 snd_seq_midi
snd_seq                73728  2 snd_seq_midi,snd_seq_midi_event
snd_seq_device         16384  3 snd_seq,snd_seq_midi,snd_rawmidi
snd_timer              40960  2 snd_seq,snd_pcm
snd                   102400  11 snd_hda_codec_generic,snd_seq,snd_seq_device,snd_hda_codec_hdmi,snd_hwdep,snd_hda_intel,snd_hda_codec,snd_hda_codec_realtek,snd_timer,snd_pcm,snd_rawmidi
soundcore              16384  1 snd

Alles anzeigen

Da kann man wohl nicht einfach mit den gelisteten Modulen arbeiten, sondern man muss sich da an der Zahl der genutzten Instanzen entlang hangeln - also mit snd_hda_intel anfangen, weil das keine aktiven Instanzen hat, danach snd_hda_codec_hdmi und snd_hda_codec_realtek entfernen, dann snd_hda_codec_generic usw. - ich fürchte, das muss man iterativ lösen - kannst du mal schauen, ob dir das folgende Skript wie erwartet funktioniert?

Python

#!/usr/bin/env python3
from dataclasses import dataclass, field
import argparse
import pathlib
import pickle
import subprocess
import sys

PROC_MODULES = pathlib.Path('/proc/modules')


@dataclass
class Module:
    name: str
    raw_dependencies: list["Module"] = field(default_factory=list)
    dependencies: list["Module"] = field(default_factory=list)
    n_instances: int = 0

    def __hash__(self) -> int:
        return hash(self.name)

    @property
    def has_dependencies(self) -> bool:
        return len(self.dependencies) > 0 or self.n_instances > 0

    def get_all_dependencies(self) -> set["Module"]:
        deps = set()
        deps.add(self)
        for dep in self.dependencies:
            deps |= dep.get_all_dependencies()
        return deps


def read_modules(main_module_name) -> set[Module]:
    modules_with_deps = {}
    # read the proc filesystem to get the loaded modules
    for line in PROC_MODULES.read_text().splitlines():
        module, _, n_instances, dependencies, *_ = line.split()
        deps = list(
            filter(lambda x: x not in ('', '-'), dependencies.split(',')))
        modules_with_deps[module] = Module(
            name=module,
            raw_dependencies=deps,
            n_instances=int(n_instances)
        )
    # fill in dependencies
    for m in modules_with_deps.values():
        for dep in m.raw_dependencies:
            m.dependencies.append(modules_with_deps[dep])
        m.raw_dependencies.clear()

    # get a set of the modules we need to unload
    if (main_module := modules_with_deps.get(main_module_name)):
        all_dependencies = main_module.get_all_dependencies()
    else:
        all_dependencies = set()
    return all_dependencies


def run_command_on_module_list(command, module_list):
    for module in module_list:
        cmd = [command, module]
        print(*cmd)
        subprocess.run(cmd, check=True)


def create_argparser():
    parser = argparse.ArgumentParser(description="load or unload modules")
    group = parser.add_mutually_exclusive_group()
    group.add_argument('-u', '--unload', metavar='MODULE', nargs='+',
                       help='unload modules')
    group.add_argument('-r', '--reload', action='store_true',
                       help='reload modules')
    parser.add_argument('-t', '--temp-file', nargs='?',
                        default='/tmp/modules.list',
                        help='''store names of unloaded modules in a file,
                              default location is /tmp/modules.list''')
    return parser


def main():
    parser = create_argparser()
    args = parser.parse_args()
    if args.unload:
        for module in args.unload:
            unloaded_modules = []
            while (all_dependencies := read_modules(module)):
                # print(all_dependencies)
                modules_without_deps = [
                    m for m in all_dependencies if not m.has_dependencies
                ]
                for m in modules_without_deps:
                    print(f"modprobe -r {m.name}")
                    subprocess.run(['modprobe', '-r', m.name], check=True)
                    unloaded_modules.append(m.name)
            try:
                with open(args.temp_file, 'wb') as f:
                    pickle.dump(unloaded_modules, f)
            except Exception as err:
                sys.exit(err)
    elif args.reload:
        with open(args.temp_file, 'rb') as f:
            all_modules = pickle.load(f)
        run_command_on_module_list('modprobe', all_modules)
    else:
        parser.print_help()


if __name__ == '__main__':
    main()

Alles anzeigen

wirbel · 3. Mai 2022

so ein binary zum Entladen der DVB Treiber habe ich mal für die Ex-easyvdr-Distri geschrieben.

Vielleicht haben die Jungs da noch die Sources irgendwo.

mahil · 4. Mai 2022

Zitat von seahawk1986

Ich fürchte das ist komplexer als die Logik, die ich damals aus dem Skript von e-tobi übernommen hatte - ich habe das gerade noch mal mit den snd_* Modulen auf meinem System durchgespielt:

Code

$ lsmod | grep snd
snd_hda_codec_hdmi     73728  1
snd_hda_codec_realtek   151552  1
snd_hda_codec_generic   102400  1 snd_hda_codec_realtek
ledtrig_audio          16384  1 snd_hda_codec_generic
snd_hda_intel          53248  0
snd_intel_dspcfg       28672  1 snd_hda_intel
snd_intel_sdw_acpi     20480  1 snd_intel_dspcfg
snd_hda_codec         155648  4 snd_hda_codec_generic,snd_hda_codec_hdmi,snd_hda_intel,snd_hda_codec_realtek
snd_hda_core          110592  5 snd_hda_codec_generic,snd_hda_codec_hdmi,snd_hda_intel,snd_hda_codec,snd_hda_codec_realtek
snd_hwdep              16384  1 snd_hda_codec
snd_pcm               139264  4 snd_hda_codec_hdmi,snd_hda_intel,snd_hda_codec,snd_hda_core
snd_seq_midi           20480  0
snd_seq_midi_event     16384  1 snd_seq_midi
snd_rawmidi            49152  1 snd_seq_midi
snd_seq                73728  2 snd_seq_midi,snd_seq_midi_event
snd_seq_device         16384  3 snd_seq,snd_seq_midi,snd_rawmidi
snd_timer              40960  2 snd_seq,snd_pcm
snd                   102400  11 snd_hda_codec_generic,snd_seq,snd_seq_device,snd_hda_codec_hdmi,snd_hwdep,snd_hda_intel,snd_hda_codec,snd_hda_codec_realtek,snd_timer,snd_pcm,snd_rawmidi
soundcore              16384  1 snd

Alles anzeigen

Da kann man wohl nicht einfach mit den gelisteten Modulen arbeiten, sondern man muss sich da an der Zahl der genutzten Instanzen entlang hangeln - also mit snd_hda_intel anfangen, weil das keine aktiven Instanzen hat, danach snd_hda_codec_hdmi und snd_hda_codec_realtek entfernen, dann snd_hda_codec_generic usw. - ich fürchte, das muss man iterativ lösen - kannst du mal schauen, ob dir das folgende Skript wie erwartet funktioniert?

Python

#!/usr/bin/env python3
from dataclasses import dataclass, field
import argparse
import pathlib
import pickle
import subprocess
import sys

PROC_MODULES = pathlib.Path('/proc/modules')


@dataclass
class Module:
    name: str
    raw_dependencies: list["Module"] = field(default_factory=list)
    dependencies: list["Module"] = field(default_factory=list)
    n_instances: int = 0

    def __hash__(self) -> int:
        return hash(self.name)

    @property
    def has_dependencies(self) -> bool:
        return len(self.dependencies) > 0 or self.n_instances > 0

    def get_all_dependencies(self) -> set["Module"]:
        deps = set()
        deps.add(self)
        for dep in self.dependencies:
            deps |= dep.get_all_dependencies()
        return deps


def read_modules(main_module_name) -> set[Module]:
    modules_with_deps = {}
    # read the proc filesystem to get the loaded modules
    for line in PROC_MODULES.read_text().splitlines():
        module, _, n_instances, dependencies, *_ = line.split()
        deps = list(
            filter(lambda x: x not in ('', '-'), dependencies.split(',')))
        modules_with_deps[module] = Module(
            name=module,
            raw_dependencies=deps,
            n_instances=int(n_instances)
        )
    # fill in dependencies
    for m in modules_with_deps.values():
        for dep in m.raw_dependencies:
            m.dependencies.append(modules_with_deps[dep])
        m.raw_dependencies.clear()

    # get a set of the modules we need to unload
    if (main_module := modules_with_deps.get(main_module_name)):
        all_dependencies = main_module.get_all_dependencies()
    else:
        all_dependencies = set()
    return all_dependencies


def run_command_on_module_list(command, module_list):
    for module in module_list:
        cmd = [command, module]
        print(*cmd)
        subprocess.run(cmd, check=True)


def create_argparser():
    parser = argparse.ArgumentParser(description="load or unload modules")
    group = parser.add_mutually_exclusive_group()
    group.add_argument('-u', '--unload', metavar='MODULE', nargs='+',
                       help='unload modules')
    group.add_argument('-r', '--reload', action='store_true',
                       help='reload modules')
    parser.add_argument('-t', '--temp-file', nargs='?',
                        default='/tmp/modules.list',
                        help='''store names of unloaded modules in a file,
                              default location is /tmp/modules.list''')
    return parser


def main():
    parser = create_argparser()
    args = parser.parse_args()
    if args.unload:
        for module in args.unload:
            unloaded_modules = []
            while (all_dependencies := read_modules(module)):
                # print(all_dependencies)
                modules_without_deps = [
                    m for m in all_dependencies if not m.has_dependencies
                ]
                for m in modules_without_deps:
                    print(f"modprobe -r {m.name}")
                    subprocess.run(['modprobe', '-r', m.name], check=True)
                    unloaded_modules.append(m.name)
            try:
                with open(args.temp_file, 'wb') as f:
                    pickle.dump(unloaded_modules, f)
            except Exception as err:
                sys.exit(err)
    elif args.reload:
        with open(args.temp_file, 'rb') as f:
            all_modules = pickle.load(f)
        run_command_on_module_list('modprobe', all_modules)
    else:
        parser.print_help()


if __name__ == '__main__':
    main()

Alles anzeigen

Dein Skript liefert bei mir leider eine Fehlermeldung:

Code

# ./module-helper-new -u dvb_core
Traceback (most recent call last):
  File "./module-helper-new", line 13, in <module>
    class Module:
  File "./module-helper-new", line 15, in Module
    raw_dependencies: list["Module"] = field(default_factory=list)
TypeError: 'type' object is not subscriptable

Habe leider keine Python Programmierkenntnisse um das selber zu lösen.

seahawk1986 · 4. Mai 2022

Bist du noch mit focal unterwegs? Ich hatte das gestern nur mit Python 3.10 unter Ubuntu 22.04 probiert, für ältere Versionen braucht es noch andere Type-Annotationen:

Python

#!/usr/bin/env python3
from dataclasses import dataclass, field
from typing import List, Set
import argparse
import pathlib
import pickle
import subprocess
import sys

PROC_MODULES = pathlib.Path('/proc/modules')


@dataclass
class Module:
    name: str
    raw_dependencies: List["Module"] = field(default_factory=list)
    dependencies: List["Module"] = field(default_factory=list)
    n_instances: int = 0

    def __hash__(self) -> int:
        return hash(self.name)

    @property
    def has_dependencies(self) -> bool:
        return len(self.dependencies) > 0 or self.n_instances > 0

    def get_all_dependencies(self) -> Set["Module"]:
        deps = set()
        deps.add(self)
        for dep in self.dependencies:
            deps |= dep.get_all_dependencies()
        return deps


def read_modules(main_module_name: str) -> Set[Module]:
    modules_with_deps = {}
    # read the proc filesystem to get the loaded modules
    for line in PROC_MODULES.read_text().splitlines():
        module, _, n_instances, dependencies, *_ = line.split()
        deps = list(
            filter(lambda x: x not in ('', '-'), dependencies.split(',')))
        modules_with_deps[module] = Module(
            name=module,
            raw_dependencies=deps,
            n_instances=int(n_instances)
        )
    # fill in dependencies
    for m in modules_with_deps.values():
        for dep in m.raw_dependencies:
            m.dependencies.append(modules_with_deps[dep])
        m.raw_dependencies.clear()

    # get a set of the modules we need to unload
    if (main_module := modules_with_deps.get(main_module_name)):
        all_dependencies = main_module.get_all_dependencies()
    else:
        all_dependencies = set()
    return all_dependencies


def run_command_on_module_list(command, module_list):
    for module in module_list:
        cmd = [command, module]
        print(*cmd)
        subprocess.run(cmd, check=True)


def create_argparser():
    parser = argparse.ArgumentParser(description="load or unload modules")
    group = parser.add_mutually_exclusive_group()
    group.add_argument('-u', '--unload', metavar='MODULE', nargs='+',
                       help='unload modules')
    group.add_argument('-r', '--reload', action='store_true',
                       help='reload modules')
    parser.add_argument('-t', '--temp-file', nargs='?',
                        default='/tmp/modules.list',
                        help='''store names of unloaded modules in a file,
                              default location is /tmp/modules.list''')
    return parser


def main():
    parser = create_argparser()
    args = parser.parse_args()
    if args.unload:
        for module in args.unload:
            unloaded_modules = []
            while (all_dependencies := read_modules(module)):
                # print(all_dependencies)
                modules_without_deps = [
                    m for m in all_dependencies if not m.has_dependencies
                ]
                for m in modules_without_deps:
                    print(f"modprobe -r {m.name}")
                    subprocess.run(['modprobe', '-r', m.name], check=True)
                    unloaded_modules.append(m.name)
            try:
                with open(args.temp_file, 'wb') as f:
                    pickle.dump(unloaded_modules, f)
            except Exception as err:
                sys.exit(err)
    elif args.reload:
        with open(args.temp_file, 'rb') as f:
            all_modules = pickle.load(f)
        run_command_on_module_list('modprobe', all_modules)
    else:
        parser.print_help()


if __name__ == '__main__':
    main()

Alles anzeigen

mahil · 4. Mai 2022

Ja bin noch auf Focal. Dein Skript funktioniert dort fast . Beim reload der Module fehlt dann noch das dvb_core. Das wird beim unload nicht in /tmp/modules.list geschrieben.

seahawk1986 · 4. Mai 2022

Ok, das kann ich noch in die Liste der Module aufnehmen - auf meinem System wird dvb_core automatisch entladen und dann beim Restore auch wieder geladen - passiert das bei dir nicht?

Code

$ lsmod | grep dvb
dvb_core              139264  2 budget_av,budget_core
mc                     53248  2 videodev,dvb_core
$ sudo python3 module_helper.py -u dvb_core
modprobe -r budget_av
$ lsmod | grep dvb
$ sudo python3 module_helper.py -r
modprobe budget_av
$ lsmod | grep dvb
dvb_core              139264  2 budget_av,budget_core
mc                     53248  2 videodev,dvb_core

Alles anzeigen

seahawk1986 · 4. Mai 2022

Damit entlädt er das angegebene Modul explizit:

Python

#!/usr/bin/env python3
from dataclasses import dataclass, field
from typing import List, Set
import argparse
import pathlib
import pickle
import subprocess
import sys

PROC_MODULES = pathlib.Path('/proc/modules')


@dataclass
class Module:
    name: str
    raw_dependencies: List["Module"] = field(default_factory=list)
    dependencies: List["Module"] = field(default_factory=list)
    n_instances: int = 0

    def __hash__(self) -> int:
        return hash(self.name)

    @property
    def has_dependencies(self) -> bool:
        return len(self.dependencies) > 0 or self.n_instances > 0

    def get_all_dependencies(self) -> Set["Module"]:
        deps = set()
        deps.add(self)
        for dep in self.dependencies:
            deps |= dep.get_all_dependencies()
        return deps


def read_modules(main_module_name: str) -> Set[Module]:
    modules_with_deps = {}
    # read the proc filesystem to get the loaded modules
    for line in PROC_MODULES.read_text().splitlines():
        module, _, n_instances, dependencies, *_ = line.split()
        deps = list(
            filter(lambda x: x not in ('', '-'), dependencies.split(',')))
        modules_with_deps[module] = Module(
            name=module,
            raw_dependencies=deps,
            n_instances=int(n_instances)
        )
    # fill in dependencies
    for m in modules_with_deps.values():
        for dep in m.raw_dependencies:
            m.dependencies.append(modules_with_deps[dep])
        m.raw_dependencies.clear()

    # get a set of the modules we need to unload
    if (main_module := modules_with_deps.get(main_module_name)):
        all_dependencies = main_module.get_all_dependencies()
    else:
        all_dependencies = set()
    return all_dependencies


def run_command_on_module_list(command, module_list):
    for module in module_list:
        cmd = [command, module]
        print(*cmd)
        subprocess.run(cmd, check=True)


def create_argparser():
    parser = argparse.ArgumentParser(description="load or unload modules")
    group = parser.add_mutually_exclusive_group()
    group.add_argument('-u', '--unload', metavar='MODULE', nargs='+',
                       help='unload modules')
    group.add_argument('-r', '--reload', action='store_true',
                       help='reload modules')
    parser.add_argument('-t', '--temp-file', nargs='?',
                        default='/tmp/modules.list',
                        help='''store names of unloaded modules in a file,
                              default location is /tmp/modules.list''')
    return parser


def main():
    parser = create_argparser()
    args = parser.parse_args()
    if args.unload:
        for module in args.unload:
            unloaded_modules = []
            while (all_dependencies := read_modules(module)):
                # print(all_dependencies)
                modules_without_deps = [
                    m for m in all_dependencies if not m.has_dependencies
                ]
                for m in modules_without_deps:
                    print(f"modprobe -r {m.name}")
                    subprocess.run(['modprobe', '-r', m.name], check=True)
                    unloaded_modules.append(m.name)
            print(f"modprobe -r {module}")
            subprocess.run(['modprobe', '-r', module], check=True)
            unloaded_modules.append(module)
            try:
                with open(args.temp_file, 'wb') as f:
                    pickle.dump(unloaded_modules, f)
            except Exception as err:
                sys.exit(err)
    elif args.reload:
        with open(args.temp_file, 'rb') as f:
            all_modules = pickle.load(f)
        run_command_on_module_list('modprobe', all_modules)
    else:
        parser.print_help()


if __name__ == '__main__':
    main()

Alles anzeigen

mahil · 4. Mai 2022

Supi, vielen Dank, funktioniert jetzt. Bei mir wurde dvb_core nicht automatisch geladen.

seahawk1986 · 4. Mai 2022

Ich habe es mal ins git gebracht.

[gelöst] yavdr-ansible: /usr/local/bin/module-helper unload der DVB Treiber schlägt fehl

Jetzt mitmachen!

Teilen