orhun/kmonGestore del kernel Linux e Monitor delle attività 🐧💻
Linux Kernel Manager e Activity Monitor 🐧💻
Il kernel è la parte del sistema operativo che facilita le interazioni tra i componenti hardware e software. Sulla maggior parte dei sistemi, viene caricato all'avvio dopo il bootloader e gestisce le richieste I/O così come le periferiche come tastiere, monitor, schede di rete e altoparlanti. Tipicamente, il kernel è responsabile della gestione della memoria, gestione dei processi, gestione dei dispositivi, chiamate di sistema e sicurezza.
Le applicazioni utilizzano il meccanismo di chiamata di sistema per richiedere un servizio al sistema operativo e, il più delle volte, questa richiesta viene passata al kernel utilizzando una libreria fornita dal sistema operativo per invocare la relativa funzione del kernel. Mentre il kernel esegue queste attività di basso livello, risiede in una parte separata della memoria chiamata spazio del kernel protetto, che non è accessibile dalle applicazioni e da altre parti del sistema. Al contrario, applicazioni come browser, editor di testo, window manager o lettori audio/video utilizzano un'area diversa e separata della memoria, lo spazio utente. Questa separazione impedisce che i dati utente e i dati del kernel interferiscano tra loro, causando instabilità e rallentamenti, e impedisce inoltre che programmi applicativi malfunzionanti facciano crashare l'intero sistema operativo.
Esistono diversi progetti di kernel a causa dei diversi modi di gestire le chiamate di sistema e le risorse. Ad esempio, mentre i kernel monolitici eseguono tutte le istruzioni del sistema operativo nello stesso spazio di indirizzi per velocità, i microkernel utilizzano spazi diversi per i servizi utente e del kernel per modularità. Oltre a questi, esistono kernel ibridi, nanokernel ed esokernel. L'architettura del kernel ibrido si basa sulla combinazione di aspetti del microkernel e dei kernel monolitici.
Il kernel Linux è il kernel open source, monolitico e simile a Unix utilizzato nelle distribuzioni Linux, in vari sistemi embedded come router e in tutti i sistemi basati su Android. Linus Torvalds ha concepito e creato il kernel Linux nel 1991, ed è ancora sviluppato da migliaia di sviluppatori oggi. È un esempio prominente di software libero e open source ed è utilizzato in altri progetti software libero, in particolare il sistema operativo GNU. Sebbene i sistemi operativi basati su Linux dominino la maggior parte dell'informatica, portano ancora alcuni difetti di progettazione che furono oggetto di un acceso dibattito nei primi giorni di Linux. Ad esempio, ha la maggiore impronta e la maggiore complessità rispetto ad altri tipi di kernel. Ma è una caratteristica di progettazione inerente ai kernel monolitici. Questi tipi di problemi di progettazione hanno portato gli sviluppatori ad aggiungere nuove funzionalità e meccanismi al kernel Linux che altri kernel non hanno.
A differenza dei kernel monolitici standard, il kernel Linux è anche modulare, accettando moduli del kernel caricabili (LKM) che vengono tipicamente utilizzati per aggiungere supporto per nuovo hardware (come driver di dispositivo) e/o filesystem, o per aggiungere chiamate di sistema. Poiché gli LKM possono essere caricati e scaricati dal sistema in esecuzione, hanno il vantaggio di estendere il kernel senza riavviare e ricompilare. Pertanto, le funzionalità del kernel fornite dai moduli non risiedono in memoria senza essere utilizzate e il modulo correlato può essere scaricato per liberare memoria e altre risorse.
I moduli del kernel caricabili si trovano in /lib/modules con estensione .ko (kernel object) in Linux. Mentre il comando lsmod può essere utilizzato per elencare i moduli del kernel caricati, modprobe o insmod/rmmod viene utilizzato per caricare o scaricare un modulo del kernel. insmod/rmmod vengono utilizzati per moduli indipendenti da modprobe e senza richiedere un'installazione in /lib/modules/$(uname -r).
Ecco un semplice esempio di un modulo del kernel Linux che stampa un messaggio quando viene caricato e scaricato. Di seguito sono mostrati i passaggi di compilazione e installazione del modulo utilizzando un Makefile.``` make # build sudo make install # install sudo modprobe lkm_example # load sudo modprobe -r lkm_example # unload
Il comando [dmesg](https://linux.die.net/man/8/dmesg) viene utilizzato di seguito per recuperare il buffer dei messaggi del kernel.```
[16994.295552] [+] Example kernel module loaded.
[16996.325674] [-] Example kernel module unloaded.
kmon fornisce un'interfaccia utente testuale per gestire i moduli del kernel Linux e monitorare le attività del kernel. Per gestione si intende caricamento, rimozione, inserimento in lista nera e visualizzazione delle informazioni di un modulo. Questi aggiornamenti dei moduli del kernel, i log relativi all'hardware e altri messaggi del kernel possono essere monitorati con il monitor delle attività in tempo reale di kmon. Poiché in Linux per queste operazioni è necessario l'uso di diversi strumenti come dmesg e kmod, kmon mira a raccoglierli in un'unica finestra del terminale e a facilitarne l'utilizzo il più possibile, mantenendo al contempo la funzionalità.
kmon è scritto in Rust e utilizza le librerie Ratatui e termion per la sua interfaccia utente testuale.
kmon può essere installato da crates.io usando Cargo se Rust è installato.``` cargo install kmon
La versione minima supportata di Rust (MSRV) è `1.74.1`.
### Arch Linux
**kmon** può essere installato dal [repository ufficiale](https://www.archlinux.org/packages/extra/x86_64/kmon/) di Arch Linux.```
pacman -S kmon
C'è anche un pacchetto di sviluppo su AUR. Usa il tuo AUR helper preferito per installare. Per esempio,``` paru -S kmon-git
### Nixpkgs
**kmon** può essere installato utilizzando [Nix package manager](https://nixos.org/nix/) dal canale `nixpkgs-unstable`.```
nix-channel --add https://nixos.org/channels/nixpkgs-unstable
nix-channel --update nixpkgs
nix-env -iA nixpkgs.kmon
Su NixOS:``` nix-channel --add https://nixos.org/channels/nixos-unstable nix-channel --update nixos nix-env -iA nixos.kmon
### Alpine Linux
**kmon** è disponibile per [Alpine Edge](https://pkgs.alpinelinux.org/packages?name=kmon&branch=edge). Può essere installato tramite [apk](https://wiki.alpinelinux.org/wiki/Alpine_Package_Keeper) dopo aver abilitato il [repository community](https://wiki.alpinelinux.org/wiki/Repositories).```
apk add kmon
#### Compilazione```
docker build -t kmon .
docker run -it --cap-add syslog kmon
### Manuale
1. Scarica l'ultimo binario dalla sezione [rilasci](https://github.com/orhun/kmon/releases) e scegli tra il binario [glibc](https://en.wikipedia.org/wiki/Glibc) o [musl-libc](https://musl.libc.org/).
2. Per scaricare il pacchetto compilato con [glibc](https://en.wikipedia.org/wiki/Glibc) esegui:```
wget https://github.com/orhun/kmon/releases/download/v[VERSION]/kmon-[VERSION]-x86_64-unknown-linux-gnu.tar.gz
3. Estrai i file.```
tar -xvzf kmon-*.tar.gz
5. Eseguire il binario.```
./kmon
Sposta il binario in /usr/local/bin/ per eseguirlo dal terminale usando il comando kmon.
La pagina man e i completamenti della shell vengono generati in fase di compilazione nella directory target.
libxcb deve essere installato per utilizzare i comandi di copia/incolla di X11.
Ad es.: Installa il pacchetto libxcb1-dev per Debian/Ubuntu* e il pacchetto libxcb-devel per Fedora/openSUSE/Void Linux.
kmon [OPTIONS] [COMMAND]
### Opzioni```
-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
#### Ordina```
kmon sort [OPTIONS]
Opzioni:``` -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
## Combinazioni di tasti
| | |
| ----------------------- | ------------------------------------- |
| `[?], F1` | Aiuto |
| `right/left, h/l` | Cambia tra i blocchi |
| `up/down, k/j, alt-k/j` | Scorri su/giù [blocco selezionato] |
| `pgup/pgdown` | Scorri su/giù [attività del kernel] |
| `</>` | Scorri su/giù [informazioni modulo] |
| `alt-h/l` | Scorri destra/sinistra [attività del kernel] |
| `ctrl-t/b, home/end` | Vai all'inizio/fine [elenco moduli] |
| `alt-e/s` | Espandi/restringi il blocco selezionato |
| `ctrl-x` | Cambia la posizione del blocco |
| `ctrl-l/u, alt-c` | Pulisci il ring buffer del kernel |
| `[d], alt-d` | Mostra i moduli dipendenti |
| `[1]..[9]` | Salta al modulo dipendente |
| `[\], tab, backtab` | Mostra la successiva informazione del kernel |
| `[/], s, enter` | Cerca un modulo del kernel |
| `[+], i, insert` | Carica un modulo del kernel |
| `[-], u, backspace` | Scarica il modulo del kernel |
| `[x], b, delete` | Blacklist del modulo del kernel |
| `ctrl-r, alt-r` | Ricarica il modulo del kernel |
| `m, o` | Mostra il menu delle opzioni |
| `y/n` | Esegui/annulla il comando |
| `c/v` | Copia/incolla |
| `r, F5` | Aggiorna |
| `q, ctrl-c/d, ESC` | Esci |
## Funzionalità
### Aiuto
Premi '`?`' durante l'esecuzione dell'interfaccia utente terminale per vedere le combinazioni di tasti.
### Navigazione e scorrimento
I `tasti freccia` sono usati per navigare tra i blocchi e per scorrere.
#### Scorrimento attività del kernel
Alcuni messaggi del kernel potrebbero essere troppo lunghi per entrare nel blocco delle attività del kernel, poiché non sono mandati a capo. In questa situazione, le attività del kernel possono essere scorse orizzontalmente con i tasti `alt-h & alt-l`. Il meccanismo di scorrimento verticale è lo stesso degli altri blocchi.
#### Scorrimento fluido
I tasti `alt-j & alt-k` possono essere usati per scorrere lentamente i blocchi delle attività del kernel e delle informazioni sul modulo.
### Menu delle opzioni
I tasti `m` e `o` possono essere usati come scorciatoia per le operazioni di gestione del kernel. Quando premuti, verrà fornito un menu di opzioni per gestire il modulo del kernel attualmente selezionato.
### Dimensioni dei blocchi
I tasti `alt-e & alt-s` possono essere usati per espandere/restringere il blocco selezionato.
### Posizioni dei blocchi
Il tasto `ctrl-x` può essere usato per cambiare le posizioni dei blocchi.
### Informazioni sul kernel
Usa uno dei tasti `\, tab, backtab` per passare tra le informazioni su release, versione e piattaforma del kernel.
### Informazioni sul modulo
Lo stato di un modulo del kernel viene mostrato al momento della selezione.
#### Visualizzazione dei moduli dipendenti
Usa uno dei tasti `d, alt-d` per mostrare tutti i moduli dipendenti del modulo selezionato.
#### Salto ai moduli dipendenti
Per saltare a un modulo del kernel dipendente dal suo modulo padre, i `tasti numerici` (1-9) possono essere usati per specificare l'indice del modulo nella colonna _Usato da_.
### Ricerca di un modulo
Passa all'area di ricerca con i tasti freccia o usando uno dei tasti `/, s, enter` e fornisci una query di ricerca per il nome del modulo.
### Caricamento di un modulo
Per aggiungere un modulo al kernel Linux, passa alla modalità di caricamento con uno dei tasti `+, i, insert` e fornisci il nome del modulo da caricare. Quindi conferma/annulla l'esecuzione del comando di caricamento con `y/n`.
Il comando utilizzato per caricare un modulo:```
modprobe <module_name> || insmod <module_name>.ko
Usa uno dei tasti -, u, backspace per rimuovere il modulo selezionato dal kernel Linux.
Il comando utilizzato per rimuovere un modulo:``` modprobe -r <module_name> || rmmod <module_name>
### Blacklisting di un modulo
Il [blacklisting](https://wiki.archlinux.org/index.php/Kernel_module#Blacklisting) è un meccanismo per impedire il caricamento del modulo del kernel. Per disabilitare il modulo selezionato, usa uno dei tasti `x, b, delete` e conferma l'esecuzione.
Il comando utilizzato per disabilitare un modulo:```
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
Usa il tasto ctrl-r o alt-r per ricaricare il modulo selezionato.
Il comando utilizzato per ricaricare un modulo:``` modprobe -r <module_name> || rmmod <module_name> && modprobe <module_name> || insmod <module_name>.ko
### Cancellazione del buffer circolare
Il buffer circolare del kernel può essere cancellato usando uno dei tasti `ctrl-l/u, alt-c`.
```
dmesg --clear
I tasti c/v sono impostati per le operazioni di copia/incolla.
Usa ctrl-c/ctrl-v per copiare e incollare mentre sei in modalità input.
Il sottocomando sort può essere utilizzato per ordinare i moduli del kernel per nome, dimensione o moduli dipendenti.```
kmon sort --name
kmon sort --size
kmon sort --dependent
Inoltre il flag `-r, --reverse` viene utilizzato per invertire l'elenco dei moduli del kernel.```
kmon --reverse
kmon utilizza i colori del terminale come predefiniti, ma il colore di evidenziazione può essere specificato con l'opzione -c, --color. In alternativa, il colore del testo predefinito può essere impostato tramite l'opzione -a, --accent-color.
I colori del terminale supportati sono black, red, green, yellow, blue, magenta, cyan, gray, darkgray, lightred, lightgreen, lightyellow, lightblue, lightmagenta, lightcyan, white.```
kmon --color red
#### Utilizzo di un colore personalizzato
Fornisci un valore esadecimale per il colore da utilizzare.```
kmon --color 19683a
Il colore del testo predefinito potrebbe causare problemi di leggibilità su alcuni temi che hanno trasparenza. L'opzione -a, --accent-color può essere utilizzata in modo simile all'opzione -c, --color per risolvere questo problema.```
kmon --color 6f849c --accent-color e35760
### Simboli Unicode
Usa il flag `-u, --unicode` per mostrare i simboli Unicode per i titoli dei blocchi.```
kmon --unicode
-t, --tickrate L'opzione può essere utilizzata per impostare l'intervallo di aggiornamento dell'interfaccia utente del terminale in millisecondi.
-E, --regex L'opzione può essere utilizzata per cercare moduli tramite espressione regolare.
kmon mira a diventare uno strumento standard per la gestione del kernel Linux, supportando la maggior parte delle distribuzioni Linux.
Per raggiungere questo obiettivo, kmon dovrebbe essere accessibile da diversi gestori di pacchetti come Snap* e RPM.
È necessario che nel sistema siano presenti strumenti essenziali come dmesg e kmod affinché kmon funzioni correttamente. Il passo successivo sarebbe quindi utilizzare solo le risorse di sistema per queste funzioni.
Le azioni di gestione del kernel Linux dovrebbero essere applicabili in kmon per minimizzare la dipendenza dalla riga di comando e da altri strumenti.
kmon dovrebbe essere testato e segnalato su diverse architetture per ulteriori sviluppi e supporto.
| Fedora 31 | Debian 10 | Manjaro 19 |
|---|---|---|
 |  |  |
| Ubuntu 18.04 | openSUSE | Void Linux |
|---|---|---|
 |  |  |
Sostieni lo sviluppo dei miei progetti supportandomi su GitHub Sponsors.
Sostieni gli sforzi di sviluppo open source diventando un sostenitore o uno sponsor.
GNU General Public License (3.0)
Copyright © 2020-2024, Orhun Parmaksız
