Cómo utilizar las herramientas de seguimiento del kernel de BCC para el análisis del rendimiento de Linux

Saludos, BCC ya está disponible para Ubuntu y en este artículo le mostraremos su uso extendido de la línea de comandos para rastrear sistemas Linux y monitorear el desempeño. BPF Compiler Collection (BCC) es un conjunto de herramientas para crear herramientas de rastreo del kernel que aprovechan la funcionalidad proporcionada por los filtros de paquetes Berkeley extendidos (BPF) de Linux. BPF garantiza que los programas cargados en el kernel no pueden fallar y no pueden ejecutarse para siempre, pero aún así BPF es lo suficientemente de propósito general para realizar muchos tipos arbitrarios de cálculo. BCC hace que los programas eBPF sean más fáciles de escribir, con instrumentación del kernel en C y un front-end en Python. Es adecuado para muchas tareas, incluido el análisis de rendimiento y el control del tráfico de la red. eBPF mejora el seguimiento de Linux, lo que permite que se ejecuten mini programas en eventos de seguimiento y le permite etiquetar eventos con marcas de tiempo personalizadas, almacenar histogramas, filtrar eventos y emitir información resumida a nivel de usuario. Estas capacidades brindan la información con el menor costo indirecto posible.

Requisitos previos:

Para instalar BCC, se requiere una versión del kernel de Linux 4.1 o más reciente. Si la versión de su kernel es diferente a la versión mencionada, entonces debería haber sido compilado con los siguientes indicadores establecidos en el ‘/boot/config-4.4.0-21-generic’ .

CONFIG_BPF=y
CONFIG_BPF_SYSCALL=y
# [optional, for tc filters]
CONFIG_NET_CLS_BPF=m
# [optional, for tc actions]
CONFIG_NET_ACT_BPF=m
CONFIG_BPF_JIT=y
CONFIG_HAVE_BPF_JIT=y
# [optional, for kprobes]
CONFIG_BPF_EVENTS=y

Instalación de BCC (colección de compiladores BPF) en Ubuntu 16:

En Ubuntu 16.04 es necesario actualizar o cambiar los parámetros del kernel, simplemente ejecute los siguientes comandos para agregar su clave de origen en el repositorio y luego ejecute la actualización del sistema.

# echo "deb [trusted=yes] https://repo.iovisor.org/apt/xenial xenial-nightly main" | sudo tee /etc/apt/sources.list.d/iovisor.list

# apt-get update

Una vez que el sistema se haya actualizado, ejecute el siguiente comando para instalar bcc junto con algunas otras bibliotecas.

# apt-get install binutils bcc bcc-tools libbcc-examples python-bcc

Las herramientas BCC también están disponibles instantáneamente y se pueden instalar rápida y fácilmente con solo usar el siguiente comando en su terminal de línea de comandos.

# snap install --devmode bcc

Una vez completada la instalación, podemos probarla con los siguientes comandos de Python.

# python /usr/share/bcc/examples/hello_world.py

Obtendrá la imagen como se muestra a continuación.

-806 [001] d... 6685.522352: : Hello, World!
-36641 [000] d... 6685.554148: : Hello, World!
-36641 [000] d... 6695.999935: : Hello, World!
-36644 [000] d... 6696.004081: : Hello, World!
-36645 [000] d... 6696.007041: : Hello, World!
-36646 [000] d... 6696.010295: : Hello, World!
-36646 [000] d... 6696.011882: : Hello, World!
-36646 [000] d... 6696.013417: : Hello, World!
-36645 [000] d... 6696.014687: : Hello, World!
-36650 [001] d... 6696.015892: : Hello, World!
-36650 [001] d... 6696.016025: : Hello, World!

# python /usr/share/bcc/examples/tracing/task_switch.py

Usando BCC Tools en Ubuntu:

Actualmente hay alrededor de 70 herramientas BCC disponibles después de su instalación. A continuación, le mostraremos el uso de las herramientas más importantes y los trazados.

1) ardista

Muestra los valores de los parámetros de función como histograma o recuento de frecuencia. Para obtener ayuda detallada sobre el uso de esta herramienta, utilice el siguiente comando.

