Comment doit-strace-elle être utilisée?

en termes simples, strace trace tous les appels système émis par un programme avec leurs codes de retour. Pensez à des choses comme les opérations de fichier/socket et beaucoup plus obscures.

il est très utile si vous avez une certaine connaissance de travail de C car ici les appels système signifierait plus précisément pour les appels de bibliothèque C standard.

disons que votre programme est /usr/local/bin/toux. Utiliser simplement:

strace /usr/local/bin/cough <any required argument for cough here>

ou

strace -o <out_file> /usr/local/bin/cough <any required argument for cough here>

pour écrire dans "out_file".

toutes les sorties de strace iront à stderr (attention, le volume de celui-ci demande souvent une redirection vers un fichier). Dans les cas les plus simples, votre programme va avorter avec une erreur et vous serez en mesure de voir ce que ses dernières interactions avec le système d'exploitation dans la sortie strace.

pour plus d'informations, veuillez contacter:

man strace

strace répertorie tous les appels système fait par le processus, il est appliqué. Si vous ne savez pas ce système d'appels veux dire, vous ne serez pas en mesure d'obtenir beaucoup de kilométrage de lui.

néanmoins, si votre problème implique des fichiers ou des chemins ou des valeurs d'environnement, exécuter strace sur le programme problématique et rediriger la sortie vers un fichier et ensuite grapper ce fichier pour votre chemin / fichier / chaîne env peut vous aider à voir ce que votre programme est en fait essayer de faire, par opposition à ce que vous attendiez.

Strace se distingue comme un outil pour étudier les systèmes de production où vous ne pouvez pas vous permettre d'exécuter ces programmes sous un débogueur. En particulier, nous avons utilisé strace dans les deux situations suivantes:

• Programme foo semble être dans l'impasse et est devenu insensible. Cela pourrait être une cible pour gdb; cependant, nous n'avons pas toujours eu le code source ou nous avons parfois eu affaire à des langages scriptés qui n'étaient pas simples à exécuter sous un débogueur. Dans ce cas, vous exécutez strace sur un programme déjà en marche et vous obtiendrez la liste des appels système effectués. Ceci est particulièrement utile si vous recherchez une application client/serveur ou une application qui interagit avec une base de données
• Recherche pourquoi un programme est lent. En particulier, nous venions de déménager vers un nouveau système de fichiers distribués et le nouveau débit du système était très lent. Vous pouvez spécifier strace avec l'option '- T' qui indiquera combien de temps a été consacré à chaque appel système. Cela a aidé à déterminer pourquoi le système de fichiers causait des ralentissements.

pour un exemple d'analyse utilisant strace voir ma réponse à cette question .

j'utilise strace tout le temps pour déboguer les problèmes de permission. La technique est la suivante:

$ strace -e trace=open,stat,read,write gnome-calculator

Où gnome-calculator est la commande que vous souhaitez exécuter.

strace-tfp PID va surveiller les appels système du processus PID, nous pouvons donc déboguer/surveiller l'état de notre processus / programme.

Strace peut être utilisé comme outil de débogage, ou comme profileur primitif.

en tant que débogueur, vous pouvez voir comment les appels système donnés ont été appelés, exécutés et ce qu'ils retournent. C'est très important, car cela permet de voir non seulement qu'un programme a échoué, mais aussi pourquoi un programme a échoué. Habituellement, c'est juste le résultat d'un mauvais codage qui ne saisit pas tous les résultats possibles d'un programme. D'autres fois, c'est juste des chemins codés pour les fichiers. Sans strace, tu devines ce qui s'est passé. mal où et comment. Avec strace vous obtenez une décomposition d'un appel de syscall, habituellement juste en regardant une valeur de retour vous dit beaucoup.

Profilage est une autre utilisation. Vous pouvez l'utiliser pour le temps d'exécution de chaque syscalls individuellement, ou comme un agrégat. Bien que cela ne soit peut-être pas suffisant pour régler vos problèmes, cela permettra au moins de réduire considérablement la liste des suspects potentiels. Si vous voyez beaucoup de couples fopen / close sur un seul fichier, vous ouvrez et fermez probablement inutilement des fichiers exécution d'une boucle, au lieu de l'ouvrir et de le fermer à l'extérieur d'une boucle.

Ltrace est le cousin proche de strace, lui aussi très utile. Vous devez apprendre à différencier où le goulot d'étranglement est. Si une exécution totale est de 8 secondes, et que vous passez seulement 0,05 secondes sur les appels système, alors stracing le programme ne va pas vous faire beaucoup de bien, le problème est dans votre code, qui est habituellement un problème de logique, ou le programme doit réellement prendre ce long à exécuter.

le plus gros problème avec strace/ltrace est de lire leur sortie. Si vous ne savez pas comment les appels sont faits, ou du moins les noms des appels/fonctions, il va être difficile de déchiffrer la signification. Savoir ce que les fonctions de retour peuvent également être très bénéfique, en particulier pour les codes d'erreur différents. Alors que c'est une douleur à déchiffrer, ils retournent parfois vraiment une perle de connaissance; une fois que j'ai vu une situation où je suis à court d'inodes, mais pas hors de l'espace libre, donc tous les les services publics ne m'ont pas prévenu, je ne pouvais pas créer un nouveau fichier. La lecture du code d'erreur de la sortie de strace m'a pointé dans la bonne direction.

strace est un bon outil pour apprendre comment votre programme effectue divers appels système (requêtes vers le noyau) et signale également ceux qui ont échoué ainsi que la valeur d'erreur associée à cet échec. Tous les échecs ne sont pas des bogues. Par exemple, un code qui essaie de rechercher un fichier peut obtenir une erreur ENOENT (pas de tel fichier ou répertoire) mais cela peut être un scénario acceptable dans la logique du code.

