X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=prochand.tex;h=e503452fe748a99b55de4b5f0d87c834bcc55039;hp=b337e4de05fa73b64c708a9cf62a2c6da36ad7b4;hb=b672a57f9abbea283031bdd00e4e8b894750fabe;hpb=e603c6e45f005839118e2142839114c00efa3449 diff --git a/prochand.tex b/prochand.tex index b337e4d..e503452 100644 --- a/prochand.tex +++ b/prochand.tex @@ -54,7 +54,6 @@ comunque consente di lanciare al posto di \cmd{init} qualunque altro programma corrotto, è possibile farlo ad esempio passando la riga \cmd{init=/bin/sh} all'avvio). - Dato che tutti i processi successivi sono comunque generati da \cmd{init} o da suoi figli tutto ciò comporta che, i processi sono organizzati gerarchicamente dalla relazione fra genitori e figli, in maniera analoga a come i file sono @@ -71,9 +70,9 @@ processo \cmd{init} che I processi vengono creati dalla funzione \func{fork}; in molti unix questa è una system call, Linux però usa un'altra nomenclatura, e la funzione fork è -basata a sua volta sulla system call \func{clone}, che viene usata anche per -generare i \textit{thread}. Il processo figlio creato dalla \func{fork} è una -copia identica del processo processo padre, ma ha nuovo \acr{pid} e viene +basata a sua volta sulla system call \func{\_\_clone}, che viene usata anche +per generare i \textit{thread}. Il processo figlio creato dalla \func{fork} è +una copia identica del processo processo padre, ma ha nuovo \acr{pid} e viene eseguito in maniera indipendente (le differenze fra padre e figlio sono affrontate in dettaglio in \secref{sec:proc_fork}). @@ -110,55 +109,94 @@ prima ritorna due volte (nel processo padre e nel figlio) mentre la seconda non ritorna mai (in quanto con essa viene eseguito un altro programma). -\section{Il controllo dei processi} -\label{sec:proc_control} -Esamineremo in questa sezione le varie funzioni per il controllo dei processi: -la loro creazione, la terminazione, l'esecuzione di altri programmi. Prima di -trattare in dettaglio le singole funzioni, +\section{La gestione dei processi} +\label{sec:proc_handling} + +In questa sezione tratteremo le funzioni per la gestione dei processi, a +partire dalle funzioni elementari che permettono di leggerne gli +identificatori, alle varie funzioni di manipolazione dei processi, che +riguardano la lore creazione, terminazione, e la messa in esecuzione di altri +programmi. + \subsection{Gli identificatori dei processi} -\label{sec:proc_id} - -Come accennato ogni processo viene identificato dal sistema da un numero -identificativo unico, il \textit{process id} o \acr{pid}. Questo viene -assegnato in forma progressiva ogni volta che un nuovo processo viene creato, -fino ad un limite massimo (in genere essendo detto numero memorizzato in un -intero a 16 bit si arriva a 32767) oltre il quale si riparte dal numero più -basso disponibile (FIXME: verificare, non sono sicuro). Per questo motivo -processo il processo di avvio (init) ha sempre il pid uguale a uno. - -Ogni processo è identificato univocamente dal sistema per il suo pid; -quest'ultimo è un tipo di dato standard, il \texttt{pid\_t} che in genere è un -intero con segno (nel caso di Linux e delle glibc il tipo usato è -\texttt{int}). - -Tutti i processi inoltre portano traccia del pid del genitore, chiamato in -genere \textit{ppid} (da \textit{Parente Process Id}). Questi identificativi -possono essere ottenuti da un programma usando le funzioni: +\label{sec:proc_pid} + +Come accennato nell'introduzione ogni processo viene identificato dal sistema +da un numero identificativo unico, 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 glibc il tipo usato è \type{int}). + +Il \acr{pid} viene assegnato in forma progressiva ogni volta che un nuovo +processo viene creato, fino ad un limite massimo (in genere essendo detto +numero memorizzato in un intero a 16 bit si arriva a 32767) oltre il quale si +riparte dal numero più basso disponibile (FIXME: verificare, non sono sicuro). +Per questo motivo processo il processo di avvio (\cmd{init}) ha sempre il +\acr{pid} uguale a uno. + +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}) ed è normalmente utilizzato per il controllo di +sessione. Questi due identificativi possono essere ottenuti da programma +usando le funzioni: \begin{functions} \headdecl{sys/types.h} \headdecl{unistd.h} \funcdecl{pid\_t getpid(void)} restituisce il pid del processo corrente. \funcdecl{pid\_t getppid(void)} restituisce il pid del padre del processo corrente. + +Entrambe le funzioni non riportano condizioni di errore. \end{functions} +Il fatto che il \acr{pid} sia un numero univoco per il sistema lo rende il +candidato ideale per generare ultieriori indicatori associati al processo di +cui diventa possibile garantire l'unicità: ad esempio la funzione +\func{tmpname} (si veda \secref{sec:file_temp_file}) usa il \acr{pid} per +generare un 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 è un'altra delle relazioni usate nel controllo di +sessione, in cui si raggruppano tutti i processi creati su uno stesso +terminale una volta che si è effettuato il login. Torneremo su questo +argomento in \secref{cap:terminal}, dove esamineremo tutti gli altri +identificativi associati ad un processo relativi al controllo di sessione. \subsection{La funzione \func{fork}} \label{sec:proc_fork} -La funzione \func{fork} +La funzione \func{fork} è la funzione fondamentale della gestione dei processi +in unix; come si è detto l'unico modo di creare un nuovo processo è attraverso +l'uso di questa funzione, che è quindi la base per il multitasking; il protipo +della funzione è: +\begin{functions} + \headdecl{sys/types.h} + \headdecl{unistd.h} + + \funcdecl{pid\_t fork(void)} + + Restituisce zero al padre e il \acr{pid} al figlio in caso di successo, + ritorna -1 al padre (senza creare il figlio) in caso di errore; + \texttt{errno} può assumere i valori: + \begin{errlist} + \item \macro{EAGAIN} non ci sono risorse sufficienti per creare un'altro + processo (per allocare la tabella delle pagine e le strutture del task) o + si è esaurito il numero di processi disponibili. + \item \macro{ENOMEM} non è stato possibile allocare la memoria per le + strutture necessarie al kernel per creare il nuovo processo. + \end{errlist} +\end{functions} -Dopo l'esecuzione di una fork sia il processo padre che il processo figlio -continuano ad essere eseguiti normalmente, ed il processo figlio esegue +Dopo l'esecuzione di una \func{fork} sia il processo padre che il processo +figlio continuano ad essere eseguiti normalmente, ed il processo figlio esegue esattamente lo stesso codice del padre. La sola differenza è che nel processo -padre il valore di ritorno della funzione fork è il pid del processo figlio, -mentre nel figlio è zero; in questo modo il programma può identificare se -viene eseguito dal padre o dal figlio. - +padre il valore di ritorno della funzione fork è il \acr{pid} del processo +figlio, mentre nel figlio è zero; in questo modo il programma può identificare +se viene eseguito dal padre o dal figlio. @@ -174,8 +212,78 @@ viene eseguito dal padre o dal figlio. \section{Il controllo di accesso} \label{sec:proc_perms} -Va messo qui tutta la storia su effective, real, saved uid, e pure le cose di -Linux come il filesystem uid. +In questa sezione esamineremo le problematiche relative al controllo di +accesso dal punto di vista del processi; gli identificativi usati, come questi +vengono modificati nella creazione e nel lancio di nuovi processi, e le varie +funzioni per la loro manipolazione diretta. + + +\subsection{Utente e gruppo di un processo} +\label{sec:proc_user_group} + +Abbiamo già accennato in \secref{sec:intro_multiuser} ad ogni utente ed gruppo +sono associati due identificatori univoci, lo \acr{uid} e il \acr{gid} che li +contraddistinguono nei confonti del kernel. Questi identificatori stanno alla +base del sistema di permessi e protezioni di un sistema unix, e vengono usati +anche nella gestione dei privilegi di accesso dei processi. + +In realtà ad ogni processo è associato un certo numero di identificatori, il +cui elenco è riportato \ntab, in genere questi derivano direttamente +dall'utente che ha lanciato il processo (attraverso i valori di \acr{uid} e +\acr{gid}), e vengono usati sia per il controllo di accesso ai file che per la +gestione dei privilegi associati ai processi stessi. +\begin{table}[htb] + \centering + \begin{tabular}[c]{|c|l|l|} + \hline + Sigla & Significato & Utilizzo \\ + \hline + \hline + \acr{ruid} & \textit{real user id} & indica l'utente reale che ha lanciato + il programma\\ + \acr{rgid} & \textit{real group id} & indica il gruppo reale dell'utente + che ha lanciato il programma \\ + \acr{euid} & \textit{effective user id} & indica l'utente effettivo usato + dal programma \\ + \acr{egid} & \textit{effective group id} & indica il gruppo effettivo usato + dal programma \\ + & \textit{supplementary group id} & indica i gruppi cui + l'utente appartiene \\ + \acr{suid} & \textit{saved user id} & indica l'utente \\ + \acr{sgid} & \textit{daved group id} & indica il gruppo \\ + \acr{fsuid} & \textit{filesystem user id} & indica l'utente effettivo per + il filesystem \\ + \acr{fsgid} & \textit{filesystem group id} & indica il gruppo effettivo + per il filesystem \\ + \hline + \end{tabular} + \caption{Identificatori di utente e gruppo associati a ciascun processo.} + \label{tab:proc_uid_gid} +\end{table} + +Il \textit{real user id} e il \textit{real group id} indicano l'utente che ha +lanciato il processo, e vengono settati al login al valore standard di +\acr{uid} e \acr{gid} dell'utente letti direttamente da \file{/etc/passwd}. +Questi non vengono mai cambiati nella creazione di nuovi processi e restano +sempre gli stessi per tutti i processi avviati in una sessione. In realtà è +possibile modificarli (vedi \secref{sec:proc_setuid}), ma solo per un processo +che abbia i privilegi di amministratore (ed è così infatti che \cmd{login} li +setta ai valori corrispondenti all'utente che entra nel sistema). + +L'\textit{effective user id}, l'\textit{effective group id} e gli eventuali +\textit{supplementary group id} sono gli identificativi usati per il controllo +di accesso ai file secondo quanto descritto in dettaglio in +\secref{sec:file_perm_overview}. Normalmente sono uguali al \textit{real user + id} e al \textit{real group id}, a meno che il file posto in esecuzione non +abbia i bit \acr{suid} o \acr{sgid} settati, nel qual caso vengono settati +rispettivamente all'\acr{uid} e \acr{gid} del file. + +Il \textit{saved user id} e il \textit{saved group id} sono copie +dell'\textit{effective user id} e dell'\textit{effective group id} del +processo padre, e vengono settati all'avvio del processo, prima che +\textit{effective user id} e \textit{effective group id} vengano modificati +per tener conto di eventuali \acr{suid} o \acr{sgid}. + \subsection{Le funzioni \texttt{setuid} e \texttt{setgid}} \label{sec:proc_setuid}