Introspecção Linux e SystemTap

Uma interface e linguagem para análise de kernel dinâmico

Os kernels de sistemas operacionais modernos fornecem os meios para introspecção, a capacidade de compartilhar dinamicamente dentro do kernel para compreender seus comportamentos. Esses comportamentos indicam problemas no kernel, assim como gargalos de desempenho. Com este conhecimento, é possível sintonizar ou modificar o kernel para evitar condições de falha. Descubra uma infraestrutura de software livre chamada SystemTap que fornece esta introspecção dinâmica para o kernel do Linux® .

M. Tim Jones, Consultant Engineer, Emulex Corp.

M. Tim JonesM. 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.


nível de autor Contribuidor do
        developerWorks

16/Dez/2009

Entre em contato com Tim

Tim é um de nossos mais populares e criativos autores. Navegue por todos os arquivos de Tim no developerWorks. Consulte o perfil de Tim e entre em contato com ele, outros autores e colegas leitores no My developerWorks.

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).

Lista 1. Um script DTrace simples para contar chamadas do sistema por processo
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 .

Lista 2. Um script ProbeVue simples para indicar qual de seus processos invocou 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.


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.


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.

Figura 1. O processo SystemTap
O processo SystemTap

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.

Figura 2. O processo SystemTap a partir da perspectiva do kernel/espaço do usuário
O processo SystemTap a partir da perspectiva do kernel/espaço do usuário

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.

Tabela 1. Padrões de análise de exemplo
Tipo de AnáliseDescrição
beginDispara quando o script inicia
endDispara quando o script termina
kernel.function("sys_sync")Dispara quando sys_sync é chamado
kernel.function("sys_sync").callMesmo que acima
kernel.function("sys_sync").returnDispara quando sys_sync retorna
kernel.syscall.*Dispara quando qualquer chamada do sistema é realizada
kernel.function("*@kernel/fork.c:934")Dispara quando a linha 934 de fork.c é atingida
module("ext3").function("ext3_file_write")Dispara quando a função ext3 write é chamada
timer.jiffies(1000)Dispara a cada 1.000 jiffies kernel
timer.ms(200).randomize(50)Dispara a cada 200 ms, com um aditivo aleatório distribuído de forma linear (-50 a +50)

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.

Lista 3. Uma análise e um script simples
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.

Tabela 2. Elementos da linguagem do SystemTap
InstruçãoDescrição
if (exp) {} else {}Instrução if-then-else padrão
for (exp1 ; exp2 ; exp3 ) {}Um loop for
while (exp) {}Instrução while
do {} while (exp)Um loop do-while
breakSair da iteração
continueContinuar iteração
nextRetornar da análise
returnRetornar uma expressão de uma função
foreach (VAR in ARRAY) {}Iterar uma array, designando a chave atual para VAR

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.


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.

Lista 4. Monitorando todas as chamadas de sistema (profile.stp)
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.

Lista 5. Saída do script profile.stp
$ 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.

Lista 6. Novo script de monitoramento de chamada de sistema (syslog_profile.stp)
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.

Lista 7. A saída SystemTap para o novo script (syslog_profile.stp)
$ 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 .

Lista 8. Reunindo dados de comprimento do pacote de rede (net.stp)
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.

Lista 9. A saída para net.stp
$ 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 .

Lista 10. Capturando e apresentando dados do histograma (nethist.stp)
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.

Lista 11. Saída do histograma do nethist.stp
$ 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

$

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

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

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Linux
ArticleID=451592
ArticleTitle=Introspecção Linux e SystemTap
publish-date=12162009