# argdist -h

Por ejemplo, deseaba pasar un histograma de tamaños de búfer a write ()
función en todo el sistema, ejecute el siguiente comando junto con los parámetros dados.

# ./argdist -c -H 'p:c:write(int fd, void *buf, size_t len):size_t:len'

[17:14:42]
len : count distribution
0 -> 1 : 0 | |
2 -> 3 : 0 | |
4 -> 7 : 0 | |
8 -> 15 : 1 |****************************************|
16 -> 31 : 0 | |
32 -> 63 : 0 | |
64 -> 127 : 1 |****************************************|
[17:14:43]
len : count distribution
0 -> 1 : 0 | |
2 -> 3 : 0 | |
4 -> 7 : 0 | |
8 -> 15 : 2 |******** |
16 -> 31 : 0 | |
32 -> 63 : 1 |**** |
64 -> 127 : 10 |****************************************|
128 -> 255 : 3 |************ |
256 -> 511 : 1 |**** |
[17:14:44]

Muestra que la mayoría de las escrituras se dividen en tres grupos: escrituras muy pequeñas de 2-3 bytes, escrituras medianas de 32-63 bytes y escrituras más grandes de 64-127 bytes.

2) línea de hilo

La herramienta bashreadline imprime comandos bash de todos los shells bash en ejecución en el sistema. Para usar esta herramienta, simplemente ejecute el comando como se muestra a continuación y obtendrá una lista de todos los comandos bash en ejecución.

# ./bashreadline

TIME PID COMMAND
11:28:35 21176 echo hello world
11:28:43 21176 foo this command failed
11:28:45 21176 df -h
11:29:04 3059 echo another shell
11:29:13 21176 echo first shell again

3) biolatencia

La biolatencia rastrea la E / S del dispositivo de bloque (E / S de disco) y registra la distribución de la latencia de E / S (tiempo), imprimiendo esto como un histograma cuando se presiona Ctrl-C.

# ./biolatency

Tracing block device I/O... Hit Ctrl-C to end.
^C
usecs : count distribution
0 -> 1 : 0 | |
2 -> 3 : 0 | |
4 -> 7 : 0 | |
8 -> 15 : 0 | |
16 -> 31 : 0 | |
32 -> 63 : 0 | |
64 -> 127 : 0 | |
128 -> 255 : 0 | |
256 -> 511 : 2 |****************************************|

Para mayor eficiencia, biolatency usa un mapa eBPF en el kernel para almacenar marcas de tiempo con solicitudes y otro mapa en el kernel para almacenar la columna de histograma (el «recuento»), que se copia en el espacio de usuario solo cuando se imprime la salida. Estos métodos reducen la sobrecarga de rendimiento cuando se realiza el seguimiento.

4) biotop

Biotop, abreviatura de block device I / O top, resume qué procesos están realizando E / S de disco. Es superior para discos y mostrará los resultados en el siguiente formato.

# ./biotop

Tracing... Output every 1 secs. Hit Ctrl-C to end

18:33:46 loadavg: 0.00 0.03 0.05 1/303 38817

PID COMM D MAJ MIN DISK I/O Kbytes AVGms
24301 cksum R 202 1 sda 361 28832 3.39
7961 dd R 202 1 sda 1628 13024 0.59

5) biosnop

El biosnoop rastrea la E / S del dispositivo de bloque (E / S de disco) e imprime una línea de salida por E / S. Esto incluye el PID y el comm (nombre del proceso) que estaban en la CPU en el momento de la emisión (que generalmente significa el proceso responsable). La latencia de la E / S del disco, medida desde el problema hasta el dispositivo hasta su finalización, se incluye como la última columna como se muestra a continuación.

# ./biosnoop

