trace-cmd-record - En ligne dans le cloud

PROGRAMME:

Nom

trace-cmd-record - enregistre une trace à partir du traceur interne Ftrace Linux

SYNOPSIS

trace-cmd record [OPTIONS] [commander]

DESCRIPTION

Le site de trace-cmd(1) la commande record configurera le traceur du noyau Linux Ftrace pour enregistrer le
plugins ou événements spécifiés qui se produisent pendant que le commander exécute. Si aucune commande n'est
donné, alors il enregistrera jusqu'à ce que l'utilisateur appuie sur Ctrl-C.

La commande record de trace-cmd configurera le traceur Ftrace pour commencer à tracer les différents
événements ou plugins qui sont donnés sur la ligne de commande. Il créera alors un certain nombre de
processus de traçage (un par CPU) qui commenceront à enregistrer à partir du tampon en anneau du noyau
directement dans les fichiers temporaires. Lorsque la commande est terminée (ou que Ctrl-C est appuyé), tous les
seront combinés dans un fichier trace.dat qui pourra être lu ultérieurement (voir
trace-cmd-rapport(1)).

OPTIONS

-p plug-in
Spécifiez un plug-in de trace. Les plugins sont des traceurs Ftrace spéciaux qui font généralement plus que
il suffit de tracer un événement. Les plugins courants sont fonction, fonction_graphique, préemptirqsoff,
irqsoff, préemptionet la bien-aimée Sonate en la majeur Réveillez-vous. Un plugin doit être pris en charge par le noyau en cours d'exécution. À
voir la liste des plugins disponibles, voir trace-cmd-liste (1).

-e event
Spécifiez un événement à tracer. Divers points de trace statiques ont été ajoutés au Linux
noyau. Ils sont regroupés par sous-système où vous pouvez activer tous les événements d'un
sous-système ou spécifiez des événements spécifiques à activer. Les event est du format
"sous-système:nom-événement". Vous pouvez également simplement spécifier le sous-système sans le
:Nom de l'événement ou le nom de l'événement sans le "sous-système :". L'utilisation de "-e sched_switch"
activer l'événement "sched_switch" où, comme, "-e sched" activera tous les événements sous le
sous-système "sched".

L'"événement" peut également contenir des expressions glob. C'est-à-dire que "*stat*"
sélectionner tous les événements (ou sous-systèmes) qui ont les caractères "stat" dans leur
des noms.

Le mot-clé « all » peut être utilisé pour activer tous les événements.

-a
Chaque événement enregistré a son fichier de format de sortie enregistré dans le fichier de sortie
pour pouvoir l'afficher plus tard. Mais si d'autres événements sont activés dans la trace sans
trace-cmd, les formats de ces événements ne seront pas enregistrés et trace-cmd
rapport ne pourra pas les afficher. Si tel est le cas, précisez le -a
l'option et le format de tous les événements du système seront enregistrés.

-T
Activez un stacktrace sur chaque événement. Par exemple:

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

--func-pile
Activez une trace de pile sur toutes les fonctions. Notez que ceci n'est applicable que pour la "fonction"
traceur de plugin, et ne prendra effet que si l'option -l est utilisée et réussit
fonctions limitantes. Si le traceur de fonction n'est pas filtré et que la trace de pile est
activé, vous pouvez verrouiller la machine en direct.

-f une fonction filtre
Spécifiez un filtre pour l'événement précédent. Cela doit venir après un -e. Cela filtrera
quels événements sont enregistrés en fonction du contenu de l'événement. Le filtrage est passé au
noyau directement, donc le filtrage autorisé peut dépendre de la version du noyau
vous avez. Fondamentalement, il vous permettra d'utiliser la notation C pour vérifier si un événement doit être
traité ou non.

==, >=, <=, >, <, &, |, && et ||

Ce qui précède est généralement sûr à utiliser pour comparer les champs.

-R déclencher
Spécifiez un déclencheur pour l'événement précédent. Cela doit venir après un -e. Cela ajoutera un
déclencheur donné à l'événement donné. Pour n'activer que le déclencheur et non l'événement lui-même,
puis placez l'événement après le -v option.

Voir Documentation/trace/events.txt dans les sources du noyau Linux pour plus d'informations
informations sur les déclencheurs.

-v
Cela empêchera le suivi de tous les événements spécifiés après celui-ci sur la ligne de commande.
Ceci est utile pour sélectionner un sous-système à tracer mais pour omettre divers événements.
Par exemple : "-e sched -v -e "*stat\*"" activera tous les événements dans le sous-système sched
sauf ceux qui ont "stat" dans leurs noms.

