X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=process.tex;h=8d85fcb4a736778d776ec69f621a780ea2234b76;hp=2cca5986b9c0f08ed8f83f3d296e492e77119ef9;hb=0196c376e39fc18f8cd5e7fef47b61264f943faf;hpb=c49e97bdcba8e4da8578d5a048a5764a622aff1e diff --git a/process.tex b/process.tex index 2cca598..8d85fcb 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-2008 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} @@ -34,8 +35,8 @@ ciascun processo vedr tutte le parti uguali siano condivise), avrà un suo spazio di indirizzi, variabili proprie e sarà eseguito in maniera completamente indipendente da tutti gli altri.\footnote{questo non è del tutto vero nel caso di un programma - \textit{multi-thread}, ma la gestione dei \textit{thread} in Linux sarà - trattata a parte.} + \textit{multi-thread}, ma la gestione dei \itindex{thread} \textit{thread} + in Linux sarà trattata a parte in cap.~\ref{cha:threads}.} \subsection{La funzione \func{main}} @@ -48,8 +49,8 @@ dinamico del codice e alla fine lo esegue. Infatti, a meno di non aver specificato il flag \texttt{-static} durante la compilazione, tutti i programmi in Linux sono incompleti e necessitano di essere \textsl{collegati} alle librerie condivise quando vengono avviati. La procedura è controllata da -alcune variabili di ambiente e dal contenuto di \file{/etc/ld.so.conf}. I -dettagli sono riportati nella man page di \cmd{ld.so}. +alcune variabili di ambiente e dal contenuto di \conffile{/etc/ld.so.conf}. I +dettagli sono riportati nella pagina di manuale di \cmd{ld.so}. Il sistema fa partire qualunque programma chiamando la funzione \func{main}; sta al programmatore chiamare così la funzione principale del programma da cui @@ -81,8 +82,8 @@ controllo direttamente alla funzione di conclusione dei processi del kernel. Oltre alla conclusione ``\textsl{normale}'' esiste anche la possibilità di una conclusione ``\textsl{anomala}'' del programma a causa della ricezione di un -segnale (si veda cap.~\ref{cha:signals}) o della chiamata alla funzione -\func{abort}; torneremo su questo in sez.~\ref{sec:proc_termination}. +segnale (tratteremo i segnali in cap.~\ref{cha:signals}) o della chiamata alla +funzione \func{abort}; torneremo su questo in sez.~\ref{sec:proc_termination}. Il valore di ritorno della funzione \func{main}, o quello usato nelle chiamate ad \func{exit} e \func{\_exit}, viene chiamato \textsl{stato di uscita} (o @@ -233,7 +234,44 @@ normalmente un programma \begin{figure}[htb] \centering - \includegraphics[width=9cm]{img/proc_beginend} +% \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}}; + + \filldraw[fill=black!15] (1.5,2) rectangle (4,3); + \draw (2.75,2.5) node {\texttt{ld-linux.so}}; + \draw [->] (2.75,1) -- (2.75,2); + \draw (2.75,1.5) node [anchor=west]{\texttt{exec}}; + + \filldraw[fill=black!15,rounded corners] (1.5,4) rectangle (4,5); + \draw (2.75,4.5) node {\texttt{main}}; + + \draw [<->, dashed] (2.75,3) -- (2.75,4); + \draw [->] (1.5,4.5) -- (0.3,4.5) -- (0.3,1); + \draw (0.9,4.5) node [anchor=south] {\texttt{\_exit}}; + + \filldraw[fill=black!15,rounded corners] (1.5,6) rectangle (4,7); + \draw (2.75,6.5) node {\texttt{funzione}}; + + \draw [<->, dashed] (2.75,5) -- (2.75,6); + \draw [->] (1.5,6.5) -- (0.05,6.5) -- (0.05,1); + \draw (0.9,6.5) node [anchor=south] {\texttt{\_exit}}; + + \draw (6.75,4.5) node (exit) [rectangle,fill=black!15,minimum width=2.5cm,minimum height=1cm,rounded corners, draw]{\texttt{exit}}; + + \draw[->] (4,6.5) -- node[anchor=south west]{\texttt{exit}} (exit); + \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[<->, dashed] (exithandler1) -- (exit); + \draw[<->, dashed] (exithandler2) -- (exit); + \draw[<->, dashed] (stream) -- (exit); + \end{tikzpicture} \caption{Schema dell'avvio e della conclusione di un programma.} \label{fig:proc_prog_start_stop} \end{figure} @@ -261,13 +299,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 +322,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 +343,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 +362,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} @@ -337,15 +373,15 @@ gestione della memoria Benché lo spazio di indirizzi virtuali copra un intervallo molto ampio, solo una parte di essi è effettivamente allocato ed utilizzabile dal processo; il tentativo di accedere ad un indirizzo non allocato è un tipico errore che si -commette quando si è manipolato male un puntatore e genera quello che viene -chiamato un \textit{segmentation fault}. Se si tenta cioè di leggere o -scrivere da un indirizzo per il quale non esiste un'associazione della pagina -virtuale, il kernel risponde al relativo \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 +commette quando si è manipolato male un puntatore e genera quella che viene +chiamata una \itindex{segment~violation} \textit{segment violation}. Se si +tenta cioè di leggere o scrivere da un indirizzo per il quale non esiste +un'associazione della pagina virtuale, il kernel risponde al relativo +\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 \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 +423,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 @@ -403,10 +439,17 @@ seguenti segmenti: viene il nome \itindex{stack} \textit{stack}) in sequenza uno sull'altro; in questo modo le funzioni possono essere chiamate ricorsivamente. Al ritorno della funzione lo spazio è automaticamente rilasciato e - ``\textsl{ripulito}''. La pulizia in C e C++ viene fatta dal - chiamante.\footnote{a meno che non sia stato specificato l'utilizzo di una - calling convention diversa da quella standard.} -% TODO verificare le modalità di cambiamento della calling convention + ``\textsl{ripulito}''.\footnote{il compilatore si incarica di generare + automaticamente il codice necessario, seguendo quella che viene chiamata + una \textit{calling convention}; quella standard usata con il C ed il C++ + è detta \textit{cdecl} e prevede che gli argomenti siano caricati nello + \textit{stack} dal chiamante da destra a sinistra, e che si il chiamante + stesso ad eseguire la ripulitura dello \textit{stack} al ritorno della + funzione, se ne possono però utilizzare di alternative (ad esempio nel + pascal gli argomenti sono inseriti da sinistra a destra ed è compito del + chiamato ripulire lo \textit{stack}), in genere non ci si deve preoccupare + di questo fintanto che non si mescolano funzioni scritte con linguaggi + diversi.} La dimensione di questo segmento aumenta seguendo la crescita dello \itindex{stack} \textit{stack} del programma, ma non viene ridotta quando @@ -415,7 +458,27 @@ seguenti segmenti: \begin{figure}[htb] \centering - \includegraphics[height=12cm]{img/memory_layout} +% \includegraphics[height=12cm]{img/memory_layout} + \begin{tikzpicture} + \draw (0,0) rectangle (4,1); + \draw (2,0.5) node {text}; + \draw (0,1) rectangle (4,2.5); + \draw (2,1.75) node {dati inizializzati}; + \draw (0,2.5) rectangle (4,5); + \draw (2,3.75) node {dati non inizializzati}; + \draw (0,5) rectangle (4,9); + \draw[dashed] (0,6) -- (4,6); + \draw[dashed] (0,8) -- (4,8); + \draw (2,5.5) node {heap}; + \draw (2,8.5) node {stack}; + \draw [->] (2,6) -- (2,6.5); + \draw [->] (2,8) -- (2,7.5); + \draw (0,9) rectangle (4,10); + \draw (2,9.5) node {environment}; + \draw (4,0) node [anchor=west] {\texttt{0x08000000}}; + \draw (4,5) node [anchor=west] {\texttt{0x08xxxxxx}}; + \draw (4,9) node [anchor=west] {\texttt{0xC0000000}}; + \end{tikzpicture} \caption{Disposizione tipica dei segmenti di memoria di un processo.} \label{fig:proc_mem_layout} \end{figure} @@ -446,7 +509,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 +521,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} @@ -467,24 +531,22 @@ attraverso i puntatori alla memoria loro riservata che si sono ottenuti dalle funzioni di allocazione. -\subsection{Le funzioni \func{malloc}, \func{calloc}, \func{realloc} e - \func{free}} -\label{sec:proc_mem_malloc} - Le funzioni previste dallo standard ANSI C per la gestione della memoria sono quattro: \funcd{malloc}, \funcd{calloc}, \funcd{realloc} e \funcd{free}, i 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 @@ -572,8 +634,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 @@ -586,13 +648,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 @@ -600,7 +662,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 @@ -628,22 +690,17 @@ ricompilare il programma,\footnote{esempi sono \textit{Dmalloc} \textit{Electric Fence} di Bruce Perens.} di eseguire diagnostiche anche molto complesse riguardo l'allocazione della memoria. - -\subsection{Le funzioni \func{alloca}, \func{brk} e \func{sbrk}} -\label{sec:proc_mem_sbrk_alloca} - Una possibile alternativa all'uso di \func{malloc}, che non soffre dei -problemi di \textit{memory leak}\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. + Alloca \param{size} byte nello \textit{stack}. - \bodydesc{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}.} + \bodydesc{La funzione restituisce il puntatore alla zona di memoria + allocata.} \end{prototype} La funzione alloca la quantità di memoria (non inizializzata) richiesta @@ -653,7 +710,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 @@ -671,16 +728,6 @@ suo utilizzo quindi limita la portabilit non può essere usata nella lista degli argomenti di una funzione, perché lo spazio verrebbe allocato nel mezzo degli stessi. -% Questo è riportato solo dal manuale delle glibc, nelle pagine di manuale non c'è -% traccia di tutto ciò -% -%Inoltre se si -%cerca di allocare troppa memoria non si ottiene un messaggio di errore, ma un -%segnale di \textit{segment violation} analogo a quello che si avrebbe da una -%ricorsione infinita. -% TODO inserire più informazioni su alloca come da man page - - Inoltre non è chiaramente possibile usare \func{alloca} per allocare memoria che deve poi essere usata anche al di fuori della funzione in cui essa viene chiamata, dato che all'uscita dalla funzione lo spazio allocato diventerebbe @@ -688,15 +735,29 @@ libero, e potrebbe essere sovrascritto all'invocazione di nuove funzioni. Questo è lo stesso problema che si può avere con le variabili automatiche, su cui torneremo in sez.~\ref{sec:proc_auto_var}. +Infine non esiste un modo di sapere se l'allocazione ha avuto successo, la +funzione infatti viene realizzata inserendo del codice \textit{inline} nel +programma\footnote{questo comporta anche il fatto che non è possibile + sostituirla con una propria versione o modificarne il comportamento + collegando il proprio programma con un'altra libreria.} che si limita a +modificare il puntatore nello \itindex{stack} \textit{stack} e non c'è modo di +sapere se se ne sono superate le dimensioni, per cui in caso di fallimento +nell'allocazione il comportamento del programma può risultare indefinito, +dando luogo ad una \itindex{segment~violation} \textit{segment violation} la +prima volta che cercherà di accedere alla memoria non effettivamente +disponibile. Le due funzioni seguenti\footnote{le due funzioni sono state definite con BSD - 4.3, non fanno parte delle librerie standard del C e mentre sono state - esplicitamente escluse dallo standard POSIX.} vengono utilizzate soltanto -quando è necessario effettuare direttamente la gestione della memoria -associata allo spazio dati di un processo, ad esempio qualora si debba -implementare la propria versione delle funzioni di allocazione della memoria -viste in sez.~\ref{sec:proc_mem_malloc}. La prima funzione è \funcd{brk}, ed -il suo prototipo è: + 4.3, sono marcate obsolete in SUSv2 e non fanno parte delle librerie + standard del C e mentre sono state esplicitamente rimosse dallo standard + POSIX/1-2001.} vengono utilizzate soltanto quando è necessario effettuare +direttamente la gestione della memoria associata allo spazio dati di un +processo, ad esempio qualora si debba implementare la propria versione delle +funzioni di allocazione della memoria. Per poterle utilizzare è necessario +definire una della macro di funzionalità (vedi +sez.~\ref{sec:intro_gcc_glibc_std}) fra \macro{\_BSD\_SOURCE}, +\macro{\_SVID\_SOURCE} e \macro{\_XOPEN\_SOURCE} (ad un valore maggiore o +ugiale di 500). La prima funzione è \funcd{brk}, ed il suo prototipo è: \begin{prototype}{unistd.h}{int brk(void *end\_data\_segment)} Sposta la fine del segmento dei dati. @@ -704,15 +765,22 @@ il suo prototipo fallimento, nel qual caso \var{errno} assumerà il valore \errval{ENOMEM}.} \end{prototype} -La funzione è un'interfaccia diretta all'omonima system call ed imposta -l'indirizzo finale del \index{segmento!dati}segmento dati di un processo -all'indirizzo specificato da \param{end\_data\_segment}. Quest'ultimo deve -essere un valore ragionevole, ed inoltre la dimensione totale del segmento non -deve comunque eccedere un eventuale limite (si veda -sez.~\ref{sec:sys_resource_limit}) imposto sulle dimensioni massime dello -spazio dati del processo. - -Una seconda funzione per la manipolazione delle dimensioni +La funzione è un'interfaccia all'omonima system call ed imposta l'indirizzo +finale del \index{segmento!dati} segmento dati di un processo all'indirizzo +specificato da \param{end\_data\_segment}. Quest'ultimo deve essere un valore +ragionevole, ed inoltre la dimensione totale del segmento non deve comunque +eccedere un eventuale limite (si veda sez.~\ref{sec:sys_resource_limit}) +imposto sulle dimensioni massime dello spazio dati del processo. + +Il valore di ritorno della funzione fa riferimento alla versione fornita dalle +\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 dalle \acr{glibc} che +fornisce i valori di ritorno appena descritti, questo può non accadere se si +usano librerie diverse. + +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, e non di una system call.} è \funcd{sbrk}, ed il suo prototipo è: @@ -733,34 +801,29 @@ per i programmi normali standard descritte in precedenza, che sono costruite su di esse. -% \subsection{La personalizzazione delle funzioni di allocazione} -% \label{sec:proc_mem_malloc_custom} - -% TODO documentare \func{madvise} -% TODO documentare \func{mincore} - \subsection{Il controllo della memoria virtuale} \label{sec:proc_mem_lock} \index{memoria~virtuale|(} + Come spiegato in sez.~\ref{sec:proc_mem_gen} il kernel gestisce la memoria virtuale in maniera trasparente ai processi, decidendo quando rimuovere pagine dalla memoria per metterle nello swap, sulla base dell'utilizzo corrente da 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 @@ -771,7 +834,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 @@ -781,22 +844,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 @@ -806,9 +869,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 @@ -820,7 +883,7 @@ in byte.\footnote{con Linux questo non avviene e si deve ricorrere alla funzione \func{getpagesize}, vedi sez.~\ref{sec:sys_memory_res}.} -Con il kernel 2.6.9 anche un processo normale può bloccare la propria +A partire dal kernel 2.6.9 anche un processo normale può bloccare la propria memoria\footnote{la funzionalità è stata introdotta per non essere costretti a dare privilegi eccessivi a programmi di crittografia, che necessitano di questa funzionalità, ma che devono essere usati da utenti normali.} ma @@ -831,7 +894,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} @@ -842,7 +905,6 @@ prototipi sono: \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 @@ -860,7 +922,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 @@ -868,7 +930,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} @@ -881,7 +943,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} @@ -897,35 +959,46 @@ 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} -% TODO: trattare \func{madvise} + +% TODO documentare \func{madvise} +% TODO documentare \func{mincore} \index{memoria~virtuale|)} -\itindend{memory~locking} + +% \subsection{Gestione avanzata dell'allocazione della memoria} +% \label{sec:proc_mem_malloc_custom} + +% TODO: trattare le funzionalità avanzate di \func{malloc} +% TODO: trattare \func{memalign} +% TODO: trattare \func{valloc} +% TODO: trattare \func{posix\_memalign} @@ -949,6 +1022,7 @@ manipolare ed utilizzare le variabili di ambiente. \subsection{Il formato degli argomenti} \label{sec:proc_par_format} + In genere il passaggio degli argomenti al programma viene effettuato dalla shell, che si incarica di leggere la linea di comando e di effettuarne la scansione (il cosiddetto \textit{parsing}) per individuare le parole che la @@ -1073,17 +1147,6 @@ questo permette di identificare gli elementi che non sono opzioni, ma non effettua il riordinamento del vettore \param{argv}. -\subsection{Opzioni in formato esteso} -\label{sec:proc_opt_extended} - -Un'estensione di questo schema è costituita dalle cosiddette -\textit{long-options} espresse nella forma \cmd{-{}-option=parameter}, anche -la gestione di queste ultime è stata standardizzata attraverso l'uso di una -versione estesa di \func{getopt}. - -(NdA: questa parte verrà inserita in seguito). - - \subsection{Le variabili di ambiente} \label{sec:proc_environ} @@ -1282,8 +1345,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 @@ -1305,6 +1368,21 @@ alla cancellazione di tutto l'ambiente per costruirne una versione ``\textsl{sicura}'' da zero. +\subsection{Opzioni in formato esteso} +\label{sec:proc_opt_extended} + +Oltre alla modalità ordinaria di gestione delle opzioni trattata in +sez.~\ref{sec:proc_opt_handling} le \acr{glibc} forniscono una modalità +alternativa costituita dalle cosiddette \textit{long-options}, che consente di +esprimere le opzioni in una forma più descrittiva che nel caso più generale è +qualcosa del tipo di ``\texttt{-{}-option-name=parameter}''. + +(NdA: questa parte verrà inserita in seguito). + +% TODO opzioni in formato esteso + + + \section{Problematiche di programmazione generica} \label{sec:proc_gen_prog} @@ -1349,7 +1427,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 @@ -1362,10 +1440,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 @@ -1382,7 +1460,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 @@ -1407,9 +1485,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}. @@ -1465,11 +1543,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 @@ -1519,9 +1598,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 @@ -1567,11 +1646,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)} @@ -1583,10 +1662,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 @@ -1597,8 +1676,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. @@ -1615,10 +1694,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. @@ -1630,11 +1710,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}); @@ -1669,31 +1749,28 @@ 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 % LocalWords: SUCCESS FAILURE void atexit stream fclose unistd descriptor init % LocalWords: SIGCHLD wait function glibc SunOS arg argp execve fig high kb Mb % LocalWords: memory alpha swap table printf Unit MMU paging fault SIGSEGV BSS -% LocalWords: multitasking segmentation text segment NULL Block Started Symbol +% LocalWords: multitasking text segment NULL Block Started Symbol % LocalWords: heap stack calling convention size malloc calloc realloc nmemb % LocalWords: ENOMEM ptr uClib cfree error leak smartpointers hook Dmalloc brk % LocalWords: Gray Watson Electric Fence Bruce Perens sbrk longjmp SUSv BSD ap @@ -1707,4 +1784,10 @@ dichiarandole tutte come \direct{volatile}\footnote{la direttiva % LocalWords: clearenv libc value overwrite string reference result argument % 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 +% LocalWords: env return if while Di page cdecl +% LocalWords: environment + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "gapil" +%%% End: