Correzioni ortografiche
authorSimone Piccardi <piccardi@gnulinux.it>
Wed, 8 Aug 2001 11:29:40 +0000 (11:29 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Wed, 8 Aug 2001 11:29:40 +0000 (11:29 +0000)
process.tex

index e663713..dae486f 100644 (file)
@@ -50,7 +50,7 @@ sta al programmatore chiamare cos
 si suppone iniziale l'esecuzione; in ogni caso senza questa funzione lo stesso
 linker darebbe luogo ad errori.
 
-Lo standard ISO C specifica che la funzione \texttt{main} può o non avere
+Lo standard ISO C specifica che la funzione \texttt{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:
 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
@@ -123,7 +123,7 @@ processo (vedi \secref{sec:prochand_xxx}).
 \label{sec:proc_exit}
 
 Come accennato funzioni per l'uscita ``normale'' da un programma sono due, la
-prima è la funzione \texttt{exit} che è definita dallo standard ANSI C, il
+prima è la funzione \texttt{exit} che è definita dallo standard ANSI C; il
 prototipo della funzione è il seguente:
 \begin{prototype}{stdlib.h}{void exit(int status)}
   Causa la conclusione ordinaria del programma restituendo il valore
@@ -190,7 +190,7 @@ funzione che si pu
 La funzione richiede come argomento l'indirizzo della opportuna da chiamare
 all'uscita che non deve prendere argomenti e non deve ritornare niente. Una
 estensione di \texttt{atexit} è la funzione \texttt{on\_exit} (che la glibc
-include per compatibilità con SunOS e che non è detta sia definita su altri
+include per compatibilità con SunOS e che non è detto sia definita su altri
 sistemi), il cui prototipo è:
 \begin{prototype}{stdlib.h}
 {void on\_exit(void (*function)(int status, void *arg), void *arg)}
@@ -207,10 +207,10 @@ quali sar
 \texttt{exit} ed il secondo al puntatore generico specificato come secondo
 argomento nella chiamata di \texttt{on\_exit}.
 
-Tutte le funzioni registrate vengono chiamate in ordine inverso rispetto a
-quello di registrazione (ed una stessa funzione registrata più volte sarà
-chiamata più volte); poi vengono chiusi tutti gli stream aperti, infine viene
-chiamata \texttt{\_exit}.
+Nella sequenza di chiusura tutte le funzioni registrate verranno chiamate in
+ordine inverso rispetto a quello di registrazione (ed una stessa funzione
+registrata più volte sarà chiamata più volte); poi verranno chiusi tutti gli
+stream aperti, infine verrà chiamata \texttt{\_exit}.
 
 
 \subsection{Conclusioni}
@@ -219,12 +219,12 @@ chiamata \texttt{\_exit}.
 Data l'importanza dell'argomento è opportuno sottolineare ancora una volta che
 in un sistema unix l'unico modo in cui un programma può essere eseguito dal
 kernel è attraverso la chiamata alla system call \texttt{execve} (in genere
-attraveso una delle funzioni \texttt{exec} che vedremo in
+attraverso una delle funzioni \texttt{exec} che vedremo in
 \secref{sec:prochand_exec}).
 
 Allo stesso modo l'unico modo in cui un programma può concludere
 volontariamente la sua esecuzione è attraverso una chiamata alla system call
-\texttt{\_exec} sia esplicitamente o che in maniera indiretta attraverso l'uso
+\texttt{\_exit} sia esplicitamente o che in maniera indiretta attraverso l'uso
 di \texttt{exit} o il ritorno della funzione \texttt{main}.
 
 Lo schema delle modalità con cui si avvia e conclude normalmente un programma
@@ -269,12 +269,12 @@ corrisponde all'effettiva posizione dei dati nella RAM del computer; in genere
 detto spazio non è neanche continuo (cioè non tutti gli indirizzi sono
 utilizzabili e/o utilizzati).
 
-La memoria virtuale viene divisa in pagine (che ad esempio sono di 4kb su
-macchine a 32 bit e 8kb sulle alpha, valori strettamente connessi all'hardware
-di gestione della memoria) di dimensione fissa, e ciascuna pagina della
+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), 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).
+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
@@ -285,15 +285,15 @@ virtuale di tutti i processi hanno detta funzione nel loro codice.
 
 La corrispondenza fra le pagine della memoria virtuale e quelle della memoria
 fisica della macchina viene gestita in maniera trasparente dall'hardware di
-gestione della memoria (dalla \textit{Memory Management Unit} del processore),
+gestione della memoria (la \textit{Memory Management Unit} del processore),
 ma poiché in genere quest'ultima è solo una piccola frazione della memoria
 virtuale è necessario un meccanismo che permetta di trasferire le pagine
