X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=process.tex;h=3f500455336e5b8f1bfb686e4fdbfc1d1a95649a;hp=4db223d20432394227cf26a2c7af5c9649993b59;hb=ff76d56c6a2c280cbe4f153173488871d7b12336;hpb=6e257bf71f9acd5839dbae72de3dc9523cfb47c9 diff --git a/process.tex b/process.tex index 4db223d..3f50045 100644 --- a/process.tex +++ b/process.tex @@ -1,6 +1,6 @@ %% 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", @@ -8,6 +8,7 @@ %% license is included in the section entitled "GNU Free Documentation %% License". %% + \chapter{L'interfaccia base con i processi} \label{cha:process_interface} @@ -261,13 +262,12 @@ esecuzione, e le varie funzioni utilizzabili per la sua gestione. 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 @@ -285,7 +285,7 @@ indirizzi virtuale 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}.} @@ -306,7 +306,7 @@ gestita in maniera trasparente dal kernel.\footnote{in genere con l'ausilio 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 @@ -325,10 +325,9 @@ a tempi molto pi 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} @@ -344,8 +343,8 @@ virtuale, il kernel risponde al relativo \itindex{page~fault} \textit{page fault} mandando un segnale \const{SIGSEGV} al processo, che normalmente ne causa la terminazione immediata. -È pertanto importante capire come viene strutturata \textsl{la memoria - virtuale} \index{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: @@ -387,7 +386,7 @@ 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 @@ -446,7 +445,7 @@ loro occupato non viene liberato fino alla sua conclusione. 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} @@ -458,7 +457,8 @@ Il C non consente di usare variabili allocate dinamicamente, non 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} @@ -473,14 +473,16 @@ loro prototipi sono i seguenti: \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 @@ -568,8 +570,8 @@ tollerante nei confronti di piccoli errori come quello di chiamate doppie a 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 @@ -582,13 +584,13 @@ Il problema 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 @@ -596,7 +598,7 @@ genere va a scapito delle prestazioni dell'applicazione in esecuzione. % 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 @@ -626,11 +628,11 @@ molto complesse riguardo l'allocazione della memoria. 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. @@ -646,7 +648,7 @@ la memoria allocata (e quindi non esiste un analogo della \func{free}) in 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 @@ -729,24 +731,25 @@ standard descritte in precedenza, che sono costruite su di esse. \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 @@ -757,7 +760,7 @@ motivi per cui si possono avere di queste necessit \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 @@ -767,22 +770,22 @@ motivi per cui si possono avere di queste necessit \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 @@ -792,9 +795,9 @@ con \func{exec} (vedi sez.~\ref{sec:proc_exec}). 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 @@ -817,7 +820,7 @@ poi ogni processo pu 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} @@ -845,7 +848,7 @@ prototipi sono: \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 @@ -853,7 +856,7 @@ 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} @@ -866,7 +869,7 @@ di indirizzi di un processo. I prototipi di queste funzioni sono: \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} @@ -882,28 +885,28 @@ costanti: 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} @@ -1274,8 +1277,8 @@ corrente sar 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 @@ -1341,7 +1344,7 @@ nella programmazione normale. 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 @@ -1354,10 +1357,10 @@ strutture degli indirizzi utilizzate, viene usato questo meccanismo. 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 @@ -1374,7 +1377,7 @@ tre punti: 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 @@ -1399,9 +1402,9 @@ quando la si va a definire. Gli argomenti fissi infatti hanno un loro nome, ma quelli variabili vengono indicati in maniera generica dalla \textit{ellipsis}. L'unica modalità in cui essi possono essere recuperati è pertanto quella -sequenziale; essi verranno estratti dallo \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}. @@ -1457,11 +1460,12 @@ argomenti e poter memorizzare una posizione durante la stessa. La cosa pi naturale in questo caso sembrerebbe quella di copiarsi il puntatore alla lista degli argomenti con una semplice assegnazione. Dato che una delle realizzazioni più comuni di \macro{va\_list} è quella di un puntatore nello -\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 @@ -1511,9 +1515,9 @@ come ultimo argomento (come fa ad esempio \func{execl} che usa un puntatore 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 @@ -1559,11 +1563,11 @@ scartando l'input come errato.\footnote{a meno che, come precisa \cite{glibc}, 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)} @@ -1575,10 +1579,10 @@ il cui prototipo 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 @@ -1589,8 +1593,8 @@ essere viste in tutte le funzioni del programma. 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. @@ -1607,10 +1611,11 @@ un punto precedentemente stabilito con \func{setjmp} si usa la funzione \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. @@ -1622,11 +1627,11 @@ il ritorno pu 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}); @@ -1661,24 +1666,21 @@ Quello che succede infatti 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 @@ -1700,3 +1702,8 @@ dichiarandole tutte come \direct{volatile}\footnote{la direttiva % 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: