SystemTap é um método dinâmico de monitoramento e rastreio da operação de um kernel Linux em execução. A palavra-chave lá é dinâmico, porque em vez de construir um kernel especial com instrumentação, o SystemTap permite instalar essa instrumentação dinamicamente no tempo de execução. Ele faz isso com uma interface de programação de aplicativos (API) chamada Kprobes, que é explorada por este artigo. Vamos iniciar com uma exploração de algumas das abordagens de rastreio do kernel anterior e, em seguida, detalharemos a arquitetura do SystemTap e seu uso.

Rastreio de kernel

O SystemTap é semelhante a uma tecnologia mais antiga chamada DTrace, originada no sistema operacional Sun Solaris. No DTrace, os desenvolvedores podem escrever scripts na linguagem de programação D (um subconjunto da linguagem C mas modificado para suportar comportamentos específicos de rastreio). Um script DTrace contém um número de análises e ações associadas que ocorrem quando a análise é "disparada". Por exemplo, uma análise pode representar algo tão simples quanto invocar uma chamada de sistema ou interações mais complicadas, como uma determinada linha do código sendo executado. A Lista 1 mostra um exemplo simples de um script DTrace que conta o número de chamadas do sistema realizadas por cada processo. (Observe o uso do dicionário para associar contagens com processos). O formato do script inclui a análise (que dispara quando uma chamada de sistema é realizada) e uma ação (o script de ação correspondente).

	
syscall:::entry
{ 

  @num[pid,execname] = count(); 

}

O DTrace tem sido uma parte invejável do Solaris, portanto não é surpresa encontrá-lo desenvolvido também para outros sistemas operacionais. O DTrace foi lançado sob a Common Development and Distribution License (CDDL) e foi portado para o sistema operacional FreeBSD.

Um outro recurso de rastreio de kernel útil chamado ProbeVue foi desenvolvido pela IBM para o sistema operacional IBM® AIX® , versão 6.1. É possível usar o ProbeVue para explorar o comportamento e o desempenho de um sistema, assim como fornecer informações detalhadas sobre um determinado processo. A ferramenta realiza isso de forma dinâmica, usando um kernel padrão. A Lista 2 mostra um script de amostra para o ProbeVue que indica o processo específico que está realizando a chamada de sistema sync .

	
@@syscall:*:sync:entry
{
  printf( "sync() syscall invoked by process ID %d\n", __pid );
  exit();
}

Dada a utilidade do DTrace e do ProbeVue em seus respectivos sistemas operacionais, um projeto de software livre para Linux foi inevitável. O SystemTap começou em 2005 e fornece funcionalidade semelhante ao DTrace e ao ProbeVue. Ele foi desenvolvido por uma comunidade que inclui Red Hat, Intel, Hitachi, IBM, entre outros.

Cada uma dessas soluções fornece funcionalidade semelhante, usando análises e scripts de ações associados quando as análises são disparadas. Agora, vamos abordar a instalação do SystemTap e, em seguida, explorar sua arquitetura e uso.

Voltar para parte superior

Instalando o SystemTap

Dependendo da sua distribuição e kernel, é possível suportar o SystemTap com nada além de uma instalação do SystemTap. Em outros casos, uma imagem de kernel de depuração é necessária. Essa seção passa pela instalação do SystemTap no Ubuntu versão 8.10 (Intrepid Ibex), que não é representante de uma instalação do SystemTap. Na seção Recursos , você encontrará informações adicionais sobre instalações para outras distribuições e versões.

Para a maioria dos usuários, uma simples instalação do SystemTap é o necessário. Para Ubuntu, use apt-get:

$ sudo apt-get install systemtap

Com a instalação concluída, é possível testar seu kernel para ver se ele suporta SystemTap. O seguinte script de linha de comandos simples atende esse objetivo:

$ sudo stap -ve 'probe begin { log("hello world") exit() }'

Se este script funcionar, "hello world" será exibido na saída padrão [stdout]. Caso contrário, desculpe-me, pois haverá um trabalho adicional a ser feito. Para Ubuntu 8.10, uma imagem de kernel de depuração era necessária. Deveria ser possível simplesmente usar apt-get para recuperar o pacote linux-image-debug-generic. Mas como isso não pôde ser realizado diretamente com o apt-get, é possível fazer o download de um e instalá-lo por meio de dpkg. É possível fazer o download da imagem de depuração genérica e instalá-la conforme mostrado abaixo:

$ wget http://ddebs.ubuntu.com/pool/main/l/linux/
          linux-image-debug-2.6.27-14-generic_2.6.27-14.39_i386.ddeb
$ sudo dpkg -i linux-image-debug-2.6.27-14-generic_2.6.27-14.39_i386.ddeb

Agora você possui uma imagem de depuração genérica instalada. Há apenas mais uma etapa para Ubuntu 8.10: A distribuição do SystemTap teve um problema que você pode facilmente solucionar modificando a origem do SystemTap. Consulte Recursos para obter informações sobre como atualizar o arquivo time.c do tempo de execução.

Se você tem um kernel customizado, será necessário garantir que as opções de kernel CONFIG_RELAY, CONFIG_DEBUG_FS, CONFIG_DEBUG_INFOe CONFIG_KPROBES estejam ativadas.

Voltar para parte superior

Arquitetura SystemTap

Vamos abordar alguns dos detalhes do SystemTap para compreender como ele fornece análises dinâmicas dentro de um kernel em execução. Você também verá como o SystemTap funciona, a partir do processo de script até a obtenção desses scripts ativos dentro de um kernel em execução.

Instrumentando dinamicamente um kernel

Dois dos métodos usados no SystemTap para instrumentar um kernel em execução são Kprobes e análises de retorno. Mas um importante elemento da compreensão de qualquer kernel é o mapa do kernel, que fornece informações de símbolos (tais como funções e variáveis, assim como seus endereços). Com o mapa, é possível resolver o endereço de qualquer símbolo e realizar alterações para suportar o comportamento da análise.

O Kprobes está no kernel Linux de linha principal desde a versão 2.6.9 e fornece um serviço geral para análise de um kernel. Ele fornece alguns serviços diferentes, mas dois dos mais importantes são Kprobe e Kretprobe. O Kprobe é específico da arquitetura e insere uma instrução de ponto de interrupção no primeiro byte da instrução a ser analisada. Quando a instrução é atingida, o manipulador específico para a análise é executado. Quando concluído, a instrução original é executada (a partir do ponto de interrupção), e a execução continua nesse ponto.

Kretprobes são um pouco diferentes, operando no retorno da função chamada. Observe que, como uma função pode ter muitos pontos de retorno, parece um pouco complicado. No entanto, na verdade, ela usa uma simples técnica chamada trampolim. Em vez de instrumentar cada ponto de retorno em uma função (o que não abrangeria todos os casos), inclua uma pequena quantidade de código para a entrada de função. Esse código substitui o endereço de retorno na pilha pelo endereço do trampolim—o endereço do Kretprobe. Quando a função é finalizada, em vez de retornar para o responsável pela chamada, ela chama o Kretprobe, que executa sua funcionalidade e, em seguida, retorna para o verdadeiro responsável pela chamada a partir do Kretprobe.

O processo SystemTap

A Figura 1 apresenta o fluxo básico do processo SystemTap, envolvendo três utilitários de interação em cinco fases. O processo inicia com o script SystemTap. Use o utilitário stap para converter o script stap para o módulo do kernel que fornece os comportamentos da análise. O processo stap inicia com uma conversão do script para uma árvore de análise (passagem 1). Os símbolos são, então resolvidos usando informações de símbolos sobre o kernel em execução atualmente na etapa de elaboração (passagem 2). O processo de conversão, então, converte a árvore de análise na fonte C (passagem 3) e usa as informações resolvidas, assim como os que são chamados de scripts tapset (bibliotecas de funcionalidade útil definidas pelo SystemTap). A etapa final de stap é a construção do módulo do kernel (passagem 4), que usa o processo de construção do módulo do kernel local.

Com a disponibilidade do módulo do kernel, stap fornece o controle sobre dois outros utilitários SystemTap: staprun e stapio. Esses dois utilitários trabalham em conjunto para gerenciar a instalação do módulo no kernel e rotear sua saída para stdout (passagem 5). Se você pressionar Ctrl-C no shell ou o script for finalizado, o processo de limpeza será realizado, o que descarrega o módulo e faz com que todos os utilitários associados sejam finalizados.

