trace-cmd-record - Online na nuvem

PROGRAMA:

NOME

trace-cmd-record - registra um rastreamento do rastreador interno do Ftrace Linux

SINOPSE

rastreamento-cmd registro [OPÇÕES] [comando]

DESCRIÇÃO

O rastreamento-cmd(1) o comando de registro configurará o rastreador de kernel do Ftrace Linux para registrar o
plug-ins ou eventos especificados que acontecem enquanto o comando executa. Se nenhum comando é
fornecido, então ele gravará até que o usuário pressione Ctrl-C.

O comando de registro do trace-cmd irá configurar o rastreador Ftrace para começar a rastrear os vários
eventos ou plug-ins fornecidos na linha de comando. Em seguida, criará uma série de
processos de rastreamento (um por CPU) que iniciarão a gravação do buffer de anel do kernel
direto para arquivos temporários. Quando o comando é concluído (ou Ctrl-C é pressionado), todos os
os arquivos serão combinados em um arquivo trace.dat que pode ser lido posteriormente (consulte
trace-cmd-relatório(1)).

OPÇÕES

-p plug-in
Especifique um plugin de rastreamento. Plugins são rastreadores Ftrace especiais que geralmente fazem mais do que
apenas rastreie um evento. Plugins comuns são função, gráfico_função, preemptirqsoff,
irqsoff, preempção e acorde. Um plugin deve ser suportado pelo kernel em execução. Para
veja uma lista de plugins disponíveis, veja lista de rastreamento-cmd(1).

-e evento
Especifique um evento para rastrear. Vários pontos de rastreamento estáticos foram adicionados ao Linux
núcleo. Eles são agrupados por subsistema onde você pode habilitar todos os eventos de um determinado
subsistema ou especifique eventos específicos a serem ativados. o evento é do formato
"subsistema: nome do evento". Você também pode apenas especificar o subsistema sem o
:nome do evento ou o nome do evento sem o "subsistema:". Usar "-e sched_switch" irá
habilitar o evento "sched_switch" onde, como, "-e sched" irá habilitar todos os eventos sob o
subsistema "sched".

O 'evento' também pode conter expressões glob. Ou seja, "* stat *" irá
selecione todos os eventos (ou subsistemas) que possuem os caracteres "stat" em seus
nomes.

A palavra-chave 'todos' pode ser usada para habilitar todos os eventos.

-a
Cada evento que está sendo gravado tem seu arquivo de formato de saída salvo no arquivo de saída
para poder exibi-lo mais tarde. Mas se outros eventos estiverem habilitados no trace sem
conhecimento do trace-cmd, os formatos desses eventos não serão gravados e trace-cmd
relatório não poderá exibi-los. Se for esse o caso, especifique o -a
opção e o formato de todos os eventos no sistema serão salvos.

-T
Habilite um rastreamento de pilha em cada evento. Por exemplo:

-0 [003] 58549.289091: sched_switch: kworker / 0: 1: 0 [120] R ==> trace-cmd: 2603 [120]
-0 [003] 58549.289092: kernel_stack:
=> agendar (ffffffff814b260e)
=> cpu_idle (ffffffff8100a38c)
=> start_secondary (ffffffff814ab828)

--func-stack
Habilite um rastreamento de pilha em todas as funções. Observe que isso só é aplicável para a "função"
rastreador de plugin, e só terá efeito se a opção -l for usada e tiver sucesso em
funções limitantes. Se o rastreador de função não for filtrado e o rastreamento de pilha for
habilitado, você pode bloquear a máquina ao vivo.

-f filtro
Especifique um filtro para o evento anterior. Isso deve vir depois de um -e. Isso irá filtrar
quais eventos são registrados com base no conteúdo do evento. A filtragem é passada para o
kernel diretamente, então a filtragem permitida pode depender de qual versão do kernel
você tem. Basicamente, permitirá que você use a notação C para verificar se um evento deve ser
processado ou não.

