25.4. Utiliser DTrace

Avant d'utiliser DTrace, il faut que le périphérique DTrace existe. Pour charger le périphérique, exécutez la commande suivante:

# kldload dtraceall

Le système devrait maintenant supporter DTrace. Pour afficher toutes les sondes, l'administrateur peut maintenant executer la commande:

# dtrace -l | more

Toutes les données sortantes de cette commande sont passées à l'utilitaire more, pour empêcher qu'elles saturent l'écran. A ce niveau, DTrace peut être considéré comme fonctionnel. On est maintenant prêt à passer en revue l'ensemble des outils disponibles.

La boîte à outils est une collection de scripts prêts à fonctionner avec DTrace pour rassembler des informations systèmes. Il y a des scripts pour vérifier les fichiers ouvertes, la mémoire, l'usage du CPU et beaucoup plus. Il faut extraire les scripts avec la commande suivante:

# gunzip -c DTracetoolkit* | tar xvf -

Aller dans ce répértoire en utilisant cd et changer les permissions de tous les fichiers, les fichiers avec les noms en miniscules, à 755.

Chacun de ces scripts devra avoir son contenu modifié. Ceux qui font référence à /usr/bin/ksh devront pointer sur /usr/local/bin/ksh, les autres qui utilisent /usr/bin/sh devront être modifiés pour qu'ils utilisent /bin/sh, et finalement ceux qui utilisent /usr/bin/perl, devront pointer sur /usr/local/bin/perl.

Important:

A ce point il est prudent de rappeler au lecteur que le support de DTrace sous FreeBSD n'est pas complet et est encore expérimental. Un bon nombre de ces scripts ne fonctionneront pas, soit parce qu'ils sont trop spécifiques à Solaris™, soit parce qu'ils utilisent des sondes qui ne sont pas encore supportées.

Au moment de l'écriture de ces lignes, seuls deux des scripts de la boîte à outils DTrace sont totalement supportés sous FreeBSD: les outils hotkernel et procsystime. Ce sont ces deux outils que nous détaillerons dans la suite de cette section.

L'outil hotkernel est censé identifier quel fonction utilise le plus de temps noyau. Fonctionnant normalement, il affichera une liste comparable à la suivante:

# ./hotkernel
Sampling... Hit Ctrl-C to end.

L'administrateur système doit utiliser la combinaison de touches Ctrl+C pour arrêter le processus. Le script affichera une liste de fonctions du noyau et des informations de temps, et les triera dans l'ordre croissant du temps consommé:

kernel`_thread_lock_flags                                   2   0.0%
0xc1097063                                                  2   0.0%
kernel`sched_userret                                        2   0.0%
kernel`kern_select                                          2   0.0%
kernel`generic_copyin                                       3   0.0%
kernel`_mtx_assert                                          3   0.0%
kernel`vm_fault                                             3   0.0%
kernel`sopoll_generic                                       3   0.0%
kernel`fixup_filename                                       4   0.0%
kernel`_isitmyx                                             4   0.0%
kernel`find_instance                                        4   0.0%
kernel`_mtx_unlock_flags                                    5   0.0%
kernel`syscall                                              5   0.0%
kernel`DELAY                                                5   0.0%
0xc108a253                                                  6   0.0%
kernel`witness_lock                                         7   0.0%
kernel`read_aux_data_no_wait                                7   0.0%
kernel`Xint0x80_syscall                                     7   0.0%
kernel`witness_checkorder                                   7   0.0%
kernel`sse2_pagezero                                        8   0.0%
kernel`strncmp                                              9   0.0%
kernel`spinlock_exit                                       10   0.0%
kernel`_mtx_lock_flags                                     11   0.0%
kernel`witness_unlock                                      15   0.0%
kernel`sched_idletd                                       137   0.3%
0xc10981a5                                              42139  99.3%

Ce script fonctionnera aussi avec des modules de noyau. Pour utiliser ce fonction, exécutez le script avec l'option -m:

# ./hotkernel -m
Sampling... Hit Ctrl-C to end.
^C
MODULE                                                  COUNT   PCNT
0xc107882e                                                  1   0.0%
0xc10e6aa4                                                  1   0.0%
0xc1076983                                                  1   0.0%
0xc109708a                                                  1   0.0%
0xc1075a5d                                                  1   0.0%
0xc1077325                                                  1   0.0%
0xc108a245                                                  1   0.0%
0xc107730d                                                  1   0.0%
0xc1097063                                                  2   0.0%
0xc108a253                                                 73   0.0%
kernel                                                    874   0.4%
0xc10981a5                                             213781  99.6%

Le script procsystime capture et affiche le temps consommé en appels système pour un PID ou un processus donné. Dans l'exemple suivant, un nouvel exemplaire de /bin/csh a été lancé. L'outil procsystime a été exécuté et laissé en attente pendant que quelques commandes été tapées sur les autres incarnations de csh. Voici le résultat de ce test:

# ./procsystime -n csh
Tracing... Hit Ctrl-C to end...
^C

Elapsed Times for processes csh,

         SYSCALL          TIME (ns)
          getpid               6131
       sigreturn               8121
           close              19127
           fcntl              19959
             dup              26955
         setpgid              28070
            stat              31899
       setitimer              40938
           wait4              62717
       sigaction              67372
     sigprocmask             119091
    gettimeofday             183710
           write             263242
          execve             492547
           ioctl             770073
           vfork            3258923
      sigsuspend            6985124
            read         3988049784

Comme indiqué, l'appel système read() semble prendre le plus de temps en nanosecondes, alors que l'appel système getpid() prend très peu de temps.

Ce document, ainsi que d'autres peut être téléchargé sur ftp://ftp.FreeBSD.org/pub/FreeBSD/doc/

Pour toutes questions à propos de FreeBSD, lisez la documentation avant de contacter <questions@FreeBSD.org>.

Pour les questions sur cette documentation, contactez <doc@FreeBSD.org>.