Um recurso interessante do SystemTap é a capacidade de armazenar em cache as conversões de scripts. Se um script deve ser instalado e não foi alterado, será possível usar o módulo existente em vez de passar pelo processo de sua reconstrução. A Figura 2 mostra o espaço do usuário e os elementos do espaço do kernel juntamente com o processo de conversão com base no stap.

Voltar para parte superior

Script SystemTap

O script no SystemTap é absolutamente simples, mas também flexível, com muitas ações para obter dele o que for necessário. A comunidade Recursos fornece links para manuais que detalham a linguagem e as possibilidades, mas esta seção explora alguns exemplos para fornecer uma amostra dos scripts SystemTap.

Análises

Os scripts SystemTap são formados por análises e blocos associados do código a ser executado quando a análise for disparada. As análises possuem um número de padrões definidos, como aqueles mostrados na Tabela 1. Esta tabela enumera vários tipos de análises, incluindo a chamada de uma função de kernel e o retorno de uma função de kernel.

Vamos observar um exemplo simples para compreender como construir uma análise e associar o código a essa análise. Uma análise de amostra é mostrada na Lista 3 que é finalizada para disparo quando a chamada de sistema do kernel sys_sync é invocada. Quando esta análise é disparada, você deseja contar o número de invocações e emitir esta contagem com uma indicação do ID do processo de chamada (PID). Primeiro, declare um valor global que qualquer análise pode usar (o nome de espaço global é comum a todas as análises) e, em seguida, inicialize-o como zero. Em seguida, defina sua análise, que é uma análise de entrada na função de kernel sys_sync. O script associado à análise é para incrementar a variável count e, em seguida, para emitir uma mensagem que define o número de vezes que a chamada foi realizada e o PID para a invocação atual. Observe que este exemplo aparece muito com C (exceto para a sintaxe de definição de análise), que, se você possui experiência em C, é excelente.

	
global count=0

probe kernel.function("sys_sync") {
  count++
  printf( "sys_sync called %d times, currently by pid %d\n", count, pid );
}

Também é possível declarar funções que as análises podem chamar, o que é perfeito para funções comuns para as quais gostaria de realizar várias análises. A ferramenta suporta ainda a recursão para um determinado detalhadamento.

Variáveis e tipos

O SystemTap permite a definição de variáveis de vários tipos, mas o tipo é deduzido a partir do contexto, portanto nenhum tipo de declaração é necessário. No SystemTap, você encontrará números (números inteiros assinados de 64 bits), números inteiros (quantidades de 64 bits), cadeias de caracteres e literais (cadeias de caracteres ou números inteiros). Também é possível usar arrays associativas e estatísticas (que exploraremos mais adiante).

Expressões

O SystemTap fornece todos os operadores necessários esperados do C e segue as mesmas regras. Você encontrará operadores aritméticos, operadores binários, operadores de designação e dereferência de ponteiro. Também encontrará algumas simplificações do C, que incluem a concatenação de cadeias de caracteres, elementos de array associativa e operadores de agregação.

Elementos da linguagem

Dentro de uma análise, o SystemTap fornece um conjunto confortável de instruções remanescentes do C. Observe que, embora a linguagem permita desenvolver scripts complexos, apenas 1.000 instruções podem ser executadas por análise (apenas deste número ser configurável). A Tabela 2 fornece uma breve lista de instruções da linguagem apenas para fornecer uma visão geral. Observe aqui que muitos elementos aparecem exatamente como no C, apesar de haver algumas inclusões específicas no SystemTap.

Este artigo explora os recursos de estatísticas e a agregação nos scripts de amostra, pois não possuem equivalentes na linguagem C .

Finalmente, o SystemTap fornece um número de funções internas que oferecem informações adicionais sobre o contexto atual. Por exemplo, é possível usar caller() para identificar a função de chamada, cpu() para identificar o número do processador atual e pid() para retornar o PID. O SystemTap fornece também uma série de outras funções, fornecendo acesso à pilha de chamada e aos registros atuais.

Voltar para parte superior

Exemplos SystemTap

