orhun/kmonGestionnaire du noyau Linux et moniteur d'activité 🐧💻
Gestionnaire de noyau Linux et moniteur d'activité 🐧💻
Le noyau est la partie du système d'exploitation qui facilite les interactions entre les composants matériels et logiciels. Sur la plupart des systèmes, il est chargé au démarrage après le chargeur d'amorçage et gère les demandes d'E/S ainsi que les périphériques tels que les claviers, les moniteurs, les adaptateurs réseau et les haut-parleurs. Généralement, le noyau est responsable de la gestion de la mémoire, de la gestion des processus, de la gestion des périphériques, des appels système et de la sécurité.
Les applications utilisent le mécanisme d'appel système pour demander un service au système d'exploitation et, la plupart du temps, cette requête est transmise au noyau via une bibliothèque fournie par le système d'exploitation pour invoquer la fonction noyau correspondante. Pendant que le noyau effectue ces tâches de bas niveau, il réside dans une partie séparée de la mémoire appelée espace noyau protégé, qui n'est pas accessible par les applications et les autres parties du système. En revanche, les applications comme les navigateurs, les éditeurs de texte, les gestionnaires de fenêtres ou les lecteurs audio/vidéo utilisent une zone distincte de la mémoire, l'espace utilisateur. Cette séparation empêche les données utilisateur et les données du noyau d'interférer entre elles, évitant ainsi l'instabilité et la lenteur, ainsi que la possibilité que des programmes applicatifs défaillants fassent planter l'ensemble du système d'exploitation.
Il existe différentes conceptions de noyau en raison des différentes manières de gérer les appels système et les ressources. Par exemple, alors que les noyaux monolithiques exécutent toutes les instructions du système d'exploitation dans le même espace d'adressage pour la vitesse, les micro-noyaux utilisent des espaces différents pour les services utilisateur et noyau pour la modularité. Outre ceux-ci, il existe des noyaux hybrides, des nanokernels et des exokernels. L'architecture du noyau hybride est basée sur la combinaison d'aspects des micro-noyaux et des noyaux monolithiques.
Le noyau Linux est le noyau open-source, monolithique et de type Unix utilisé dans les distributions Linux, divers systèmes embarqués comme les routeurs, ainsi que dans tous les systèmes basés sur Android. Linus Torvalds a conçu et créé le noyau Linux en 1991 et il est encore développé aujourd'hui par des milliers de développeurs. C'est un exemple marquant de logiciel libre et open source et il est utilisé dans d'autres projets de logiciels libres, notamment le système d'exploitation GNU. Bien que les systèmes d'exploitation basés sur Linux dominent la majeure partie de l'informatique, ils portent encore certains défauts de conception qui ont été assez débattus aux débuts de Linux. Par exemple, il a la plus grande empreinte et la plus grande complexité par rapport aux autres types de noyaux. Mais c'est une caractéristique de conception inhérente aux noyaux monolithiques. Ce genre de problèmes de conception a conduit les développeurs à ajouter de nouvelles fonctionnalités et mécanismes au noyau Linux que les autres noyaux ne possèdent pas.
Contrairement aux noyaux monolithiques standard, le noyau Linux est également modulaire, acceptant les modules noyau chargeables (LKM) qui sont généralement utilisés pour ajouter la prise en charge de nouveau matériel (en tant que pilotes de périphériques) et/ou de systèmes de fichiers, ou pour ajouter des appels système. Comme les LKM peuvent être chargés et déchargés dans le système à l'exécution, ils ont l'avantage d'étendre le noyau sans redémarrer ni recompiler. Ainsi, les fonctionnalités du noyau fournies par les modules ne résident pas en mémoire sans être utilisées, et le module correspondant peut être déchargé pour libérer de la mémoire et d'autres ressources.
Les modules noyau chargeables se trouvent dans /lib/modules avec l'extension .ko (kernel object) sous Linux. Alors que la commande lsmod peut être utilisée pour lister les modules noyau chargés, modprobe ou insmod/rmmod sont utilisés pour charger ou décharger un module noyau. insmod/rmmod sont utilisés pour les modules indépendants de modprobe et sans nécessiter une installation dans /lib/modules/$(uname -r).
Voici un exemple simple d'un module noyau Linux qui affiche un message lorsqu'il est chargé et déchargé. Les étapes de construction et d'installation du module à l'aide d'un Makefile sont présentées ci-dessous.``` make # build sudo make install # install sudo modprobe lkm_example # load sudo modprobe -r lkm_example # unload
La commande [dmesg](https://linux.die.net/man/8/dmesg) est utilisée ci-dessous pour récupérer le tampon de messages du noyau.```
[16994.295552] [+] Example kernel module loaded.
[16996.325674] [-] Example kernel module unloaded.
kmon fournit une interface utilisateur textuelle pour gérer les modules du noyau Linux et surveiller les activités du noyau. Gérer signifie charger, décharger, mettre sur liste noire et afficher les informations d'un module. Ces mises à jour des modules du noyau, les journaux concernant le matériel et autres messages du noyau peuvent être suivis grâce au moniteur d'activité en temps réel de kmon. Comme l'utilisation de différents outils comme dmesg et kmod est nécessaire pour ces tâches sous Linux, kmon vise à les rassembler dans une seule fenêtre de terminal et à faciliter au maximum l'utilisation tout en conservant les fonctionnalités.
kmon est écrit en Rust et utilise les bibliothèques Ratatui et termion pour son interface utilisateur textuelle.
kmon peut être installé depuis crates.io en utilisant Cargo si Rust est installé.``` cargo install kmon
La version minimale de Rust supportée (MSRV) est `1.74.1`.
### Arch Linux
**kmon** peut être installé depuis le [dépôt officiel](https://www.archlinux.org/packages/extra/x86_64/kmon/) d'Arch Linux.```
pacman -S kmon
Il existe également un paquet de développement sur l'AUR. Utilisez votre AUR helper préféré pour l'installer. Par exemple,``` paru -S kmon-git
### Nixpkgs
**kmon** peut être installé en utilisant le [Nix package manager](https://nixos.org/nix/) depuis le canal `nixpkgs-unstable`.```
nix-channel --add https://nixos.org/channels/nixpkgs-unstable
nix-channel --update nixpkgs
nix-env -iA nixpkgs.kmon
Sur NixOS:``` nix-channel --add https://nixos.org/channels/nixos-unstable nix-channel --update nixos nix-env -iA nixos.kmon
### Alpine Linux
**kmon** est disponible pour [Alpine Edge](https://pkgs.alpinelinux.org/packages?name=kmon&branch=edge). Il peut être installé via [apk](https://wiki.alpinelinux.org/wiki/Alpine_Package_Keeper) après avoir activé le [dépôt communautaire](https://wiki.alpinelinux.org/wiki/Repositories).```
apk add kmon
#### Construction```
docker build -t kmon .
docker run -it --cap-add syslog kmon
### Manuel
1. Téléchargez le dernier binaire depuis la section [releases](https://github.com/orhun/kmon/releases) et choisissez entre le binaire [glibc](https://en.wikipedia.org/wiki/Glibc) ou [musl-libc](https://musl.libc.org/).
2. Pour télécharger le paquet compilé avec [glibc](https://en.wikipedia.org/wiki/Glibc) exécutez :```
wget https://github.com/orhun/kmon/releases/download/v[VERSION]/kmon-[VERSION]-x86_64-unknown-linux-gnu.tar.gz
3. Extrayez les fichiers.```
tar -xvzf kmon-*.tar.gz
5. Exécutez le binaire.```
./kmon
Déplacez le binaire vers /usr/local/bin/ pour l'exécuter depuis le terminal avec la commande kmon.
La page de manuel et les complétions shell sont générées lors de la compilation dans le répertoire target.
libxcb doit être installé pour utiliser les commandes copier/coller de X11.
ex : Installez le paquet libxcb1-dev pour Debian/Ubuntu* et le paquet libxcb-devel pour Fedora/openSUSE/Void Linux.
kmon [OPTIONS] [COMMAND]
### Options```
-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
#### Tri```
kmon sort [OPTIONS]
Options:``` -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
## Raccourcis clavier
| | |
| ----------------------- | ---------------------------------------------- |
| `[?], F1` | Aide |
| `right/left, h/l` | Basculer entre les blocs |
| `up/down, k/j, alt-k/j` | Défiler vers le haut/bas [bloc sélectionné] |
| `pgup/pgdown` | Défiler vers le haut/bas [activités noyau] |
| `</>` | Défiler vers le haut/bas [infos module] |
| `alt-h/l` | Défiler à droite/gauche [activités noyau] |
| `ctrl-t/b, home/end` | Aller en haut/bas [liste des modules] |
| `alt-e/s` | Agrandir/réduire le bloc sélectionné |
| `ctrl-x` | Changer la position du bloc |
| `ctrl-l/u, alt-c` | Effacer le tampon circulaire du noyau |
| `[d], alt-d` | Afficher les modules dépendants |
| `[1]..[9]` | Sauter au module dépendant |
| `[\], tab, backtab` | Afficher l'info noyau suivante |
| `[/], s, enter` | Chercher un module noyau |
| `[+], i, insert` | Charger un module noyau |
| `[-], u, backspace` | Décharger le module noyau |
| `[x], b, delete` | Mettre le module noyau sur liste noire |
| `ctrl-r, alt-r` | Recharger le module noyau |
| `m, o` | Afficher le menu d'options |
| `y/n` | Exécuter/annuler la commande |
| `c/v` | Copier/coller |
| `r, F5` | Actualiser |
| `q, ctrl-c/d, ESC` | Quitter |
## Fonctionnalités
### Aide
Appuyez sur '`?`' pendant l'utilisation de l'interface utilisateur pour voir les raccourcis clavier.
### Navigation et défilement
Les `touches fléchées` sont utilisées pour naviguer entre les blocs et défiler.
#### Défilement des activités du noyau
Certains messages du noyau peuvent être trop longs pour tenir dans le bloc des activités du noyau car ils ne sont pas coupés. Dans ce cas, les activités du noyau peuvent être défilées horizontalement avec les touches `alt-h & alt-l`. Le mécanisme de défilement vertical est le même que pour les autres blocs.
#### Défilement fluide
Les touches `alt-j & alt-k` peuvent être utilisées pour faire défiler lentement le bloc des activités du noyau et les informations du module.
### Menu d'options
Les touches `m` et `o` peuvent être utilisées comme raccourci pour les opérations de gestion du noyau. Lorsqu'elles sont pressées, un menu d'options s'affiche pour gérer le module noyau actuellement sélectionné.
### Tailles des blocs
Les touches `alt-e & alt-s` peuvent être utilisées pour agrandir/réduire le bloc sélectionné.
### Positions des blocs
La touche `ctrl-x` peut être utilisée pour changer les positions des blocs.
### Informations sur le noyau
Utilisez l'une des touches `\, tab, backtab` pour basculer entre les informations de version, de version et de plateforme du noyau.
### Informations sur le module
L'état d'un module noyau est affiché lors de la sélection.
#### Affichage des modules dépendants
Utilisez l'une des touches `d, alt-d` pour afficher tous les modules dépendants du module sélectionné.
#### Sauter aux modules dépendants
Pour sauter à un module noyau dépendant depuis son module parent, les `touches numériques` (1-9) peuvent être utilisées pour spécifier l'index du module dans la colonne _Utilisé par_.
### Recherche d'un module
Basculez vers la zone de recherche avec les touches fléchées ou en utilisant l'une des touches `/, s, entrée` et fournissez une requête de recherche pour le nom du module.
### Chargement d'un module
Pour ajouter un module au noyau Linux, basculez en mode chargement avec l'une des touches `+, i, insertion` et fournissez le nom du module à charger. Ensuite, confirmez/annulez l'exécution de la commande de chargement avec `y/n`.
La commande utilisée pour charger un module :```
modprobe <module_name> || insmod <module_name>.ko
Utilisez l'une des touches -, u, backspace pour supprimer le module sélectionné du noyau Linux.
The command that used for removing a module:``` modprobe -r <module_name> || rmmod <module_name>
### Mise sur liste noire d'un module
La [mise sur liste noire](https://wiki.archlinux.org/index.php/Kernel_module#Blacklisting) est un mécanisme pour empêcher le chargement du module du noyau. Pour mettre sur liste noire le module sélectionné, utilisez l'une des touches `x, b, delete` et confirmez l'exécution.
La commande utilisée pour mettre sur liste noire un module :```
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
Utilisez les touches ctrl-r ou alt-r pour recharger le module sélectionné.
La commande utilisée pour recharger un module :``` modprobe -r <module_name> || rmmod <module_name> && modprobe <module_name> || insmod <module_name>.ko
### Effacement du tampon circulaire
Le tampon circulaire du noyau peut être effacé en utilisant l'une des touches `ctrl-l/u, alt-c`.
```
dmesg --clear
Les touches c/v sont définies pour les opérations de copier/coller.
Utilisez ctrl-c/ctrl-v pour copier et coller en mode saisie.
La sous-commande sort peut être utilisée pour trier les modules du noyau par leur nom, taille ou modules dépendants.```
kmon sort --name
kmon sort --size
kmon sort --dependent
De plus, le flag `-r, --reverse` est utilisé pour inverser la liste des modules du noyau.```
kmon --reverse
kmon utilise les couleurs du terminal par défaut, mais la couleur de surbrillance peut être spécifiée avec l'option -c, --color. Alternativement, la couleur du texte par défaut peut être définie via l'option -a, --accent-color.
Les couleurs de terminal prises en charge sont black, red, green, yellow, blue, magenta, cyan, gray, darkgray, lightred, lightgreen, lightyellow, lightblue, lightmagenta, lightcyan, white.```
kmon --color red
#### Utilisation d'une couleur personnalisée
Fournissez une valeur hexadécimale pour la couleur à utiliser.```
kmon --color 19683a
La couleur de texte par défaut peut causer des problèmes de lisibilité sur certains thèmes transparents. L'option -a, --accent-color peut être utilisée de la même manière que l'option -c, --color pour résoudre ce problème.```
kmon --color 6f849c --accent-color e35760
### Symboles Unicode
Utilisez le drapeau `-u, --unicode` pour afficher les symboles Unicode dans les titres des blocs.```
kmon --unicode
L'option -t, --tickrate peut être utilisée pour définir l'intervalle de rafraîchissement de l'interface utilisateur du terminal en millisecondes.
L'option -E, --regex peut être utilisée pour rechercher des modules par expression régulière.
kmon vise à devenir un outil standard pour la gestion du noyau Linux tout en prenant en charge la plupart des distributions Linux.
Pour atteindre cet objectif, kmon doit être accessible depuis différents gestionnaires de paquets tels que Snap* et RPM.
Il est nécessaire d'avoir les outils essentiels comme dmesg et kmod sur le système pour que kmon fonctionne correctement. Ainsi, la prochaine étape consisterait à utiliser uniquement les ressources système pour ces fonctions.
Les actions de gestion concernant le noyau Linux devraient être applicables dans kmon afin de minimiser la dépendance envers la ligne de commande et d'autres outils.
kmon devrait être testé et rapporté sur différentes architectures pour un développement et un support ultérieurs.
| Fedora 31 | Debian 10 | Manjaro 19 |
|---|---|---|
 |  |  |
| Ubuntu 18.04 | openSUSE | Void Linux |
|---|---|---|
 |  |  |
Soutenez le développement de mes projets en me soutenant sur GitHub Sponsors.
Soutenez les efforts de développement open source en devenant contributeur ou sponsor.
GNU General Public License (3.0)
Copyright © 2020-2024, Orhun Parmaksız
