%% process.tex
%%
-%% Copyright (C) 2000-2011 Simone Piccardi. Permission is granted to
+%% Copyright (C) 2000-2012 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 "Un preambolo",
ambiente e dal contenuto del file \conffile{/etc/ld.so.conf}, che consentono
di elencare le directory un cui cercare le librerie e determinare quali
verranno utilizzate. In particolare con la variabile di ambiente
-\texttt{LD\_LIBRARY\_PATH} si possono indicare ulteriori directory rispetto a
+\envvar{LD\_LIBRARY\_PATH} si possono indicare ulteriori directory rispetto a
quelle di sistema in cui inserire versioni personali delle librerie che hanno
la precedenza su quelle di sistema, mentre con la variabile di ambiente
-\texttt{LD\_PRELOAD} si può passare direttamente una lista di file di librerie
+\envvar{LD\_PRELOAD} si può passare direttamente una lista di file di librerie
condivise da usare al posto di quelli di sistema. In questo modo è possibile
effettuare lo sviluppo o il test di nuove librerie senza dover sostituire
quelle di sistema. Ulteriori dettagli sono riportati nella pagina di manuale
sez.~3.1.2 di \cite{AGL}.
Una volta completate le operazioni di inizializzazione di \cmd{ld-linux.so}, il
-sistema fa partire qualunque programma chiamando la funzione \func{main}. Sta
+sistema fa partire qualunque programma chiamando la funzione \code{main}. Sta
al programmatore chiamare così la funzione principale del programma da cui si
suppone che inizi l'esecuzione. In ogni caso senza questa funzione lo stesso
\textit{link-loader} darebbe luogo ad errori. Lo standard ISO C specifica che
-la funzione \func{main} può non avere argomenti o prendere due argomenti che
+la funzione \code{main} può non avere argomenti o prendere due argomenti che
rappresentano gli argomenti passati da linea di comando (su cui torneremo in
sez.~\ref{sec:proc_par_format}), in sostanza un prototipo che va sempre bene è
il seguente:
\itindend{link-loader}
In realtà nei sistemi Unix esiste un altro modo per definire la funzione
-\func{main}, che prevede la presenza di un terzo argomento, \code{char
+\code{main}, che prevede la presenza di un terzo argomento, \code{char
*envp[]}, che fornisce l'\textsl{ambiente} del programma; questa forma però
non è prevista dallo standard POSIX.1 per cui se si vogliono scrivere
programmi portabili è meglio evitarla. Per accedere all'ambiente, come vedremo
viene sempre definita automaticamente.
Ogni programma viene fatto partire mettendo in esecuzione il codice contenuto
-nella funzione \func{main}, ogni altra funzione usata dal programma, che sia
+nella funzione \code{main}, ogni altra funzione usata dal programma, che sia
ottenuta da una libreria condivisa, o che sia direttamente definita nel
-codice, dovrà essere invocata a partire dal codice di \func{main}. Nel caso di
+codice, dovrà essere invocata a partire dal codice di \code{main}. Nel caso di
funzioni definite nel programma occorre tenere conto che, nel momento stesso
in cui si usano le librerie di sistema (vale a dire la \acr{glibc}) alcuni
nomi sono riservati e non possono essere utilizzati.
il controllo e la conversione del tipo di caratteri,
\item i nomi che iniziano con ``\texttt{LC\_}'' e costituiti
da lettere maiuscole che possono essere usato per macro attinenti la
- localizzazione (vedi sez.~\ref{sec:proc_localization}),
+ localizzazione,% mettere in seguito (vedi sez.~\ref{sec:proc_localization}),
\item nomi che iniziano con ``\texttt{SIG}'' o ``\texttt{SIG\_}'' e costituiti
da lettere maiuscole che potrebbero essere usati per nuovi nomi di segnale
(vedi sez.~\ref{sec:sig_classification}),
& ANSI C& POSIX& \\
\hline
\hline
- \file{assert.h}&$\bullet$& -- & Verifica le asserzioni fatte in un
- programma.\\
- \file{ctype.h} &$\bullet$& -- & Tipi standard.\\
- \file{dirent.h}& -- &$\bullet$& Manipolazione delle directory.\\
- \file{errno.h} & -- &$\bullet$& Errori di sistema.\\
- \file{fcntl.h} & -- &$\bullet$& Controllo sulle opzioni dei file.\\
- \file{limits.h}& -- &$\bullet$& Limiti e parametri del sistema.\\
- \file{malloc.h}&$\bullet$& -- & Allocazione della memoria.\\
- \file{setjmp.h}&$\bullet$& -- & Salti non locali.\\
- \file{signal.h}& -- &$\bullet$& Gestione dei segnali.\\
- \file{stdarg.h}&$\bullet$& -- & Gestione di funzioni a argomenti
- variabili.\\
- \file{stdio.h} &$\bullet$& -- & I/O bufferizzato in standard ANSI C.\\
- \file{stdlib.h}&$\bullet$& -- & Definizioni della libreria standard.\\
- \file{string.h}&$\bullet$& -- & Manipolazione delle stringhe.\\
- \file{time.h} & -- &$\bullet$& Gestione dei tempi.\\
- \file{times.h} &$\bullet$& -- & Gestione dei tempi.\\
- \file{unistd.h}& -- &$\bullet$& Unix standard library.\\
- \file{utmp.h} & -- &$\bullet$& Registro connessioni utenti.\\
+ \headfile{assert.h}&$\bullet$& -- & Verifica le asserzioni fatte in un
+ programma.\\
+ \headfile{ctype.h} &$\bullet$& -- & Tipi standard.\\
+ \headfile{dirent.h}& -- &$\bullet$& Manipolazione delle directory.\\
+ \headfile{errno.h} & -- &$\bullet$& Errori di sistema.\\
+ \headfile{fcntl.h} & -- &$\bullet$& Controllo sulle opzioni dei file.\\
+ \headfile{limits.h}& -- &$\bullet$& Limiti e parametri del sistema.\\
+ \headfile{malloc.h}&$\bullet$& -- & Allocazione della memoria.\\
+ \headfile{setjmp.h}&$\bullet$& -- & Salti non locali.\\
+ \headfile{signal.h}& -- &$\bullet$& Gestione dei segnali.\\
+ \headfile{stdarg.h}&$\bullet$& -- & Gestione di funzioni a argomenti
+ variabili.\\
+ \headfile{stdio.h} &$\bullet$& -- & I/O bufferizzato in standard ANSI
+ C.\\
+ \headfile{stdlib.h}&$\bullet$& -- & Definizioni della libreria
+ standard.\\
+ \headfile{string.h}&$\bullet$& -- & Manipolazione delle stringhe.\\
+ \headfile{time.h} & -- &$\bullet$& Gestione dei tempi.\\
+ \headfile{times.h} &$\bullet$& -- & Gestione dei tempi.\\
+ \headfile{unistd.h}& -- &$\bullet$& Unix standard library.\\
+ \headfile{utmp.h} & -- &$\bullet$& Registro connessioni utenti.\\
\hline
\end{tabular}
\caption{Elenco dei principali \textit{header file} definiti dagli standard
esempio, è il seguente, e si noti come gli \textit{header file} possano essere
referenziati con il nome fra parentesi angolari, nel qual caso si indica l'uso
di quelli installati con il sistema,\footnote{in un sistema GNU/Linux che
- segue le specifiche del \textit{Filesystem Hierarchy Standard} (per maggiori
- informazioni si consulti sez.~1.2.3 di \cite{AGL}) si trovano sotto
- \texttt{/usr/include}.} o fra virgolette, nel qual caso si fa riferimento ad
-una versione locale, da indicare con un pathname relativo:
+ segue le specifiche del \itindex{Filesystem~Hierarchy~Standard~(FHS)}
+ \textit{Filesystem Hierarchy Standard} (per maggiori informazioni si
+ consulti sez.~1.2.3 di \cite{AGL}) si trovano sotto \texttt{/usr/include}.}
+o fra virgolette, nel qual caso si fa riferimento ad una versione locale, da
+indicare con un \itindsub{pathname}{relativo} \textit{pathname} relativo:
\includecodesnip{listati/main_include.c}
Si tenga presente che oltre ai nomi riservati a livello generale di cui si è
riservano degli ulteriori identificativi, il cui uso sarà da evitare, ad
esempio si avrà che:
\begin{itemize*}
-\item in \file{dirent.h} vengono riservati i nomi che iniziano con
+\item in \headfile{dirent.h} vengono riservati i nomi che iniziano con
``\texttt{d\_}'' e costituiti da lettere minuscole,
-\item in \file{fcntl.h} vengono riservati i nomi che iniziano con
+\item in \headfile{fcntl.h} vengono riservati i nomi che iniziano con
``\texttt{l\_}'', ``\texttt{F\_}'',``\texttt{O\_}'' e ``\texttt{S\_}'',
-\item in \file{limits.h} vengono riservati i nomi che finiscono in
+\item in \headfile{limits.h} vengono riservati i nomi che finiscono in
``\texttt{\_MAX}'',
-\item in \file{signal.h} vengono riservati i nomi che iniziano con
+\item in \headfile{signal.h} vengono riservati i nomi che iniziano con
``\texttt{sa\_}'' e ``\texttt{SA\_}'',
-\item in \file{sys/stat.h} vengono riservati i nomi che iniziano con
+\item in \headfile{sys/stat.h} vengono riservati i nomi che iniziano con
``\texttt{st\_}'' e ``\texttt{S\_}'',
-\item in \file{sys/times.h} vengono riservati i nomi che iniziano con
+\item in \headfile{sys/times.h} vengono riservati i nomi che iniziano con
``\texttt{tms\_}'',
-\item in \file{termios.h} vengono riservati i nomi che iniziano con
+\item in \headfile{termios.h} vengono riservati i nomi che iniziano con
``\texttt{c\_}'', ``\texttt{V}'', ``\texttt{I}'', ``\texttt{O}'' e
``\texttt{TC}'' e con ``\texttt{B}'' seguito da un numero,
-\item in \file{grp.h} vengono riservati i nomi che iniziano con
+\item in \headfile{grp.h} vengono riservati i nomi che iniziano con
``\texttt{gr\_}'',
-\item in \file{pwd.h}vengono riservati i nomi che iniziano con
+\item in \headfile{pwd.h}vengono riservati i nomi che iniziano con
``\texttt{pw\_}'',
\end{itemize*}
\fdesc{Esegue la \textit{system call} indicata da \param{number}.}
}
{La funzione ritorna un intero dipendente dalla \textit{system call} invocata,
-in generale $0$ indica il successo e un valore negativo un errore.}
+ in generale $0$ indica il successo ed un valore negativo un errore.}
\end{funcproto}
La funzione richiede come primo argomento il numero della \textit{system call}
ciascuna \textit{system call} viene in genere identificata da una costante
nella forma \texttt{SYS\_*} dove al prefisso viene aggiunto il nome che spesso
corrisponde anche alla omonima funzione di libreria. Queste costanti sono
-definite nel file \texttt{sys/syscall.h}, ma si possono anche usare
+definite nel file \headfile{sys/syscall.h}, ma si possono anche usare
direttamente valori numerici.
\label{sec:proc_conclusion}
Normalmente un programma conclude la sua esecuzione quando si fa ritornare la
-funzione \func{main}, si usa cioè l'istruzione \instruction{return} del
+funzione \code{main}, si usa cioè l'istruzione \instruction{return} del
linguaggio C all'interno della stessa, o se si richiede esplicitamente la
chiusura invocando direttamente la funzione \func{exit}. Queste due modalità
sono assolutamente equivalenti, dato che \func{exit} viene chiamata in maniera
-trasparente anche quando \func{main} ritorna, passandogli come argomento il
+trasparente anche quando \code{main} ritorna, passandogli come argomento il
valore di ritorno (che essendo .
La funzione \funcd{exit}, che è completamente generale, essendo definita dallo
La funzione è pensata per eseguire una conclusione pulita di un programma che
usi la libreria standard del C; essa esegue tutte le funzioni che sono state
registrate con \func{atexit} e \func{on\_exit} (vedi
-sez.~\ref{sec:proc_atexit}), chiude tutti gli stream effettuando il
-salvataggio dei dati sospesi (chiamando \func{fclose}, vedi
-sez.~\ref{sec:file_fopen}), infine passa il controllo al kernel chiamando la
-\textit{system call} \func{\_exit} (che vedremo a breve) che completa la
-terminazione del processo.
+sez.~\ref{sec:proc_atexit}), chiude tutti gli \textit{stream} (vedi
+sez.~\ref{sec:file_stream}) effettuando il salvataggio dei dati sospesi
+(chiamando \func{fclose}, vedi sez.~\ref{sec:file_fopen}), infine passa il
+controllo al kernel chiamando la \textit{system call} \func{\_exit} (che
+vedremo a breve) che completa la terminazione del processo.
\itindbeg{exit~status}
-Il valore dell'argomento \param{status} o il valore di ritorno di \func{main},
+Il valore dell'argomento \param{status} o il valore di ritorno di \code{main},
costituisce quello che viene chiamato lo \textsl{stato di uscita}
(l'\textit{exit status}) del processo. In generale si usa questo valore per
fornire al processo padre (come vedremo in sez.~\ref{sec:proc_wait}) delle
informazioni generiche sulla riuscita o il fallimento del programma appena
terminato.
-Anche se l'argomento \param{status} (ed il valore di ritorno di \func{main})
+Anche se l'argomento \param{status} (ed il valore di ritorno di \code{main})
sono numeri interi di tipo \ctyp{int}, si deve tener presente che il valore
-dello stato di uscita viene comunque troncato ad 8 bit, per cui deve essere
-sempre compreso fra 0 e 255. Si tenga presente che se si raggiunge la fine
-della funzione \func{main} senza ritornare esplicitamente si ha un valore di
-uscita indefinito, è pertanto consigliabile di concludere sempre in maniera
-esplicita detta funzione.
+dello stato di uscita viene comunque troncato ad 8 bit,
+per cui deve essere sempre compreso fra 0 e 255. Si tenga presente che se si
+raggiunge la fine della funzione \code{main} senza ritornare esplicitamente si
+ha un valore di uscita indefinito, è pertanto consigliabile di concludere
+sempre in maniera esplicita detta funzione.
Non esiste un valore significato intrinseco della stato di uscita, ma una
convenzione in uso pressoché universale è quella di restituire 0 in caso di
usare un multiplo di 256, di avere uno stato di uscita uguale a zero, che
verrebbe interpretato come un successo.
-Per questo motivo in \file{stdlib.h} sono definite, seguendo lo standard
+Per questo motivo in \headfile{stdlib.h} sono definite, seguendo lo standard
POSIX, le due costanti \const{EXIT\_SUCCESS} e \const{EXIT\_FAILURE}, da usare
sempre per specificare lo stato di uscita di un processo. Su Linux, ed in
generale in qualunque sistema POSIX, ad esse sono assegnati rispettivamente i
Una forma alternativa per effettuare una terminazione esplicita di un
programma è quella di chiamare direttamente la \textit{system call}
-\func{\_exit}, che restituisce il controllo direttamente al kernel,
+\funcd{\_exit},\footnote{la stessa è definita anche come \funcd{\_Exit} in
+ \headfile{stdlib.h}.} che restituisce il controllo direttamente al kernel,
concludendo immediatamente il processo, il suo prototipo è:
\begin{funcproto}{ \fhead{unistd.h} \fdecl{void \_exit(int status)}
registrate con \func{atexit} e \func{on\_exit} non vengono eseguite. La
funzione chiude tutti i file descriptor appartenenti al processo, cosa che
però non comporta il salvataggio dei dati eventualmente presenti nei buffer
-degli stream, (torneremo sulle due interfacce dei file a partire da
-cap.~\ref{cha:file_intro}). Infine fa sì che ogni figlio del processo sia
-adottato da \cmd{init} (vedi cap.~\ref{cha:process_handling}), manda un
+degli \textit{stream}, (torneremo sulle due interfacce dei file in
+sez.~\ref{sec:file_unix_interface} e
+sez.~\ref{sec:files_std_interface}). Infine fa sì che ogni figlio del processo
+sia adottato da \cmd{init} (vedi sez.~\ref{sec:proc_termination}), manda un
segnale \signal{SIGCHLD} al processo padre (vedi
sez.~\ref{sec:sig_job_control}) e ritorna lo stato di uscita specificato
in \param{status} che può essere raccolto usando la funzione \func{wait} (vedi
programma,\footnote{nel caso di \func{atexit} lo standard POSIX.1-2001
richiede che siano registrabili almeno \const{ATEXIT\_MAX} funzioni (il
valore può essere ottenuto con \func{sysconf}, vedi
- sez.~\ref{sec:sys_sysconf}).} sia per la chiamata ad \func{exit} che per il
-ritorno di \func{main}. La prima funzione che si può utilizzare a tal fine è
+ sez.~\ref{sec:sys_limits}).} sia per la chiamata ad \func{exit} che per il
+ritorno di \code{main}. La prima funzione che si può utilizzare a tal fine è
\funcd{atexit}, il cui prototipo è:
-\begin{funcproto}{ \fhead{stdlib.h} \fdecl{void (*function)(void)}
- \fdesc{Registra la funzione \param{function} per la chiamata all'uscita
- dal programma.} } {La funzione restituisce $0$ in caso di successo e
- $-1$ in caso di fallimento, \var{errno} non viene modificata.}
+\begin{funcproto}{
+\fhead{stdlib.h}
+\fdecl{int atexit(void (*function)(void))}
+\fdesc{Registra la funzione \param{function} per la chiamata all'uscita
+ dal programma.}
+}
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, \var{errno}
+ non viene modificata.}
\end{funcproto}
La funzione richiede come argomento \param{function} l'indirizzo di una
\begin{funcproto}{
\fhead{stdlib.h}
-\fdecl{void (*function)(int , void *), void *arg)}
+\fdecl{int on\_exit(void (*function)(int, void *), void *arg))}
\fdesc{Registra la funzione \param{function} per la chiamata all'uscita dal
- programma.} }{La funzione restituisce $0$ in caso di successo e $-1$ in caso
-di fallimento, \var{errno} non viene modificata.}
+ programma.}
+}
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, \var{errno}
+ non viene modificata.}
\end{funcproto}
In questo caso la funzione da chiamare all'uscita prende i due argomenti
indipendentemente dalla funzione usata per farla.
Una volta completata l'esecuzione di tutte le funzioni registrate verranno
-chiusi tutti gli stream aperti ed infine verrà chiamata \func{\_exit} per la
-terminazione del programma. Questa è la sequenza ordinaria, eseguita a meno
-che una delle funzioni registrate non esegua al suo interno \func{\_exit}, nel
-qual caso la terminazione del programma sarà immediata ed anche le successive
-funzioni registrate non saranno invocate.
+chiusi tutti gli \textit{stream} aperti ed infine verrà chiamata \func{\_exit}
+per la terminazione del programma. Questa è la sequenza ordinaria, eseguita a
+meno che una delle funzioni registrate non esegua al suo interno
+\func{\_exit}, nel qual caso la terminazione del programma sarà immediata ed
+anche le successive funzioni registrate non saranno invocate.
Se invece all'interno di una delle funzioni registrate si chiama un'altra
volta \func{exit} lo standard POSIX.1-2001 prescrive un comportamento
volontariamente la propria esecuzione è attraverso una chiamata alla
\textit{system call} \func{\_exit}, sia che questa venga fatta esplicitamente,
o in maniera indiretta attraverso l'uso di \func{exit} o il ritorno di
-\func{main}.
+\code{main}.
Uno schema riassuntivo che illustra le modalità con cui si avvia e conclude
normalmente un programma è riportato in fig.~\ref{fig:proc_prog_start_stop}.
% \includegraphics[width=9cm]{img/proc_beginend}
\begin{tikzpicture}[>=stealth]
\filldraw[fill=black!35] (-0.3,0) rectangle (12,1);
- \draw(5.5,0.5) node {\large{kernel}};
+ \draw(5.5,0.5) node {\large{\textsf{kernel}}};
\filldraw[fill=black!15] (1.5,2) rectangle (4,3);
\draw (2.75,2.5) node {\texttt{ld-linux.so}};
\draw[->] (4,4.5) -- node[anchor=south]{\texttt{exit}} (exit);
\draw[->] (exit) -- node[anchor=east]{\texttt{\_exit}}(6.75,1);
- \draw (10,4.5) node (exithandler1) [rectangle,fill=black!15,rounded corners, draw]{exit handler};
- \draw (10,5.5) node (exithandler2) [rectangle,fill=black!15,rounded corners, draw]{exit handler};
- \draw (10,3.5) node (stream) [rectangle,fill=black!15,rounded corners, draw]{chiusura stream};
+ \draw (10,4.5) node (exithandler1) [rectangle,fill=black!15,rounded corners, draw]{\textsf{exit handler}};
+ \draw (10,5.5) node (exithandler2) [rectangle,fill=black!15,rounded corners, draw]{\textsf{exit handler}};
+ \draw (10,3.5) node (stream) [rectangle,fill=black!15,rounded corners, draw]{\textsf{chiusura stream}};
\draw[<->, dashed] (exithandler1) -- (exit);
\draw[<->, dashed] (exithandler2) -- (exit);
anche utilizzare pagine di dimensioni maggiori (di 4Mb, dette \textit{huge
page}), per sistemi con grandi quantitativi di memoria in cui l'uso di
pagine troppo piccole comporta una perdita di prestazioni. In alcuni sistemi
-la costante \const{PAGE\_SIZE}, definita in \file{limits.h}, indica la
+la costante \const{PAGE\_SIZE}, definita in \headfile{limits.h}, indica la
dimensione di una pagina in byte, con Linux questo non avviene e per ottenere
questa dimensione si deve ricorrere alla funzione \func{getpagesize} (vedi
sez.~\ref{sec:sys_memory_res}).
}
{Entrambe le funzioni restituiscono il puntatore alla zona di memoria allocata
in caso di successo e \val{NULL} in caso di fallimento, nel qual caso
- \var{errno} assumerà il valore \errval{ENOMEM}.}
+ \var{errno} assumerà il valore \errcode{ENOMEM}.}
\end{funcproto}
In genere si usano \func{malloc} e \func{calloc} per allocare dinamicamente
inizializzata.
Una volta che non sia più necessaria la memoria allocata dinamicamente deve
-essere esplicitamente rilasciata usando la funzione \func{free},\footnote{le
- glibc provvedono anche una funzione \func{cfree} definita per compatibilità
+essere esplicitamente rilasciata usando la funzione \funcd{free},\footnote{le
+ glibc provvedono anche una funzione \funcm{cfree} definita per compatibilità
con SunOS, che è deprecata.} il suo prototipo è:
\begin{funcproto}{
\fhead{stdlib.h}
\fdecl{void *realloc(void *ptr, size\_t size)}
\fdesc{Cambia la dimensione di un'area di memoria precedentemente allocata.}
-} {La funzione restituisce il puntatore alla zona di memoria allocata in caso
- di successo e \val{NULL} in caso di fallimento, nel qual caso \var{errno}
- assumerà il valore \errval{ENOMEM}.}
+} {La funzione ritorna il puntatore alla zona di memoria allocata in caso
+ di successo e \val{NULL} per un errore, nel qual caso \var{errno}
+ assumerà il valore \errcode{ENOMEM}.}
\end{funcproto}
La funzione vuole come primo argomento il puntatore restituito da una
La \acr{glibc} ha un'implementazione delle funzioni di allocazione che è
controllabile dall'utente attraverso alcune variabili di ambiente (vedi
sez.~\ref{sec:proc_environ}), in particolare diventa possibile tracciare
-questo tipo di errori usando la variabile di ambiente \val{MALLOC\_CHECK\_}
+questo tipo di errori usando la variabile di ambiente \envvar{MALLOC\_CHECK\_}
che quando viene definita mette in uso una versione meno efficiente delle
funzioni suddette, che però è più tollerante nei confronti di piccoli errori
come quello dei \itindex{double~free} \textit{double~free} o i
\begin{itemize*}
\item se la variabile è posta a $0$ gli errori vengono ignorati;
\item se la variabile è posta a $1$ viene stampato un avviso sullo
- \textit{standard error} (vedi sez.~\ref{sec:file_std_stream});
+ \textit{standard error} (vedi sez.~\ref{sec:file_fd});
\item se la variabile è posta a $2$ viene chiamata la funzione \func{abort}
(vedi sez.~\ref{sec:sig_alarm_abort}), che in genere causa l'immediata
terminazione del programma;
specializzata per il debugging). Esistono varie librerie che forniscono dei
sostituti opportuni delle funzioni di allocazione in grado, senza neanche
ricompilare il programma,\footnote{esempi sono \textit{Dmalloc}
- \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. Vedremo alcune delle
-funzionalità di ausilio presenti nella \acr{glibc} in
-sez.~\ref{sec:proc_memory_adv_management}.
+ \url{http://dmalloc.com/} di Gray Watson ed \textit{Electric Fence} di Bruce
+ Perens.} di eseguire diagnostiche anche molto complesse riguardo
+l'allocazione della memoria. Vedremo alcune delle funzionalità di ausilio
+presenti nella \acr{glibc} in sez.~\ref{sec:proc_memory_adv_management}.
Una possibile alternativa all'uso di \func{malloc}, per evitare di soffrire
dei problemi di \itindex{memory~leak} \textit{memory leak} descritti in
\fdecl{void *alloca(size\_t size)}
\fdesc{Alloca un'area di memoria nello \textit{stack}.}
}
-{La funzione restituisce il puntatore alla zona di memoria allocata, in caso
- di fallimento il comportamento è indefinito.}
+{La funzione ritorna il puntatore alla zona di memoria allocata, in caso
+ di errore il comportamento è indefinito.}
\end{funcproto}
La funzione alloca la quantità di memoria (non inizializzata) richiesta
prima volta che cercherà di accedere alla memoria non effettivamente
disponibile.
+
+\index{segmento!dati|(}
+
Le due funzioni seguenti\footnote{le due funzioni sono state definite con BSD
4.3, sono marcate obsolete in SUSv2 e non fanno parte delle librerie
standard del C e mentre sono state esplicitamente rimosse dallo standard
\fdecl{int brk(void *addr)}
\fdesc{Sposta la fine del segmento dati del processo.}
}
-{La funzione restituisce 0 in caso di successo e $-1$ in caso di fallimento,
- nel qual caso \var{errno} assumerà il valore \errval{ENOMEM}.}
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore,
+ nel qual caso \var{errno} assumerà il valore \errcode{ENOMEM}.}
\end{funcproto}
La funzione è un'interfaccia all'omonima \textit{system call} ed imposta
-l'indirizzo finale del \index{segmento!dati} segmento dati di un processo (più
-precisamente dello \itindex{heap} \textit{heap}) all'indirizzo specificato
+l'indirizzo finale del segmento dati di un processo (più precisamente dello
+\itindex{heap} \textit{heap}) all'indirizzo specificato
da \param{addr}. Quest'ultimo deve essere un valore ragionevole, e la
dimensione totale non deve comunque eccedere un eventuale limite (vedi
sez.~\ref{sec:sys_resource_limit}) imposto sulle dimensioni massime del
-\index{segmento!dati} segmento dati del processo.
+segmento dati del processo.
Il valore di ritorno della funzione fa riferimento alla versione fornita dalla
\acr{glibc}, in realtà in Linux la \textit{system call} corrispondente
-restituisce come valore di ritorno il nuovo valore della fine del
-\index{segmento!dati} segmento dati in caso di successo e quello corrente in
-caso di fallimento, è la funzione di interfaccia usata dalla \acr{glibc} che
-fornisce i valori di ritorno appena descritti; se si usano librerie diverse
-questo potrebbe non accadere.
+restituisce come valore di ritorno il nuovo valore della fine del segmento
+dati in caso di successo e quello corrente in caso di fallimento, è la
+funzione di interfaccia usata dalla \acr{glibc} che fornisce i valori di
+ritorno appena descritti; se si usano librerie diverse questo potrebbe non
+accadere.
-Una seconda funzione per la manipolazione diretta delle dimensioni
-\index{segmento!dati} del segmento dati\footnote{in questo caso si tratta
- soltanto di una funzione di libreria, anche se basata sulla stessa
- \textit{system call}.} è \funcd{sbrk}, ed il suo prototipo è:
+Una seconda funzione per la manipolazione diretta delle dimensioni del
+segmento dati\footnote{in questo caso si tratta soltanto di una funzione di
+ libreria, anche se basata sulla stessa \textit{system call}.} è
+\funcd{sbrk}, ed il suo prototipo è:
\begin{funcproto}{
\fhead{unistd.h}
\fdecl{void *sbrk(intptr\_t increment)}
\fdesc{Incrementa la dimensione del segmento dati del processo.}
}
-{La funzione restituisce il puntatore all'inizio della nuova zona di memoria
- allocata in caso di successo e \val{NULL} in caso di fallimento, nel qual
- caso \var{errno} assumerà il valore \errval{ENOMEM}.}
+{La funzione ritorna il puntatore all'inizio della nuova zona di memoria
+ allocata in caso di successo e \val{NULL} per un errore, nel qual
+ caso \var{errno} assumerà il valore \errcode{ENOMEM}.}
\end{funcproto}
La funzione incrementa la dimensione dello \itindex{heap} \textit{heap} di un
nuovo indirizzo finale dello stesso. L'argomento è definito come di tipo
\type{intptr\_t}, ma a seconda della versione delle librerie e del sistema può
essere indicato con una serie di tipi equivalenti come \type{ptrdiff\_t},
-\type{ssize\_t}, \ctyp{int}. Se invocata con un valore nullo la funzone
-permette di ottenere l'attuale posizione della fine del \index{segmento!dati}
-segmento dati.
+\type{ssize\_t}, \ctyp{int}. Se invocata con un valore nullo la funzione
+permette di ottenere l'attuale posizione della fine del segmento dati.
Queste due funzioni sono state deliberatamente escluse dallo standard POSIX.1
dato che per i normali programmi è sempre opportuno usare le funzioni di
per proprio conto un diverso meccanismo di gestione della memoria del segmento
dati.
+\index{segmento!dati|)}
+
\subsection{Il controllo della memoria virtuale}
\label{sec:proc_mem_lock}
\end{itemize*}
Per ottenere informazioni sulle modalità in cui un programma sta usando la
-memoria virtuale è disponibile una apposita funzione, \funcd{mincore}, che
-però non è standardizzata da POSIX e pertanto non è disponibile su tutte le
-versioni di kernel unix-like;\footnote{nel caso di Linux devono essere
- comunque definite le macro \macro{\_BSD\_SOURCE} e \macro{\_SVID\_SOURCE}.}
-il suo prototipo è:
-% \begin{functions}
-% \headdecl{unistd.h}
-% \headdecl{sys/mman.h}
-
-% \funcdecl{int mincore(void *addr, size\_t length, unsigned char *vec)}
-% Ritorna lo stato delle pagine di memoria occupate da un processo.
-
-% \bodydesc{La funzione ritorna 0 in caso di successo e $-1$ in caso di
-% errore, nel qual caso \var{errno} assumerà uno dei valori:
-% \begin{errlist}
-% \item[\errcode{ENOMEM}] o \param{addr} + \param{length} eccede la dimensione
-% della memoria usata dal processo o l'intervallo di indirizzi specificato
-% non è mappato.
-% \item[\errcode{EINVAL}] \param{addr} non è un multiplo delle dimensioni di
-% una pagina.
-% \item[\errcode{EFAULT}] \param{vec} punta ad un indirizzo non valido.
-% \item[\errcode{EAGAIN}] il kernel è temporaneamente non in grado di fornire
-% una risposta.
-% \end{errlist}
-% }
-% \end{functions}
+memoria virtuale è disponibile una apposita funzione di sistema,
+\funcd{mincore}, che però non è standardizzata da POSIX e pertanto non è
+disponibile su tutte le versioni di kernel unix-like;\footnote{nel caso di
+ Linux devono essere comunque definite le macro \macro{\_BSD\_SOURCE} e
+ \macro{\_SVID\_SOURCE}.} il suo prototipo è:
\begin{funcproto}{
\fhead{unistd.h}
\fdecl{int mincore(void *addr, size\_t length, unsigned char *vec)}
\fdesc{Ritorna lo stato delle pagine di memoria occupate da un processo.}
}
-{La funzione ritorna 0 in caso di successo e $-1$ in caso di errore, nel qual
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{ENOMEM}] o \param{addr} + \param{length} eccede la dimensione
- della memoria usata dal processo o l'intervallo di indirizzi specificato
- non è mappato.
- \item[\errcode{EINVAL}] \param{addr} non è un multiplo delle dimensioni di
- una pagina.
- \item[\errcode{EFAULT}] \param{vec} punta ad un indirizzo non valido.
\item[\errcode{EAGAIN}] il kernel è temporaneamente non in grado di fornire
una risposta.
+ \item[\errcode{EFAULT}] \param{vec} punta ad un indirizzo non valido.
+ \item[\errcode{EINVAL}] \param{addr} non è un multiplo delle dimensioni di
+ una pagina.
+ \item[\errcode{ENOMEM}] o \param{addr}$+$\param{length} eccede la dimensione
+ della memoria usata dal processo o l'intervallo di indirizzi specificato
+ non è mappato.
\end{errlist}}
\end{funcproto}
Il sistema pone dei limiti all'ammontare di memoria di un processo che può
essere bloccata e al totale di memoria fisica che si può dedicare a questo, lo
-standard POSIX.1 richiede che sia definita in \file{unistd.h} la macro
+standard POSIX.1 richiede che sia definita in \headfile{unistd.h} la macro
\macro{\_POSIX\_MEMLOCK\_RANGE} per indicare la capacità di eseguire il
\textit{memory locking}.
però diversi processi bloccano la stessa pagina questa resterà bloccata
fintanto che ci sarà almeno un processo che la blocca.
-Le funzioni per bloccare e sbloccare la \index{paginazione} paginazione di
-singole sezioni di memoria sono rispettivamente \funcd{mlock} e
+Le funzioni di sistema per bloccare e sbloccare la \index{paginazione}
+paginazione di singole sezioni di memoria sono rispettivamente \funcd{mlock} e
\funcd{munlock}; i loro prototipi sono:
-% \begin{functions}
-% \headdecl{sys/mman.h}
-
-% \funcdecl{int mlock(const void *addr, size\_t len)}
-% Blocca la paginazione su un intervallo di memoria.
-
-% \funcdecl{int munlock(const void *addr, size\_t len)}
-% Rimuove il blocco della paginazione su un intervallo di memoria.
-
-% \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e $-1$ in
-% caso di errore, nel qual caso \var{errno} assumerà uno dei
-% valori:
-% \begin{errlist}
-% \item[\errcode{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[\errcode{EINVAL}] \param{len} non è un valore positivo.
-% \item[\errcode{EPERM}] con un kernel successivo al 2.6.9 il processo non è
-% privilegiato e si un limite nullo per \const{RLIMIT\_MEMLOCK}.
-% \end{errlist}
-% e, per \func{mlock}, anche \errval{EPERM} quando il processo non ha i
-% privilegi richiesti per l'operazione.}
-% \end{functions}
\begin{funcproto}{
\fhead{sys/mman.h}
{Entrambe le funzioni ritornano $0$ in caso di successo e $-1$ in caso di
errore, nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
+ \item[\errcode{EINVAL}] \param{len} non è un valore positivo.
\item[\errcode{ENOMEM}] alcuni indirizzi dell’intervallo specificato non
corrispondono allo spazio di indirizzi del processo o si è superato il
limite di \const{RLIMIT\_MEMLOCK} per un processo non privilegiato (solo
per kernel a partire dal 2.6.9).
- \item[\errcode{EINVAL}] \param{len} non è un valore positivo.
\item[\errcode{EPERM}] il processo non è privilegiato (per kernel precedenti
il 2.6.9) o si ha un limite nullo per \const{RLIMIT\_MEMLOCK} e
il processo non è privilegiato (per kernel a partire dal 2.6.9).
pagine di memoria, pertanto se si ha a cuore la portabilità si deve avere cura
di allinearne correttamente il valore.
-Altre due funzioni, \funcd{mlockall} e \funcd{munlockall}, consentono di
-bloccare genericamente la \index{paginazione} paginazione per l'intero spazio
-di indirizzi di un processo. I prototipi di queste funzioni sono:
+Altre due funzioni di sistema, \funcd{mlockall} e \funcd{munlockall},
+consentono di bloccare genericamente la \index{paginazione} paginazione per
+l'intero spazio di indirizzi di un processo. I prototipi di queste funzioni
+sono:
\begin{funcproto}{
\fhead{sys/mman.h}
caso di successo e \val{NULL} in caso di errore, nel qual caso \var{errno}
assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione.
\item[\errcode{EINVAL}] \param{boundary} non è una potenza di due.
+ \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione.
\end{errlist}}
\end{funcproto}
Nessuna delle due funzioni ha una chiara standardizzazione e nessuna delle due
compare in POSIX.1, inoltre ci sono indicazioni discordi sui file che ne
contengono la definizione;\footnote{secondo SUSv2 \func{valloc} è definita in
- \texttt{stdlib.h}, mentre sia le \acr{glibc} che le precedenti \acr{libc4} e
- \acr{libc5} la dichiarano in \texttt{malloc.h}, lo stesso vale per
- \func{memalign} che in alcuni sistemi è dichiarata in \texttt{stdlib.h}.}
+ \headfile{stdlib.h}, mentre sia le \acr{glibc} che le precedenti \acr{libc4}
+ e \acr{libc5} la dichiarano in \headfile{malloc.h}, lo stesso vale per
+ \func{memalign} che in alcuni sistemi è dichiarata in \headfile{stdlib.h}.}
per questo motivo il loro uso è sconsigliato, essendo state sostituite dalla
nuova \funcd{posix\_memalign}, che è stata standardizzata in POSIX.1d; il suo
prototipo è:
caso di successo e \val{NULL} in caso di errore, nel qual caso \var{errno}
assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione.
\item[\errcode{EINVAL}] \param{alignment} non è potenza di due e multiplo
di \code{sizeof(void *)}.
+ \item[\errcode{ENOMEM}] non c'è memoria sufficiente per l'allocazione.
\end{errlist}}
\end{funcproto}
Abbiamo visto in sez.~\ref{sec:proc_mem_lock} come una prima funzionalità di
ausilio nella ricerca di questi errori sia l'uso della variabile di ambiente
-\var{MALLOC\_CHECK\_}. Una modalità alternativa per effettuare dei controlli
-di consistenza sullo stato delle allocazioni di memoria eseguite con
+\envvar{MALLOC\_CHECK\_}. Una modalità alternativa per effettuare dei
+controlli di consistenza sullo stato delle allocazioni di memoria eseguite con
\func{malloc}, anche questa fornita come estensione specifica (e non standard)
della \acr{glibc}, è quella di utilizzare la funzione \funcd{mcheck}, che deve
essere chiamata prima di eseguire qualunque allocazione con \func{malloc}; il
\fdecl{int mcheck(void (*abortfn) (enum mcheck\_status status))}
\fdesc{Attiva i controlli di consistenza delle allocazioni di memoria.}
}
-{La funzione restituisce $0$ in caso di successo e $-1$ in caso di fallimento;
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errorre;
\var{errno} non viene impostata.}
\end{funcproto}
Nonostante la scarsa leggibilità del prototipo si tratta semplicemente di
definire una funzione di tipo \code{void abortfn(enum mcheck\_status status)},
che non deve restituire nulla e che deve avere un unico argomento di tipo
-\type{mcheck\_status}. In caso di errore la funzione verrà eseguita ricevendo
+\code{mcheck\_status}. In caso di errore la funzione verrà eseguita ricevendo
un opportuno valore di \param{status} che è un tipo enumerato che può assumere
soltanto i valori di tab.~\ref{tab:mcheck_status_value} che indicano la
tipologia di errore riscontrata.
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \macro{MCHECK\_OK} & riportato a \func{mprobe} se nessuna
+ \const{MCHECK\_OK} & Riportato a \func{mprobe} se nessuna
inconsistenza è presente.\\
- \macro{MCHECK\_DISABLED}& riportato a \func{mprobe} se si è chiamata
+ \const{MCHECK\_DISABLED}& Riportato a \func{mprobe} se si è chiamata
\func{mcheck} dopo aver già usato
\func{malloc}.\\
- \macro{MCHECK\_HEAD} & i dati immediatamente precedenti il buffer sono
+ \const{MCHECK\_HEAD} & I dati immediatamente precedenti il buffer sono
stati modificati, avviene in genere quando si
decrementa eccessivamente il valore di un
puntatore scrivendo poi prima dell'inizio del
buffer.\\
- \macro{MCHECK\_TAIL} & i dati immediatamente seguenti il buffer sono
+ \const{MCHECK\_TAIL} & I dati immediatamente seguenti il buffer sono
stati modificati, succede quando si va scrivere
oltre la dimensione corretta del buffer.\\
- \macro{MCHECK\_FREE} & il buffer è già stato disallocato.\\
+ \const{MCHECK\_FREE} & Il buffer è già stato disallocato.\\
\hline
\end{tabular}
\caption{Valori dello stato dell'allocazione di memoria ottenibili dalla
\fdecl{enum mcheck\_status mprobe(ptr)}
\fdesc{Esegue un controllo di consistenza delle allocazioni.}
}
-{La funzione restituisce un codice fra quelli riportati in
- tab.\ref{tab:mcheck_status_value} e non ha errori.}
+{La funzione ritorna un codice fra quelli riportati in
+ tab.~\ref{tab:mcheck_status_value} e non ha errori.}
\end{funcproto}
La funzione richiede che si passi come argomento un puntatore ad un blocco di
Tutti i programmi hanno la possibilità di ricevere argomenti e opzioni quando
vengono lanciati e come accennato in sez.~\ref{sec:proc_main} questo viene
effettuato attraverso gli argomenti \param{argc} e \param{argv} ricevuti nella
-funzione \func{main} all'avvio del programma. Questi argomenti vengono passati
+funzione \code{main} all'avvio del programma. Questi argomenti 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.
\fhead{unistd.h}
\fdecl{int getopt(int argc, char * const argv[], const char *optstring)}
\fdesc{Esegue la scansione delle opzioni negli argomenti della funzione
- \func{main}.}
+ \code{main}.}
}
{Ritorna il carattere che segue l'opzione, ``\texttt{:}'' se manca un
parametro all'opzione, ``\texttt{?}'' se l'opzione è sconosciuta, e $-1$ se
\end{funcproto}
Questa funzione prende come argomenti le due variabili \param{argc} e
-\param{argv} che devono essere quelle passate come argomenti di \func{main}
+\param{argv} che devono essere quelle passate come argomenti di \code{main}
all'esecuzione del programma, ed una stringa \param{optstring} che indica
quali sono le opzioni valide. La funzione effettua la scansione della lista
degli argomenti ricercando ogni stringa che comincia con il carattere
\end{itemize*}
In fig.~\ref{fig:proc_options_code} si è mostrata la sezione del programma
-\file{ForkTest.c}, che useremo nel prossimo capitolo per effettuare dei test
+\file{fork\_test.c}, che useremo nel prossimo capitolo per effettuare dei test
sulla creazione dei processi, deputata alla decodifica delle opzioni a riga di
comando da esso supportate.
\subsection{Le variabili di ambiente}
\label{sec:proc_environ}
+\index{variabili!di~ambiente|(}
Oltre agli argomenti passati a linea di comando esiste un'altra modalità che
permette di trasferire ad un processo delle informazioni in modo da
modificarne il comportamento. Ogni processo infatti riceve dal sistema, oltre
\end{figure}
Per convenzione le stringhe che definiscono l'ambiente sono tutte del tipo
-\textsl{\texttt{nome=valore}} ed in questa forma che le funzioni di gestione
+\textsl{\texttt{NOME=valore}} ed in questa forma che le funzioni di gestione
che vedremo a breve se le aspettano, se pertanto si dovesse costruire
manualmente un ambiente si abbia cura di rispettare questa convenzione.
Inoltre alcune variabili, come quelle elencate in
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 \texttt{PATH}
+La shell ad esempio ne usa molte per il suo funzionamento, come \envvar{PATH}
per indicare la lista delle directory in cui effettuare la ricerca dei comandi
-o \texttt{PS1} per impostare il proprio \textit{prompt}. Alcune di esse, come
-\texttt{HOME}, \texttt{USER}, ecc. sono invece definite al login (per i
+o \envvar{PS1} per impostare il proprio \textit{prompt}. Alcune di esse, come
+\envvar{HOME}, \envvar{USER}, ecc. sono invece definite al login (per i
dettagli si veda sez.~\ref{sec:sess_login}), ed in genere è cura della propria
distribuzione definire le opportune variabili di ambiente in uno script di
avvio. Alcune servono poi come riferimento generico per molti programmi, come
-\texttt{EDITOR} che indica l'editor preferito da invocare in caso di
-necessità. Una in particolare, \texttt{LANG}, serve a controllare la
-localizzazione del programma (su cui torneremo in
-sez.~\ref{sec:proc_localization}) per adattarlo alla lingua ed alle convezioni
+\envvar{EDITOR} che indica l'editor preferito da invocare in caso di
+necessità. Una in particolare, \envvar{LANG}, serve a controllare la
+localizzazione del programma
+%(su cui torneremo in sez.~\ref{sec:proc_localization})
+per adattarlo alla lingua ed alle convezioni
dei vari paesi.
Gli standard POSIX e XPG3 definiscono alcune di queste variabili (le più
\fdesc{Cerca una variabile di ambiente del processo.}
}
{La funzione ritorna il puntatore alla stringa contenente il valore della
- variabile di ambiente in caso di successo e \val{NULL} in caso di errore.}
+ variabile di ambiente in caso di successo e \val{NULL} per un errore.}
\end{funcproto}
La funzione effettua una ricerca nell'ambiente del processo cercando una
\fdecl{int putenv(char *string)}
\fdesc{Inserisce, modifica o rimuove una variabile d'ambiente.}
}
-{La funzione ritorna 0 in caso di successo e $-1$ in caso di errore, che può
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, che può
essere solo \errval{ENOMEM}.}
\end{funcproto}
all'ambiente, se invece esiste il suo valore sarà impostato a quello
specificato dal contenuto di \param{string} (nel caso \texttt{valore}). Se
invece si passa come argomento solo il nome di una variabile di ambiente
-(cioè \param{string} è nella forma ``\texttt{NAME}'' e non contiene il
+(cioè \param{string} è nella forma ``\texttt{NOME}'' e non contiene il
carattere ``\texttt{=}'') allora questa, se presente nell'ambiente, verrà
cancellata.
dal prototipo.} pertanto ogni cambiamento alla stringa in questione si
riflette automaticamente sull'ambiente, e quindi si deve evitare di passare a
questa funzione una \index{variabili!automatiche} variabile automatica (per
-evitare i problemi esposti in sez.~\ref{sec:proc_var_passing}).
+evitare i problemi esposti in sez.~\ref{sec:proc_var_passing}). Benché non sia
+richiesto dallo standard nelle versioni della \acr{glibc} a partire dalla 2.1
+la funzione è rientrante (vedi sez.~\ref{sec:proc_reentrant}).
Infine quando una chiamata a \func{putenv} comporta la necessità di creare una
nuova versione del vettore \var{environ} questo sarà allocato automaticamente,
un'allocazione fatta in precedenza da un'altra \func{putenv}. Questo avviene
perché il vettore delle variabili di ambiente iniziale, creato dalla chiamata
ad \func{exec} (vedi sez.~\ref{sec:proc_exec}) è piazzato nella memoria al di
-sopra dello \itindex{stack} stack, (vedi fig.~\ref{fig:proc_mem_layout}) e non
-nello \itindex{heap} \textit{heap} e quindi non può essere deallocato.
-Inoltre la memoria associata alle variabili di ambiente eliminate non viene
-liberata.
+sopra dello \itindex{stack} \textit{stack}, (vedi
+fig.~\ref{fig:proc_mem_layout}) e non nello \itindex{heap} \textit{heap} e
+quindi non può essere deallocato. Inoltre la memoria associata alle variabili
+di ambiente eliminate non viene liberata.
Come alternativa a \func{putenv} si può usare la funzione \funcd{setenv} che
però consente solo di aggiungere o modificare una variabile di ambiente; il
\fdecl{int setenv(const char *name, const char *value, int overwrite)}
\fdesc{Inserisce o modifica una variabile di ambiente.}
}
-{La funzione ritorna 0 in caso di successo e $-1$ per un errore,
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore,
nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{ENOMEM}] non c'è memoria sufficiente per aggiungere una nuova
- variabile all'ambiente.
\item[\errcode{EINVAL}] \param{name} è \val{NULL} o una stringa di lunghezza
nulla o che contiene il carattere ``\texttt{=}''.
+ \item[\errcode{ENOMEM}] non c'è memoria sufficiente per aggiungere una nuova
+ variabile all'ambiente.
\end{errlist}}
\end{funcproto}
\fdecl{int unsetenv(const char *name)}
\fdesc{Rimuove una variabile di ambiente.}
}
-{La funzione ritorna 0 in caso di successo e $-1$ per un errore,
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore,
nel qual caso \var{errno} assumerà uno dei valori:
\begin{errlist}
\item[\errcode{EINVAL}] \param{name} è \val{NULL} o una stringa di lunghezza
nulla o che contiene il carattere ``\texttt{=}''.
- \end{errlist}}
+\end{errlist}}
\end{funcproto}
La funzione richiede soltanto il nome della variabile di ambiente
\acr{glibc} successive la 2.2.2, per le precedenti \func{unsetenv} era
definita come \texttt{void} e non restituiva nessuna informazione.}
-L'ultima funzione per la gestione dell'ambiente è \funcd{clearenv}, che viene
-usata per cancellare completamente tutto l'ambiente; il suo prototipo è:
+L'ultima funzione per la gestione dell'ambiente è
+\funcd{clearenv},\footnote{che come accennato è l'unica non presente nello
+ standard POSIX.1-2000, ed è disponibili solo per versioni della \acr{glibc}
+ a partire dalla 2.0; per poterla utilizzare occorre aver definito le macro
+ \macro{\_SVID\_SOURCE} e \macro{\_XOPEN\_SOURCE}.} che viene usata per
+cancellare completamente tutto l'ambiente; il suo prototipo è:
+\begin{funcproto}{
+\fhead{stdlib.h}
+\fdecl{int clearenv(void)}
+\fdesc{Cancella tutto l'ambiente.}
+}
+{La funzione ritorna $0$ in caso di successo e un valore diverso da zero per
+ un errore.}
+\end{funcproto}
In genere si usa questa funzione in maniera precauzionale per evitare i
problemi di sicurezza connessi nel trasmettere ai programmi che si invocano un
-ambiente che può contenere dei dati non controllati. In tal caso si provvede
-alla cancellazione di tutto l'ambiente per costruirne una versione
-``\textsl{sicura}'' da zero.
+ambiente che può contenere dei dati non controllati, le cui variabili possono
+causare effetti indesiderati. Con l'uso della funzione si provvede alla
+cancellazione di tutto l'ambiente originale in modo da poterne costruirne una
+versione ``\textsl{sicura}'' da zero.
+\index{variabili!di~ambiente|)}
-\subsection{La localizzazione}
-\label{sec:proc_localization}
-Abbiamo accennato in sez.~\ref{sec:proc_environ} come la variabile di ambiente
-\texttt{LANG} sia usata per indicare ai processi il valore della cosiddetta
-\textsl{localizzazione}. Si tratta di una funzionalità fornita dalle librerie
-di sistema\footnote{prenderemo in esame soltanto il caso della \acr{glibc}.}
-che consente di gestire in maniera automatica sia la lingua in cui vengono
-stampati i vari messaggi (come i messaggi associati agli errori che vedremo in
-sez.~\ref{sec:sys_strerror}) che le convenzioni usate nei vari paesi per una
-serie di aspetti come il formato dell'ora, quello delle date, gli ordinamenti
-alfabetici, le espressioni della valute, ecc.
+% \subsection{La localizzazione}
+% \label{sec:proc_localization}
-Da finire.
+% Abbiamo accennato in sez.~\ref{sec:proc_environ} come la variabile di ambiente
+% \envvar{LANG} sia usata per indicare ai processi il valore della cosiddetta
+% \textsl{localizzazione}. Si tratta di una funzionalità fornita dalle librerie
+% di sistema\footnote{prenderemo in esame soltanto il caso della \acr{glibc}.}
+% che consente di gestire in maniera automatica sia la lingua in cui vengono
+% stampati i vari messaggi (come i messaggi associati agli errori che vedremo in
+% sez.~\ref{sec:sys_strerror}) che le convenzioni usate nei vari paesi per una
+% serie di aspetti come il formato dell'ora, quello delle date, gli ordinamenti
+% alfabetici, le espressioni della valute, ecc.
+
+% Da finire.
% La localizzazione di un programma si può selezionare con la
\subsection{Il passaggio di un numero variabile di argomenti}
\label{sec:proc_variadic}
+\index{funzioni!variadic|(}
+
Come vedremo nei capitoli successivi, non sempre è possibile specificare un
numero fisso di argomenti per una funzione. Lo standard ISO C prevede nella
-sua sintassi la possibilità di definire delle \index{variadic}
-\textit{variadic function} che abbiano un numero variabile di argomenti,
-attraverso l'uso nella dichiarazione della funzione dello speciale costrutto
-``\texttt{...}'', che viene chiamato \textit{ellipsis}.
+sua sintassi la possibilità di definire delle \textit{variadic function} che
+abbiano un numero variabile di argomenti, 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
a seguire quelli addizionali.
\end{itemize*}
-Lo standard ISO C prevede che una \index{variadic} \textit{variadic function}
-abbia sempre almeno un argomento fisso. Prima di effettuare la dichiarazione
-deve essere incluso l'apposito \textit{header file} \file{stdarg.h}; un
-esempio di dichiarazione è il prototipo della funzione \func{execl} che
-vedremo in sez.~\ref{sec:proc_exec}:
+Lo standard ISO C prevede che una \textit{variadic function} abbia sempre
+almeno un argomento fisso. Prima di effettuare la dichiarazione deve essere
+incluso l'apposito \textit{header file} \headfile{stdarg.h}; un esempio di
+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 argomenti fissi ed un numero variabile
di altri argomenti, che andranno a costituire gli elementi successivi al primo
\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 argomento fisso come
-\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 è
- originaria dell'epoca dai primi compilatori, quando stava al programmatore
- scrivere codice ottimizzato, riservando esplicitamente alle variabili più
- usate l'uso dei registri del processore, oggi questa direttiva è in disuso
- dato che tutti i compilatori sono normalmente in grado di valutare con
- maggior efficacia degli stessi programmatori quando sia il caso di eseguire
- questa ottimizzazione.}
+alcuni compilatori è di non dichiarare l'ultimo argomento fisso come variabile
+di tipo \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 è originaria dell'epoca dai primi compilatori, quando stava al
+ programmatore scrivere codice ottimizzato, riservando esplicitamente alle
+ variabili più usate l'uso dei registri del processore, oggi questa direttiva
+ è in disuso pressoché completo dato che tutti i compilatori sono normalmente
+ in grado di valutare con maggior efficacia degli stessi programmatori quando
+ sia il caso di eseguire questa ottimizzazione.}
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
\textit{stack} secondo l'ordine in cui sono stati scritti nel prototipo della
funzione.
-Per fare questo in \file{stdarg.h} sono definite delle macro specifiche,
+Per fare questo in \headfile{stdarg.h} sono definite delle macro specifiche,
previste dallo standard ISO C89, che consentono di eseguire questa operazione.
La prima di queste macro è \macro{va\_start}, che inizializza opportunamente
una lista degli argomenti, la sua definizione è:
\textit{self-promoting}.
In generale è perfettamente legittimo richiedere meno argomenti di quelli che
-potrebbero essere stati effettivamente forniti, e nella esecuzione delle
+potrebbero essere stati effettivamente forniti, per cui nella esecuzione delle
\macro{va\_arg} ci si può fermare in qualunque momento ed i restanti argomenti
-saranno ignorati. Se invece si richiedono più argomenti di quelli forniti si
-otterranno dei valori indefiniti, si avranno risultati indefiniti anche quando
-si chiama \macro{va\_arg} specificando un tipo che non corrisponde a quello
-usato per il corrispondente argomento.
+saranno ignorati. Se invece si richiedono più argomenti di quelli
+effettivamente forniti si otterranno dei valori indefiniti. Si avranno
+risultati indefiniti anche quando si chiama \macro{va\_arg} specificando un
+tipo che non corrisponde a quello usato per il corrispondente argomento.
Infine una volta completata l'estrazione occorre indicare che si sono concluse
le operazioni con la macro \macro{va\_end}, la cui definizione è:
quei tipi di dati, in genere usati da una libreria, la cui struttura interna
non deve essere vista dal programma chiamante (da cui deriva il nome opaco)
che li devono utilizzare solo attraverso dalle opportune funzioni di
-gestione. Per questo motivo non può essere assegnata direttamente ad un'altra
-variabile dello stesso tipo. Per risolvere questo problema lo standard ISO
-C99\footnote{alcuni sistemi che non hanno questa macro provvedono al suo posto
- \macro{\_\_va\_copy} che era il nome proposto in una bozza dello standard.}
-ha previsto una macro ulteriore che permette di eseguire la copia di una lista
-degli argomenti:
+gestione.
+
+Per questo motivo una variabile di tipo \type{va\_list} non può essere
+assegnata direttamente ad un'altra variabile dello stesso tipo, ma lo standard
+ISO C99\footnote{alcuni sistemi che non hanno questa macro provvedono al suo
+ posto \macro{\_\_va\_copy} che era il nome proposto in una bozza dello
+ standard.} ha previsto una macro ulteriore che permette di eseguire la
+copia di una lista degli argomenti:
{\centering
\begin{funcbox}{
dei medesimi occorrerà tenerne conto (ad esempio un \ctyp{char} verrà visto da
\macro{va\_arg} come \ctyp{int}).
-Uno dei problemi che si devono affrontare con le funzioni con un numero
+Un altro 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 gli argomenti passati effettivamente in una chiamata.
+stabilire quanti sono gli argomenti effettivamente passati 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 argomento
-per specificare anche il tipo degli argomenti (come fa la stringa di formato
-per \func{printf}).
+fisso per specificare anche il tipo degli argomenti variabili, come fa la
+stringa di formato per \func{printf} (vedi sez.~\ref{sec:file_formatted_io}).
-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).
+Infine una ulteriore modalità diversa, che può essere applicata solo quando il
+tipo degli argomenti lo rende possibile, è quella che prevede di usare un
+valore speciale per l'ultimo argomento, come fa ad esempio \func{execl} che
+usa un puntatore \val{NULL} per indicare la fine della lista degli argomenti
+(vedi sez.~\ref{sec:proc_exec}).
+\index{funzioni!variadic|)}
\subsection{Il controllo di flusso non locale}
\label{sec:proc_longjmp}
Il controllo del flusso di un programma in genere viene effettuato con le
varie istruzioni del linguaggio C; fra queste la più bistrattata è il
-\code{goto}, che viene deprecato in favore dei costrutti della programmazione
-strutturata, che rendono il codice più leggibile e mantenibile. Esiste però un
-caso in cui l'uso di questa istruzione porta all'implementazione più
-efficiente e più chiara anche dal punto di vista della struttura del
-programma: quello dell'uscita in caso di errore.
+\instruction{goto}, che viene deprecato in favore dei costrutti della
+programmazione strutturata, che rendono il codice più leggibile e
+mantenibile. Esiste però un caso in cui l'uso di questa istruzione porta
+all'implementazione più efficiente e più chiara anche dal punto di vista della
+struttura del programma: quello dell'uscita in caso di errore.
\index{salto~non-locale|(}
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}. Il caso classico in cui si ha questa necessità,
-citato sia in \cite{APUE} che in \cite{glibc}, è quello di un programma nel
+citato sia in \cite{APUE} che in \cite{GlibcMan}, è 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
all'indietro di tutti gli errori rilevabili dalle funzioni usate nelle fasi
successive. Questo comporterebbe una notevole complessità, mentre sarebbe
molto più comodo poter tornare direttamente al ciclo di lettura principale,
-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.}
+scartando l'input come errato.\footnote{a meno che, come precisa
+ \cite{GlibcMan}, 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.}
Tutto ciò può essere realizzato proprio con un salto non-locale; questo di
norma viene realizzato salvando il contesto dello \itindex{stack}
\textit{stack} nel punto in cui si vuole tornare in caso di errore, e
-ripristinandolo, in modo da tornare nella funzione da cui si era partiti,
-quando serve. La funzione che permette di salvare il contesto dello
+ripristinandolo, in modo da tornare quando serve nella funzione da cui si era
+partiti. La funzione che permette di salvare il contesto dello
\itindex{stack} \textit{stack} è \funcd{setjmp}, il cui prototipo è:
-\begin{functions}
- \headdecl{setjmp.h}
- \funcdecl{int setjmp(jmp\_buf env)}
-
- Salva il contesto dello stack.
- \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}
+\begin{funcproto}{
+\fhead{setjmp.h}
+\fdecl{int setjmp(jmp\_buf env)}
+\fdesc{Salva il contesto dello \textit{stack}.}
+}
+{La funzione ritorna $0$ quando è chiamata direttamente ed un valore diverso
+ da zero quando ritorna da una chiamata di \func{longjmp} che usa il contesto
+ salvato in precedenza.}
+\end{funcproto}
Quando si esegue la funzione il contesto corrente dello \itindex{stack}
\textit{stack} viene salvato nell'argomento \param{env}, una variabile di tipo
\func{longjmp} può comportare conseguenze imprevedibili (e di norma fatali)
per il processo.
-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}
- \headdecl{setjmp.h}
- \funcdecl{void longjmp(jmp\_buf env, int val)}
-
- Ripristina il contesto dello stack.
-
- \bodydesc{La funzione non ritorna.}
-\end{functions}
+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{funcproto}{
+\fhead{setjmp.h}
+\fdecl{void longjmp(jmp\_buf env, int val)}
+\fdesc{Ripristina il contesto dello stack.}
+}
+{La funzione non ritorna.}
+\end{funcproto}
La funzione ripristina il contesto dello \itindex{stack} \textit{stack}
salvato da una chiamata a \func{setjmp} nell'argomento \param{env}. Dopo
-l'esecuzione della funzione il programma prosegue nel codice successivo al
-ritorno della \func{setjmp} con cui si era salvato \param{env}, che restituirà
-il valore
-\param{val} invece di zero. Il valore di \param{val} specificato nella
-chiamata deve essere diverso da zero, se si è specificato 0 sarà comunque
-restituito 1 al suo posto.
-
-In sostanza un \func{longjmp} è analogo ad un \code{return}, solo che invece
-di ritornare alla riga successiva della funzione chiamante, il programma
-ritorna alla posizione della relativa \func{setjmp}, l'altra differenza è che
-il ritorno può essere effettuato anche attraverso diversi livelli di funzioni
-annidate.
+l'esecuzione della funzione il programma prosegue nel codice successivo alla
+chiamata della \func{setjmp} con cui si era salvato \param{env}, che
+restituirà il valore dell'argomento \param{val} invece di zero. Il valore
+dell'argomento \param{val} deve essere sempre diverso da zero, se si è
+specificato 0 sarà comunque restituito 1 al suo posto.
+
+In sostanza l'esecuzione di \func{longjmp} è analoga a quella di una
+istruzione \instruction{return}, solo che invece di ritornare alla riga
+successiva della funzione chiamante, il programma in questo caso ritorna alla
+posizione della relativa \func{setjmp}. L'altra differenza fondamentale con
+\instruction{return} è che il ritorno può essere effettuato anche attraverso
+diversi livelli di funzioni annidate.
L'implementazione di queste funzioni comporta alcune restrizioni dato che esse
interagiscono direttamente con la gestione dello \itindex{stack}
\textit{stack} ed il funzionamento del compilatore stesso. In particolare
\func{setjmp} è implementata con una macro, pertanto non si può cercare di
-ottenerne l'indirizzo, ed inoltre delle chiamate a questa funzione sono sicure
+ottenerne l'indirizzo, ed inoltre le 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});
+\item come espressione di controllo in un comando condizionale, di selezione o
+ di iterazione (come \instruction{if}, \instruction{switch} o
+ \instruction{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;
In generale, dato che l'unica differenza fra la chiamata diretta e quella
ottenuta nell'uscita con un \func{longjmp} è costituita dal valore di ritorno
-di \func{setjmp}, quest'ultima usualmente viene chiamata all'interno di un
-comando \code{if}.
+di \func{setjmp}, pertanto quest'ultima viene usualmente chiamata all'interno
+di un una istruzione \instruction{if} che permetta di distinguere i due casi.
Uno dei punti critici dei salti non-locali è quello del valore delle
variabili, ed in particolare quello delle \index{variabili!automatiche}
\index{salto~non-locale|)}
-\subsection{La \textit{endianess}}
-\label{sec:sock_endianess}
+\subsection{La \textit{endianness}}
+\label{sec:sock_endianness}
-\itindbeg{endianess}
+\itindbeg{endianness}
-Uno dei problemi di programmazione che può dar luogo ad effetti imprevisti è
-quello relativo alla cosiddetta \textit{endianess}. Questa è una
+Un altro dei problemi di programmazione che può dar luogo ad effetti
+imprevisti è quello relativo alla cosiddetta \textit{endianness}. Questa è una
caratteristica generale dell'architettura hardware di un computer che dipende
dal fatto che la rappresentazione di un numero binario può essere fatta in due
modi, chiamati rispettivamente \textit{big endian} e \textit{little endian} a
cablati sui bus interni del computer).
\begin{figure}[!htb]
- \centering \includegraphics[height=3cm]{img/endianess}
+ \centering \includegraphics[height=3cm]{img/endianness}
\caption{Schema della disposizione dei dati in memoria a seconda della
- \textit{endianess}.}
- \label{fig:sock_endianess}
+ \textit{endianness}.}
+ \label{fig:sock_endianness}
\end{figure}
Per capire meglio il problema si consideri un intero a 32 bit scritto in una
locazione di memoria posta ad un certo indirizzo. Come illustrato in
-fig.~\ref{fig:sock_endianess} i singoli bit possono essere disposti in memoria
+fig.~\ref{fig:sock_endianness} i singoli bit possono essere disposti in memoria
in due modi: a partire dal più significativo o a partire dal meno
significativo. Così nel primo caso si troverà il byte che contiene i bit più
significativi all'indirizzo menzionato e il byte con i bit meno significativi
parte dal bit meno significativo è detto per lo stesso motivo \textit{little
endian}.
-Si può allora verificare quale tipo di \textit{endianess} usa il proprio
+Si può allora verificare quale tipo di \textit{endianness} usa il proprio
computer con un programma elementare che si limita ad assegnare un valore ad
una variabile per poi ristamparne il contenuto leggendolo un byte alla volta.
Il codice di detto programma, \file{endtest.c}, è nei sorgenti allegati,
allora se lo eseguiamo su un normale PC compatibile, che è \textit{little
endian} otterremo qualcosa del tipo:
-\begin{verbatim}
+\begin{Command}
[piccardi@gont sources]$ ./endtest
+\end{Command}
+%$
+\begin{Terminal}
Using value ABCDEF01
val[0]= 1
val[1]=EF
val[2]=CD
val[3]=AB
-\end{verbatim}%$
+\end{Terminal}
mentre su un vecchio Macintosh con PowerPC, che è \textit{big endian} avremo
qualcosa del tipo:
-\begin{verbatim}
+\begin{Command}
piccardi@anarres:~/gapil/sources$ ./endtest
+\end{Command}
+%$
+\begin{Terminal}
Using value ABCDEF01
val[0]=AB
val[1]=CD
val[2]=EF
val[3]= 1
-\end{verbatim}%$
+\end{Terminal}
-L'attenzione alla \textit{endianess} nella programmazione è importante, perché
+L'attenzione alla \textit{endianness} nella programmazione è importante, perché
se si fanno assunzioni relative alla propria architettura non è detto che
queste restino valide su un'altra architettura. Inoltre, come vedremo ad
esempio in sez.~\ref{sec:sock_addr_func}, si possono avere problemi quando ci
si trova a usare valori di un formato con una infrastruttura che ne usa
un altro.
-La \textit{endianess} di un computer dipende essenzialmente dalla architettura
+La \textit{endianness} di un computer dipende essenzialmente dalla architettura
hardware usata; Intel e Digital usano il \textit{little endian}, Motorola,
IBM, Sun (sostanzialmente tutti gli altri) usano il \textit{big endian}. Il
formato dei dati contenuti nelle intestazioni dei protocolli di rete (il
-cosiddetto \textit{network order} è anch'esso \textit{big endian}; altri
+cosiddetto \textit{network order}) è anch'esso \textit{big endian}; altri
esempi di uso di questi due diversi formati sono quello del bus PCI, che è
\textit{little endian}, o quello del bus VME che è \textit{big endian}.
\includecodesample{listati/endian.c}
\end{minipage}
\normalsize
- \caption{La funzione \func{endian}, usata per controllare il tipo di
+ \caption{La funzione \samplefunc{endian}, usata per controllare il tipo di
architettura della macchina.}
\label{fig:sock_endian_code}
\end{figure}
Per questo prima (\texttt{\small 10}) si definisce il puntatore \var{ptr} per
accedere al contenuto della prima variabile, ed infine calcola (\texttt{\small
11}) il valore della seconda assumendo che il primo byte sia quello meno
-significativo (cioè, per quanto visto in fig.~\ref{fig:sock_endianess}, che sia
+significativo (cioè, per quanto visto in fig.~\ref{fig:sock_endianness}, che sia
\textit{little endian}). Infine la funzione restituisce (\texttt{\small 12})
il valore del confronto delle due variabili.
-\itindend{endianess}
+In generale non ci si deve preoccupare della \textit{endianness} all'interno
+di un programma fintanto che questo non deve generare o manipolare dei dati
+che sono scambiati con altre macchine, ad esempio tramite via rete o tramite
+dei file binari. Nel primo caso la scelta è già stata fatta nella
+standardizzazione dei protocolli, che hanno adottato il \textit{big endian}
+(che viene detto anche per questo \textit{network order} e vedremo in
+sez.~\ref{sec:sock_func_ord} le funzioni di conversione che devono essere
+usate.
+
+Nel secondo caso occorre sapere quale \textit{endianness} è stata usata nei
+dati memorizzati sul file e tenerne conto nella rilettura e nella
+manipolazione e relativa modifica (e salvataggio). La gran parte dei formati
+binari standardizzati specificano quale \textit{endianness} viene utilizzata e
+basterà identificare qual'è, se se ne deve definire uno per i propri scopi
+basterà scegliere una volta per tutte quale usare e attenersi alla scelta.
+
+\itindend{endianness}
% LocalWords: like exec kernel thread main ld linux static linker char envp Gb
% LocalWords: exithandler handler violation inline SOURCE SVID XOPEN mincore
% LocalWords: length unsigned vec EFAULT EAGAIN dell'I memalign valloc posix
% LocalWords: boundary memptr alignment sizeof overrun mcheck abortfn enum big
-% LocalWords: mprobe DISABLED HEAD TAIL touch right emacs OSTYPE endianess IBM
+% LocalWords: mprobe DISABLED HEAD TAIL touch right emacs OSTYPE endianness IBM
% LocalWords: endian little endtest Macintosh PowerPC Intel Digital Motorola
% LocalWords: Sun order VME loader Windows DLL shared objects PRELOAD termios
% LocalWords: is to LC SIG str mem wcs assert ctype dirent fcntl signal stdio
% LocalWords: times library utmp syscall number Filesystem Hierarchy pathname
% LocalWords: context assembler sysconf fork Dinamic huge segmentation program
-% LocalWords: break store
+% LocalWords: break store Using
%%% Local Variables:
%%% mode: latex
projects / gapil.git / blobdiff