qualunque processo può a sua volta generarne altri, detti processi figli
(\textit{child process}). Ogni processo è identificato presso il sistema da un
numero univoco, il cosiddetto \textit{process identifier} o, più brevemente,
-\acr{pid}, assengnato in forma progressiva (vedi \secref{sec:proc_pid}) quando
+\acr{pid}, assegnato in forma progressiva (vedi \secref{sec:proc_pid}) quando
il processo viene creato.
Una seconda caratteristica di un sistema Unix è che la generazione di un
\label{sec:proc_pid}
Come accennato nell'introduzione, ogni processo viene identificato dal sistema
-da un numero identificativo univoco, il \textit{process id} o \acr{pid};
+da un numero identificativo univoco, il \textit{process ID} o \acr{pid};
quest'ultimo è un tipo di dato standard, il \type{pid\_t} che in genere è un
intero con segno (nel caso di Linux e delle \acr{glibc} il tipo usato è
\ctyp{int}).
Tutti i processi inoltre memorizzano anche il \acr{pid} del genitore da cui
sono stati creati, questo viene chiamato in genere \acr{ppid} (da
-\textit{parent process id}). Questi due identificativi possono essere
+\textit{parent process ID}). Questi due identificativi possono essere
ottenuti usando le due funzioni \funcd{getpid} e \funcd{getppid}, i cui
prototipi sono:
\begin{functions}
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 seccessiva alla \func{fork}; il processo figlio è però una
+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
\secref{sec:proc_mem_layout}), ed esegue esattamente lo stesso codice del
padre. Si tenga presente però che la memoria è copiata, non condivisa,
alla conclusione del ciclo, prima di uscire, può essere specificato un altro
periodo di attesa.
-Se eseguiamo il comando senza specificare attese (come si può notare in
-\texttt{\small 17--19} i valori predefiniti specificano di non attendere),
-otterremo come output sul terminale:
+Se eseguiamo il comando\footnote{che è preceduto dall'istruzione \code{export
+ LD\_LIBRARY\_PATH=./} per permettere l'uso delle librerie dinamiche.}}
+senza specificare attese (come si può notare in (\texttt{\small 17--19}) i
+valori predefiniti specificano di non attendere), otterremo come output sul
+terminale:
\footnotesize
\begin{verbatim}
-[piccardi@selidor sources]$ ./forktest 3
+[piccardi@selidor sources]$ export LD_LIBRARY_PATH=./; ./forktest 3
Process 1963: forking 3 child
Spawned 1 child, pid 1964
Child 1 successfully executing
\item i file aperti e gli eventuali flag di
\textit{close-on-exec}\index{close-on-exec} impostati (vedi
\secref{sec:proc_exec} e \secref{sec:file_fcntl}).
-\item gli identificatori per il controllo di accesso: l'\textsl{userid reale},
- il \textsl{groupid reale}, l'\textsl{userid effettivo}, il \textsl{groupid
- effettivo} ed i \textit{groupid supplementari} (vedi
+\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
\secref{sec:proc_access_id}).
\item gli identificatori per il controllo di sessione: il \textit{process
- groupid} e il \textit{session id} ed il terminale di controllo (vedi
+ group-ID} e il \textit{session id} ed il terminale di controllo (vedi
\secref{sec:sess_proc_group}).
\item la directory di lavoro e la directory radice (vedi
\secref{sec:file_work_dir} e \secref{sec:file_chroot}).
\begin{itemize*}
\item il \textit{process id} (\acr{pid}) ed il \textit{parent process id}
(\acr{ppid}).
-\item l'\textsl{userid reale}, il \textit{groupid reale} ed i \textsl{groupid
- supplementari} (vedi \secref{sec:proc_access_id}).
-\item il \textit{session id} (\acr{sid}) ed il \textit{process groupid}
+\item l'\textsl{user-ID reale}, il \textit{group-ID reale} ed i
+ \textsl{group-ID supplementari} (vedi \secref{sec:proc_access_id}).
+\item il \textit{session id} (\acr{sid}) ed il \textit{process group-ID}
(\acr{pgid}), vedi \secref{sec:sess_proc_group}.
\item il terminale di controllo (vedi \secref{sec:sess_ctrl_term}).
\item il tempo restante ad un allarme (vedi \secref{sec:sig_alarm_abort}).
l'impostazione del flag di \textit{close-on-exec}\index{close-on-exec} sulle
directory che apre, in maniera trasparente all'utente.
-Abbiamo detto che l'\textsl{userid reale} ed il \textsl{groupid reale} restano
-gli stessi all'esecuzione di \func{exec}; lo stesso vale per l'\textsl{userid
- effettivo} ed il \textsl{groupid effettivo} (il significato di questi
-identificatori è trattato in \secref{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{userid effettivo} ed il \textsl{groupid
- effettivo} vengono impostati rispettivamente all'utente o al gruppo cui il
-file appartiene (per i dettagli vedi \secref{sec:proc_perms}).
+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 \secref{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 \secref{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
o il \textit{Mandatory Access Control} 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}, ol LSM, in grado di fornire diversi agganci a livello del kernel
+ Modules}, o LSM, in grado di fornire diversi agganci a livello del kernel
per modularizzare tutti i possibili controlli di accesso.} di sicurezza di
un sistema unix-like è fondato sui concetti di utente e gruppo, e sulla
separazione fra l'amministratore (\textsl{root}, detto spesso anche
%notevole flessibilità,
Abbiamo già accennato come il sistema associ ad ogni utente e gruppo due
-identificatori univoci, lo userid ed il groupid; questi servono al kernel per
+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
controllare che essi siano autorizzati a compiere le operazioni richieste. Ad
esempio in \secref{sec:file_access_control} vedremo come ad ogni file vengano
& \textbf{Significato} \\
\hline
\hline
- \acr{uid} & \textit{real} & \textsl{userid reale}
+ \acr{uid} & \textit{real} & \textsl{user-ID reale}
& indica l'utente che ha lanciato il programma\\
- \acr{gid} & '' &\textsl{groupid reale}
+ \acr{gid} & '' &\textsl{group-ID reale}
& indica il gruppo principale dell'utente che ha lanciato
il programma \\
\hline
- \acr{euid} & \textit{effective} &\textsl{userid effettivo}
+ \acr{euid} & \textit{effective} &\textsl{user-ID effettivo}
& indica l'utente usato nel controllo di accesso \\
- \acr{egid} & '' & \textsl{groupid effettivo}
+ \acr{egid} & '' & \textsl{group-ID effettivo}
& indica il gruppo usato nel controllo di accesso \\
- -- & -- & \textsl{groupid supplementari}
+ -- & -- & \textsl{group-ID supplementari}
& indicano gli ulteriori gruppi cui l'utente appartiene \\
\hline
- -- & \textit{saved} & \textsl{userid salvato}
+ -- & \textit{saved} & \textsl{user-ID salvato}
& è una copia dell'\acr{euid} iniziale\\
- -- & '' & \textsl{groupid salvato}
+ -- & '' & \textsl{group-ID salvato}
& è una copia dell'\acr{egid} iniziale \\
\hline
- \acr{fsuid} & \textit{filesystem} &\textsl{userid di filesystem}
+ \acr{fsuid} & \textit{filesystem} &\textsl{user-ID di filesystem}
& indica l'utente effettivo per l'accesso al filesystem \\
- \acr{fsgid} & '' & \textsl{groupid di filesystem}
+ \acr{fsgid} & '' & \textsl{group-ID di filesystem}
& indica il gruppo effettivo per l'accesso al filesystem \\
\hline
\end{tabular}
\label{tab:proc_uid_gid}
\end{table}
-Al primo gruppo appartengono l'\textsl{userid reale} ed il \textsl{groupid
+Al primo gruppo appartengono l'\textsl{user-ID reale} ed il \textsl{group-ID
reale}: questi vengono impostati al login ai valori corrispondenti
all'utente con cui si accede al sistema (e relativo gruppo principale).
Servono per l'identificazione dell'utente e normalmente non vengono mai
imposta questi identificatori ai valori corrispondenti all'utente che entra
nel sistema.
-Al secondo gruppo appartengono lo \textsl{userid effettivo} ed il
-\textsl{groupid effettivo} (a cui si aggiungono gli eventuali \textsl{groupid
+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
controllo di accesso ai file (argomento affrontato in dettaglio in
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 opportune funzioni:
+identificatori possono essere letti attraverso le rispettive funzioni:
\funcd{getuid}, \funcd{geteuid}, \funcd{getgid} e \funcd{getegid}, i loro
prototipi sono:
\begin{functions}
\headdecl{unistd.h}
\headdecl{sys/types.h}
- \funcdecl{uid\_t getuid(void)} Restituisce l'\textsl{userid reale} del
+ \funcdecl{uid\_t getuid(void)} Restituisce l'\textsl{user-ID reale} del
processo corrente.
- \funcdecl{uid\_t geteuid(void)} Restituisce l'\textsl{userid effettivo} del
+ \funcdecl{uid\_t geteuid(void)} Restituisce l'\textsl{user-ID effettivo} del
processo corrente.
- \funcdecl{gid\_t getgid(void)} Restituisce il \textsl{groupid reale} del
+ \funcdecl{gid\_t getgid(void)} Restituisce il \textsl{group-ID reale} del
processo corrente.
- \funcdecl{gid\_t getegid(void)} Restituisce il \textsl{groupid effettivo}
+ \funcdecl{gid\_t getegid(void)} Restituisce il \textsl{group-ID effettivo}
del processo corrente.
\bodydesc{Queste funzioni non riportano condizioni di errore.}
definita.} il secondo gruppo è specifico di Linux e viene usato per
migliorare la sicurezza con NFS.
-L'\textsl{userid salvato} ed il \textsl{groupid salvato} sono copie
-dell'\textsl{userid effettivo} e del \textsl{groupid effettivo} del processo
+L'\textsl{user-ID salvato} ed il \textsl{group-ID salvato} sono copie
+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{userid effettivo} e del \textsl{groupid effettivo}
+come copie dell'\textsl{user-ID effettivo} e del \textsl{group-ID effettivo}
dopo che questo 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.
-L'\textsl{userid di filesystem} e il \textsl{groupid di filesystem} sono
+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 \secref{sec:proc_setfsuid}). Essi sono una
replica dei corrispondenti identificatori del gruppo \textit{effective}, ai
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 \secref{sec:proc_access_id} in Linux esse
-seguono la semantica POSIX che prevede l'esistenza dell'\textit{userid
- salvato} e del \textit{groupid salvato}; i loro prototipi sono:
+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}
-\funcdecl{int setuid(uid\_t uid)} Imposta l'\textsl{userid} del processo
+\funcdecl{int setuid(uid\_t uid)} Imposta l'\textsl{user-ID} del processo
corrente.
-\funcdecl{int setgid(gid\_t gid)} Imposta il \textsl{groupid} del processo
+\funcdecl{int setgid(gid\_t gid)} Imposta il \textsl{group-ID} del processo
corrente.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
Il funzionamento di queste due funzioni è analogo, per cui considereremo solo
la prima; la seconda si comporta esattamente allo stesso modo facendo
-riferimento al \textsl{groupid} invece che all'\textsl{userid}. Gli
-eventuali \textsl{groupid supplementari} non vengono modificati.
+riferimento al \textsl{group-ID} invece che all'\textsl{user-ID}. Gli
+eventuali \textsl{group-ID supplementari} non vengono modificati.
L'effetto della chiamata è diverso a seconda dei privilegi del processo; se
-l'\textsl{userid effettivo} è zero (cioè è quello dell'amministratore di
+l'\textsl{user-ID effettivo} è zero (cioè è quello dell'amministratore di
sistema) allora tutti gli identificatori (\textit{real}, \textit{effective} e
\textit{saved}) vengono impostati al valore specificato da \param{uid},
-altrimenti viene impostato solo l'\textsl{userid effettivo}, e soltanto se il
-valore specificato corrisponde o all'\textsl{userid reale} o
-all'\textsl{userid salvato}. Negli altri casi viene segnalato un errore (con
+altrimenti viene impostato solo l'\textsl{user-ID effettivo}, e soltanto se il
+valore specificato corrisponde o all'\textsl{user-ID reale} o
+all'\textsl{user-ID salvato}. Negli altri casi viene segnalato un errore (con
\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
-\secref{sec:file_suid_sgid}) di riportare l'\textsl{userid effettivo} a quello
+\secref{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.
situazione degli identificatori è la seguente:
\begin{eqnarray*}
\label{eq:1}
- \textsl{groupid reale} &=& \textrm{\acr{gid} (del chiamante)} \\
- \textsl{groupid effettivo} &=& \textrm{\acr{utmp}} \\
- \textsl{groupid salvato} &=& \textrm{\acr{utmp}}
+ \textsl{group-ID reale} &=& \textrm{\acr{gid} (del chiamante)} \\
+ \textsl{group-ID effettivo} &=& \textrm{\acr{utmp}} \\
+ \textsl{group-ID salvato} &=& \textrm{\acr{utmp}}
\end{eqnarray*}
-in questo modo, dato che il \textsl{groupid effettivo} è quello giusto, il
+in questo modo, dato che il \textsl{group-ID effettivo} è quello giusto, il
programma può accedere a \file{/var/log/utmp} in scrittura ed aggiornarlo. A
questo punto il programma può eseguire una \code{setgid(getgid())} per
-impostare il \textsl{groupid effettivo} a quello dell'utente (e dato che il
-\textsl{groupid reale} corrisponde la funzione avrà successo), in questo modo
+impostare il \textsl{group-ID effettivo} a quello dell'utente (e dato che il
+\textsl{group-ID reale} corrisponde la funzione avrà successo), in questo modo
non sarà possibile lanciare dal terminale programmi che modificano detto file,
in tal caso infatti la situazione degli identificatori sarebbe:
\begin{eqnarray*}
\label{eq:2}
- \textsl{groupid reale} &=& \textrm{\acr{gid} (invariato)} \\
- \textsl{groupid effettivo} &=& \textrm{\acr{gid}} \\
- \textsl{groupid salvato} &=& \textrm{\acr{utmp} (invariato)}
+ \textsl{group-ID reale} &=& \textrm{\acr{gid} (invariato)} \\
+ \textsl{group-ID effettivo} &=& \textrm{\acr{gid}} \\
+ \textsl{group-ID salvato} &=& \textrm{\acr{utmp} (invariato)}
\end{eqnarray*}
e ogni processo lanciato dal terminale avrebbe comunque \acr{gid} come
-\textsl{groupid effettivo}. All'uscita dal terminale, per poter di nuovo
+\textsl{group-ID effettivo}. All'uscita dal terminale, per poter di nuovo
aggiornare lo stato di \file{/var/log/utmp} il programma eseguirà una
\code{setgid(utmp)} (dove \var{utmp} è il valore numerico associato al gruppo
\acr{utmp}, ottenuto ad esempio con una precedente \func{getegid}), dato che
-in questo caso il valore richiesto corrisponde al \textsl{groupid salvato} la
+in questo caso il valore richiesto corrisponde al \textsl{group-ID salvato} la
funzione avrà successo e riporterà la situazione a:
\begin{eqnarray*}
\label{eq:3}
- \textsl{groupid reale} &=& \textrm{\acr{gid} (invariato)} \\
- \textsl{groupid effettivo} &=& \textrm{\acr{utmp}} \\
- \textsl{groupid salvato} &=& \textrm{\acr{utmp} (invariato)}
+ \textsl{group-ID reale} &=& \textrm{\acr{gid} (invariato)} \\
+ \textsl{group-ID effettivo} &=& \textrm{\acr{utmp}} \\
+ \textsl{group-ID salvato} &=& \textrm{\acr{utmp} (invariato)}
\end{eqnarray*}
consentendo l'accesso a \file{/var/log/utmp}.
rendendo impossibile riguadagnare i privilegi di amministratore. 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{userid effettivo} del processo per cedere i privilegi occorre
+l'\textsl{user-ID effettivo} del processo per cedere i privilegi occorre
ricorrere ad altre funzioni (si veda ad esempio \secref{sec:proc_seteuid}).
-\subsection{Le funzioni \funcd{setreuid} e \funcd{setresuid}}
+\subsection{Le funzioni \func{setreuid} e \func{setresuid}}
\label{sec:proc_setreuid}
Queste due funzioni derivano da BSD che, non supportando\footnote{almeno fino
\headdecl{unistd.h}
\headdecl{sys/types.h}
-\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta l'\textsl{userid
- reale} e l'\textsl{userid effettivo} del processo corrente ai valori
+\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta l'\textsl{user-ID
+ reale} e l'\textsl{user-ID effettivo} del processo corrente ai valori
specificati da \param{ruid} e \param{euid}.
-\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textsl{groupid
- reale} ed il \textsl{groupid effettivo} del processo corrente ai valori
+\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textsl{group-ID
+ reale} ed il \textsl{group-ID effettivo} del processo corrente ai valori
specificati da \param{rgid} e \param{egid}.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
\end{functions}
La due funzioni sono analoghe ed il loro comportamento è identico; quanto
-detto per la prima prima riguardo l'userid, si applica immediatamente alla
-seconda per il groupid. I processi non privilegiati possono impostare solo i
-valori del loro userid effettivo o reale; valori diversi comportano il
+detto per la prima prima riguardo l'user-ID, si applica immediatamente alla
+seconda per il group-ID. I processi non privilegiati possono impostare solo i
+valori del loro user-ID effettivo o reale; valori diversi comportano il
fallimento della chiamata; l'amministratore invece può specificare un valore
qualunque. Specificando un argomento di valore -1 l'identificatore
corrispondente verrà lasciato inalterato.
-Con queste funzioni si possono scambiare fra loro gli userid reale e
+Con queste funzioni si possono scambiare fra loro gli user-ID reale e
effettivo, e pertanto è possibile implementare un comportamento simile a
quello visto in precedenza per \func{setgid}, cedendo i privilegi con un primo
scambio, e recuperandoli, eseguito il lavoro non privilegiato, con un secondo
In questo caso però occorre porre molta attenzione quando si creano nuovi
processi nella fase intermedia in cui si sono scambiati gli identificatori, in
-questo caso infatti essi avranno un userid reale privilegiato, che dovrà
+questo caso infatti essi avranno un user-ID reale privilegiato, che dovrà
essere esplicitamente eliminato prima di porre in esecuzione un nuovo
programma (occorrerà cioè eseguire un'altra chiamata dopo la \func{fork} e
-prima della \func{exec} per uniformare l'userid reale a quello effettivo) in
+prima della \func{exec} per uniformare l'user-ID reale a quello effettivo) in
caso contrario il nuovo programma potrebbe a sua volta effettuare uno scambio
e riottenere privilegi non previsti.
Lo stesso problema di propagazione dei privilegi ad eventuali processi figli
-si pone per l'userid salvato: questa funzione deriva da un'implementazione che
+si pone per l'user-ID salvato: questa funzione deriva da un'implementazione che
non ne prevede la presenza, e quindi non è possibile usarla per correggere la
situazione come nel caso precedente. Per questo motivo in Linux tutte le volte
-che si imposta un qualunque valore diverso da quello dall'userid reale
-corrente, l'userid salvato viene automaticamente uniformato al valore
-dell'userid effettivo.
+che si imposta un qualunque valore diverso da quello dall'user-ID reale
+corrente, l'user-ID salvato viene automaticamente uniformato al valore
+dell'user-ID effettivo.
\subsection{Le funzioni \funcd{seteuid} e \funcd{setegid}}
\headdecl{unistd.h}
\headdecl{sys/types.h}
-\funcdecl{int seteuid(uid\_t uid)} Imposta l'userid effettivo del processo
+\funcdecl{int seteuid(uid\_t uid)} Imposta l'user-ID effettivo del processo
corrente a \param{uid}.
-\funcdecl{int setegid(gid\_t gid)} Imposta il groupid effettivo del processo
+\funcdecl{int setegid(gid\_t gid)} Imposta il group-ID effettivo del processo
corrente a \param{gid}.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
\end{functions}
Come per le precedenti le due funzioni sono identiche, per cui tratteremo solo
-la prima. Gli utenti normali possono impostare l'userid effettivo solo al
-valore dell'userid reale o dell'userid salvato, l'amministratore può
+la prima. Gli utenti normali possono impostare l'user-ID effettivo solo al
+valore dell'user-ID reale o dell'user-ID salvato, l'amministratore può
specificare qualunque valore. Queste funzioni sono usate per permettere
-all'amministratore di impostare solo l'userid effettivo, dato che l'uso
+all'amministratore di impostare solo l'user-ID effettivo, dato che l'uso
normale di \func{setuid} comporta l'impostazione di tutti gli identificatori.
\headdecl{sys/types.h}
\funcdecl{int setresuid(uid\_t ruid, uid\_t euid, uid\_t suid)} Imposta
-l'userid reale, l'userid effettivo e l'userid salvato del processo corrente ai
-valori specificati rispettivamente da \param{ruid}, \param{euid} e
+l'user-ID reale, l'user-ID effettivo e l'user-ID salvato del processo corrente
+ai valori specificati rispettivamente da \param{ruid}, \param{euid} e
\param{suid}.
\funcdecl{int setresgid(gid\_t rgid, gid\_t egid, gid\_t sgid)} Imposta il
-groupid reale, il groupid effettivo ed il groupid salvato del processo
+group-ID reale, il group-ID effettivo ed il group-ID salvato del processo
corrente ai valori specificati rispettivamente da \param{rgid}, \param{egid} e
\param{sgid}.
di fallimento: l'unico errore è \errval{EPERM}.}
\end{functions}
-Le due funzioni sono identiche, quanto detto per la prima riguardo gli userid
-si applica alla seconda per i groupid. I processi non privilegiati possono
-cambiare uno qualunque degli userid solo ad un valore corripondente o
-all'userid reale, o a quello effettivo o a quello salvato, l'amministratore
+Le due funzioni sono identiche, quanto detto per la prima riguardo gli user-ID
+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
lascia inalterato l'identificatore corrispondente.
\headdecl{sys/types.h}
\funcdecl{int getresuid(uid\_t *ruid, uid\_t *euid, uid\_t *suid)} Legge
-l'userid reale, l'userid effettivo e l'userid salvato del processo corrente.
+l'user-ID reale, l'user-ID effettivo e l'user-ID salvato del processo corrente.
\funcdecl{int getresgid(gid\_t *rgid, gid\_t *egid, gid\_t *sgid)} Legge il
-groupid reale, il groupid effettivo e il groupid salvato del processo
+group-ID reale, il group-ID effettivo e il group-ID salvato del processo
corrente.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso di
ovviare ad un problema di sicurezza che si presenta quando si deve
implementare un server NFS. Il server NFS infatti deve poter cambiare
l'identificatore con cui accede ai file per assumere l'identità del singolo
-utente remoto, ma se questo viene fatto cambiando l'userid effettivo o
-l'userid reale il server si espone alla ricezione di eventuali segnali ostili
+utente remoto, ma se questo viene fatto cambiando l'user-ID effettivo o
+l'user-ID reale il server si espone alla ricezione di eventuali segnali ostili
da parte dell'utente di cui ha temporaneamente assunto l'identità. Cambiando
-solo l'userid di filesystem si ottengono i privilegi necessari per accedere ai
+solo l'user-ID di filesystem si ottengono i privilegi necessari per accedere ai
file, mantenendo quelli originari per quanto riguarda tutti gli altri
controlli di accesso, così che l'utente non possa inviare segnali al server
NFS.
\begin{functions}
\headdecl{sys/fsuid.h}
-\funcdecl{int setfsuid(uid\_t fsuid)} Imposta l'userid di filesystem del
+\funcdecl{int setfsuid(uid\_t fsuid)} Imposta l'user-ID di filesystem del
processo corrente a \param{fsuid}.
-\funcdecl{int setfsgid(gid\_t fsgid)} Imposta il groupid di filesystem del
+\funcdecl{int setfsgid(gid\_t fsgid)} Imposta il group-ID di filesystem del
processo corrente a \param{fsgid}.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
La funzione legge gli identificatori dei gruppi supplementari del processo sul
vettore \param{list} di dimensione \param{size}. Non è specificato se la
-funzione inserisca o meno nella lista il groupid effettivo del processo. Se si
+funzione inserisca o meno nella lista il group-ID effettivo del processo. Se si
specifica un valore di \param{size} uguale a 0 \param{list} non viene
modificato, ma si ottiene il numero di gruppi supplementari.
tutti i processi indicati dagli argomenti \param{which} e \param{who}. La
gestione dei permessi dipende dalle varie implementazioni; in Linux, secondo
le specifiche dello standard SUSv3, e come avviene per tutti i sistemi che
-derivano da SYSV, è richiesto che l'userid reale o effettivo del processo
-chiamante corrispondano al real user id (e solo quello) del processo di cui si
+derivano da SysV, è richiesto che l'user-ID reale o effettivo del processo
+chiamante corrispondano al real user-ID (e solo quello) del processo di cui si
vuole cambiare la priorità; per i sistemi derivati da BSD invece (SunOS,
-Ultrix, *BSD) la corrispondenza può essere anche con l'userid effettivo.
+Ultrix, *BSD) la corrispondenza può essere anche con l'user-ID effettivo.
\textit{deadlock}\index{deadlock}}
\label{sec:proc_race_cond}
-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
-tipico è quello di un'operazione che viene eseguita da un processo in più
-passi, e può essere compromessa dall'intervento di un altro processo che
-accede alla stessa risorsa quando ancora non tutti i passi sono stati
-completati.
+Si definiscono \textit{race condition}\index{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 tipico è quello di un'operazione che viene eseguita da un
+processo in più passi, e può essere compromessa dall'intervento di un altro
+processo che accede alla stessa risorsa quando ancora non tutti i passi sono
+stati completati.
Dato che in un sistema multitasking ogni processo può essere interrotto in
qualunque momento per farne subentrare un'altro in esecuzione, niente può
Per questo occorre essere ben consapevoli di queste problematiche, e del fatto
che l'unico modo per evitarle è quello di riconoscerle come tali e prendere
gli adeguati provvedimenti per far sì che non si verifichino. Casi tipici di
-\textit{race condition} si hanno quando diversi processi accedono allo stesso
-file, o nell'accesso a meccanismi di intercomunicazione come la memoria
-condivisa. In questi casi, se non si dispone della possibilità di eseguire
-atomicamente le operazioni necessarie, occorre che quelle parti di codice in
-cui si compiono le operazioni sulle risorse condivise (le cosiddette
+\textit{race condition}\index{race condition} si hanno quando diversi processi
+accedono allo stesso file, o nell'accesso a meccanismi di intercomunicazione
+come la memoria condivisa. In questi casi, se non si dispone della possibilità
+di eseguire atomicamente le operazioni necessarie, occorre che quelle parti di
+codice in cui si compiono le operazioni sulle risorse condivise (le cosiddette
\textsl{sezioni critiche}\index{sezioni critiche}) del programma, siano
opportunamente protette da meccanismi di sincronizzazione (torneremo su queste
problematiche di questo tipo in \capref{cha:IPC}).
-Un caso particolare di \textit{race condition} sono poi i cosiddetti
-\textit{deadlock}\index{deadlock}, particolarmente gravi in quanto comportano
-spesso il blocco completo di un servizio, e non il fallimento di una singola
-operazione. Per definizione un \textit{deadlock}\index{deadlock} è una
-situazione in cui due o più processi non sono più in grado di proseguire
-perché ciascuno aspetta il risultato di una operazione che dovrebbe essere
-eseguita dall'altro.
+Un caso particolare di \textit{race condition}\index{race condition} sono poi
+i cosiddetti \textit{deadlock}\index{deadlock}, particolarmente gravi in
+quanto comportano spesso il blocco completo di un servizio, e non il
+fallimento di una singola operazione. Per definizione un
+\textit{deadlock}\index{deadlock} è una situazione in cui due o più processi
+non sono più in grado di proseguire perché ciascuno aspetta il risultato di
+una operazione che dovrebbe essere eseguita dall'altro.
L'esempio tipico di una situazione che può condurre ad un
-\textit{deadlock}\index{deadlock} è quello in cui un flag di ``occupazione''
-viene rilasciato da un evento asincrono (come un segnale o un altro processo)
-fra il momento in cui lo si è controllato (trovandolo occupato) e la
-successiva operazione di attesa per lo sblocco. In questo caso, dato che
-l'evento di sblocco del flag è avvenuto senza che ce ne accorgessimo proprio
-fra il controllo e la messa in attesa, quest'ultima diventerà perpetua (da cui
-il nome di \textit{deadlock}\index{deadlock}).
+\textit{deadlock}\index{deadlock} è quello in cui un flag di
+``\textsl{occupazione}'' viene rilasciato da un evento asincrono (come un
+segnale o un altro processo) fra il momento in cui lo si è controllato
+(trovandolo occupato) e la successiva operazione di attesa per lo sblocco. In
+questo caso, dato che l'evento di sblocco del flag è avvenuto senza che ce ne
+accorgessimo proprio fra il controllo e la messa in attesa, quest'ultima
+diventerà perpetua (da cui il nome di \textit{deadlock}\index{deadlock}).
In tutti questi casi è di fondamentale importanza il concetto di atomicità
visto in \secref{sec:proc_atom_oper}; questi problemi infatti possono essere
un altro thread di esecuzione senza che questo comporti nessun problema
nell'esecuzione della stessa. La problematica è comune nella programmazione
multi-thread, ma si hanno gli stessi problemi quando si vogliono chiamare
-delle funzioni all'interno dei manipolatori dei segnali.
+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
projects / gapil.git / blobdiff