Traccia di programmi eseguiti chiamati da script bash

Question

Uno script non funziona correttamente. Ho bisogno di sapere chi chiama quello script e chi chiama lo script chiamante, e così via, solo modificando lo script non valido.

Questo è simile a uno stack-trace, ma io sono non interessato a uno stack di chiamate di chiamate di funzione all'interno di un singolo script bash. Invece, ho bisogno della catena di programmi/script eseguiti che è stata avviata dal mio script.

Answer 1

Dal momento che dici è possibile modificare lo script stesso, è sufficiente mettere un:

ps -ef >/tmp/bash_stack_trace.$$ 

in esso, in cui si verifica il problema.

Ciò creerà un numero di file nella directory tmp che mostra l'intero elenco di processi nel momento in cui si è verificato.

È quindi possibile calcolare quale processo ha chiamato quale altro processo esaminando questo output. Questo può essere fatto manualmente o automatizzata con qualcosa di simile awk, poiché l'uscita è regolare -. Basta usare quei PID e PPID colonne di capire le relazioni tra tutti i processi a cui siete interessati

Avrete è necessario tenere d'occhio i file, dal momento che ne avrai uno per processo in modo da poterli gestire. Poiché questo è qualcosa che dovrebbe essere fatto solo durante il debug, la maggior parte delle volte quella linea sarà commentata (preceduta da #), quindi i file non verranno creati.

Per pulirli, si può semplicemente fare:

rm /tmp/bash_stack_trace.* 

Answer 2

aggiungendo pstree -p -u ` whoami ` >> uscita nello script sarà probabilmente ottenere le informazioni necessarie.

Answer 3

~$ help caller 
caller: caller [EXPR] 
    Returns the context of the current subroutine call. 

    Without EXPR, returns "$line $filename". With EXPR, 
    returns "$line $subroutine $filename"; this extra information 
    can be used to provide a stack trace. 

    The value of EXPR indicates how many call frames to go back before the 
    current one; the top frame is frame 0. 

Answer 4

Si potrebbe provare qualcosa di simile

strace -f -e execve script.sh 

Answer 5

Un semplice script che ho scritto qualche giorno fa ...

# FILE  : sctrace.sh 
# LICENSE : GPL v2.0 (only) 
# PURPOSE : print the recursive callers' list for a script 
#    (sort of a process backtrace) 
# USAGE  : [in a script] source sctrace.sh 
# 
# TESTED ON : 
# - Linux, x86 32-bit, Bash 3.2.39(1)-release 

# REFERENCES: 
# [1]: http://tldp.org/LDP/abs/html/internalvariables.html#PROCCID 
# [2]: http://linux.die.net/man/5/proc 
# [3]: http://linux.about.com/library/cmd/blcmdl1_tac.htm 

#! /bin/bash 

TRACE="" 
CP=$$ # PID of the script itself [1] 

while true # safe because "all starts with init..." 
do 
     CMDLINE=$(cat /proc/$CP/cmdline) 
     PP=$(grep PPid /proc/$CP/status | awk '{ print $2; }') # [2] 
     TRACE="$TRACE [$CP]:$CMDLINE\n" 
     if [ "$CP" == "1" ]; then # we reach 'init' [PID 1] => backtrace end 
       break 
     fi 
     CP=$PP 
done 
echo "Backtrace of '$0'" 
echo -en "$TRACE" | tac | grep -n ":" # using tac to "print in reverse" [3] 

... e un semplice test.

Spero vi piaccia.

Answer 6

UPDATE: Il codice seguente dovrebbe funzionare. Ora ho trovato un newer answer con una versione di codice più recente che consente di inserire un messaggio nello stacktrace.

IIRC Non sono riuscito a trovare questa risposta per aggiornarlo anche in quel momento. Ma ora il codice deciso è meglio conservato in git, la versione più recente di cui sopra dovrebbe essere in questo gist.

risposta in codice corretto originale di seguito:

C'era un'altra risposta su questo da qualche parte, ma qui è una funzione da utilizzare per ottenere analisi dello stack nel senso usato ad esempio nel linguaggio di programmazione Java. Chiami la funzione e mette la traccia dello stack nella variabile $ STACK. Mostra i punti di codice che hanno portato a chiamare get_stack. Questo è in gran parte utile per complicate esecuzioni in cui una singola shell genera più frammenti di script e nidificazione.

function get_stack() { 
    STACK="" 
    # to avoid noise we start with 1 to skip get_stack caller 
    local i 
    local stack_size=${#FUNCNAME[@]} 
    for ((i=1; i<$stack_size ; i++)); do 
     local func="${FUNCNAME[$i]}" 
     [ x$func = x ] && func=MAIN 
     local linen="${BASH_LINENO[((i - 1))]}" 
     local src="${BASH_SOURCE[$i]}" 
     [ x"$src" = x ] && src=non_file_source 

     STACK+=$'\n'" "$func" "$src" "$linen 
    done 
} 

Answer 7

È possibile utilizzare Bash Debugger http://bashdb.sourceforge.net/

Oppure, come accennato nei commenti precedenti, il caller bash built-in. Vedi: http://wiki.bash-hackers.org/commands/builtin/caller

i=0; while caller $i ;do ((i++)) ;done 

Un altro modo per farlo è quello di cambiare la PS4 e attivare xtrace:

PS4='+$(date "+%F %T") ${FUNCNAME[0]}() $BASH_SOURCE:${BASH_LINENO[0]}+ ' 
set -o xtrace # Comment this line to disable tracing.