Remarque : l'option *-v* a été prise de la manière grep(1) inverse ce qui suit
allumettes.

-F
Cela filtrera uniquement l'exécutable qui est donné sur la ligne de commande. Si aucune commande
est donné, alors il se filtrera (assez inutile). À l'aide de -F vous laissera tracer
uniquement les événements provoqués par la commande donnée.

-P Pid
Similaire à -F mais vous permet de spécifier un ID de processus à tracer.

-c
Utilisé avec soit -F pour retracer les enfants du processus aussi.

-C horloge
Réglez l'horloge de suivi sur « horloge ».

Utilisez le trace-cmd(1) liste -C pour voir quelles horloges sont disponibles.

-o fichier de sortie
Par défaut, le rapport trace-cmd créera un trace.dat déposer. Vous pouvez spécifier un autre
fichier dans lequel écrire avec le -o option.

-l nom-fonction
Cela limitera la fonction et fonction_graphique traceurs pour ne tracer que le donné
nom de la fonction. Plus d'un -l peut être spécifié sur la ligne de commande pour tracer plus
qu'une fonction. L'utilisation limitée des expressions glob est également autorisée. Ceux-ci sont
rencontre* pour filtrer uniquement les fonctions commençant par rencontre. *rencontre filtrer uniquement
fonctions qui se terminent par rencontre. *rencontre\* pour filtrer uniquement sur les fonctions qui contiennent
rencontre.

-g nom-fonction
Cette option est pour le plugin function_graph. Il représentera graphiquement la fonction donnée. Cette
c'est-à-dire qu'il ne tracera que la fonction et toutes les fonctions qu'il appelle. Vous pouvez avoir plus
d'un -g sur la ligne de commande.

-n nom-fonction
Cela a l'effet inverse de -l. La fonction donnée avec le -n l'option ne sera pas
tracé. Ceci est prioritaire, c'est-à-dire si vous incluez la même fonction pour les deux -n
et -l, il ne sera pas tracé.

-d
Certains plugins de traceur activent la fonction traceur par défaut. Comme les traceurs de latence.
Cette option empêche l'activation de la fonction traceur au démarrage.

-D
L'option -d essaiera d'utiliser l'option function-trace pour désactiver le traceur de fonction
(si disponible), sinon il s'agit par défaut du fichier proc :
/proc/sys/kernel/ftrace_enabled, mais ne le touchera pas si l'option function-trace est
disponible. le -D L'option désactivera à la fois le fichier proc ftrace_enabled ainsi que le
l'option de trace de fonction si elle existe.

Notez que cette fonction de désactivation du traçage pour tous les utilisateurs, y compris les utilisateurs
en dehors des traceurs ftrace (stack_tracer, perf, etc.).

-O option
Ftrace a diverses options qui peuvent être activées ou désactivées. Cela vous permet de définir
eux. Ajout du texte aucune à une option la désactive. Par exemple : "-O nograph-time"
désactivera l'option Ftrace "graph-time".

-s intervalle
Les processus créés par trace-cmd pour enregistrer à partir de la mémoire tampon en anneau doivent se réveiller pour
faire l'enregistrement. Réglage de la intervalle à zéro provoquera le réveil des processus
chaque fois que de nouvelles données sont écrites dans le tampon. Mais puisque Ftrace enregistre le noyau
activité, l'acte de ce processus de se rendormir peut provoquer de nouveaux événements dans le
tampon en anneau qui réactivera le processus. Cela ajoutera inutilement des données supplémentaires
dans le tampon annulaire.

La métrique "d'intervalle" est en microsecondes. La valeur par défaut est de 1000 (1 ms).
Il s'agit de la durée pendant laquelle chaque processus d'enregistrement se mettra en veille avant de se réveiller
enregistrer toutes les nouvelles données qui ont été écrites dans la mémoire tampon en anneau.

-r priorité
La priorité à laquelle exécuter les threads de capture. Dans un système occupé, la capture de trace
les threads peuvent être bloqués et les événements peuvent être perdus. Cela augmente la priorité de ceux
threads à la priorité temps réel (FIFO). Mais utilisez cette option avec précaution, elle peut aussi
modifier le comportement du système tracé.