TIME(s) COMM PID DISK T SECTOR BYTES LAT(ms)
0.000000000 ? 0 R -1 8 0.26
1.771303000 jbd2/sda1-8 192 sda W 17273608 8192 27.53
1.772083000 jbd2/sda1-8 192 sda W 17273624 4096 0.67
2.047987000 ? 0 R -1 8 0.26
4.095943000 ? 0 R -1 8 0.24
6.144020000 ? 0 R -1 8 0.26
8.191950000 ? 0 R -1 8 0.25
10.239991000 ? 0 R -1 8 0.27
12.288032000 ? 0 R -1 8 0.27
14.336013000 ? 0 R -1 8 0.25
16.384132000 ? 0 R -1 8 0.40
18.431956000 ? 0 R -1 8 0.24
20.479998000 ? 0 R -1 8 0.26
22.527986000 ? 0 R -1 8 0.28
24.576031000 ? 0 R -1 8 0.29
26.623940000 ? 0 R -1 8 0.24
28.671949000 ? 0 R -1 8 0.24
30.719936000 ? 0 R -1 8 0.25
32.767940000 ? 0 R -1 8 0.25

Esta salida de ejemplo es de lo que debería ser un sistema inactivo, sin embargo, lo siguiente es visible en la salida de iostat.

# iostat -x 1

Linux 4.4.0-21-generic (k-vm) 02/01/2017 _x86_64_ (2 CPU)

avg-cpu: %user %nice %system %iowait %steal %idle
0.82 1.20 0.37 0.52 0.00 97.10

Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s avgrq-sz avgqu-sz await r_await w_await svctm %util
loop0 0.00 0.00 0.01 0.00 0.10 0.00 31.32 0.00 0.14 0.14 0.00 0.06 0.00
loop1 0.00 0.00 0.01 0.00 0.03 0.00 11.23 0.00 0.03 0.03 0.00 0.03 0.00
sda 0.02 6.54 1.74 4.65 45.87 214.31 81.50 0.19 30.48 9.25 38.42 2.70 1.72

avg-cpu: %user %nice %system %iowait %steal %idle
0.00 0.00 0.00 0.00 0.00 100.00

Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s avgrq-sz avgqu-sz await r_await w_await svctm %util
loop0 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
loop1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
sda 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00

6) tamaño de un bocado

El objetivo de esta herramienta es mostrar la distribución de E / S para los tamaños de bloque solicitados, por nombre de proceso.

# ./bitesize

Tracing... Hit Ctrl-C to end.
^C
Process Name="jbd2/sda1-8"
Kbytes : count distribution
0 -> 1 : 1 |****************************************|
2 -> 3 : 0 | |
4 -> 7 : 1 |****************************************|
8 -> 15 : 1 |****************************************|

7) capaz

Capable rastrea las llamadas a la función cap_capable () del kernel, que realiza verificaciones de capacidad de seguridad e imprime los detalles de cada llamada.

# ./capable

TIME UID PID COMM CAP NAME AUDIT
19:20:34 0 39820 capable 21 CAP_SYS_ADMIN 1
19:20:34 0 39820 capable 21 CAP_SYS_ADMIN 1
19:21:09 100 6022 systemd-timesyn 12 CAP_NET_ADMIN 1
19:22:09 0 647 systemd-logind 12 CAP_NET_ADMIN 1
19:22:09 0 17302 systemd-udevd 12 CAP_NET_ADMIN 1

El resultado anterior incluye varias comprobaciones de capacidad: snmpd comprobando CAP_NET_ADMIN, ejecute comprobando CAP_SYS_RESOURCES, luego algunos procesos de corta duración
comprobar CAP_FOWNER, CAP_FSETID, etc. Esto puede ser útil para la depuración general y también para la aplicación de seguridad, como determinar una lista blanca de capacidades que necesita una aplicación.

8) cachestat

cachestat se puede utilizar para mostrar una línea de estadísticas resumidas del caché del sistema cada segundo. Esto permite las operaciones de ajuste del sistema al señalar una baja tasa de aciertos de caché y una alta tasa de errores.

# ./cachestat

HITS MISSES DIRTIES READ_HIT% WRITE_HIT% BUFFERS_MB CACHED_MB
0 0 0 0.0% 0.0% 170 2156
3 3 1 33.3% 33.3% 170 2156
0 0 0 0.0% 0.0% 170 2156
0 0 0 0.0% 0.0% 170 2156
0 0 0 0.0% 0.0% 170 2156
0 0 0 0.0% 0.0% 170 2156
0 0 0 0.0% 0.0% 170 2156
^C 0 0 0 0.0% 0.0% 170 2156

