% Linux Guida dell'Utente                   -*- TeX -*-
 % shell2.tex
 % Copyright (c) 1993, 1994 by Larry Greenfield
 %
 % Traduzione di Eugenia Franzoni, 1997
 %
 % Questo file \`e liberamente distribuibile, ma si deve preservare questo
 % avviso di copyright su tutte le copie, e deve essere distribuito solo come
 % parte di "Linux Guida dell'Utente". L'uso di questo file \`e
 % protetto dal copyright dell'intero documento, nel file "copyright.tex".
 
 % Titolo del capitolo
 \chapter{Lavorare con \unix}
 \label{shell2-chapter}
 
 % Frasetta estratta dal programma fortune e non tradotta...
 % \begin{screen}\begin{verbatim}
 % better !pout !cry
 % better watchout
 % lpr why
 % santa claus <north pole >town
 % 
 % cat /etc/passwd >list
 % ncheck list 
 % ncheck list
 % cat list | grep naughty >nogiftlist
 % cat list | grep nice >giftlist
 % santa claus <north pole > town
 % 
 % who | grep sleeping
 % who | grep awake
 % who | egrep 'bad|good'
 % for (goodness sake) {
 %         be good
 % }
 % \end{verbatim}\end{screen}
 
 \glossary{C shell}\glossary{Bourne shell}
 \glossary{file}\glossary{input}\glossary{output}
 
 UNIX \`e un sistema molto potente per quelli che sanno come gestirlo.
 In questo capitolo prover\`o a descrivere vari modi di usare la
 shell di \unix, {\tt bash}\ttindex{bash}, in modo pi\`u efficiente.
 
 
 \section{Metacaratteri}
 \bindex{shell!metacaratteri}
 \index{shell!raggruppamenti|see{shell, metacaratteri}}
 \index{metacaratteri|see{shell, metacaratteri}}
 \index{{caratteri jolly}|see{shell, metacaratteri}}
 
 Nel capitolo precedente avete imparato alcuni comandi di manutenzione dei
 file: {\tt cp}, {\tt mv} e {\tt rm}. Pu\`o capitare che vogliate
 interagire con 
 pi\`u di un file alla volta. Per esempio, potreste voler copiare tutti i
 file che cominciano con {\tt data} nella directory {\tt
 \verb+~+/backup}: si pu\`o fare sia dando pi\`u comandi {\tt cp},
 sia elencando tutti i file in un'unica linea di comando; entrambi
 questi
 metodi, comunque, portano via molto tempo e avete molte possibilit\`a di
 compiere errori.
 
 Una via migliore per farlo \`e scrivere:
 
 \begin{screen}\begin{verbatim}
 /home/larry/report$ ls -F
 1993-1          1994-1          data1           data5
 1993-2          data-new        data2
 /home/larry/report$ mkdir ~/backup
 /home/larry/report$ cp data* ~/backup
 /home/larry/report$ ls -F ~/backup
 data-new        data1           data2           data5
 /home/larry/report$
 \end{verbatim}\end{screen}
 
 Come potete vedere, l'asterisco dice a {\tt cp} di prendere tutti i file che
 iniziano con {\tt data} e copiarli in {\tt \verb+~+/backup}. Riuscite
 ad indovinare cosa farebbe {\tt cp d*w \verb+~+/backup}?
 
 
 \subsection{Cosa succede {\em realmente\/}?}
 
 Buona domanda. In realt\`a ci sono due caratteri speciali che vengono 
 intercettati dalla shell {\tt bash}\ttindex{bash}. Il carattere ``{\tt
 *}'', un asterisco, dice ``sostituisci questa parola con tutti  i file che
 verificano questa specifica''. In questo modo, il comando {\tt cp data*
 \verb+~+/backup}, come nell'esempio precedente, viene cambiato in {\tt cp
 data-new data1 data2 data5 \verb+~+/backup} prima di venire eseguito.
 
 Per vedere come funziona introduciamo un nuovo comando, {\tt
 echo}\impttindex{echo}. {\tt echo} \`e un comando estremamente semplice;
 rimanda sullo schermo o stampa ogni parametro. Cio\`e:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ echo Ciao!
 Ciao!
 /home/larry$ echo Come va?
 Come va?
 /home/larry$ cd report
 /home/larry/report$ ls -F
 1993-1          1994-1          data1           data5
 1993-2          data-new        data2
 /home/larry/report$ echo 199*
 1993-1 1993-2 1994-1
 /home/larry/report$ echo *4*
 1994-1
 /home/larry/report$ echo *2*
 1993-2 data2
 /home/larry/report$
 \end{verbatim}\end{screen}
 
 Come potete vedere, la shell espande il metacarattere e passa tutti i file
 al programma che volete sia eseguito. Questo solleva una domanda
 interessante: cosa succede se {\em non\/} ci sono file che incontrano le
 specifiche del metacarattere? Provate {\tt echo /rc/fr*og} e guardate cosa
 succede\ldots {\tt bash} passa testualmente la stringa con il
 metacarattere al programma.
 
 
 Bisogna dire anche che altre shell, come {\tt tcsh}\ttindex{tcsh}, invece
 di passare testualmente il metacarattere, rispondono {\tt No match}.
 Ecco lo stesso comando sotto {\tt tcsh}:
 
 \begin{screen}\begin{verbatim}
 mousehouse>echo /rc/fr*og
 echo: No match.
 mousehouse>
 \end{verbatim}\end{screen}
 
 L'ultima cosa che chiederete \`e come fare se volete che sullo
 schermo compaia
 {\tt data*}, al posto della lista dei nomi dei file? Beh, sia sotto
 {\tt bash} che {\tt tcsh}, basta racchiudere la stringa tra
 virgolette:
 
 \begin{minipage}{2.6in}\begin{screen}
 \begin{verbatim}
 /home/larry/report$ echo "data*"
 data*
 /home/larry/report$
 \end{verbatim}\end{screen}\end{minipage}\ {\large oppure}\ 
 \begin{minipage}{2.6in}\begin{screen}
 \begin{verbatim}
 mousehouse>echo "data*"
 data*
 mousehouse>
 \end{verbatim}\end{screen}\end{minipage}
 
 
 \subsection{Il punto interrogativo}
 
 Oltre all'asterisco, anche il punto interrogativo viene interpretato dalla
 shell
 come carattere speciale. Un punto interrogativo corrisponde ad uno,
 ed un solo carattere. Per esempio, {\tt ls /etc/??} mostra tutti i
 nomi di file di due lettere nella directory {\tt /etc}.
 
 \eindex{shell!metacaratteri}
 
 \section{Risparmiare tempo con {\tt bash}}
 
 \index{inserimento di linee di comando|vedere{shell, editing}}
 
 \subsection{Inserimento di linee di comando}
 \bindex{shell!editing}
 
 Qualche volta vi capiter\`a di scrivere un lungo comando in {\tt
 bash}\ttindex{bash} e, prima di premere \ret, di accorgervi di un
 errore di battitura all'inizio della riga. Potreste cancellare tutto,
 tornare indietro e riscrivere tutto correttamente, ma questo richiede un
 bello sforzo! Potete invece premere i tasti freccia per tornare indietro,
 eliminare i caratteri errati, ed inserire quelli corretti.
 
 Ci sono molti tasti speciali per modificare le
 linee di
 comando; molti sono simili ai comandi di GNU
 Emacs\index{GNU
 Emacs}. Per esempio, \key{Ctrl-T} scambia due caratteri
 adiacenti.\footnote{\key{Ctrl-T} significa tener premuto il tasto ``Ctrl'',
 premere il tasto ``t'' e quindi rilasciare il tasto ``Ctrl''.} Troverete
 molti di questi comandi nel capitolo di Emacs, il capitolo~\ref{emacs-chapter}.
 
 \eindex{shell!editing}
 
 \subsection{Completamento file e comandi}
 \bindex{shell!completamento}
 
 Un'altra caratteristica di {\tt bash}\ttindex{bash} \`e il completamento
 automatico della linea di comando. Diamo un'occhiata al seguente esempio di
 un tipico comando {\tt cp}:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ ls -F
 un-file-lunghissimo
 /home/larry$ cp un-file-lunghissimo corto
 /home/larry$ ls -F
 corto                un-file-lunghissimo
 /home/larry$
 \end{verbatim}\end{screen}
 
 \`E una gran fatica dover inserire ogni carattere di {\tt
 un-file-lunghissimo}
 ogni volta che dovete accedervi. Create {\tt un-file-lunghissimo}
 copiandolo da {\tt /etc/passwd},\footnote{\tt cp /etc/passwd
 un-file-lunghissimo} e andiamo a ripetere lo stesso comando
 {\tt cp} in un
 modo molto pi\`u veloce e con poche possibilit\`a di errore.
 
 Invece di inserire il nome per intero, digitate {\tt cp un}, e premete e
 rilasciate il tasto \key{Tab}. Come per magia, il resto del nome viene
 mostrato nella riga di comando e potete inserire {\tt corto}.
 Sfortunatamente, {\tt bash} non pu\`o leggervi nel pensiero, e dovete
 inserire {\tt corto} completamente.
 
 Quando digitate \key{Tab}, {\tt bash} guarda cosa avete scritto, e cerca un
 file che inizi nello stesso modo. Per esempio, se scrivo {\tt
 /usr/bin/ema} e
 premo \key{Tab}, {\tt bash} trover\`a {\tt /usr/bin/emacs}, che \`e il
 solo file che comincia con {\tt /usr/bin/ema} nel mio sistema.
 Comunque, se
 scrivessi {\tt /usr/bin/ld} e premessi \key{Tab}, {\tt bash} emetterebbe un
 suono di avviso, perch\'e nel mio sistema ci sono tre file che cominciano
 con {\tt
 /usr/bin/ld}: {\tt /usr/bin/ld}, {\tt /usr/bin/ldd} e {\tt /usr/bin/ld86}.
 
 Se provando il completamento automatico sentite un suono, potete
 premere di nuovo \key{Tab} per ottenere la lista di tutti i file che
 iniziano in quel modo. Cos\`{\i}, se non siete sicuri del nome esatto di
 un file, potete iniziare a scriverlo e cercare in lista di nomi pi\`u
 ristretta.
 
 \eindex{shell!completamento}
 
 
 \section{Standard Input e Standard Output}
 
 % sarebbe carino avere alcune illustrazioni su questo, con frecce che
 % mostrano dove sta andando l'output
 
 Proviamo a risolvere un problema semplice: ottenere un listato della
 directory {\tt /usr/bin}. Se facciamo {\tt ls /usr/bin}, alcuni file
 scrolleranno fuori dallo schermo. Come possiamo vederli tutti?
 
 
 \subsection{Concetti di \unix}
 
 Il sistema operativo UNIX rende molto semplice per i programmi usare il
 terminale. Quando un programma scrive qualcosa sullo schermo, sta
 usando una cosa che si chiama {\bf standard output}\index{standard output}. Lo
 standard output, abbreviato in stdout, \`e quello che usano i programmi
 per scrivere le informazioni all'utente. Il nome per quello che usate voi
 per comunicare con i programmi \`e {\bf standard input}\index{standard
 input} (stdin). \`E possibile che i programmi comunichino con l'utente 
 senza usare
 standard input o output, ma la maggior parte dei comandi che descrivo
 in questo libro usano stdin e stdout.
 
 Per esempio, il comando {\tt ls} stampa il listato di una directory sullo
 standard output, che \`e normalmente ``connesso'' al vostro terminale. Un
 comando interattivo, come la shell, {\tt bash}, legge i vostri comandi dallo
 standard input.
 
 \`E anche possibile per un programma scrivere nello {\bf standard
 error}\index{standard error}, dato che \`e molto semplice dirottare lo
 standard output altrove rispetto al terminale. Lo standard error, stderr, \`e
 quasi sempre connesso al terminale, in modo che si possano leggere i messaggi
 d'errore.
 
 In questa sezione esamineremo tre modi per divertirsi
 con lo
 standard input e output: redirezione dell'input, dell'output e pipe.
 
 
 \subsection{Redirezione dell'output}
 \bindex{redirezione dell'output}
 
 Una caratteristica importante di UNIX \`e la capacit\`a di {\bf
 redirigere}
 l'output. Questo vi permette, invece di vedere i risultati di un comando,
 di registrarli in un file o di mandarli direttamente alla stampante.
 Per
 esempio, per redirigere l'output del comando {\tt ls /usr/bin}, metteremo un
 segno {\tt >} alla fine della linea e diremo in quale file vogliamo che sia
 messo l'output:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ ls
 /home/larry$ ls -F /usr/bin > lista
 /home/larry$ ls
 lista
 /home/larry$
 \end{verbatim}\end{screen}
 
 Come potete vedere, invece di scrivere i nomi di tutti i file, il comando
 crea un nuovo file nella home directory; proviamo a vederlo con
 il comando {\tt cat}. Se tornate indietro, ricorderete che {\tt cat} era un
 comando apparentemente inutile che copiava quello che scrivevate (lo
 standard input) sul terminale (standard output). {\tt cat} pu\`o anche
 stampare un file sullo standard output se gli date il file come
 parametro:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ cat lista
 ...
 /home/larry$
 \end{verbatim}\end{screen}
 
 L'output esatto del comando {\tt ls /usr/bin} appare nel contenuto di {\tt
 lista}. Tutto bene, anche se questo non ha risolto il problema
 originale.\footnote{Per i lettori impazienti, il comando che state cercando
 \`e {\tt more}. Comunque ci sono ancora alcune cose da dire prima di
 arrivarci.}
 
 Comunque, {\tt cat} fa qualcosa di interessante quando il suo output viene
 rediretto. Cosa fa il comando {\tt cat lista > nuovofile}? Normalmente, {\tt
 > nuovofile} dice ``prendere tutto l'output del comando e metterlo in {\tt
 nuovofile}''. L'output del comando {\tt cat lista} \`e il file {\tt lista}. In
 questo modo abbiamo inventato un metodo nuovo (e non molto efficiente) per
 copiare i file.
 
 E che dire del comando {\tt cat > pippo}? {\tt cat} da solo legge ogni linea
 inserita dal terminale (standard input) e stampa tutto nello standard output
 finch\'e non legge \key{Ctrl-d}. In questo caso, lo standard output \`e
 stato rediretto nel file {\tt pippo}. Adesso {\tt cat} \`e servito come un
 rudimentale editor (programma per scrittura testi):
 
 \begin{quote}{\tt 
 /home/larry\$ cat > pippo\\
 Oggi \`e una bella giornata.\\
 {\em premete Ctrl-d}
 }\end{quote}
 
 Abbiamo creato quindi il file {\tt pippo} che contiene la frase ``Oggi \`e
 una bella giornata''. Un altro uso del versatile comando {\tt cat} \`e con{\bf
 cat}enare pi\`u file insieme: {\tt cat} stampa tutti i file che gli
 vengono passati
 come parametro, un file dopo l'altro. Cos\`{\i} il comando {\tt cat lista pippo}
 stampa il listato della directory {\tt /usr/bin}, e poi la
 nostra frase. In questo modo, il comando {\tt cat lista pippo > listaepippo}
 creer\`a un nuovo file contenente sia {\tt lista} sia {\tt pippo}.
 
 \eindex{redirezione dell'output}
 
 
 \subsection{Redirezione dell'input}
 \bindex{redirezione dell'input}
 
 Come per lo standard output, \`e anche possibile redirigere
 lo standard input\index{standard input}. Un programma, invece di
 leggere dalla
 tastiera, legge da un file. Siccome la redirezione dell'input \`e
 collegata alla redirezione dell'output, sembra naturale che il carattere
 speciale per la redirezione dell'input sia {\tt <}. Anche questo deve essere
 usato dopo
 il comando da eseguire.
 
 La redirezione dell'input \`e utile generalmente se avete un
 file di dati e un comando si
 aspetta dell'input dallo standard input. La maggior parte dei comandi
 permettono di
 specificare un file su cui operare, cos\`{\i} {\tt <} non \`e usato
 nelle normali operazioni giornaliere come altre tecniche.
 
 \eindex{redirezione dell'inut}
 
 
 \subsection{Soluzione: le pipe}
 \bindex{pipe}
 
 Molti comandi UNIX producono una grande quantit\`a di informazioni:
 per
 esempio, non \`e strano per un comando come {\tt ls /usr/bin} produrre
 pi\`u
 output di quello che potete vedere su una sola schermata. Per
 riuscire a vedere
 tutte le informazioni di un comando come {\tt ls /usr/bin}, \`e necessario
 usare un altro comando \unix, chiamato {\tt more}\ttindex{more}.\footnote{Si
 chiama {\tt more} perch\'e il prompt (messaggio) che stampava
 originariamente era {\tt --more--}. In molte versioni di \linux, il comando
 {\tt more} \`e identico ad un comando pi\`u avanzato che fa tutto quello che fa
 {\tt more} e molto di pi\`u. Come prova che i programmatori non hanno
 il senso dell'umorismo, l'hanno chiamato {\tt less}\ttindex{less}!}
 {\tt more} si ferma ad ogni videata di informazioni. Per esempio,
 {\tt more <
 /etc/rc} mostra il file {\tt /etc/rc}, esattamente come farebbe
 {\tt cat /etc/rc}, eccetto che vi permette di leggerlo.
 {\tt more} permette anche la forma {\tt more /etc/rc}, ed \`e questo il
 modo normale di invocarlo.
 
 Comunque, questo non risolve il problema che {\tt ls /usr/bin} mostra pi\`u
 informazioni di quelle che potete vedere. {\tt more < ls /usr/bin} non
 funziona---la redirezione dell'input funziona solamente con i file, non con
 i comandi! {\em Potreste\/} fare questo:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ ls /usr/bin > temp-ls
 /home/larry$ more temp-ls
 ...
 /home/larry$ rm temp-ls
 \end{verbatim}\end{screen}
 
 UNIX d\`a un modo pi\`u pulito per fare la stessa cosa: si usa
 il comando
 {\tt ls /usr/bin | more}. Il carattere ``{\tt |}'' indica una {\bf
 pipe}
 (conduttura). Come una conduttura dell'acqua, una pipe UNIX
 controlla il flusso.
 Invece
 di acqua, stiamo controllando il flusso di informazioni!
 
 Uno strumento utile con le pipe sono i programmi chiamati {\bf
 filtri}\index{filtri}. Un filtro \`e un programma che legge lo standard
 input, lo elabora in qualche modo e manda i risultati sullo standard
 output. {\tt more} \`e un filtro---legge i dati che provengono dallo
 standard input e li visualizza sullo standard output una videata alla volta,
 permettendovi di leggere il file. {\tt more} non \`e un granch\'e come
 filtro, dato che il suo output non pu\`o essere usato come input per un
 altro programma.
 
 Altri filtri sono i programmi {\tt cat}\ttindex{cat}, {\tt
 sort}\ttindex{sort}, {\tt head}\ttindex{head} e
 {\tt tail}\ttindex{tail}. Per esempio, se volete leggere solo le
 prime dieci linee
 dell'output di {\tt ls}, potete usare {\tt ls /usr/bin | head}.
 
 \eindex{pipe}
 
 
 \section{Multitasking}
 \label{section-multitasking}
 
 \subsection{Le basi}
 \index{controllo dei job|see{shell, controllo dei job}} 
 
 Il {\bf Job control}\index{shell!controllo dei job} (controllo dei job)  si
 riferisce alla possibilit\`a di mettere i processi
 (essenzialmente la stessa cosa dei programmi)
 in background (sullo sfondo) e di riportarli in foreground (in primo 
 piano), cio\`e 
 poter
 eseguire un processo mentre voi state facendo qualcos'altro, ma mantenendone il
 controllo per potergli comunicare qualcosa o per poterlo fermare.
 In \unix, lo strumento
 principale per controllare i job \`e la shell---tiene traccia dei
 job per conto vostro, se imparate il suo linguaggio.
 
 Le due parole pi\`u importanti in questo linguaggio sono {\tt
 fg}\ttindex{fg}, per ``foreground'', e {\tt bg}\ttindex{bg}, per
 ``background''. Per vedere come funzionano, usiamo il comando {\tt
 yes}\ttindex{yes} al prompt.
 
 \begin{screen}\begin{verbatim}
 /home/larry$ yes
 \end{verbatim}\end{screen}
 
 Questo comando ha lo strano effetto di creare una lunga colonna di {\tt y} nel bordo
 sinistro dello schermo, pi\`u veloce di quello che riuscite a 
 vedere.\footnote{Ci sono delle buone ragioni per l'esistenza di questo
 strano comando. Talvolta i comandi chiedono conferma---chiedono di
 rispondere ``yes'' a delle domande. Il comando {\tt yes} permette di  
 automatizzare la risposta a queste domande.}
 Per
 fermare il comando, normalmente dovete premere
 \key{Ctrl-C}, ma questa volta premete
 \key{Ctrl-Z}. Sembra che si sia fermato, e viene stampato un
 messaggio
 prima del prompt pi\`u o meno cos\`i:
 
 \begin{screen}\begin{verbatim}
 [1]+   Stopped                  yes
 \end{verbatim}\end{screen}
 
 Significa che il processo {\tt yes} \`e stato \concept{sospeso}
 in background.
 Potete farlo ripartire nuovamente con
 il
 comando {\tt fg}\ttindex{fg}\index{foreground} al prompt, che lo 
 riporter\`a in primo piano.
 Se volete, potete fare altro prima,
 mentre \`e sospeso. Provate alcuni {\tt ls} o altro prima di rimetterlo in
 foreground.
 
 Una volta ritornato in foreground, ricominceranno le {\tt y}, veloci come
 prima. 
 Non dovete preoccuparvi che il programma ``immagazzini'' delle {\tt
 y} mentre il job \`e sospeso: quando un programma \`e
 sospeso, l'intero programma non viene pi\`u eseguito finch\'e non lo fate
 ritornare in vita (e ora potete premere \key{Ctrl-C} per cancellarlo
 in
 modo definitivo, una volta che lo avete sopportato abbastanza).
 
 Vediamo in dettaglio il messaggio lasciato dalla shell:
 
 \begin{screen}\begin{verbatim}
 [1]+   Stopped                yes
 \end{verbatim}\end{screen}
 
 Il numero tra parentesi \`e il {\bf numero del job}\index{shell|numero del
 job} di questo processo, e sar\`a usato quando dovrete riferirvi in modo
 specifico a quel job (naturalmente, siccome il controllo dei job riguarda
 l'esecuzione di pi\`u processi, \`e necessario un metodo per distinguerli
 l'uno dall'altro). Il carattere {\tt +} che segue le parentesi
 comunica che
 quello \`e il ``job corrente''---cio\`e il job spostato per ultimo dal
 foreground al background.
 Se
 scrivete {\tt fg}, metterete in foreground il job marcato con il {\tt +}
 (ne parleremo ancora pi\`u avanti, quando parleremo dell'esecuzione di
 pi\`u job
 contemporaneamente). La parola {\tt Stopped} significa che il job \`e
 sospeso: il job non \`e morto, ma non \`e pi\`u in esecuzione; Linux lo ha
 salvato in uno speciale stato di sospensione, pronto a tornare in azione
 appena qualcuno lo richieda. Infine, {\tt yes} \`e il nome del processo
 che \`e stato fermato.
 
 Prima di proseguire, cancelliamo questo job ed avviamolo in modo diverso. Il
 comando si chiama {\tt kill}\ttindex{kill} e pu\`o essere usato cos\`{\i}:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ kill %1
 [1]+  Stopped                 yes
 \end{verbatim}\end{screen}
 \index{job|see{shell, controllo dei job}}
 
 Il messaggio che il job \`e sospeso \`e ingannevole. Per vedere se \`e
 ancora in vita (cio\`e in esecuzione o in stato sospeso), digitate {\tt
 jobs}\index{shell!job}:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ jobs
 [1]+  Terminated                 yes
 \end{verbatim}\end{screen}
 
 Ecco qui! Il job \`e stato terminato! (\`E possibile che {\tt jobs} non
 restituisca niente, per indicare che non ci sono jobs in esecuzione in
 background. Se avete appena cancellato un job, e digitando {\tt jobs} non
 viene mostrato nulla, allora la cancellazione \`e stata compiuta con
 successo. Normalmente viene comunicato che il job \`e stato ``terminato''
 (terminated) o ``ucciso'' (killed).)
 
 Adesso avviamo {\tt yes} nuovamente, cos\`{\i}:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ yes > /dev/null
 \end{verbatim}\end{screen}
 
 Se avete letto la sezione sulla redirezione dell'input e dell'output,
 saprete che questo sta mandando l'output di {\tt yes} nel file speciale {\tt
 /dev/null}. {\tt /dev/null} \`e un buco nero che assorbe ogni output
 che gli si manda
 (potete immaginare che il flusso di {\tt y} finisca fuori dal
 computer e scompaia in un buco nel muro, se questo vi rende pi\`u contenti).
 
 Dopo aver digitato questo comando, non otterrete indietro il prompt,
 ma non vedrete
 nemmeno la colonna di {\tt y}. Anche se l'output viene mandato a {\tt
 /dev/null}, il job \`e ugualmente in esecuzione in foreground. Come al
 solito, potete sospendere il job premendo \key{Ctrl-Z}; fatelo adesso per
 ottenere di nuovo il prompt.        
 
 \begin{screen}\begin{verbatim}
 /home/larry$ yes > /dev/null
 ["yes" e' in esecuzione, e se premiamo ctrl-z adesso, lo sospenderemo
  e otterremo indietro il prompt. Immaginiamo che lo abbia appena fatto...]
 [1]+  Stopped                 yes >/dev/null 
 
 /home/larry$
 \end{verbatim}\end{screen}
 
 Hmm\ldots\ c'\`e un modo per far s\`{\i} che esso {\em funzioni\/} in
 background, cos\`{\i} da lasciarci il prompt per altri lavori interattivi?
 Il comando da
 usare \`e {\tt bg}\ttindex{bg}\index{background}:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ bg
 [1]+ yes >/dev/null  &
 /home/larry$ 
 \end{verbatim}\end{screen}
 
 Adesso dovete avere fiducia in me: dopo che avete inserito {\tt bg}, {\tt
 yes > /dev/null} \`e tornato a funzionare nuovamente, ma questa volta in
 background. Infatti, se fate qualcosa al prompt, come {\tt ls} e simili,
 noterete che la macchina \`e leggermente rallentata (convogliare un continuo
 flusso di caratteri richiede comunque del lavoro!). Oltre a questo,
 comunque, non ci sono altri effetti. Potete fare qualsiasi cosa vogliate al
 prompt, e {\tt yes} continuer\`a a mandare il suo output nel buco nero.
 
 Ci sono adesso due modi diversi per cancellarlo: con il comando {\tt kill}
 che avete appena imparato, o rimettendo il job in foreground
 e
 premendo il tasto di interruzione (\key{Ctrl-C}). Proviamo il secondo
 metodo, solo per capire meglio le relazioni tra {\tt fb} e {\tt bg}:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ fg
 yes >/dev/null 
 
 [adesso e' nuovamente in foreground. Immaginiamo che io abbia
  premuto ctrl-c per terminarlo]
 
 /home/larry$
 \end{verbatim}\end{screen}
 
 Ecco, \`e andato. Adesso avviamo un po' di job in contemporanea, cos\`{\i}:
 
 % lg: rephrase the above paragraph, maybe. It's a little awkward and
 % lg: too much a meta-paragraph: a paragraph about the document
 % kff: done, (good point).
 
 \begin{screen}\begin{verbatim}
 /home/larry$ yes  > /dev/null &
 [1] 1024
 /home/larry$ yes | sort > /dev/null &
 [2] 1026
 /home/larry$ yes | uniq > /dev/null 
 [e qui, premete ctrl-Z per sospenderlo]
 
 [3]+  Stopped                 yes | uniq >/dev/null
 \end{verbatim}\end{screen}
 
 La prima cosa che dovreste notare di questi comandi \`{e} il simbolo {\tt \&}
 alla fine delle prime due righe\index{\&}. Mettere un {\tt \&} dopo un
 comando comunica alla shell di avviarlo fin dall'inizio in background
 (\`e soltanto un modo per evitare di dover avviare il
 programma, premere \key{ctrl-Z} e digitare {\tt bg}). Cos\`{\i} abbiamo avviato
 questi due comandi in background. Il terzo, attualmente, \`{e} sospeso e
 inattivo. Potreste notare come adesso la macchina sia diventata un po' pi\`{u}
 lenta, in quanto ci sono due processi in esecuzione che richiedono un
 po' di tempo CPU.
 
 Ogni processo vi ha comunicato il suo numero di job. I primi due
 hanno mostrato
 anche il loro numero di \concept{Process IDentification}\index{PID},
 o {\tt
 PID},  subito dopo il numero del job. Normalmente non \`{e}
 necessario conoscere il PID dei processi, ma qualche volta pu\`{o}
 tornare
 utile.
 
 Eliminiamo il secondo processo, dato che pu\`o rallentare la
 macchina. Potrei semplicemente scrivere {\tt kill \%2}, ma sarebbe troppo
 semplice. Invece, facciamo cos\`{\i}:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ fg %2
 yes | sort > /dev/null
 [e poi premete ctrl-C per eliminarlo]
 \end{verbatim}\end{screen}
 
 Come abbiamo appena dimostrato, {\tt fg} prende anche i parametri
 che cominciano 
 con {\tt \%}. In effetti, potevate anche digitare:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ %2
 yes | sort >/dev/null
 [e poi premete ctrl-C per eliminarlo]
 \end{verbatim}\end{screen}
 
 Questo funziona perch\'e la shell interpreta automaticamente un numero di job
 come una richiesta di mettere quel job in foreground. \`E possibile
 distinguere un numero di job da altri numeri anteponendo {\tt \%}. Adesso
 digitiamo {\tt jobs} per vedere quali job sono ancora in esecuzione:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ jobs
 [1]-  Running                 yes >/dev/null  &
 [3]+  Stopped                 yes | uniq >/dev/null
 \end{verbatim}\end{screen}
 
 Il ``{\tt -}'' significa che il job numero 1 \`{e} il secondo job
 pronto ad essere messo in foreground, se digitate {\tt fg} senza dare nessun
 altro parametro. Il ``{\tt +}'' significa che il job in questione \`e
 il primo della lista---un {\tt fg} senza parametri porter\`a in primo
 piano il job numero 3.
 Comunque potete farlo anche tramite il suo numero, se
 volete:        
 
 \begin{screen}\begin{verbatim}
 /home/larry$ fg %1
 yes >/dev/null 
 [adesso premete ctrl-Z per sospenderlo]
 
 [1]+  Stopped                 yes >/dev/null
 
 \end{verbatim}\end{screen}
 
 Essere passati al job numero 1 ed averlo sospeso ha anche cambiato la
 priorit\`a
 di tutti i vostri job. Potete vederlo con il comando {\tt jobs}:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ jobs
 [1]+  Stopped                 yes >/dev/null
 [3]-  Stopped                 yes | uniq >/dev/null
 \end{verbatim}\end{screen}
         
 Adesso sono entrambi sospesi (perch\'e li avete sospesi con
 \key{ctrl-z}), e il job 1 \`e il prossimo job che viene messo in foreground
 per default; questo perch\'e avete lo avete messo in foreground manualmente, e
 successivamente sospeso. Il ``{\tt +}'' si riferisce sempre al job
 pi\`u recente
 che \`e stato sospeso dal foreground. Potete rimetterlo in esecuzione di
 nuovo:
 
 \begin{screen}\begin{verbatim}
 /home/larry$ bg
 [1]+ yes >/dev/null  &
 /home/larry$ jobs
 [1]-  Running                 yes >/dev/null  
 [3]+  Stopped                 yes | uniq >/dev/null
 \end{verbatim}\end{screen}
 
 Notate che adesso \`{e} in esecuzione, e l'altro job \`e tornato
 indietro nell'elenco ed ha il {\tt +}.
 Ora eliminiamo tutti questi job per poter
 usare meglio la macchina:
 
 \begin{screen}\begin{verbatim}
 /home/larry# kill %1 %3
 [3]   Terminated              yes | uniq >/dev/null
 /home/larry# jobs
 [1]+  Terminated              yes >/dev/null
 /home/larry#
 \end{verbatim}
 \end{screen}
 
 Dovreste vedere vari messaggi sulla terminazione dei job---nessuno muore
 tranquillamente, sembra. 
 La Figura~\ref{job-control} fa un breve riassunto di tutto 
 quello
 che dovreste sapere sul controllo dei job:
 
 \begin{figure}[tb]
 \index{shell!controllo dei job!riassunto}
 \begin{dispitems}
 \item{{\tt fg} {\sl \%job}} \`E un comando di shell che riporta in
 foreground un job. Per scoprire a quale viene applicato per default, 
 digitate {\tt jobs} e cercate quello con il {\tt +}.\\
 Parametri:
   Numero di job opzionale. Il default \`e il processo identificato con
   il {\tt +}.
  
 \item{{\tt \&}} Quando viene aggiunta una {\tt \&} alla fine della
   linea di comando, il comando viene eseguito automaticamente in background; il processo \`e poi soggetto a tutti i metodi
 normali di controllo dei job.
  
 \item{{\tt bg} {\sl \%job}} \`E un comando di shell che fa girare
 in background un   job sospeso. Per scoprire quale \`e di default,
 digitate {\tt jobs} e cercate quello con il {\tt +}.\\ Parametri:
 numero di job opzionale. Il default \`e il processo identificato con il
 {\tt +}.
  
 \item{{\tt kill} {\sl \%job} {\sl PID}} \`E un comando di shell che
 termina un job in background, sia sospeso che attivo. Si dovrebbe
 specificare sempre il numero di job, e se state usando il numero di
 job, ricordatevi di anteporvi un {\tt \%}.\\ Parametri: il numero di
 job (preceduto da {\tt \%}) o il PID (senza {\tt \%}). Su una stessa
 linea si possono specificare pi\`u job.
  
 \item{{\tt jobs}} Questo comando di shell elenca semplicemente
 alcune informazioni sui job attivi o sospesi al momento. Talvolta
 indica anche quelli che sono stati appena terminati.  
  
 \item{\key{ctrl-c}}
         \`E il generico carattere di interrupt. In genere, se lo
 digitate mentre c'\`e un programma che gira in primo piano, lo termina
 (qualche volta servono un paio di tentativi); non funziona con tutti i programmi.
  
 \item{\key{ctrl-z}} Questa combinazione di tasti sospende un
 programma, anche se alcuni programmi la ignorano. Una volta che \`e
 stato sospeso, il job pu\`o essere avviato in background o ucciso.
 \end{dispitems}
 \caption{Riassunto dei comandi e dei tasti usati nel controllo dei
 job.}
 \label{job-control}
 \end{figure}
 
 
 \subsection{Cosa sta succedendo veramente?}
 \index{shell!controllo dei job!concetti}
 
 \`E importante capire che il controllo dei job viene fatto dalla shell. Non
 esiste nel sistema un programma {\tt fg}; piuttosto {\tt
 fg},
 {\tt bg}, {\tt \&}, {\tt jobs} e {\tt kill} sono tutti comandi interni alla
 shell (qualche volta {\tt kill} \`{e} un programma indipendente, ma
 la shell {\tt
 bash} usata da Linux ce l'ha interno). Questo \`{e} un
 modo logico di procedere: siccome ogni utente ha il proprio spazio per il
 controllo dei job, e ogni utente ha gi\`a la sua shell, \`{e} pi\`u 
 semplice far
 controllare i job dell'utente alla shell. Quindi, ogni numero di
 job di un
 utente si riferisce soltanto a quell'utente: il mio job numero [1] e il
 tuo job numero [1] sono due processi totalmente differenti. In
 effetti,
 se siete loggati pi\`u di una volta, ogni vostra shell avr\`{a} dati
 diversi
 per controllare i job, cos\`{\i} ogni utente pu\`{o} avere due job diversi
 con lo stesso numero in due shell diverse.
 
 Il modo per riferirsi in modo sicuro ad un processo \`{e} mediante il numero di
 identificazione di processo, o Process ID ({\tt PID}). 
 Questo numero viene assegnato dal sistema---ogni processo
 ha un {\tt PID} univoco. Due utenti diversi possono riferirsi ad un processo
 mediante il suo {\tt PID} e sapere che si stanno riferendo allo stesso
 processo (assumendo che siano loggati nella stessa macchina!).
 
 Diamo un'occhiata ad un altro comando per capite cosa sono i {\tt PID}. Il
 comando {\tt ps} elenca tutti i processi in esecuzione, compresa la vostra
 shell. Provate. Ha anche alcune opzioni: le pi\`{u} importanti
 (secondo
 molti) sono {\tt a}, {\tt u} e {\tt x}. L'opzione {\tt a} elencher\`{a} i
 processi di tutti gli utenti, non solo i vostri. L'opzione {\tt x} mostrer\`{a}
 i processi che non hanno un terminale
 associato.\footnote{Principalmente sono
 programmi di sistema che non comunicano con l'utente attraverso la
 tastiera.} Infine, l'opzione {\tt u} d\`{a} ulteriori informazioni
 sui processi, che spesso sono utili.
 
 Per avere davvero un'idea di cosa sta facendo il sistema, mettete insieme
 tutte le opzioni: {\tt ps -aux}. Potete vedere i processi che usano pi\`{u}
 memoria guardando la colonna {\tt \%MEM}, e pi\`{u} tempo di CPU sulla colonna
 {\tt \%CPU} (la colonna {\tt TIME} elenca il tempo {\em totale\/} di CPU
 usato).\glossary{tempo di CPU}
 
 Un'altra nota veloce sui PID\@. {\tt kill}, oltre ad accettare le opzioni
 nella forma \%{\sl numero-job}, accetta direttamente anche i PID\@.
 Cos\`{\i}, mettete
 {\tt yes > /dev/null} in background, eseguite {\tt ps} e cercate {\tt yes}.
 Quindi digitate {\tt kill PID}.\footnote{In genere \`{e} pi\`{u} semplice eliminare
 il processo tramite il numero di job invece che con il PID.}
 
 Se iniziate a programmare in C nel vostro sistema Linux, imparerete che il
 controllo dei job della shell \`{e} soltanto una versione interattiva delle
 chiamate {\tt fork} e {\tt execl}. \`E troppo complesso da vedere
 qui,
 ma potrebbe essere utile ricordarlo pi\`u avanti quando dovrete
 programmare e
 vorrete eseguire processi multipli di un singolo programma. 
 
 
 \section{Console Virtuali: essere in pi\`{u} posti contemporaneamente}
 
 Linux supporta le {\bf console virtuali}\index{console virtuali}, che
 sono
 un modo per rendere una singola macchina simile a terminali multipli, tutti
 connessi ad un unico kernel Linux. Fortunatamente l'uso delle console
 virtuali \`{e} una delle
 cose pi\`{u} semplici di Linux: ci sono alcuni ``tasti dedicati'' per passare
 rapidamente da una console all'altra. Per provarlo, loggatevi nel sistema
 Linux, tenete premuto il tasto \key{Alt} sinistro e premete \key{F2} (cio\`{e}
 il tasto funzione numero 2).\footnote{Assicuratevi di farlo dalle
 console in modo testo: se state eseguendo X~Window o altre applicazioni
 grafiche, probabilmente non funzioner\`{a}, sebbene voci dicano che X~Window
 permetta di commutare le console virtuali sotto Linux.}
 % I think it does now. -M ****
 
 Vi troverete di fronte ad un altro prompt di login. Niente panico: 
 siete nella console virtuale (VC) numero 2! Loggatevi e fate qualcosa---un
 po' di {\tt ls} o altro---per avere conferma che \`{e} una vera shell di login.
 Ora potete tornare nella VC numero 1, tenendo premuto il tasto
 \key{Alt} sinistro e premendo \key{F1}. Oppure potete passare ad una {\em
 terza\/} VC, in modo ovvio (\key{Alt}-\key{F3}).
 
 I sistemi Linux hanno generalmente quattro VC abilitate per
 default. Potete aumentarle fino a otto; come dovrebbe essere spiegato in
 \ldpsa: basta editare uno o due file in {\tt /etc}, anche se quattro
 dovrebbero essere sufficienti per la maggior parte delle persone.
 % lg: just is more direct and better for both I&GS and UG
 % yup, shouldn't take up space here with this stuff, you're right.
 
 % Umm, the virtual consoles are enabled, there just aren't any
 % shells running in them - you can start programs with stdin from
 % other VCs and/or stdout to other VCs. -M ****
 
 Una volta che vi ci sarete abituati, le VC probabilmente diventeranno
 uno strumento
 indispensabile per fare pi\`u cose contemporaneamente. Per esempio, io uso
 spesso Emacs nella VC~1 (e faccio la maggior parte del mio lavoro
 qui); contemporaneamente ho un
 programma di comunicazione nella VC~3 (cos\`{\i} posso scaricare file con il
 modem mentre lavoro, o portare avanti dei job su una macchina
 remota), e tengo una shell nella VC~2 in caso voglia eseguire
 qualcos'altro senza sospendere il lavoro sulla VC~1.
 % Local Variables:
 % mode: latex
 % TeX-master: "guide"
 % End:
