Come trovare quale processo sta uccidendo mysqld con SIGKILL o SIGTERM su Linux

Per determinare quale processo sta inviando il segnale a mysqld, è necessario tracciare i segnali attraverso il kernel Linux. Due opzioni per farlo sono:

1. il registro di controllo (auditd)
2. tocca sistema

Ciascuno di questi metodi sarà discusso nelle sezioni seguenti.

Registro di controllo

Il registro di controllo è semplice da configurare, ma non fornisce un controllo dettagliato di quali processi e segnali vengono monitorati; tutto è incluso. Quindi il registro può diventare piuttosto rumoroso, quindi si consiglia di disabilitare il monitoraggio non appena il processo è stato determinato. I passaggi sono:

1. Configura auditd per monitorare i segnali. Questo può essere fatto in runtime o tramite il file di configurazione auditd (/etc/audit/audit.rules ). Poiché l'output del registro aggiunto è piuttosto rumoroso (registra tutti i segnali anche kill -0, ovvero verifica se un processo è attivo) e la modifica viene apportata per eseguire il debug di un singolo problema, di solito è preferibile apportare la modifica in fase di esecuzione. Lo fai con il comando:

 auditctl -a exit,always -F arch=b64 -S kill -k audit_kill

2. Attendi che mysqld venga ucciso/spento dal segnale.

3. Interrompere nuovamente le chiamate del segnale di registrazione auditd, la cosa più semplice è riavviarlo (se hai aggiunto una regola nel file di configurazione, dovrai prima rimuovere la regola):

# service auditd restart

Il file di registro (di solito /var/log/audit.log ) ora dovrebbe avere un evento simile a:

type=SYSCALL msg=audit(1450214919.813:148): arch=c000003e syscall=62 success=yes exit=0 a0=f60 a1=9 a2=7f736e706980 a3=0 items=0 ppid=3649 pid=3997 auid=500 uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=pts3 ses=1 comm="mykill" exe="/opt/bin/mykill" subj=user_u:system_r:unconfined_t:s0 key="audit_kill"
type=OBJ_PID msg=audit(1450214919.813:148): opid=3936 oauid=500 ouid=102 oses=1 obj=user_u:system_r:mysqld_t:s0 ocomm="mysqld"

Le parti importanti sono:

Generale:

msg=audit(1450214919.813:148) :il timestamp dell'evento. Questo è in epoca (tempo dal 1 gennaio 1970 a mezzanotte UTC). Puoi ad es. usa la funzione FROM_UNIXTIME() in MySQL per convertirlo in una data normale:

mysql> SELECT FROM_UNIXTIME(1450214919);
+---------------------------+
| FROM_UNIXTIME(1450214919) |
+---------------------------+
| 2015-12-16 08:28:39       |
+---------------------------+
1 row in set (0.05 sec)

digitare=SYSCALL

Informazioni sull'attivazione della syscall.

syscall=62 :significa che è un segnale (uccidi):

# ausyscall 62
kill

a1=9 :significa che il segnale è SIGKILL (per un segnale SIGTERM, il valore è 15).
comm=”mykill” exe=”/opt/bin/mykill” :è il processo che invia il segnale:questo è ciò che ti interessa.
key="audit_kill" :è l'opzione "-k audit_kill" dal comando auditctl. Dice semplicemente che l'evento è stato attivato dalla regola che abbiamo aggiunto.

tipo=OBJ_PID

Informazioni sulla destinazione della syscall.

opid=3936 :è l'id del processo (come quello che vedi in alto o l'output ps) del processo che riceve il segnale.
ouid=102 :l'id utente dell'utente che esegue il processo (come nell'id da /etc/passwd).
ocomm=”mysqld” :il nome del processo.

Quindi devi cercare un evento con type=SYSCALL con a1=9 e key=”audit_kill” dove il seguente oggetto ha ocomm=”mysqld”.

premi sistema

systemtap richiede uno script che specifichi cosa dovrebbe essere monitorato e cosa dovrebbe essere fatto con le informazioni disponibili. Questo lo rende più complesso da usare, ma consente anche una maggiore flessibilità. Uno script di esempio che monitorerà l'invio di SIGKILL e SIGTERM al processo mysqld è:

#! /usr/bin/env stap
#
# This systemtap script will monitor for SIGKILL and SIGTERM signals send to
# a process named "mysqld".
#

probe signal.send {
  if (
    (sig_name == "SIGKILL" || sig_name == "SIGTERM")
    && pid_name == "mysqld"
  ) {
    printf("%10d   %-34s   %-10s   %5d   %-7s   %s\n",
      gettimeofday_s(), tz_ctime(gettimeofday_s()),
      pid_name, sig_pid, sig_name, execname());
  }
}

probe begin {
  printf("systemtap script started at: %s\n\n", tz_ctime(gettimeofday_s()));
  printf("%50s%-18s\n",
    "",  "Signaled Process");
  printf("%-10s   %-34s   %-10s   %5s   %-7s   %s\n",
    "Epoch", "Time of Signal", "Name", "PID", "Signal", "Signaling Process Name");
  printf("---------------------------------------------------------------");
  printf("---------------------------------------------------------------");
  printf("\n");
}

probe end {
  printf("\n");
}

Nota :Lo script sopra è inteso come esempio. Si prega di testare su un sistema di prova prima di utilizzarlo in produzione.

Salva lo script in un file (di seguito presuppone che il nome del file sia mysqld_kill_or_term.stp). L'utilizzo è:

# stap mysqld_kill_or_term.stp
systemtap script started at: Fri Dec 18 13:35:44 2015 AEDT

                                                  Signaled Process
Epoch        Time of Signal                       Name           PID   Signal    Signaling Process Name
------------------------------------------------------------------------------------------------------------------------------
1450406150   Fri Dec 18 13:35:50 2015 AEDT        mysqld       21578   SIGKILL   mykill
1450406161   Fri Dec 18 13:36:01 2015 AEDT        mysqld       21942   SIGKILL   mykill
1450406171   Fri Dec 18 13:36:11 2015 AEDT        mysqld       22045   SIGTERM   mykill
^C