9) tapa de caché

cachetop muestra estadísticas de aciertos / errores de caché de páginas de Linux, incluido el porcentaje de aciertos de lectura y escritura por procesos en una interfaz de usuario como top.

# ./cachetop

20:07:24 Buffers MB: 171 / Cached MB: 2156 / Sort: HITS / Order: ascending
PID UID CMD HITS MISSES DIRTIES READ_HIT% WRITE_HIT%
39844 root python 1 0 0 100.0% 0.0%

10) cpudista

Este programa resume el tiempo de la tarea en la CPU como un histograma, que muestra cuánto tiempo pasaron las tareas en la CPU antes de ser desprogramadas. Esto proporciona información valiosa que puede indicar exceso de suscripción (demasiadas tareas para muy pocos procesadores), sobrecarga debido a un cambio de contexto excesivo (por ejemplo, un bloqueo compartido común para varios subprocesos), distribución desigual de la carga de trabajo, tareas demasiado granulares y más.

# ./cpudist

Tracing on-CPU time... Hit Ctrl-C to end.
^C
usecs : count distribution
0 -> 1 : 0 | |
2 -> 3 : 1 | |
4 -> 7 : 3 | |
8 -> 15 : 1 | |
16 -> 31 : 4 | |
32 -> 63 : 2 | |
64 -> 127 : 4 | |
128 -> 255 : 5 | |
256 -> 511 : 9 | |
512 -> 1023 : 24 | |
1024 -> 2047 : 40 | |
2048 -> 4095 : 1615 |****************************************|
4096 -> 8191 : 9

A continuación se muestran algunos otros comandos que puede usar para monitorear la CPU de su sistema.
Para resumir el tiempo fuera de la CPU como un histograma

# ./cpudist -O

Para imprimir resúmenes de 1 segundo, 10 veces

# ./cpudist 1 10

Resúmenes de 1 s, milisegundos y marcas de tiempo

# ./cpudist -mT 1

Para mostrar cada PID por separado.

# ./cpudist -P

Para rastrear solo PID 185

# ./cpudist -p 185

11) dcsnoop

dcsnoop rastrea las búsquedas de la caché de entrada de directorio (dcache) y se puede usar para una investigación adicional más allá de dcstat (8). Es probable que el resultado sea detallado, ya que es probable que las búsquedas de dcache sean frecuentes. De forma predeterminada, solo se muestran las búsquedas fallidas.

# ./dcsnoop

TIME(s) PID COMM T FILE
1.777623 39844 python M meminfo
6.787286 39844 python M meminfo
8.912472 812 irqbalance M interrupts
8.912550 812 irqbalance M stat
11.795628 39844 python M meminfo
16.803827 39844 python M meminfo
18.912481 812 irqbalance M interrupts
18.912570 812 irqbalance M stat
21.812077 39844 python M meminfo
26.820298 39844 python M meminfo
28.912554 812 irqbalance M interrupts
28.912629 812 irqbalance M stat
31.828839 39844 python M meminfo

La salida muestra los procesos, el tipo de evento (columna «T»: M == falta, R == referencia) y el nombre de archivo para la búsqueda de dcache.

12) execsnoop

El execsnoop rastrea nuevos procesos. Por ejemplo, rastrear los comandos invocados al ejecutar «man rm».

# ./execsnoop

La salida muestra el nombre del proceso / comando principal (PCOMM), el PID, el valor de retorno de exec () (RET) y el nombre de archivo con argumentos (ARGS).

13) ext4dist

ext4dist rastrea las lecturas, escrituras, aperturas y fsyncs de ext4, y resume su latencia como un histograma de potencia de 2.

# ./ext4dist

Tracing ext4 operation latency... Hit Ctrl-C to end.
^C
operation = 'read'
usecs : count distribution
0 -> 1 : 44 |****************************************|
2 -> 3 : 20 |****************** |
4 -> 7 : 1 | |

