Introdução
Neste laboratório, exploraremos como verificar se um ponto de rastreamento (tracepoint) do kernel está ativo no Linux. Os tracepoints são essenciais para observar eventos do kernel e são inestimáveis para depuração e análise de desempenho. Começaremos listando os tracepoints disponíveis no seu sistema usando o sistema de arquivos /sys/kernel/debug/tracing.
Após a exploração inicial, aprenderemos como verificar o status de tracepoints específicos usando o utilitário trace-cmd e, finalmente, verificaremos os tracepoints examinando o arquivo /proc/kallsyms.
Listar tracepoints com ls /sys/kernel/debug/tracing
Nesta etapa, começaremos a explorar os tracepoints do Linux. Os tracepoints são ganchos (hooks) colocados no código-fonte do kernel que permitem observar eventos específicos que ocorrem dentro do kernel. Eles são inestimáveis para depuração e análise de desempenho.
O kernel Linux fornece um framework de rastreamento (tracing framework), frequentemente acessado através do diretório /sys/kernel/debug/tracing. Este diretório contém vários arquivos que controlam e fornecem informações sobre o rastreamento.
Para ver os tracepoints disponíveis no seu sistema, você pode listar o conteúdo do diretório events dentro do sistema de arquivos de rastreamento.
Abra seu terminal, caso ainda não esteja aberto. Lembre-se, você pode encontrar o ícone do Xfce Terminal no lado esquerdo da sua área de trabalho.
Agora, digite o seguinte comando e pressione Enter:
ls /sys/kernel/debug/tracing/events
Este comando usa ls para listar o conteúdo do diretório /sys/kernel/debug/tracing/events. O diretório events é onde o kernel expõe os tracepoints disponíveis, organizados por subsistema.
Você verá uma lista de diretórios, cada um representando um subsistema do kernel (como syscalls, sched, ext4, etc.). Dentro desses diretórios estão os nomes reais dos tracepoints.
Por exemplo, você pode ver uma saída semelhante a esta (a saída exata variará dependendo da versão e configuração do seu kernel):
block/ ext4/ kmem/ net/ pci/ random/ sock/ task/ workqueue/
bpf/ fib/ kvm/ nfs/ power/ raw_syscalls/ signal/ timer/ xfs/
compaction/ ftrace/ libata/ nipi/ printk/ regmap/ skb/ udp/ xen/
cpu-freq/ gpio/ mdio/ oom/ qdisc/ rpm/ snd/ vmscan/
cgroup/ header_event header_page irq/ migrate/ pagemap/ ras/ scsi/ spi/ writeback/
dma_fence/ i2c/ kcsan/ module/ perf_events/ rcu/ sfc/ syscalls/ xhci-hcd/
enable iommu/ kprobe/ mpx/ powerpc/ regulator/ signal/ tcp/ xilinx-vsec/
exceptions/ iov/ kscan/ napi/ probe/ rpm/ skb/ timer/ xfs/
Esta saída mostra as diferentes categorias de eventos que você pode rastrear. Nas próximas etapas, aprenderemos como verificar o status desses tracepoints.
Clique em Continuar para prosseguir.
Verificar o status do tracepoint com trace-cmd
Na etapa anterior, listamos os tracepoints disponíveis explorando o diretório /sys/kernel/debug/tracing/events. Agora, vamos usar o utilitário trace-cmd para obter informações mais detalhadas sobre os tracepoints, especificamente seu status (se estão habilitados ou desabilitados).
O comando trace-cmd é uma ferramenta poderosa para interagir com o framework de rastreamento do Linux. Se o trace-cmd ainda não estiver instalado, você pode instalá-lo usando apt.
Primeiro, atualize a lista de pacotes:
sudo apt update
Em seguida, instale o trace-cmd:
sudo apt install trace-cmd
Você pode ver uma saída indicando que o trace-cmd já está instalado, o que é normal.
Agora, para listar todos os tracepoints disponíveis e seu status, use o comando trace-cmd list -e. A opção -e informa ao trace-cmd para listar eventos (tracepoints).
Digite o seguinte comando e pressione Enter:
trace-cmd list -e
Este comando exibirá uma longa lista de tracepoints, mostrando seu subsistema e nome, seguido por seu status atual entre colchetes ([enabled] ou [disabled]).
Você verá uma saída semelhante a esta (novamente, a lista exata variará):
block:block_bio_backmerge [disabled]
block:block_bio_bounce [disabled]
block:block_bio_complete [disabled]
block:block_bio_frontmerge [disabled]
block:block_bio_queue [disabled]
block:block_bio_remap [disabled]
block:block_dirty_buffer [disabled]
block:block_getrq [disabled]
block:block_plug [disabled]
block:block_rq_complete [disabled]
block:block_rq_insert [disabled]
block:block_rq_issue [disabled]
block:block_rq_remap [disabled]
block:block_rq_requeue [disabled]
block:block_sync_buffer [disabled]
block:block_touch_buffer [disabled]
block:block_unplug [disabled]
bpf:bpf_trace_printk [disabled]
bpf:bpf_trace_vprintk [disabled]
... (many more tracepoints)
Como você pode ver, a maioria dos tracepoints está desabilitada por padrão para evitar sobrecarga de desempenho. Você normalmente habilitaria tracepoints específicos quando precisasse rastrear eventos específicos do kernel.
Usar trace-cmd list -e é uma maneira conveniente de ver a lista completa de tracepoints e seu estado atual sem navegar manualmente no sistema de arquivos /sys/kernel/debug/tracing.
Clique em Continuar para passar para a próxima etapa.
Verificar tracepoints em /proc/kallsyms
Nas etapas anteriores, aprendemos como listar tracepoints usando o sistema de arquivos de rastreamento e o utilitário trace-cmd. Agora, vamos explorar outra maneira de ver informações sobre tracepoints: o arquivo /proc/kallsyms.
O arquivo /proc/kallsyms contém os endereços e nomes de todos os símbolos do kernel exportados, incluindo funções e variáveis. Os tracepoints também são representados como símbolos neste arquivo.
Você pode usar comandos como cat e grep para pesquisar símbolos de tracepoint dentro de /proc/kallsyms. Os símbolos de tracepoint normalmente seguem uma convenção de nomenclatura, frequentemente incluindo tracepoint ou _tracepoint.
Vamos tentar encontrar símbolos relacionados a tracepoints em /proc/kallsyms. Usaremos cat para ler o arquivo e canalizar a saída para grep para pesquisar linhas contendo a palavra "tracepoint".
Digite o seguinte comando e pressione Enter:
cat /proc/kallsyms | grep tracepoint
Este comando exibirá linhas de /proc/kallsyms que contêm a string "tracepoint". Você verá uma saída semelhante a esta:
...
ffffffffXXXXXXXX R __tracepoint_module_load
ffffffffXXXXXXXX R __tracepoint_module_free
ffffffffXXXXXXXX R __tracepoint_module_get
ffffffffXXXXXXXX R __tracepoint_module_put
ffffffffXXXXXXXX R __tracepoint_module_request_module
ffffffffXXXXXXXX R __tracepoint_module_module_init
ffffffffXXXXXXXX R __tracepoint_module_module_exit
ffffffffXXXXXXXX R __tracepoint_module_module_request
ffffffffXXXXXXXX R __tracepoint_module_module_autoload
ffffffffXXXXXXXX R __tracepoint_module_module_kset_reg
ffffffffXXXXXXXX R __tracepoint_module_module_kset_unreg
...
O XXXXXXXX representa endereços hexadecimais, que serão diferentes no seu sistema. A parte importante é o nome do símbolo, que geralmente começa com __tracepoint_ seguido pelo subsistema e nome do evento.
Isso confirma que os tracepoints são de fato representados como símbolos dentro da tabela de símbolos do kernel, acessível através de /proc/kallsyms. Embora /sys/kernel/debug/tracing e trace-cmd forneçam uma interface mais amigável para gerenciar e visualizar tracepoints, entender que eles existem como símbolos do kernel é fundamental para conceitos avançados de rastreamento do kernel.
Você agora aprendeu três maneiras diferentes de identificar e inspecionar tracepoints em um sistema Linux.
Clique em Continuar para concluir este laboratório.
Resumo
Neste laboratório, começamos explorando os tracepoints do Linux, que são cruciais para a depuração do kernel e análise de desempenho. Aprendemos que o diretório /sys/kernel/debug/tracing fornece acesso ao framework de rastreamento do kernel. Especificamente, usamos o comando ls /sys/kernel/debug/tracing/events para listar os tracepoints disponíveis, que são organizados por subsistema do kernel dentro do diretório events. Esta etapa inicial demonstrou como identificar os vários eventos do kernel que podem ser rastreados em um sistema.
