From 992e4ddc3eb4351007fac08cb852297069f759b6 Mon Sep 17 00:00:00 2001 From: Simone Piccardi Date: Wed, 3 Oct 2001 21:18:48 +0000 Subject: [PATCH] Avanti ad exec... --- prochand.tex | 120 +++++++++++++++++++++++++++++++++++++++++++-------- socket.tex | 84 +++++++++++++++++++----------------- 2 files changed, 146 insertions(+), 58 deletions(-) diff --git a/prochand.tex b/prochand.tex index 57ba6ab..c9e4e15 100644 --- a/prochand.tex +++ b/prochand.tex @@ -970,18 +970,6 @@ versione 4.3 Reno di BSD, attualmente (con il kernel 2.4.x) i soli campi che sono mantenuti sono: \var{ru\_utime}, \var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e \var{ru\_nswap}. -\subsection{Le \textit{race condition}} -\label{sec:proc_race_cond} - -Si definisce una \textit{race condition} il caso in cui diversi processi -stanno cercando di fare qualcosa con una risorsa comune ed il risultato finale -viene a dipendere dall'ordine di esecuzione dei medesimi. Ovviamente dato che -l'ordine di esecuzione di un processo, senza appositi meccanismi di -sincronizzazione, non è assolutamente prevedibile, queste situazioni sono -fonti di errori molto subdoli, che possono verificarsi solo in condizioni -particolari e quindi difficilmente riproducibili. - - \subsection{Le funzioni \texttt{exec}} \label{sec:proc_exec} @@ -997,7 +985,7 @@ disco. Ci sono sei diverse versioni di \func{exec} (per questo la si è chiamata famiglia di funzioni) che possono essere usate per questo compito, che in realtà (come mostrato in \figref{fig:proc_exec_relat}), costituiscono un -front-end a \func{execve}. Il prototipo di quest'utiltima è: +front-end a \func{execve}. Il prototipo di quest'ultima è: \begin{prototype}{unistd.h} {int execve(const char * filename, char * const argv [], char * const envp[])} @@ -1033,13 +1021,95 @@ front-end a \func{execve}. Il prototipo di quest'utiltima \end{prototype} Le altre funzioni della famiglia servono per fornire all'utente una serie -possibile di diverse interfacce per la creazione di un nuovo processo. +possibile di diverse interfacce per la creazione di un nuovo processo. I loro +prototipi sono: + +\begin{functions} +\headdecl{unistd.h} +\funcdecl{int execl(const char *path, const char *arg, ...)} +\funcdecl{int execv(const char *path, char *const argv[])} +\funcdecl{int execle(const char *path, const char *arg, ..., char +* const envp[])} +\funcdecl{int execlp(const char *file, const char *arg, ...)} +\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 +linea di comando e l'ambiente ricevuti dal nuovo processo. + +Queste funzioni ritornano solo in caso di errore, restituendo -1; nel qual +caso \var{errno} andrà ad assumere i valori visti in precedenza per +\func{execve}. +\end{functions} + +Per capire meglio le differenze fra le funzioni della famiglia si può fare +riferimento allo specchietto riportato in \ntab. 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 \var{argv} e \var{argc} visti +dalla funzione \func{main} del programma chiamato). +Queste modalità sono due e sono riassunte dagli mnenonici \func{v} e \func{l} +che stanno rispettivamente per \textit{vector} e \textit{list}. Nel primo caso +gli argomenti sono passati tramite il vettore di puntatori \var{argv[]} a +stringhe terminate con zero che costituiranno gli argomenti a riga di comando, +questo vettore \emph{deve} essere terminato da un puntatore nullo. -Con \func{exec} si chiude il cerchio delle funzioni su cui si basa il -controllo dei processi in unix: con \func{fork} si crea un nuovo processo, con -\func{exec} si avvia un nuovo programma, con \func{exit} e \func{wait} si -effettua e si gestisce la conclusione dei programmi. +Nel secondo caso le stringhe degli argomenti sono passate alla funzione come +lista di puntatori, nella forma: +\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{} + char * arg0, char * arg1, ..., char * argn, NULL +\end{lstlisting} +che deve essere terminata da un puntatore nullo. In entrambi i casi vale la +convenzione che il primo argomento (\var{arg0} o \var{argv[0]}) viene usato +per indicare il nome del file che contiene il programma che verrà eseguito. + + +\begin{table}[!htb] + \footnotesize + \centering + \begin{tabular}[c]{|l|c|c|c||c|c|c|} + \hline + \multicolumn{1}{|c|}{\textbf{Caratteristiche}} & + \multicolumn{6}{|c|}{\textbf{Funzioni}} \\ + \hline + &\func{execl\ }&\func{execlp}&\func{execle} + &\func{execv\ }& \func{execvp}& \func{execve} \\ + \hline + \hline + 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$ \\ + \hline + ambiente a vettore &&&$\bullet$&&&$\bullet$ \\ + uso di \var{environ} &$\bullet$&$\bullet$&&$\bullet$&$\bullet$& \\ + \hline + \end{tabular} + \caption{Confronto delle caratteristiche delle varie funzioni della + famiglia \func{exec}.} + \label{tab:proc_exec_scheme} +\end{table} + +La seconda differenza fra le funzioni riguarda le modalità con cui si +specifica il programma che si vuole eseguire. Con lo mnemonico \func{p} si +indicano le due funzioni che necessitano del \textit{pathname} assoluto del +programma come valore del parametro \var{path}. Le altre quattro funzioni +invece usano come parametro \var{file} un nome che viene cercato +automaticamente fra i file presenti nella lista di directory specificate dalla +variabile di ambiente \var{PATH}. + + +La terza differenza è . + + + +Con la famiglia delle \func{exec} si chiude il novero delle funzioni su cui è +basato il controllo dei processi in unix: con \func{fork} si crea un nuovo +processo, con \func{exec} si avvia un nuovo programma, con \func{exit} e +\func{wait} si effettua e si gestisce la conclusione dei programmi. Tutte le +altre funzioni sono ausiliarie e servono la lettura e il settaggio dei vari +parametri connessi ai processi. \section{Il controllo di accesso} @@ -1066,6 +1136,7 @@ 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] + \footnotesize \centering \begin{tabular}[c]{|c|l|p{8cm}|} \hline @@ -1126,3 +1197,16 @@ per tener conto di eventuali \acr{suid} o \acr{sgid}. \subsection{Le funzioni \texttt{seteuid} e \texttt{setegid}} \label{sec:proc_seteuid} + +\subsection{Le \textit{race condition}} +\label{sec:proc_race_cond} + +Si definisce una \textit{race condition} il caso in cui diversi processi +stanno cercando di fare qualcosa con una risorsa comune ed il risultato finale +viene a dipendere dall'ordine di esecuzione dei medesimi. Ovviamente dato che +l'ordine di esecuzione di un processo, senza appositi meccanismi di +sincronizzazione, non è assolutamente prevedibile, queste situazioni sono +fonti di errori molto subdoli, che possono verificarsi solo in condizioni +particolari e quindi difficilmente riproducibili. + + diff --git a/socket.tex b/socket.tex index 6125406..9a1018b 100644 --- a/socket.tex +++ b/socket.tex @@ -552,16 +552,18 @@ numero. Il caso opposto, in cui si parte dal bit meno significativo per lo stesso motivo \textit{big endian}. La \textit{endianess} di un computer dipende essenzialmente dalla architettura -hardware usata; Intel e Digital usano il little endian, Motorola, IBM, Sun -(sostanzialmente tutti gli altri) usano il big endian. Il formato della rete è -anch'esso big endian, quello del bus PCI è little endian, quello del bus VME è -big endian. +hardware usata; Intel e Digital usano il \textit{little endian}, Motorola, +IBM, Sun (sostanzialmente tutti gli altri) usano il \textit{big endian}. Il +formato della rete è anch'esso \textit{big endian}, altri esempi sono quello +del bus PC, che è \textit{little endian}, o quello del bus VME che è +\textit{big endian}. Esistono poi anche dei processori che possono scegliere il tipo di formato -all'avvio e alcuni, come il PowerPC o l'Intel i860, possono pure passare da un -tipo di ordinamento all'altro con una specifica istruzione; in ogni caso in -Linux l'ordinamento è definito dall'architettura e anche se questi cambiamenti -sono possibili anche dopo che il sistema è avviato, non vengono mai eseguiti. +all'avvio e alcuni che, come il PowerPC o l'Intel i860, possono pure passare +da un tipo di ordinamento all'altro con una specifica istruzione. In ogni caso +in Linux l'ordinamento è definito dall'architettura e dopo l'avvio del sistema +resta sempre lo stesso, anche quando il processore permetterebbe di eseguire +questi cambiamenti. \subsection{Le funzioni per il riordinamento} \label{sec:sock_func_ord} @@ -596,16 +598,17 @@ funzioni sono: Converte l'intero a 16 bit \var{netshort} dal formato della rete a quello della macchina. \end{prototype} -I nomi sono assegnati usando la lettera $n$ come mnemonico per indicare -l'ordinamento usato sulla rete (da \textit{network order}) e la lettera $h$ -come mnemonico per l'ordinamento usato sulla macchina locale (da \textit{host - order}), mentre le lettere $s$ e $l$ stanno ad indicare i tipi di dato -(\type{long} o \type{short}, riportati anche dai prototipi). +I nomi sono assegnati usando la lettera \func{n} come mnemonico per indicare +l'ordinamento usato sulla rete (da \textit{network order}) e la lettera +\func{h} come mnemonico per l'ordinamento usato sulla macchina locale (da +\textit{host order}), mentre le lettere \func{s} e \func{l} stanno ad indicare +i tipi di dato (\type{long} o \type{short}, riportati anche dai prototipi). -Usando queste funzioni si ha la conversione automatica (nel caso pure la -macchina sia in big endian queste funzioni sono definite come macro che non -fanno nulla); esse vanno sempre utilizzate per assicurare la portabilità del -codice su tutte le architetture. +Usando queste funzioni si ha la conversione automatica: nel caso in cui la +macchina che si sta usando abbia una architettura \textit{big endian} queste +funzioni sono definite come macro che non fanno nulla. Per questo motivo vanno +sempre utilizzate, anche quando potrebbero non essere necessarie, in modo da +assicurare la portabilità del codice su tutte le architetture. \subsection{Le funzioni \func{inet\_aton}, \func{inet\_addr} e @@ -620,16 +623,16 @@ Le prime tre funzioni di manipolazione riguardano la conversione degli indirizzi IPv4 da una stringa in cui il numero di IP è espresso secondo la cosiddetta notazione \textit{dotted-decimal}, (cioè nella forma \texttt{192.160.0.1}) al formato binario (direttamente in \textit{network - order}) e viceversa; in questo caso si usa la lettera $a$ come mnemonico per -indicare la stringa. Dette funzioni sono: + order}) e viceversa; in questo caso si usa la lettera \func{a} come +mnemonico per indicare la stringa. Dette funzioni sono: \begin{prototype}{arpa/inet.h} - {int inet\_aton(const char *src, struct in\_addr *dest)} Converte la stringa - puntata da \var{src} nell'indirizzo binario da memorizzare all'indirizzo - puntato da \var{dest}, restituendo 0 in caso di successo e 1 in caso di - fallimento (è espressa in questa forma in modo da poterla usare direttamente - con il puntatore usato per passare la struttura degli indirizzi). Se usata - con \var{dest} inizializzato a \macro{NULL} effettua la validazione - dell'indirizzo. + {int inet\_aton(const char *src, struct in\_addr *dest)} + Converte la stringa puntata da \var{src} nell'indirizzo binario da + memorizzare all'indirizzo puntato da \var{dest}, restituendo 0 in caso di + successo e 1 in caso di fallimento (è espressa in questa forma in modo da + poterla usare direttamente con il puntatore usato per passare la struttura + degli indirizzi). Se usata con \var{dest} inizializzato a \macro{NULL} + effettua la validazione dell'indirizzo. \end{prototype} \begin{prototype}{arpa/inet.h}{in\_addr\_t inet\_addr(const char *strptr)} Restituisce l'indirizzo a 32 bit in network order a partire dalla stringa @@ -640,10 +643,10 @@ indicare la stringa. Dette funzioni sono: generalmente deprecata in favore della precedente. \end{prototype} \begin{prototype}{arpa/inet.h}{char *inet\_ntoa(struct in\_addr addrptr)} - Converte il valore a 32 bit dell'indirizzo (espresso in network order) - restituendo il puntatore alla stringa che contiene l'espressione in formato - dotted decimal. Si deve tenere presente che la stringa risiede in memoria - statica, per cui questa funzione non è rientrante. + Converte il valore a 32 bit dell'indirizzo (espresso in \textit{network + order}) restituendo il puntatore alla stringa che contiene l'espressione + in formato dotted decimal. Si deve tenere presente che la stringa risiede in + memoria statica, per cui questa funzione non è rientrante. \end{prototype} @@ -653,8 +656,9 @@ indicare la stringa. Dette funzioni sono: Le tre funzioni precedenti sono limitate solo ad indirizzi IPv4, per questo motivo è preferibile usare le due nuove funzioni \func{inet\_pton} e \func{inet\_ntop} che possono convertire anche gli indirizzi IPv6. Anche in -questo caso le lettere $n$ e $p$ sono degli mnemonici per ricordare il tipo di -conversione effettuata e stanno per \textit{presentation} e \textit{numeric}. +questo caso le lettere \func{n} e \func{p} sono degli mnemonici per ricordare +il tipo di conversione effettuata e stanno per \textit{presentation} e +\textit{numeric}. % \begin{figure}[htb] % \centering @@ -763,16 +767,16 @@ ssize_t SockRead(int fd, void *buf, size_t count) return (count - nleft); } \end{lstlisting} - \caption{Funzione \texttt{SockRead}, legge $n$ bytes da un socket } + \caption{Funzione \func{SockRead}, legge \var{count} bytes da un socket } \label{fig:sock_SockRead_code} \end{figure} Per questo motivo seguendo l'esempio di W. R. Stevens si sono definite due -funzioni \texttt{SockRead} e \texttt{SockWrite} che eseguono la lettura da un +funzioni \func{SockRead} e \func{SockWrite} che eseguono la lettura da un socket tenendo conto di questa caratteristica, ed in grado di ritornare dopo avere letto o scritto esattamente il numero di bytes specificato; il sorgente è riportato in \curfig\ e \nfig\ ed è disponibile fra i sorgenti allegati alla -guida nei files \texttt{SockRead.c} e \texttt{SockWrite.c}. +guida nei files \file{SockRead.c} e \file{SockWrite.c}. \begin{figure}[htb] \centering @@ -800,19 +804,19 @@ ssize_t SockWrite(int fd, const void *buf, size_t count) return (count); } \end{lstlisting} - \caption{Funzione \texttt{SockWrite}, scrive $n$ bytes su un socket } + \caption{Funzione \func{SockWrite}, scrive \var{count} bytes su un socket } \label{fig:sock_SockWrite_code} \end{figure} Come si può notare le funzioni ripetono la lettura/scrittura in un ciclo fino all'esaurimento del numero di bytes richiesti, in caso di errore viene -controllato se questo è \texttt{EINTR} (cioè un'interruzione della system call +controllato se questo è \macro{EINTR} (cioè un'interruzione della system call dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti -l'errore viene ritornato interrompendo il ciclo. +l'errore viene ritornato interrompendo il ciclo. -Nel caso della lettura se il numero di bytes letti è zero significa che è +Nel caso della lettura, se il numero di bytes letti è zero, significa che si è arrivati alla fine del file e pertanto si ritorna senza aver concluso la -lettura di tutti i bytes richiesti. +lettura di tutti i bytes richiesti. -- 2.30.2