operation = 'write'
usecs : count distribution
0 -> 1 : 0 | |
2 -> 3 : 0 | |
4 -> 7 : 0 | |
8 -> 15 : 2 |****************************************|
16 -> 31 : 1 |******************** |

operation = 'open'
usecs : count distribution
0 -> 1 : 46 |****************************************|
2 -> 3 : 0 | |
4 -> 7 : 2 |* |

La salida muestra una distribución bimodal para la latencia de lectura, con un modo más rápido de menos de 7 microsegundos. La columna de recuento muestra cuántos eventos cayeron en ese rango de latencia. Es probable que el modo más rápido haya sido un éxito de la caché del sistema de archivos en la memoria, y el modo más lento sea una lectura de un dispositivo de almacenamiento (disco). Esta «latencia» se mide desde que se emitió la operación desde la interfaz VFS al sistema de archivos hasta que se completó.

14) ext4slower

La herramienta Ext4slower rastrea operaciones comunes de archivos ext4 como lecturas, escrituras, aperturas y sincronizaciones. Mide el tiempo invertido en estas operaciones e imprime los detalles de cada uno que excedió un umbral.
De forma predeterminada, se utiliza un umbral mínimo de milisegundos de 10. Si se usa un umbral de 0, se imprimen todos los eventos. El archivo síncrono de seguimiento lee y escribe más lento que 10 ms.

#./ext4slower

Para rastrear más lento de 1 ms:

# ./ext4slower 1

Rastree más lento que 1 ms y genere solo los campos en formato analizable (csv), use el siguiente comando.

# ./ext4slower -j 1

Para rastrear todas las lecturas y escrituras de archivos, ejecute a continuación.

# ./ext4slower 0

Rastreo más lento que 1 ms, solo para PID 1182:

# ext4slower -p 1182 1

15) vida de archivo

filelife rastrea archivos de corta duración, aquellos que se han creado y luego eliminado durante el rastreo.

# ./filelife

TIME PID COMM AGE(s) FILE
14:35:01 41399 cron 0.00 tmpfnq6U0D
14:45:01 41403 cron 0.00 tmpf4FoYPW

Esto ha detectado archivos de corta duración que se crearon durante la compilación del kernel de Linux. El PID muestra el ID del proceso que finalmente eliminó el archivo, y COMM
es su nombre de proceso. La columna EDAD (s) muestra la antigüedad del archivo, en segundos, cuando se eliminó. Todos estos son de corta duración y existieron por menos de
una décima de segundo.

16) tapa de archivo

filetop muestra lecturas y escrituras por archivo, con detalles del proceso.

# ./filetop

14:47:25 loadavg: 0.00 0.01 0.05 1/302 41425

TID COMM READS WRITES R_Kb W_Kb T FILE
41425 clear 2 0 8 0 R xterm
812 irqbalance 4 0 4 0 R interrupts
812 irqbalance 4 0 4 0 R stat
41409 filetop 2 0 2 0 R loadavg
41425 clear 1 0 0 0 R libc-2.23.so
41425 clear 1 0 0 0 R libtinfo.so.5.9
41425 filetop 3 0 0 0 R clear
41425 filetop 2 0 0 0 R ld-2.23.so

Esto muestra varios archivos leídos y escritos durante la compilación del kernel de Linux. La salida se ordena por el tamaño total de lectura en Kbytes (R_Kb). Esto se instrumenta en la interfaz VFS, por lo que se trata de lecturas y escrituras que pueden regresar por completo desde la caché del sistema de archivos (caché de página).

17) cuenta funcional

Este programa rastrea funciones, puntos de rastreo o sondas USDT que coinciden con un patrón específico, y cuando se presiona Ctrl-C, imprime un resumen de su recuento.
mientras rastrea. Por ejemplo, rastrear todas las funciones del kernel que comienzan con «vfs_».

# ./funccount 'vfs_*'

Tracing 46 functions for "vfs_*"... Hit Ctrl-C to end.
^C
FUNC COUNT
vfs_statfs 2
vfs_unlink 2
vfs_create 2
vfs_lock_file 4
vfs_writev 90
vfs_fstatat 156
vfs_write 396
vfs_fstat 409
vfs_open 456
vfs_getattr 565
vfs_getattr_nosec 565
vfs_read 1600

