%% process.tex
%%
-%% Copyright (C) 2000-2004 Simone Piccardi. Permission is granted to
+%% Copyright (C) 2000-2005 Simone Piccardi. Permission is granted to
%% copy, distribute and/or modify this document under the terms of the GNU Free
%% Documentation License, Version 1.1 or any later version published by the
-%% Free Software Foundation; with the Invariant Sections being "Prefazione",
+%% Free Software Foundation; with the Invariant Sections being "Un preambolo",
%% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
%% license is included in the section entitled "GNU Free Documentation
%% License".
Come accennato nell'introduzione il \textsl{processo} è l'unità di base con
cui un 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ò
+gli argomenti, 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.
Quando un programma viene lanciato il kernel esegue un'opportuna routine di
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 \textit{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}.
+le librerie condivise che servono al programma, poi effettua il collegamento
+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 \textsl{collegati}
+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
si suppone iniziare l'esecuzione; in ogni caso senza questa funzione lo stesso
-\textit{linker} darebbe luogo ad errori.
-
-Lo standard ISO C specifica che la funzione \func{main} può non avere
-argomenti o prendere due argomenti che rappresentano gli argomenti passati da
-linea di comando, in sostanza un prototipo che va sempre bene è il seguente:
+\textit{linker} (ci chiama così il programma che effettua i collegamenti di
+cui sopra) darebbe luogo ad errori. Lo standard ISO C specifica che la
+funzione \func{main} può non avere argomenti o prendere due argomenti che
+rappresentano gli argomenti passati da linea di comando, in sostanza un
+prototipo che va sempre bene è il seguente:
\includecodesnip{listati/main_def.c}
In realtà nei sistemi Unix esiste un'altro modo per definire la funzione
-\func{main}, che prevede la presenza di un terzo parametro, \code{char
- *envp[]}, che fornisce l'\textsl{ambiente} (vedi sez.~\ref{sec:proc_environ})
-del programma; questa forma però non è prevista dallo standard POSIX.1 per cui
-se si vogliono scrivere programmi portabili è meglio evitarla.
+\func{main}, che prevede la presenza di un terzo argomento, \code{char
+ *envp[]}, che fornisce (vedi sez.~\ref{sec:proc_environ})
+l'\textsl{ambiente} del programma; questa forma però non è prevista dallo
+standard POSIX.1 per cui se si vogliono scrivere programmi portabili è meglio
+evitarla.
\subsection{Come chiudere un programma}
La funzione chiude tutti i file descriptor appartenenti al processo (si tenga
presente che questo non comporta il salvataggio dei dati bufferizzati degli
-stream), fa sì che ogni figlio del processo sia ereditato da \cmd{init} (vedi
+stream), fa sì che ogni figlio del processo sia adottato da \cmd{init} (vedi
cap.~\ref{cha:process_handling}), manda un segnale \const{SIGCHLD} al processo
padre (vedi sez.~\ref{sec:sig_job_control}) ed infine ritorna lo stato di
uscita specificato in \param{status} che può essere raccolto usando la
fallimento, \var{errno} non viene modificata.}
\end{prototype}
-In questo caso la funzione da chiamare all'uscita prende i due parametri
+In questo caso la funzione da chiamare all'uscita prende i due argomenti
specificati nel prototipo, dovrà cioè essere definita come \code{void
function(int status, void *argp)}. Il primo argomento sarà inizializzato
allo stato di uscita con cui è stata chiamata \func{exit} ed il secondo al
Ci sono vari modi in cui i vari sistemi organizzano la memoria (ed i dettagli
di basso livello dipendono spesso in maniera diretta dall'architettura
dell'hardware), ma quello più tipico, usato dai sistemi unix-like come Linux è
-la cosiddetta \textsl{memoria virtuale}\index{memoria virtuale} che consiste
+la cosiddetta \textsl{memoria virtuale}\index{memoria~virtuale} che consiste
nell'assegnare ad ogni processo uno spazio virtuale di indirizzamento lineare,
in cui gli indirizzi vanno da zero ad un qualche valore massimo.\footnote{nel
caso di Linux fino al kernel 2.2 detto massimo era, per macchine a 32bit, di
2Gb. Con il kernel 2.4 ed il supporto per la \textit{high-memory} il limite
- è stato esteso.}
+ è stato esteso anche per macchine a 32 bit.}
Come accennato in cap.~\ref{cha:intro_unix} questo spazio di indirizzi è
virtuale e non corrisponde all'effettiva posizione dei dati nella RAM del
sola pagina di memoria reale che farà da supporto a tutte le pagine di memoria
virtuale di tutti i processi che hanno detta funzione nel loro codice.
-La corrispondenza fra le pagine della memoria virtuale e quelle della memoria
-fisica della macchina viene gestita in maniera trasparente dall'hardware di
-gestione della memoria (la \textit{Memory Management Unit} del processore).
-Poiché in genere la memoria fisica è solo una piccola frazione della memoria
-virtuale, è necessario un meccanismo che permetta di trasferire le pagine che
-servono dal supporto su cui si trovano in memoria, eliminando quelle che non
-servono. Questo meccanismo è detto \textsl{paginazione}\index{paginazione} (o
-\textit{paging}), ed è uno dei compiti principali del kernel.
+La corrispondenza fra le pagine della \index{memoria~virtuale}memoria virtuale
+e quelle della memoria fisica della macchina viene gestita in maniera
+trasparente dall'hardware di gestione della memoria (la \textit{Memory
+ Management Unit} del processore). Poiché in genere la memoria fisica è solo
+una piccola frazione della memoria virtuale, è necessario un meccanismo che
+permetta di trasferire le pagine che servono dal supporto su cui si trovano in
+memoria, eliminando quelle che non servono. Questo meccanismo è detto
+\textsl{paginazione}\index{paginazione} (o \textit{paging}), ed è uno dei
+compiti principali del kernel.
Quando un processo cerca di accedere ad una pagina che non è nella memoria
-reale, avviene quello che viene chiamato un
-\textit{page fault}\index{page fault};
-l'hardware di gestione della memoria genera un'interruzione e passa
-il controllo al kernel il quale sospende il processo e si incarica di mettere
-in RAM la pagina richiesta (effettuando tutte le operazioni necessarie per
-reperire lo spazio necessario), per poi restituire il controllo al processo.
+reale, avviene quello che viene chiamato un \textit{page
+ fault}\index{\textit{page~fault}}; l'hardware di gestione della memoria
+genera un'interruzione e passa il controllo al kernel il quale sospende il
+processo e si incarica di mettere in RAM la pagina richiesta (effettuando
+tutte le operazioni necessarie per reperire lo spazio necessario), per poi
+restituire il controllo al processo.
Dal punto di vista di un processo questo meccanismo è completamente
trasparente, e tutto avviene come se tutte le pagine fossero sempre
commette quando si è manipolato male un puntatore e genera quello che viene
chiamato un \textit{segmentation fault}. Se si tenta cioè di leggere o
scrivere da un indirizzo per il quale non esiste un'associazione della pagina
-virtuale, il kernel risponde al relativo \textit{page fault}\index{page fault}
-mandando un segnale \const{SIGSEGV} al processo, che normalmente ne causa la
-terminazione immediata.
+virtuale, il kernel risponde al relativo \textit{page
+ fault}\index{\textit{page~fault}} mandando un segnale \const{SIGSEGV} al
+processo, che normalmente ne causa la terminazione immediata.
È pertanto importante capire come viene strutturata \textsl{la memoria
- virtuale}\index{page fault} di un processo. Essa viene divisa in
+ virtuale}\index{\textit{page~fault}} di un processo. Essa viene divisa in
\textsl{segmenti}, cioè un insieme contiguo di indirizzi virtuali ai quali il
processo può accedere. Solitamente un programma C viene suddiviso nei
seguenti segmenti:
puntatori a \val{NULL}).\footnote{si ricordi che questo vale solo per le
variabili che vanno nel segmento dati, e non è affatto vero in generale.}
- Storicamente questo segmento viene chiamato BSS (da \textit{block started by
- symbol}). La sua dimensione è fissa.
+ Storicamente questa seconda parte del segmento dati viene chiamata BSS (da
+ \textit{Block Started by Symbol}). La sua dimensione è fissa.
\item Lo \textit{heap}. Tecnicamente lo si può considerare l'estensione del
segmento dati, a cui di solito è posto giusto di seguito. È qui che avviene
\begin{figure}[htb]
\centering
- \includegraphics[height=12cm]{img/memory_layout}
+ \includegraphics[height=11cm]{img/memory_layout}
\caption{Disposizione tipica dei segmenti di memoria di un processo.}
\label{fig:proc_mem_layout}
\end{figure}
per queste variabili viene allocato nello stack quando viene eseguita la
funzione e liberato quando si esce dalla medesima.
-Esiste però un terzo tipo di allocazione, l'\textsl{allocazione dinamica della
- memoria}, che non è prevista direttamente all'interno del linguaggio C, ma
-che è necessaria quando il quantitativo di memoria che serve è determinabile
-solo durante il corso dell'esecuzione del programma.
+Esiste però un terzo tipo di allocazione, l'\textsl{allocazione dinamica}
+della memoria, che non è prevista direttamente all'interno del linguaggio C,
+ma che è necessaria quando il quantitativo di memoria che serve è
+determinabile solo durante il corso dell'esecuzione del programma.
Il C non consente di usare variabili allocate dinamicamente, non è possibile
cioè definire in fase di programmazione una variabile le cui dimensioni
La memoria allocata dinamicamente deve essere esplicitamente rilasciata usando
\func{free}\footnote{le glibc provvedono anche una funzione \func{cfree}
definita per compatibilità con SunOS, che è deprecata.} una volta che non
-sia più necessaria. Questa funzione vuole come parametro un puntatore
+sia più necessaria. Questa funzione vuole come argomento un puntatore
restituito da una precedente chiamata a una qualunque delle funzioni di
allocazione che non sia già stato liberato da un'altra chiamata a \func{free},
in caso contrario il comportamento della funzione è indefinito.
puntatori) è quello di chiamare \func{free} più di una volta sullo stesso
puntatore; per evitare questo problema una soluzione di ripiego è quella di
assegnare sempre a \val{NULL} ogni puntatore liberato con \func{free}, dato
-che, quando il parametro è un puntatore nullo, \func{free} non esegue nessuna
+che, quando l'argomento è un puntatore nullo, \func{free} non esegue nessuna
operazione.
Le \acr{glibc} hanno un'implementazione delle routine di allocazione che è
Il problema più comune e più difficile da risolvere che si incontra con le
routine di allocazione è quando non viene opportunamente liberata la memoria
non più utilizzata, quello che in inglese viene chiamato \textit{memory
- leak}\index{memory leak}, cioè una \textsl{perdita di memoria}.
+ leak}\index{\textit{memory~leak}}, cioè una \textsl{perdita di memoria}.
Un caso tipico che illustra il problema è quello in cui in una subroutine si
alloca della memoria per uso locale senza liberarla prima di uscire. La
momento, in corrispondenza ad una qualunque chiamata di \func{malloc}, che può
essere in una sezione del codice che non ha alcuna relazione con la subroutine
che contiene l'errore. Per questo motivo è sempre molto difficile trovare un
-\textit{memory leak}\index{memory leak}.
+\textit{memory leak}\index{\textit{memory~leak}}.
In C e C++ il problema è particolarmente sentito. In C++, per mezzo della
programmazione ad oggetti, il problema dei \textit{memory leak} è notevolmente
specializzata per il debugging). Esistono varie librerie che forniscono dei
sostituti opportuni delle routine di allocazione in grado, senza neanche
ricompilare il programma,\footnote{esempi sono \textit{Dmalloc}
- \href{http://dmalloc.com/}{http://dmalloc.com/} di Gray Watson ed
+ \href{http://dmalloc.com/}{\textsf{http://dmalloc.com/}} di Gray Watson ed
\textit{Electric Fence} di Bruce Perens.} di eseguire diagnostiche anche
molto complesse riguardo l'allocazione della memoria.
-
-\subsection{La funzione \func{alloca}}
-\label{sec:proc_mem_alloca}
+\subsection{Le funzioni \func{alloca}, \func{brk} e \func{sbrk}}
+\label{sec:proc_mem_sbrk_alloca}
Una possibile alternativa all'uso di \func{malloc}, che non soffre dei
-problemi di \textit{memory leak}\index{memory leak} descritti in precedenza, è
-la funzione \funcd{alloca}, che invece di allocare la memoria nello heap usa
-il segmento di stack della funzione corrente. La sintassi è identica a quella
-di \func{malloc}, il suo prototipo è:
+problemi di \textit{memory leak}\index{\textit{memory~leak}} descritti in
+precedenza, è la funzione \funcd{alloca}, che invece di allocare la memoria
+nello heap usa il segmento di stack della funzione corrente. La sintassi è
+identica a quella di \func{malloc}, il suo prototipo è:
\begin{prototype}{stdlib.h}{void *alloca(size\_t size)}
Alloca \param{size} byte nello stack.
rilasciata automaticamente al ritorno della funzione.
Come è evidente questa funzione ha molti vantaggi, anzitutto permette di
-evitare alla radice i problemi di memory leak\index{memory leak}, dato che non
-serve più la deallocazione esplicita; inoltre la deallocazione automatica
-funziona anche quando si usa \func{longjmp} per uscire da una subroutine con
-un salto non locale da una funzione (vedi sez.~\ref{sec:proc_longjmp}).
+evitare alla radice i problemi di memory leak\index{\textit{memory~leak}},
+dato che non serve più la deallocazione esplicita; inoltre la deallocazione
+automatica funziona anche quando si usa \func{longjmp} per uscire da una
+subroutine con un salto non locale da una funzione (vedi
+sez.~\ref{sec:proc_longjmp}).
Un altro vantaggio è che in Linux la funzione è molto più veloce di
\func{malloc} e non viene sprecato spazio, infatti non è necessario gestire un
cui torneremo in sez.~\ref{sec:proc_auto_var}.
-\subsection{Le funzioni \func{brk} e \func{sbrk}}
-\label{sec:proc_mem_sbrk}
-
Queste due funzioni vengono utilizzate soltanto quando è necessario effettuare
direttamente la gestione della memoria associata allo spazio dati di un
processo, ad esempio qualora si debba implementare la propria versione delle
% \label{sec:proc_mem_malloc_custom}
-\subsection{Il controllo della memoria virtuale\index{memoria virtuale}}
+\subsection{Il controllo della memoria virtuale}
\label{sec:proc_mem_lock}
+\index{memoria~virtuale|(}
Come spiegato in sez.~\ref{sec:proc_mem_gen} il kernel gestisce la memoria
virtuale in maniera trasparente ai processi, decidendo quando rimuovere pagine
dalla memoria per metterle nello swap, sulla base dell'utilizzo corrente da
crittografia richiedono il blocco di alcune pagine di memoria.
\end{itemize}
+\index{\textit{memory~locking}|(}
Il meccanismo che previene la paginazione\index{paginazione} di parte della
memoria virtuale di un processo è chiamato \textit{memory locking} (o
\textsl{blocco della memoria}). Il blocco è sempre associato alle pagine della
comporta anche la fine dell'uso della sua memoria virtuale, e quindi anche di
tutti i suoi \textit{memory lock}. Infine \textit{memory lock} non sono
ereditati dai processi figli.\footnote{ma siccome Linux usa il \textit{copy on
- write}\index{copy on write} (vedi sez.~\ref{sec:proc_fork}) gli indirizzi
- virtuali del figlio sono mantenuti sullo stesso segmento di RAM del padre,
- quindi fintanto che un figlio non scrive su un segmento, può usufruire del
- memory lock del padre.}
+ write} (vedi sez.~\ref{sec:proc_fork}) gli indirizzi virtuali del figlio
+ sono mantenuti sullo stesso segmento di RAM del padre, quindi fintanto che
+ un figlio non scrive su un segmento, può usufruire del \textit{memory lock}
+ del padre.}
Siccome la richiesta di un \textit{memory lock} da parte di un processo riduce
la memoria fisica disponibile nel sistema, questo ha un evidente impatto su
In ogni caso un processo real-time che deve entrare in una sezione critica
deve provvedere a riservare memoria sufficiente prima dell'ingresso, per
-scongiurare l'occorrenza di un eventuale \textit{page fault}\index{page fault}
-causato dal meccanismo di \textit{copy on write}\index{copy on write}.
-Infatti se nella sezione critica si va ad utilizzare memoria che non è ancora
-stata riportata in RAM si potrebbe avere un page fault durante l'esecuzione
-della stessa, con conseguente rallentamento (probabilmente inaccettabile) dei
-tempi di esecuzione.
+scongiurare l'occorrenza di un eventuale \textit{page
+ fault}\index{\textit{page~fault}} causato dal meccanismo di \textit{copy on
+ write}\index{\textit{copy~on~write}}. Infatti se nella sezione critica si
+va ad utilizzare memoria che non è ancora stata riportata in RAM si potrebbe
+avere un page fault durante l'esecuzione della stessa, con conseguente
+rallentamento (probabilmente inaccettabile) dei tempi di esecuzione.
In genere si ovvia a questa problematica chiamando una funzione che ha
allocato una quantità sufficientemente ampia di variabili automatiche, in modo
che esse vengano mappate in RAM dallo stack, dopo di che, per essere sicuri
che esse siano state effettivamente portate in memoria, ci si scrive sopra.
+\index{memoria~virtuale|)}
+\index{\textit{memory~locking}|)}
-\section{Parametri, opzioni ed ambiente di un processo}
+\section{Argomenti, opzioni ed ambiente di un processo}
\label{sec:proc_options}
-Tutti i programmi hanno la possibilità di ricevere parametri e opzioni quando
-vengono lanciati. Il passaggio dei parametri è effettuato attraverso gli
+Tutti i programmi hanno la possibilità di ricevere argomenti e opzioni quando
+vengono lanciati. Il passaggio degli argomenti è effettuato attraverso gli
argomenti \param{argc} e \param{argv} della funzione \func{main}, che vengono
passati al programma dalla shell (o dal processo che esegue la \func{exec},
secondo le modalità che vedremo in sez.~\ref{sec:proc_exec}) quando questo
viene messo in esecuzione.
-Oltre al passaggio dei parametri, un'altra modalità che permette di passare
+Oltre al passaggio degli argomenti, un'altra modalità che permette di passare
delle informazioni che modifichino il comportamento di un programma è quello
dell'uso del cosiddetto \textit{environment} (cioè l'uso delle
\textsl{variabili di ambiente}). In questa sezione esamineremo le funzioni che
-permettono di gestire parametri ed opzioni, e quelle che consentono di
+permettono di gestire argomenti ed opzioni, e quelle che consentono di
manipolare ed utilizzare le variabili di ambiente.
-\subsection{Il formato dei parametri}
+\subsection{Il formato degli argomenti}
\label{sec:proc_par_format}
-In genere passaggio dei parametri al programma viene effettuato dalla shell,
+In genere passaggio degli argomenti al programma viene effettuato dalla shell,
che si incarica di leggere la linea di comando e di effettuarne la scansione
(il cosiddetto \textit{parsing}) per individuare le parole che la compongono,
-ciascuna delle quali viene considerata un parametro. Di norma per individuare
+ciascuna delle quali viene considerata un argomento. Di norma per individuare
le parole viene usato come carattere di separazione lo spazio o il tabulatore,
ma il comportamento è modificabile attraverso l'impostazione della variabile
di ambiente \cmd{IFS}.
\begin{figure}[htb]
\centering
- \includegraphics[width=11cm]{img/argv_argc}
+ \includegraphics[width=13cm]{img/argv_argc}
\caption{Esempio dei valori di \param{argv} e \param{argc} generati nella
scansione di una riga di comando.}
\label{fig:proc_argv_argc}
\end{figure}
Nella scansione viene costruito il vettore di puntatori \param{argv} inserendo
-in successione il puntatore alla stringa costituente l'$n$-simo parametro; la
-variabile \param{argc} viene inizializzata al numero di parametri trovati, in
-questo modo il primo parametro è sempre il nome del programma; un esempio di
+in successione il puntatore alla stringa costituente l'$n$-simo argomento; la
+variabile \param{argc} viene inizializzata al numero di argomenti trovati, in
+questo modo il primo argomento è sempre il nome del programma; un esempio di
questo meccanismo è mostrato in fig.~\ref{fig:proc_argv_argc}.
In generale un programma Unix riceve da linea di comando sia gli argomenti che
le opzioni, queste ultime sono standardizzate per essere riconosciute come
tali: un elemento di \param{argv} che inizia con il carattere \texttt{'-'} e
-che non sia un singolo \texttt{'-'} o un \texttt{'--'} viene considerato
+che non sia un singolo \texttt{'-'} o un \texttt{'-{}-'} viene considerato
un'opzione. In genere le opzioni sono costituite da una lettera singola
(preceduta dal carattere \cmd{'-'}) e possono avere o no un parametro
associato; un comando tipico può essere quello mostrato in
dichiarata in \param{optstring} viene ritornato il carattere \texttt{'?'}
mentre se un opzione che lo richiede non è seguita da un parametro viene
ritornato il carattere \texttt{':'}, infine se viene incontrato il valore
-\texttt{'--'} la scansione viene considerata conclusa, anche se vi sono altri
+\texttt{'-{}-'} la scansione viene considerata conclusa, anche se vi sono altri
elementi di \param{argv} che cominciano con il carattere \texttt{'-'}.
\begin{figure}[htb]
\label{sec:proc_opt_extended}
Un'estensione di questo schema è costituito dalle cosiddette
-\textit{long-options} espresse nella forma \cmd{--option=parameter}, anche la
-gestione di queste ultime è stata standardizzata attraverso l'uso di una
+\textit{long-options} espresse nella forma \cmd{-{}-option=parameter}, anche
+la gestione di queste ultime è stata standardizzata attraverso l'uso di una
versione estesa di \func{getopt}.
-(NdA: da finire).
+(NdA: questa parte verrà inserita in seguito).
\subsection{Le variabili di ambiente}
\textit{environment list}) messa a disposizione dal processo, e costruita
nella chiamata alla funzione \func{exec} quando questo viene lanciato.
-Come per la lista dei parametri anche questa lista è un vettore di puntatori a
-caratteri, ciascuno dei quali punta ad una stringa, terminata da un
+Come per la lista degli argomenti anche questa lista è un vettore di puntatori
+a caratteri, ciascuno dei quali punta ad una stringa, terminata da un
\val{NULL}. A differenza di \code{argv[]} in questo caso non si ha una
lunghezza del vettore data da un equivalente di \param{argc}, ma la lista è
terminata da un puntatore nullo.
fig.~\ref{fig:proc_envirno_list}.
\begin{figure}[htb]
\centering
- \includegraphics[width=11cm]{img/environ_var}
+ \includegraphics[width=13cm]{img/environ_var}
\caption{Esempio di lista delle variabili di ambiente.}
\label{fig:proc_envirno_list}
\end{figure}
queste variabili al programma messo in esecuzione attraverso un uso opportuno
delle relative chiamate (si veda sez.~\ref{sec:proc_exec}).
-La shell ad esempio ne usa molte per il suo funzionamento (come \var{PATH} per
-la ricerca dei comandi, o \cmd{IFS} per la scansione degli argomenti), e
-alcune di esse (come \var{HOME}, \var{USER}, etc.) sono definite al login (per
-i dettagli si veda sez.~\ref{sec:sess_login}). In genere è cura
+La shell ad esempio ne usa molte per il suo funzionamento (come \texttt{PATH}
+per la ricerca dei comandi, o \texttt{IFS} per la scansione degli argomenti),
+e alcune di esse (come \texttt{HOME}, \texttt{USER}, ecc.) sono definite al
+login (per i dettagli si veda sez.~\ref{sec:sess_login}). In genere è cura
dell'amministratore definire le opportune variabili di ambiente in uno script
di avvio. Alcune servono poi come riferimento generico per molti programmi
-(come \var{EDITOR} che indica l'editor preferito da invocare in caso di
+(come \texttt{EDITOR} che indica l'editor preferito da invocare in caso di
necessità).
Gli standard POSIX e XPG3 definiscono alcune di queste variabili (le più
& \textbf{Linux} & \textbf{Descrizione} \\
\hline
\hline
- \val{USER} & $\bullet$ & $\bullet$ & $\bullet$ & Nome utente\\
- \val{LOGNAME} & $\bullet$ & $\bullet$ & $\bullet$ & Nome di login\\
- \val{HOME} & $\bullet$ & $\bullet$ & $\bullet$ &
- Directory base dell'utente\\
- \val{LANG} & $\bullet$ & $\bullet$ & $\bullet$ & Localizzazione\\
- \val{PATH} & $\bullet$ & $\bullet$ & $\bullet$ & Elenco delle directory
- dei programmi\\
- \val{PWD} & $\bullet$ & $\bullet$ & $\bullet$ & Directory corrente\\
- \val{SHELL} & $\bullet$ & $\bullet$ & $\bullet$ & Shell in uso\\
- \val{TERM} & $\bullet$ & $\bullet$ & $\bullet$ & Tipo di terminale\\
- \val{PAGER} & $\bullet$ & $\bullet$ & $\bullet$ & Programma per vedere i
- testi\\
- \val{EDITOR} & $\bullet$ & $\bullet$ & $\bullet$ & Editor preferito\\
- \val{BROWSER} & $\bullet$ & $\bullet$ & $\bullet$ & Browser preferito\\
- \val{TMPDIR} & $\bullet$ & $\bullet$ & $\bullet$ & Directory dei file
- temporanei\\
+ \texttt{USER} &$\bullet$&$\bullet$&$\bullet$& Nome utente\\
+ \texttt{LOGNAME}&$\bullet$&$\bullet$&$\bullet$& Nome di login\\
+ \texttt{HOME} &$\bullet$&$\bullet$&$\bullet$& Directory base
+ dell'utente\\
+ \texttt{LANG} &$\bullet$&$\bullet$&$\bullet$& Localizzazione\\
+ \texttt{PATH} &$\bullet$&$\bullet$&$\bullet$& Elenco delle directory
+ dei programmi\\
+ \texttt{PWD} &$\bullet$&$\bullet$&$\bullet$& Directory corrente\\
+ \texttt{SHELL} &$\bullet$&$\bullet$&$\bullet$& Shell in uso\\
+ \texttt{TERM} &$\bullet$&$\bullet$&$\bullet$& Tipo di terminale\\
+ \texttt{PAGER} &$\bullet$&$\bullet$&$\bullet$& Programma per vedere i
+ testi\\
+ \texttt{EDITOR} &$\bullet$&$\bullet$&$\bullet$& Editor preferito\\
+ \texttt{BROWSER}&$\bullet$&$\bullet$&$\bullet$& Browser preferito\\
+ \texttt{TMPDIR} &$\bullet$&$\bullet$&$\bullet$& Directory dei file
+ temporanei\\
\hline
\end{tabular}
\caption{Esempi delle variabili di ambiente più comuni definite da vari
variabile esista già, sovrascrivendola se diverso da zero, lasciandola
immutata se uguale a zero.
-La seconda funzione prende come parametro una stringa analoga quella
+La seconda funzione prende come argomento una stringa analoga quella
restituita da \func{getenv}, e sempre nella forma \code{NOME=valore}. Se la
variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
invece esiste il suo valore sarà impostato a quello specificato da
seguendo il comportamento di BSD4.4; dato che questo può dar luogo a perdite
di memoria e non rispetta lo standard. Il comportamento è stato modificato a
partire dalle 2.1.2, eliminando anche, sempre in conformità a SUSv2,
- l'attributo \ctyp{const} dal prototipo.} \param{string} alla lista delle
+ l'attributo \direct{const} dal prototipo.} \param{string} alla lista delle
variabili di ambiente; pertanto ogni cambiamento alla stringa in questione si
riflette automaticamente sull'ambiente, e quindi si deve evitare di passare a
questa funzione una variabile automatica (per evitare i problemi esposti in
variabile, copia che la subroutine potrà modificare a piacere, senza che il
valore originale nella routine chiamante venga toccato. In questo modo non
occorre preoccuparsi di eventuali effetti delle operazioni della subroutine
-sulla variabile passata come parametro.
+sulla variabile passata come argomento.
Questo però va inteso nella maniera corretta. Il passaggio \textit{by value}
vale per qualunque variabile, puntatori compresi; quando però in una
Nella maggior parte delle funzioni di libreria e delle system call i puntatori
vengono usati per scambiare dati (attraverso buffer o strutture) e le
-variabili semplici vengono usate per specificare parametri; in genere le
+variabili semplici vengono usate per specificare argomenti; in genere le
informazioni a riguardo dei risultati vengono passate alla routine chiamante
attraverso il valore di ritorno. È buona norma seguire questa pratica anche
nella programmazione normale.
Talvolta però è necessario che la funzione possa restituire indietro alla
-funzione chiamante un valore relativo ad uno dei suoi parametri. Per far
-questo si usa il cosiddetto \textit{value result argument}, si passa cioè,
-invece di una normale variabile, un puntatore alla stessa; vedremo alcuni
-esempi di questa modalità nelle funzioni che gestiscono i socket (in
+funzione chiamante un valore relativo ad uno dei suoi argomenti. Per far
+questo si usa il cosiddetto
+\index{\textit{value~result~argument}}\textit{value result argument}, si passa
+cioè, invece di una normale variabile, un puntatore alla stessa; vedremo
+alcuni esempi di questa modalità nelle funzioni che gestiscono i socket (in
sez.~\ref{sec:TCP_functions}), in cui, per permettere al kernel di restituire
informazioni sulle dimensioni delle strutture degli indirizzi utilizzate,
viene usato questo meccanismo.
\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 nella
+numero fisso di argomenti per una funzione. Lo standard ISO C prevede nella
sua sintassi la possibilità di definire delle \textit{variadic
function}\index{variadic} che abbiano un numero variabile di argomenti,
-attraverso l'uso della \textit{ellipsis} \code{...} nella dichiarazione della
-funzione; ma non provvede a livello di linguaggio alcun meccanismo con cui
-dette funzioni possono accedere ai loro argomenti.
-
-L'accesso viene invece realizzato dalle librerie standard che provvedono gli
-strumenti adeguati. L'uso delle \textit{variadic function} prevede tre punti:
-\begin{itemize*}
+attraverso l'uso nella dichiarazione della funzione dello speciale costrutto
+``\texttt{...}'', che viene chiamato \textit{ellipsis}.
+
+Lo standard però non provvede a livello di linguaggio alcun meccanismo con cui
+dette funzioni possono accedere ai loro argomenti. L'accesso viene pertanto
+realizzato a livello delle librerie standard del C che provvedono gli
+strumenti adeguati. L'uso di una \textit{variadic function} prevede quindi
+tre punti:
+\begin{itemize}
\item \textsl{Dichiarare} la funzione come \textit{variadic} usando un
prototipo che contenga una \textit{ellipsis}.
-\item \textsl{Definire} la funzione come \textit{variadic} usando lo stesso
+\item \textsl{Definire} la funzione come \textit{variadic} usando la stessa
\textit{ellipsis}, ed utilizzare le apposite macro che consentono la
gestione di un numero variabile di argomenti.
-\item \textsl{Chiamare} la funzione specificando prima gli argomenti fissi, e
- a seguire gli addizionali.
-\end{itemize*}
+\item \textsl{Invocare} la funzione specificando prima gli argomenti fissi, ed
+ a seguire quelli addizionali.
+\end{itemize}
Lo standard ISO C prevede che una \textit{variadic function}\index{variadic}
abbia sempre almeno un argomento fisso; prima di effettuare la dichiarazione
dichiarazione è il prototipo della funzione \func{execl} che vedremo in
sez.~\ref{sec:proc_exec}:
\includecodesnip{listati/exec_sample.c}
-in questo caso la funzione prende due parametri fissi ed un numero variabile
-di altri parametri (che verranno a costituire gli elementi successivi al primo
-del vettore \param{argv} passato al nuovo processo). Lo standard ISO C richiede
-inoltre che l'ultimo degli argomenti fissi sia di tipo
+in questo caso la funzione prende due argomenti fissi ed un numero variabile
+di altri argomenti (che verranno a costituire gli elementi successivi al primo
+del vettore \param{argv} passato al nuovo processo). Lo standard ISO C
+richiede inoltre che l'ultimo degli argomenti fissi sia di tipo
\textit{self-promoting}\footnote{il linguaggio C prevede che quando si
mescolano vari tipi di dati, alcuni di essi possano essere \textsl{promossi}
per compatibilità; ad esempio i tipi \ctyp{float} vengono convertiti
\ctyp{int}. Un tipo \textit{self-promoting} è un tipo che verrebbe promosso
a sé stesso.} il che esclude vettori, puntatori a funzioni e interi di tipo
\ctyp{char} o \ctyp{short} (con segno o meno). Una restrizione ulteriore di
-alcuni compilatori è di non dichiarare l'ultimo parametro fisso come
-\ctyp{register}.
+alcuni compilatori è di non dichiarare l'ultimo argomento fisso come
+\direct{register}.
-Una volta dichiarata la funzione il secondo passo è accedere ai vari parametri
-quando la si va a definire. I parametri fissi infatti hanno un loro nome, ma
-quelli variabili vengono indicati in maniera generica dalla ellipsis.
+Una volta dichiarata la funzione il secondo passo è accedere ai vari argomenti
+quando la si va a definire. Gli argomenti fissi infatti hanno un loro nome, ma
+quelli variabili vengono indicati in maniera generica dalla \textit{ellipsis}.
L'unica modalità in cui essi possono essere recuperati è pertanto quella
sequenziale; essi verranno estratti dallo stack secondo l'ordine in cui sono
stati scritti. Per fare questo in \file{stdarg.h} sono definite delle apposite
macro; la procedura da seguire è la seguente:
-\begin{enumerate*}
+\begin{enumerate}
\item Inizializzare un puntatore alla lista degli argomenti di tipo
\macro{va\_list} attraverso la macro \macro{va\_start}.
\item Accedere ai vari argomenti opzionali con chiamate successive alla macro
\macro{va\_arg}, la prima chiamata restituirà il primo argomento, la seconda
il secondo e così via.
-\item Dichiarare la conclusione dell'estrazione dei parametri invocando la
+\item Dichiarare la conclusione dell'estrazione degli argomenti invocando la
macro \macro{va\_end}.
-\end{enumerate*}
+\end{enumerate}
in generale è perfettamente legittimo richiedere meno argomenti di quelli che
potrebbero essere stati effettivamente forniti, e nella esecuzione delle
\macro{va\_arg} ci si può fermare in qualunque momento ed i restanti argomenti
\funcdecl{void va\_start(va\_list ap, last)} Inizializza il puntatore alla
lista di argomenti \param{ap}; il parametro \param{last} \emph{deve} essere
- l'ultimo dei parametri fissi.
+ l'ultimo degli argomenti fissi.
\funcdecl{type va\_arg(va\_list ap, type)} Restituisce il valore del
- successivo parametro opzionale, modificando opportunamente \param{ap}; la
+ successivo argomento opzionale, modificando opportunamente \param{ap}; la
macro richiede che si specifichi il tipo dell'argomento attraverso il
parametro \param{type} che deve essere il nome del tipo dell'argomento in
questione. Il tipo deve essere \textit{self-promoting}.
Dopo l'uso di \macro{va\_end} la variabile \param{ap} diventa indefinita e
successive chiamate a \macro{va\_arg} non funzioneranno. Si avranno risultati
indefiniti anche chiamando \macro{va\_arg} specificando un tipo che non
-corrisponde a quello del parametro.
+corrisponde a quello dell'argomento.
Un altro limite delle macro è che i passi 1) e 3) devono essere eseguiti nel
corpo principale della funzione, il passo 2) invece può essere eseguito anche
usato (lo standard richiederebbe la chiamata esplicita di \macro{va\_end}),
dato che il valore di \param{ap} risulterebbe indefinito.
-Esistono dei casi in cui è necessario eseguire più volte la scansione dei
-parametri e poter memorizzare una posizione durante la stessa. La cosa più
+Esistono dei casi in cui è necessario eseguire più volte la scansione degli
+argomenti e poter memorizzare una posizione durante la stessa. La cosa più
naturale in questo caso sembrerebbe quella di copiarsi il puntatore alla lista
degli argomenti con una semplice assegnazione. Dato che una delle
realizzazioni più comuni di \macro{va\_list} è quella di un puntatore nello
-stack all'indirizzo dove sono stati salvati i parametri, è assolutamente
+stack all'indirizzo dove sono stati salvati gli argomenti, è assolutamente
normale pensare di poter effettuare questa operazione.
In generale però possono esistere anche realizzazioni diverse, per questo
La chiamata di una funzione con un numero variabile di argomenti, posto che la
si sia dichiarata e definita come tale, non prevede nulla di particolare;
-l'invocazione è identica alle altre, con i parametri, sia quelli fissi che
+l'invocazione è identica alle altre, con gli argomenti, sia quelli fissi che
quelli opzionali, separati da virgole. Quello che però è necessario tenere
-presente è come verranno convertiti gli argomenti variabili.
+presente è come verranno convertiti gli argomenti variabili.
In Linux gli argomenti dello stesso tipo sono passati allo stesso modo, sia
che siano fissi sia che siano opzionali (alcuni sistemi trattano diversamente
Uno dei problemi che si devono affrontare con le funzioni con un numero
variabile di argomenti è che non esiste un modo generico che permetta di
-stabilire quanti sono i parametri passati effettivamente in una chiamata.
+stabilire quanti sono gli argomenti passati effettivamente in una chiamata.
Esistono varie modalità per affrontare questo problema; una delle più
immediate è quella di specificare il numero degli argomenti opzionali come uno
-degli argomenti fissi. Una variazione di questo metodo è l'uso di un parametro
+degli argomenti fissi. Una variazione di questo metodo è l'uso di un argomento
per specificare anche il tipo degli argomenti (come fa la stringa di formato
per \func{printf}).
-Una modalità diversa, che può essere applicata solo quando il tipo dei
-parametri lo rende possibile, è quella che prevede di usare un valore speciale
+Una modalità diversa, che può essere applicata solo quando il tipo degli
+argomenti lo rende possibile, è quella che prevede di usare un valore speciale
come ultimo argomento (come fa ad esempio \func{execl} che usa un puntatore
\val{NULL} per indicare la fine della lista degli argomenti).
efficiente e più chiara anche dal punto di vista della struttura del
programma: quello dell'uscita in caso di errore.
+\index{salto~non-locale|(}
+
Il C però non consente di effettuare un salto ad una etichetta definita in
un'altra funzione, per cui se l'errore avviene in una funzione, e la sua
gestione ordinaria è in un'altra, occorre usare quello che viene chiamato un
-\textsl{salto non-locale}\index{salto non-locale}. Il caso classico in cui si
-ha questa necessità, citato sia da \cite{APUE} che da \cite{glibc}, è quello
-di un programma nel cui corpo principale vengono letti dei dati in ingresso
-sui quali viene eseguita, tramite una serie di funzioni di analisi, una
-scansione dei contenuti da si ottengono le indicazioni per l'esecuzione delle
-opportune operazioni.
+\textsl{salto non-locale}. Il caso classico in cui si ha questa necessità,
+citato sia in \cite{APUE} che in \cite{glibc}, è quello di un programma nel
+cui corpo principale vengono letti dei dati in ingresso sui quali viene
+eseguita, tramite una serie di funzioni di analisi, una scansione dei
+contenuti, da cui si ottengono le indicazioni per l'esecuzione di opportune
+operazioni.
Dato che l'analisi può risultare molto complessa, ed opportunamente suddivisa
in fasi diverse, la rilevazione di un errore nei dati in ingresso può accadere
scartando l'input come errato.\footnote{a meno che, come precisa \cite{glibc},
alla chiusura di ciascuna fase non siano associate operazioni di pulizia
specifiche (come deallocazioni, chiusure di file, ecc.), che non potrebbero
- essere eseguite con un salto non-locale\index{salto non-locale}.}
+ essere eseguite con un salto non-locale.}
Tutto ciò può essere realizzato proprio con un salto non-locale; questo di
norma viene realizzato salvando il contesto dello stack nel punto in cui si
Quando viene eseguita direttamente la funzione ritorna sempre zero, un valore
diverso da zero viene restituito solo quando il ritorno è dovuto ad una
chiamata di \func{longjmp} in un'altra parte del programma che ripristina lo
-stack effettuando il salto non-locale\index{salto non-locale}. Si tenga conto
-che il contesto salvato in \param{env} viene invalidato se la routine che ha
-chiamato \func{setjmp} ritorna, nel qual caso un successivo uso di
-\func{longjmp} può comportare conseguenze imprevedibili (e di norma fatali)
-per il processo.
+stack effettuando il salto non-locale. Si tenga conto che il contesto salvato
+in \param{env} viene invalidato se la routine che ha chiamato \func{setjmp}
+ritorna, nel qual caso un successivo uso di \func{longjmp} può comportare
+conseguenze imprevedibili (e di norma fatali) per il processo.
-Come accennato per effettuare un salto non-locale\index{salto non-locale} ad
+Come accennato per effettuare un salto non-locale ad
un punto precedentemente stabilito con \func{setjmp} si usa la funzione
\funcd{longjmp}; il suo prototipo è:
\begin{functions}
chiamate a questa funzione sono sicure solo in uno dei seguenti casi:
\begin{itemize}
\item come espressione di controllo in un comando condizionale, di selezione
- o di iterazione (come \code{if}, \code{switch} o \code{while}).
+ o di iterazione (come \code{if}, \code{switch} o \code{while});
\item come operando per un operatore di uguaglianza o confronto in una
espressione di controllo di un comando condizionale, di selezione o di
- iterazione.
+ iterazione;
\item come operando per l'operatore di negazione (\code{!}) in una espressione
di controllo di un comando condizionale, di selezione o di iterazione.
\item come espressione a sé stante.
ottenuta da un \func{longjmp}, è il valore di ritorno di \func{setjmp}, essa è
usualmente chiamata all'interno di un comando \code{if}.
-Uno dei punti critici dei salti non-locali\index{salto non-locale} è quello
-del valore delle variabili, ed in particolare quello delle variabili
-automatiche della funzione a cui si ritorna. In generale le variabili globali
-e statiche mantengono i valori che avevano al momento della chiamata di
-\func{longjmp}, ma quelli delle variabili automatiche (o di quelle dichiarate
+Uno dei punti critici dei salti non-locali è quello del valore delle
+variabili, ed in particolare quello delle variabili automatiche della funzione
+a cui si ritorna. In generale le variabili globali e statiche mantengono i
+valori che avevano al momento della chiamata di \func{longjmp}, ma quelli
+delle variabili automatiche (o di quelle dichiarate
\direct{register}\footnote{la direttiva \direct{register} del compilatore
chiede che la variabile dichiarata tale sia mantenuta, nei limiti del
possibile, all'interno di un registro del processore. Questa direttiva è
torneranno al valore avuto al momento della chiamata di \func{setjmp}; per
questo quando si vuole avere un comportamento coerente si può bloccare
l'ottimizzazione che porta le variabili nei registri dichiarandole tutte come
-\direct{volatile}\footnote{la direttiva \ctyp{volatile} informa il compilatore
- che la variabile che è dichiarata può essere modificata, durante
+\direct{volatile}\footnote{la direttiva \direct{volatile} informa il
+ compilatore che la variabile che è dichiarata può essere modificata, durante
l'esecuzione del nostro, da altri programmi. Per questo motivo occorre dire
al compilatore che non deve essere mai utilizzata l'ottimizzazione per cui
quanto opportuno essa viene mantenuta in un registro, poiché in questo modo
si perderebbero le eventuali modifiche fatte dagli altri programmi (che
avvengono solo in una copia posta in memoria).}.
-
+\index{salto~non-locale|)}
%%% Local Variables:
%%% mode: latex