Determinazione di file specifici responsabili di I / O elevato

Questo è un problema semplice, ma la prima volta che ho mai dovuto risolverlo effettivamente: trovare quali file / inode specifici sono gli obiettivi di più I / O. Mi piacerebbe essere in grado di ottenere una panoramica generale del sistema, ma se devo fornire un PID o un TID, sono d'accordo.

Mi piacerebbe andare senza dover fare un straceprogramma che si apre iotop. Preferibilmente, usando uno strumento nella stessa vena di iotopquello che ordina per file. Posso usare lsofper vedere quali file Mailman ha aperto ma non indica quale file sta ricevendo I / O o quanto.

Ho visto altrove dove è stato suggerito di utilizzare, auditdma preferirei non farlo poiché metterebbe le informazioni nei nostri file di controllo, che utilizziamo per altri scopi e questo sembra un problema che dovrei essere in grado di ricercare in questo modo.

Il problema specifico che ho in questo momento è che le istantanee LVM si riempiono troppo rapidamente. Da allora ho risolto il problema, ma vorrei essere stato in grado di risolverlo in questo modo piuttosto che fare semplicemente uno lssu tutti i descrittori di file aperti /proc/<pid>/fdper vedere quale stava crescendo più velocemente.

Esistono diversi aspetti di questa domanda che sono stati affrontati parzialmente tramite altri strumenti, ma non sembra esserci un unico strumento che fornisca tutte le funzionalità che stai cercando.

iotop

Questo strumento mostra quali processi stanno consumando più I / O. Ma manca opzioni per mostrare nomi di file specifici.

$ sudo iotop
Total DISK READ:       0.00 B/s | Total DISK WRITE:       0.00 B/s
  TID  PRIO  USER     DISK READ  DISK WRITE  SWAPIN     IO>    COMMAND                                                        
    1 be/4 root        0.00 B/s    0.00 B/s  0.00 %  0.00 % init
    2 be/4 root        0.00 B/s    0.00 B/s  0.00 %  0.00 % [kthreadd]
    3 be/4 root        0.00 B/s    0.00 B/s  0.00 %  0.00 % [ksoftirqd/0]
    5 be/4 root        0.00 B/s    0.00 B/s  0.00 %  0.00 % [kworker/u:0]
    6 rt/4 root        0.00 B/s    0.00 B/s  0.00 %  0.00 % [migration/0]
    7 rt/4 root        0.00 B/s    0.00 B/s  0.00 %  0.00 % [watchdog/0]

Per impostazione predefinita, fa ciò che fa regolarmente topper i processi in competizione per il tempo della CPU, ad eccezione dell'I / O del disco. Puoi convincerlo a darti una vista di 30.000 piedi usando l' -ainterruttore in modo che mostri un accumulo per processo, nel tempo.

$ sudo iotop -a
Total DISK READ:       0.00 B/s | Total DISK WRITE:       0.00 B/s
  TID  PRIO  USER     DISK READ  DISK WRITE  SWAPIN     IO>    COMMAND                                                        
  258 be/3 root          0.00 B    896.00 K  0.00 %  0.46 % [jbd2/dm-0-8]
22698 be/4 emma          0.00 B     72.00 K  0.00 %  0.00 % chrome
22712 be/4 emma          0.00 B    172.00 K  0.00 %  0.00 % chrome
 1177 be/4 root          0.00 B     36.00 K  0.00 %  0.00 % cupsd -F
22711 be/4 emma          0.00 B    120.00 K  0.00 %  0.00 % chrome
22703 be/4 emma          0.00 B     32.00 K  0.00 %  0.00 % chrome
22722 be/4 emma          0.00 B     12.00 K  0.00 %  0.00 % chrome

Strumenti i * (inotify, iwatch, ecc.)

Questi strumenti forniscono accesso agli eventi di accesso ai file, tuttavia devono essere indirizzati in modo specifico a directory o file specifici. Quindi non sono così utili quando si tenta di rintracciare un accesso non autorizzato ai file da un processo sconosciuto, durante il debug di problemi di prestazioni.

Inoltre, il inotifyframework non fornisce dettagli sui file a cui si accede. Solo il tipo di accesso, quindi non sono disponibili informazioni sulla quantità di dati spostati avanti e indietro, utilizzando questi strumenti.

iostat

Mostra le prestazioni generali (lettura e scrittura) in base all'accesso a un determinato dispositivo (disco rigido) o partizione. Ma non fornisce alcuna idea di quali file generano questi accessi.