Como já foi dada uma rápida introdução ao SystemTap, vamos explorar alguns exemplos simples para ver como o SystemTap realmente funciona. Este artigo também demonstra alguns dos aspectos interessantes da linguagem de script, tais como agregações.

Monitoramento de chamada de sistema

A seção anterior explorou um script simples para monitorar a chamada de sistema sync . Agora, vamos abordar um script mais geral que pode monitorar todas as chamadas de sistema e coletar informações adicionais sobre elas.

A Lista 4 mostra um script simples que inclui uma definição de variável global e três análises separadas. A primeira análise é invocada quando o script é carregado pela primeira vez (a análise begin ). Nesta análise, você simplesmente emite uma mensagem de texto para indicar que o script está executando no kernel. Em seguida, você possui uma análise syscall . Observe o uso do curinga (*) aqui, que informa o SystemTap para monitorar todas as chamadas do sistema correspondentes. Quando a análise for disparada, você incrementa um elemento de array associativa para o PID e o nome de processo fornecidos. A análise final é uma análise de cronômetro. Esta análise é disparada após 10.000 milissegundos (10 segundos). O script para esta análise, então, emite os dados coletados (iterando por meio de cada um dos membros da matriz associativa). Quando todos os membros tiverem sido iterados, a chamada exit será realizada, o que faz com que o módulo seja descarregado e todos os processos de SystemTap sejam finalizados.

	
global syscalllist

probe begin {
  printf("System Call Monitoring Started (10 seconds)...\n")
}

probe syscall.*
{
  syscalllist[pid(), execname()]++
}

probe timer.ms(10000) {
  foreach ( [pid, procname] in syscalllist ) {
    printf("%s[%d] = %d\n", procname, pid, syscalllist[pid, procname] )
  }
  exit()
}

A saída para o script na Lista 4 é mostrada na Lista 5. É possível ver a partir deste script cada um dos processos em execução no espaço do usuário e o número de chamadas de sistema realizadas ao longo do período de 10 segundos.

	
$ sudo stap profile.stp
System Call Monitoring Started (10 seconds)...
stapio[16208] = 104
gnome-terminal[6416] = 196
Xorg[5525] = 90
vmware-guestd[5307] = 764
hald-addon-stor[4969] = 30
hald-addon-stor[4988] = 15
update-notifier[6204] = 10
munin-node[5925] = 5
gnome-panel[6190] = 33
ntpd[5830] = 20
pulseaudio[6152] = 25
miniserv.pl[5859] = 10
syslogd[4513] = 5
gnome-power-man[6215] = 4
gconfd-2[6157] = 5
hald[4877] = 3
$ 

Monitoramento de chamada de sistema para um processo específico

Neste exemplo, você modifica um pouco seu último script para coletar dados da chamada de sistema para um único processo. Além disso, em vez de apenas capturar contagens, você captura a chamada de sistema específica que está sendo realizada para o seu processo de destino. O script é mostrado na Lista 6.

Este exemplo testa o processo específico de interesse (neste caso, o daemon syslog ) e, em seguida, altera sua array associativa para mapear nomes de chamadas de sistema para contagens. Quando sua análise de cronômetro for disparada, emita a chamada de sistema e os dados da contagem.

	
global syscalllist

probe begin {
  printf("Syslog Monitoring Started (10 seconds)...\n")
}

probe syscall.*
{
  if (execname() == "syslogd") {
    syscalllist[name]++
  }
}

probe timer.ms(10000) {
  foreach ( name in syscalllist ) {
    printf("%s = %d\n", name, syscalllist[name] )
  }
  exit()
}

A saída para este script é fornecida na Lista 7.

	
$ sudo stap syslog_profile.stp
Syslog Monitoring Started (10 seconds)...
writev = 3
rt_sigprocmask = 1
select = 1
$ 

Usando agregados para capturar dados numéricos