==,> =, <=,>, <, &, |, && e ||

Os itens acima são geralmente seguros de usar para comparar campos.

-R desencadear
Especifique um gatilho para o evento anterior. Isso deve vir depois de um -e. Isso irá adicionar um
determinado gatilho para o evento determinado. Para ativar apenas o acionador e não o próprio evento,
em seguida, coloque o evento após o -v opção.

Veja Documentation / trace / events.txt na fonte do kernel Linux para mais
informações sobre gatilhos.

-v
Isso fará com que todos os eventos especificados depois dele na linha de comando não sejam rastreados.
Isso é útil para selecionar um subsistema a ser rastreado, mas para omitir vários eventos.
Por exemplo: "-e sched -v -e" * stat \ * "" ativará todos os eventos no subsistema de sched
exceto aqueles que têm "stat" em seus nomes.

Nota: a opção * -v * foi retirada do caminho grep(1) inverte o seguinte
fósforos.

-F
Isso filtrará apenas o executável fornecido na linha de comando. Se nenhum comando
é fornecido, então ele se auto-filtrará (sem sentido). Usando -F vai deixar você rastrear
apenas eventos que são causados ​​pelo comando fornecido.

-P pid
Semelhante a -F mas permite que você especifique um ID de processo para rastrear.

-c
Usado com qualquer -F para rastrear os filhos do processo também.

-C relógio
Defina o rastreio do relógio para "relógio".

Uso rastreamento-cmd(1) lista -C para ver quais relógios estão disponíveis.

-o arquivo de saída
Por padrão, o relatório trace-cmd criará um rastreamento.dat Arquivo. Você pode especificar um diferente
arquivo para escrever com o -o opção.

-l nome da função
Isso vai limitar o função e gráfico_função rastreadores para rastrear apenas o dado
nome da função. Mais de um -l pode ser especificado na linha de comando para rastrear mais
de uma função. O uso limitado de expressões glob também é permitido. Estes são
partida* para filtrar apenas funções que começam com partida. *partida para apenas filtrar
funções que terminam com partida. *partida\* para filtrar apenas as funções que contêm
partida.

-g nome da função
Esta opção é para o plugin function_graph. Ele representará graficamente a função dada. Este
ou seja, ele rastreará apenas a função e todas as funções que ele chamar. Você pode ter mais
do que um -g na linha de comando.

-n nome da função
Isso tem o efeito oposto de -l. A função dada com o -n opção não será
rastreado. Isso tem precedência, ou seja, se você incluir a mesma função para ambos -n
e -l, não será rastreado.

-d
Alguns plug-ins do tracer habilitam a função tracer por padrão. Como os rastreadores de latência.
Esta opção evita que o rastreador de função seja habilitado na inicialização.

-D
A opção -d irátentar usar a opção de rastreio da função para desactivar o rastreador de função
(se disponível), caso contrário, o padrão é o arquivo proc:
/ proc / sys / kernel / ftrace_enabled, mas não vai tocá-lo se a opção de rastreamento de função for
acessível. o -D opção irá desabilitar o arquivo proc ftrace_enabled, bem como o
opção de rastreio de função, se existir.

Observe que esta função desabilita o rastreamento para todos os usuários, o que inclui usuários
fora dos rastreadores ftrace (stack_tracer, perf, etc).

-O opção
O Ftrace possui várias opções que podem ser ativadas ou desativadas. Isso permite que você defina
eles. Anexando o texto não para uma opção desativa-o. Por exemplo: "-O nograph-time"
irá desabilitar a opção Ftrace "tempo gráfico".

-s intervalo
Os processos que o trace-cmd cria para gravar a partir do buffer de anel precisam ser ativados para
faça a gravação. Configurando o intervalo para zero fará com que os processos despertem
toda vez que novos dados são gravados no buffer. Mas como o Ftrace está gravando o kernel
atividade, o ato desse processo voltar a dormir pode causar novos eventos no
buffer de anel que reativará o processo. Isso adicionará dados extras desnecessariamente
no buffer de anel.

A métrica de 'intervalo' é de microssegundos. O padrão é definido como 1000 (1 ms).
Esta é a hora em que cada processo de gravação irá dormir antes de acordar para
registre todos os novos dados que foram gravados no buffer de anel.

-r prioridade
A prioridade para executar os threads de captura. Em um sistema ocupado, a captura de rastreamento
threads podem ser bloqueados e eventos podem ser perdidos. Isso aumenta a prioridade daqueles
threads para a prioridade em tempo real (FIFO). Mas use essa opção com cuidado, ela também pode
alterar o comportamento do sistema que está sendo rastreado.

-b tamanho
Isso define o tamanho do buffer de anel para tamanho kilobytes. Porque o buffer de anel Ftrace é
por CPU, este tamanho é o tamanho de cada buffer em anel por CPU dentro do kernel. Usando
"-b 10000" em uma máquina com 4 CPUs fará com que o Ftrace tenha um tamanho de buffer total de 40
Megas.

-B nome-tampão
Se o kernel suportar múltiplos buffers, será adicionado um buffer com o nome fornecido.
Se o nome do buffer já existe, esse buffer é apenas redefinido e não será excluído
no final da execução do registro. Se o buffer for criado, ele será removido no
fim da execução (a menos que o -k está definido, ou começo foi usado).

Depois que um nome de buffer é declarado, todos os eventos adicionados depois disso serão
associado a esse buffer. Se nenhum buffer for especificado, ou um evento
é especificado antes de um nome de buffer, ele será associado ao
buffer principal (nível superior).

trace-cmd registro -e agendar -B bloco -e bloco -B tempo -e cronômetro dormir 1

O exemplo acima irá habilitar todos os eventos de agendamento no buffer principal. Será
em seguida, crie uma instância de buffer de 'bloco' e habilite todos os eventos de bloco dentro
esse buffer. Uma instância de buffer de 'tempo' é criada e todos os eventos de temporizador
será habilitado para esse evento.

-m tamanho
O tamanho máximo em kilobytes que um buffer por CPU deve ter. Nota, devido ao arredondamento para
tamanho da página, o número pode não estar totalmente correto. Além disso, isso é feito trocando
entre dois buffers com metade do tamanho dado, portanto, a saída pode não ser do
dado tamanho, mesmo que muito mais tenha sido escrito.

Use isso para evitar que fique sem espaço em disco para execuções longas.

-M cpumask
Defina a cpumask para rastrear. Afeta apenas a última instância do buffer fornecida. Se
fornecido antes de qualquer instância do buffer, ele afeta o buffer principal. O valor que
fornecido deve ser um número hexadecimal.

rastreamento-cmd registro -p função -M c -B eventos 13 -e todos -M 5

Se o -M for omitido, a máscara permanecerá a mesma. Para habilitar todos
CPUs, passam um valor de '-1'.

-k
Por padrão, quando trace-cmd conclui o rastreamento, ele redefinirá os buffers e desabilitará
todo o rastreamento que ele habilitou. Esta opção impede que trace-cmd desabilite o rastreador
e redefinir o buffer. Esta opção é útil para depurar trace-cmd.

Nota: geralmente trace-cmd irá definir o arquivo "tracing_on" de volta para o que ele
era antes de ser chamado. Esta opção deixará esse arquivo definido como zero.

-i
Por padrão, se um evento listado que trace-cmd não encontrar, ele sairá com um
erro. Esta opção irá apenas ignorar os eventos que estão listados na linha de comando, mas são
não encontrado no sistema.

-N host: porta
Se outra máquina estiver executando "trace-cmd listen", esta opção é usada para ter os dados
enviado para aquela máquina com pacotes UDP. Em vez de gravar em um arquivo de saída, os dados
é enviado para uma caixa remota. Isso é ideal para máquinas embarcadas com pouco armazenamento,
ou ter uma única máquina que irá manter todos os dados em um único repositório.