Esto es útil para explorar el código del kernel, para averiguar qué funciones están en uso y cuáles no. Esto puede reducir una investigación a unas pocas funciones, cuyos recuentos son similares a la carga de trabajo investigada.

# ./funccount 'tcp_*'

Tracing 276 functions for "tcp_*"... Hit Ctrl-C to end.
^C
FUNC COUNT
tcp_delack_timer_handler 1
tcp_update_pacing_rate 1
tcp_send_delayed_ack 1
tcp_delack_timer 1
tcp_rack_advance 1
tcp_cwnd_restart 2
tcp_queue_rcv 2
tcp_check_space 2
tcp_event_data_recv 2
tcp_push 3
tcp_sendmsg 3
tcp_init_tso_segs 3
tcp_rearm_rto.part.56 4
tcp_release_cb 5
tcp_options_write 5
tcp_v4_md5_lookup 8
tcp_established_options 8
tcp_md5_do_lookup 11
tcp_poll 14

18) no se abre

opensnoop rastrea la llamada al sistema open () en todo el sistema e imprime varios detalles.

# ./opensnoop

PID COMM FD ERR PATH
812 irqbalance 3 0 /proc/interrupts
812 irqbalance 3 0 /proc/stat
812 irqbalance 3 0 /proc/interrupts
812 irqbalance 3 0 /proc/stat
812 irqbalance 3 0 /proc/interrupts
812 irqbalance 3 0 /proc/stat
1 systemd 21 0 /proc/6022/cgroup
1 systemd 21 0 /proc/647/cgroup
1 systemd 21 0 /proc/17302/cgroup
1 systemd 21 0 /proc/225/cgroup
812 irqbalance 3 0 /proc/interrupts
812 irqbalance 3 0 /proc/stat
812 irqbalance 3 0 /proc/interrupts
812 irqbalance 3 0 /proc/stat

Durante el seguimiento, el proceso systemd abrió varios archivos / proc (lectura de métricas) y un proceso de «ejecución» leyó varias bibliotecas y archivos de configuración. opensnoop puede ser útil para descubrir archivos de configuración y de registro, si se usa durante el inicio de la aplicación.

19) pidpersec

Esto muestra el número de nuevos procesos creados por segundo, medidos mediante el seguimiento de la rutina kernel fork ().

# ./pidpersec

Tracing... Ctrl-C to end.
16:27:27: PIDs/sec: 0
16:27:28: PIDs/sec: 0
16:27:29: PIDs/sec: 0
16:27:30: PIDs/sec: 0
16:27:31: PIDs/sec: 0
16:27:32: PIDs/sec: 0
16:27:33: PIDs/sec: 0
16:27:34: PIDs/sec: 0
16:27:35: PIDs/sec: 0
16:27:36: PIDs/sec: 0
16:27:37: PIDs/sec: 0

Cada segundo no hay nuevos procesos (esto pasa a ser causado por un script de inicio que se está reintentando en un bucle y encuentra errores). Cuando ejecute cualquier comando en la otra sesión, verá un aumento en su número de proceso.

20) statsnoop

statsnoop rastrea las diferentes llamadas al sistema stat () en todo el sistema e imprime varios detalles.

# ./statsnoop

PID COMM FD ERR PATH
640 cron 0 0 /etc/localtime
640 cron 0 0 crontabs
640 cron 0 0 /etc/crontab
640 cron 0 0 /etc/cron.d
640 cron 0 0 /etc/cron.d/anacron
640 cron 0 0 /etc/cron.d/popularity-contest
640 cron 0 0 /etc/cron.d/sysstat
640 cron 0 0 /etc/localtime
640 cron 0 0 crontabs
640 cron 0 0 /etc/crontab
640 cron 0 0 /etc/cron.d
640 cron 0 0 /etc/cron.d/anacron
640 cron 0 0 /etc/cron.d/popularity-contest
640 cron 0 0 /etc/cron.d/sysstat

