Los programas de Linux preguntan al
núcleo
Para hacer algunas cosas para ellos. los
fastidiar
[dieciséis]
El comando revela estas llamadas del sistema. Puedes usarlos para entender cómo funcionan los programas y por qué, a veces, no lo hacen.
El kernel y el sistema llama.
Tan inteligente como lo podrían ser, los programas informáticos no pueden hacer todo por sí mismos. Necesitan hacer que las solicitudes tengan ciertas funciones realizadas para ellos. Estas solicitudes van al kernel de Linux. Por lo general, hay una biblioteca u otra interfaz de software que el programa llama, y la biblioteca realiza la solicitud adecuada, llamada llamada a un sistema al kernel.
Poder ver las llamadas del sistema que se ha realizado un programa y cuáles podrían ayudarlo las respuestas a comprender el funcionamiento interno de los programas que le interesan o que ha escrito. Este es
qué
fastidiar
[dieciséis]
lo hace
. Puede ayudar a solucionar problemas y buscar cuellos de botella.
Esto no es lo mismo que
depurar una aplicación
con una herramienta como
GDB
[dieciséis]
. Un programa de depuración le permite investigar la operación interna de un programa a medida que se ejecuta. Le permite pasar por la lógica de su programa e inspeccione los valores de memoria y variables. En comparación, qué
fastidiar
[dieciséis]
¿Captura la información de llamadas del sistema a medida que se ejecuta el programa? Cuando el programa trazado termina,
fastidiar
[dieciséis]
Enumera la información de llamadas del sistema a la ventana del terminal.
Las llamadas del sistema proporcionan todo tipo de funcionalidades de bajo nivel, como las acciones de lectura y escritura en archivos, matando procesos, etc. Hay una lista de cientos de llamadas del sistema en el Página de hombre de syscalls .
RELACIONADO: Depuración con GDB: Comenzar
Instalación de ruinas
Si
fastidiar
[dieciséis]
ya no está instalado en su computadora, puede instalarlo con mucha facilidad.
En Ubuntu, use este comando:
Sudo APT Instale Strace
En Fedora, escriba este comando:
Sudo DNF Instale Strace
En MANJARO, el comando es:
Sudo de Sudo Pacman-Strace
Primeros pasos con Strace
Usaremos un pequeño programa para demostrar.
fastidiar
[dieciséis]
. No hace mucho: abre un archivo y le escribe una línea de texto, y no tiene ninguna revisión de errores. Es solo un truco rápido para que tengamos algo que usar con
fastidiar
[dieciséis]
.
#include & lt; stdio.h & gt;
INT principal (int argc, char argv []) {
// manija de archivo
Archivo * filegeek;
// Abrir un archivo llamado "strace_demo.txt", o crealo
filegeek = fopen ("strace_demo.txt", "w");
// escribe un poco de texto al archivo
FPRINTF (FileGeek, "Escribe esto al archivo");
// cerrar el archivo
fclose (filegeek);
// Salir del programa
retorno (0);
} // FIN DE PRINCIPAL
Guardamos esto en un archivo llamado "File-IO.C" y lo compilamos con
gcc
[dieciséis]
en un ejecutable llamado
Stex
[dieciséis]
, nombrado para "
S t
raza
ex
amplio."
GCC -O STEX FILE-IO.C
Llamaremos
fastidiar
[dieciséis]
Desde la línea de comandos y transfiera el nombre de nuestro nuevo ejecutable como el proceso que queremos haber trazado. Podríamos simplemente rastrear cualquiera de los comandos de Linux o cualquier otro ejecutable binario. Estamos usando nuestro pequeño programa por dos razones.
La primera razón es que
fastidiar
[dieciséis]
es verboso. Puede haber mucha salida. Eso es genial cuando estás usando
fastidiar
[dieciséis]
Enojado, pero puede ser abrumador al principio. Hay limitado
fastidiar
[dieciséis]
Salida para nuestro pequeño programa. La segunda razón es que nuestro programa tiene una funcionalidad limitada, y el código fuente es corto y sencillo. Esto facilita la identificación de qué secciones de la salida se refieren a las diferentes partes del funcionamiento interno del programa.
Strace ./stex
Podemos ver claramente el
escribir
[dieciséis]
Llamada del sistema Enviando el texto "Escriba esto al archivo" a nuestro archivo abierto y el
exit_group
[dieciséis]
llamada del sistema. Esto termina todos los hilos en la aplicación y envía un valor de retorno a la cáscara.
Filtrando la salida
Incluso con nuestro simple programa de demostración, hay una gran cantidad de salida. Podemos usar el
-mi
[dieciséis]
Opción (expresión). Pasaremos en el nombre de la llamada del sistema que queremos ver.
Strace -e write ./stex
Puede informar sobre múltiples llamadas del sistema agregándolas como una lista separada por comas. No incluya ningún espacio en blanco en la lista de llamadas del sistema.
Strace -e Cierre, escribe ./stex
Enviando la salida a un archivo.
El beneficio de filtrar la salida es también el problema con el filtrado de la salida. Ves lo que has pedido ver, pero no ves nada más. Y parte de esa otra salida podría ser más útil para usted que las cosas que le pedimos ver.
A veces, es más conveniente capturar todo y buscar y desplazarse por todo el conjunto de resultados. De esa manera, no excluirás accidentalmente nada importante. los
-o
[dieciséis]
(Salida) La opción le permite enviar la salida de un
fastidiar
[dieciséis]
Sesión a un archivo de texto.
Strace -O Trace-Output.TXT ./stex
Puedes entonces
utilizar el
menos
[dieciséis]
mando
Para desplazarse por el listado y busque llamadas del sistema, o cualquier otra cosa, por nombre.
Menos Trace-Output.TXT
Ahora puedes usar todo
menos
[dieciséis]
Las capacidades de búsqueda para investigar la salida.
RELACIONADO: Cómo usar el mando menos en Linux
Añadiendo marcas de tiempo
Puede agregar varias marcas de tiempo diferentes a la salida. los
-R
[dieciséis]
La opción (marcas de tiempo relativa) agrega marcas de tiempo que muestran la diferencia de tiempo entre el inicio de cada llamada de sistema sucesivo. Tenga en cuenta que estos valores de tiempo incluirán el tiempo empleado en la llamada del sistema anterior y cualquier otra cosa que el programa esté realizando antes de la siguiente llamada del sistema.
Strace -R ./stex
Las marcas de tiempo se muestran al inicio de cada línea de salida.
Para ver la cantidad de tiempo empleado en cada llamada del sistema, use el
-T
[dieciséis]
Opción (Syscall-Times). Esto muestra la duración del tiempo pasado dentro de cada llamada del sistema.
Strace -t ./stex
Las duraciones de tiempo se muestran al final de cada línea de llamada del sistema.
Para ver la hora a la que se llamó cada llamada del sistema, use el
-tt
[dieciséis]
Opción (marcas de tiempo absoluta). Esto muestra el tiempo de "reloj de pared", con una resolución de microsegundidad.
Strace -tt ./stex
Los tiempos se muestran al inicio de cada línea.
Trazando un proceso de funcionamiento
Si el proceso que desea rastrear ya está funcionando, todavía puede adjuntar
fastidiar
[dieciséis]
lo. Para hacerlo, necesita conocer el ID de proceso. Usted puede
usar
PD
[dieciséis]
con
grete
[dieciséis]
para encontrar esto. Tenemos Firefox corriendo. Para averiguar el id de la
firefox
[dieciséis]
proceso, podemos usar
PD
[dieciséis]
y
pídalo a través de
grete
[dieciséis]
.
PS -E | grep firefox
Podemos ver que el ID de proceso es 8483. Usaremos el
-pag
[dieciséis]
Opción (ID de proceso) para contar
fastidiar
[dieciséis]
en qué proceso se adjunte. Tenga en cuenta que deberá usar
sudo
[dieciséis]
:
Sudo Strace -P 8483
Verás una notificación que
fastidiar
[dieciséis]
Se ha unido al proceso, y luego las llamadas de seguimiento del sistema se mostrarán en la ventana del terminal como de costumbre.
Creando un informe
los
-C
[dieciséis]
(SOLO RESUMEN) Causas de opción
fastidiar
[dieciséis]
para imprimir un informe. Genera una tabla para obtener información sobre las llamadas del sistema que fueron hechas por el programa trazado.
Strace -C ./stex
Las columnas son:
- % tiempo : El porcentaje del tiempo de ejecución que se gastó en cada llamada del sistema.
- segundos : El tiempo total expresado en segundos y microsegundos gastados en cada llamada del sistema.
- USECS / Llamada : El tiempo promedio en microsegundos gastados en cada llamada del sistema.
- llamadas : Se ejecutó el número de veces que se ejecutó cada llamada de sistema.
- errores : El número de fallas para cada llamada del sistema.
- syscall : El nombre de la llamada del sistema.
Estos valores mostrarán ceros para programas triviales que se ejecuten y terminan rápidamente. Los valores del mundo real se muestran para programas que hacen algo más significativo que nuestra aplicación de demostración.
Perspectivas profundas, fácilmente
los
fastidiar
[dieciséis]
La salida puede mostrarle qué llamadas del sistema se están realizando, cuáles se están realizando repetidamente y cuánto tiempo de ejecución se está gastando dentro del código del lado del kernel. Esa es una gran información. A menudo, cuando está tratando de entender lo que está pasando dentro de su código, es fácil olvidar que su binario está interactuando casi sin parar con el kernel para realizar muchas de sus funciones.
Mediante el uso
fastidiar
[dieciséis]
, Ves la foto completa.
