[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


30. Processi e shell

La shell è l'intermediario tra l'utente e il sistema, e di conseguenza il mezzo normale attraverso cui si può avviare e controllare un processo. Un comando impartito attraverso una shell può generare più di un processo, per esempio quando viene avviato un programma o uno script che avvia a sua volta diversi programmi, oppure quando si realizzano delle pipeline. Per questo motivo, quando si vuole fare riferimento all'attività derivata da un comando dato attraverso una shell, si parla di job e non di singoli processi.

30.1 Controllo dei job di shell

Attraverso alcune shell è possibile gestire i job che in questo caso rappresentano raggruppamenti di processi generati da un solo comando.

La shell Bash, e in generale le shell POSIX, oltre alla shell Korn e alla shell C, gestiscono i job. Nelle sezioni seguenti si fa riferimento al comportamento di Bash (in qualità di shell POSIX), ma la maggior parte di quanto spiegato in queste sezioni vale anche per le shell Korn e C (`ksh' e `csh').

Non si deve confondere un job di shell con un processo. Un processo è un singolo eseguibile messo in funzione: se questo a sua volta avvia un altro eseguibile, viene generato un nuovo processo a esso associato. Un job di shell rappresenta tutti i processi che vengono generati da un comando impartito tramite la shell stessa. Basta immaginare cosa succede quando si utilizza una canalizzazione di programmi (pipe), dove l'output di un programma è l'input del successivo.

30.1.1 Processi in primo piano e processi sullo sfondo

L'attività di un job può avvenire in primo piano (foreground) o sullo sfondo (background). Nel primo caso, il job impegna la shell e quindi anche il terminale, mentre nel secondo la shell è libera da impegni e così anche il terminale. Di conseguenza, non ha senso pretendere da un programma che richiede l'interazione continua con l'utente che possa funzionare sullo sfondo.

Se un programma richiede dati dallo standard input o ha la necessità di emettere dati attraverso lo standard output o lo standard error, per poterlo avviare come job sullo sfondo, bisogna almeno provvedere a ridirigere l'input e l'output.

30.1.2 Avvio di un job sullo sfondo

Un programma è avviato esplicitamente come job sullo sfondo quando alla fine della riga di comando viene aggiunto il simbolo `&'. Per esempio:

make zImage > ~/make.msg &

avvia sullo sfondo il comando `make zImage', per generare un kernel, dirigendo lo standard output verso un file per un possibile controllo successivo dell'esito della compilazione.

Dopo l'avvio di un programma come job sullo sfondo, la shell restituisce una riga contenente il numero del job e il numero del processo terminale generato da questo job (PID). Per esempio:

[1] 173

rappresenta il job numero uno che termina con il processo 173.

Se viene avviato un job sullo sfondo, quando a un certo punto ha la necessità di emettere dati attraverso lo standard output o lo standard error e questi non sono stati ridiretti, si ottiene una segnalazione simile a quella seguente:

[1]+ Stopped (tty output) pippo

Nell'esempio, il job avviato con il comando `pippo' si è bloccato in attesa di poter emettere dell'output. Nello stesso modo, se viene avviato un job sullo sfondo che a un certo punto ha la necessità di ricevere dati dallo standard input e questo non è stato ridiretto, si ottiene una segnalazione simile alla seguente:

[1]+ Stopped (tty input) pippo

30.1.3 Sospensione di un job in primo piano

Se è stato avviato un job in primo piano e si desidera sospenderne l'esecuzione, si può inviare attraverso la tastiera il carattere `susp', che di solito si ottiene con la combinazione [Ctrl+z]. Il job viene sospeso e posto sullo sfondo. Quando un job viene sospeso, la shell genera una riga come nell'esempio seguente:

[1]+ Stopped pippo

dove il job `pippo' è stato sospeso.

30.1.4 jobs

jobs [<opzioni>] [<job>]

Il comando di shell `jobs', permette di conoscere l'elenco dei job esistenti e il loro stato. Per poter utilizzare il comando `jobs' occorre che non ci siano altri job in esecuzione in primo piano, di conseguenza, quello che si ottiene è solo l'elenco dei job sullo sfondo.

Alcune opzioni

-l

Permette di conoscere anche i numeri PID dei processi di ogni job.

-p

Emette solo i numeri PID del processo leader (quello iniziale) di ogni job.

Esempi

jobs

Si ottiene l'elenco normale dei job sullo sfondo. Nel caso dell'esempio seguente, il primo job è in esecuzione, il secondo è sospeso in attesa di poter emettere l'output, l'ultimo è sospeso in attesa di poter ricevere l'input.

[1]   Running                 yes >/dev/null &
[2]-  Stopped (tty output)    mc
[3]+  Stopped (tty input)     unix2dos

jobs -p

Si ottiene soltanto l'elenco dei numeri PID dei processi leader di ogni job.

232
233
235

---------

Per comprendere l'utilizzo dell'opzione `-l', occorre avviare sullo sfondo qualche comando un po' articolato.

yes | cat | sort > /dev/null &[Invio]

[1] 594

yes | cat > /dev/null &[Invio]

[2] 596

jobs -l[Invio]

[1]-   592 Running                 yes
       593                       | cat
       594                       | sort >/dev/null &
[2]+   595 Running                 yes
       596                       | cat >/dev/null &

Come si può osservare, l'opzione `-l' permette di avere informazioni più dettagliate su tutti i processi che dipendono dai vari job presenti.

30.1.5 Riferimenti ai job

L'elenco di job ottenuto attraverso il comando `jobs', mostra in particolare il simbolo `+' a fianco del numero del job attuale, ed eventualmente il simbolo `-' a fianco di quello che diventerebbe il job attuale se il primo termina o viene comunque eliminato.

Il job attuale è quello a cui si fa riferimento in modo predefinito tutte le volte che un comando richiede l'indicazione di un job e questo non viene fornito.

Di norma si indica un job con il suo numero preceduto dal simbolo `%', ma si possono anche utilizzare altri metodi elencati nella tabella 30.1.

Simbolo Descrizione
%n Il job con il numero indicato dalla lettera n.
%<stringa> Il job il cui comando inizia con la stringa indicata.
%?<stringa> Il job il cui comando contiene la stringa indicata.
%% Il job attuale.
%+ Il job attuale.
%- Il job precedente a quello attuale.

Tabella 30.1: Elenco dei parametri utilizzabili come riferimento ai job di shell.

30.1.6 fg

fg [<job>]

Il comando `fg' porta in primo piano un job che prima era sullo sfondo. Se non viene specificato il job su cui agire, si intende quello attuale.

30.1.7 bg

bg [<job>]

Il comando `bg' permette di fare riprendere (sullo sfondo) l'esecuzione di un job sospeso. Ciò è possibile solo se il job in questione non è in attesa di un input o di poter emettere l'output. Se non si specifica il job, si intende quello attuale.

Quando si utilizza la combinazione [Ctrl+z] per sospendere l'esecuzione di un job, questo viene messo sullo sfondo e diviene il job attuale. Di conseguenza, è normale utilizzare il comando `bg' subito dopo, senza argomenti, in modo da fare riprendere il job appena sospeso.

30.1.8 kill

kill [-s <segnale> | -<segnale>] [<job>]

Il comando `kill' funziona quasi nello stesso modo del programma omonimo. Di solito, non ci si rende conto che si utilizza il comando e non il programma. Il comando `kill' in particolare, rispetto al programma, permette di inviare un segnale ai processi di un job, indicando direttamente il job.

Quando si vuole eliminare tutto un job, a volte non è sufficiente un segnale `SIGTERM'. Se necessario si può utilizzare il segnale `SIGKILL' (con prudenza però).

Esempi

kill -KILL %1

Elimina i processi abbinati al job numero uno, inviando il segnale `SIGKILL'.

kill -9 %1

Elimina i processi abbinati al job numero uno, inviando il segnale `SIGKILL', espresso in forma numerica.

30.2 Cattura dei segnali

Attraverso il comando interno `trap' è possibile catturare ed eventualmente attribuire un comando (comando interno, funzione o programma) a un segnale particolare.

In questo modo uno script può gestire i segnali. L'esempio seguente ne mostra uno (`trappola') in grado di reagire ai segnali `SIGUSR1' e `SIGUSR2' emettendo semplicemente un messaggio.

#!/bin/bash

    trap 'echo "Ho catturato il segnale SIGUSR1"' SIGUSR1
    trap 'echo "Ho catturato il segnale SIGUSR2"' SIGUSR2

    while [ 0 ]		# ripete continuamente
    do
    	NULLA="ciao"	# esegue un'operazione inutile
    done

Supponendo di avere avviato lo script nel modo seguente,

trappola &[Invio]

e che il suo numero PID sia 1234...

kill -s SIGUSR1 1234[Invio]

Ho catturato il segnale SIGUSR1	

kill -s SIGUSR2 1234[Invio]

Ho catturato il segnale SIGUSR2

30.2.1 trap

trap [-l] [<comando>] [<segnale>]

Il comando espresso come argomento di `trap' viene eseguito quando la shell riceve il segnale o i segnali indicati. Se non viene fornito il comando, o se al suo posto si mette un trattino (`-'), tutti i segnali specificati sono riportati al loro valore originale (i valori che avevano al momento dell'ingresso nella shell), cioè riprendono il loro significato normale. Se il comando fornito corrisponde a una stringa nulla, il segnale relativo viene ignorato dalla shell e dai comandi che questo avvia. Il segnale può essere espresso in forma verbale (per nome) o con il suo numero. Se il segnale è `EXIT', pari a zero, il comando viene eseguito all'uscita della shell.

Se viene utilizzato senza argomenti, `trap' emette la lista di comandi associati con ciascun numero di segnale.

Esempi

trap 'ls -l' SIGUSR1

Se la shell riceve un segnale `SIGUSR1' esegue `ls -l'.

trap '' SIGUSR1

La shell e tutti i processi figli ignorano il segnale `SIGUSR1'.

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]