statsnoop se puede utilizar para la depuración general, para ver qué información de archivo se ha solicitado y si esos archivos existen. Se puede utilizar como complemento de opensnoop, que muestra qué archivos se abrieron realmente.

21) syncsnoop

Este programa rastrea las llamadas a la rutina sync () del kernel, con marcas de tiempo básicas.

# ./syncsnoop

TIME(s) CALL
134548.6152 sync()
134151.5339 sync()
^C

Durante el seguimiento, el comando «sync» se ejecutó en otra sesión del servidor. Esto puede ser útil para identificar que se está llamando a sync () y su frecuencia.

22) tcptop

tcptop resume el rendimiento por host y puerto.

# ./tcptop

16:53:21 loadavg: 0.00 0.01 0.05 1/301 41994

PID COMM LADDR RADDR RX_KB TX_KB
36670 sshd 192.168.10.14:22 192.168.9.7:62379 0 0

Este resultado de ejemplo muestra dos listas de conexiones TCP, para IPv4 e IPv6. Si solo hay tráfico para uno de estos, solo se muestra un grupo.

23) rastro

Rastrear funciones arbitrarias, con filtros. rastrea las funciones que usted especifica y muestra mensajes de rastreo si un
se cumple la condición. Puede controlar el formato del mensaje para mostrar argumentos de función y valores de retorno.

Por ejemplo, suponga que desea rastrear todos los comandos que se ejecutan en el sistema.

# ./trace 'sys_execve "%s", arg1'

PID TID COMM FUNC -
42200 42200 bash sys_execve /bin/ls
42201 42201 bash sys_execve /usr/bin/man
42208 42208 man sys_execve /usr/local/sbin/preconv
42208 42208 man sys_execve /usr/local/bin/preconv
42208 42208 man sys_execve /usr/sbin/preconv
42208 42208 man sys_execve /usr/bin/preconv
42212 42212 man sys_execve /usr/local/sbin/pager
42212 42212 man sys_execve /usr/local/bin/pager
42212 42212 man sys_execve /usr/sbin/pager
42212 42212 man sys_execve /usr/bin/pager
42210 42210 man sys_execve /usr/local/sbin/nroff
42210 42210 man sys_execve /usr/local/bin/nroff

La sintaxis :: sys_execve especifica que desea una sonda de entrada (que es la predeterminada), en una función del kernel (que es la predeterminada) llamada sys_execve. A continuación, la cadena de formato para imprimir es simplemente «% s», que imprime una cadena. Finalmente, el valor a imprimir es el primer argumento de la función sys_execve, que resulta ser el comando que se ejecuta. La traza anterior se generó ejecutando «man ls» en un shell separado. Como puede ver, man ejecuta una serie de programas adicionales para finalmente mostrar la página de manual.

24) tcpconnect

Realiza un seguimiento de las conexiones TCP activas (por ejemplo, a través de un connect () syscall) y muestra la latencia (tiempo) de la conexión medida localmente. Esta es una métrica de rendimiento útil que generalmente abarca el procesamiento TCP / IP del kernel y el tiempo de ida y vuelta de la red (no el tiempo de ejecución de la aplicación). Esta herramienta funciona mediante el seguimiento dinámico del kernel de las funciones de TCP / IP y deberá actualizarse para que coincida con los cambios que se realicen en estas funciones. Esta herramienta debe actualizarse en el futuro para usar puntos de rastreo estáticos, una vez que estén disponibles.

Ejecute el siguiente comando para obtener más ayuda sobre su uso.

# ./tcpconnect -h

Conclusión

BCC es uno de los mejores kits de herramientas para rastrear y monitorear el nivel de rendimiento de los sistemas Linux. Proporciona más de 50 herramientas de monitoreo de sistemas y redes que se puede utilizar con diferentes parámetros para rastrear la información requerida en el sistema. BCC viene con una fácil instalación en cualquier sistema Linux, mientras que hay suficientes manuales de soporte disponibles para obtener ayuda sobre las herramientas y técnicas disponibles. Espero que este artículo haya sido de mucha ayuda, comencemos a usarlo en su propio sistema y compartamos su experiencia.