Observação: esta opção não é compatível com plug-ins latency tracer:
wakeup, wakeup_rt, irqsoff, preemptoff e preemptirqsoff

-t
Esta opção é usada com -N, quando há necessidade de enviar os dados ao vivo com TCP
pacotes em vez de UDP. Embora o TCP não seja tão rápido quanto o envio de pacotes UDP,
mas pode ser necessário se a rede não for tão confiável, a quantidade de dados não é
tão intensivo, e é necessária uma garantia de que todas as informações rastreadas sejam transferidas
com sucesso.

--data
Com o --data opção, "trace-cmd" gravará carimbos de data / hora no buffer de rastreamento após
terminou a gravação. Em seguida, ele mapeará o carimbo de data / hora para gettimeofday, que irá
permitir a saída de tempo de parede a partir dos carimbos de data / hora lendo o criado rastreamento.dat arquivo.

--perfil
Com o --perfil opção, "trace-cmd" permitirá o rastreamento que pode ser usado com
trace-cmd-relatório(1) opção --profile. Se um traçador -p não está definido, e o gráfico de função
profundidade é suportada pelo kernel, então o rastreador function_graph será habilitado com
uma profundidade de um (mostra apenas onde o espaço do usuário entra no kernel). Também irá permitir
vários pontos de rastreamento com rastreamento de pilha, de modo que o relatório possa mostrar onde as tarefas
foi bloqueado por muito tempo.

See trace-cmd-perfil(1) para mais detalhes e exemplos.

-H ganchos de eventos
Adicione correspondência de eventos personalizados para conectar quaisquer dois eventos. Quando não é usado com
--perfil, ele salvará o parâmetro e será usado pelo relatório trace-cmd
--perfile também. Isso é:

trace-cmd record -H hrtimer_expire_entry, hrtimer / hrtimer_expire_exit, hrtimer, sp
relatório trace-cmd --profile

Irá criar o perfil de hrtimer_expire_entry e hrtimer_expire_ext vezes.

See trace-cmd-perfil(1) para formato.

--stderr
Faça com que a saída vá para stderr em vez de stdout, mas a saída do comando executado
não será alterado. Isso é útil se você deseja monitorar a saída do comando
sendo executado, mas não vê a saída de trace-cmd.

EXEMPLOS

A maneira básica de rastrear todos os eventos:

# trace-cmd record -e all ls> / dev / null
# relatório trace-cmd
trace-cmd-13541 [003] 106260.693809: filemap_fault: endereço = 0x128122 deslocamento = 0xce
trace-cmd-13543 [001] 106260.693809: kmalloc: call_site = 81128dd4 ptr = 0xffff88003dd83800 bytes_req = 768 bytes_alloc = 1024 gfp_flags = GFP_KERNEL | GFP_ZERO
ls-13545 [002] 106260.693809: kfree: call_site = 810a7abb ptr = 0x0
ls-13545 [002] 106260.693818: sys_exit_write: 0x1

Para usar o rastreador de função com rastreamento de switch de programação:

# trace-cmd record -p function -e sched_switch ls> / dev / null
# relatório trace-cmd
ls-13587 [002] 106467.860310: função: hrtick_start_fair <- pick_next_task_fair
ls-13587 [002] 106467.860313: sched_switch: prev_comm = trace-cmd prev_pid = 13587 prev_prio = 120 prev_state = R ==> next_comm = trace-cmd next_pid = 13583 next_prio = 120
trace-cmd-13585 [001] 106467.860314: função: native_set_pte_at <- __do_fault
trace-cmd-13586 [003] 106467.860314: função: up_read <- do_page_fault
ls-13587 [002] 106467.860317: função: __phys_addr <- agenda
trace-cmd-13585 [001] 106467.860318: função: _raw_spin_unlock <- __do_fault
ls-13587 [002] 106467.860320: função: native_load_sp0 <- __switch_to
trace-cmd-13586 [003] 106467.860322: função: down_read_trylock <- do_page_fault

Esta é uma boa maneira de descobrir quais interrupções têm a latência mais alta:

# trace-cmd record -p function_graph -e irq_handler_entry -l do_IRQ sleep 10
# relatório trace-cmd
-0 [000] 157412.933969: funcgraph_entry: | do_IRQ () {
-0 [000] 157412.933974: irq_handler_entry: irq = 48 nome = eth0
-0 [000] 157412.934004: funcgraph_exit: + 36.358 us | }
-0 [000] 157413.895004: funcgraph_entry: | do_IRQ () {
-0 [000] 157413.895011: irq_handler_entry: irq = 48 nome = eth0
-0 [000] 157413.895026: funcgraph_exit: + 24.014 us | }
-0 [000] 157415.891762: funcgraph_entry: | do_IRQ () {
-0 [000] 157415.891769: irq_handler_entry: irq = 48 nome = eth0
-0 [000] 157415.891784: funcgraph_exit: + 22.928 us | }
-0 [000] 157415.934869: funcgraph_entry: | do_IRQ () {
-0 [000] 157415.934874: irq_handler_entry: irq = 48 nome = eth0
-0 [000] 157415.934906: funcgraph_exit: + 37.512 us | }
-0 [000] 157417.888373: funcgraph_entry: | do_IRQ () {
-0 [000] 157417.888381: irq_handler_entry: irq = 48 nome = eth0
-0 [000] 157417.888398: funcgraph_exit: + 25.943 us | }

Um exemplo do perfil:

# registro trace-cmd --profile sleep 1
# trace-cmd report --profile --comm sleep
tarefa: sleep-21611
Evento: sched_switch: R (1) Total: 99442 Média: 99442 Máx .: 99442 Mín: 99442
1 total: 99442 min: 99442 máx: 99442 média = 99442
=> ftrace_raw_event_sched_switch (0xffffffff8105f812)
=> __schedule (0xffffffff8150810a)
=> preempt_schedule (0xffffffff8150842e)
=> ___preempt_schedule (0xffffffff81273354)
=> cpu_stop_queue_work (0xffffffff810b03c5)
=> stop_one_cpu (0xffffffff810b063b)
=> sched_exec (0xffffffff8106136d)
=> do_execve_common.isra.27 (0xffffffff81148c89)
=> do_execve (0xffffffff811490b0)
=> SyS_execve (0xffffffff811492c4)
=> return_to_handler (0xffffffff8150e3c8)
=> stub_execve (0xffffffff8150c699)
Evento: sched_switch: S (1) Total: 1000506680 Média: 1000506680 Máx: 1000506680 Mín: 1000506680
1 total: 1000506680 min: 1000506680 máx: 1000506680 média = 1000506680
=> ftrace_raw_event_sched_switch (0xffffffff8105f812)
=> __schedule (0xffffffff8150810a)
=> agendar (0xffffffff815084b8)
=> do_nanosleep (0xffffffff8150b22c)
=> hrtimer_nanosleep (0xffffffff8108d647)
=> SyS_nanosleep (0xffffffff8108d72c)
=> return_to_handler (0xffffffff8150e3c8)
=> tracesys_phase2 (0xffffffff8150c304)
Evento: sched_wakeup: 21611 (1) Total: 30326 Média: 30326 Máx .: 30326 Mín: 30326
1 total: 30326 min: 30326 máx: 30326 média = 30326
=> ftrace_raw_event_sched_wakeup_template (0xffffffff8105f653)
=> ttwu_do_wakeup (0xffffffff810606eb)
=> ttwu_do_activate.constprop.124 (0xffffffff810607c8)
=> try_to_wake_up (0xffffffff8106340a)

Use trace-cmd-record online usando serviços onworks.net