orhun/kmonLinux-Kernel-Manager und Aktivitätsmonitor 🐧💻
Linux-Kernel-Manager und Aktivitätsmonitor 🐧💻
Der Kernel ist der Teil des Betriebssystems, der die Interaktionen zwischen Hardware- und Software-Komponenten ermöglicht. Auf den meisten Systemen wird er nach dem Start nach dem Bootloader geladen und bearbeitet I/O-Anfragen sowie Peripheriegeräte wie Tastaturen, Monitore, Netzwerkadapter und Lautsprecher. Typischerweise ist der Kernel für die Speicherverwaltung, Prozessverwaltung, Geräteverwaltung, Systemaufrufe und Sicherheit zuständig. Anwendungen nutzen den Systemaufruf-Mechanismus, um einen Dienst vom Betriebssystem anzufordern, und in den meisten Fällen wird diese Anfrage mithilfe einer vom Betriebssystem bereitgestellten Bibliothek an den Kernel weitergeleitet, um die entsprechende Kernelfunktion aufzurufen. Während der Kernel diese grundlegenden Aufgaben ausführt, residiert er in einem separaten Speicherbereich namens geschützter Kernelspace, der für Anwendungen und andere Teile des Systems nicht zugänglich ist. Im Gegensatz dazu nutzen Anwendungen wie Browser, Texteditoren, Fenstermanager oder Audio-/Videoplayer einen anderen separaten Bereich des Speichers, den Userspace. Diese Trennung verhindert, dass Benutzerdaten und Kernel-Daten sich gegenseitig beeinträchtigen und zu Instabilität und Langsamkeit führen, und verhindert zudem, dass fehlerhafte Anwendungsprogramme das gesamte Betriebssystem zum Absturz bringen. Es gibt verschiedene Kernel-Designs aufgrund der unterschiedlichen Arten der Verwaltung von Systemaufrufen und Ressourcen. Während beispielsweise monolithische Kernel alle Betriebssystemanweisungen im selben Adressraum ausführen, um Geschwindigkeit zu erreichen, verwenden Mikrokerne unterschiedliche Räume für Benutzer- und Kernel-Dienste aus Gründen der Modularität. Darüber hinaus gibt es Hybridkerne, Nanokerne und Exokerne. Die hybride Kernelarchitektur basiert auf einer Kombination von Aspekten von Mikrokernen und monolithischen Kernen.
Der Linux-Kernel ist der quelloffene, monolithische und unixähnliche Betriebssystemkernel, der in den Linux-Distributionen, verschiedenen eingebetteten Systemen wie Routern sowie in allen Android-basierten Systemen verwendet wird. Linus Torvalds konzipierte und erstellte den Linux-Kernel im Jahr 1991, und er wird auch heute noch von Tausenden von Entwicklern weiterentwickelt. Er ist ein prominentes Beispiel für freie und Open-Source-Software und wird in anderen freien Softwareprojekten verwendet, insbesondere im GNU-Betriebssystem. Obwohl die Linux-basierten Betriebssysteme den größten Teil der Computerwelt dominieren, tragen sie immer noch einige Designschwächen in sich, die in den frühen Tagen von Linux recht umstritten waren. Beispielsweise hat er den größten Fußabdruck und die höchste Komplexität im Vergleich zu den anderen Kerneltypen. Aber dies ist eine Designeigenschaft, die monolithischen Kernen innewohnt. Diese Art von Designproblemen veranlasste Entwickler dazu, dem Linux-Kernel neue Funktionen und Mechanismen hinzuzufügen, die andere Kernel nicht haben.
Im Gegensatz zu den standardmäßigen monolithischen Kernen ist der Linux-Kernel auch modular und akzeptiert ladbare Kernelmodule (LKM), die typischerweise verwendet werden, um Unterstützung für neue Hardware (als Gerätetreiber) und/oder Dateisysteme hinzuzufügen oder um Systemaufrufe hinzuzufügen. Da LKMs zur Laufzeit in das System geladen und entladen werden können, haben sie den Vorteil, den Kernel zu erweitern, ohne neu starten und neu kompilieren zu müssen. Somit würden die durch Module bereitgestellten Kernelfunktionen nicht ohne Nutzung im Speicher verbleiben, und das entsprechende Modul kann entladen werden, um Speicher und andere Ressourcen freizugeben.
Ladbare Kernelmodule befinden sich in /lib/modules mit der Erweiterung .ko (kernel object) in Linux. Während der Befehl lsmod zum Auflisten der geladenen Kernelmodule verwendet werden kann, werden modprobe oder insmod/rmmod zum Laden oder Entladen eines Kernelmoduls verwendet. insmod/rmmod werden für Module verwendet, die unabhängig von modprobe sind und keine Installation in /lib/modules/$(uname -r) erfordern.
Hier ist ein einfaches Beispiel eines Linux-Kernelmoduls, das beim Laden und Entladen eine Nachricht ausgibt. Die Build- und Installationsschritte des Moduls mittels eines Makefiles sind unten aufgeführt.``` make # build sudo make install # install sudo modprobe lkm_example # load sudo modprobe -r lkm_example # unload
Der Befehl [dmesg](https://linux.die.net/man/8/dmesg) wird unten verwendet, um den Nachrichtenpuffer des Kernels abzurufen.```
[16994.295552] [+] Example kernel module loaded.
[16996.325674] [-] Example kernel module unloaded.
kmon bietet eine textbasierte Benutzeroberfläche zur Verwaltung der Linux-Kernel-Module und zur Überwachung der Kernel-Aktivitäten. Dabei umfasst die Verwaltung das Laden, Entladen, Blacklisten und Anzeigen der Informationen eines Moduls. Diese Aktualisierungen der Kernel-Module, Protokolle über die Hardware und andere Kernel-Nachrichten können mit dem Echtzeit-Aktivitätsmonitor in kmon verfolgt werden. Da für diese Aufgaben in Linux die Verwendung verschiedener Tools wie dmesg und kmod erforderlich ist, zielt kmon darauf ab, sie in einem einzigen Terminalfenster zu bündeln und die Nutzung so weit wie möglich zu erleichtern, während die Funktionalität erhalten bleibt.
kmon ist in Rust geschrieben und verwendet die Bibliotheken Ratatui und termion für seine textbasierte Benutzeroberfläche.
kmon kann mit Cargo von crates.io installiert werden, wenn Rust installiert ist.``` cargo install kmon
Die mindestens unterstützte Rust-Version (MSRV) ist `1.74.1`.
### Arch Linux
**kmon** kann aus dem [offiziellen Repository](https://www.archlinux.org/packages/extra/x86_64/kmon/) von Arch Linux installiert werden.```
pacman -S kmon
Es gibt auch ein Entwicklerpaket im AUR. Verwenden Sie Ihren bevorzugten AUR-Helfer zur Installation. Zum Beispiel,``` paru -S kmon-git
### Nixpkgs
**kmon** kann mit dem [Nix-Paketmanager](https://nixos.org/nix/) aus dem Kanal `nixpkgs-unstable` installiert werden.```
nix-channel --add https://nixos.org/channels/nixpkgs-unstable
nix-channel --update nixpkgs
nix-env -iA nixpkgs.kmon
Auf NixOS:``` nix-channel --add https://nixos.org/channels/nixos-unstable nix-channel --update nixos nix-env -iA nixos.kmon
### Alpine Linux
**kmon** ist für [Alpine Edge](https://pkgs.alpinelinux.org/packages?name=kmon&branch=edge) verfügbar. Es kann über [apk](https://wiki.alpinelinux.org/wiki/Alpine_Package_Keeper) installiert werden, nachdem das [Community-Repository](https://wiki.alpinelinux.org/wiki/Repositories) aktiviert wurde.```
apk add kmon
#### Build```
docker build -t kmon .
docker run -it --cap-add syslog kmon
### Manuell
1. Laden Sie die neueste Binärdatei aus dem Bereich [releases](https://github.com/orhun/kmon/releases) herunter und wählen Sie zwischen der [glibc](https://en.wikipedia.org/wiki/Glibc)- oder [musl-libc](https://musl.libc.org/)-Binärdatei.
2. Um das mit [glibc](https://en.wikipedia.org/wiki/Glibc) kompilierte Paket herunterzuladen, führen Sie Folgendes aus:```
wget https://github.com/orhun/kmon/releases/download/v[VERSION]/kmon-[VERSION]-x86_64-unknown-linux-gnu.tar.gz
3. Die Dateien extrahieren.```
tar -xvzf kmon-*.tar.gz
5. Führe die Binärdatei aus.```
./kmon
Verschiebe die Binärdatei nach /usr/local/bin/, um sie über das Terminal mit dem Befehl kmon auszuführen.
Manpage und Shell-Vervollständigungen werden zur Build-Zeit im Verzeichnis target generiert.
libxcb sollte installiert sein, um die Kopier-/Einfüge-Befehle von X11 nutzen zu können.
z. B.: Installiere das Paket libxcb1-dev für Debian/Ubuntu* und das Paket libxcb-devel für Fedora/openSUSE/Void Linux.
kmon [OPTIONS] [COMMAND]
### Optionen```
-a, --accent-color <COLOR> Set the accent color using hex or color name [default: white]
-c, --color <COLOR> Set the main color using hex or color name [default: darkgray]
-t, --tickrate <MS> Set the refresh rate of the terminal [default: 250]
-r, --reverse Reverse the kernel module list
-u, --unicode Show Unicode symbols for the block titles
-E, --regex Interpret the module search query as a regular expression
-h, --help Print help information
-V, --version Print version information
sort Sort kernel modules
#### Sortieren```
kmon sort [OPTIONS]
Optionen:``` -s, --size Sort modules by their sizes -n, --name Sort modules by their names -d, --dependent Sort modules by their dependent modules -h, --help Print help information
## Tastaturbelegungen
| | |
| ----------------------- | ------------------------------------- |
| `[?], F1` | Hilfe |
| `right/left, h/l` | Zwischen Blöcken wechseln |
| `up/down, k/j, alt-k/j` | Nach oben/unten scrollen [ausgewählter Block] |
| `pgup/pgdown` | Nach oben/unten scrollen [Kernel-Aktivitäten] |
| `</>` | Nach oben/unten scrollen [Modulinformationen] |
| `alt-h/l` | Nach rechts/links scrollen [Kernel-Aktivitäten] |
| `ctrl-t/b, home/end` | Nach oben/unten springen [Modulliste] |
| `alt-e/s` | Ausgewählten Block vergrößern/verkleinern |
| `ctrl-x` | Blockposition ändern |
| `ctrl-l/u, alt-c` | Kernel-Ringpuffer leeren |
| `[d], alt-d` | Abhängige Module anzeigen |
| `[1]..[9]` | Zum abhängigen Modul springen |
| `[\], tab, backtab` | Nächste Kernel-Information anzeigen |
| `[/], s, enter` | Ein Kernel-Modul suchen |
| `[+], i, insert` | Ein Kernel-Modul laden |
| `[-], u, backspace` | Kernel-Modul entladen |
| `[x], b, delete` | Kernel-Modul auf die Blacklist setzen |
| `ctrl-r, alt-r` | Kernel-Modul neu laden |
| `m, o` | Optionsmenü anzeigen |
| `y/n` | Befehl ausführen/abbrechen |
| `c/v` | Kopieren/Einfügen |
| `r, F5` | Aktualisieren |
| `q, ctrl-c/d, ESC` | Beenden |
## Funktionen
### Hilfe
Drücken Sie '`?`' während die Terminal-Benutzeroberfläche läuft, um die Tastaturbelegungen zu sehen.
### Navigation und Scrollen
`Pfeiltasten` werden zum Navigieren zwischen Blöcken und zum Scrollen verwendet.
#### Scrollen durch Kernel-Aktivitäten
Manche Kernel-Nachrichten können so lang sein, dass sie nicht in den Block der Kernel-Aktivitäten passen, da sie nicht umgebrochen werden. In diesem Fall können die Kernel-Aktivitäten mit den Tasten `alt-h & alt-l` horizontal gescrollt werden. Der vertikale Scrollmechanismus ist derselbe wie bei anderen Blöcken.
#### Sanftes Scrollen
Die Tasten `alt-j & alt-k` können verwendet werden, um den Block der Kernel-Aktivitäten und die Modulinformationen langsam zu scrollen.
### Optionsmenü
Die Tasten `m` und `o` können als Abkürzung für Kernel-Verwaltungsoperationen verwendet werden. Nach dem Drücken wird ein Optionsmenü zum Verwalten des aktuell ausgewählten Kernel-Moduls angezeigt.
### Blockgrößen
Die Tasten `alt-e & alt-s` können verwendet werden, um den ausgewählten Block zu vergrößern/verkleinern.
### Blockpositionen
Die Taste `ctrl-x` kann verwendet werden, um die Positionen der Blöcke zu ändern.
### Kernel-Informationen
Verwenden Sie eine der Tasten `\, tab, backtab`, um zwischen den Informationen zu Kernel-Version, -Ausgabe und -Plattform zu wechseln.
### Modulinformationen
Der Status eines Kernel-Moduls wird bei der Auswahl angezeigt.
#### Anzeigen der abhängigen Module
Verwenden Sie eine der Tasten `d, alt-d`, um alle abhängigen Module des ausgewählten Moduls anzuzeigen.
#### Springen zu abhängigen Modulen
Um von einem übergeordneten Modul zu einem abhängigen Kernel-Modul zu springen, können die `Zifferntasten` (1-9) verwendet werden, um den Index des Moduls in der Spalte _Verwendet von_ anzugeben.
### Ein Modul suchen
Wechseln Sie mit den Pfeiltasten oder einer der Tasten `/, s, enter` in den Suchbereich und geben Sie eine Suchanfrage für den Modulnamen ein.
### Ein Modul laden
Um ein Modul zum Linux-Kernel hinzuzufügen, wechseln Sie mit einer der Tasten `+, i, insert` in den Lademodus und geben Sie den Namen des zu ladenden Moduls ein. Bestätigen/brechen Sie dann die Ausführung des Ladebefehls mit `y/n`.
Der Befehl, der zum Laden eines Moduls verwendet wird:```
modprobe <module_name> || insmod <module_name>.ko
Verwenden Sie eine der -, u, Rückschritt Tasten, um das ausgewählte Modul aus dem Linux-Kernel zu entfernen.
Der Befehl, der zum Entfernen eines Moduls verwendet wird:``` modprobe -r <module_name> || rmmod <module_name>
### Ein Modul auf die Blacklist setzen
[Auf die Blacklist setzen](https://wiki.archlinux.org/index.php/Kernel_module#Blacklisting) ist ein Mechanismus, um zu verhindern, dass das Kernelmodul geladen wird. Um das ausgewählte Modul auf die Blacklist zu setzen, verwenden Sie eine der Tasten `x, b, delete` und bestätigen Sie die Ausführung.
Der Befehl, der zum Auf-die-Blacklist-Setzen eines Moduls verwendet wird:```
if ! grep -q <module_name> /etc/modprobe.d/blacklist.conf; then
echo 'blacklist <module_name>' >> /etc/modprobe.d/blacklist.conf
echo 'install <module_name> /bin/false' >> /etc/modprobe.d/blacklist.conf
fi
Verwenden Sie die ctrl-r- oder alt-r-Taste, um das ausgewählte Modul neu zu laden.
Der Befehl, der zum Neuladen eines Moduls verwendet wird:
reload
modprobe -r <module_name> || rmmod <module_name> && modprobe <module_name> || insmod <module_name>.ko
### Leeren des Ringpuffers
Der Kernel-Ringpuffer kann mit einer der Tasten `ctrl-l/u, alt-c` geleert werden.
```
dmesg --clear
c/v Tasten sind für Kopier-/Einfügeoperationen eingestellt.
Verwenden Sie ctrl-c/ctrl-v zum Kopieren und Einfügen im Eingabemodus.
Der sort Unterbefehl kann zum Sortieren der Kernelmodule nach ihren Namen, Größen oder abhängigen Modulen verwendet werden.```
kmon sort --name
kmon sort --size
kmon sort --dependent
Auch die `-r, --reverse`-Option wird verwendet, um die Liste der Kernel-Module umzukehren.```
kmon --reverse
kmon verwendet standardmäßig die Farben des Terminals, aber die Hervorhebungsfarbe kann mit der Option -c, --color angegeben werden. Alternativ kann die Standard-Textfarbe über die Option -a, --accent-color festgelegt werden.
Unterstützte Terminalfarben sind black, red, green, yellow, blue, magenta, cyan, gray, darkgray, lightred, lightgreen, lightyellow, lightblue, lightmagenta, lightcyan, white.```
kmon --color red
#### Verwenden einer benutzerdefinierten Farbe
Geben Sie einen hexadezimalen Wert für die zu verwendende Farbe an.```
kmon --color 19683a
Die Standardtextfarbe kann bei einigen Designs mit Transparenz zu Lesbarkeitsproblemen führen. Die Option -a, --accent-color kann ähnlich wie die Option -c, --color verwendet werden, um dieses Problem zu umgehen.```
kmon --color 6f849c --accent-color e35760
### Unicode-Symbole
Verwende die Option `-u, --unicode`, um Unicode-Symbole für die Blocktitel anzuzeigen.```
kmon --unicode
Die Option -t, --tickrate kann verwendet werden, um das Aktualisierungsintervall der Terminal-Benutzeroberfläche in Millisekunden festzulegen.
Die Option -E, --regex kann verwendet werden, um Module mittels regulärem Ausdruck zu suchen.
kmon möchte ein Standardwerkzeug für die Linux-Kernelverwaltung sein, während es die meisten Linux-Distributionen unterstützt.
Um dieses Ziel zu erreichen, sollte kmon über verschiedene Paketmanager wie Snap* und RPM zugänglich sein.
Es ist erforderlich, dass die grundlegenden Werkzeuge wie dmesg und kmod auf dem System vorhanden sind, damit kmon wie erwartet funktioniert. Daher wäre der nächste Schritt, für diese Funktionen nur die Systemressourcen zu nutzen.
Verwaltungsaktionen bezüglich des Linux-Kernels sollten in kmon anwendbar sein, um die Abhängigkeit von der Kommandozeile und anderen Werkzeugen zu minimieren.
kmon sollte auf verschiedenen Architekturen getestet und gemeldet werden, um die weitere Entwicklung und Unterstützung zu fördern.
| Fedora 31 | Debian 10 | Manjaro 19 |
|---|---|---|
 |  |  |
| Ubuntu 18.04 | openSUSE | Void Linux |
|---|---|---|
 |  |  |
Unterstützen Sie die Entwicklung meiner Projekte, indem Sie mich auf GitHub Sponsors unterstützen.
Unterstützen Sie die Open-Source-Entwicklung, indem Sie Unterstützer oder Sponsor werden.
GNU General Public License (3.0)
Copyright © 2020-2024, Orhun Parmaksız
