Processi padri e figli
Manuel
Sto preparando degli script e, per una serie di ragioni, mi farebbe
comodo dall'interno degli script stessi poter capire qual è il
processo che li ha lanciati.
Mi spiego: diciamo che io ho uno script "master", chiamiamolo A, che
durante l'esecuzione ne invoca un altro, chiamiamolo B. Per tutta una
serie di ragioni, mi interessa riutilizzare le funzionalità di B
lanciandolo a mano o facendolo lanciare da C, tuttavia B si deve
comportare in modo leggermente diverso nei due casi.
Una soluzione banale può essere quella di fare una copia di B,
modificarla, e di volta in volta usare B1 o B2 a secondo delle
necessità; tuttavia ho un vago ricordo di una variabile che entro una
shell contiene gli estremi del processo che l'ha lanciata. Può darsi
che stia prendendo un abbaglio colossale, ma più ci penso e più sono
convinto di questa cosa e mi piacerebbe poterla usare per gestire la
cosa in modo più elegante.
Lo so, è una sega mentale, però adesso mi è venuto il tarlo...
Qualche idea?
Grazie,
Manuel
Crononauta
> Sto preparando degli script e, per una serie di ragioni, mi farebbe
> comodo dall'interno degli script stessi poter capire qual è il
> processo che li ha lanciati.
echo $PPID
--
Massimo Bacilieri AKA Crononauta
Marco
wrote:
Puoi passare l'informazione allo script B tramite variabili d'ambiente:
# script A
...
caller=A /path/to/B
# script C
...
caller=C /path/to/B
# script B
...
if [ "$caller" = "A" ]; then
# siamo chiamati da A
else
# siamo chiamati da B
fi
oppure come argomento:
# script A
...
/path/to/B A
# script C
...
/path/to/B C
# script B
...
if [ "$1" = "A" ]; then
# siamo chiamati da A
else
# siamo chiamati da B
fi
shift
# qui gli altri argomenti sono disponibili...
--
Cio' che si vede, e'.
M_M
> echo $PPID
Per cercare di capire la tua indicazione ho fatto questo script di prova
che riavvia se stesso ricorsivamente elencando ogni volta i PID.
=================================================
#!/bin/bash
# ID_istanze.sh
# ID dei processi delle diverse istanze dello script.
PID=$(pidof sh $0)
# Visualizza gli ID dei processi.
echo "ID processi: $PID"
# Visualizza l'ID del processo padre.
echo "PID padre: $PPID"
echo "Premere Ctl-C per terminare."; echo
# Attesa.
sleep 1
# Ripete.
sh $0
=================================================
e questo e` il suo output:
=================================================
mm@shaka:~/Script$ ./ID_istanze.sh
ID processi:
PID padre: 13688
Premere Ctl-C per terminare.
ID processi: 13708
PID padre: 13705
Premere Ctl-C per terminare.
ID processi: 13711 13708
PID padre: 13708
Premere Ctl-C per terminare.
ID processi: 13714 13711 13708
PID padre: 13711
Premere Ctl-C per terminare.
=================================================
Non sapevo bene cosa aspettatarmi e sono rimasto un po' sorpreso dai
risultati delle prime due istanze.
Per non trarre ora conclusioni errate, vorrei sapere se lo script e`
giusto o presenta degli errori, soprattutto di ordine logico.
Crononauta
Francamente non ho capito bene cosa vuoi fare... e soprattutto cosa ti
stupisce dell'output. Sono solo perplesso dall'uso di pidof, che per
cercare processi generici come "sh" rischia di intercettare un processo
che non c'entra niente.
Anche perché vedo che il tuo script lo fai girare sotto bash, non sotto
sh (e va bene che bash è una shell... ma come processo si chiama
"bash").
--
Massimo Bacilieri AKA Crononauta
Skype: crononauta <massimo....@gmail.com>
Facebook: Massimo Bacilieri
M_M
> Francamente non ho capito bene cosa vuoi fare... e soprattutto cosa ti
> stupisce dell'output.
Cercavo solo un mezzo per capire cosa restituisce in realta` $PPID che hai
indicato; mi sono soffermato sull'output delle prime due istanze perche` poi
in questa prova le successive proseguono con un ordine costante, con il PID
padre sempre come secondo processo in ordine decrescente.
> Sono solo perplesso dall'uso di pidof, che per
> cercare processi generici come "sh" rischia di intercettare un processo
> che non c'entra niente.
ma $0 non sta ad indicare in questo caso "ID_istanze.sh" ?
> Anche perché vedo che il tuo script lo fai girare sotto bash, non sotto
> sh (e va bene che bash è una shell... ma come processo si chiama
> "bash").
Forse dovrei sempre scrivere "#!/bin/sh", tanto poi se poi sul sistema c'e`
bash, di default usa quella shell, giusto??
Scusami se faccio domande sciocche: e` gia` da un po' che cerco di imparare ma
purtroppo ho parecchie difficolta` nell'apprendimento degli script shell e
trovo abbastanza lungo ... :-/
Giuseppe Della Bianca
]zac[
> Cercavo solo un mezzo per capire cosa restituisce in realta` $PPID che hai
> indicato; mi sono soffermato sull'output delle prime due istanze perche`
]zac[
ps -ef
o
pstree -ap
o CTRL+ESC in KDE
o altri programmi che mostrino l'elenco dei processi.
P.S. Presta attenzione alle varie opzioni dei vari comandi/programmi che di
default potrebbero visualizzare solo alcuni processi
M_M
> ps -ef
>
> o
>
> pstree -ap
Ti ringrazio!
Mentre ero fuori per fare la spesa stavo pensando se era il caso di usare "ps
aux" per controllare ed ero pure giunto alla conclusione che prima di mettermi a
vedere come funzionava in bash, "forse" sarebbe stato il caso che avessi
studiato bene con quali regole il sistema governa i processi; ad esempio prima
di controllare, non ero affatto certo che premendo Ctrl-C si chiudessero tutti i
processi aperti dallo script.
Se mi domandassero il perche` si chiudono tutti, azzarderei che visto che tali
processi sono tutti legati da parentela, con l'uno che chiama il successivo,
allora chiudendo il primo si innesca una specie di reazione a catena; pero` in
realta` veramente non lo so.
Crononauta
> Cercavo solo un mezzo per capire cosa restituisce in realta` $PPID che hai
> indicato;
Il PID del processo padre. Esempio:
$ echo $PPID
32268
$ ps -A | grep 32268
32268 tty1 00:00:00 xfce4-terminal
che è quello che mi aspettavo, visto che ho aperto un terminale di XFCE
(xfce4-terminal) e da qui ho dato il comando "echo", per cui il processo
padre di qualsiasi comando io possa dare in quel terminale, sarà sempre
32268 (cioè appunto il valore di PPID).
Il problema ad usare pidof, come fai tu, lo puoi capire subito da questo
semplice script:
#!/bin/bash
echo Padre: $PPID
ps -A | grep $PPID
pidof bash
che eseguito mi offre come output:
Padre: 749
749 pts/2 00:00:00 bash
32265 32262 14225 1891 749
Ops! Cos'è tutto quell'elenco di processi? Sono tutte le bash che ho
attive in questo momento! Capisci perché pidof non è una buona idea, per
quello che vuoi fare tu?
> mi sono soffermato sull'output delle prime due istanze perche` poi
> in questa prova le successive proseguono con un ordine costante, con il PID
> padre sempre come secondo processo in ordine decrescente.
Il kernel assegna il numero di PID ai processi in modo non
necessariamente crescente, per cui potresti ad un certo punto avere
- in modo apparentemente paradossale - un figlio con un PID minore del
padre.
>> Sono solo perplesso dall'uso di pidof, che per
>> cercare processi generici come "sh" rischia di intercettare un processo
>> che non c'entra niente.
>
> ma $0 non sta ad indicare in questo caso "ID_istanze.sh" ?
$0 sì, ma sh no! Se scrivi:
pidof sh $0
ti trova tutti i PID dei processi "sh", che capisci anche tu possono
essere tanti!
> Forse dovrei sempre scrivere "#!/bin/sh", tanto poi se poi sul sistema c'e`
> bash, di default usa quella shell, giusto??
Usa la shell impostata, che *solitamente* è bash, ma potrebbe anche
essere ash o altre, se qualche sistemista si è divertito un po' ;-)
M_M
> Comunque se vuoi informarti (ma non solo) sui segnali e sulla gestione
> dei processi in UNIX (e GNU/Linux) ti consiglio l'ottimo GaPiL:
> http://gapil.truelite.it/
Una bella guida! Per ora ho letto i primi due capitoli. La trova chiara e
dettagliata senza essere "eterna" come gli appunti di informatica libera, e` in
italiano, che non guasta, e cosa non secondaria per me che non ho la stampante,
e` ben impaginata per lo schermo.
Mi pare sia molto orientata al linguaggio C che per me va bene, almeno ci
capisco qualcosa in piu` che in altri linguaggi che proprio non conosco.
Un bel regalo! Grazie. :-)
M_M
> Ops! Cos'è tutto quell'elenco di processi? Sono tutte le bash che ho
> attive in questo momento! Capisci perché pidof non è una buona idea, per
> quello che vuoi fare tu?
Ho capito. Sei piu` chiaro di un manuale. :-)
Il punto e` che io avrei voluto ricavare non solo il PID del processo padre ma
anche quello del propcesso in corso.
Ora ho modificato cosi`:
=======================================
#!/bin/bash
# ID_istanze.sh
echo "PID del processo padre: $PPID"
echo "PID del processo in corso : $$"
echo "Premere Ctl-C per terminare."; echo
sleep 3
sh $0
=======================================
e mi da questo output:
=======================================
PID del processo padre: 18139
PID del processo in corso : 18278
PID del processo padre: 18278
PID del processo in corso : 18280
PID del processo padre: 18280
PID del processo in corso : 18282
=======================================
che mi pare corretto visto che lanciando "ps aux" da un altro terminale ottengo:
mm 18139 0.0 0.1 21056 3820 pts/1 Ss 12:49 0:00 bash
mm 18278 0.0 0.0 10716 1428 pts/1 S+ 13:13 0:00 /bin/bash ./ID_istanze.sh
mm 18280 0.0 0.0 4096 604 pts/1 S+ 13:13 0:00 sh ./ID_istanze.sh
mm 18282 0.0 0.0 4096 604 pts/1 S+ 13:13 0:00 sh ./ID_istanze.sh
Giuseppe Della Bianca
]zac[
> Se mi domandassero il perche` si chiudono tutti, azzarderei che visto che
> tali processi sono tutti legati da parentela, con l'uno che chiama il
> successivo, allora chiudendo il primo si innesca una specie di reazione a
> catena; pero` in realta` veramente non lo so.
Messa in questo modo è troppo generica, non è scontato che tutti i processi
legati fra di loro in qualche modo si chiudano sempre tutti alla chiusura di
uno dei programmai.
Comunque se un programma ne lancia un altro e attende che termini per poi
proseguire e terminare il proprio funzionamento, è evidente che questo
capita per ogni condizione che ha provocato la chiusura del processo figlio.
Crononauta
> echo "PID del processo padre: $PPID"
> echo "PID del processo in corso : $$"
>
Infatti così è corretto. $PPID ti da il pid padre, e $$ il pid assegnato
al processo corrente.