$ iostat -htx 1 1
Linux 3.5.0-19-generic (manny)  08/18/2013  _x86_64_    (3 CPU)

08/18/2013 10:15:38 PM
avg-cpu:  %user   %nice %system %iowait  %steal   %idle
          18.41    0.00    1.98    0.11    0.00   79.49

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
sda
                  0.01     0.67    0.09    0.87     1.45    16.27    37.06     0.01   10.92   11.86   10.82   5.02   0.48
dm-0
                  0.00     0.00    0.09    1.42     1.42    16.21    23.41     0.01    9.95   12.22    9.81   3.19   0.48
dm-1
                  0.00     0.00    0.00    0.02     0.01     0.06     8.00     0.00  175.77   24.68  204.11   1.43   0.00

blktrace

Questa opzione è di livello troppo basso. Manca la visibilità su quali file e / o inode sono accessibili, solo numeri di blocco non elaborati.

$ sudo blktrace -d /dev/sda -o - | blkparse -i -
  8,5    0        1     0.000000000   258  A WBS 0 + 0 <- (252,0) 0
  8,0    0        2     0.000001644   258  Q WBS [(null)]
  8,0    0        3     0.000007636   258  G WBS [(null)]
  8,0    0        4     0.000011344   258  I WBS [(null)]
  8,5    2        1 1266874889.709032673   258  A  WS 852117920 + 8 <- (252,0) 852115872
  8,0    2        2 1266874889.709033751   258  A  WS 852619680 + 8 <- (8,5) 852117920
  8,0    2        3 1266874889.709034966   258  Q  WS 852619680 + 8 [jbd2/dm-0-8]
  8,0    2        4 1266874889.709043188   258  G  WS 852619680 + 8 [jbd2/dm-0-8]
  8,0    2        5 1266874889.709045444   258  P   N [jbd2/dm-0-8]
  8,0    2        6 1266874889.709051409   258  I  WS 852619680 + 8 [jbd2/dm-0-8]
  8,0    2        7 1266874889.709053080   258  U   N [jbd2/dm-0-8] 1
  8,0    2        8 1266874889.709056385   258  D  WS 852619680 + 8 [jbd2/dm-0-8]
  8,5    2        9 1266874889.709111456   258  A  WS 482763752 + 8 <- (252,0) 482761704
...
^C
...
Total (8,0):
 Reads Queued:           0,        0KiB  Writes Queued:           7,       24KiB
 Read Dispatches:        0,        0KiB  Write Dispatches:        3,       24KiB
 Reads Requeued:         0       Writes Requeued:         0
 Reads Completed:        0,        0KiB  Writes Completed:        5,       24KiB
 Read Merges:            0,        0KiB  Write Merges:            3,       12KiB
 IO unplugs:             2           Timer unplugs:           0

Throughput (R/W): 0KiB/s / 510KiB/s
Events (8,0): 43 entries
Skips: 0 forward (0 -   0.0%)

fatrace

Questa è una nuova aggiunta al kernel Linux e una benvenuta, quindi è solo nelle nuove distribuzioni come Ubuntu 12.10. Il mio sistema Fedora 14 era carente Cool.

Fornisce lo stesso accesso che puoi ottenere inotifysenza dover scegliere come target una directory e / o file particolari.

$ sudo fatrace
pickup(4910): O /var/spool/postfix/maildrop
pickup(4910): C /var/spool/postfix/maildrop
sshd(4927): CO /etc/group
sshd(4927): CO /etc/passwd
sshd(4927): RCO /var/log/lastlog
sshd(4927): CWO /var/log/wtmp
sshd(4927): CWO /var/log/lastlog
sshd(6808): RO /bin/dash
sshd(6808): RO /lib/x86_64-linux-gnu/ld-2.15.so
sh(6808): R /lib/x86_64-linux-gnu/ld-2.15.so
sh(6808): O /etc/ld.so.cache
sh(6808): O /lib/x86_64-linux-gnu/libc-2.15.so

Quanto sopra mostra l'ID del processo che sta eseguendo l'accesso al file e quale file sta accedendo, ma non ti dà alcun utilizzo complessivo della larghezza di banda, quindi ogni accesso è indistinguibile da qualsiasi altro accesso.

Quindi che si fa?

L' fatraceopzione mostra la più promettente per FINALMENTE fornire uno strumento in grado di mostrare l'utilizzo aggregato dell'I / O del disco in base ai file a cui si accede, piuttosto che i processi che eseguono l'accesso.

Riferimenti

• fatrace: segnala gli eventi di accesso ai file a livello di sistema
• fatrace - segnala gli eventi di accesso ai file a livello di sistema
• Un'altra nuova ABI per fanotify
• Guida dell'utente di blktrace

