Newsgroup: it.comp.os.linux.sys
Titolo: [bash] rilevare pid di un processo

Sto preparando un init script che deve lanciare un demone che logga su
stdout (per il momento non posso cambiare il codice) ma mi interessa che
logghi su su syslog, quindi volevo metterlo in pipe con logger.
supernode -l 8080 -v 2>&1 | logger -p 
daemon.info
 -t supernode -i &
Problema: voglio sapere che PID ha il demone supernode e salvarlo
in una variabile d'ambiente.
$! contiene il PID di logger (che non me ne faccio niente).
Se fosse da salvarlo in un file allora basterebbe questo:
( supernode -l 8080 -v 2>&1 & echo $! > /var/run/supernode.pid ) | \
     logger -p 
daemon.info
 -t supernode -i &
Ma come soluzione non mi piaceva molto. Non c'è modo semplice e pulito
di mettere il PID del primo processo di una pipe in una cavolo di
variabile d'ambiente?
-- 
Flavio Visentin
Scientists have finally discovered what's wrong with the female brain:
On the left side, there is nothing right, and on the right side, there
is nothing left.

 
Potresti utilizzare pidof
Quindi diventerebbe
( supernode -l 8080 -v 2>&1 & pidof supernode > /var/run/supernode.pid ) | \
logger -p 
daemon.info
 -t supernode -i &
L'unico problema che vedo � che quando esistono pi� processi con lo
stesso nome (vedi apache), pidof ti restituisce tutti i pid dei processi
che soddisfano la ricerca.
Non ho trovato il modo di chiedergli di restituire solo il primo pid
pascky@luca2000:~$ pidof apache2
4460 4459 4458 4457 4456 4448
In questo caso i processi sono
  |-apache2,4448 -k start
  |   |-apache2,4456 -k start
  |   |-apache2,4457 -k start
  |   |-apache2,4458 -k start
  |   |-apache2,4459 -k start
  |   `-apache2,4460 -k start
PSK

 variabile d'ambiente?
cosi funziona?
( supernode -l 8080 -v 2>&1 & PIPPO=$! &) | \


> supernode -l 8080 -v 2>&1 | logger -p 
daemon.info
 -t supernode -i &
supernode e logger son due processi...
la riga sotto puoi fare pidof di supernode dovrebbe darti il suo PID, 
che e' un'altro rispetto a quello di logger...
ma e' troppo semplice... probabilmente sbaglio qualcosa.

Il Fri, 03 Oct 2008 10:13:45 +0200, RedWiz scriveva:
R> cosi funziona?
R> ( supernode -l 8080 -v 2>&1 & PIPPO=$! &) | \
R>       logger -p 
daemon.info
 -t supernode -i &
No, già provato :-( 
La variabile PIPPO è inaccessibile in quanto l'uso delle parentesi
tonde apre una nuova shell; nemmeno esportandola funziona.


Il Fri, 03 Oct 2008 10:25:02 +0200, Antonio Macchi scriveva:
AM> 
AM> > supernode -l 8080 -v 2>&1 | logger -p 
daemon.info
 -t supernode -i
AM> > &
AM> 
AM> supernode e logger son due processi...
AM> 
AM> la riga sotto puoi fare pidof di supernode dovrebbe darti il suo
AM> PID, che e' un'altro rispetto a quello di logger...
Sì, pidof mi restituisce il pid del processo supernode, ma non è
l'approccio corretto perché potrei avere più processi attivi con lo
stesso nome.
Per il momento ho usato il passaggio da file, ma se qualcuno ha la
soluzione della variabile preferirei.


 soluzione della variabile preferirei.
Siccome sai (o dovresti sapere) il PID della shell parent di supernode
(quella da cui lo lanci), potresti parsare l'output di ps --ppid per
ottenere il pid, qualcosa del tipo 
ps --ppid $$ | awk '/supernode/{print $1}'
sempre supponendo che dalla stessa shell non lanci piu' istanze di
supernode, altrimenti credo che usare il file sia l'unica maniera.

 tonde apre una nuova shell; nemmeno esportandola funziona.
ok, soluzione teriBBBBBile:
a=pidof supernode
supernode -l 8080 -v 2>&1 | logger -p 
daemon.info
 -t supernode -i &
b=pidof supernode
PID=${b/$a/""}
di melgionon mi viene in mente O_O

 
supernode -l 8080 -v 2>&1 | logger -p 
daemon.info
 -t supernode -i
export snpid=pidof -s
questo 'dovrebbe' funzionare...
i processi son sempre lanciati con PID crescenti... quindi l'ultimo PID 
di supernode sara' quello maggiore... e pidof li scrive in ordine 
decrescente... e pidof -s restituisce il primo (ovvero l'ultimo eseguito)
avrebbe anche un senso... altrimenti a cosa servirebbe mai quel -s?
comunque ho fatto un po' di prove... e sembra ok... fanne un po' anche 
te nel caso

 
ops....
supernode -l 8080 -v 2>&1 | logger -p 
daemon.info
 -t supernode -i
export snpid=pidof -s supernode
(ma avevi capito cosa intendevo...)

 te nel caso
ho fatto questa prova qui...
$ pidof /bin/bash
13522 12944 12047 12044 3252 3251 3250 3248 3225
$ /bin/bash
$ pidof /bin/bash
13573 13522 12944 12047 12044 3252 3251 3250 3248 3225
$ echo $$
13573
$ pidof -s /bin/bash
13573
sembra che i PID vengano restituiti sempre in ordine decrescente.. e che 
i nuovi PID siano sempre di numero maggiore... e che quindi pidof -s dia 
sempre l'ultimo eseguito...
cosi' ad okkio, pare ok.

 [..] e che i nuovi PID siano sempre di numero maggiore...
Non è vero. Prova ad aprire tanti processi, e vedrai che prima o poi
ricominciano da numeri "bassi" (non da 0, per intenderci).
Non so quale sia il limite, ma mi è capitato, dopo una giornata di lavoro, di
avere PID a quattro cifre, mentre a metà giornata ero a cinque cifre.
M2C,
David
-- 
 . ''`.  Debian maintainer | 
