orhun/kmonGerenciador do Kernel Linux e Monitor de Atividades 🐧💻
Gerenciador do Kernel Linux e Monitor de Atividades 🐧💻
O kernel é a parte do sistema operacional que facilita as interações entre componentes de hardware e software. Na maioria dos sistemas, ele é carregado na inicialização após o bootloader e lida com requisições de E/S, bem como periféricos como teclados, monitores, adaptadores de rede e alto-falantes. Tipicamente, o kernel é responsável por gerenciamento de memória, gerenciamento de processos, gerenciamento de dispositivos, chamadas de sistema e segurança. Aplicações usam o mecanismo de chamada de sistema para solicitar um serviço do sistema operacional e, na maioria das vezes, essa requisição é passada ao kernel usando uma biblioteca fornecida pelo sistema operacional para invocar a função do kernel relacionada. Enquanto o kernel executa essas tarefas de baixo nível, ele reside em uma parte separada da memória chamada espaço do kernel protegido, que não é acessível por aplicações ou outras partes do sistema. Em contraste, aplicações como navegadores, editores de texto, gerenciadores de janelas ou players de áudio/vídeo usam uma área separada diferente da memória, o espaço do usuário. Essa separação impede que dados do usuário e do kernel interfiram entre si, causando instabilidade e lentidão, além de evitar que programas aplicativos defeituosos derrubem todo o sistema operacional. Existem diferentes designs de kernel devido às diferentes formas de gerenciar chamadas de sistema e recursos. Por exemplo, enquanto kernels monolíticos executam todas as instruções do sistema operacional no mesmo espaço de endereço por velocidade, microkernels usam espaços diferentes para serviços de usuário e kernel por modularidade. Além desses, existem kernels híbridos, nanokernels e exokernels. A arquitetura de kernel híbrido baseia-se na combinação de aspectos de microkernel e kernels monolíticos.
O kernel Linux é o kernel de sistema operacional de código aberto, monolítico e do tipo Unix usado nas distribuições Linux, vários sistemas embarcados como roteadores e também em todos os sistemas baseados em Android. Linus Torvalds concebeu e criou o kernel Linux em 1991 e ainda hoje é desenvolvido por milhares de desenvolvedores. É um exemplo proeminente de software livre e de código aberto e é usado em outros projetos de software livre, notavelmente o sistema operacional GNU. Embora os sistemas operacionais baseados em Linux dominem a maior parte da computação, eles ainda carregam algumas das falhas de design que foram bastante debatidas nos primórdios do Linux. Por exemplo, ele tem a maior pegada e a maior complexidade em relação a outros tipos de kernel. Mas é uma característica de design que os kernels monolíticos têm inerentemente. Esse tipo de problema de design levou os desenvolvedores a adicionar novos recursos e mecanismos ao kernel Linux que outros kernels não possuem.
Ao contrário dos kernels monolíticos padrão, o kernel Linux também é modular, aceitando módulos de kernel carregáveis (LKMs) que são tipicamente usados para adicionar suporte a novos hardware (como drivers de dispositivo) e/ou sistemas de arquivos, ou para adicionar chamadas de sistema. Como os LKMs podem ser carregados e descarregados no sistema em tempo de execução, eles têm a vantagem de estender o kernel sem reinicializar e recompilar. Assim, as funcionalidades do kernel fornecidas por módulos não residem na memória sem serem usadas, e o módulo relacionado pode ser descarregado para liberar memória e outros recursos.
Os módulos de kernel carregáveis estão localizados em /lib/modules com a extensão .ko (kernel object) no Linux. Enquanto o comando lsmod pode ser usado para listar os módulos de kernel carregados, modprobe ou insmod/rmmod são usados para carregar ou descarregar um módulo de kernel. insmod/rmmod são usados para módulos independentes do modprobe e sem exigir uma instalação em /lib/modules/$(uname -r).
Aqui está um exemplo simples de um módulo de kernel Linux que imprime uma mensagem quando é carregado e descarregado. As etapas de construção e instalação do módulo usando um Makefile são mostradas abaixo.``` make # build sudo make install # install sudo modprobe lkm_example # load sudo modprobe -r lkm_example # unload
O comando [dmesg](https://linux.die.net/man/8/dmesg) é usado abaixo para recuperar o buffer de mensagens do kernel.```
[16994.295552] [+] Example kernel module loaded.
[16996.325674] [-] Example kernel module unloaded.
kmon fornece uma interface de usuário baseada em texto para gerenciar os módulos do kernel Linux e monitorar as atividades do kernel. Por gerenciar, entende-se carregar, descarregar, colocar na lista negra e mostrar as informações de um módulo. Essas atualizações nos módulos do kernel, logs sobre o hardware e outras mensagens do kernel podem ser rastreadas com o monitor de atividades em tempo real no kmon. Como o uso de diferentes ferramentas como dmesg e kmod é necessário para essas tarefas no Linux, o kmon visa reuni-las em uma única janela de terminal e facilitar o uso tanto quanto possível, mantendo a funcionalidade.
kmon é escrito em Rust e usa as bibliotecas Ratatui e termion para sua interface de usuário baseada em texto.
kmon pode ser instalado a partir do crates.io usando o Cargo se o Rust estiver instalado.``` cargo install kmon
The minimum supported Rust version (MSRV) is `1.74.1`.
### Arch Linux
**kmon** pode ser instalado a partir do [repositório oficial](https://www.archlinux.org/packages/extra/x86_64/kmon/) do Arch Linux.```
pacman -S kmon
Existe também um pacote de desenvolvimento no AUR. Use seu ajudante do AUR favorito para instalar. Por exemplo,``` paru -S kmon-git
### Nixpkgs
**kmon** pode ser instalado usando o [gerenciador de pacotes Nix](https://nixos.org/nix/) a partir do canal `nixpkgs-unstable`.```
nix-channel --add https://nixos.org/channels/nixpkgs-unstable
nix-channel --update nixpkgs
nix-env -iA nixpkgs.kmon
No NixOS:``` nix-channel --add https://nixos.org/channels/nixos-unstable nix-channel --update nixos nix-env -iA nixos.kmon
### Alpine Linux
**kmon** está disponível para [Alpine Edge](https://pkgs.alpinelinux.org/packages?name=kmon&branch=edge). Pode ser instalado via [apk](https://wiki.alpinelinux.org/wiki/Alpine_Package_Keeper) após ativar o [repositório comunitário](https://wiki.alpinelinux.org/wiki/Repositories).```
apk add kmon
#### Construção```
docker build -t kmon .
docker run -it --cap-add syslog kmon
### Manual
1. Descarregue o binário mais recente da secção [releases](https://github.com/orhun/kmon/releases) e escolha entre binário [glibc](https://en.wikipedia.org/wiki/Glibc) ou [musl-libc](https://musl.libc.org/).
2. Para descarregar o pacote compilado com [glibc](https://en.wikipedia.org/wiki/Glibc) execute:```
wget https://github.com/orhun/kmon/releases/download/v[VERSION]/kmon-[VERSION]-x86_64-unknown-linux-gnu.tar.gz
3. Extraia os ficheiros.```
tar -xvzf kmon-*.tar.gz
5. Execute o binário.```
./kmon
Mova o binário para /usr/local/bin/ para executá-lo no terminal usando o comando kmon.
A página de manual e as completações de shell são geradas no momento da compilação no diretório target.
libxcb deve ser instalado para usar os comandos de copiar/colar do X11.
ex.: Instale o pacote libxcb1-dev no Debian/Ubuntu* e o pacote libxcb-devel no Fedora/openSUSE/Void Linux.
kmon [OPTIONS] [COMMAND]
### Opções```
-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]
Opções:``` -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
## Key Bindings
| | |
| ----------------------- | ------------------------------------- |
| `[?], F1` | Ajuda |
| `right/left, h/l` | Alternar entre blocos |
| `up/down, k/j, alt-k/j` | Rolar para cima/baixo [bloco selecionado] |
| `pgup/pgdown` | Rolar para cima/baixo [atividades do kernel] |
| `</>` | Rolar para cima/baixo [informações do módulo] |
| `alt-h/l` | Rolar para direita/esquerda [atividades do kernel] |
| `ctrl-t/b, home/end` | Rolar para o topo/fim [lista de módulos] |
| `alt-e/s` | Expandir/reduzir o bloco selecionado |
| `ctrl-x` | Alterar a posição do bloco |
| `ctrl-l/u, alt-c` | Limpar o buffer circular do kernel |
| `[d], alt-d` | Mostrar os módulos dependentes |
| `[1]..[9]` | Ir para o módulo dependente |
| `[\], tab, backtab` | Mostrar a próxima informação do kernel |
| `[/], s, enter` | Pesquisar um módulo do kernel |
| `[+], i, insert` | Carregar um módulo do kernel |
| `[-], u, backspace` | Descarregar o módulo do kernel |
| `[x], b, delete` | Colocar na lista negra o módulo do kernel |
| `ctrl-r, alt-r` | Recarregar o módulo do kernel |
| `m, o` | Mostrar o menu de opções |
| `y/n` | Executar/cancelar o comando |
| `c/v` | Copiar/colar |
| `r, F5` | Atualizar |
| `q, ctrl-c/d, ESC` | Sair |
## Features
### Ajuda
Pressione '`?`' enquanto executa a interface de terminal para ver as teclas de atalho.
### Navegação e Rolagem
As `teclas de seta` são usadas para navegar entre blocos e rolar.
#### Rolagem de Atividades do Kernel
Algumas mensagens do kernel podem ser longas o suficiente para não caberem no bloco de atividades do kernel, pois não são quebradas. Nessa situação, as atividades do kernel podem ser roladas horizontalmente com as teclas `alt-h & alt-l`. O mecanismo de rolagem vertical é o mesmo que em outros blocos.
#### Rolagem Suave
As teclas `alt-j & alt-k` podem ser usadas para rolar lentamente os blocos de atividade do kernel e informações do módulo.
### Menu de Opções
As teclas `m` e `o` podem ser usadas como atalho para operações de gerenciamento do kernel. Quando pressionadas, um menu de opções será exibido para gerenciar o módulo do kernel atualmente selecionado.
### Tamanhos dos Blocos
As teclas `alt-e & alt-s` podem ser usadas para expandir/reduzir o bloco selecionado.
### Posições dos Blocos
A tecla `ctrl-x` pode ser usada para alterar as posições dos blocos.
### Informações do Kernel
Use uma das teclas `\, tab, backtab` para alternar entre as informações de release, versão e plataforma do kernel.
### Informações do Módulo
O status de um módulo do kernel é mostrado na seleção.
#### Exibindo os módulos dependentes
Use uma das teclas `d, alt-d` para mostrar todos os módulos dependentes do módulo selecionado.
#### Indo para módulos dependentes
Para ir para um módulo do kernel dependente a partir do módulo pai, as `teclas numéricas` (1-9) podem ser usadas para especificar o índice do módulo na coluna _Usado por_.
### Pesquisando um módulo
Alterne para a área de pesquisa com as teclas de seta ou usando uma das teclas `/, s, enter` e forneça uma consulta de pesquisa para o nome do módulo.
### Carregando um módulo
Para adicionar um módulo ao kernel Linux, alterne para o modo de carregamento com uma das teclas `+, i, insert` e forneça o nome do módulo a carregar. Em seguida, confirme/cancele a execução do comando de carregamento com `y/n`.
O comando usado para carregar um módulo:```
modprobe <module_name> || insmod <module_name>.ko
Use uma das teclas -, u, backspace para remover o módulo selecionado do kernel Linux.
O comando usado para remover um módulo:``` modprobe -r <module_name> || rmmod <module_name>
### Colocando um módulo na lista negra
[A colocação de um módulo na lista negra](https://wiki.archlinux.org/index.php/Kernel_module#Blacklisting) é um mecanismo para impedir que o módulo do kernel seja carregado. Para colocar o módulo selecionado na lista negra, use uma das teclas `x, b, delete` e confirme a execução.
O comando usado para colocar um módulo na lista negra:```
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
Use a tecla ctrl-r ou alt-r para recarregar o módulo selecionado.
O comando usado para recarregar um módulo:``` modprobe -r <module_name> || rmmod <module_name> && modprobe <module_name> || insmod <module_name>.ko
### Limpando o buffer de anel
O buffer de anel do kernel pode ser limpo usando uma das teclas `ctrl-l/u, alt-c`.
```
dmesg --clear
As teclas c/v estão definidas para operações de copiar/colar.
Use ctrl-c/ctrl-v para copiar e colar enquanto estiver no modo de entrada.
O subcomando sort pode ser usado para ordenar os módulos do kernel por seus nomes, tamanhos ou módulos dependentes.```
kmon sort --name
kmon sort --size
kmon sort --dependent
Além disso, a flag `-r, --reverse` é usada para reverter a lista de módulos do kernel.```
kmon --reverse
O kmon usa as cores do terminal como padrão, mas a cor de destaque pode ser especificada com a opção -c, --color. Alternativamente, a cor padrão do texto pode ser definida através da opção -a, --accent-color.
As cores de terminal suportadas são black, red, green, yellow, blue, magenta, cyan, gray, darkgray, lightred, lightgreen, lightyellow, lightblue, lightmagenta, lightcyan, white.```
kmon --color red
#### Usando uma cor personalizada
Forneça um valor hexadecimal para a cor a ser usada.```
kmon --color 19683a
A cor do texto padrão pode causar problemas de legibilidade em alguns temas que têm transparência. A opção -a, --accent-color pode ser usada de forma semelhante à opção -c, --color para superar esse problema.```
kmon --color 6f849c --accent-color e35760
### Símbolos Unicode
Use a flag `-u, --unicode` para exibir símbolos Unicode nos títulos dos blocos.```
kmon --unicode
A opção -t, --tickrate pode ser usada para definir o intervalo de atualização da interface do terminal em milissegundos.
A opção -E, --regex pode ser usada para pesquisar módulos por expressão regular.
kmon pretende ser uma ferramenta padrão para gerenciamento do kernel Linux enquanto suporta a maioria das distribuições Linux.
Para alcançar este objetivo, kmon deve estar acessível a partir de diferentes gerenciadores de pacotes como Snap* e RPM.
É necessário ter ferramentas essenciais como dmesg e kmod no sistema para que kmon funcione conforme esperado. Assim, o próximo passo seria usar apenas os recursos do sistema para essas funções.
Ações de gerenciamento sobre o kernel Linux devem ser aplicáveis no kmon para minimizar a dependência da linha de comando e outras ferramentas.
kmon deve ser testado e relatado em diferentes arquiteturas para desenvolvimento e suporte adicionais.
| Fedora 31 | Debian 10 | Manjaro 19 |
|---|---|---|
 |  |  |
| Ubuntu 18.04 | openSUSE | Void Linux |
|---|---|---|
 |  |  |
Apoie o desenvolvimento dos meus projetos me apoiando no GitHub Sponsors.
Apoie os esforços de desenvolvimento de código aberto tornando-se um apoiador ou patrocinador.
GNU General Public License (3.0)
Copyright © 2020-2024, Orhun Parmaksız
