La funzione \funcd{fork} è la funzione fondamentale della gestione dei
processi: come si è detto tradizionalmente l'unico modo di creare un nuovo
processo era attraverso l'uso di questa funzione,\footnote{in realtà oggi la
- system call usata più comunemente da Linux per creare nuovi processi è
- \func{clone} (vedi \ref{sec:process_clone}) , anche perché a partire dalle
- \acr{glibc} 2.3.3 non viene più usata la system call originale, ma la stessa
+ \textit{system call} usata da Linux per creare nuovi processi è \func{clone}
+ (vedi \ref{sec:process_clone}), anche perché a partire dalle \acr{glibc}
+ 2.3.3 non viene più usata la \textit{system call} originale, ma la stessa
\func{fork} viene implementata tramite \func{clone}, cosa che consente una
migliore interazione coi \textit{thread}.} essa quindi riveste un ruolo
centrale tutte le volte che si devono scrivere programmi che usano il
Dato che Linux supporta il \itindex{copy~on~write} \textit{copy on write} la
perdita di prestazioni è assolutamente trascurabile, e l'uso di questa
-funzione, che resta un caso speciale della system call \func{clone} (che
-tratteremo in dettaglio in sez.~\ref{sec:process_clone}) è deprecato; per
+funzione, che resta un caso speciale della \textit{system call} \func{clone}
+(che tratteremo in dettaglio in sez.~\ref{sec:process_clone}) è deprecato; per
questo eviteremo di trattarla ulteriormente.
parte in tab.~\ref{tab:proc_waitpid_options} che possono essere combinati fra
loro con un OR aritmetico. Nella seconda parte della stessa tabella si sono
riportati anche alcuni valori non standard specifici di Linux, che consentono
-un controllo più dettagliato per i processi creati con la system call generica
-\func{clone} (vedi sez.~\ref{sec:process_clone}) usati principalmente per la
-gestione della terminazione dei \itindex{thread} \textit{thread} (vedi
+un controllo più dettagliato per i processi creati con la \textit{system call}
+generica \func{clone} (vedi sez.~\ref{sec:process_clone}) usati principalmente
+per la gestione della terminazione dei \itindex{thread} \textit{thread} (vedi
sez.~\ref{sec:thread_xxx}).
\begin{table}[!htb]
attengono alla gestione ordinaria dei processi e delle loro proprietà più
comuni. Tratteremo qui alcune \textit{system call} dedicate alla gestione di
funzionalità dei processi molto specifiche ed avanzate, il cui uso è in genere
-piuttosto ridotto. Trattandosi di problematiche relativamente complesse, che
-spesso presuppongono la conoscenza di altri argomenti trattati più avanti
-nella guida, si può saltare questa lezione ad una prima lettura, tornando su
+piuttosto ridotto. Trattandosi di problematiche abbastanza complesse, che
+spesso presuppongono la conoscenza di altri argomenti trattati nel seguito
+della guida, si può saltare questa sezione in una prima lettura, tornando su
di essa in un secondo tempo.
\subsection{La system call \func{clone}}
\label{sec:process_clone}
-Da fare
+La funzione tradizionale con cui creare un nuovo processo in un sistema
+Unix-like, come illustrato in sez.~\ref{sec:proc_fork}, è \func{fork}, ma con
+l'introduzione del supporto del kernel per i \textit{thread} (vedi
+cap.~\ref{cha:threads}), si è avuta la necessità di una interfaccia che
+consentisse un maggiore controllo sulla modalità con cui vengono creati nuovi
+processi, che poi è stata utilizzata anche per fornire ulteriore supporto per
+le tecnologie di virtualizzazione dei processi (i cosidetti
+\textit{container}).
+
+Per questo l'interfaccia per la creazione di un nuovo processo è stata
+delegata ad una nuova \textit{system call}, \texttt{sys\_clone}, che consente
+di reimplementare anche la tradizionale \func{fork}. In realtà in questo caso
+più che di nuovi processi si può parlare della creazioni di nuovi
+``\textit{task}'' del kernel che possono assumere la veste sia di un processo
+vero e proprio come quelli trattati finora, che di un \textit{thread}, come
+quelli che vedremo in sez.~\ref{sec:linux_thread}, in cui la memoria viene
+condivisa fra il processo chiamante ed il nuovo processo creato. Per evitare
+confusione fra \textit{thread} e processi ordinari, abbiamo deciso di usare la
+nomenclatura \textit{task} per indicare la unità di esecuzione generica messa
+a disposizione del kernel che \texttt{sys\_clone} permette di creare.
+
+La \textit{system call} richiede soltanto due argomenti: il
+primo, \param{flags}, consente di controllare le modalità di creazione del
+nuovo \textit{task}, il secondo, \param{child\_stack}, imposta l'indirizzo
+dello \itindex{stack} \textit{stack} per il nuovo \textit{task}, e deve essere
+indicato quando si intende creare un \textit{thread}. L'esecuzione del
+programma creato da \param{child\_stack} riprende, come per \func{fork}, da
+dopo l'esecuzione della stessa.
+
+La necessità di avere uno \itindex{stack} \textit{stack} alternativo c'è solo
+quando si intende creare un \textit{thread}, in tal caso infatti il nuovo
+\textit{task} vede esattamente la stessa memoria del \textit{task}
+``\textsl{padre}'',\footnote{in questo caso per padre si intende semplicemente
+ il \textit{task} che ha eseguito \texttt{sys\_clone} rispetto al
+ \textit{task} da essa creato, senza nessuna delle implicazioni che il
+ concetto ha per i processi.} e nella sua esecuzione alla prima chiamata di
+una funzione andrebbe a scrivere sullo \textit{stack} usato anche dal padre
+(si ricordi quanto visto in sez.~\ref{sec:proc_mem_layout} riguardo all'uso
+dello \textit{stack}).
+
+Per evitare di doversi garantire contro la evidente possibilità di
+\itindex{race~condition} \textit{race conditions} che questa situazione
+comporta è necessario che il chiamante allochi preventivamente un'area di
+memoria (in genere lo si fa con una \func{malloc}) che la funzione imposterà
+come \textit{stack} del nuovo processo, avendo ovviamente cura di non
+utilizzarla direttamente. In questo modo i due \textit{task} avranno degli
+\textit{stack} indipendenti e non si dovranno affrontare problematiche di
+\itindex{race~condition} \textit{race conditions}. Si tenga presente inoltre
+che in molte architetture lo \textit{stack} cresce verso il basso, pertanto in
+tal caso non si dovrà specificare per \param{child\_stack} il puntatore
+restituito da \func{malloc}, ma un puntatore alla fine del buffer con essa
+allocato.
+
+Dato che tutto ciò è necessario solo per i \textit{thread} che condividono la
+memoria, la \textit{system call}, a differenza della funzione di libreria che
+vedremo a breve, consente anche di passare per \param{child\_stack} il valore
+\val{NULL}, che non imposta un nuovo \textit{stack}. Se infatti si crea un
+processo, questo ottiene un suo nuovo spazio degli indirizzi,\footnote{è
+ sottinteso cioè che non si stia usando il flag \const{CLONE\_VM}.} ed in
+questo caso si applica la semantica del \itindex{copy-on-write} \textit{copy
+ on write} illustrata in sez.~\ref{sec:proc_fork}, per cui le pagine dello
+\textit{stack} verranno automaticamente copiate come le altre e il nuovo
+processo avrà un suo \textit{stack} totalmente indipendente da quello del
+padre.
+
+Dato che l'uso principale della nuova \textit{system call} è quello relativo
+alla creazione dei \textit{thread}, le \acr{glibc} definiscono una funzione di
+libreria
+
+\funcd{clone}
+
\subsection{La funzione \func{prctl}}
\label{sec:process_prctl}
fornisce una interfaccia generica per tutte le operazioni specialistiche. La
funzione è \funcd{prctl} ed il suo prototipo è:\footnote{la funzione non è
standardizzata ed è specifica di Linux, anche se ne esiste una analoga in
- IRIX, è stata introdotta con il kernel 2.1.57.}
+ IRIX; è stata introdotta con il kernel 2.1.57.}
\begin{functions}
\headdecl{sys/prctl.h}
projects / gapil.git / blobdiff