-b longueur du câble
Cela définit la taille de la mémoire tampon d'anneau à longueur du câble kilo-octets. Parce que le tampon en anneau Ftrace est
par CPU, cette taille est la taille de chaque tampon en anneau par CPU à l'intérieur du noyau. À l'aide de
"-b 10000" sur une machine avec 4 CPU fera que Ftrace aura une taille de tampon totale de 40
Meg.

-B nom-tampon
Si le noyau prend en charge plusieurs tampons, cela ajoutera un tampon avec le nom donné.
Si le nom du tampon existe déjà, ce tampon est simplement réinitialisé et ne sera pas supprimé
à la fin de l'exécution de l'enregistrement. Si le tampon est créé, il sera supprimé au
fin d'exécution (à moins que le -k est défini, ou Commencer commande a été utilisée).

Une fois qu'un nom de tampon est indiqué, tous les événements ajoutés après cela seront
associé à ce tampon. Si aucun tampon n'est spécifié, ou un événement
est spécifié avant un nom de tampon, il sera associé au
tampon principal (de niveau supérieur).

trace-cmd record -e sched -B block -e block -B time -e timer sleep 1

Ce qui précède activera tous les événements planifiés dans le tampon principal. Ce sera
puis créez une instance de tampon « bloc » et activez tous les événements de bloc dans
ce tampon. Une instance de tampon « temps » est créée et tous les événements de minuterie
sera activé pour cet événement.

-m longueur du câble
La taille maximale en kilo-octets qu'un tampon par processeur devrait être. Remarque, en raison de l'arrondi à
taille de la page, le nombre peut ne pas être tout à fait correct. En outre, cela est effectué en commutant
entre deux tampons qui sont la moitié de la taille donnée donc la sortie peut ne pas être de la
taille donnée même si beaucoup plus a été écrit.

Utilisez-le pour éviter de manquer d'espace disque pour les longs trajets.

-M cpmasque
Définissez le cpmask pour tracer. Cela n'affecte que la dernière instance de tampon donnée. Si
fourni avant toute instance de tampon, il affecte alors le tampon principal. La valeur
fourni doit être un nombre hexadécimal.

trace-cmd record -p fonction -M c -B events13 -e all -M 5

Si le -M est omis, le masque reste le même. Pour activer tous
CPU, transmettez une valeur de '-1'.

-k
Par défaut, lorsque trace-cmd a terminé le traçage, il réinitialisera les tampons et désactivera
tout le traçage qu'il a permis. Cette option empêche trace-cmd de désactiver le traceur
et réinitialiser le tampon. Cette option est utile pour déboguer trace-cmd.

Remarque : généralement, trace-cmd remettra le fichier "tracing_on" à ce qu'il
était avant qu'il ne soit appelé. Cette option laissera ce fichier à zéro.

-i
Par défaut, si un événement est répertorié que trace-cmd ne trouve pas, il se terminera avec un
Erreur. Cette option ignorera simplement les événements répertoriés sur la ligne de commande mais qui sont
introuvable sur le système.

-N port hôte
Si une autre machine exécute "trace-cmd listen", cette option est utilisée pour que les données
envoyé à cette machine avec des paquets UDP. Au lieu d'écrire dans un fichier de sortie, les données
est envoyé à une boîte distante. C'est idéal pour les machines embarquées avec peu de stockage,
ou avoir une seule machine qui conservera toutes les données dans un seul référentiel.

Remarque : Cette option n'est pas prise en charge avec les plugins de suivi de latence :
wakeup, wakeup_rt, irqsoff, preemptoff et preemptirqsoff

-t
Cette option est utilisée avec -N, lorsqu'il est nécessaire d'envoyer les données en direct avec TCP
paquets au lieu d'UDP. Bien que TCP ne soit pas aussi rapide que l'envoi des paquets UDP,
mais cela peut être nécessaire si le réseau n'est pas si fiable, la quantité de données n'est pas
aussi intensif, et une garantie est nécessaire que toutes les informations tracées sont transférées
avec succès.

--Date
Avec la collection --Date option, "trace-cmd" écrira les horodatages dans le tampon de trace après
il a fini d'enregistrer. Il mappera ensuite l'horodatage sur gettimeofday qui
autoriser la sortie de l'heure du mur à partir des horodatages en lisant le trace.dat fichier.

