Newsgroup: it.comp.os.linux.iniziare
Titolo: Processi padri e figli

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

 processo che li ha lanciati.
echo $PPID
-- 
Massimo Bacilieri AKA Crononauta


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'.

 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.


Facebook: Massimo Bacilieri

 "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 ... :-/

 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

 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. 

 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' ;-)


 
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. :-)

 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

 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.

 che mi pare corretto visto che lanciando "ps aux" da un altro terminale ottengo:
Infatti così è corretto. $PPID ti da il pid padre, e $$ il pid assegnato
al processo corrente.