Instâncias agregadas são uma excelente forma para capturar estatísticas sobre valores numéricos. Este método é eficiente e útil quando estiver capturando uma grande quantidade de dados. Neste exemplo, você coleta dados no recebimento e na transmissão de pacotes de rede. A Lista 8 define duas novas análises para capturar a E/S de rede. Cada análise captura o comprimento do pacote para um determinado nome de dispositivo de rede, PID e nome de processo. A análise de término, que é chamada se o usuário pressionar Ctrl-C, fornece os meios para emitir os dados capturados. Neste caso, você itera por meio do conteúdo do agregado recv , soma os comprimentos dos pacotes para cada tupla (nome do dispositivo, PID e nome do processo) e, em seguida, emite esses dados. Observe o extrator usado aqui para somar as tuplas: o extrator @count para capturar o número de comprimentos capturados (contagens de pacotes). Também é possível usar o extrator @sum para executar uma adição, o @min ou o @max para reunir os comprimentos mínimo ou máximo, respectivamente, assim como computar a média com o extrator @avg .

	
global recv, xmit

probe begin {
  printf("Starting network capture (Ctl-C to end)\n")
}

probe netdev.receive {
  recv[dev_name, pid(), execname()] <<< length
}

probe netdev.transmit {
  xmit[dev_name, pid(), execname()] <<< length
}

probe end {
  printf("\nEnd Capture\n\n")

  printf("Iface Process........ PID.. RcvPktCnt XmtPktCnt\n")

  foreach ([dev, pid, name] in recv) {
    recvcount = @count(recv[dev, pid, name])
    xmitcount = @count(xmit[dev, pid, name])
    printf( "%5s %-15s %-5d %9d %9d\n", dev, name, pid, recvcount, xmitcount )
  }

  delete recv
  delete xmit
}

A saída para o script na Lista 8 é fornecida na Lista 9. Observe aqui, que o script é finalizado após o usuário pressionar Ctrl-C e, em seguida, emite os dados capturados.

	
$ sudo stap net.stp
Starting network capture (Ctl-C to end)
^C
End Capture

Iface Process........ PID.. RcvPktCnt XmtPktCnt
 eth0 swapper         0           122        85
 eth0 metacity        6171          4         2
 eth0 gconfd-2        6157          5         1
 eth0 firefox         21424        48        98
 eth0 Xorg            5525         36        21
 eth0 bash            22860         1         0
 eth0 vmware-guestd   5307          1         1
 eth0 gnome-screensav 6244          6         3
Pass 5: run completed in 0usr/50sys/37694real ms.
$ 

Capturando dados do histograma

Este exemplo final explora como é fácil para o SystemTap apresentar dados em outros formatos—neste caso, um histograma. Retornando ao exemplo anterior, capture seus dados em um agregado chamado histogram (consulte a Lista 10). Em seguida, use o recebimento de netdev e transmita análises para capturar os dados de comprimento do pacote. Quando a análise é terminada, você emite os dados em um histograma usando o extrator @hist_log .

	
global histogram

probe begin {
  printf("Capturing...\n")
}

probe netdev.receive {
  histogram <<< length
}

probe netdev.transmit {
  histogram <<< length
}

probe end {
  printf( "\n" )
  print( @hist_log(histogram) )
}

A saída da Lista 10 é mostrada na Lista 11. Neste exemplo, uma sessão do navegador, uma sessão FTP e ping foram usados para gerar o tráfego de rede. A comunidade @hist_log é um histograma logarítmico de base 2 (conforme mostrado). Outros histogramas podem ser capturados, permitindo definir os tamanhos dos depósitos.

	
$ sudo stap nethist.stp
Capturing...
^C
value |-------------------------------------------------- count
    8 |                                                      0
   16 |                                                      0
   32 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@            1601
   64 |@                                                    52
  128 |@                                                    46
  256 |@@@@                                                164
  512 |@@@                                                 140
 1024 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@  2033
 2048 |                                                      0
 4096 |                                                      0

$ 

Voltar para parte superior

Indo além

Este artigo abordou muito pouco sobre os recursos do SystemTap. Na seção Recursos , você encontrará links para uma série de tutoriais, exemplos e a referência da linguagem, que informa tudo que é necessário saber para usar o SystemTap. O SystemTap usa vários métodos existentes e adquiriu experiência de implementação anteriores do rastreio do kernel. Embora ainda esteja em desenvolvimento, a ferramenta é bastante útil agora, e será interessante ver o que virá no futuro.

Recursos

Aprender