--profil
Avec la collection --profil option, "trace-cmd" activera le traçage qui peut être utilisé avec
trace-cmd-rapport(1) --option de profil. Si un traceur -p n'est pas défini, et le graphique de fonction
profondeur est pris en charge par le noyau, alors le traceur function_graph sera activé avec
une profondeur de un (afficher uniquement où l'espace utilisateur entre dans le noyau). Il permettra également
divers points de trace avec traçage de pile de sorte que le rapport puisse montrer où les tâches ont
été bloqué le plus longtemps.

See trace-cmd-profil(1) pour plus de détails et d'exemples.

-H crochets d'événement
Ajoutez une correspondance d'événements personnalisée pour connecter deux événements ensemble. Lorsqu'il n'est pas utilisé avec
--profil, il enregistrera le paramètre et celui-ci sera utilisé par le rapport trace-cmd
--profil aussi. C'est-à-dire:

enregistrement trace-cmd -H hrtimer_expire_entry,hrtimer/hrtimer_expire_exit,hrtimer,sp
rapport trace-cmd --profile

Profilera hrtimer_expire_entry et hrtimer_expire_ext fois.

See trace-cmd-profil(1) pour le format.

--stderr
Avoir la sortie vers stderr au lieu de stdout, mais la sortie de la commande exécutée
ne sera pas modifié. Ceci est utile si vous souhaitez surveiller la sortie de la commande
en cours d'exécution, mais ne voit pas la sortie de trace-cmd.

EXEMPLES

La méthode de base pour tracer tous les événements :

# trace-cmd record -e all ls > /dev/null
# rapport trace-cmd
trace-cmd-13541 [003] 106260.693809 : filemap_fault : adresse=0x128122 décalage=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

Pour utiliser la fonction traceur avec sched switch tracing :

# trace-cmd record -p function -e sched_switch ls > /dev/null
# rapport trace-cmd
ls-13587 [002] 106467.860310 : fonction : 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 : fonction : native_set_pte_at <-- __do_fault
trace-cmd-13586 [003] 106467.860314 : fonction : up_read <-- do_page_fault
ls-13587 [002] 106467.860317 : fonction : __phys_addr <-- schedule
trace-cmd-13585 [001] 106467.860318 : fonction : _raw_spin_unlock <-- __do_fault
ls-13587 [002] 106467.860320 : fonction : native_load_sp0 <-- __switch_to
trace-cmd-13586 [003] 106467.860322 : fonction : down_read_trylock <-- do_page_fault

Voici un bon moyen de trouver quelles interruptions ont la latence la plus élevée :

# trace-cmd record -p function_graph -e irq_handler_entry -l do_IRQ sleep 10
# rapport trace-cmd
-0 [000] 157412.933969 : funcgraph_entry : | do_IRQ() {
-0 [000] 157412.933974 : irq_handler_entry : irq=48 nom=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 nom=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 nom=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 nom=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 nom=eth0
-0 [000] 157417.888398 : funcgraph_exit : + 25.943 us | }

Un exemple de profil :

# enregistrement trace-cmd --profile sleep 1
# rapport trace-cmd --profile --comm sleep
tâche : sommeil-21611
Événement : sched_switch:R (1) Total : 99442 Moyenne : 99442 Max : 99442 Min :99442
1 total:99442 min:99442 max:99442 moy=99442
=> ftrace_raw_event_sched_switch (0xffffffff8105f812)
=> __horaire (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)
Événement : sched_switch:S (1) Total : 1000506680 Moy : 1000506680 Max : 1000506680 Min : 1000506680
1 total:1000506680 min:1000506680 max:1000506680 moy=1000506680
=> ftrace_raw_event_sched_switch (0xffffffff8105f812)
=> __horaire (0xffffffff8150810a)
=> horaire (0xffffffff815084b8)
=> do_nanosleep (0xffffffff8150b22c)
=> hrtimer_nanosleep (0xffffffff8108d647)
=> SyS_nanosleep (0xffffffff8108d72c)
=> return_to_handler (0xffffffff8150e3c8)
=> tracesys_phase2 (0xffffffff8150c304)
Événement : sched_wakeup : 21611 (1) Total : 30326 Moy : 30326 Max : 30326 Min : 30326
1 total:30326 min:30326 max:30326 moy=30326
=> ftrace_raw_event_sched_wakeup_template (0xffffffff8105f653)
=> ttwu_do_wakeup (0xffffffff810606eb)
=> ttwu_do_activate.constprop.124 (0xffffffff810607c8)
=> try_to_wake_up (0xffffffff8106340a)

Utiliser trace-cmd-record en ligne à l'aide des services onworks.net