un bon cas d'utilisation de strace est de déboguer race conditions lors de la création de fichiers temporaires. Par exemple, un programme qui peut créer des fichiers en ajoutant L'identifiant du processus (PID) à une chaîne prédéfinie peut rencontrer des problèmes dans des scénarios multi-threadés. [Un PID+TID (process id + thread id) ou un meilleur appel système tel que mkstemp corrigera cela].

il est également bon pour déboguer les crashs. Vous pouvez trouver cet (mon) article sur les pannes de strace et de débogage utile.

Strace est un outil qui vous indique comment votre application interagit avec votre système d'exploitation.

il le fait en vous disant ce que le système D'exploitation appelle votre application utilise et avec quels paramètres il les appelle.

ainsi, par exemple, vous voyez quels fichiers Votre programme essaie d'ouvrir, et la météo de l'appel réussit.

Vous pouvez déboguer toutes sortes de problèmes avec cet outil. Par exemple, si application dit qu'il ne peut pas trouver bibliothèque que vous savez que vous avez installé vous strace vous dirait où l'application est à la recherche de ce fichier.

Et ce n'est qu'une partie émergée de l'iceberg.

j'ai aimé certaines des réponses où il se lit strace vérifie comment vous interagissez avec votre système d'exploitation.

C'est exactement ce que nous pouvons voir. Les appels système. Si vous comparez strace et ltrace la différence est plus évidente.

$>strace -c cd
Desktop  Documents  Downloads  examples.desktop  Music  Pictures  Public  Templates  Videos
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
  0.00    0.000000           0         7           read
  0.00    0.000000           0         1           write
  0.00    0.000000           0        11           close
  0.00    0.000000           0        10           fstat
  0.00    0.000000           0        17           mmap
  0.00    0.000000           0        12           mprotect
  0.00    0.000000           0         1           munmap
  0.00    0.000000           0         3           brk
  0.00    0.000000           0         2           rt_sigaction
  0.00    0.000000           0         1           rt_sigprocmask
  0.00    0.000000           0         2           ioctl
  0.00    0.000000           0         8         8 access
  0.00    0.000000           0         1           execve
  0.00    0.000000           0         2           getdents
  0.00    0.000000           0         2         2 statfs
  0.00    0.000000           0         1           arch_prctl
  0.00    0.000000           0         1           set_tid_address
  0.00    0.000000           0         9           openat
  0.00    0.000000           0         1           set_robust_list
  0.00    0.000000           0         1           prlimit64
------ ----------- ----------- --------- --------- ----------------
100.00    0.000000                    93        10 total

par contre il y a ltrace qui trace des fonctions.

$>ltrace -c cd
Desktop  Documents  Downloads  examples.desktop  Music  Pictures  Public  Templates  Videos
% time     seconds  usecs/call     calls      function
------ ----------- ----------- --------- --------------------
 15.52    0.004946         329        15 memcpy
 13.34    0.004249          94        45 __ctype_get_mb_cur_max
 12.87    0.004099        2049         2 fclose
 12.12    0.003861          83        46 strlen
 10.96    0.003491         109        32 __errno_location
 10.37    0.003303         117        28 readdir
  8.41    0.002679         133        20 strcoll
  5.62    0.001791         111        16 __overflow
  3.24    0.001032         114         9 fwrite_unlocked
  1.26    0.000400         100         4 __freading
  1.17    0.000372          41         9 getenv
  0.70    0.000222         111         2 fflush
  0.67    0.000214         107         2 __fpending
  0.64    0.000203         101         2 fileno
  0.62    0.000196         196         1 closedir
  0.43    0.000138         138         1 setlocale
  0.36    0.000114         114         1 _setjmp
  0.31    0.000098          98         1 realloc
  0.25    0.000080          80         1 bindtextdomain
  0.21    0.000068          68         1 opendir
  0.19    0.000062          62         1 strrchr
  0.18    0.000056          56         1 isatty
  0.16    0.000051          51         1 ioctl
  0.15    0.000047          47         1 getopt_long
  0.14    0.000045          45         1 textdomain
  0.13    0.000042          42         1 __cxa_atexit
------ ----------- ----------- --------- --------------------
100.00    0.031859                   244 total

bien que j'ai vérifié les manuels plusieurs fois, je n'ai pas trouvé l'origine du nom "151920920 mais il est probable que le système d'appel de trace, puisque c'est évident.

il y a trois plus grosses notes à dire sur strace .

Note 1: Ces deux fonctions strace et ltrace utilisent l'appel système ptrace . Ainsi ptrace appel système est effectivement comment strace fonctionne.

l'appel système ptrace () fournit un moyen par lequel un processus (le "traceur") peuvent observer et de contrôler l'exécution d'un autre processus (le" tracee"), et d'examiner et de changer la mémoire du tracee et inscrire. Il est principalement utilisé pour implémenter le débogage de point de rupture et de traçage des appels système.

Note 2: Il y a différents paramètres que vous pouvez utiliser avec strace , car strace peut être très verbeux. J'aime expérimenter avec -c qui est comme un résumé des choses. Basé sur -c vous pouvez sélectionner un appel système comme -e trace=open où vous ne verrez que cet appel. Cela peut être intéressant si vous examinez quels fichiers seront ouverts pendant la commande que vous traquez. Et bien sûr, vous pouvez utiliser le grep dans le même but, mais notez que vous devez rediriger comme ce 2>&1 | grep etc pour comprendre que les fichiers de configuration sont référencés lorsque la commande a été émise.

Note 3: je trouve cela très remarque importante. Vous n'êtes pas limité à une architecture spécifique. strace va vous épater, puisqu'il peut tracer sur des binaires de différentes architectures.