-virtuali che servono dal supporto su cui si trovano in memoria eliminando
+virtuali che servono dal supporto su cui si trovano in memoria, eliminando
 quelle che non servono. Questo meccanismo è detto \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}, l'hardware di
+reale, avviene quello che viene chiamato un \textit{page fault}; l'hardware di
 gestione della memoria (la MMU del processore) genera una 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
@@ -319,10 +319,10 @@ Bench
 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}, si tenta cioè di leggere e scrivere
-da un indirizzo per il quale non esiste una associazione della pagina virtuale
-ed il kernel risponde al relativo \textit{page fault} mandando un segnale
-\texttt{SIGSEGV} al processo, che normalmente ne causa la terminazione
+chiamato un \textit{segmentation fault}. Se si tenta cioè di leggere o
+scrivere da un indirizzo per il quale non esiste una associazione della pagina
+virtuale il kernel risponde al relativo \textit{page fault}, mandando un
+segnale \texttt{SIGSEGV} al processo, che normalmente ne causa la terminazione
 immediata.
 
 È pertanto importante capire come viene strutturata la memoria virtuale di un
@@ -332,9 +332,9 @@ programma C viene suddiviso nei seguenti segmenti:
 
 \begin{enumerate}
 \item Il segmento di testo (\textit{text segment}). Contiene il codice
-  macchina del programma e le costanti statiche. Normalmente viene condiviso
-  così che più processi (anche diversi nel caso di librerie) possano
-  utilizzarlo e viene marcato in sola lettura per evitare sovrascritture
+  macchina del programma e le costanti statiche. Normalmente viene condiviso
+  in modo che più processi (anche diversi nel caso di librerie) possano
+  utilizzarlo, e viene marcato in sola lettura per evitare sovrascritture
   accidentali (o maliziose) che ne modifichino le istruzioni.
   
   Viene allocato da \texttt{exec} all'avvio del programma e resta invariato
@@ -463,8 +463,8 @@ quattro, i prototipi sono i seguenti:
 \end{functions}
 Il puntatore che le funzioni di allocazione ritornano è garantito essere
 sempre correttamente allineato per tutti i tipi di dati; ad esempio sulle
-macchine a 32 bit in genere è allineato a multipli di 4 bytes e sulle macchine
-a 64 bit a multipli di 8 bytes
+macchine a 32 bit in genere è allineato a multipli di 4 byte e sulle macchine
+a 64 bit a multipli di 8 byte. 
 
 In genere su usano le funzioni \texttt{malloc} e \texttt{calloc} per allocare
 dinamicamente la memoria necessaria al programma, siccome i puntatori
@@ -492,7 +492,7 @@ comporta come \texttt{malloc}\footnote{questo 
   allocazione, questa funzionalità è totalmente deprecata e non è consentita
   sotto linux}), ad esempio quando si deve far crescere la dimensione di un
 vettore; in questo caso se è disponibile dello spazio adiacente al precedente
-la funzione lo utilzza, altrimenti rialloca altrove un blocco della dimensione
+la funzione lo utilizza, altrimenti rialloca altrove un blocco della dimensione
 voluta copiandoci automaticamente il contenuto, lo spazio in più non viene
 inizializzato. 
 
@@ -515,7 +515,7 @@ particolare diventa possibile tracciare questo tipo di errori usando la
 variabile \texttt{MALLOC\_CHECK\_} che quando viene settata mette in uso una
 versione meno efficiente delle funzioni, che però è più tollerante nei
 confronti di piccoli errori come quello di chiamate doppie a \texttt{free}; in
-pparticolare se la variabile è posta a zero gli errori vengono ignorati, se è
+particolare se la variabile è posta a zero gli errori vengono ignorati, se è
 posta ad 1 viene stampato un avviso sullo standard error e se 
 
 Il problema più comune e più difficile da tracciare che si incontra con
