%% process.tex
%%
-%% Copyright (C) 2000-2005 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}
\subsection{La funzione \func{main}}
\label{sec:proc_main}
-Quando un programma viene lanciato il kernel esegue un'opportuna routine di
+Quando un programma viene lanciato il kernel esegue un opportuno codice di
avvio, usando il programma \cmd{ld-linux.so}. Questo programma prima carica
-le librerie condivise che servono al programma, poi effettua il link 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 \textit{linkati} 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}.
+le librerie condivise che servono al programma, poi effettua il collegamento
+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}.
Il sistema fa partire qualunque programma chiamando la funzione \func{main};
sta al programmatore chiamare così la funzione principale del programma da cui
si suppone iniziare l'esecuzione; in ogni caso senza questa funzione lo stesso
-\textit{linker} darebbe luogo ad errori.
-
-Lo standard ISO C specifica che la funzione \func{main} può non avere
-argomenti o prendere due argomenti che rappresentano gli argomenti passati da
-linea di comando, in sostanza un prototipo che va sempre bene è il seguente:
+\textit{linker} (si chiama così il programma che effettua i collegamenti di
+cui sopra) darebbe luogo ad errori. Lo standard ISO C specifica che la
+funzione \func{main} può non avere argomenti o prendere due argomenti che
+rappresentano gli argomenti passati da linea di comando, in sostanza un
+prototipo che va sempre bene è il seguente:
\includecodesnip{listati/main_def.c}
-In realtà nei sistemi Unix esiste un'altro modo per definire la funzione
+In realtà nei sistemi Unix esiste un altro modo per definire la funzione
\func{main}, che prevede la presenza di un terzo argomento, \code{char
- *envp[]}, che fornisce l'\textsl{ambiente} (vedi sez.~\ref{sec:proc_environ})
-del programma; questa forma però non è prevista dallo standard POSIX.1 per cui
-se si vogliono scrivere programmi portabili è meglio evitarla.
+ *envp[]}, che fornisce (vedi sez.~\ref{sec:proc_environ})
+l'\textsl{ambiente} del programma; questa forma però non è prevista dallo
+standard POSIX.1 per cui se si vogliono scrivere programmi portabili è meglio
+evitarla.
\subsection{Come chiudere un programma}
direttamente la funzione \func{exit} (che viene comunque chiamata
automaticamente quando \func{main} ritorna). Una forma alternativa è quella
di chiamare direttamente la system call \func{\_exit}, che restituisce il
-controllo direttamente alla routine di conclusione dei processi del kernel.
+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
La funzione chiude tutti i file descriptor appartenenti al processo (si tenga
presente che questo non comporta il salvataggio dei dati bufferizzati degli
-stream), fa sì che ogni figlio del processo sia ereditato da \cmd{init} (vedi
+stream), fa sì che ogni figlio del processo sia adottato da \cmd{init} (vedi
cap.~\ref{cha:process_handling}), manda un segnale \const{SIGCHLD} al processo
padre (vedi sez.~\ref{sec:sig_job_control}) ed infine ritorna lo stato di
uscita specificato in \param{status} che può essere raccolto usando la
\begin{figure}[htb]
\centering
- \includegraphics[width=14cm]{img/proc_beginend}
+ \includegraphics[width=9cm]{img/proc_beginend}
\caption{Schema dell'avvio e della conclusione di un programma.}
\label{fig:proc_prog_start_stop}
\end{figure}
Si ricordi infine che un programma può anche essere interrotto dall'esterno
attraverso l'uso di un segnale (modalità di conclusione non mostrata in
-fig.~\ref{fig:proc_prog_start_stop}); torneremo su questo aspetto in
-cap.~\ref{cha:signals}.
+fig.~\ref{fig:proc_prog_start_stop}); tratteremo nei dettagli i segnali e la
+loro gestione nel capitolo \ref{cha:signals}.
\subsection{I concetti generali}
\label{sec:proc_mem_gen}
-Ci sono vari modi in cui i vari sistemi 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.}
+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 \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
indirizzi possibili sono utilizzabili, e quelli usabili non sono
necessariamente adiacenti).
-Per la gestione da parte del kernel la memoria virtuale viene divisa in pagine
-di dimensione fissa (che ad esempio sono di 4kb su macchine a 32 bit e 8kb
-sulle alpha, valori strettamente connessi all'hardware di gestione della
-memoria),\footnote{con le versioni più recenti del kernel è possibile anche
- utilizzare pagine di dimensioni maggiori, per sistemi con grandi
- quantitativi di memoria in cui l'uso di pagine troppo piccole comporta una
- perdita di prestazioni.} e ciascuna pagina della memoria virtuale è
-associata ad un supporto che può essere una pagina di memoria reale o ad un
-dispositivo di stoccaggio secondario (in genere lo spazio disco riservato alla
-swap, o i file che contengono il codice).
-
-Lo stesso pezzo di memoria reale (o di spazio disco) può fare da supporto a
-diverse pagine di memoria virtuale appartenenti a processi diversi (come
-accade in genere per le pagine che contengono il codice delle librerie
-condivise). Ad esempio il codice della funzione \func{printf} starà su una
-sola pagina di memoria reale che farà da supporto a tutte le pagine di memoria
-virtuale di tutti i processi che hanno detta funzione nel loro codice.
-
-La corrispondenza fra le pagine della \index{memoria~virtuale}memoria virtuale
-e quelle della memoria fisica della macchina viene gestita in maniera
-trasparente dall'hardware di gestione della memoria (la \textit{Memory
- Management Unit} del processore). 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} (o \textit{paging}), ed è uno dei
-compiti principali del kernel.
+Per la gestione da parte del kernel la memoria viene divisa in pagine di
+dimensione fissa,\footnote{inizialmente questi erano di 4kb sulle macchine a
+ 32 bit e di 8kb sulle alpha, con le versioni più recenti del kernel è
+ possibile anche utilizzare pagine di dimensioni maggiori (4Mb), per sistemi
+ con grandi quantitativi di memoria in cui l'uso di pagine troppo piccole
+ comporta una perdita di prestazioni.} e ciascuna pagina nello spazio di
+indirizzi virtuale è associata ad un supporto che può essere una pagina di
+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 è
+ una semplificazione brutale, il meccanismo è molto più complesso; una buona
+ trattazione di come Linux gestisce la memoria virtuale si trova su
+ \cite{LinVM}.}
+
+Una stessa pagina di memoria reale può fare da supporto a diverse pagine di
+memoria virtuale appartenenti a processi diversi (come accade in genere per le
+pagine che contengono il codice delle librerie condivise). Ad esempio il
+codice della funzione \func{printf} starà su una sola pagina di memoria reale
+che farà da supporto a tutte le pagine di memoria virtuale di tutti i processi
+che hanno detta funzione nel loro codice.
+
+La corrispondenza fra le pagine della \index{memoria~virtuale} memoria
+virtuale di un processo e quelle della memoria fisica della macchina viene
+gestita in maniera trasparente dal kernel.\footnote{in genere con l'ausilio
+ dell'hardware di gestione della memoria (la \textit{Memory Management Unit}
+ del processore), con i kernel della serie 2.6 è comunque diventato possibile
+ utilizzare Linux anche su architetture che non dispongono di una MMU.}
+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 \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
-reale, avviene quello che viene chiamato un \textit{page
- fault}\index{\textit{page~fault}}; l'hardware di gestione della memoria
-genera un'interruzione e passa il controllo al kernel il quale sospende il
-processo e si incarica di mettere in RAM la pagina richiesta (effettuando
-tutte le operazioni necessarie per reperire lo spazio necessario), per poi
-restituire il controllo al processo.
+reale, avviene quello che viene chiamato un \itindex{page~fault} \textit{page
+ fault}; la gestione della memoria genera un'interruzione e passa il
+controllo al kernel il quale sospende il processo e si incarica di mettere in
+RAM la pagina richiesta (effettuando tutte le operazioni necessarie per
+reperire lo spazio necessario), per poi restituire il controllo al processo.
Dal punto di vista di un processo questo meccanismo è completamente
trasparente, e tutto avviene come se tutte le pagine fossero sempre
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
+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}
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 \textit{page
- fault}\index{\textit{page~fault}} mandando un segnale \const{SIGSEGV} al
-processo, che normalmente ne causa la terminazione immediata.
+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{\textit{page~fault}} 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:
\begin{enumerate}
-\item Il segmento di testo o \textit{text segment}. Contiene il codice del
- programma, delle funzioni di librerie da esso utilizzate, e le costanti.
- Normalmente viene condiviso fra tutti i processi che eseguono lo stesso
- programma (e anche da processi che eseguono altri programmi nel caso delle
- librerie). Viene marcato in sola lettura per evitare sovrascritture
- accidentali (o maliziose) che ne modifichino le istruzioni.
+\item Il \index{segmento!testo} segmento di testo o \textit{text segment}.
+ Contiene il codice del programma, delle funzioni di librerie da esso
+ utilizzate, e le costanti. Normalmente viene condiviso fra tutti i processi
+ che eseguono lo stesso programma (e anche da processi che eseguono altri
+ programmi nel caso delle librerie). Viene marcato in sola lettura per
+ evitare sovrascritture accidentali (o maliziose) che ne modifichino le
+ istruzioni.
Viene allocato da \func{exec} all'avvio del programma e resta invariato
per tutto il tempo dell'esecuzione.
-\item Il segmento dei dati o \textit{data segment}. Contiene le variabili
- globali (cioè quelle definite al di fuori di tutte le funzioni che
- compongono il programma) e le variabili statiche (cioè quelle dichiarate con
- l'attributo \ctyp{static}). Di norma è diviso in due parti.
+\item Il \index{segmento!dati} segmento dei dati o \textit{data segment}.
+ Contiene le variabili globali (cioè quelle definite al di fuori di tutte le
+ funzioni che compongono il programma) e le variabili statiche (cioè quelle
+ dichiarate con l'attributo \ctyp{static}). Di norma è diviso in due parti.
La prima parte è il segmento dei dati inizializzati, che contiene le
variabili il cui valore è stato assegnato esplicitamente. Ad esempio
puntatori a \val{NULL}).\footnote{si ricordi che questo vale solo per le
variabili che vanno nel segmento dati, e non è affatto vero in generale.}
- Storicamente questo segmento viene chiamato BSS (da \textit{block started by
- symbol}). La sua dimensione è fissa.
+ Storicamente questa seconda parte del segmento dati viene chiamata BSS (da
+ \textit{Block Started by Symbol}). La sua dimensione è fissa.
-\item Lo \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 funzioni (vedi
- sez.~\ref{sec:proc_mem_alloc}), ma il suo limite inferiore (quello adiacente
- al segmento dati) ha una posizione fissa.
+\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
+ funzioni (vedi sez.~\ref{sec:proc_mem_alloc}), ma il suo limite inferiore
+ (quello adiacente al segmento dati) ha una posizione fissa.
-\item Il segmento di \textit{stack}, che contiene lo \textit{stack} del
- programma. Tutte le volte che si effettua una chiamata ad una funzione è
- qui che viene salvato l'indirizzo di ritorno e le informazioni dello stato
- del chiamante (tipo il contenuto di alcuni registri della CPU). Poi la
- funzione chiamata alloca qui lo spazio per le sue variabili locali: in
+\item Il segmento di \itindex{stack} \textit{stack}, che contiene quello che
+ viene chiamato \textit{stack} del programma. Tutte le volte che si effettua
+ una chiamata ad una funzione è qui che viene salvato l'indirizzo di ritorno
+ e le informazioni dello stato del chiamante (tipo il contenuto di alcuni
+ registri della CPU), poi la funzione chiamata alloca qui lo spazio per le
+ sue variabili locali. Tutti questi dati vengono \textit{impilati} (da questo
+ 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.}
-
- La dimensione di questo segmento aumenta seguendo la crescita dello stack
- del programma, ma non viene ridotta quando quest'ultimo si restringe.
+% TODO verificare le modalità di cambiamento della calling convention
+
+ La dimensione di questo segmento aumenta seguendo la crescita dello
+ \itindex{stack} \textit{stack} del programma, ma non viene ridotta quando
+ quest'ultimo si restringe.
\end{enumerate}
\begin{figure}[htb]
\label{fig:proc_mem_layout}
\end{figure}
-Una disposizione tipica di questi segmenti è riportata in
-fig.~\ref{fig:proc_mem_layout}. Usando il comando \cmd{size} su un programma se
-ne può stampare le dimensioni dei segmenti di testo e di dati (inizializzati e
-BSS); si tenga presente però che il BSS non è mai salvato sul file che
-contiene l'eseguibile, dato che viene sempre inizializzato a zero al
+Una disposizione tipica dei vari segmenti (testo, \itindex{heap}
+\textit{heap}, \itindex{stack} \textit{stack}, ecc.) è riportata in
+fig.~\ref{fig:proc_mem_layout}. Usando il comando \cmd{size} su un programma
+se ne può stampare le dimensioni dei segmenti di testo e di dati
+(inizializzati e BSS); si tenga presente però che il BSS non è mai salvato sul
+file che contiene l'eseguibile, dato che viene sempre inizializzato a zero al
caricamento del programma.
\subsection{Allocazione della memoria per i programmi C}
\label{sec:proc_mem_alloc}
-Il C supporta, a livello di linguaggio, soltanto due modalità di allocazione
-della memoria: l'\textsl{allocazione statica} e l'\textsl{allocazione
- automatica}.
+Il C supporta direttamente, come linguaggio di programmazione, soltanto due
+modalità di allocazione della memoria: l'\textsl{allocazione statica} e
+l'\textsl{allocazione automatica}.
L'\textsl{allocazione statica} è quella con cui sono memorizzate le variabili
globali e le variabili statiche, cioè le variabili il cui valore deve essere
mantenuto per tutta la durata del programma. Come accennato queste variabili
-vengono allocate nel segmento dei dati all'avvio del programma (come parte
-delle operazioni svolte da \func{exec}) e lo spazio da loro occupato non viene
-liberato fino alla sua conclusione.
+vengono allocate nel \index{segmento!dati} segmento dei dati all'avvio del
+programma (come parte delle operazioni svolte da \func{exec}) e lo spazio da
+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 stack quando viene eseguita la
-funzione e liberato quando si esce dalla medesima.
+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 della
- memoria}, che non è prevista direttamente all'interno del linguaggio C, ma
-che è necessaria quando il quantitativo di memoria che serve è determinabile
-solo durante il corso dell'esecuzione del programma.
+Esiste però un terzo tipo di allocazione, l'\textsl{allocazione dinamica}
+della memoria, che non è prevista direttamente all'interno del linguaggio C,
+ma che è necessaria quando il quantitativo di memoria che serve è
+determinabile solo durante il corso dell'esecuzione del programma.
Il C non consente di usare variabili allocate dinamicamente, non è possibile
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 heap). Le variabili il
-cui contenuto è allocato in questo modo non potranno essere usate direttamente
-come le altre, ma l'accesso sarà possibile solo in maniera indiretta,
-attraverso dei puntatori.
+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}
+\textit{stack}), ma l'accesso sarà possibile solo in maniera indiretta,
+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 size)}
- Alloca \param{size} byte nello heap. La memoria viene inizializzata a 0.
+\funcdecl{void *calloc(size\_t nmemb, size\_t size)}
+ 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
che, quando l'argomento è un puntatore nullo, \func{free} non esegue nessuna
operazione.
-Le \acr{glibc} hanno un'implementazione delle routine di allocazione che è
+Le \acr{glibc} hanno un'implementazione delle funzioni di allocazione che è
controllabile dall'utente attraverso alcune variabili di ambiente, in
particolare diventa possibile tracciare questo tipo di errori usando la
variabile di ambiente \val{MALLOC\_CHECK\_} che quando viene definita mette in
uso una versione meno efficiente delle funzioni suddette, che però è più
tollerante nei confronti di piccoli errori come quello di chiamate doppie a
\func{free}. In particolare:
-\begin{itemize}
-\item se la variabile è posta a zero gli errori vengono ignorati.
+\begin{itemize*}
+\item se la variabile è posta a zero gli errori vengono ignorati;
\item se è posta ad 1 viene stampato un avviso sullo \textit{standard error}
- (vedi sez.~\ref{sec:file_std_stream}).
+ (vedi sez.~\ref{sec:file_std_stream});
\item se è posta a 2 viene chiamata \func{abort}, che in genere causa
l'immediata conclusione del programma.
-\end{itemize}
+\end{itemize*}
Il problema più comune e più difficile da risolvere che si incontra con le
-routine di allocazione è quando non viene opportunamente liberata la memoria
-non più utilizzata, quello che in inglese viene chiamato \textit{memory
- leak}\index{\textit{memory~leak}}, cioè una \textsl{perdita di memoria}.
+funzioni di allocazione è quando non viene opportunamente liberata la 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}\index{\textit{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} è notevolmente
-ridimensionato attraverso l'uso accurato di appositi oggetti come gli
-\textit{smartpointers}. Questo però va a scapito delle prestazioni
-dell'applicazione in esecuzione.
-
-In altri linguaggi come il java e recentemente il C\# il problema non si pone
-nemmeno perché la gestione della memoria viene fatta totalmente in maniera
-automatica, ovvero il programmatore non deve minimamente preoccuparsi di
-liberare la memoria allocata precedentemente quando non serve più, poiché il
-framework gestisce automaticamente la cosiddetta \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 qualunque momento dall'infrastruttura.
-
-Anche questo va a scapito delle prestazioni dell'applicazione in esecuzione
-(inoltre le applicazioni sviluppate con tali linguaggi di solito non sono
-eseguibili compilati, come avviene invece per il C ed il C++, ed è necessaria
-la presenza di una infrastruttura per la loro interpretazione e pertanto hanno
-di per sé delle prestazioni più scadenti rispetto alle stesse applicazioni
-compilate direttamente). Questo comporta però il problema della non
-predicibilità del momento in cui viene deallocata la memoria precedentemente
-allocata da un oggetto.
+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
+% nemmeno perché la gestione della memoria viene fatta totalmente in maniera
+% 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,
+% 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
+% qualunque momento dall'infrastruttura.
+
+% Anche questo va a scapito delle prestazioni dell'applicazione in esecuzione
+% (inoltre le applicazioni sviluppate con tali linguaggi di solito non sono
+% eseguibili compilati, come avviene invece per il C ed il C++, ed è necessaria
+% la presenza di una infrastruttura per la loro interpretazione e pertanto hanno
+% di per sé delle prestazioni più scadenti rispetto alle stesse applicazioni
+% compilate direttamente). Questo comporta però il problema della non
+% predicibilità del momento in cui viene deallocata la memoria precedentemente
+% allocata da un oggetto.
Per limitare l'impatto di questi problemi, e semplificare la ricerca di
-eventuali errori, l'implementazione delle routine di allocazione delle
+eventuali errori, l'implementazione delle funzioni di allocazione delle
\acr{glibc} mette a disposizione una serie di funzionalità che permettono di
-tracciare le allocazioni e le disallocazione, e definisce anche una serie di
+tracciare le allocazioni e le disallocazioni, e definisce anche una serie di
possibili \textit{hook} (\textsl{ganci}) che permettono di sostituire alle
funzioni di libreria una propria versione (che può essere più o meno
specializzata per il debugging). Esistono varie librerie che forniscono dei
-sostituti opportuni delle routine di allocazione in grado, senza neanche
+sostituti opportuni delle funzioni di allocazione in grado, senza neanche
ricompilare il programma,\footnote{esempi sono \textit{Dmalloc}
- \href{http://dmalloc.com/}{http://dmalloc.com/} di Gray Watson ed
+ \href{http://dmalloc.com/}{\textsf{http://dmalloc.com/}} di Gray Watson ed
\textit{Electric Fence} di Bruce Perens.} di eseguire diagnostiche anche
molto complesse riguardo l'allocazione della memoria.
-
-\subsection{La funzione \func{alloca}}
-\label{sec:proc_mem_alloca}
-
Una possibile alternativa all'uso di \func{malloc}, che non soffre dei
-problemi di \textit{memory leak}\index{\textit{memory~leak}} descritti in
+problemi di \itindex{memory~leak} \textit{memory leak} descritti in
precedenza, è la funzione \funcd{alloca}, che invece di allocare la memoria
-nello heap usa il segmento di stack della funzione corrente. La sintassi è
-identica a quella di \func{malloc}, il suo prototipo è:
+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.
\end{prototype}
La funzione alloca la quantità di memoria (non inizializzata) richiesta
-dall'argomento \param{size} nel segmento di stack della funzione chiamante.
-Con questa funzione non è più necessario liberare la memoria allocata (e
-quindi non esiste un analogo della \func{free}) in quanto essa viene
-rilasciata automaticamente al ritorno della funzione.
+dall'argomento \param{size} nel segmento di \itindex{stack} \textit{stack}
+della funzione chiamante. Con questa funzione non è più necessario liberare
+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 memory leak\index{\textit{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
%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
cui torneremo in sez.~\ref{sec:proc_auto_var}.
-\subsection{Le funzioni \func{brk} e \func{sbrk}}
-\label{sec:proc_mem_sbrk}
-
-Queste due funzioni 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
-routine di allocazione della memoria viste in sez.~\ref{sec:proc_mem_malloc}.
+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.
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.
\end{prototype}
La funzione è un'interfaccia diretta all'omonima system call ed imposta
-l'indirizzo finale del 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.
-
-La seconda funzione per la manipolazione delle dimensioni 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 è:
+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
+\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 è:
\begin{prototype}{unistd.h}{void *sbrk(ptrdiff\_t increment)}
Incrementa la dimensione dello spazio dati.
\noindent la funzione incrementa la dimensione lo spazio dati di un programma
di \param{increment} byte, restituendo il nuovo indirizzo finale dello stesso.
Un valore nullo permette di ottenere l'attuale posizione della fine del
-segmento dati.
+\index{segmento!dati} segmento dati.
Queste funzioni sono state deliberatamente escluse dallo standard POSIX.1 e
per i programmi normali è sempre opportuno usare le funzioni di allocazione
standard descritte in precedenza, che sono costruite su di esse.
-% \subsection{La personalizzazione delle funzioni di allocazione}
-% \label{sec:proc_mem_malloc_custom}
-
-
\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
\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
crittografia richiedono il blocco di alcune pagine di memoria.
\end{itemize}
-\index{\textit{memory~locking}|(}
-Il meccanismo che previene la paginazione\index{paginazione} di parte della
+\itindbeg{memory~locking}
+
+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
+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
+\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.
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 \textit{memory lock} non sono
-ereditati dai processi figli.\footnote{ma siccome Linux usa il \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.}
+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
+ 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
+vengono automaticamente rimossi se si pone in esecuzione un altro programma
+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 solo un processo con i privilegi di
-amministratore (vedremo in sez.~\ref{sec:proc_perms} cosa significa) ha la
-capacità di bloccare una pagina. Ogni processo può però sbloccare le pagine
-relative alla propria memoria.
+tutti gli altri processi, per cui fino al kernel 2.6.9 solo un processo con i
+privilegi opportuni (la \itindex{capabilities} \textit{capability}
+\const{CAP\_IPC\_LOCK}, vedi sez.~\ref{sec:proc_capabilities}) aveva la
+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
standard POSIX.1 richiede che sia definita in \file{unistd.h} la macro
\macro{\_POSIX\_MEMLOCK\_RANGE} per indicare la capacità di eseguire il
-\textit{memory locking} e la costante \const{PAGESIZE} in \file{limits.h} per
-indicare la dimensione di una pagina in byte.
-
-Le funzioni per bloccare e sbloccare la paginazione\index{paginazione} di
+\textit{memory locking}. Inoltre in alcuni sistemi è definita la costante
+\const{PAGE\_SIZE} in \file{limits.h} per indicare la dimensione di una pagina
+in byte.\footnote{con Linux questo non avviene e si deve ricorrere alla
+ funzione \func{getpagesize}, vedi sez.~\ref{sec:sys_memory_res}.}
+
+
+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
+mentre un processo privilegiato non ha limiti sulla quantità di memoria che
+può bloccare, un processo normale è soggetto al limite della risorsa
+\const{RLIMIT\_MEMLOCK} (vedi sez.~\ref{sec:sys_resource_limit}). In generale
+poi ogni processo può sbloccare le pagine relative alla propria memoria, se
+però diversi processi bloccano la stessa pagina questa resterà bloccata
+fintanto che ci sarà almeno un processo che la blocca.
+
+Le funzioni per bloccare e sbloccare la \index{paginazione} paginazione di
singole sezioni di memoria sono \funcd{mlock} e \funcd{munlock}; i loro
prototipi sono:
\begin{functions}
\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
corrispondono allo spazio di indirizzi del processo o si è ecceduto
il numero massimo consentito di pagine bloccate.
\item[\errcode{EINVAL}] \param{len} non è un valore positivo.
+ \item[\errcode{EPERM}] con un kernel successivo al 2.6.9 il processo non è
+ privilegiato e si un limite nullo per \const{RLIMIT\_MEMLOCK}.
\end{errlist}
e, per \func{mlock}, anche \errval{EPERM} quando il processo non ha i
privilegi richiesti per l'operazione.}
\end{functions}
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.
+mantenute in RAM per tutta la durata del blocco.\footnote{con altri kernel si
+ può ottenere un errore di \errcode{EINVAL} se \param{addr} non è un multiplo
+ 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}
\funcdecl{int munlockall(void)}
Sblocca la paginazione per lo spazio di indirizzi del processo corrente.
- \bodydesc{Codici di ritorno ed errori sono gli stessi di \func{mlock}
- e \func{munlock}.}
+ \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}
+\const{CAP\_IPC\_LOCK} genera un errore di \errcode{EPERM}.}
\end{functions}
L'argomento \param{flags} di \func{mlockall} permette di controllarne il
\end{basedescript}
Con \func{mlockall} si possono bloccare tutte le pagine mappate nello spazio
-di indirizzi del processo, sia che comprendano il segmento di testo, di dati,
-lo stack, lo 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 sezione critica
-deve provvedere a riservare memoria sufficiente prima dell'ingresso, per
-scongiurare l'occorrenza di un eventuale \textit{page
- fault}\index{\textit{page~fault}} causato dal meccanismo di \textit{copy on
- write}\index{\textit{copy~on~write}}. Infatti se nella sezione critica si
-va ad utilizzare memoria che non è ancora stata riportata in RAM si potrebbe
-avere un page fault durante l'esecuzione della stessa, con conseguente
+di indirizzi del processo, sia che comprendano il \index{segmento!dati}
+\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
+\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 stack, dopo di che, per essere sicuri
-che esse siano state effettivamente portate in memoria, ci si scrive sopra.
-\index{memoria~virtuale|)}
-\index{\textit{memory~locking}|)}
+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 documentare \func{madvise}
+% TODO documentare \func{mincore}
+
+
+\index{memoria~virtuale|)}
+
+
+% \subsection{Gestione avanzata dell'allocazione della memoria}
+% \label{sec:proc_mem_malloc_custom}
+% TODO: trattare le funzionalità avanzate di \func{malloc}
\subsection{Il formato degli argomenti}
\label{sec:proc_par_format}
-In genere 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 compongono,
-ciascuna delle quali viene considerata un argomento. Di norma per individuare
-le parole viene usato come carattere di separazione lo spazio o il tabulatore,
-ma il comportamento è modificabile attraverso l'impostazione della variabile
-di ambiente \cmd{IFS}.
+
+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
+compongono, ciascuna delle quali viene considerata un argomento. Di norma per
+individuare le parole viene usato come carattere di separazione lo spazio o il
+tabulatore, ma il comportamento è modificabile attraverso l'impostazione della
+variabile di ambiente \cmd{IFS}.
\begin{figure}[htb]
\centering
- \includegraphics[width=11cm]{img/argv_argc}
+ \includegraphics[width=13cm]{img/argv_argc}
\caption{Esempio dei valori di \param{argv} e \param{argc} generati nella
scansione di una riga di comando.}
\label{fig:proc_argv_argc}
In generale un programma Unix riceve da linea di comando sia gli argomenti che
le opzioni, queste ultime sono standardizzate per essere riconosciute come
tali: un elemento di \param{argv} che inizia con il carattere \texttt{'-'} e
-che non sia un singolo \texttt{'-'} o un \texttt{'--'} viene considerato
+che non sia un singolo \texttt{'-'} o un \texttt{'-{}-'} viene considerato
un'opzione. In genere le opzioni sono costituite da una lettera singola
(preceduta dal carattere \cmd{'-'}) e possono avere o no un parametro
associato; un comando tipico può essere quello mostrato in
funzione all'interno di un ciclo, fintanto che essa non ritorna il valore -1
che indica che non ci sono più opzioni. Nel caso si incontri un'opzione non
dichiarata in \param{optstring} viene ritornato il carattere \texttt{'?'}
-mentre se un opzione che lo richiede non è seguita da un parametro viene
+mentre se un'opzione che lo richiede non è seguita da un parametro viene
ritornato il carattere \texttt{':'}, infine se viene incontrato il valore
-\texttt{'--'} la scansione viene considerata conclusa, anche se vi sono altri
+\texttt{'-{}-'} la scansione viene considerata conclusa, anche se vi sono altri
elementi di \param{argv} che cominciano con il carattere \texttt{'-'}.
\begin{figure}[htb]
\subsection{Opzioni in formato esteso}
\label{sec:proc_opt_extended}
-Un'estensione di questo schema è costituito dalle cosiddette
+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).
-
+% TODO opzioni in formato esteso
\subsection{Le variabili di ambiente}
\label{sec:proc_environ}
fig.~\ref{fig:proc_envirno_list}.
\begin{figure}[htb]
\centering
- \includegraphics[width=11cm]{img/environ_var}
+ \includegraphics[width=13cm]{img/environ_var}
\caption{Esempio di lista delle variabili di ambiente.}
\label{fig:proc_envirno_list}
\end{figure}
La shell ad esempio ne usa molte per il suo funzionamento (come \texttt{PATH}
per la ricerca dei comandi, o \texttt{IFS} per la scansione degli argomenti),
-e alcune di esse (come \texttt{HOME}, \texttt{USER}, etc.) sono definite al
+e alcune di esse (come \texttt{HOME}, \texttt{USER}, ecc.) sono definite al
login (per i dettagli si veda sez.~\ref{sec:sess_login}). In genere è cura
dell'amministratore definire le opportune variabili di ambiente in uno script
di avvio. Alcune servono poi come riferimento generico per molti programmi
Gli standard POSIX e XPG3 definiscono alcune di queste variabili (le più
comuni), come riportato in tab.~\ref{tab:proc_env_var}. GNU/Linux le supporta
tutte e ne definisce anche altre: per una lista più completa si può
-controllare \cmd{man environ}.
+controllare \cmd{man 5 environ}.
\begin{table}[htb]
\centering
variabile esista già, sovrascrivendola se diverso da zero, lasciandola
immutata se uguale a zero.
-La seconda funzione prende come argomento una stringa analoga quella
+La seconda funzione prende come argomento una stringa analoga a quella
restituita da \func{getenv}, e sempre nella forma \code{NOME=valore}. Se la
variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
invece esiste il suo valore sarà impostato a quello specificato da
corrente sarà deallocata solo se anch'essa è risultante da un'allocazione
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 stack, (vedi
-fig.~\ref{fig:proc_mem_layout}) e non nello heap e non può essere deallocato.
-Inoltre la memoria associata alle variabili di ambiente eliminate non viene
-liberata.
+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} \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
completamente tutto l'ambiente; il suo prototipo è:
Il passaggio di una variabile \textit{by value} significa che in realtà quello
che viene passato alla subroutine è una copia del valore attuale di quella
variabile, copia che la subroutine potrà modificare a piacere, senza che il
-valore originale nella routine chiamante venga toccato. In questo modo non
+valore originale nella funzione chiamante venga toccato. In questo modo non
occorre preoccuparsi di eventuali effetti delle operazioni della subroutine
sulla variabile passata come argomento.
subroutine si usano dei puntatori (ad esempio per scrivere in un buffer) in
realtà si va a modificare la zona di memoria a cui essi puntano, per cui anche
se i puntatori sono copie, i dati a cui essi puntano sono sempre gli stessi, e
-le eventuali modifiche avranno effetto e saranno visibili anche nella routine
+le eventuali modifiche avranno effetto e saranno visibili anche nella funzione
chiamante.
Nella maggior parte delle funzioni di libreria e delle system call i puntatori
vengono usati per scambiare dati (attraverso buffer o strutture) e le
variabili semplici vengono usate per specificare argomenti; in genere le
-informazioni a riguardo dei risultati vengono passate alla routine chiamante
+informazioni a riguardo dei risultati vengono passate alla funzione chiamante
attraverso il valore di ritorno. È buona norma seguire questa pratica anche
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
-\index{\textit{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 permettere al kernel di restituire
-informazioni sulle dimensioni delle strutture degli indirizzi utilizzate,
-viene usato questo meccanismo.
+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
+permettere al kernel di restituire informazioni sulle dimensioni delle
+strutture degli indirizzi utilizzate, viene usato questo meccanismo.
\subsection{Il passaggio di un numero variabile di argomenti}
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,
-attraverso l'uso della \textit{ellipsis} \code{...} nella dichiarazione della
-funzione; ma non provvede a livello di linguaggio alcun meccanismo con cui
-dette funzioni possono accedere ai loro argomenti.
-
-L'accesso viene invece realizzato dalle librerie standard che provvedono gli
-strumenti adeguati. L'uso delle \textit{variadic function} prevede tre punti:
-\begin{itemize*}
+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}.
+
+Lo standard però non provvede a livello di linguaggio alcun meccanismo con cui
+dette funzioni possono accedere ai loro argomenti. L'accesso viene pertanto
+realizzato a livello delle librerie standard del C che provvedono gli
+strumenti adeguati. L'uso di una \textit{variadic function} prevede quindi
+tre punti:
+\begin{itemize}
\item \textsl{Dichiarare} la funzione come \textit{variadic} usando un
prototipo che contenga una \textit{ellipsis}.
-\item \textsl{Definire} la funzione come \textit{variadic} usando lo stesso
+\item \textsl{Definire} la funzione come \textit{variadic} usando la stessa
\textit{ellipsis}, ed utilizzare le apposite macro che consentono la
gestione di un numero variabile di argomenti.
-\item \textsl{Chiamare} la funzione specificando prima gli argomenti fissi, e
- a seguire gli addizionali.
-\end{itemize*}
+\item \textsl{Invocare} la funzione specificando prima gli argomenti fissi, ed
+ 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 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*}
+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}.
\item Accedere ai vari argomenti opzionali con chiamate successive alla macro
il secondo e così via.
\item Dichiarare la conclusione dell'estrazione degli argomenti invocando la
macro \macro{va\_end}.
-\end{enumerate*}
-in generale è perfettamente legittimo richiedere meno argomenti di quelli che
+\end{enumerate}
+In generale è perfettamente legittimo richiedere meno argomenti di quelli che
potrebbero essere stati effettivamente forniti, e nella esecuzione delle
\macro{va\_arg} ci si può fermare in qualunque momento ed i restanti argomenti
saranno ignorati; se invece si richiedono più argomenti di quelli forniti si
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
-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 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
\index{salto~non-locale|(}
-Il C però non consente di effettuare un salto ad
-una etichetta definita in un'altra funzione, per cui se l'errore avviene in
-una funzione, e la sua gestione ordinaria è in un'altra, occorre usare quello
-che viene chiamato un \textsl{salto non-locale}. Il caso classico in cui si
-ha questa necessità, citato sia da \cite{APUE} che da \cite{glibc}, è quello
-di un programma nel cui corpo principale vengono letti dei dati in ingresso
-sui quali viene eseguita, tramite una serie di funzioni di analisi, una
-scansione dei contenuti da si ottengono le indicazioni per l'esecuzione delle
-opportune operazioni.
+Il C però non consente di effettuare un salto ad una etichetta definita in
+un'altra funzione, per cui se l'errore avviene in una funzione, e la sua
+gestione ordinaria è in un'altra, occorre usare quello che viene chiamato un
+\textsl{salto non-locale}. Il caso classico in cui si ha questa necessità,
+citato sia in \cite{APUE} che in \cite{glibc}, è quello di un programma nel
+cui corpo principale vengono letti dei dati in ingresso sui quali viene
+eseguita, tramite una serie di funzioni di analisi, una scansione dei
+contenuti, da cui si ottengono le indicazioni per l'esecuzione di opportune
+operazioni.
Dato che l'analisi può risultare molto complessa, ed opportunamente suddivisa
in fasi diverse, la rilevazione di un errore nei dati in ingresso può accadere
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 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 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 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
-stack effettuando il salto non-locale. Si tenga conto che il contesto salvato
-in \param{env} viene invalidato se la routine 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.
+\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.
Come accennato per effettuare un salto non-locale ad
un punto precedentemente stabilito con \func{setjmp} si usa la funzione
\bodydesc{La funzione non ritorna.}
\end{functions}
-La funzione ripristina il contesto dello 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.
+La funzione ripristina il contesto dello \itindex{stack} \textit{stack}
+salvato da una chiamata a \func{setjmp} nell'argomento \param{env}. Dopo
+l'esecuzione della funzione il programma prosegue nel codice successivo al
+ritorno della \func{setjmp} con cui si era salvato \param{env}, che restituirà
+il valore
+\param{val} invece di zero. Il valore di \param{val} specificato nella
+chiamata deve essere diverso da zero, se si è specificato 0 sarà comunque
+restituito 1 al suo posto.
In sostanza un \func{longjmp} è analogo ad un \code{return}, solo che invece
di ritornare alla riga successiva della funzione chiamante, il programma
annidate.
L'implementazione di queste funzioni comporta alcune restrizioni dato che esse
-interagiscono direttamente con la gestione dello 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}).
+ o di iterazione (come \code{if}, \code{switch} o \code{while});
\item come operando per un operatore di uguaglianza o confronto in una
espressione di controllo di un comando condizionale, di selezione o di
- iterazione.
+ iterazione;
\item come operando per l'operatore di negazione (\code{!}) in una espressione
- di controllo di un comando condizionale, di selezione o di iterazione.
+ di controllo di un comando condizionale, di selezione o di iterazione;
\item come espressione a sé stante.
\end{itemize}
In generale, dato che l'unica differenza fra la chiamata diretta e quella
-ottenuta da un \func{longjmp}, è il valore di ritorno di \func{setjmp}, essa è
-usualmente chiamata all'interno di un comando \code{if}.
+ottenuta da un \func{longjmp} è costituita dal valore di ritorno di
+\func{setjmp}, essa è usualmente chiamata all'interno di un comando \code{if}.
Uno dei punti critici dei salti non-locali è quello del valore delle
variabili, ed in particolare quello delle variabili automatiche della funzione
Quello che succede infatti è che i valori delle variabili che sono tenute in
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 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).}.
+chiamata ad un'altra funzione vengono salvati nel contesto nello
+\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).}
\index{salto~non-locale|)}
+
+
+% 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: 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
+% LocalWords: ptrdiff increment locking lock copy write capabilities IPC mlock
+% LocalWords: capability MEMLOCK limits getpagesize RLIMIT munlock sys const
+% LocalWords: addr len EINVAL EPERM mlockall munlockall flags l'OR CURRENT IFS
+% LocalWords: argc argv parsing questofile txt getopt optstring switch optarg
+% LocalWords: optind opterr optopt ForkTest POSIXLY CORRECT long options NdA
+% LocalWords: option parameter list environ PATH HOME XPG tab LOGNAME LANG PWD
+% LocalWords: TERM PAGER TMPDIR getenv name SVr setenv unsetenv putenv opz gcc
+% 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 sottoprocesso Di
+
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "gapil"
projects / gapil.git / blobdiff