http://wiki.debian.org/DavidPaleino
 : :'  : Linuxer #334216 --|-- 
http://www.hanskalabs.net/
 `. `'`  GPG: 1392B174 ----|---- 
http://snipr.com/qa_page
   `-   2BAB C625 4E66 E7B8 450A C3E1 E6AA 9017 1392 B174

Il Fri, 03 Oct 2008 12:37:56 +0200, Antonio Macchi scriveva:
AM> supernode -l 8080 -v 2>&1 | logger -p 
daemon.info
 -t supernode -i
AM> 
AM> export snpid=pidof -s
AM> 
AM> questo 'dovrebbe' funzionare...
Sì, ma è sempre un escamotage. Non è deterministico, è probabilistico.
AM> i processi son sempre lanciati con PID crescenti...
Non è vero. Arrivato a 32767 il PID riparte dal più basso. Oltretutto
vi sono distribuzioni in cui è applicata la pid randomness (
p.es
. se
applichi grsecurity) e quindi non è lecito fare questo assunto.
Se il metodo è deterministico va bene, altrimenti preferisco passare
dal file. E' che poi mi tocca rileggerlo per avere il pid nella
variabile.




Vedi anche 
http://wooledge.org:8000/BashFAQ/033

> Se il metodo � deterministico va bene
il mio dovrebe esserlo (a meno che una istanza di supernode muoia proprio
tra le due valorizzazioni di a e b, � possibile?)

Il Fri, 03 Oct 2008 13:32:10 +0200, RedWiz scriveva:
R> il mio dovrebe esserlo (a meno che una istanza di supernode muoia
R> proprio tra le due valorizzazioni di a e b, è possibile?)
Il tuo è già più corretto, ma non offre sensibili vantaggi rispetto
al più semplice (e deterministico) scrivere e rileggere il file.


 
Puoi crearne un certo numero con nomi alternativi (supernode1,
supernode2, ecc...) poi li chiami a rotazione e usi pidof per l'ultimo
chiamato.
-- 
Fa freddo nello scriptorium, il pollice mi duole. Lascio questa
scrittura, non so per chi, non so pi� intorno a che cosa...
U. Eco

 
vero... ho provato adesso
ho scritto un piccolo script, chiamato gobash.sh
-------
#!/bin/bash
echo $$ - `pidof -s /bin/bash`
exit 0
-------
l'ho avviato cosi'
for i in {1..2000}; do ./gobash.sh ; done
l'output e' stato questo (dopo diversi lanci...)
[...]
32742 - 32742
32744 - 32744
32746 - 32746
32748 - 32748
32750 - 32750
32752 - 32752
32754 - 32754
32756 - 32756
32758 - 32758
32760 - 32760
32762 - 32762
32764 - 32764
32766 - 32766
300 - 32647
302 - 32647
304 - 32647
306 - 32647
308 - 32647
310 - 32647
[...]
$ bash
$ echo $$
362
$ pidof /bin/bash
32647 3414 3413 3402 3401 3400 3384 362
$ pidof -s bin/bash
32647
quindi in effetti pidof -s non restituisce sempre il PID dell'ultimo 
processo avviato...
ma forse si potrebbe usare il tempo
facendo ps aux, compare anche la colonna del tempo...
si potrebbe prendere l'ultimo processo in ordine temporale

 variabile d'ambiente?
Curiositï¿œ: perchï¿œ non ti piace il pidfile, che utilizzano praticamente tutti
gli script d'init? Anche perchï¿œ poi ti serve per lo stop...
-- 
Vide

Il Fri, 03 Oct 2008 15:36:56 +0200, Vide scriveva:
V> > Ma come soluzione non mi piaceva molto. Non c'è modo semplice e
V> > pulito di mettere il PID del primo processo di una pipe in una
V> > cavolo di variabile d'ambiente?
V> 
V> Curiosità: perchè non ti piace il pidfile, che utilizzano
V> praticamente tutti gli script d'init? Anche perchè poi ti serve per
V> lo stop...
Non è che non mi piaccia in termini assoluti. Solo che mi serve il
valore del PID per altre operazioni, e non mi piace scrivere per poi
rileggere.
Poi è diventata anche una questione di principio; mi pare assurdo che
non ci sia un modo per sapere il pid del primo processo di una pipe.
Avevo valutato anche l'uso di jobs -p, ma sono sempre "accrocchi".
Speravo ci fosse un sistema analogo a $! o perlomeno la possibilità di
memorizzare tale valore a "metà" di una pipe.
Un sistema ci sarebbe; basterebbe sfruttare una named pipe invece di
una pipe anonima, quindi fare mkfifo, lanciare il logger e poi lanciare
il demone salvando il pid. Però se non ricordo male c'erano problemi
con l'uso delle named pipe se si killava il processo che leggeva dalla
pipe, e non vorrei rischiare che se il logger si inchioda ciò abbia
conseguenze sul resto del sistema.
