\cmd{init} o da uno dei suoi figli\footnote{in realtà questo non è del tutto
vero, in Linux ci sono alcuni processi speciali che pur comparendo come
figli di \cmd{init}, o con \acr{pid} successivi, sono in realtà generati
- direttamente dal kernel, (come \cmd{keventd}, \cmd{kswapd}, etc.).} si
+ direttamente dal kernel, (come \cmd{keventd}, \cmd{kswapd}, ecc.).} si
possono classificare i processi con la relazione padre/figlio in
un'organizzazione gerarchica ad albero, in maniera analoga a come i file sono
organizzati in un albero di directory (si veda
processi.
Il kernel mantiene una tabella dei processi attivi, la cosiddetta
-\textit{process table}; per ciascun processo viene mantenuta una voce,
-costituita da una struttura \struct{task\_struct}, nella tabella dei processi
-che contiene tutte le informazioni rilevanti per quel processo. Tutte le
-strutture usate a questo scopo sono dichiarate nell'header file
-\file{linux/sched.h}, ed uno schema semplificato, che riporta la struttura
-delle principali informazioni contenute nella \struct{task\_struct} (che in
-seguito incontreremo a più riprese), è mostrato in
+\itindex{process~table} \textit{process table}; per ciascun processo viene
+mantenuta una voce, costituita da una struttura \struct{task\_struct}, nella
+tabella dei processi che contiene tutte le informazioni rilevanti per quel
+processo. Tutte le strutture usate a questo scopo sono dichiarate nell'header
+file \file{linux/sched.h}, ed uno schema semplificato, che riporta la
+struttura delle principali informazioni contenute nella \struct{task\_struct}
+(che in seguito incontreremo a più riprese), è mostrato in
fig.~\ref{fig:proc_task_struct}.
\begin{figure}[htb]
\end{figure}
Come accennato in sez.~\ref{sec:intro_unix_struct} è lo
-\textit{scheduler}\index{\textit{scheduler}} che decide quale processo mettere
-in esecuzione; esso viene eseguito ad ogni system call ed ad ogni
-interrupt,\footnote{più in una serie di altre occasioni. NDT completare questa
- parte.} (ma può essere anche attivato esplicitamente). Il timer di sistema
-provvede comunque a che esso sia invocato periodicamente, generando un
-interrupt periodico secondo la frequenza specificata dalla costante
-\const{HZ}, definita in \file{asm/param.h}, ed il cui valore è espresso in
-Hertz.\footnote{Il valore usuale di questa costante è 100, per tutte le
- architetture eccetto l'alpha, per la quale è 1000. Occorre fare attenzione a
- non confondere questo valore con quello dei clock tick (vedi
+\textit{scheduler}\itindex{scheduler} che decide quale processo mettere in
+esecuzione; esso viene eseguito ad ogni system call ed ad ogni
+interrupt,\footnote{più in una serie di altre occasioni.}
+% TODO completare questa parte.
+(ma può essere anche attivato esplicitamente). Il timer di sistema provvede
+comunque a che esso sia invocato periodicamente, generando un interrupt
+periodico secondo la frequenza specificata dalla costante \const{HZ}, definita
+in \file{asm/param.h}, ed il cui valore è espresso in Hertz.\footnote{Fino al
+ kernel 2.4 l valore usuale di questa costante era 100, per tutte le
+ architetture eccetto l'alpha, per la quale era 1000. Occorre fare attenzione
+ a non confondere questo valore con quello dei clock tick (vedi
sez.~\ref{sec:sys_unix_time}).}
-%Si ha cioè un interrupt dal timer ogni centesimo di secondo.
+% TODO verificare gli ultimi cambiamenti del 2.6
+% Si ha cioè un interrupt dal timer ogni centesimo di secondo.
-Ogni volta che viene eseguito, lo \textit{scheduler}\index{\textit{scheduler}}
+Ogni volta che viene eseguito, lo \textit{scheduler}\itindex{scheduler}
effettua il calcolo delle priorità dei vari processi attivi (torneremo su
questo in sez.~\ref{sec:proc_priority}) e stabilisce quale di essi debba
essere posto in esecuzione fino alla successiva invocazione.
Il fatto che il \acr{pid} sia un numero univoco per il sistema lo rende un
candidato per generare ulteriori indicatori associati al processo di cui
diventa possibile garantire l'unicità: ad esempio in alcune implementazioni la
-funzione \func{tmpname} (si veda sez.~\ref{sec:file_temp_file}) usa il
-\acr{pid} per generare un \index{\textit{pathname}}\textit{pathname} univoco,
-che non potrà essere replicato da un altro processo che usi la stessa
-funzione.
+funzione \func{tempnam} (si veda sez.~\ref{sec:file_temp_file}) usa il
+\acr{pid} per generare un \itindex{pathname}\textit{pathname} univoco, che non
+potrà essere replicato da un altro processo che usi la stessa funzione.
Tutti i processi figli dello stesso processo padre sono detti
\textit{sibling}, questa è una delle relazioni usate nel \textsl{controllo di
Dopo il successo dell'esecuzione di una \func{fork} sia il processo padre che
il processo figlio continuano ad essere eseguiti normalmente a partire
dall'istruzione successiva alla \func{fork}; il processo figlio è però una
-copia del padre, e riceve una copia dei segmenti di testo, stack e dati (vedi
-sez.~\ref{sec:proc_mem_layout}), ed esegue esattamente lo stesso codice del
-padre. Si tenga presente però che la memoria è copiata, non condivisa,
-pertanto padre e figlio vedono variabili diverse.
-
-Per quanto riguarda la gestione della memoria, in generale il segmento di
-testo, che è identico per i due processi, è condiviso e tenuto in read-only
-per il padre e per i figli. Per gli altri segmenti Linux utilizza la tecnica
-del \textit{copy on write}\index{\textit{copy~on~write}}; questa tecnica
-comporta che una pagina di memoria viene effettivamente copiata per il nuovo
-processo solo quando ci viene effettuata sopra una scrittura (e si ha quindi
-una reale differenza fra padre e figlio). In questo modo si rende molto più
-efficiente il meccanismo della creazione di un nuovo processo, non essendo più
-necessaria la copia di tutto lo spazio degli indirizzi virtuali del padre, ma
-solo delle pagine di memoria che sono state modificate, e solo al momento
-della modifica stessa.
+copia del padre, e riceve una copia dei segmenti di testo, \itindex{stack}
+stack e dati (vedi sez.~\ref{sec:proc_mem_layout}), ed esegue esattamente lo
+stesso codice del padre. Si tenga presente però che la memoria è copiata, non
+condivisa, pertanto padre e figlio vedono variabili diverse.
+
+Per quanto riguarda la gestione della memoria, in generale
+il\index{segmento!testo} segmento di testo, che è identico per i due processi,
+è condiviso e tenuto in read-only per il padre e per i figli. Per gli altri
+segmenti Linux utilizza la tecnica del \textit{copy on
+ write}\itindex{copy~on~write}; questa tecnica comporta che una pagina di
+memoria viene effettivamente copiata per il nuovo processo solo quando ci
+viene effettuata sopra una scrittura (e si ha quindi una reale differenza fra
+padre e figlio). In questo modo si rende molto più efficiente il meccanismo
+della creazione di un nuovo processo, non essendo più necessaria la copia di
+tutto lo spazio degli indirizzi virtuali del padre, ma solo delle pagine di
+memoria che sono state modificate, e solo al momento della modifica stessa.
La differenza che si ha nei due processi è che nel processo padre il valore di
ritorno della funzione \func{fork} è il \acr{pid} del processo figlio, mentre
descrizione delle opzioni); il codice completo, compresa la parte che gestisce
le opzioni a riga di comando, è disponibile nel file \file{ForkTest.c},
distribuito insieme agli altri sorgenti degli esempi su
-\href{http://gapil.firenze.linux.it/gapil_source.tgz}
-{\texttt{http://gapil.firenze.linux.it/gapil\_source.tgz}}.
+\href{http://gapil.truelite.it/gapil_source.tgz}
+{\textsf{http://gapil.truelite.it/gapil\_source.tgz}}.
Decifrato il numero di figli da creare, il ciclo principale del programma
(\texttt{\small 24--40}) esegue in successione la creazione dei processi figli
Esaminiamo questo risultato: una prima conclusione che si può trarre è che non
si può dire quale processo fra il padre ed il figlio venga eseguito per
primo\footnote{a partire dal kernel 2.5.2-pre10 è stato introdotto il nuovo
- scheduler\index{\textit{scheduler}} di Ingo Molnar che esegue sempre per
- primo il figlio; per mantenere la portabilità è opportuno non fare comunque
+ scheduler\itindex{scheduler} di Ingo Molnar che esegue sempre per primo il
+ figlio; per mantenere la portabilità è opportuno non fare comunque
affidamento su questo comportamento.} dopo la chiamata a \func{fork};
dall'esempio si può notare infatti come nei primi due cicli sia stato eseguito
per primo il padre (con la stampa del \acr{pid} del nuovo processo) per poi
istruzioni del codice fra padre e figli, né sull'ordine in cui questi potranno
essere messi in esecuzione. Se è necessaria una qualche forma di precedenza
occorrerà provvedere ad espliciti meccanismi di sincronizzazione, pena il
-rischio di incorrere nelle cosiddette
-\textit{race condition}\index{\textit{race~condition}}
-(vedi sez.~\ref{sec:proc_race_cond}).
+rischio di incorrere nelle cosiddette \textit{race
+ condition}\itindex{race~condition} (vedi sez.~\ref{sec:proc_race_cond}).
Si noti inoltre che essendo i segmenti di memoria utilizzati dai singoli
processi completamente separati, le modifiche delle variabili nei processi
con il nostro esempio, le varie scritture risulteranno mescolate fra loro in
una sequenza impredicibile. Per questo le modalità con cui in genere si usano
i file dopo una \func{fork} sono sostanzialmente due:
-\begin{enumerate}
+\begin{enumerate*}
\item Il processo padre aspetta la conclusione del figlio. In questo caso non
è necessaria nessuna azione riguardo ai file, in quanto la sincronizzazione
della posizione corrente dopo eventuali operazioni di lettura e scrittura
\item L'esecuzione di padre e figlio procede indipendentemente. In questo caso
ciascuno dei due processi deve chiudere i file che non gli servono una volta
che la \func{fork} è stata eseguita, per evitare ogni forma di interferenza.
-\end{enumerate}
+\end{enumerate*}
Oltre ai file aperti i processi figli ereditano dal padre una serie di altre
proprietà; la lista dettagliata delle proprietà che padre e figlio hanno in
comune dopo l'esecuzione di una \func{fork} è la seguente:
\begin{itemize*}
\item i file aperti e gli eventuali flag di
- \textit{close-on-exec}\index{\textit{close-on-exec}} impostati (vedi
- sez.~\ref{sec:proc_exec} e sez.~\ref{sec:file_fcntl}).
+ \textit{close-on-exec}\itindex{close-on-exec} impostati (vedi
+ sez.~\ref{sec:proc_exec} e sez.~\ref{sec:file_fcntl});
\item gli identificatori per il controllo di accesso: l'\textsl{user-ID
reale}, il \textsl{group-ID reale}, l'\textsl{user-ID effettivo}, il
\textsl{group-ID effettivo} ed i \textit{group-ID supplementari} (vedi
- sez.~\ref{sec:proc_access_id}).
+ sez.~\ref{sec:proc_access_id});
\item gli identificatori per il controllo di sessione: il \textit{process
group-ID} e il \textit{session id} ed il terminale di controllo (vedi
- sez.~\ref{sec:sess_proc_group}).
+ sez.~\ref{sec:sess_proc_group});
\item la directory di lavoro e la directory radice (vedi
- sez.~\ref{sec:file_work_dir} e sez.~\ref{sec:file_chroot}).
-\item la maschera dei permessi di creazione (vedi sez.~\ref{sec:file_umask}).
+ sez.~\ref{sec:file_work_dir} e sez.~\ref{sec:file_chroot});
+\item la maschera dei permessi di creazione (vedi sez.~\ref{sec:file_umask});
\item la maschera dei segnali bloccati (vedi sez.~\ref{sec:sig_sigmask}) e le
- azioni installate (vedi sez.~\ref{sec:sig_gen_beha}).
+ azioni installate (vedi sez.~\ref{sec:sig_gen_beha});
\item i segmenti di memoria condivisa agganciati al processo (vedi
- sez.~\ref{sec:ipc_sysv_shm}).
-\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit}).
+ sez.~\ref{sec:ipc_sysv_shm});
+\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit});
+\item le priorità real-time e le affinità di processore (vedi
+ sez.~\ref{sec:proc_real_time});
\item le variabili di ambiente (vedi sez.~\ref{sec:proc_environ}).
\end{itemize*}
-le differenze fra padre e figlio dopo la \func{fork} invece sono:
+Le differenze fra padre e figlio dopo la \func{fork} invece sono:
\begin{itemize*}
-\item il valore di ritorno di \func{fork}.
-\item il \acr{pid} (\textit{process id}).
+\item il valore di ritorno di \func{fork};
+\item il \acr{pid} (\textit{process id});
\item il \acr{ppid} (\textit{parent process id}), quello del figlio viene
- impostato al \acr{pid} del padre.
+ impostato al \acr{pid} del padre;
\item i valori dei tempi di esecuzione della struttura \struct{tms} (vedi
- sez.~\ref{sec:sys_cpu_times}) che nel figlio sono posti a zero.
+ sez.~\ref{sec:sys_cpu_times}) che nel figlio sono posti a zero;
\item i \textit{lock} sui file (vedi sez.~\ref{sec:file_locking}), che non
- vengono ereditati dal figlio.
+ vengono ereditati dal figlio;
\item gli allarmi ed i segnali pendenti (vedi sez.~\ref{sec:sig_gen_beha}), che
per il figlio vengono cancellati.
\end{itemize*}
\func{fork} veniva fatta solo per poi eseguire una \func{exec}. La funzione
venne introdotta in BSD per migliorare le prestazioni.
-Dato che Linux supporta il \textit{copy on
- write}\index{\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}), è deprecato; per questo
-eviteremo di trattarla ulteriormente.
+Dato che Linux supporta il \textit{copy on write}\itindex{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}) è
+deprecato; per questo eviteremo di trattarla ulteriormente.
-\subsection{La conclusione di un processo.}
+\subsection{La conclusione di un processo}
\label{sec:proc_termination}
In sez.~\ref{sec:proc_conclusion} abbiamo già affrontato le modalità con cui
memoria che stava usando, e così via; l'elenco completo delle operazioni
eseguite alla chiusura di un processo è il seguente:
\begin{itemize*}
-\item tutti i file descriptor sono chiusi.
-\item viene memorizzato lo stato di terminazione del processo.
+\item tutti i file descriptor sono chiusi;
+\item viene memorizzato lo stato di terminazione del processo;
\item ad ogni processo figlio viene assegnato un nuovo padre (in genere
- \cmd{init}).
+ \cmd{init});
\item viene inviato il segnale \const{SIGCHLD} al processo padre (vedi
- sez.~\ref{sec:sig_sigchld}).
+ sez.~\ref{sec:sig_sigchld});
\item se il processo è un leader di sessione ed il suo terminale di controllo
è quello della sessione viene mandato un segnale di \const{SIGHUP} a tutti i
- processi del gruppo di foreground e il terminale di controllo viene
- disconnesso (vedi sez.~\ref{sec:sess_ctrl_term}).
+ processi del gruppo di \textit{foreground} e il terminale di controllo viene
+ disconnesso (vedi sez.~\ref{sec:sess_ctrl_term});
\item se la conclusione di un processo rende orfano un \textit{process
group} ciascun membro del gruppo viene bloccato, e poi gli vengono
inviati in successione i segnali \const{SIGHUP} e \const{SIGCONT}
completamente conclusa.
Possiamo utilizzare il nostro programma di prova per analizzare anche questa
-condizione: lanciamo il comando \cmd{forktest} in background, indicando al
-processo padre di aspettare 10 secondi prima di uscire; in questo caso, usando
-\cmd{ps} sullo stesso terminale (prima dello scadere dei 10 secondi)
-otterremo:
+condizione: lanciamo il comando \cmd{forktest} in \textit{background} (vedi
+sez.~\ref{sec:sess_job_control}), indicando al processo padre di aspettare 10
+secondi prima di uscire; in questo caso, usando \cmd{ps} sullo stesso
+terminale (prima dello scadere dei 10 secondi) otterremo:
\footnotesize
\begin{verbatim}
nella variabile puntata da \param{status} e tutte le risorse del kernel
relative al processo (vedi sez.~\ref{sec:proc_termination}) vengono rilasciate.
Nel caso un processo abbia più figli il valore di ritorno (il \acr{pid} del
-figlio) permette di identificare qual'è quello che è uscito.
+figlio) permette di identificare qual è quello che è uscito.
Questa funzione ha il difetto di essere poco flessibile, in quanto ritorna
all'uscita di un qualunque processo figlio. Nelle occasioni in cui è
\textbf{Valore} & \textbf{Opzione} &\textbf{Significato}\\
\hline
\hline
- $<-1$& -- & attende per un figlio il cui \textit{process group} (vedi
- sez.~\ref{sec:sess_proc_group}) è uguale al
- valore assoluto di \param{pid}. \\
- $-1$ & \const{WAIT\_ANY} & attende per un figlio qualsiasi, usata in
- questa maniera è equivalente a \func{wait}.\\
- $0$ & \const{WAIT\_MYPGRP} & attende per un figlio il cui \textit{process
- group} è uguale a quello del processo chiamante. \\
- $>0$ & -- &attende per un figlio il cui \acr{pid} è uguale al
- valore di \param{pid}.\\
+ $<-1$& -- & attende per un figlio il cui
+ \itindex{process~group} \textit{process group}
+ (vedi sez.~\ref{sec:sess_proc_group}) è uguale
+ al valore assoluto di \param{pid}. \\
+ $-1$& \const{WAIT\_ANY} & attende per un figlio qualsiasi, usata in
+ questa maniera è equivalente a \func{wait}.\\
+ $0$ &\const{WAIT\_MYPGRP}&attende per un figlio il cui
+ \itindex{process~group} \textit{process group} è
+ uguale a quello del processo chiamante. \\
+ $>0$& -- & attende per un figlio il cui \acr{pid} è uguale
+ al valore di \param{pid}.\\
\hline
\end{tabular}
\caption{Significato dei valori dell'argomento \param{pid} della funzione
\hline
\hline
\macro{WIFEXITED(s)} & Condizione vera (valore non nullo) per un processo
- figlio che sia terminato normalmente. \\
+ figlio che sia terminato normalmente. \\
\macro{WEXITSTATUS(s)} & Restituisce gli otto bit meno significativi dello
- stato di uscita del processo (passato attraverso \func{\_exit}, \func{exit}
- o come valore di ritorno di \func{main}). Può essere valutata solo se
- \val{WIFEXITED} ha restituito un valore non nullo.\\
+ stato di uscita del processo (passato attraverso
+ \func{\_exit}, \func{exit} o come valore di
+ ritorno di \func{main}). Può essere valutata solo
+ se \val{WIFEXITED} ha restituito un valore non
+ nullo.\\
\macro{WIFSIGNALED(s)} & Vera se il processo figlio è terminato
- in maniera anomala a causa di un segnale che non è stato catturato (vedi
- sez.~\ref{sec:sig_notification}).\\
- \macro{WTERMSIG(s)} & restituisce il numero del segnale che ha causato
- la terminazione anomala del processo. Può essere valutata solo se
- \val{WIFSIGNALED} ha restituito un valore non nullo.\\
+ in maniera anomala a causa di un segnale che non
+ è stato catturato (vedi
+ sez.~\ref{sec:sig_notification}).\\
+ \macro{WTERMSIG(s)} & Restituisce il numero del segnale che ha causato
+ la terminazione anomala del processo. Può essere
+ valutata solo se \val{WIFSIGNALED} ha restituito
+ un valore non nullo.\\
\macro{WCOREDUMP(s)} & Vera se il processo terminato ha generato un
- file si \textit{core dump}. Può essere valutata solo se
- \val{WIFSIGNALED} ha restituito un valore non nullo.\footnotemark \\
+ file di \itindex{core~dump}\textit{core
+ dump}. Può essere valutata solo se
+ \val{WIFSIGNALED} ha restituito un valore non
+ nullo.\footnotemark \\
\macro{WIFSTOPPED(s)} & Vera se il processo che ha causato il ritorno di
- \func{waitpid} è bloccato. L'uso è possibile solo avendo specificato
- l'opzione \const{WUNTRACED}. \\
- \macro{WSTOPSIG(s)} & restituisce il numero del segnale che ha bloccato
- il processo, Può essere valutata solo se \val{WIFSTOPPED} ha
- restituito un valore non nullo. \\
+ \func{waitpid} è bloccato. L'uso è possibile solo
+ avendo specificato l'opzione \const{WUNTRACED}. \\
+ \macro{WSTOPSIG(s)} & Restituisce il numero del segnale che ha bloccato
+ il processo. Può essere valutata solo se
+ \val{WIFSTOPPED} ha restituito un valore non
+ nullo. \\
\hline
\end{tabular}
\caption{Descrizione delle varie macro di preprocessore utilizzabili per
presente come estensione sia in Linux che in altri Unix.}
Entrambe le funzioni di attesa restituiscono lo stato di terminazione del
-processo tramite il puntatore \param{status} (se non interessa memorizzare lo
-stato si può passare un puntatore nullo). Il valore restituito da entrambe le
-funzioni dipende dall'implementazione, e tradizionalmente alcuni bit (in
-genere 8) sono riservati per memorizzare lo stato di uscita, e altri per
-indicare il segnale che ha causato la terminazione (in caso di conclusione
-anomala), uno per indicare se è stato generato un core file, ecc.\footnote{le
- definizioni esatte si possono trovare in \file{<bits/waitstatus.h>} ma
- questo file non deve mai essere usato direttamente, esso viene incluso
- attraverso \file{<sys/wait.h>}.}
+processo tramite il puntatore \param{status} (se non interessa memorizzare
+lo stato si può passare un puntatore nullo). Il valore restituito da
+entrambe le funzioni dipende dall'implementazione, e tradizionalmente alcuni
+bit (in genere 8) sono riservati per memorizzare lo stato di uscita, e altri
+per indicare il segnale che ha causato la terminazione (in caso di
+conclusione anomala), uno per indicare se è stato generato un
+\itindex{core~dump}\textit{core dump}, ecc.\footnote{le definizioni esatte
+ si possono trovare in \file{<bits/waitstatus.h>} ma questo file non deve
+ mai essere usato direttamente, esso viene incluso attraverso
+ \file{<sys/wait.h>}.}
Lo standard POSIX.1 definisce una serie di macro di preprocessore da usare per
analizzare lo stato di uscita. Esse sono definite sempre in
Linux, seguendo un'estensione di BSD, supporta altre due funzioni per la
lettura dello stato di terminazione di un processo, analoghe alle precedenti
-ma che prevedono un ulteriore parametro attraverso il quale il kernel può
+ma che prevedono un ulteriore argomento attraverso il quale il kernel può
restituire al padre informazioni sulle risorse usate dal processo terminato e
dai vari figli. Le due funzioni sono \funcd{wait3} e \funcd{wait4}, che
diventano accessibili definendo la macro \macro{\_USE\_BSD}; i loro prototipi
\headdecl{sys/times.h} \headdecl{sys/types.h} \headdecl{sys/wait.h}
\headdecl{sys/resource.h}
- \funcdecl{pid\_t wait4(pid\_t pid, int * status, int options, struct rusage
- * rusage)}
- È identica a \func{waitpid} sia per comportamento che per i valori dei
- parametri, ma restituisce in \param{rusage} un sommario delle risorse usate
+ \funcdecl{pid\_t wait4(pid\_t pid, int *status, int options, struct rusage
+ *rusage)}
+ È identica a \func{waitpid} sia per comportamento che per i valori degli
+ argomenti, ma restituisce in \param{rusage} un sommario delle risorse usate
dal processo.
\funcdecl{pid\_t wait3(int *status, int options, struct rusage *rusage)}
fatto attraverso una delle funzioni della famiglia \func{exec}. Quando un
processo chiama una di queste funzioni esso viene completamente sostituito dal
nuovo programma; il \acr{pid} del processo non cambia, dato che non viene
-creato un nuovo processo, la funzione semplicemente rimpiazza lo stack, lo
-heap, i dati ed il testo del processo corrente con un nuovo programma letto da
-disco.
+creato un nuovo processo, la funzione semplicemente rimpiazza lo
+\itindex{stack} stack, lo \itindex{heap} heap, i dati ed il testo del processo
+corrente con un nuovo programma letto da disco.
Ci sono sei diverse versioni di \func{exec} (per questo la si è chiamata
famiglia di funzioni) che possono essere usate per questo compito, in realtà
\begin{errlist}
\item[\errcode{EACCES}] il file non è eseguibile, oppure il filesystem è
montato in \cmd{noexec}, oppure non è un file regolare o un interprete.
- \item[\errcode{EPERM}] il file ha i bit \acr{suid} o \acr{sgid}, l'utente
- non è root, il processo viene tracciato, o il filesystem è montato con
- l'opzione \cmd{nosuid}.
+ \item[\errcode{EPERM}] il file ha i bit \itindex{suid~bit} \acr{suid} o
+ \itindex{sgid~bit} \acr{sgid}, l'utente non è root, il processo viene
+ tracciato, o il filesystem è montato con l'opzione \cmd{nosuid}.
\item[\errcode{ENOEXEC}] il file è in un formato non eseguibile o non
riconosciuto come tale, o compilato per un'altra architettura.
\item[\errcode{ENOENT}] il file o una delle librerie dinamiche o l'interprete
necessari per eseguirlo non esistono.
- \item[\errcode{ETXTBSY}] L'eseguibile è aperto in scrittura da uno o più
+ \item[\errcode{ETXTBSY}] l'eseguibile è aperto in scrittura da uno o più
processi.
- \item[\errcode{EINVAL}] L'eseguibile ELF ha più di un segmento
+ \item[\errcode{EINVAL}] l'eseguibile ELF ha più di un segmento
\const{PF\_INTERP}, cioè chiede di essere eseguito da più di un
interprete.
- \item[\errcode{ELIBBAD}] Un interprete ELF non è in un formato
+ \item[\errcode{ELIBBAD}] un interprete ELF non è in un formato
riconoscibile.
- \item[\errcode{E2BIG}] La lista degli argomenti è troppo grande.
+ \item[\errcode{E2BIG}] la lista degli argomenti è troppo grande.
\end{errlist}
ed inoltre anche \errval{EFAULT}, \errval{ENOMEM}, \errval{EIO},
\errval{ENAMETOOLONG}, \errval{ELOOP}, \errval{ENOTDIR}, \errval{ENFILE},
quando la sua funzione \func{main} è dichiarata nella forma
\code{main(int argc, char *argv[], char *envp[])}.
-Le altre funzioni della famiglia servono per fornire all'utente una serie
-possibile di diverse interfacce per la creazione di un nuovo processo. I loro
+Le altre funzioni della famiglia servono per fornire all'utente una serie di
+possibili diverse interfacce per la creazione di un nuovo processo. I loro
prototipi sono:
\begin{functions}
\headdecl{unistd.h}
\funcdecl{int execvp(const char *file, char *const argv[])}
Sostituiscono l'immagine corrente del processo con quella indicata nel primo
-argomento. I parametri successivi consentono di specificare gli argomenti a
+argomento. Gli argomenti successivi consentono di specificare gli argomenti a
linea di comando e l'ambiente ricevuti dal nuovo processo.
\bodydesc{Queste funzioni ritornano solo in caso di errore, restituendo -1;
Per capire meglio le differenze fra le funzioni della famiglia si può fare
riferimento allo specchietto riportato in tab.~\ref{tab:proc_exec_scheme}. La
-prima differenza riguarda le modalità di passaggio dei parametri che poi
-andranno a costituire gli argomenti a linea di comando (cioè i valori di
+prima differenza riguarda le modalità di passaggio dei valori che poi andranno
+a costituire gli argomenti a linea di comando (cioè i valori di
\param{argv} e \param{argc} visti dalla funzione \func{main} del programma
chiamato).
argomenti a lista &$\bullet$&$\bullet$&$\bullet$&&& \\
argomenti a vettore &&&&$\bullet$&$\bullet$&$\bullet$\\
\hline
- filename completo &&$\bullet$&&&$\bullet$& \\
- ricerca su \var{PATH}&$\bullet$&&$\bullet$&$\bullet$&&$\bullet$ \\
+ filename completo &$\bullet$&&$\bullet$&$\bullet$&&$\bullet$\\
+ ricerca su \var{PATH} &&$\bullet$&&&$\bullet$& \\
\hline
ambiente a vettore &&&$\bullet$&&&$\bullet$ \\
uso di \var{environ} &$\bullet$&$\bullet$&&$\bullet$&$\bullet$& \\
La seconda differenza fra le funzioni riguarda le modalità con cui si
specifica il programma che si vuole eseguire. Con lo mnemonico \code{p} si
indicano le due funzioni che replicano il comportamento della shell nello
-specificare il comando da eseguire; quando il parametro \param{file} non
-contiene una ``\file{/}'' esso viene considerato come un nome di programma, e
-viene eseguita automaticamente una ricerca fra i file presenti nella lista di
-directory specificate dalla variabile di ambiente \var{PATH}. Il file che
+specificare il comando da eseguire; quando l'argomento \param{file} non
+contiene una ``\texttt{/}'' esso viene considerato come un nome di programma,
+e viene eseguita automaticamente una ricerca fra i file presenti nella lista
+di directory specificate dalla variabile di ambiente \var{PATH}. Il file che
viene posto in esecuzione è il primo che viene trovato. Se si ha un errore
relativo a permessi di accesso insufficienti (cioè l'esecuzione della
sottostante \func{execve} ritorna un \errcode{EACCES}), la ricerca viene
Le altre quattro funzioni si limitano invece a cercare di eseguire il file
indicato dall'argomento \param{path}, che viene interpretato come il
-\index{\textit{pathname}}\textit{pathname} del programma.
+\itindex{pathname}\textit{pathname} del programma.
\begin{figure}[htb]
\centering
- \includegraphics[width=16cm]{img/exec_rel}
+ \includegraphics[width=15cm]{img/exec_rel}
\caption{La interrelazione fra le sei funzioni della famiglia \func{exec}.}
\label{fig:proc_exec_relat}
\end{figure}
La terza differenza è come viene passata la lista delle variabili di ambiente.
-Con lo mnemonico \code{e} vengono indicate quelle funzioni che necessitano di
-un vettore di parametri \var{envp[]} analogo a quello usato per gli argomenti
-a riga di comando (terminato quindi da un \val{NULL}), le altre usano il
-valore della variabile \var{environ} (vedi sez.~\ref{sec:proc_environ}) del
-processo di partenza per costruire l'ambiente.
+Con lo mnemonico \texttt{e} vengono indicate quelle funzioni che necessitano
+di un vettore di parametri \var{envp[]} analogo a quello usato per gli
+argomenti a riga di comando (terminato quindi da un \val{NULL}), le altre
+usano il valore della variabile \var{environ} (vedi
+sez.~\ref{sec:proc_environ}) del processo di partenza per costruire
+l'ambiente.
Oltre a mantenere lo stesso \acr{pid}, il nuovo programma fatto partire da
\func{exec} assume anche una serie di altre proprietà del processo chiamante;
la lista completa è la seguente:
\begin{itemize*}
\item il \textit{process id} (\acr{pid}) ed il \textit{parent process id}
- (\acr{ppid}).
+ (\acr{ppid});
\item l'\textsl{user-ID reale}, il \textit{group-ID reale} ed i
- \textsl{group-ID supplementari} (vedi sez.~\ref{sec:proc_access_id}).
-\item il \textit{session id} (\acr{sid}) ed il \textit{process group-ID}
- (\acr{pgid}), vedi sez.~\ref{sec:sess_proc_group}.
-\item il terminale di controllo (vedi sez.~\ref{sec:sess_ctrl_term}).
-\item il tempo restante ad un allarme (vedi sez.~\ref{sec:sig_alarm_abort}).
+ \textsl{group-ID supplementari} (vedi sez.~\ref{sec:proc_access_id});
+\item il \textit{session ID} (\acr{sid}) ed il \itindex{process~group}
+ \textit{process group ID} (\acr{pgid}), vedi sez.~\ref{sec:sess_proc_group};
+\item il terminale di controllo (vedi sez.~\ref{sec:sess_ctrl_term});
+\item il tempo restante ad un allarme (vedi sez.~\ref{sec:sig_alarm_abort});
\item la directory radice e la directory di lavoro corrente (vedi
- sez.~\ref{sec:file_work_dir}).
+ sez.~\ref{sec:file_work_dir});
\item la maschera di creazione dei file (\var{umask}, vedi
sez.~\ref{sec:file_umask}) ed i \textit{lock} sui file (vedi
- sez.~\ref{sec:file_locking}).
+ sez.~\ref{sec:file_locking});
\item i segnali sospesi (\textit{pending}) e la maschera dei segnali (si veda
- sez.~\ref{sec:sig_sigmask}).
-\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit}).
+ sez.~\ref{sec:sig_sigmask});
+\item i limiti sulle risorse (vedi sez.~\ref{sec:sys_resource_limit});
\item i valori delle variabili \var{tms\_utime}, \var{tms\_stime},
\var{tms\_cutime}, \var{tms\_ustime} (vedi sez.~\ref{sec:sys_cpu_times}).
\end{itemize*}
sez.~\ref{sec:sig_gen_beha}).
La gestione dei file aperti dipende dal valore che ha il flag di
-\textit{close-on-exec}\index{\textit{close-on-exec}} (vedi anche
+\textit{close-on-exec}\itindex{close-on-exec} (vedi anche
sez.~\ref{sec:file_fcntl}) per ciascun file descriptor. I file per cui è
impostato vengono chiusi, tutti gli altri file restano aperti. Questo
significa che il comportamento predefinito è che i file restano aperti
Per le directory, lo standard POSIX.1 richiede che esse vengano chiuse
attraverso una \func{exec}, in genere questo è fatto dalla funzione
\func{opendir} (vedi sez.~\ref{sec:file_dir_read}) che effettua da sola
-l'impostazione del flag di
-\textit{close-on-exec}\index{\textit{close-on-exec}} sulle directory che apre,
-in maniera trasparente all'utente.
+l'impostazione del flag di \textit{close-on-exec}\itindex{close-on-exec} sulle
+directory che apre, in maniera trasparente all'utente.
Abbiamo detto che l'\textsl{user-ID reale} ed il \textsl{group-ID reale}
restano gli stessi all'esecuzione di \func{exec}; lo stesso vale per
l'\textsl{user-ID effettivo} ed il \textsl{group-ID effettivo} (il significato
di questi identificatori è trattato in sez.~\ref{sec:proc_access_id}), tranne
-quando il file che si va ad eseguire abbia o il \acr{suid} bit o lo \acr{sgid}
-bit impostato, in questo caso l'\textsl{user-ID effettivo} ed il
-\textsl{group-ID effettivo} vengono impostati rispettivamente all'utente o al
-gruppo cui il file appartiene (per i dettagli vedi sez.~\ref{sec:proc_perms}).
+quando il file che si va ad eseguire abbia o il \itindex{suid~bit}\acr{suid}
+bit o lo \itindex{sgid~bit} \acr{sgid} bit impostato, in questo caso
+l'\textsl{user-ID effettivo} ed il \textsl{group-ID effettivo} vengono
+impostati rispettivamente all'utente o al gruppo cui il file appartiene (per i
+dettagli vedi sez.~\ref{sec:proc_perms}).
Se il file da eseguire è in formato \emph{a.out} e necessita di librerie
-condivise, viene lanciato il \textit{linker} dinamico \cmd{ld.so} prima del
-programma per caricare le librerie necessarie ed effettuare il link
+condivise, viene lanciato il \textit{linker} dinamico \cmd{/lib/ld.so} prima
+del programma per caricare le librerie necessarie ed effettuare il link
dell'eseguibile. Se il programma è in formato ELF per caricare le librerie
dinamiche viene usato l'interprete indicato nel segmento \const{PT\_INTERP},
in genere questo è \file{/lib/ld-linux.so.1} per programmi linkati con le
\acr{libc5}, e \file{/lib/ld-linux.so.2} per programmi linkati con le
-\acr{glibc}. Infine nel caso il file sia uno script esso deve iniziare con
-una linea nella forma \cmd{\#!/path/to/interpreter} dove l'interprete indicato
-deve esse un programma valido (binario, non un altro script) che verrà
+\acr{glibc}.
+
+Infine nel caso il file sia uno script esso deve iniziare con una linea nella
+forma \cmd{\#!/path/to/interpreter [argomenti]} dove l'interprete indicato
+deve essere un programma valido (binario, non un altro script) che verrà
chiamato come se si fosse eseguito il comando \cmd{interpreter [argomenti]
- filename}.
+ filename}.\footnote{si tenga presente che con Linux quanto viene scritto
+ come \texttt{argomenti} viene passato all'inteprete come un unico argomento
+ con una unica stringa di lunghezza massima di 127 caratteri e se questa
+ dimensione viene ecceduta la stringa viene troncata; altri Unix hanno
+ dimensioni massime diverse, e diversi comportamenti, ad esempio FreeBSD
+ esegue la scansione della riga e la divide nei vari argomenti e se è troppo
+ lunga restitituisce un errore di \const{ENAMETOOLONG}, una comparazione dei
+ vari comportamenti si trova su
+ \href{http://www.in-ulm.de/~mascheck/various/shebang/}
+ {\texttt{http://www.in-ulm.de/\tild mascheck/various/shebang/}}.}
Con la famiglia delle \func{exec} si chiude il novero delle funzioni su cui è
basata la gestione dei processi in Unix: con \func{fork} si crea un nuovo
\label{sec:proc_perms}
In questa sezione esamineremo le problematiche relative al controllo di
-accesso dal punto di vista del processi; vedremo quali sono gli identificatori
+accesso dal punto di vista dei processi; vedremo quali sono gli identificatori
usati, come questi possono essere modificati nella creazione e nel lancio di
nuovi processi, le varie funzioni per la loro manipolazione diretta e tutte le
problematiche connesse ad una gestione accorta dei privilegi.
Come accennato in sez.~\ref{sec:intro_multiuser} il modello base\footnote{in
realtà già esistono estensioni di questo modello base, che lo rendono più
- flessibile e controllabile, come le \textit{capabilities}, le ACL per i file
- o il \textit{Mandatory Access Control} di SELinux; inoltre basandosi sul
+ flessibile e controllabile, come le \itindex{capabilities}
+ \textit{capabilities} illustrate in sez.~\ref{sec:proc_capabilities}, le ACL
+ per i file o il \textit{Mandatory Access Control}
+ \itindex{Mandatory~Access~Control~(MAC)} di SELinux; inoltre basandosi sul
lavoro effettuato con SELinux, a partire dal kernel 2.5.x, è iniziato lo
sviluppo di una infrastruttura di sicurezza, il \textit{Linux Security
Modules}, o LSM, in grado di fornire diversi agganci a livello del kernel
\textit{superuser}) che non è sottoposto a restrizioni, ed il resto degli
utenti, per i quali invece vengono effettuati i vari controlli di accesso.
-%Benché il sistema sia piuttosto semplice (è basato su un solo livello di
-% separazione) il sistema permette una
-%notevole flessibilità,
-
Abbiamo già accennato come il sistema associ ad ogni utente e gruppo due
identificatori univoci, lo user-ID ed il group-ID; questi servono al kernel per
identificare uno specifico utente o un gruppo di utenti, per poi poter
Dato che tutte le operazioni del sistema vengono compiute dai processi, è
evidente che per poter implementare un controllo sulle operazioni occorre
anche poter identificare chi è che ha lanciato un certo programma, e pertanto
-anche a ciascun processo dovrà essere associato ad un utente e ad un gruppo.
+anche a ciascun processo dovrà essere associato un utente e un gruppo.
Un semplice controllo di una corrispondenza fra identificativi non garantisce
però sufficiente flessibilità per tutti quei casi in cui è necessario poter
Al secondo gruppo appartengono lo \textsl{user-ID effettivo} ed il
\textsl{group-ID effettivo} (a cui si aggiungono gli eventuali \textsl{group-ID
supplementari} dei gruppi dei quali l'utente fa parte). Questi sono invece
-gli identificatori usati nella verifiche dei permessi del processo e per il
+gli identificatori usati nelle verifiche dei permessi del processo e per il
controllo di accesso ai file (argomento affrontato in dettaglio in
sez.~\ref{sec:file_perm_overview}).
Questi identificatori normalmente sono identici ai corrispondenti del gruppo
\textit{real} tranne nel caso in cui, come accennato in
-sez.~\ref{sec:proc_exec}, il programma che si è posto in esecuzione abbia i bit
-\acr{suid} o \acr{sgid} impostati (il significato di questi bit è affrontato
-in dettaglio in sez.~\ref{sec:file_suid_sgid}). In questo caso essi saranno
-impostati all'utente e al gruppo proprietari del file. Questo consente, per
-programmi in cui ci sia necessità, di dare a qualunque utente normale
-privilegi o permessi di un altro (o dell'amministratore).
+sez.~\ref{sec:proc_exec}, il programma che si è posto in esecuzione abbia i
+bit \itindex{suid~bit} \acr{suid} o \itindex{sgid~bit} \acr{sgid} impostati
+(il significato di questi bit è affrontato in dettaglio in
+sez.~\ref{sec:file_suid_sgid}). In questo caso essi saranno impostati
+all'utente e al gruppo proprietari del file. Questo consente, per programmi in
+cui ci sia necessità, di dare a qualunque utente normale privilegi o permessi
+di un altro (o dell'amministratore).
Come nel caso del \acr{pid} e del \acr{ppid}, anche tutti questi
identificatori possono essere letti attraverso le rispettive funzioni:
dell'\textsl{user-ID effettivo} e del \textsl{group-ID effettivo} del processo
padre, e vengono impostati dalla funzione \func{exec} all'avvio del processo,
come copie dell'\textsl{user-ID effettivo} e del \textsl{group-ID effettivo}
-dopo che questi sono stati impostati tenendo conto di eventuali \acr{suid} o
-\acr{sgid}. Essi quindi consentono di tenere traccia di quale fossero utente
-e gruppo effettivi all'inizio dell'esecuzione di un nuovo programma.
+dopo che questi sono stati impostati tenendo conto di eventuali
+\itindex{suid~bit}\acr{suid} o \itindex{sgid~bit} \acr{sgid}. Essi quindi
+consentono di tenere traccia di quale fossero utente e gruppo effettivi
+all'inizio dell'esecuzione di un nuovo programma.
L'\textsl{user-ID di filesystem} e il \textsl{group-ID di filesystem} sono
un'estensione introdotta in Linux per rendere più sicuro l'uso di NFS
-(torneremo sull'argomento in sez.~\ref{sec:proc_setfsuid}). Essi sono una
+(torneremo sull'argomento in sez.~\ref{sec:proc_setuid}). Essi sono una
replica dei corrispondenti identificatori del gruppo \textit{effective}, ai
quali si sostituiscono per tutte le operazioni di verifica dei permessi
relativi ai file (trattate in sez.~\ref{sec:file_perm_overview}). Ogni
ignorarne l'esistenza, in quanto saranno del tutto equivalenti ai precedenti.
-\subsection{Le funzioni \func{setuid} e \func{setgid}}
+\subsection{Le funzioni di gestione degli identificatori dei processi}
\label{sec:proc_setuid}
-Le due funzioni che vengono usate per cambiare identità (cioè utente e gruppo
-di appartenenza) ad un processo sono rispettivamente \funcd{setuid} e
-\funcd{setgid}; come accennato in sez.~\ref{sec:proc_access_id} in Linux esse
-seguono la semantica POSIX che prevede l'esistenza dell'\textit{user-ID
- salvato} e del \textit{group-ID salvato}; i loro prototipi sono:
+Le due funzioni più comuni che vengono usate per cambiare identità (cioè
+utente e gruppo di appartenenza) ad un processo sono rispettivamente
+\funcd{setuid} e \funcd{setgid}; come accennato in
+sez.~\ref{sec:proc_access_id} in Linux esse seguono la semantica POSIX che
+prevede l'esistenza dell'\textit{user-ID salvato} e del \textit{group-ID
+ salvato}; i loro prototipi sono:
\begin{functions}
\headdecl{unistd.h}
\headdecl{sys/types.h}
\errcode{EPERM}).
Come accennato l'uso principale di queste funzioni è quello di poter
-consentire ad un programma con i bit \acr{suid} o \acr{sgid} impostati (vedi
-sez.~\ref{sec:file_suid_sgid}) di riportare l'\textsl{user-ID effettivo} a
-quello dell'utente che ha lanciato il programma, effettuare il lavoro che non
-necessita di privilegi aggiuntivi, ed eventualmente tornare indietro.
+consentire ad un programma con i bit \itindex{suid~bit} \acr{suid} o
+\itindex{sgid~bit} \acr{sgid} impostati (vedi sez.~\ref{sec:file_suid_sgid})
+di riportare l'\textsl{user-ID effettivo} a quello dell'utente che ha lanciato
+il programma, effettuare il lavoro che non necessita di privilegi aggiuntivi,
+ed eventualmente tornare indietro.
Come esempio per chiarire l'uso di queste funzioni prendiamo quello con cui
viene gestito l'accesso al file \file{/var/log/utmp}. In questo file viene
Questo comportamento è corretto per l'uso che ne fa \cmd{login} una volta che
crea una nuova shell per l'utente; ma quando si vuole cambiare soltanto
l'\textsl{user-ID effettivo} del processo per cedere i privilegi occorre
-ricorrere ad altre funzioni (si veda ad esempio sez.~\ref{sec:proc_seteuid}).
-
-
-\subsection{Le funzioni \func{setreuid} e \func{setregid}}
-\label{sec:proc_setreuid}
+ricorrere ad altre funzioni.
Le due funzioni \funcd{setreuid} e \funcd{setregid} derivano da BSD che, non
supportando\footnote{almeno fino alla versione 4.3+BSD TODO, FIXME verificare
corrente, l'user-ID salvato viene automaticamente uniformato al valore
dell'user-ID effettivo.
-
-\subsection{Le funzioni \func{seteuid} e \func{setegid}}
-\label{sec:proc_seteuid}
-
-Le due funzioni \funcd{seteuid} e \funcd{setegid} sono un'estensione allo
-standard POSIX.1 (ma sono comunque supportate dalla maggior parte degli Unix)
-e vengono usate per cambiare gli identificatori del gruppo \textit{effective};
-i loro prototipi sono:
+Altre due funzioni, \funcd{seteuid} e \funcd{setegid}, sono un'estensione
+dello standard POSIX.1, ma sono comunque supportate dalla maggior parte degli
+Unix; esse vengono usate per cambiare gli identificatori del gruppo
+\textit{effective} ed i loro prototipi sono:
\begin{functions}
\headdecl{unistd.h}
\headdecl{sys/types.h}
normale di \func{setuid} comporta l'impostazione di tutti gli identificatori.
-\subsection{Le funzioni \func{setresuid} e \func{setresgid}}
-\label{sec:proc_setresuid}
-
-Le due funzioni \funcd{setresuid} e \funcd{setresgid} sono un'estensione
-introdotta in Linux,\footnote{a partire dal kernel 2.1.44.} e permettono un
-completo controllo su tutti e tre i gruppi di identificatori (\textit{real},
-\textit{effective} e \textit{saved}), i loro prototipi sono:
+Le due funzioni \funcd{setresuid} e \funcd{setresgid} sono invece
+un'estensione introdotta in Linux,\footnote{per essere precisi a partire dal
+ kernel 2.1.44.} e permettono un completo controllo su tutti e tre i gruppi
+di identificatori (\textit{real}, \textit{effective} e \textit{saved}), i loro
+prototipi sono:
\begin{functions}
\headdecl{unistd.h}
\headdecl{sys/types.h}
si applica alla seconda per i group-ID. I processi non privilegiati possono
cambiare uno qualunque degli user-ID solo ad un valore corrispondente o
all'user-ID reale, o a quello effettivo o a quello salvato, l'amministratore
-può specificare i valori che vuole; un valore di -1 per un qualunque parametro
+può specificare i valori che vuole; un valore di -1 per un qualunque argomento
lascia inalterato l'identificatore corrispondente.
Per queste funzioni esistono anche due controparti che permettono di leggere
Anche queste funzioni sono un'estensione specifica di Linux, e non richiedono
nessun privilegio. I valori sono restituiti negli argomenti, che vanno
specificati come puntatori (è un altro esempio di
-\index{\textit{value~result~argument}}\textit{value result argument}). Si noti
-che queste funzioni sono le uniche in grado di leggere gli identificatori del
+\itindex{value~result~argument}\textit{value result argument}). Si noti che
+queste funzioni sono le uniche in grado di leggere gli identificatori del
gruppo \textit{saved}.
-\subsection{Le funzioni \func{setfsuid} e \func{setfsgid}}
-\label{sec:proc_setfsuid}
-
-Queste funzioni servono per impostare gli identificatori del gruppo
-\textit{filesystem} che sono usati da Linux per il controllo dell'accesso ai
-file. Come già accennato in sez.~\ref{sec:proc_access_id} Linux definisce
-questo ulteriore gruppo di identificatori, che in circostanze normali sono
-assolutamente equivalenti a quelli del gruppo \textit{effective}, dato che
-ogni cambiamento di questi ultimi viene immediatamente riportato su di essi.
+Infine le funzioni \func{setfsuid} e \func{setfsgid} servono per impostare gli
+identificatori del gruppo \textit{filesystem} che sono usati da Linux per il
+controllo dell'accesso ai file. Come già accennato in
+sez.~\ref{sec:proc_access_id} Linux definisce questo ulteriore gruppo di
+identificatori, che in circostanze normali sono assolutamente equivalenti a
+quelli del gruppo \textit{effective}, dato che ogni cambiamento di questi
+ultimi viene immediatamente riportato su di essi.
C'è un solo caso in cui si ha necessità di introdurre una differenza fra gli
identificatori dei gruppi \textit{effective} e \textit{filesystem}, ed è per
\textit{saved}.
-\subsection{Le funzioni \func{setgroups} e \func{getgroups}}
+\subsection{Le funzioni per la gestione dei gruppi associati a un processo}
\label{sec:proc_setgroups}
Le ultime funzioni che esamineremo sono quelle che permettono di operare sui
scrivere codice portabile.
-%
-% Da fare !!!
-% insieme alla risistemazioni dei titoli delle sezioni precedenti
-% (accorpare il materiale) qualosa tipo:
-% le funzioni di controllo
-% estenzioni di Linux
-%
-%\subsection{La gestione delle capabilities}
-%\label{sec:proc_capabilities}
+\subsection{La gestione delle \textit{capabilities}}
+\label{sec:proc_capabilities}
+
+
+\itindbeg{capabilities}
+
+Come accennato in sez.~\ref{sec:proc_access_id} l'architettura classica della
+gestione dei privilegi in un sistema unix-like ha il sostanziale problema di
+fornire all'amministratore dei poteri troppo ampi, questo comporta che anche
+quando di siamo predisposte delle protezioni per in essere in grado di
+difendersi dagli effetti di una eventuale compromissione del sistema (come
+montare un filesystem in sola lettura per impedirne modifiche), una volta che
+questa sia stata effettuata e si siano ottenuti i privilegi di amministratore,
+queste potranno essere comunque rimosse (nel caso dell'esempio si potrà sempre
+rimontare il sistema in lettura-scrittura).
+
+Il problema consiste nel fatto che nell'architettura tradizionale di un
+sistema unix-like i controlli di accesso sono basati su un solo livello di
+separazione: per i processi normali essi sono posti in atto, mentre per i
+processi con i privilegi di amministratore essi non vengono neppure eseguiti.
+Dato che i privilegi sono sempre gli stessi, non esiste modo per evitare che
+un processo con diritti di amministratore non possa eseguire certe operazioni.
+Per ovviare a tutto ciò, a partire dai kernel della serie 2.2, è stato
+introdotto un meccanismo, detto \textit{capabilities}, che consentisse di
+suddividere i vari privilegi tradizionalmente associati all'amministratore in
+un insieme di \textsl{capacità} distinte.
+
+Queste capacità possano essere abilitate e disabilitate in maniera
+indipendente per ciascun processo, permettendo una granularità molto più fine
+nella distribuzione dei privilegi. Il meccanismo completo delle
+\textit{capabilities} prevederebbe anche la possibilità di associare le stesse
+\textit{capabilities} anche ai singoli file
+eseguibili,\footnote{l'implementazione di Linux si rifà ad una bozza per
+ quello che dovrebbe divenire lo standard POSIX.1e, che prevede questa
+ funzionalità.} in modo da poter stabilire quali capacità possono essere
+utilizzate quando viene messo in esecuzione uno specifico programma;
+attualmente\footnote{vale a dire almeno fino al kernel 2.6.13, e non è
+ disponibile al momento neanche nessuna realizzazione sperimentale.} questa
+funzionalità non è implementata.
+
+Per gestire questo nuovo meccanismo ciascun processo porta con sé tre distinti
+insiemi di \textit{capabilities}, che vengono denominati rispettivamente
+\textit{effective}, \textit{permitted} ed \textit{inherited}. Questi insiemi
+vengono mantenuti in forma di tre diverse maschere binarie,\footnote{il kernel
+ li mantiene, come i vari identificatori di sez.~\ref{sec:proc_setuid},
+ all'interno della \struct{task\_struct} di ciascun processo (vedi
+ fig.~\ref{fig:proc_task_struct}), nei tre campi \texttt{cap\_effective},
+ \texttt{cap\_inheritable}, \texttt{cap\_permitted} del tipo
+ \texttt{kernel\_cap\_t} (definito come intero a 32 bit), il che comporta un
+ massimo di 32 \textit{capabilities} distinte.} in cui ciascun bit
+corrisponde ad una capacità diversa; se ne è riportato l'elenco,\footnote{si
+ tenga presente che l'elenco delle \textit{capabilities} presentato questa
+ tabella, ripreso dalla relativa pagina di manuale (accessibile con
+ \texttt{man capabilities}), è quello aggiornato al kernel 2.6.6.} con una
+breve descrizione, ed il nome delle costanti che identificano i singoli bit,
+in tab.~\ref{tab:proc_capabilities}.
+
+
+\begin{table}[!hbt]
+ \centering
+ \footnotesize
+ \begin{tabular}{|l|p{12cm}|}
+ \hline
+ \textbf{Capacità}&\textbf{Descrizione}\\
+ \hline
+ \hline
+ \const{CAP\_CHOWN} & la capacità di cambiare proprietario e gruppo
+ proprietario di un file (vedi
+ sez.~\ref{sec:file_chown}).\\
+ \const{CAP\_DAC\_OVERRIDE}& la capacità di evitare il controllo dei
+ permessi di lettura, scrittura ed esecuzione dei
+ file, (vedi sez.~\ref{sec:file_access_control})
+ caratteristici del modello classico del
+ controllo di accesso chiamato
+ \itindex{Discrectionary~Access~Control~(DAC)}
+ \textit{Discrectionary Access Control} (da cui
+ il nome DAC).\\
+ \const{CAP\_DAC\_READ\_SEARCH}& la capacità di evitare il controllo dei
+ permessi di lettura, scrittura ed esecuzione per
+ le directory (vedi
+ sez.~\ref{sec:file_access_control}).\\
+ \const{CAP\_FOWNER} & la capacità di evitare il controllo che
+ l'user-ID effettivo del processo (o meglio il
+ \textit{filesystem user-ID}, vedi
+ sez.~\ref{sec:proc_setuid}) coincida con
+ quello del proprietario di un file per tutte
+ le operazioni privilegiate non coperte dalle
+ precedenti \const{CAP\_DAC\_OVERRIDE} e
+ \const{CAP\_DAC\_READ\_SEARCH}. Queste
+ comprendono i cambiamenti dei permessi e dei
+ tempi del file (vedi sez.~\ref{sec:file_chmod} e
+ sez.~\ref{sec:file_utime}), le impostazioni degli
+ attributi estesi (con il comando \cmd{chattr}) e
+ delle ACL, poter ignorare lo
+ \itindex{sticky~bit} \textit{sticky bit} nella
+ cancellazione dei file (vedi
+ sez.~\ref{sec:file_sticky}), la possibilità di
+ impostare il flag di \const{O\_NOATIME} con
+ \func{open} e \func{fcntl} (vedi
+ sez.~\ref{sec:file_open} e
+ sez.~\ref{sec:file_fcntl}).\\
+ \const{CAP\_FSETID} & la capacità di evitare la cancellazione
+ automatica dei bit \itindex{suid~bit} \acr{suid}
+ e \itindex{sgid~bit} \acr{sgid} quando un file
+ per i quali sono impostati viene modificato da
+ un processo senza questa capacità e la capacità
+ di impostare il bit \acr{sgid} su un file anche
+ quando questo è relativo ad un gruppo cui non si
+ appartiene (vedi sez.~\ref{sec:file_chmod}).\\
+ \const{CAP\_IPC\_LOCK} & la capacità di effettuare il \textit{memory
+ locking} \itindex{memory~locking} con le
+ funzioni \func{mlock}, \func{mlockall},
+ \func{shmctl}, \func{mmap} (vedi
+ sez.~\ref{sec:proc_mem_lock} e
+ sez.~\ref{sec:file_memory_map}). \\
+ \const{CAP\_IPC\_OWNER} & la capacità di evitare il controllo dei permessi
+ per le operazioni sugli oggetti di
+ intercomunicazione fra processi (vedi
+ sez.~\ref{sec:ipc_sysv}).\\
+ \const{CAP\_KILL} & la capacità di mandare segnali a qualunque
+ processo (vedi sez.~\ref{sec:sig_kill_raise}).\\
+ \const{CAP\_LEASE} & la capacità di creare dei \textit{file lease}
+ \index{file!lease} su di un file (vedi
+ sez.~\ref{sec:file_asyncronous_lease})
+ indipendentemente dalla proprietà dello
+ stesso.\footnotemark\\
+ \const{CAP\_LINUX\_IMMUTABLE}& la capacità di impostare gli attributi
+ \textit{immutable} e \textit{append only} per i
+ file su un filesystem che supporta questi
+ attributi estesi.\\
+ \const{CAP\_MKNOD} & la capacità di creare file di dispositivo con la
+ funzione \func{mknod} (vedi
+ sez.~\ref{sec:file_mknod}).\footnotemark\\
+ \const{CAP\_NET\_ADMIN} & la capacità di eseguire alcune operazioni
+ privilegiate sulla rete (impostare le opzioni
+ privilegiate dei socket, abilitare il
+ multicasting, impostare interfacce di rete e
+ tabella di instradamento).\\
+ \const{CAP\_NET\_BIND\_SERVICE}& la capacità di porre in ascolto server
+ su porte riservate (vedi
+ sez.~\ref{sec:TCP_func_bind}).\\
+ \const{CAP\_NET\_BROADCAST}& la capacità di consentire l'uso di socket in
+ broadcast e multicast.\\
+ \const{CAP\_NET\_RAW} & la capacità di usare socket \texttt{RAW} e
+ \texttt{PACKET} (quelli che permettono di creare
+ pacchetti nei protocolli di basso livello).\\
+ \const{CAP\_SETGID} & la capacità di manipolare i group ID dei
+ processi, sia il principale che i supplementari,
+ (vedi sez.~\ref{sec:proc_setgroups} che quelli
+ trasmessi tramite i \index{socket} socket
+ \textit{unix domain} (vedi
+ sez.~\ref{sec:unix_socket}).\\
+ \const{CAP\_SETPCAP} & la capacità di impostare o rimuovere una capacità
+ (limitatamente a quelle che il processo
+ chiamante ha nel suo insieme di capacità
+ permesse) da qualunque processo.\\
+ \const{CAP\_SETUID} & la capacità di manipolare gli user ID del
+ processo (e trasmettere un valore arbitrario
+ tramite i socket unix domain).\\
+ \const{CAP\_SYS\_ADMIN} & la capacità di eseguire una serie di compiti
+ amministrativi (come impostare le quote,
+ attivare e disattivare la swap, montare,
+ rimontare e smontare filesystem, ecc.). \\
+ \const{CAP\_SYS\_BOOT} & la capacità di fare eseguire un reboot del
+ sistema.\\
+ \const{CAP\_SYS\_CHROOT}& la capacità di eseguire la funzione
+ \func{chroot} (vedi
+ sez.~\ref{sec:file_chroot}).\\
+ \const{CAP\_SYS\_MODULE}& la capacità di caricare e rimuovere moduli del
+ kernel. \\
+ \const{CAP\_SYS\_NICE} & la capacità di modificare le priorità dei
+ processi (vedi sez.~\ref{sec:proc_priority}). \\
+ \const{CAP\_SYS\_PACCT} & la capacità di usare le funzioni di
+ \textit{accounting} dei processi (vedi
+ sez.~\ref{sec:sys_bsd_accounting}).\\
+ \const{CAP\_SYS\_RAWIO} & la capacità di eseguire operazioni sulle porte
+ di I/O con \func{ioperm} e \func{iopl} (vedi
+ sez.~\ref{sec:file_io_port}).\\
+ \const{CAP\_SYS\_RESOURCE}& la capacità di superare le limitazioni sulle
+ risorse, aumentare le quote disco, usare lo
+ spazio disco riservato all'amministratore.\\
+ \const{CAP\_SYS\_TIME} & la capacità di modificare il tempo di sistema
+ (vedi sez.~\ref{sec:sys_time}).\\
+ \const{CAP\_SYS\_TTY\_CONFIG}& la capacità di simulare un \textit{hangup}
+ della console, con la funzione
+ \func{vhangup}.\\
+ \const{CAP\_SYS\_PTRACE}& consente di tracciare qualunque processo con
+ \func{ptrace} (vedi
+ sez.~\ref{sec:xxx_ptrace}).\\
+% TODO documentatare ptrace
+ \hline
+ \end{tabular}
+ \caption{Le costanti che identificano le \textit{capabilities} presenti nel
+ kernel.}
+\label{tab:proc_capabilities}
+\end{table}
+
+\footnotetext{questa capacità è presente soltato a partire dai kernel della
+ serie 2.4.x.}
+
+\footnotetext{questa capacità è presente soltato a partire dai kernel della
+ serie 2.4.x.}
+
+
+L'utilizzo di tre distinti insiemi serve a fornire una interfaccia flessibile
+per l'uso delle \textit{capabilities}, con scopi analoghi a quelli per cui
+sono mantenuti i diversi insiemi di identificatori di
+sez.~\ref{sec:proc_setuid}; il loro significato è il seguente:
+\begin{basedescript}{\desclabelwidth{2.0cm}\desclabelstyle{\nextlinelabel}}
+\item[\textit{effective}] l'insieme delle \textit{capabilities}
+ ``\textsl{effettive}'', cioè quelle che vengono effettivamente usate dal
+ kernel per eseguire il controllo di accesso per le operazioni compiute dal
+ processo.
+\item[\textit{permitted}] l'insieme delle \textit{capabilities}
+ ``\textsl{permesse}'', cioè l'insieme di quelle che un processo \textsl{può}
+ impostare come \textsl{effettive} se ha la capacità \const{CAP\_SETPCAP}. Se
+ un processo cancella una capacità da questo insieme non potrà più
+ riassumerla (almeno che non esegua un programma che è \acr{suid} di root).
+\item[\textit{inherited}] l'insieme delle \textit{capabilities}
+ \textsl{ereditate}, cioè quelle che vengono trasmesse ad un nuovo programma
+ eseguito attraverso una chiamata ad \func{exec} (con l'eccezione del caso
+ che questo sia \acr{suid} di root).
+\end{basedescript}
+
+
+Oltre a questi tre insiemi relativi al singolo processo il kernel mantiene un
+valore generale per tutto il sistema, chiamato
+\index{capabilities~bounding~set} \textit{capabilities bounding set}. Questo
+è un parametro di sistema, accessibile attraverso il contenuto del file
+\file{/proc/sys/kernel/cap-bound}, che consente di impostare un limite
+generale alle capacità che possono essere accordate ai vari processi.
+
+Il meccanismo prevede infatti che nell'esecuzione di una \func{exec} venga
+utilizzato il valore mantenuto nell'insieme \textit{inherited} per
+inizializzare tutti gli insiemi
+
+
+
+vengano
+impostati come valori per le \textit{capabilities} (per tutti e tre gli
+insiemi) del nuovo programma quelle
+
+
+
+
+
+
+
+
+\itindend{capabilities}
+
+
\section{La gestione della priorità di esecuzione}
\label{sec:proc_priority}
In questa sezione tratteremo più approfonditamente i meccanismi con il quale
-lo \textit{scheduler}\index{\textit{scheduler}} assegna la CPU ai vari
-processi attivi. In particolare prenderemo in esame i vari meccanismi con cui
-viene gestita l'assegnazione del tempo di CPU, ed illustreremo le varie
-funzioni di gestione.
+lo \textit{scheduler}\itindex{scheduler} assegna la CPU ai vari processi
+attivi. In particolare prenderemo in esame i vari meccanismi con cui viene
+gestita l'assegnazione del tempo di CPU, ed illustreremo le varie funzioni di
+gestione.
\subsection{I meccanismi di \textit{scheduling}}
\label{sec:proc_sched}
+\itindbeg{scheduler}
La scelta di un meccanismo che sia in grado di distribuire in maniera efficace
il tempo di CPU per l'esecuzione dei processi è sempre una questione delicata,
ed oggetto di numerose ricerche; in generale essa dipende in maniera
cui non esiste un meccanismo che sia valido per tutti gli usi.
La caratteristica specifica di un sistema multitasking come Linux è quella del
-cosiddetto \textit{prehemptive multitasking}: questo significa che al
-contrario di altri sistemi (che usano invece il cosiddetto \textit{cooperative
+cosiddetto \itindex{prehemptive~multitasking}\textit{prehemptive
+ multitasking}: questo significa che al contrario di altri sistemi (che usano
+invece il cosiddetto \itindex{cooperative~multitasking}\textit{cooperative
multitasking}) non sono i singoli processi, ma il kernel stesso a decidere
quando la CPU deve essere passata ad un altro processo. Come accennato in
sez.~\ref{sec:proc_hierarchy} questa scelta viene eseguita da una sezione
-apposita del kernel, lo \textit{scheduler}\index{\textit{scheduler}}, il cui
-scopo è quello di distribuire al meglio il tempo di CPU fra i vari processi.
+apposita del kernel, lo \textit{scheduler}, il cui scopo è quello di
+distribuire al meglio il tempo di CPU fra i vari processi.
La cosa è resa ancora più complicata dal fatto che con le architetture
multi-processore si deve anche scegliere quale sia la CPU più opportuna da
essere eseguito, e quando un processo potrà subentrare ad un altro
nell'esecuzione.
-Il meccanismo usato da Linux è piuttosto semplice, ad ogni processo è
-assegnata una \textit{time-slice}, cioè un intervallo di tempo (letteralmente
-una fetta) per il quale esso deve essere eseguito. Il valore della
-\textit{time-slice} è controllato dalla cosiddetta \textit{nice} (o
-\textit{niceness}) del processo. Essa è contenuta nel campo \var{nice} di
-\struct{task\_struct}; tutti i processi vengono creati con lo stesso valore,
-ed essa specifica il valore della durata iniziale della \textit{time-slice}
-che viene assegnato ad un altro campo della struttura (\var{counter}) quando
-il processo viene eseguito per la prima volta e diminuito progressivamente ad
-ogni interruzione del timer.
-
-Durante la sua esecuzione lo scheduler\index{\textit{scheduler}} scandisce la
-coda dei processi in stato \textit{runnable} associando, in base al valore di
-\var{counter}, un peso ad ogni processo in attesa di esecuzione,\footnote{il
- calcolo del peso in realtà è un po' più complicato, ad esempio nei sistemi
- multiprocessore viene favorito un processo eseguito sulla stessa CPU, e a
- parità del valore di \var{counter} viene favorito chi ha una priorità più
- elevata.} chi ha il peso più alto verrà posto in esecuzione, ed il
-precedente processo sarà spostato in fondo alla coda. Dato che ad ogni
-interruzione del timer il valore di \var{counter} del processo corrente viene
-diminuito, questo assicura che anche i processi con priorità più bassa
-verranno messi in esecuzione.
+Il meccanismo usato da Linux è piuttosto semplice,\footnote{in realtà nella
+ serie 2.6.x lo scheduler è stato riscritto da zero e può usare diversi
+ algoritmi, selezionabili sia in fase di compilazione, che, nelle versioni
+ più recenti, all'avvio (addirittura è stato ideato un sistema modulare che
+ permette di cambiare lo scheduler al volo, che comunque non è incluso nel
+ kernel ufficiale).} ad ogni processo è assegnata una \textit{time-slice},
+cioè un intervallo di tempo (letteralmente una fetta) per il quale esso deve
+essere eseguito. Il valore della \textit{time-slice} è controllato dalla
+cosiddetta \textit{nice} (o \textit{niceness}) del processo. Essa è contenuta
+nel campo \var{nice} di \struct{task\_struct}; tutti i processi vengono creati
+con lo stesso valore, ed essa specifica il valore della durata iniziale della
+\textit{time-slice} che viene assegnato ad un altro campo della struttura
+(\var{counter}) quando il processo viene eseguito per la prima volta e
+diminuito progressivamente ad ogni interruzione del timer.
+
+Durante la sua esecuzione lo scheduler scandisce la coda dei processi in stato
+\textit{runnable} associando, in base al valore di \var{counter}, un peso ad
+ogni processo in attesa di esecuzione,\footnote{il calcolo del peso in realtà
+ è un po' più complicato, ad esempio nei sistemi multiprocessore viene
+ favorito un processo eseguito sulla stessa CPU, e a parità del valore di
+ \var{counter} viene favorito chi ha una priorità più elevata.} chi ha il
+peso più alto verrà posto in esecuzione, ed il precedente processo sarà
+spostato in fondo alla coda. Dato che ad ogni interruzione del timer il
+valore di \var{counter} del processo corrente viene diminuito, questo assicura
+che anche i processi con priorità più bassa verranno messi in esecuzione.
La priorità di un processo è così controllata attraverso il valore di
\var{nice}, che stabilisce la durata della \textit{time-slice}; per il
\param{which} & \param{who} & \textbf{Significato} \\
\hline
\hline
- \const{PRIO\_PROCESS} & \type{pid\_t} & processo \\
- \const{PRIO\_PRGR} & \type{pid\_t} & process group \\
- \const{PRIO\_USER} & \type{uid\_t} & utente \\
+ \const{PRIO\_PROCESS} & \type{pid\_t} & processo \\
+ \const{PRIO\_PRGR} & \type{pid\_t} & \itindex{process~group}
+ \textit{process group} \\
+ \const{PRIO\_USER} & \type{uid\_t} & utente \\
\hline
\end{tabular}
\caption{Legenda del valore dell'argomento \param{which} e del tipo
Adeos gestiti dalle code del nano-kernel), in modo da poterli controllare
direttamente qualora ci sia la necessità di avere un processo con priorità
più elevata di un \textit{interrupt handler}.} mentre con l'incorrere in un
-page fault\index{\textit{page~fault}} si possono avere ritardi non previsti.
+\textit{page fault}\itindex{page~fault} si possono avere ritardi non previsti.
Se l'ultimo problema può essere aggirato attraverso l'uso delle funzioni di
controllo della memoria virtuale (vedi sez.~\ref{sec:proc_mem_lock}), il primo
non è superabile e può comportare ritardi non prevedibili riguardo ai tempi di
cui si sia assegnata la massima priorità assoluta, in modo da poter essere
comunque in grado di rientrare nel sistema.
-Quando c'è un processo con priorità assoluta lo
-scheduler\index{\textit{scheduler}} lo metterà in esecuzione prima di ogni
-processo normale. In caso di più processi sarà eseguito per primo quello con
-priorità assoluta più alta. Quando ci sono più processi con la stessa priorità
-assoluta questi vengono tenuti in una coda e tocca al kernel decidere quale
-deve essere eseguito. Il meccanismo con cui vengono gestiti questi processi
-dipende dalla politica di scheduling che si è scelto; lo standard ne prevede
-due:
+Quando c'è un processo con priorità assoluta lo scheduler lo metterà in
+esecuzione prima di ogni processo normale. In caso di più processi sarà
+eseguito per primo quello con priorità assoluta più alta. Quando ci sono più
+processi con la stessa priorità assoluta questi vengono tenuti in una coda e
+tocca al kernel decidere quale deve essere eseguito. Il meccanismo con cui
+vengono gestiti questi processi dipende dalla politica di scheduling che si è
+scelta; lo standard ne prevede due:
\begin{basedescript}{\desclabelwidth{1.2cm}\desclabelstyle{\nextlinelabel}}
\item[\textit{FIFO}] \textit{First In First Out}. Il processo viene eseguito
- fintanto che non cede volontariamente la CPU, si blocca, finisce o viene
- interrotto da un processo a priorità più alta.
-\item[\textit{RR}] \textit{Round Robin}. Ciascun processo viene eseguito a
- turno per un certo periodo di tempo (una \textit{time slice}). Solo i
- processi con la stessa priorità ed in stato \textit{runnable} entrano nel
- circolo.
+ fintanto che non cede volontariamente la CPU (con \func{sched\_yield}), si
+ blocca, finisce o viene interrotto da un processo a priorità più alta. Se il
+ processo viene interrotto da uno a priorità più alta esso resterà in cima
+ alla lista e sarà il primo ad essere eseguito quando i processi a priorità
+ più alta diverranno inattivi. Se invece lo si blocca volontariamente sarà
+ posto in coda alla lista (ed altri processi con la stessa priorità potranno
+ essere eseguiti).
+\item[\textit{RR}] \textit{Round Robin}. Il comportamento è del tutto analogo
+ a quello precedente, con la sola differenza che ciascun processo viene
+ eseguito al massimo per un certo periodo di tempo (la cosiddetta
+ \textit{time slice}) dopo di che viene automaticamente posto in fondo alla
+ coda dei processi con la stessa priorità. In questo modo si ha comunque una
+ esecuzione a turno di tutti i processi, da cui il nome della politica. Solo
+ i processi con la stessa priorità ed in stato \textit{runnable} entrano nel
+ \textsl{girotondo}.
\end{basedescript}
La funzione per impostare le politiche di scheduling (sia real-time che
\begin{table}[htb]
\centering
\footnotesize
- \begin{tabular}[c]{|c|l|}
+ \begin{tabular}[c]{|l|l|}
\hline
\textbf{Policy} & \textbf{Significato} \\
\hline
\const{SCHED\_OTHER}& Scheduling ordinario\\
\hline
\end{tabular}
- \caption{Valori dell'argomento \param{policy} per la funzione
- \func{sched\_setscheduler}. }
+ \caption{Valori dell'argomento \param{policy} per la funzione
+ \func{sched\_setscheduler}.}
\label{tab:proc_sched_policy}
\end{table}
\struct{sched\_param} (riportata in fig.~\ref{fig:sig_sched_param}), il cui
solo campo attualmente definito è \var{sched\_priority}, che nel caso delle
priorità assolute deve essere specificato nell'intervallo fra un valore
-massimo ed uno minimo, che nel caso sono rispettivamente 1 e 99 (il valore
-zero è legale, ma indica i processi normali).
+massimo ed uno minimo, che nel caso sono rispettivamente 1 e 99; il valore
+nullo è legale, ma indica i processi normali.
\begin{figure}[!bht]
\footnotesize \centering
\label{fig:sig_sched_param}
\end{figure}
+Si tenga presente che quando si imposta una politica di scheduling real-time
+per un processo (o se ne cambia la priorità con \func{sched\_setparam}) questo
+viene messo in cima alla lista dei processi con la stessa priorità; questo
+comporta che verrà eseguito subito, interrompendo eventuali altri processi con
+la stessa priorità in quel momento in esecuzione.
+
Lo standard POSIX.1b prevede comunque che i due valori della massima e minima
priorità statica possano essere ottenuti, per ciascuna delle politiche di
-scheduling realtime, tramite le due funzioni \funcd{sched\_get\_priority\_max}
-e \funcd{sched\_get\_priority\_min}, i cui prototipi sono:
+scheduling \textit{real-time}, tramite le due funzioni
+\funcd{sched\_get\_priority\_max} e \funcd{sched\_get\_priority\_min}, i cui
+prototipi sono:
\begin{functions}
\headdecl{sched.h}
sarà reinserito in coda alla lista); l'esecuzione viene ripresa subito solo
nel caso che esso sia stato interrotto da un processo a priorità più alta.
-La priorità assoluta può essere riletta indietro dalla funzione
-\funcd{sched\_getscheduler}, il cui prototipo è:
-\begin{prototype}{sched.h}
-{int sched\_getscheduler(pid\_t pid)}
- Legge la politica di scheduling per il processo \param{pid}.
-
- \bodydesc{La funzione ritorna la politica di scheduling in caso di successo
- e -1 in caso di errore, nel qual caso \var{errno} può assumere i valori:
- \begin{errlist}
- \item[\errcode{ESRCH}] il processo \param{pid} non esiste.
- \item[\errcode{EINVAL}] il valore di \param{pid} è negativo.
- \end{errlist}}
-\end{prototype}
-
-La funzione restituisce il valore (secondo quanto elencato in
-tab.~\ref{tab:proc_sched_policy}) della politica di scheduling per il processo
-specificato; se \param{pid} è nullo viene restituito quello del processo
-chiamante.
-
Se si intende operare solo sulla priorità assoluta di un processo si possono
usare le funzioni \funcd{sched\_setparam} e \funcd{sched\_getparam}, i cui
prototipi sono:
e -1 in caso di errore, nel qual caso \var{errno} può assumere i valori:
\begin{errlist}
\item[\errcode{ESRCH}] il processo \param{pid} non esiste.
- \item[\errcode{EINVAL}] il valore di \param{pid} è negativo.
+ \item[\errcode{EINVAL}] il valore di \param{p} non ha senso per la
+ politica scelta.
+ \item[\errcode{EPERM}] il processo non ha i privilegi sufficienti per
+ eseguire l'operazione.
\end{errlist}}
\end{functions}
\func{sched\_setscheduler} specificando 0 come valore di \param{pid} si opera
sul processo corrente. La disponibilità di entrambe le funzioni può essere
verificata controllando la macro \macro{\_POSIX\_PRIORITY\_SCHEDULING} che è
-definita nell'header \file{sched.h}.
+definita nell'header \file{sched.h}.
+
+Si tenga presente che per eseguire la funzione il processo chiamante deve
+avere un user-ID effettivo uguale all'user-ID reale o a quello effettivo del
+processo di cui vuole cambiare la priorità, oppure deve avere i privilegi di
+amministratore (con la capacità \const{CAP\_SYS\_NICE}).
+
+La priorità assoluta può essere riletta indietro dalla funzione
+\funcd{sched\_getscheduler}, il cui prototipo è:
+\begin{prototype}{sched.h}
+{int sched\_getscheduler(pid\_t pid)}
+ Legge la politica di scheduling per il processo \param{pid}.
+
+ \bodydesc{La funzione ritorna la politica di scheduling in caso di successo
+ e -1 in caso di errore, nel qual caso \var{errno} può assumere i valori:
+ \begin{errlist}
+ \item[\errcode{ESRCH}] il processo \param{pid} non esiste.
+ \item[\errcode{EINVAL}] il valore di \param{pid} è negativo.
+ \end{errlist}}
+\end{prototype}
+
+La funzione restituisce il valore (secondo quanto elencato in
+tab.~\ref{tab:proc_sched_policy}) della politica di scheduling per il processo
+specificato; se \param{pid} è nullo viene restituito quello del processo
+chiamante.
L'ultima funzione che permette di leggere le informazioni relative ai processi
real-time è \funcd{sched\_rr\_get\_interval}, che permette di ottenere la
{int sched\_rr\_get\_interval(pid\_t pid, struct timespec *tp)} Legge in
\param{tp} la durata della \textit{time slice} per il processo \param{pid}.
- \bodydesc{La funzione ritorna 0in caso di successo e -1 in caso di errore,
+ \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
nel qual caso \var{errno} può assumere i valori:
\begin{errlist}
\item[\errcode{ESRCH}] il processo \param{pid} non esiste.
La funzione restituisce il valore dell'intervallo di tempo usato per la
politica \textit{round robin} in una struttura \struct{timespec}, (la cui
-definizione si può trovare in fig.~\ref{fig:sys_timeval_struct}).
+definizione si può trovare in fig.~\ref{fig:sys_timeval_struct}). In realtà
+dato che in Linux questo intervallo di tempo è prefissato e non modificabile,
+questa funzione ritorna sempre un valore di 150 millisecondi, e non importa
+specificare il PID di un processo reale.
Come accennato ogni processo che usa lo scheduling real-time può rilasciare
in modalità \textit{fifo}, per permettere l'esecuzione degli altri processi
con pari priorità quando la sezione più urgente è finita.
+Infine con il supporto dei sistemi multiprocessore sono state introdotte delle
+funzioni che permettono di controllare in maniera più dettagliata la scelta di
+quale processore utilizzare per eseguire un certo programma. Uno dei problemi
+che si pongono nei sistemi multiprocessore è infatti quello
+dell'\textsl{effetto ping-pong}.\index{effetto~ping-pong} Può accadere cioè
+che lo scheduler, quando riavvia un processo precedentemente interrotto,
+scegliendo il primo processore disponibile lo faccia eseguire da un processore
+diverso rispetto a quello su cui era stato eseguito in precedenza. Se il
+processo passa da un processore all'altro in questo modo (cosa che avveniva
+abbastanza di frequente con i kernel della seria 2.4.x) si ha
+l'\textsl{effetto ping-pong}.
+
+Questo tipo di comportamento può generare dei seri problemi di prestazioni;
+infatti tutti i processori moderni utilizzano una memoria interna (la
+\textit{cache}) contenente i dati più usati, che permette di evitare di
+eseguire un accesso (molto più lento) alla memoria principale sulla scheda
+madre. Chiaramente un processo sarà favorito se i suoi dati sono nella cache
+del processore, ma è ovvio che questo può essere vero solo per un processore
+alla volta, perché in presenza di più copie degli stessi dati su più
+processori, non si potrebbe determinare quale di questi ha la versione dei
+dati aggiornata rispetto alla memoria principale.
+
+Questo comporta che quando un processore inserisce un dato nella sua cache,
+tutti gli altri processori che hanno lo stesso dato devono invalidarlo, e
+questa operazione è molto costosa in termini di prestazioni. Il problema
+diventa serio quando si verifica l'\textsl{effetto ping-pong}, in tal caso
+infatti un processo \textsl{rimbalza} continuamente da un processore all'altro
+e si ha una continua invalidazione della cache, che non diventa mai
+disponibile.
+
+\itindbeg{CPU~affinity}
+Per ovviare a questo tipo di problemi è nato il concetto di \textsl{affinità
+ di processore} (o \textit{CPU affinity}); la
+possibilità cioè di far sì che un processo possa essere assegnato per
+l'esecuzione sempre allo stesso processore. Lo scheduler dei kernel della
+serie 2.4.x aveva una scarsa \textit{CPU affinity}, e
+\index{effetto~ping-pong} l'effetto ping-pong era comune; con il nuovo
+scheduler dei kernel della 2.6.x questo problema è stato risolto ed esso cerca
+di mantenere il più possibile ciascun processo sullo stesso processore.
+
+In certi casi però resta l'esigenza di poter essere sicuri che un processo sia
+sempre eseguito dallo stesso processore,\footnote{quella che viene detta
+ \textit{hard CPU affinity}, in contrasto con quella fornita dallo scheduler,
+ detta \textit{soft CPU affinity}, che di norma indica solo una preferenza,
+ non un requisito assoluto.} e per poter risolvere questo tipo di
+problematiche nei nuovi kernel\footnote{le due system call per la gestione
+ della \textit{CPU affinity} sono state introdotte nel kernel 2.5.8, e le
+ funzioni di libreria nelle \textsl{glibc} 2.3.} è stata introdotta
+l'opportuna infrastruttura ed una nuova system call che permette di impostare
+su quali processori far eseguire un determinato processo attraverso una
+\textsl{maschera di affinità}. La corrispondente funzione di libreria è
+\funcd{sched\_setaffinity} ed il suo prototipo\footnote{di questa funzione (e
+ della corrispondente \func{sched\_setaffinity}) esistono versioni diverse
+ per gli argomenti successivi a \param{pid}: la prima (quella riportata nella
+ pagina di manuale) prevedeva due ulteriori argomenti di tipo
+ \texttt{unsigned int len} e \texttt{unsigned long *mask}, poi l'argomento
+ \texttt{len} è stato eliminato, successivamente si è introdotta la versione
+ riportata con però un secondo argomento di tipo \texttt{size\_t cpusetsize}
+ (anche questa citata nella pagina di manuale); la versione citata è quella
+ riportata nel manuale delle \textsl{glibc} e corripondente alla definizione
+ presente in \file{sched.h}.} è:
+\begin{prototype}{sched.h}
+ {int sched\_setaffinity (pid\_t pid, const cpu\_set\_t *cpuset)}
+ Imposta la maschera di affinità del processo \param{pid}.
+
+ \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
+ nel qual caso \var{errno} può assumere i valori:
+ \begin{errlist}
+ \item[\errcode{ESRCH}] il processo \param{pid} non esiste.
+ \item[\errcode{EINVAL}] il valore di \param{cpuset} contiene riferimenti a
+ processori non esistenti nel sistema.
+ \item[\errcode{EPERM}] il processo non ha i privilegi sufficienti per
+ eseguire l'operazione.
+ \end{errlist}
+ ed inoltre anche \errval{EFAULT}.}
+\end{prototype}
+
+La funzione imposta, con l'uso del valore contenuto all'indirizzo
+\param{cpuset}, l'insieme dei processori sui quali deve essere eseguito il
+processo identificato tramite il valore passato in \param{pid}. Come in
+precedenza il valore nullo di \param{pid} indica il processo corrente. Per
+poter utilizzare questa funzione sono richiesti i privilegi di amministratore
+(è necessaria la capacità \const{CAP\_SYS\_NICE}) altrimenti essa fallirà con
+un errore di \errcode{EPERM}. Una volta impostata una maschera di affinità,
+questa viene ereditata attraverso una \func{fork}, in questo modo diventa
+possibile legare automaticamente un gruppo di processi ad un singolo
+processore.
+
+Nell'uso comune, almeno con i kernel della serie 2.6.x, l'uso di questa
+funzione non è necessario, in quanto è lo scheduler stesso che provvede a
+mantenere al meglio l'affinità di processore. Esistono però esigenze
+particolari, ad esempio quando un processo (o un gruppo di processi) è
+utilizzato per un compito importante (ad esempio per applicazioni real-time o
+la cui risposta è critica) e si vuole la massima velocità, con questa
+interfaccia diventa possibile selezionare gruppi di processori utilizzabili in
+maniera esclusiva. Lo stesso dicasi quando l'accesso a certe risorse (memoria
+o periferiche) può avere un costo diverso a seconda del processore (come
+avviene nelle architetture NUMA).
+
+Infine se un gruppo di processi accede alle stesse risorse condivise (ad
+esempio una applicazione con più thread) può avere senso usare lo stesso
+processore in modo da sfruttare meglio l'uso della sua cache; questo
+ovviamente riduce i benefici di un sistema multiprocessore nell'esecuzione
+contemporanea dei thread, ma in certi casi (quando i thread sono inerentemente
+serializzati nell'accesso ad una risorsa) possono esserci sufficienti vantaggi
+nell'evitare la perdita della cache da rendere conveniente l'uso dell'affinità
+di processore.
+
+Per facilitare l'uso dell'argomento \param{cpuset} le \acr{glibc} hanno
+introdotto un apposito dato di tipo, \ctyp{cpu\_set\_t},\footnote{questa è una
+ estensione specifica delle \acr{glibc}, da attivare definendo la macro
+ \macro{\_GNU\_SOURCE}, non esiste infatti una standardardizzazione per
+ questo tipo di interfaccia e POSIX al momento non prevede nulla al
+ riguardo.} che permette di identificare un insieme di processori. Il dato è
+una maschera binaria: in generale è un intero a 32 bit in cui ogni bit
+corrisponde ad un processore, ma dato che per architetture particolari il
+numero di bit di un intero può non essere sufficiente, è stata creata questa
+che è una interfaccia generica che permette di usare a basso livello un tipo
+di dato qualunque rendendosi indipendenti dal numero di bit e dalla loro
+disposizione.
+
+Questa interfaccia, oltre alla definizione del tipo di dato apposito, prevede
+anche una serie di macro di preprocessore per la manipolazione dello stesso,
+che consentono di svuotare un insieme, aggiungere o togliere un processore da
+esso o verificare se vi è già presente:
+\begin{functions}
+ \headdecl{sched.h}
+ \funcdecl{void \macro{CPU\_ZERO}(cpu\_set\_t *set)}
+ Inizializza l'insieme (vuoto).
+
+ \funcdecl{void \macro{CPU\_SET}(int cpu, cpu\_set\_t *set)}
+ Inserisce il processore \param{cpu} nell'insieme.
+
+ \funcdecl{void \macro{CPU\_CLR}(int cpu, cpu\_set\_t *set)}
+ Rimuove il processore \param{cpu} nell'insieme.
+
+ \funcdecl{int \macro{CPU\_ISSET}(int cpu, cpu\_set\_t *set)}
+ Controlla se il processore \param{cpu} è nell'insieme.
+\end{functions}
+
+Oltre a queste macro, simili alle analoghe usate per gli insiemi di file
+descriptor (vedi sez.~\ref{sec:file_select}) è definita la costante
+\const{CPU\_SETSIZE} che indica il numero massimo di processori che possono
+far parte dell'insieme, e che costituisce un limite massimo al valore
+dell'argomento \param{cpu}.
+
+In generale la maschera di affinità è preimpostata in modo che un processo
+possa essere eseguito su qualunque processore, se può comunque leggere il
+valore per un processo specifico usando la funzione
+\funcd{sched\_getaffinity}, il suo prototipo è:
+\begin{prototype}{sched.h}
+ {int sched\_getaffinity (pid\_t pid, const cpu\_set\_t *cpuset)}
+ Legge la maschera di affinità del processo \param{pid}.
+
+ \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
+ nel qual caso \var{errno} può assumere i valori:
+ \begin{errlist}
+ \item[\errcode{ESRCH}] il processo \param{pid} non esiste.
+ \item[\errcode{EFAULT}] il valore di \param{cpuset} non è un indirizzo
+ valido.
+ \end{errlist} }
+\end{prototype}
+
+La funzione restituirà all'indirizzo specificato da \param{cpuset} il valore
+della maschera di affinità del processo, così da poterla riutilizzare per una
+successiva reimpostazione. In questo caso non sono necessari privilegi
+paricolari.
+
+È chiaro che queste funzioni per la gestione dell'affinità hanno significato
+soltanto su un sistema multiprocessore, esse possono comunque essere
+utilizzate anche in un sistema con un processore singolo, nel qual caso però
+non avranno alcun risultato effettivo.
+\itindend{scheduler}
+\itindend{CPU~affinity}
+
+
\section{Problematiche di programmazione multitasking}
\label{sec:proc_multi_prog}
In un ambiente multitasking il concetto è essenziale, dato che un processo può
essere interrotto in qualunque momento dal kernel che mette in esecuzione un
altro processo o dalla ricezione di un segnale; occorre pertanto essere
-accorti nei confronti delle possibili
-\textit{race condition}\index{\textit{race~condition}} (vedi
-sez.~\ref{sec:proc_race_cond}) derivanti da operazioni interrotte in una fase
-in cui non erano ancora state completate.
+accorti nei confronti delle possibili \textit{race
+ condition}\itindex{race~condition} (vedi sez.~\ref{sec:proc_race_cond})
+derivanti da operazioni interrotte in una fase in cui non erano ancora state
+completate.
Nel caso dell'interazione fra processi la situazione è molto più semplice, ed
occorre preoccuparsi della atomicità delle operazioni solo quando si ha a che
\subsection{Le \textit{race condition} ed i \textit{deadlock}}
\label{sec:proc_race_cond}
-\index{\textit{race~condition}|(}
+\itindbeg{race~condition}
Si definiscono \textit{race condition} tutte quelle situazioni in cui processi
diversi operano su una risorsa comune, ed in cui il risultato viene a
dipendere dall'ordine in cui essi effettuano le loro operazioni. Il caso
opportunamente protette da meccanismi di sincronizzazione (torneremo su queste
problematiche di questo tipo in cap.~\ref{cha:IPC}).
-\index{\textit{deadlock}|(}
+\itindbeg{deadlock}
Un caso particolare di \textit{race condition} sono poi i cosiddetti
\textit{deadlock}, particolarmente gravi in quanto comportano spesso il blocco
completo di un servizio, e non il fallimento di una singola operazione. Per
visto in sez.~\ref{sec:proc_atom_oper}; questi problemi infatti possono essere
risolti soltanto assicurandosi, quando essa sia richiesta, che sia possibile
eseguire in maniera atomica le operazioni necessarie.
-\index{\textit{race~condition}|)}
-\index{\textit{deadlock}|)}
+\itindend{race~condition}
+\itindend{deadlock}
\subsection{Le funzioni rientranti}
delle funzioni all'interno dei gestori dei segnali.
Fintanto che una funzione opera soltanto con le variabili locali è rientrante;
-queste infatti vengono allocate nello stack, e un'altra invocazione non fa
-altro che allocarne un'altra copia. Una funzione può non essere rientrante
-quando opera su memoria che non è nello stack. Ad esempio una funzione non è
-mai rientrante se usa una variabile globale o statica.
+queste infatti vengono allocate nello \itindex{stack} stack, e un'altra
+invocazione non fa altro che allocarne un'altra copia. Una funzione può non
+essere rientrante quando opera su memoria che non è nello \itindex{stack}
+stack. Ad esempio una funzione non è mai rientrante se usa una variabile
+globale o statica.
Nel caso invece la funzione operi su un oggetto allocato dinamicamente, la
cosa viene a dipendere da come avvengono le operazioni: se l'oggetto è creato
projects / gapil.git / blobdiff