Non ho ancora ricevuto una risposta, ma ho scritto questo script (alla fine) e sembra fare quello che voglio. Non l'ho testato su altri sistemi ed è specifico di Linux.

Fondamentalmente si avvolge solo straceper 30 secondi, filtrando le chiamate di sistema relative ai file e fa uno sforzo per eliminare il nome del file. Conta il numero di occorrenze di quel file nel file stracee presenta all'utente un riepilogo impaginato. Non è perfetto, ma il numero di chiamate di sistema a un determinato file potrebbe avere una debole correlazione con quanto I / O sta eseguendo.

Non l'ho testato completamente, ma se non funziona immediatamente, dovrebbe dare alle persone un punto di partenza. Se si rafforza più, può essere consigliabile riscriverlo in un linguaggio di livello superiore come Python .

Se non ricevo una risposta entro una settimana da un modo meno casalingo di farlo (anche se è un altro strumento che conta solo l'I / O di un particolare processo), accetterò questa come la mia risposta per i posteri.

script:

#!/bin/bash

####
# Creates files underneath /tmp
# Requires commands: timeout  strace  stty
####
#
# All commands are GNU unless otherwise stated
#
##########################################################


####
## Initialization
####

outputFile=/tmp/out.$RANDOM.$$
uniqueLinesFile=/tmp/unique.$RANDOM.$$
finalResults=/tmp/finalOutput.txt.$$

if [ $# -ne 1 ]; then
    echo "USAGE: traceIO [PID]" >&2
    exit 2
fi

if ! [[ "$1" =~ ^[0-9]+$ ]]; then
    echo "USAGE: traceIO [PID]" >&2
    echo -e "\nGiven Process ID is not a number." >&2
    exit 2
fi

if [ ! -e /proc/$1 ]; then
    echo "USAGE: traceIO [PID]" >&2
    echo -e "\nThere is no process with $1 as the PID." >&2
    exit 2
fi

if [[ "x$PAGER" == "x" ]]; then

   for currentNeedle in less more cat; do

      which $currentNeedle >/dev/null 2>&1

      if [ $? -eq 0 ]; then
         PAGER=$currentNeedle
         break;
      fi

   done

  if [[ "x$PAGER" == "x" ]]; then

     echo "Please set \$PAGER appropriately and re-run" >&2
     exit 1

  fi

fi

####
## Tracing
####

echo "Tracing command for 30 seconds..."

timeout 30 strace -e trace=file -fvv -p $1 2>&1 | egrep -v -e "detached$" -e "interrupt to quit$" | cut -f2 -d \" > $outputFile

if [ $? -ne 0 ]; then
   echo -e "\nError performing Trace. Exiting"
   rm -f $outputFile 2>/dev/null
   exit 1
fi

echo "Trace complete. Preparing Results..."

####
## Processing
####

sort $outputFile | uniq > $uniqueLinesFile

echo -e "\n--------  RESULTS --------\n\n  #\t Path " > $finalResults
echo -e " ---\t-------" >> $finalResults

while IFS= read -r currentLine; do

   echo -n $(grep -c "$currentLine" "$outputFile")
   echo -e "\t$currentLine"

done < "$uniqueLinesFile" | sort -rn >> $finalResults

####
## Presentation
####

resultSize=$(wc -l $finalResults | awk '{print $1}')
currentWindowSize=$(stty size | awk '{print $1}')

  # We put five literal lines in the file so if we don't have more than that, there were no results
if [ $resultSize -eq 5 ]; then

   echo -e "\n\n No Results found!"

elif [ $resultSize -ge $currentWindowSize ] ; then

   $PAGER $finalResults

else

   cat $finalResults

fi

  # Cleanup
rm -f $uniqueLinesFile $outputFile $finalResults

Puoi usare iwatch usando iWatch

iWatch è molto semplice da usare, supponiamo che tu voglia guardare il cambiamento nel filesystem / etc, devi solo eseguirlo nella console

$ iwatch /etc

e iwatch ti dirà se qualcosa cambia in questa directory. E se vuoi essere avvisato via email:

$ iwatch -m admin@smsgw.local /etc

In questo caso, l'amministratore riceverà una notifica via e-mail (forse puoi usare il tuo account gateway sms, quindi verrai allarmato immediatamente sempre e ovunque). E se si desidera monitorare molte directory delle differenze, è possibile utilizzare un file di configurazione. Questo file di configurazione è un file XML con una struttura facilmente comprensibile.