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.
\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
\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
+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.
funzione chiude tutti i file descriptor appartenenti al processo, cosa che
però non comporta il salvataggio dei dati eventualmente presenti nei buffer
degli \textit{stream}, (torneremo sulle due interfacce dei file in
-cap.~\ref{cha:files_std_interface} e
-cap.~\ref{cha:file_unix_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: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
sez.~\ref{sec:proc_wait}).
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 ritorna $0$ in caso di successo e
- $-1$ per un errore, \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.}
}
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}.
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}{
\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;
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
\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}
\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 funzione
-permette di ottenere l'attuale posizione della fine del \index{segmento!dati}
-segmento dati.
+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 è:
+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}
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}
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}
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
- \const{MCHECK\_OK} & riportato a \func{mprobe} se nessuna
+ \const{MCHECK\_OK} & Riportato a \func{mprobe} se nessuna
inconsistenza è presente.\\
- \const{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}.\\
- \const{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.\\
- \const{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.\\
- \const{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
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
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}
projects / gapil.git / blobdiff