@@ -525,10 +525,10 @@ viene opportunamente liberata (quello che in inglese viene chiamato
 
 Un caso tipico è quando l'allocazione viene fatta da una subroutine per un uso
 locale, ma la memoria non viene liberata una volta usata; chiamate ripetute
-alla stessa suubroutine causeranno a lungo andare un esaurimento della memoria
+alla stessa subroutine causeranno a lungo andare un esaurimento della memoria
 disponibile, con un conseguente crash dell'applicazione che può avvenire in
-qualunque momento senza nessuna relazione con la subroutine che contiene
-l'errore. 
+qualunque momento, e senza nessuna relazione con la subroutine che contiene
+l'errore.
 
 Per questo motivo l'implementazione delle routine di allocazione delle glibc
 mette a disposizione una serie di funzionalità (su cui torneremo in
@@ -542,7 +542,7 @@ pu
 \label{sec:proc_mem_alloca}
 
 Una alternativa possibile all'uso di \texttt{malloc}, che non soffre del tipo
-di problemi di memomry leak descritti in precedenza è la funzione
+di problemi di memory leak descritti in precedenza è la funzione
 \texttt{alloca} che invece che allocare la memoria nello heap usa lo il
 segmento di stack della funzione corrente. La sintassi è identica:
 \begin{prototype}{stdlib.h}{void *alloca(size\_t size)}
@@ -566,7 +566,7 @@ Un altro vantaggio e che in Linux la funzione 
 sprecato spazio, infatti non è necessario gestire un pool di memoria da
 riservare e si evitano anche problemi di frammentazione.
 
-Gli svantaggi sono che la funzione non è disponibile su tutti gli unix quando
+Gli svantaggi sono che la funzione non è disponibile su tutti gli unix, quando
 non è possibile aumentare le dimensioni dello stack una volta chiamata una
 funzione e quindi l'uso limita la portabilità dei programmi, inoltre se si
 cerca di allocare troppa memoria non si ottiene un messaggio di errore, ma un
@@ -602,7 +602,7 @@ una propria versione di \texttt{malloc}. Le  funzione sono:
   Incrementa lo spazio dati di un programma di \texttt{increment}. Un valore
   zero restituisce l'attuale posizione della fine del segmento dati.
   
-  La funzione restituisce il puntatore all'inzio della nuova zona di memoria
+  La funzione restituisce il puntatore all'inizio della nuova zona di memoria
   allocata in caso di successo e \texttt{NULL} in caso di fallimento, nel qual
   caso \texttt{errno} viene settata a \texttt{ENOMEM}.
 \end{prototype}
@@ -648,7 +648,7 @@ si possono avere queste necessit
 \item La sicurezza. Se si tengono password o chiavi in memoria queste possono
   essere portate su disco dal meccanismo della paginazione, questo rende più
   lungo il periodo di tempo in cui i segreti sono presenti in chiaro, e
-  complessa la loro cancellazione (in genere è possibile cancellare della ram
+  complessa la loro cancellazione (in genere è possibile cancellare della RAM
   ma altrettanto non vale per il disco su cui la pagina contenente i segreti
   può essere stata salvata). Per questo motivo programmi di crittografia
   richiedono il blocco di alcune pagine di memoria.
@@ -657,9 +657,9 @@ si possono avere queste necessit
 Il meccanismo che previene la paginazione di parte della memoria virtuale di
 un processo è chiamato \textit{memory locking} (blocco della memoria), il
 blocco è sempre associato alle pagine della memoria virtuale del processo, non
-con il segmento reale di ram su cui essa viene mantenuta.
+con il segmento reale di RAM su cui essa viene mantenuta.
 
-La regola è che se un segmento di ram fa da supporto ad almeno una pagina
+La regola è che se un segmento di RAM fa da supporto ad almeno una pagina
 bloccata allora esso viene escluso dal meccanismo della paginazione. I blocchi
 non si accumulano, se si blocca due volte la stessa pagina non è necessario
 sbloccarla due volte, una pagina o è bloccata o no.
@@ -671,7 +671,7 @@ tutti i blocchi di memoria.
 
 I memory lock non sono ereditati dai processi figli\footnote{ma siccome Linux
   usa il copy on write gli indirizzi virtuali del figlio sono mantenuti sullo
-  stesso segmento di ram del padre, quindi usufruiscono dei memory lock di
+  stesso segmento di RAM del padre, quindi usufruiscono dei memory lock di
   questo}. Siccome la presenza di memory lock ha un impatto sugli altri
 processi solo root ha la capacità di bloccare una pagina, ogni processo può
 però sbloccare le sue pagine. Il sistema pone dei limiti all'ammontare di
@@ -867,11 +867,11 @@ dover ricorrere all'uso di opzioni a linea di comando o di file di
 configurazione. 
 
 La shell ad esempio ne usa molte per il suo funzionamento (come \var{PATH} per
-la ricerca dei comadi), e alcune di esse (come \var{HOME}, \var{USER}, etc.)
+la ricerca dei comandi), e alcune di esse (come \var{HOME}, \var{USER}, etc.)
 sono definite al 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 (come \var{EDITOR} che indica
-l'editor preferito da invocare in caso di ncessità).
+l'editor preferito da invocare in caso di necessità).
 
 Gli standard POSIX e XPG3 definiscono alcune di queste variabili (le più
 comuni), come riportato in \ntab. GNU/Linux le supporta tutte e ne definisce