\label{cha:process_interface}
Come accennato nell'introduzione il processo è l'unità di base con cui un
-sistema unix alloca ed utilizza le risorse. Questo capitolo tratterà
-l'interfaccia base fra il sistema e i processi, su come vengono passati i
-parametri, come viene gestita e allocata la memoria, su come un processo può
-richiedere servizi al sistema, su cosa deve fare quando ha finito la sua
+sistema unix-like alloca ed utilizza le risorse. Questo capitolo tratterà
+l'interfaccia base fra il sistema e i processi, come vengono passati i
+parametri, come viene gestita e allocata la memoria, come un processo può
+richiedere servizi al sistema e cosa deve fare quando ha finito la sua
esecuzione. Nella sezione finale accenneremo ad alcune problematiche generiche
di programmazione.
In genere un programma viene eseguito quando un processo lo fa partire
eseguendo una funzione della famiglia \func{exec}; torneremo su questo e
-sulla la creazione e gestione dei processi nel prossimo capitolo, in questo
+sulla creazione e gestione dei processi nel prossimo capitolo. In questo
affronteremo l'avvio e il funzionamento di un singolo processo partendo dal
-punto di vista del programma posto in esecuzione.
-
+punto di vista del programma che viene messo in esecuzione.
\section{Esecuzione e conclusione di un programma}
-Una delle concetti base relativi ai processi è che un processo esegue sempre
-uno ed un solo programma: si possono avere più processi che eseguono lo stesso
-programma ma ciascun processo vedrà la sua copia del codice (in realtà il
-kernel fa si che tutte le parti uguali siano condivise) avrà un suo spazio di
-indirizzi, variabili proprie e sarà eseguito in maniera completamente
-indipendente da tutti gli altri.
+Uno dei concetti base di Unix è che un processo esegue sempre uno ed un solo
+programma: si possono avere più processi che eseguono lo stesso programma ma
+ciascun processo vedrà la sua copia del codice (in realtà il kernel fa si che
+tutte le parti uguali siano condivise), avrà un suo spazio di indirizzi,
+variabili proprie e sarà eseguito in maniera completamente indipendente da
+tutti gli altri.
Anche quando all'interno di un programma possono essere presenti più
\textsl{filoni} di esecuzione (i cosiddetti \textit{thread}), o questo possa
\label{sec:proc_main}
Quando un programma viene lanciato il kernel esegue una opportuna routine di
-avvio, usando il programma \cmd{ld-linux.so}, è questo programma che prima
-carica le librerie condivise che servono al programma, effettua il link
-dinamico del codice e poi alla fine lo esegue. Infatti, a meno di non aver
-specificato il flag \texttt{-static} durante la compilazione, tutti i
-programmi in Linux sono incompleti e necessitano di essere linkati alle
-librerie condivise quando vengono avviati. La procedura è controllata da
-alcune variabili di ambiente e dal contenuto di \file{/etc/ld.so.conf}, i
-dettagli sono riportati nella man page di \cmd{ld.so}.
+avvio, usando il programma \cmd{ld-linux.so}. Questo programma prima carica
+le librerie condivise che servono al programma, poi effettua il link dinamico
+del codice e alla fine lo esegue. Infatti, a meno di non aver specificato il
+flag \texttt{-static} durante la compilazione, tutti i programmi in Linux sono
+incompleti e necessitano di essere linkati alle librerie condivise quando
+vengono avviati. La procedura è controllata da alcune variabili di ambiente e
+dal contenuto di \file{/etc/ld.so.conf}. I dettagli sono riportati nella man
+page di \cmd{ld.so}.
Il sistema fa partire qualunque programma chiamando la funzione \func{main};
sta al programmatore chiamare così la funzione principale del programma da cui
Causa la conclusione ordinaria del programma restituendo il valore
\var{status} al processo padre.
- La funzione non ritorna. Il processo viene terminato
+ \bodydesc{La funzione non ritorna. Il processo viene terminato.}
\end{prototype}
La funzione \func{exit} è pensata per una conclusione pulita di un programma
Causa la conclusione immediata del programma restituendo il valore
\var{status} al processo padre.
- La funzione non ritorna. Il processo viene terminato.
+ \bodydesc{La funzione non ritorna. Il processo viene terminato.}
\end{prototype}
La funzione chiude tutti i file descriptor appartenenti al processo (si tenga
la chiamata ad \func{exit} che per il ritorno di \func{main}). La prima
funzione che si può utilizzare a tal fine è:
\begin{prototype}{stdlib.h}{void atexit(void (*function)(void))}
- Registra la funzione \var{function} per essere chiamata all'uscita dal
+ Registra la funzione \param{function} per essere chiamata all'uscita dal
programma.
-
- La funzione restituisce 0 in caso di successo e -1 in caso di fallimento,
- \texttt{errno} non viene settata.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+ fallimento, \var{errno} non viene settata.}
\end{prototype}
La funzione richiede come argomento l'indirizzo della opportuna da chiamare
Registra la funzione \var{function} per essere chiamata all'uscita dal
programma. Tutte le funzioni registrate vengono chiamate in ordine inverso
rispetto a quello di registrazione.
-
- La funzione restituisce 0 in caso di successo e -1 in caso di fallimento,
- \var{errno} non viene settata.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+ fallimento, \var{errno} non viene settata.}
\end{prototype}
In questo caso la funzione da chiamare prende due parametri, il primo dei
L'uso di queste funzioni è necessario solo quando si voglia accedere alle
analoghe system call a cui fanno da interfaccia (ad esempio per implementare
una propria versione di \func{malloc}. Le funzioni sono:
-\begin{prototype}{unistd.h}{int *brk(void end\_data\_segment)}
+\begin{functions}
+ \headdecl{unistd.h}
+ \funcdecl{int brk(void *end\_data\_segment)}
Sposta la fine del segmento dei dati all'indirizzo specificato da
\var{end\_data\_segment}.
- La funzione restituisce 0 in caso di successo e -1 in caso di fallimento,
- nel qual caso \var{errno} viene settata a \macro{ENOMEM}.
-\end{prototype}
-\begin{prototype}{unistd.h}{int *sbrk(ptrdiff\_t increment)}
- Incrementa lo spazio dati di un programma di \var{increment}. Un valore
- zero restituisce l'attuale posizione della fine del segmento dati.
+ La funzione restituisce 0 in caso di successo e -1 in caso di
+ fallimento, nel qual caso \var{errno} viene settata a \macro{ENOMEM}.
+
+ \funcdecl{void *sbrk(ptrdiff\_t increment)} Incrementa lo spazio dati di un
+ programma di \var{increment}. Un valore zero restituisce l'attuale posizione
+ della fine del segmento dati.
La funzione restituisce il puntatore all'inizio della nuova zona di memoria
allocata in caso di successo e \macro{NULL} in caso di fallimento, nel qual
caso \macro{errno} viene settata a \macro{ENOMEM}.
-\end{prototype}
+\end{functions}
Queste funzioni sono state deliberatamente escluse dallo standard POSIX.1 e
per i programmi normali è opportuno usare le funzioni di allocazione standard
\var{len} byte. Tutte le pagine che contengono una parte dell'intervallo
sono mantenute in RAM per tutta la durata del blocco.
- La funzione ritorna 0 in caso di successo e -1 in caso di errore, nel qual
- caso \var{errno} è settata ad uno dei valori seguenti:
- \begin{errlist}
- \item \macro{ENOMEM} alcuni indirizzi dell'intervallo specificato non
- corrispondono allo spazio di indirizzi del processo o si è ecceduto il
- numero massimo consentito di pagine bloccate.
- \item \macro{EPERM} il processo non ha i privilegi richiesti per
- l'operazione.
- \item \macro{EINVAL} \var{len} non è un valore positivo.
- \end{errlist}
-
\funcdecl{int munlock(const void *addr, size\_t len)}
- Alloca \var{size} byte nello heap. La memoria non viene inizializzata.
+ Sblocca l'intervallo di memoria da \var{addr} per \var{len} byte.
- Sblocca l'intervallo di memoria da \var{addr} per \var{len} byte. La
- funzione ritorna 0 in caso di successo e -1 in caso di errore, nel qual caso
- \var{errno} è settata ad uno dei valori seguenti:
+
+ \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 in
+ caso di errore, nel qual caso \var{errno} è settata ad uno dei
+ valori seguenti:
\begin{errlist}
- \item \macro{ENOMEM} alcuni indirizzi dell'intervallo specificato non
- corrispondono allo spazio di indirizzi del processo.
- \item \macro{EINVAL} \var{len} non è un valore positivo.
+ \item[\macro{ENOMEM}] alcuni indirizzi dell'intervallo specificato non
+ corrispondono allo spazio di indirizzi del processo o si è ecceduto
+ il numero massimo consentito di pagine bloccate.
+ \item[\macro{EINVAL}] \var{len} non è un valore positivo.
\end{errlist}
+ e, per \func{mlock}, anche \macro{EPERM} quando il processo non ha i
+ privilegi richiesti per l'operazione.}
\end{functions}
Altre due funzioni, \func{mlockall} e \func{munlockall}, consentono di
\funcdecl{int mlockall(int flags)}
Blocca la paginazione per lo spazio di indirizzi del processo corrente.
- Codici di ritorno ed errori sono gli stessi di \func{mlock}.
-
\funcdecl{int munlockall(void)}
Sblocca la paginazione per lo spazio di indirizzi del processo corrente.
- Codici di ritorno ed errori sono gli stessi di \func{munlock}.
+ \bodydesc{Codici di ritorno ed errori sono gli stessi di \func{mlock}
+ e \func{munlock}.}
\end{functions}
Il parametro \var{flags} di \func{mlockall} permette di controllarne il
che ha il seguente prototipo:
\begin{prototype}{unistd.h}
{int getopt(int argc, char * const argv[], const char * optstring)}
-La funzione esegue il parsing degli argomenti passati da linea di comando
+Esegue il parsing degli argomenti passati da linea di comando
riconoscendo le possibili opzioni segnalate con \var{optstring}.
-Ritorna il carattere che segue l'opzione, \cmd{':'} se manca un parametro
-all'opzione, \cmd{'?'} se l'opzione è sconosciuta, e -1 se non esistono altre
-opzioni.
+\bodydesc{Ritorna il carattere che segue l'opzione, \cmd{':'} se manca un
+ parametro all'opzione, \cmd{'?'} se l'opzione è sconosciuta, e -1 se non
+ esistono altre opzioni.}
\end{prototype}
Questa funzione prende come argomenti le due variabili \var{argc} e \var{argv}
\cmd{--} la scansione viene considerata conclusa, anche se vi sono altri
elementi di \var{argv} che cominciano con il carattere \texttt{'-'}.
-\begin{figure}[htbp]
+\begin{figure}[htb]
\footnotesize
\begin{lstlisting}{}
opterr = 0; /* don't want writing to stderr */
Esamina l'ambiente del processo cercando una stringa che corrisponda a
quella specificata da \param{name}.
- La funzione \macro{NULL} se non trova nulla, o il puntatore alla stringa che
- corrisponde (di solito nella forma \texttt{NOME=valore}).
+ \bodydesc{La funzione ritorna \macro{NULL} se non trova nulla, o il
+ puntatore alla stringa che corrisponde (di solito nella forma
+ \texttt{NOME=valore}).}
\end{prototype}
Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
\label{tab:proc_env_func}
\end{table}
-In Linux solo le prime quattro funzioni di \curtab\ sono definite; i prototipi
-delle restanti tre sono i seguenti:
-
+In Linux solo le prime quattro funzioni di \curtab\ sono definite; delle tre
+restanti le prime due, \func{putenv} e \func{setenv} servono per assegnare
+nuove variabili di ambiente, i loro prototipi sono i seguenti:
\begin{functions}
- \headdecl{stdlib.h}
- \funcdecl{int putenv(char *string)}
- La funzione aggiunge la stringa \param{string} all'ambiente.
+ \headdecl{stdlib.h}
+
+ \funcdecl{int putenv(char *string)} Aggiunge la stringa \param{string}
+ all'ambiente.
+
\funcdecl{int setenv(const char *name, const char *value, int overwrite)}
- La funzione setta la variabile di ambiente \param{name} al valore
- \param{value}.
+ Setta la variabile di ambiente \param{name} al valore \param{value}.
+
+ \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 per un
+ errore, che è sempre \macro{ENOMEM}.}
+\end{functions}
+\noindent la terza è:
+\begin{functions}
+ \headdecl{stdlib.h}
- Entrambe le funzioni ritornano 0 in caso di successo e -1 per un errore, che
- è sempre \macro{ENOMEM}.
-
\funcdecl{void unsetenv(const char *name)}
- La funzione rimuove la variabile di ambiente \param{name}.
+ Rimuove la variabile di ambiente \param{name}.
\end{functions}
Per cancellare una variabile di ambiente si usa \func{unsetenv}, che elimina
viene usato questo meccanismo.
+\subsection{Il passaggio di un numero variabile di argomenti}
+\label{sec:proc_variadic}
+
+Come vedremo nei capitoli successivi, non sempre è possibile specificare
+un numero fisso di parametri per una funzione. Lo standard ISO C
+prevede la possibilità di definire delle \textit{varadic function} che
+abbiano un numero variabile di argomenti, ma non provvede nessun
+meccanismo con cui queste funzioni possono accedere a questi argomenti.
+
+(NdT il resto è da fare).
+
\subsection{Potenziali problemi con le variabili automatiche}
\label{sec:proc_auto_var}
Il C però non consente di effettuare un salto ad una label definita in
un'altra funzione, per cui se l'errore avviene in funzioni profondamente
-annidate occorre usare la funzioni \func{setjmp} e \func{longjmp}, il cui
-prototipo è:
+annidate occorre usare quello che viene chiamato un salto \textsl{non-locale};
+questo viene fatto usando salvando il contesto dello stack nel punto in cui si
+vuole tornare in caso di errore, e ripristinandolo quando l'occorrenza capita.
+
+
+La funzione che permette di salvare il contesto dello stack è \func{setjmp},
+il cui prototipo è:
\begin{functions}
\headdecl{setjmp.h}
\funcdecl{void setjmp(jmp\_buf env)}
- La funzione salva il contesto dello stack in \param{env} per un successivo
- uso da parte di \func{longjmp}. Il contesto viene invalidato se la routine
- che ha chiamato \func{setjmp} ritorna.
+ Salva il contesto dello stack in \param{env} per un successivo uso da parte
+ di \func{longjmp}. Il contesto viene invalidato se la routine che ha
+ chiamato \func{setjmp} ritorna.
- La funzione ritorna zero quando è chiamata direttamente e un valore diverso
- da zero quando ritorna da una chiamata di \func{longjmp} che usa il contesto
- salvato in precedenza.
+ \bodydesc{La funzione ritorna zero quando è chiamata direttamente e un
+ valore diverso da zero quando ritorna da una chiamata di \func{longjmp}
+ che usa il contesto salvato in precedenza.}
+\end{functions}
+
+Per poter effettuare un salto non locale si usa la funzione \func{longjmp}; il
+suo prototipo è:
+\begin{functions}
+ \headdecl{setjmp.h}
\funcdecl{void longjmp(jmp\_buf env, int val)}
Ripristina il contesto dello stack salvato dall'ultima chiamata di
di \func{setjmp} con un valore \param{val}. Il valore di \param{val} deve
essere diverso da zero, se viene specificato 0 sarà usato 1 al suo posto.
- La funzione non ritorna.
+ \bodydesc{La funzione non ritorna.}
\end{functions}
projects / gapil.git / blobdiff