• Consulte o Web site do projeto do SystemTap para obter as informações mais recentes, incluindo versões atuais, documentação, links e também como se envolver com o projeto do SystemTap. O SystemTap usa Kprobes como o método subjacente de instalação de pontos de análise em um kernel em execução. Aprenda mais sobre Kprobes no mesmo Web site do Sourceware.
  
  
• O IBM Redpaper "SystemTap: Instrumenting the Linux Kernel for Analyzing Performance and Functional Problems" fornece informações adicionais sobre o uso do SystemTap.
  
  
• Um Projeto IBM para Linux em sistemas IBM mostra como instalar e usar o SystemTap no Red Hat Enterprise Linux e no SUSE Linux Enterprise Server. Um outro Projeto discute como usar a GUI do SystemTap, uma ferramenta com base no Eclipse que simplifica a escrita de scripts SystemTap e a visualização de eventos do kernel.
  
  
• Aprenda como modificar o SystemTap para o Ubuntu 8.10 para corrigir o erro no arquivo time.c do tempo de execução.
  
  
• O documento "Dynamic Instrumentation of Production Systems" é proveniente do 2004 USENIX, que apresentou o recurso DTrace e foi apresentado pelos autores da Sun Microsystems.
  
  
• Este documento de arquitetura de 2005 apresenta a arquitetura e o formato de design do SystemTap. Nele, é possível aprender a motivação e os requisitos por trás do SystemTap. Além de fornecer uma grande quantidade de detalhes técnicos sobre o SystemTap, o documento também é um grande modelo para o design de documentação.
  
  
• Este tutorial do Kprobes, fornecido no simpósio 2006 Ottawa Linux, fornece uma breve, porém útil, introdução à análise de kernel com Kprobes. Você talvez ache o artigo de "depuração de kernel com Kprobes" (developerWorks, agosto de 2004) interessante.
  
  
• Nesta apresentação chamada "Dynamic Tracing and Performance Analysis Using SystemTap," Josh Stone da Intel fornece um excelente tutorial sobre o SystemTap. Esta apresentação fornece uma introdução bastante completa ao SystemTap, sua linguagem e seu uso.
  
  
• O documento SystemTap Language Reference é um excelente recurso para aprender a linguagem SystemTap e todos os seus recursos.
  
  
• A Wikipedia fornece vários recursos úteis para o SystemTap, DTracee ProbeVue. Você também encontrará um conjunto de links externos para apresentações e tutoriais para cada uma dessas tecnologias.
  
  
• Na zona Linux no developerWorks, encontre mais recursos para desenvolvedores em Linux, e realize buscas em nossos artigos e tutoriais mais populares.
  
  
• Consulte todas as dicas Linux e tutoriais Linux no developerWorks.
  
  
• Fique atualizado com os eventos técnicos e Webcasts do developerWorks.
  
  

Obter produtos e tecnologias

• Com o o software de avaliação IBM, disponível para download diretamente do developerWorks, construa seu próximo projeto de desenvolvimento no Linux.
  
  

Discutir

• Discuta sobre o SystemTap e a GUI do SystemTap no SystemTap Blueprints Community Forum.
  
  
• Participe da comunidade do My developerWorks; com seu perfil pessoal e a página inicial customizada, é possível padronizar o developerWorks para seus interesses e interagir com outros usuários do developerWorks.
  
  

Sobre o autor

M. Tim Jones é um arquiteto de firmwares embarcados e autor de Inteligência Artificial: Sistemas de Abordagem, GNU/Linux, Programação de Aplicativos AI (atualmente em sua segunda edição), Programação de Aplicativos AI (em sua segunda edição) e BSD Sockets Programming from a Multilanguage Perspective. Sua formação em engenharia vai desde o desenvolvimento de kernels para nave espacial geossincrônica até a arquitetura de sistema embarcado e o desenvolvimento de protocolos de interligação de redes. Tim é um Engenheiro Consultor para a Emulex Corp. em Longmont, Colorado.

Classificar este artigo

Comentários

Voltar para parte superior

Índice

• Rastreio de kernel
• Instalando o SystemTap
• Arquitetura SystemTap
• Script SystemTap
• Exemplos SystemTap
• Indo além
• Recursos
• Sobre o autor
• Comentários

Conheça a IBM da sua cidade

A IBM está mais perto do que você imagina!

---

Saiba mais