Un'esigenza comune che si incontra nella programmazione è quella di dover
effettuare una serie di operazioni di pulizia (ad esempio salvare dei dati,
-ripristinare dei settaggi, eliminare dei file temporanei, ecc.) prima della
-conclusione di un programma. In genere queste operazioni vengono fatte in
-un'apposita sezione del programma, ma quando si realizza una libreria diventa
-antipatico dover richiedere una chiamata esplicita ad una funzione di pulizia
-al programmatore che la utilizza.
+ripristinare delle impostazioni, eliminare dei file temporanei, ecc.) prima
+della conclusione di un programma. In genere queste operazioni vengono fatte
+in un'apposita sezione del programma, ma quando si realizza una libreria
+diventa antipatico dover richiedere una chiamata esplicita ad una funzione di
+pulizia al programmatore che la utilizza.
È invece molto meno soggetto ad errori, e completamente trasparente
all'utente, avere la possibilità di effettuare automaticamente la chiamata ad
programma.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- fallimento, \var{errno} non viene settata.}
+ fallimento, \var{errno} non viene modificata.}
\end{prototype}
\noindent la funzione richiede come argomento l'indirizzo della opportuna
funzione di pulizia da chiamare all'uscita, che non deve prendere argomenti e
rispetto a quello di registrazione.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- fallimento, \var{errno} non viene settata.}
+ fallimento, \var{errno} non viene modificata.}
\end{prototype}
In questo caso la funzione da chiamare prende due parametri, il primo dei
\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{page
- fault}; l'hardware di gestione della memoria genera un'interruzione e passa
+reale, avviene quello che viene chiamato un
+\textit{page fault}\index{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.
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}
+virtuale, il kernel risponde al relativo \textit{page fault}\index{page fault}
mandando un segnale \macro{SIGSEGV} al processo, che normalmente ne causa la
terminazione immediata.
-È pertanto importante capire come viene strutturata 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:
+È pertanto importante capire come viene strutturata \textsl{la memoria
+ virtuale}\index{page fault} 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
\begin{figure}[htb]
\centering
\includegraphics[width=5cm]{img/memory_layout}
- \caption{Disposizione tipica dei segmenti di memoria di un processo}
+ \caption{Disposizione tipica dei segmenti di memoria di un processo.}
\label{fig:proc_mem_layout}
\end{figure}
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
- \var{errno} viene settata a \macro{ENOMEM}.
+ \var{errno} assumerà il valore \macro{ENOMEM}.
\funcdecl{void *malloc(size\_t size)}
Alloca \var{size} byte nello heap. La memoria non viene inizializzata.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
- \var{errno} viene settata a \macro{ENOMEM}.
+ \var{errno} assumerà il valore \macro{ENOMEM}.
\funcdecl{void *realloc(void *ptr, size\_t size)}
Cambia la dimensione del blocco allocato all'indirizzo \var{ptr}
portandola a \var{size}.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
- \var{errno} viene settata a \macro{ENOMEM}.
+ \var{errno} assumerà il valore \macro{ENOMEM}.
\funcdecl{void free(void *ptr)}
Disalloca lo spazio di memoria puntato da \var{ptr}.
\textit{memory leak}.
Per ovviare a questi problemi l'implementazione delle routine di allocazione
-delle \acr{glibc} mette a disposizione una serie di funzionalità (su cui
-torneremo in \secref{sec:xxx_advanced}) che permettono di tracciare le
-allocazioni e le disallocazione, 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).
+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 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).
\subsection{La funzione \func{alloca}}
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
- \var{errno} viene settata a \macro{ENOMEM}.
+ \var{errno} assumerà il valore \macro{ENOMEM}.
\end{prototype}
\noindent ma in questo caso non è più necessario liberare la memoria (e quindi
non esiste un analogo della \func{free}) in quanto essa viene rilasciata
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 man page non c'è
+% Questo è riportato solo dal manuale delle glibc, nelle pagine di manuale non c'è
% traccia di tutto ciò
%
%Inoltre se si
\var{end\_data\_segment}.
La funzione restituisce 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} viene settata a \macro{ENOMEM}.
+ fallimento, nel qual caso \var{errno} assumerà il valore \macro{ENOMEM}.
\funcdecl{void *sbrk(ptrdiff\_t increment)} Incrementa lo spazio dati di un
programma di \var{increment}. Un valore zero restituisce l'attuale posizione
La funzione restituisce il puntatore all'inizio della nuova zona di memoria
allocata in caso di successo e \macro{NULL} in caso di fallimento, nel qual
- caso \macro{errno} viene settata a \macro{ENOMEM}.
+ caso \macro{errno} assumerà il valore \macro{ENOMEM}.
\end{functions}
\noindent in genere si usa \func{sbrk} con un valore zero per ottenere
l'attuale posizione della fine del segmento dati.
% \label{sec:proc_mem_malloc_custom}
-\subsection{Il controllo della memoria virtuale}
+\subsection{Il controllo della memoria virtuale\index{memoria virtuale}}
\label{sec:proc_mem_lock}
-Come spiegato in \secref{sec:proc_mem_gen} il kernel gestisce la memoria 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.
+Come spiegato in \secref{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
tutti i suoi \textit{memory lock}.
I \textit{memory lock} non sono ereditati dai processi figli.\footnote{ma
- siccome Linux usa il \textit{copy on write} (vedi \secref{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 memory lock del padre.} Siccome la presenza di un
-\textit{memory lock} riduce la memoria disponibile al sistema, con un impatto
-su tutti gli altri processi, solo l'amministratore ha la capacità di bloccare
-una pagina. Ogni processo può però sbloccare le pagine relative alla propria
-memoria.
+ siccome Linux usa il \textit{copy on write}\index{copy on write} (vedi
+ \secref{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 memory lock del padre.} Siccome la
+presenza di un \textit{memory lock} riduce la memoria disponibile al sistema,
+con un impatto su tutti gli altri processi, solo l'amministratore ha la
+capacità di bloccare una pagina. Ogni processo può però sbloccare le pagine
+relative alla propria memoria.
Il sistema pone dei limiti all'ammontare di memoria di un processo che può
essere bloccata e al totale di memoria fisica che può dedicare a questo, lo
\bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 in
- caso di errore, nel qual caso \var{errno} è settata ad uno dei
+ caso di errore, nel qual caso \var{errno} assumerà uno dei
valori seguenti:
\begin{errlist}
\item[\macro{ENOMEM}] alcuni indirizzi dell'intervallo specificato non
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 in partenza un eventuale page fault causato dal meccanismo di
-\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 rallentamento
-(probabilmente inaccettabile) dei tempi di esecuzione.
+scongiurare in partenza un eventuale page fault\index{page fault} causato dal
+meccanismo di \textit{copy on write}\index{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 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
(il cosiddetto \textit{parsing}) per individuare le parole che la compongono,
ciascuna delle quali viene considerata un parametro. Di norma per individuare
le parole viene usato come carattere di separazione lo spazio o il tabulatore,
-ma il comportamento è modificabile attraverso il settaggio della variabile di
-ambiente \cmd{IFS}.
+ma il comportamento è modificabile attraverso l'impostazione della variabile
+di ambiente \cmd{IFS}.
\begin{figure}[htb]
\centering
così che alla fine della scansione gli elementi che non sono opzioni sono
spostati in coda al vettore. Oltre a questa esistono altre due modalità di
gestire gli elementi di \var{argv}; se \var{optstring} inizia con il carattere
-\texttt{'+'} (o è settata la variabile di ambiente \macro{POSIXLY\_CORRECT})
+\texttt{'+'} (o è impostata la variabile di ambiente \macro{POSIXLY\_CORRECT})
la scansione viene fermata non appena si incontra un elemento che non è
un'opzione. L'ultima modalità, usata quando un programma può gestire la
mescolanza fra opzioni e argomenti, ma se li aspetta in un ordine definito, si
\hline
\hline
\macro{USER} & $\bullet$ & $\bullet$ & $\bullet$ & Nome utente\\
- \macro{LOGNAME} & $\bullet$ & $\bullet$ & $\bullet$ & Nome utente\\
+ \macro{LOGNAME} & $\bullet$ & $\bullet$ & $\bullet$ & Nome di login\\
\macro{HOME} & $\bullet$ & $\bullet$ & $\bullet$ &
Directory base dell'utente\\
\macro{LANG} & $\bullet$ & $\bullet$ & $\bullet$ & Localizzazione\\
\macro{TERM} & $\bullet$ & $\bullet$ & $\bullet$ & Tipo di terminale\\
\macro{PAGER} & $\bullet$ & $\bullet$ & $\bullet$ & Programma per vedere i
testi\\
- \macro{EDITOR} & $\bullet$ & $\bullet$ & $\bullet$ & Editor di default\\
- \macro{BROWSER} & $\bullet$ & $\bullet$ & $\bullet$ & Browser di default\\
+ \macro{EDITOR} & $\bullet$ & $\bullet$ & $\bullet$ & Editor preferito\\
+ \macro{BROWSER} & $\bullet$ & $\bullet$ & $\bullet$ & Browser preferito\\
\hline
\end{tabular}
\caption{Variabili di ambiente più comuni definite da vari standard.}
Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
C, nell'evoluzione dei sistemi Unix ne sono state proposte altre, da
-utilizzare per settare e per cancellare le variabili di ambiente. Uno schema
+utilizzare per impostare e per cancellare le variabili di ambiente. Uno schema
delle funzioni previste nei vari standard e disponibili in Linux è riportato
in \ntab.
\headdecl{stdlib.h}
\funcdecl{int setenv(const char *name, const char *value, int overwrite)}
- Setta la variabile di ambiente \param{name} al valore \param{value}.
+ Imposta la variabile di ambiente \param{name} al valore \param{value}.
\funcdecl{int putenv(char *string)} Aggiunge la stringa \param{string}
all'ambiente.
La seconda funzione prende come parametro una stringa analoga quella
restituita da \func{getenv}, e sempre nella forma \var{NOME=valore}. Se la
variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
-invece esiste il suo valore sarà settato a quello specificato da
+invece esiste il suo valore sarà impostato a quello specificato da
\param{string}. Si tenga presente che, seguendo lo standard SUSv2, le
\acr{glibc} successive alla versione 2.1.2 aggiungono\footnote{il
comportamento è lo stesso delle vecchie \acr{libc4} e \acr{libc5}; nelle
projects / gapil.git / blobdiff