orhun/kmonAdministrador del kernel de Linux y monitor de actividad 🐧💻
Administrador del Kernel de Linux y Monitor de Actividad 🐧💻
El kernel es la parte del sistema operativo que facilita las interacciones entre los componentes de hardware y software. En la mayoría de los sistemas, se carga al inicio después del cargador de arranque y maneja las solicitudes de E/S, así como los periféricos como teclados, monitores, adaptadores de red y altavoces. Normalmente, el kernel es responsable de la gestión de memoria, gestión de procesos, gestión de dispositivos, llamadas al sistema y seguridad.
Las aplicaciones utilizan el mecanismo de llamada al sistema para solicitar un servicio al sistema operativo y, la mayoría de las veces, esta solicitud se pasa al kernel mediante una biblioteca proporcionada por el sistema operativo para invocar la función del kernel correspondiente. Mientras el kernel realiza estas tareas de bajo nivel, reside en una parte separada de la memoria llamada espacio protegido del kernel al que las aplicaciones y otras partes del sistema no pueden acceder. Por el contrario, aplicaciones como navegadores, editores de texto, gestores de ventanas o reproductores de audio/vídeo utilizan un área separada diferente de la memoria, el espacio de usuario. Esta separación evita que los datos del usuario y del kernel interfieran entre sí causando inestabilidad y lentitud, así como evita que los programas de aplicación defectuosos paralicen todo el sistema operativo.
Existen diferentes diseños de kernel debido a las diferentes formas de gestionar las llamadas al sistema y los recursos. Por ejemplo, mientras que los núcleos monolíticos ejecutan todas las instrucciones del sistema operativo en el mismo espacio de direcciones por velocidad, los micronúcleos utilizan espacios diferentes para los servicios de usuario y kernel por modularidad. Además de estos, existen núcleos híbridos, nanonúcleos y exonúcleos. La arquitectura de núcleo híbrido se basa en combinar aspectos de los micronúcleos y los núcleos monolíticos.
El kernel de Linux es el kernel de sistema operativo de código abierto, monolítico y tipo Unix que se utiliza en las distribuciones de Linux, varios sistemas embebidos como enrutadores, así como en todos los sistemas basados en Android. Linus Torvalds concibió y creó el kernel de Linux en 1991 y todavía hoy lo desarrollan miles de desarrolladores. Es un ejemplo destacado de software libre y de código abierto y se utiliza en otros proyectos de software libre, notablemente el sistema operativo GNU. Aunque los sistemas operativos basados en Linux dominan la mayor parte de la informática, todavía presentan algunos de los defectos de diseño que fueron objeto de bastante debate en los primeros días de Linux. Por ejemplo, tiene la mayor huella y la mayor complejidad sobre los otros tipos de núcleos. Pero es una característica de diseño inherente a los núcleos monolíticos. Este tipo de problemas de diseño llevaron a los desarrolladores a agregar nuevas características y mecanismos al kernel de Linux que otros núcleos no tienen.
A diferencia de los núcleos monolíticos estándar, el kernel de Linux también es modular, aceptando módulos de kernel cargables (LKM) que normalmente se utilizan para agregar soporte para nuevo hardware (como controladores de dispositivo) y/o sistemas de archivos, o para agregar llamadas al sistema. Dado que los LKM se pueden cargar y descargar del sistema en tiempo de ejecución, tienen la ventaja de extender el kernel sin necesidad de reiniciar y recompilar. Por lo tanto, las funcionalidades del kernel proporcionadas por los módulos no residirían en la memoria sin ser utilizadas y el módulo correspondiente se puede descargar para liberar memoria y otros recursos.
Los módulos de kernel cargables se encuentran en /lib/modules con la extensión .ko (kernel object) en Linux. Mientras que el comando lsmod se puede utilizar para listar los módulos del kernel cargados, modprobe o insmod/rmmod se utiliza para cargar o descargar un módulo del kernel. insmod/rmmod se utilizan para módulos independientes de modprobe y sin necesidad de instalación en /lib/modules/$(uname -r).
A continuación se muestra un ejemplo simple de un módulo del kernel de Linux que imprime un mensaje cuando se carga y se descarga. Los pasos de compilación e instalación del módulo usando un Makefile se muestran a continuación.``` make # build sudo make install # install sudo modprobe lkm_example # load sudo modprobe -r lkm_example # unload
El comando [dmesg](https://linux.die.net/man/8/dmesg) se utiliza a continuación para recuperar el búfer de mensajes del kernel.```
[16994.295552] [+] Example kernel module loaded.
[16996.325674] [-] Example kernel module unloaded.
kmon proporciona una interfaz de usuario basada en texto para gestionar los módulos del kernel de Linux y monitorear las actividades del kernel. Gestionar significa cargar, descargar, incluir en la lista negra y mostrar la información de un módulo. Estas actualizaciones en los módulos del kernel, registros sobre el hardware y otros mensajes del kernel se pueden rastrear con el monitor de actividad en tiempo real de kmon. Dado que para estas tareas en Linux se requiere el uso de diferentes herramientas como dmesg y kmod, kmon tiene como objetivo reunirlas en una sola ventana de terminal y facilitar el uso tanto como sea posible sin perder funcionalidad.
kmon está escrito en Rust y utiliza las bibliotecas Ratatui y termion para su interfaz de usuario basada en texto.
kmon se puede instalar desde crates.io usando Cargo si Rust está instalado.``` cargo install kmon
La versión mínima de Rust soportada (MSRV) es `1.74.1`.
### Arch Linux
**kmon** se puede instalar desde el [repositorio oficial](https://www.archlinux.org/packages/extra/x86_64/kmon/) de Arch Linux.```
pacman -S kmon
También hay un paquete de desarrollo en el AUR. Usa tu ayudante de AUR favorito para instalarlo. Por ejemplo,``` paru -S kmon-git
### Nixpkgs
**kmon** se puede instalar utilizando el [gestor de paquetes Nix](https://nixos.org/nix/) desde el canal `nixpkgs-unstable`.```
nix-channel --add https://nixos.org/channels/nixpkgs-unstable
nix-channel --update nixpkgs
nix-env -iA nixpkgs.kmon
En NixOS:``` nix-channel --add https://nixos.org/channels/nixos-unstable nix-channel --update nixos nix-env -iA nixos.kmon
### Alpine Linux
**kmon** está disponible para [Alpine Edge](https://pkgs.alpinelinux.org/packages?name=kmon&branch=edge). Se puede instalar mediante [apk](https://wiki.alpinelinux.org/wiki/Alpine_Package_Keeper) después de habilitar el [repositorio comunitario](https://wiki.alpinelinux.org/wiki/Repositories).```
apk add kmon
#### Compilación```
docker build -t kmon .
docker run -it --cap-add syslog kmon
### Manual
1. Descarga el último binario de la sección [releases](https://github.com/orhun/kmon/releases) y elige entre el binario de [glibc](https://en.wikipedia.org/wiki/Glibc) o [musl-libc](https://musl.libc.org/).
2. Para descargar el paquete compilado con [glibc](https://en.wikipedia.org/wiki/Glibc) ejecuta:```
wget https://github.com/orhun/kmon/releases/download/v[VERSION]/kmon-[VERSION]-x86_64-unknown-linux-gnu.tar.gz
3. Extrae los archivos.```
tar -xvzf kmon-*.tar.gz
5. Ejecuta el binario.```
./kmon
Mueve el binario a /usr/local/bin/ para ejecutarlo desde la terminal usando el comando kmon.
La página de manual y las completaciones de shell se generan durante la compilación en el directorio target.
libxcb debe estar instalado para usar los comandos de copiar/pegar de X11.
p. ej.: Instala el paquete libxcb1-dev para Debian/Ubuntu* y el paquete libxcb-devel para Fedora/openSUSE/Void Linux.
kmon [OPTIONS] [COMMAND]
### Opciones```
-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
#### Ordenar```
kmon sort [OPTIONS]
Opciones:``` -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
## Atajos de Teclado
| | |
| ----------------------- | ------------------------------------- |
| `[?], F1` | Ayuda |
| `right/left, h/l` | Cambiar entre bloques |
| `up/down, k/j, alt-k/j` | Desplazar arriba/abajo [bloque seleccionado] |
| `pgup/pgdown` | Desplazar arriba/abajo [actividades del núcleo] |
| `</>` | Desplazar arriba/abajo [información del módulo] |
| `alt-h/l` | Desplazar derecha/izquierda [actividades del núcleo] |
| `ctrl-t/b, home/end` | Desplazar al inicio/fin [lista de módulos] |
| `alt-e/s` | Expandir/contraer el bloque seleccionado |
| `ctrl-x` | Cambiar la posición del bloque |
| `ctrl-l/u, alt-c` | Limpiar el buffer del anillo del núcleo |
| `[d], alt-d` | Mostrar los módulos dependientes |
| `[1]..[9]` | Saltar al módulo dependiente |
| `[\], tab, backtab` | Mostrar la siguiente información del núcleo |
| `[/], s, enter` | Buscar un módulo del núcleo |
| `[+], i, insert` | Cargar un módulo del núcleo |
| `[-], u, backspace` | Descargar el módulo del núcleo |
| `[x], b, delete` | Bloquear el módulo del núcleo |
| `ctrl-r, alt-r` | Recargar el módulo del núcleo |
| `m, o` | Mostrar el menú de opciones |
| `y/n` | Ejecutar/cancelar el comando |
| `c/v` | Copiar/pegar |
| `r, F5` | Refrescar |
| `q, ctrl-c/d, ESC` | Salir |
## Funcionalidades
### Ayuda
Presiona '`?`' mientras se ejecuta la interfaz de usuario de terminal para ver los atajos de teclado.
### Navegación y Desplazamiento
Las `teclas de flecha` se utilizan para navegar entre bloques y desplazarse.
#### Desplazamiento de Actividades del Núcleo
Algunos mensajes del núcleo pueden ser lo suficientemente largos como para no caber en el bloque de actividades del núcleo, ya que no se ajustan. En esta situación, las actividades del núcleo se pueden desplazar horizontalmente con las teclas `alt-h y alt-l`. El mecanismo de desplazamiento vertical es el mismo que en otros bloques.
#### Desplazamiento Suave
Las teclas `alt-j y alt-k` se pueden usar para desplazar lentamente el bloque de actividad del núcleo y de información del módulo.
### Menú de Opciones
Las teclas `m` y `o` se pueden usar como atajo para las operaciones de gestión del núcleo. Al presionarlas, se mostrará un menú de opciones para gestionar el módulo del núcleo actualmente seleccionado.
### Tamaños de Bloques
Las teclas `alt-e y alt-s` se pueden usar para expandir/contraer el bloque seleccionado.
### Posiciones de Bloques
La tecla `ctrl-x` se puede usar para cambiar las posiciones de los bloques.
### Información del Núcleo
Usa una de las teclas `\, tab, backtab` para alternar entre la versión del núcleo, la versión de lanzamiento y la información de la plataforma.
### Información del Módulo
El estado de un módulo del núcleo se muestra al seleccionarlo.
#### Mostrar los Módulos Dependientes
Usa una de las teclas `d, alt-d` para mostrar todos los módulos dependientes del módulo seleccionado.
#### Saltar a Módulos Dependientes
Para saltar a un módulo del núcleo dependiente desde su módulo padre, las `teclas numéricas` (1-9) se pueden usar para especificar el índice del módulo en la columna _Usado por_.
### Buscar un Módulo
Cambia al área de búsqueda con las teclas de flecha o usando una de `/, s, enter` y proporciona una consulta de búsqueda para el nombre del módulo.
### Cargar un Módulo
Para agregar un módulo al núcleo de Linux, cambia al modo de carga con una de las teclas `+, i, insert` y proporciona el nombre del módulo a cargar. Luego confirma/cancela la ejecución del comando de carga con `y/n`.
El comando utilizado para cargar un módulo:```
modprobe <module_name> || insmod <module_name>.ko
Use una de las teclas -, u, backspace para eliminar el módulo seleccionado del kernel de Linux.
El comando utilizado para eliminar un módulo:``` modprobe -r <module_name> || rmmod <module_name>
### Bloqueando un módulo
El [bloqueo](https://wiki.archlinux.org/index.php/Kernel_module#Blacklisting) es un mecanismo para evitar que el módulo del kernel se cargue. Para bloquear el módulo seleccionado, usa una de las teclas `x, b, delete` y confirma la ejecución.
El comando utilizado para bloquear un módulo:```
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 la tecla ctrl-r o alt-r para recargar el módulo seleccionado.
El comando que se usa para recargar un módulo:``` modprobe -r <module_name> || rmmod <module_name> && modprobe <module_name> || insmod <module_name>.ko
### Limpiando el búfer de anillo
El búfer de anillo del kernel se puede limpiar usando una de las teclas `ctrl-l/u, alt-c`.
```
dmesg --clear
Las teclas c/v están configuradas para operaciones de copiar y pegar.
Use ctrl-c/ctrl-v para copiar y pegar mientras está en modo de entrada.
El subcomando sort se puede usar para ordenar los módulos del kernel por sus nombres, tamaños o módulos dependientes.```
kmon sort --name
kmon sort --size
kmon sort --dependent
Además, la bandera `-r, --reverse` se utiliza para invertir la lista de módulos del kernel.```
kmon --reverse
kmon utiliza los colores del terminal por defecto, pero el color de resaltado se puede especificar con la opción -c, --color. Alternativamente, el color de texto predeterminado se puede establecer mediante la opción -a, --accent-color.
Los colores de terminal soportados son: black, red, green, yellow, blue, magenta, cyan, gray, darkgray, lightred, lightgreen, lightyellow, lightblue, lightmagenta, lightcyan, white.```
kmon --color red
#### Usando un color personalizado
Proporcione un valor hexadecimal para el color a utilizar.```
kmon --color 19683a
El color de texto predeterminado puede causar problemas de legibilidad en algunos temas que tienen transparencia. La opción -a, --accent-color puede usarse de manera similar a la opción -c, --color para superar este problema.```
kmon --color 6f849c --accent-color e35760
### Símbolos Unicode
Use la opción `-u, --unicode` para mostrar símbolos Unicode en los títulos de los bloques.```
kmon --unicode
-t, --tickrate opción se puede usar para establecer el intervalo de actualización de la interfaz del terminal en milisegundos.
-E, --regex opción se puede usar para buscar módulos mediante expresión regular.
kmon aspira a ser una herramienta estándar para la gestión del kernel de Linux, compatible con la mayoría de las distribuciones de Linux.
Para lograr este objetivo, kmon debería ser accesible desde diferentes gestores de paquetes como Snap* y RPM.
Es necesario tener las herramientas esenciales como dmesg y kmod en el sistema para que kmon funcione correctamente. Por lo tanto, el siguiente paso sería usar solo los recursos del sistema para estas funciones.
Las acciones de gestión del kernel de Linux deberían ser aplicables en kmon para minimizar la dependencia de la línea de comandos y otras herramientas.
kmon debería ser probado y reportado en diferentes arquitecturas para su posterior desarrollo y soporte.
| Fedora 31 | Debian 10 | Manjaro 19 |
|---|---|---|
 |  |  |
| Ubuntu 18.04 | openSUSE | Void Linux |
|---|---|---|
 |  |  |
Apoya el desarrollo de mis proyectos apoyándome en GitHub Sponsors.
Apoya los esfuerzos de desarrollo de código abierto convirtiéndote en un colaborador o patrocinador.
Licencia General Pública GNU (3.0)
Copyright © 2020-2024, Orhun Parmaksız
