%% process.tex
%%
-%% Copyright (C) 2000-2006 Simone Piccardi. Permission is granted to
+%% Copyright (C) 2000-2007 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",
%% license is included in the section entitled "GNU Free Documentation
%% License".
%%
+
\chapter{L'interfaccia base con i processi}
\label{cha:process_interface}
Ci sono vari modi in cui i sistemi operativi 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 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
- anche per macchine a 32 bit.}
+unix-like come Linux è la cosiddetta \index{memoria~virtuale} \textsl{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 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
memoria reale o ad un dispositivo di stoccaggio secondario (come lo spazio
disco riservato alla swap, o i file che contengono il codice). Per ciascun
processo il kernel si cura di mantenere un mappa di queste corrispondenze
-nella cosiddetta \itindex{page~table}\textit{page table}.\footnote{questa è
+nella cosiddetta \itindex{page~table} \textit{page table}.\footnote{questa è
una semplificazione brutale, il meccanismo è molto più complesso; una buona
trattazione di come Linux gestisce la memoria virtuale si trova su
\cite{LinVM}.}
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}
+servono. Questo meccanismo è detto \index{paginazione} \textsl{paginazione}
(o \textit{paging}), ed è uno dei compiti principali del kernel.
Quando un processo cerca di accedere ad una pagina che non è nella memoria
Normalmente questo è il prezzo da pagare per avere un multitasking reale, ed
in genere il sistema è molto efficiente in questo lavoro; quando però ci siano
esigenze specifiche di prestazioni è possibile usare delle funzioni che
-permettono di bloccare il meccanismo della paginazione\index{paginazione} e
-mantenere fisse delle pagine in memoria (vedi
-sez.~\ref{sec:proc_mem_lock}). Inoltre per certe applicazioni gli algoritmi di
-gestione della memoria
+permettono di bloccare il meccanismo della \index{paginazione} paginazione e
+mantenere fisse delle pagine in memoria (vedi sez.~\ref{sec:proc_mem_lock}).
+Inoltre per certe applicazioni gli algoritmi di gestione della memoria
\subsection{La struttura della memoria di un processo}
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{memoria~virtuale} di un processo. Essa viene divisa in
+È pertanto importante capire come viene strutturata \index{memoria~virtuale}
+\textsl{la memoria virtuale} 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:
Storicamente questa seconda parte del segmento dati viene chiamata BSS (da
\textit{Block Started by Symbol}). La sua dimensione è fissa.
-\item Lo \itindex{heap}\textit{heap}. Tecnicamente lo si può considerare
+\item Lo \itindex{heap} \textit{heap}. Tecnicamente lo si può considerare
l'estensione del segmento dati, a cui di solito è posto giusto di seguito. È
qui che avviene l'allocazione dinamica della memoria; può essere
ridimensionato allocando e disallocando la memoria dinamica con le apposite
L'\textsl{allocazione automatica} è quella che avviene per gli argomenti di
una funzione e per le sue variabili locali (le cosiddette \textsl{variabili
automatiche}), che esistono solo per la durata della funzione. Lo spazio
-per queste variabili viene allocato nello \itindex{stack}\textit{stack} quando
+per queste variabili viene allocato nello \itindex{stack} \textit{stack} quando
viene eseguita la funzione e liberato quando si esce dalla medesima.
Esiste però un terzo tipo di allocazione, l'\textsl{allocazione dinamica}
cioè definire in fase di programmazione una variabile le cui dimensioni
possano essere modificate durante l'esecuzione del programma. Per questo le
librerie del C forniscono una serie opportuna di funzioni per eseguire
-l'allocazione dinamica di memoria (in genere nello \itindex{heap} heap).
+l'allocazione dinamica di memoria (in genere nello \itindex{heap}
+\textit{heap}).
Le variabili il cui contenuto è allocato in questo modo non potranno essere
usate direttamente come le altre (quelle nello \itindex{stack}
\begin{functions}
\headdecl{stdlib.h}
\funcdecl{void *calloc(size\_t nmemb, size\_t size)}
- Alloca nello heap un'area di memoria per un vettore di \param{nmemb} membri
- di \param{size} byte di dimensione. La memoria viene inizializzata a 0.
+ Alloca nello \textit{heap} un'area di memoria per un vettore di
+ \param{nmemb} membri di \param{size} byte di dimensione. La memoria viene
+ inizializzata a 0.
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}.
\funcdecl{void *malloc(size\_t size)}
- Alloca \param{size} byte nello heap. La memoria non viene inizializzata.
+ Alloca \param{size} byte nello \textit{heap}. La memoria non viene
+ inizializzata.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \val{NULL} in caso di fallimento, nel qual caso
Il problema più comune e più difficile da risolvere che si incontra con le
funzioni di allocazione è quando non viene opportunamente liberata la memoria
-non più utilizzata, quello che in inglese viene chiamato \textit{memory
- leak}\itindex{memory~leak}, cioè una \textsl{perdita di memoria}.
+non più utilizzata, quello che in inglese viene chiamato \itindex{memory~leak}
+\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}\itindex{memory~leak}.
+\itindex{memory~leak} \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}\itindex{memory~leak} è notevolmente ridimensionato attraverso l'uso
-accurato di appositi oggetti come gli \textit{smartpointers}. Questo però in
-genere va a scapito delle prestazioni dell'applicazione in esecuzione.
+programmazione ad oggetti, il problema dei \itindex{memory~leak}
+\textit{memory leak} è notevolmente ridimensionato attraverso l'uso accurato
+di appositi oggetti come gli \textit{smartpointers}. Questo però in genere va
+a scapito delle prestazioni dell'applicazione in esecuzione.
% TODO decidere cosa fare di questo che segue
% In altri linguaggi come il java e recentemente il C\# il problema non si pone
% automatica, ovvero il programmatore non deve minimamente preoccuparsi di
% liberare la memoria allocata precedentemente quando non serve più, poiché
% l'infrastruttura del linguaggio gestisce automaticamente la cosiddetta
-% \index{\textit{garbage~collection}}\textit{garbage collection}. In tal caso,
+% \index{\textit{garbage~collection}} \textit{garbage collection}. In tal caso,
% attraverso meccanismi simili a quelli del \textit{reference counting}, quando
% una zona di memoria precedentemente allocata non è più riferita da nessuna
% parte del codice in esecuzione, può essere deallocata automaticamente in
Una possibile alternativa all'uso di \func{malloc}, che non soffre dei
-problemi di \textit{memory leak}\itindex{memory~leak} descritti in precedenza,
-è la funzione \funcd{alloca}, che invece di allocare la memoria nello
-\itindex{heap}\textit{heap} usa il segmento di \itindex{stack} \textit{stack}
-della funzione corrente. La sintassi è identica a quella di \func{malloc}, il
-suo prototipo è:
+problemi di \itindex{memory~leak} \textit{memory leak} descritti in
+precedenza, è la funzione \funcd{alloca}, che invece di allocare la memoria
+nello \itindex{heap} \textit{heap} usa il segmento di \itindex{stack}
+\textit{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.
quanto essa viene rilasciata automaticamente al ritorno della funzione.
Come è evidente questa funzione ha molti vantaggi, anzitutto permette di
-evitare alla radice i problemi di \textit{memory leak}\itindex{memory~leak},
+evitare alla radice i problemi di \itindex{memory~leak} \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
\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
parte dei vari processi.
Nell'uso comune un processo non deve preoccuparsi di tutto ciò, in quanto il
-meccanismo della paginazione\index{paginazione} riporta in RAM, ed in maniera
+meccanismo della \index{paginazione} paginazione riporta in RAM, ed in maniera
trasparente, tutte le pagine che gli occorrono; esistono però esigenze
particolari in cui non si vuole che questo meccanismo si attivi. In generale i
motivi per cui si possono avere di queste necessità sono due:
\begin{itemize}
-\item \textsl{La velocità}. Il processo della paginazione\index{paginazione} è
- trasparente solo se il programma in esecuzione non è sensibile al tempo che
- occorre a riportare la pagina in memoria; per questo motivo processi critici
- che hanno esigenze di tempo reale o tolleranze critiche nelle risposte (ad
- esempio processi che trattano campionamenti sonori) possono non essere in
- grado di sopportare le variazioni della velocità di accesso dovuta alla
- paginazione.
+\item \textsl{La velocità}. Il processo della \index{paginazione} paginazione
+ è trasparente solo se il programma in esecuzione non è sensibile al tempo
+ che occorre a riportare la pagina in memoria; per questo motivo processi
+ critici che hanno esigenze di tempo reale o tolleranze critiche nelle
+ risposte (ad esempio processi che trattano campionamenti sonori) possono non
+ essere in grado di sopportare le variazioni della velocità di accesso dovuta
+ alla paginazione.
In certi casi poi un programmatore può conoscere meglio dell'algoritmo di
allocazione delle pagine le esigenze specifiche del suo programma e decidere
\item \textsl{La sicurezza}. Se si hanno password o chiavi segrete in chiaro
in memoria queste possono essere portate su disco dal meccanismo della
- paginazione\index{paginazione}. Questo rende più lungo il periodo di tempo
+ \index{paginazione} paginazione. Questo rende più lungo il periodo di tempo
in cui detti segreti sono presenti in chiaro e più complessa la loro
cancellazione (un processo può cancellare la memoria su cui scrive le sue
variabili, ma non può toccare lo spazio disco su cui una pagina di memoria
\itindbeg{memory~locking}
-Il meccanismo che previene la paginazione\index{paginazione} di parte della
+Il meccanismo che previene la \index{paginazione} 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
memoria virtuale del processo, e non al segmento reale di RAM su cui essa
viene mantenuta. La regola è che se un segmento di RAM fa da supporto ad
almeno una pagina bloccata allora esso viene escluso dal meccanismo della
-paginazione\index{paginazione}. I blocchi non si accumulano, se si blocca due
+\index{paginazione} paginazione. I blocchi non si accumulano, se si blocca due
volte la stessa pagina non è necessario sbloccarla due volte, una pagina o è
-bloccata oppure no.
+bloccata oppure no.
Il \textit{memory lock} persiste fintanto che il processo che detiene la
memoria bloccata non la sblocca. Chiaramente la terminazione del processo
comporta anche la fine dell'uso della sua memoria virtuale, e quindi anche di
tutti i suoi \textit{memory lock}. Infine i \textit{memory lock} non sono
ereditati dai processi figli,\footnote{ma siccome Linux usa il
- \itindex{copy~on~write}\textit{copy on write} (vedi
+ \itindex{copy~on~write} \textit{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 \textit{memory lock} del padre.} e
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
tutti gli altri processi, per cui fino al kernel 2.6.9 solo un processo con i
-privilegi opportuni (la \itindex{capabilities}\textit{capability}
+privilegi opportuni (la \itindex{capabilities} \textit{capability}
\const{CAP\_IPC\_LOCK}, vedi sez.~\ref{sec:proc_capabilities}) aveva la
-capacità di bloccare una pagina.
+capacità di bloccare una pagina.
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
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 paginazione \index{paginazione} di
+Le funzioni per bloccare e sbloccare la \index{paginazione} paginazione di
singole sezioni di memoria sono \funcd{mlock} e \funcd{munlock}; i loro
prototipi sono:
\begin{functions}
\end{functions}
Le due funzioni permettono rispettivamente di bloccare e sbloccare la
-paginazione\index{paginazione} per l'intervallo di memoria specificato dagli
+\index{paginazione} paginazione per l'intervallo di memoria specificato dagli
argomenti, che ne indicano nell'ordine l'indirizzo iniziale e la lunghezza.
Tutte le pagine che contengono una parte dell'intervallo bloccato sono
mantenute in RAM per tutta la durata del blocco.\footnote{con altri kernel si
della dimensione delle pagine di memoria.}
Altre due funzioni, \funcd{mlockall} e \funcd{munlockall}, consentono di
-bloccare genericamente la paginazione\index{paginazione} per l'intero spazio
+bloccare genericamente la \index{paginazione} paginazione per l'intero spazio
di indirizzi di un processo. I prototipi di queste funzioni sono:
\begin{functions}
\headdecl{sys/mman.h}
\bodydesc{Codici di ritorno ed errori sono gli stessi di \func{mlock} e
\func{munlock}, con un kernel successivo al 2.6.9 l'uso di
- \func{munlockall} senza la \itindex{capabilities}\textit{capability}
+ \func{munlockall} senza la \itindex{capabilities} \textit{capability}
\const{CAP\_IPC\_LOCK} genera un errore di \errcode{EPERM}.}
\end{functions}
Con \func{mlockall} si possono bloccare tutte le pagine mappate nello spazio
di indirizzi del processo, sia che comprendano il \index{segmento!dati}
-\index{segmento!testo} segmento di testo, di dati, lo \itindex{stack} stack,
-lo \itindex{heap} heap e pure le funzioni di libreria chiamate, i file mappati
-in memoria, i dati del kernel mappati in user space, la memoria condivisa.
-L'uso dei flag permette di selezionare con maggior finezza le pagine da
-bloccare, ad esempio limitandosi a tutte le pagine allocate a partire da un
-certo momento.
+\index{segmento!testo} segmento di testo, di dati, lo \itindex{stack}
+\textit{stack}, lo \itindex{heap} \textit{heap} e pure le funzioni di libreria
+chiamate, i file mappati in memoria, i dati del kernel mappati in user space,
+la memoria condivisa. L'uso dei flag permette di selezionare con maggior
+finezza le pagine da bloccare, ad esempio limitandosi a tutte le pagine
+allocate a partire da un certo momento.
In ogni caso un processo real-time che deve entrare in una
\index{sezione~critica} sezione critica deve provvedere a riservare memoria
sufficiente prima dell'ingresso, per scongiurare l'occorrenza di un eventuale
-\textit{page fault}\itindex{page~fault} causato dal meccanismo di \textit{copy
- on write}\itindex{copy~on~write}. Infatti se nella \index{sezione~critica}
-sezione critica si va ad utilizzare memoria che non è ancora stata riportata
-in RAM si potrebbe avere un \itindex{page~fault}\textit{page fault} durante
-l'esecuzione della stessa, con conseguente rallentamento (probabilmente
-inaccettabile) dei tempi di esecuzione.
+\itindex{page~fault} \textit{page fault} causato dal meccanismo di
+\itindex{copy~on~write} \textit{copy on write}. Infatti se nella
+\index{sezione~critica} sezione critica si va ad utilizzare memoria che non è
+ancora stata riportata in RAM si potrebbe avere un \itindex{page~fault}
+\textit{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 \itindex{stack} stack, dopo di che, per
-essere sicuri che esse siano state effettivamente portate in memoria, ci si
-scrive sopra.
+che esse vengano mappate in RAM dallo \itindex{stack} \textit{stack}, dopo di
+che, per essere sicuri che esse siano state effettivamente portate in memoria,
+ci si scrive sopra.
\itindend{memory~locking}
fatta in precedenza da un'altra \func{putenv}. Questo perché il vettore delle
variabili di ambiente iniziale, creato dalla chiamata ad \func{exec} (vedi
sez.~\ref{sec:proc_exec}) è piazzato al di sopra dello \itindex{stack} stack,
-(vedi fig.~\ref{fig:proc_mem_layout}) e non nello \itindex{heap} heap e non
-può essere deallocato. Inoltre la memoria associata alle variabili di
+(vedi fig.~\ref{fig:proc_mem_layout}) e non nello \itindex{heap} \textit{heap}
+e non può essere deallocato. Inoltre la memoria associata alle variabili di
ambiente eliminate non viene liberata.
L'ultima funzione è \funcd{clearenv}, che viene usata per cancellare
Talvolta però è necessario che la funzione possa restituire indietro alla
funzione chiamante un valore relativo ad uno dei suoi argomenti. Per far
-questo si usa il cosiddetto \itindex{value~result~argument}\textit{value
+questo si usa il cosiddetto \itindex{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
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 \textit{variadic
- function}\index{variadic} che abbiano un numero variabile di argomenti,
+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{\textellipsis}'', che viene chiamato \textit{ellipsis}.
+``\texttt{\textellipsis}'', 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 \textit{variadic function}\index{variadic}
+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 header file \file{stdarg.h}; un esempio di
dichiarazione è il prototipo della funzione \func{execl} che vedremo in
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 \itindex{stack} 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:
+sequenziale; essi verranno estratti dallo \itindex{stack} \textit{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}
\item Inizializzare un puntatore alla lista degli argomenti di tipo
\macro{va\_list} attraverso la macro \macro{va\_start}.
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
-\itindex{stack} stack all'indirizzo dove sono stati salvati gli argomenti, è
-assolutamente normale pensare di poter effettuare questa operazione.
+\itindex{stack} \textit{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
-motivo \macro{va\_list} è definito come \textsl{tipo opaco}\index{tipo!opaco}
+motivo \macro{va\_list} è definito come \index{tipo!opaco} \textsl{tipo opaco}
e non può essere assegnato 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
Uno dei possibili problemi che si possono avere con le subroutine è quello di
restituire alla funzione chiamante dei dati che sono contenuti in una
variabile automatica. Ovviamente quando la subroutine ritorna la sezione
-dello \itindex{stack} stack che conteneva la variabile automatica potrà essere
-riutilizzata da una nuova funzione, con le immaginabili conseguenze di
-sovrapposizione e sovrascrittura dei dati.
+dello \itindex{stack} \textit{stack} che conteneva la variabile automatica
+potrà essere riutilizzata da una nuova funzione, con le immaginabili
+conseguenze di sovrapposizione e sovrascrittura dei dati.
Per questo una delle regole fondamentali della programmazione in C è che
all'uscita di una funzione non deve restare nessun riferimento alle variabili
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} 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 \itindex{stack} stack è \funcd{setjmp},
-il cui prototipo è:
+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
+\itindex{stack} \textit{stack} è \funcd{setjmp}, il cui prototipo è:
\begin{functions}
\headdecl{setjmp.h}
\funcdecl{int setjmp(jmp\_buf env)}
che usa il contesto salvato in precedenza.}
\end{functions}
-Quando si esegue la funzione il contesto corrente dello \itindex{stack} stack
-viene salvato nell'argomento \param{env}, una variabile di tipo
+Quando si esegue la funzione il contesto corrente dello \itindex{stack}
+\textit{stack} viene salvato nell'argomento \param{env}, una variabile di tipo
\type{jmp\_buf}\footnote{questo è un classico esempio di variabile di
- \textsl{tipo opaco}\index{tipo!opaco}. Si definiscono così strutture ed
+ \index{tipo!opaco} \textsl{tipo opaco}. Si definiscono così strutture ed
altri oggetti usati da una libreria, la cui struttura interna non deve
essere vista dal programma chiamante (da cui il nome) che li devono
utilizzare solo attraverso dalle opportune funzioni di gestione.} che deve
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
-\itindex{stack} stack effettuando il salto non-locale. Si tenga conto che il
-contesto salvato in \param{env} viene invalidato se la funzione che ha
+\itindex{stack} \textit{stack} effettuando il salto non-locale. Si tenga conto
+che il contesto salvato in \param{env} viene invalidato se la funzione 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.
\bodydesc{La funzione non ritorna.}
\end{functions}
-La funzione ripristina il contesto dello \itindex{stack} 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
+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.
annidate.
L'implementazione di queste funzioni comporta alcune restrizioni dato che esse
-interagiscono direttamente con la gestione dello \itindex{stack} 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 solo in
-uno dei seguenti casi:
+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
+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});
memoria manterranno il valore avuto al momento della chiamata di
\func{longjmp}, mentre quelli tenuti nei registri del processore (che nella
chiamata ad un'altra funzione vengono salvati nel contesto nello
-\itindex{stack} stack) 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
+\itindex{stack} \textit{stack}) 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
\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).}.
+ memoria).}
\index{salto~non-locale|)}
-%%% Local Variables:
-%%% mode: latex
-%%% TeX-master: "gapil"
-%%% End:
+
% LocalWords: like exec kernel thread main ld linux static linker char envp Gb
% LocalWords: sez POSIX exit system call cap abort shell diff errno stdlib int
% LocalWords: socket variadic ellipsis header stdarg execl self promoting last
% LocalWords: float double short register type dest src extern setjmp jmp buf
% LocalWords: env return if while sottoprocesso Di
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "gapil"
+%%% End:
projects / gapil.git / blobdiff