\item il server deve dare ricevuto (l'\textit{acknowledge}) del SYN del
client, inoltre anche il server deve inviare il suo SYN al client (e
trasmettere il suo numero di sequenza iniziale) questo viene fatto
- ritrasmettendo un singolo segmento in cui entrambi i flag SYN ACK e sono
- settati.
+ ritrasmettendo un singolo segmento in cui sono impostati entrambi i flag SYN
+ ACK.
\item una volta che il client ha ricevuto l'acknowledge dal server la funzione
\func{connect} ritorna, l'ultimo passo è dare dare il ricevuto del SYN del
Il numero di sequenza di ciascun segmento viene calcolato a partire da un
\textsl{numero di sequenza iniziale} generato in maniera casuale del kernel
all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di
-ciascun segmento viene effettuato dall'altro capo della connessione settando
+ciascun segmento viene effettuato dall'altro capo della connessione impostando
il flag ACK e restituendo nell'apposito campo dell'header un
\textit{acknowledge number}) pari al numero di sequenza che il ricevente si
aspetta di ricevere con il pacchetto successivo; dato che il primo pacchetto
contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}.
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
- errore; in caso di errore la variabile \var{errno} viene settata secondo i
- seguenti codici di errore:
+ errore; in caso di errore la variabile \var{errno} viene impostata secondo
+ i seguenti codici di errore:
\begin{errlist}
\item[\macro{EBADF}] il file descriptor non è valido.
\item[\macro{EINVAL}] il socket ha già un indirizzo assegnato.
socket, già descritta in \secref{sec:sock_sockaddr}.
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
- errore, in caso di errore la variabile \var{errno} viene settata secondo i
- seguenti codici di errore:
+ errore, in caso di errore la variabile \var{errno} viene impostata secondo
+ i seguenti codici di errore:
\begin{errlist}
\item[\macro{ECONNREFUSED}] non c'è nessuno in ascolto sull'indirizzo remoto.
\item[\macro{ETIMEDOUT}] si è avuto timeout durante il tentativo di
connessione.
\item[\macro{ENETUNREACH}] la rete non è raggiungibile.
- \item[\macro{EINPROGRESS}] il socket è non bloccante e la connessione non
- può essere conclusa immediatamente.
- \item[\macro{EALREADY}] il socket è non bloccante e un tentativo precedente
- di connessione non si è ancora concluso.
+ \item[\macro{EINPROGRESS}] il socket è non bloccante (vedi
+ \secref{sec:file_noblocking}) e la connessione non può essere conclusa
+ immediatamente.
+ \item[\macro{EALREADY}] il socket è non bloccante (vedi
+ \secref{sec:file_noblocking}) e un tentativo precedente di connessione non
+ si è ancora concluso.
\item[\macro{EAGAIN}] non ci sono più porte locali libere.
\item[\macro{EAFNOSUPPORT}] l'indirizzo non ha una famiglia di indirizzi
corretta nel relativo campo.
invece ripete l'emissione del SYN ad intervalli di 30 secondi per un numero
di volte che può essere stabilito dall'utente sia con una opportuna
\func{sysctl} che attraverso il filesystem \file{/proc} scrivendo il valore
- voluto in \file{/proc/sys/net/ipv4/tcp\_syn\_retries}. Il valore di default
+ voluto in \file{/proc/sys/net/ipv4/tcp\_syn\_retries}. Il valore predefinito
per la ripetizione dell'invio è di 5 volte, che comporta un timeout dopo
circa 180 secondi.
%
-% Le informazioni su tutte le opzioni settabili via /proc stanno in
+% Le informazioni su tutte le opzioni impostabili via /proc stanno in
% Linux/Documentation/networking/ip-sysctl.txt
%
\item Il client riceve come risposta al SYN un RST significa che non c'è
\bodydesc{La funzione restituisce un numero di socket descriptor positivo in
caso di successo e -1 in caso di errore, nel qual caso la variabile
- \var{errno} viene settata ai seguenti valori:
+ \var{errno} viene impostata ai seguenti valori:
\begin{errlist}
\item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
\item[\macro{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
\item[\macro{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
operazione.
- \item[\macro{EAGAIN} o \macro{EWOULDBLOCK}] il socket è stato settato come
- non bloccante, e non ci sono connessioni in attesa di essere accettate.
+ \item[\macro{EAGAIN} o \macro{EWOULDBLOCK}] il socket è stato impostato come
+ non bloccante (vedi \secref{sec:file_noblocking}), e non ci sono
+ connessioni in attesa di essere accettate.
\item[\macro{EPERM}] Le regole del firewall non consentono la connessione.
\item[\macro{ENOBUFS, ENOMEM}] questo spesso significa che l'allocazione
della memoria è limitata dai limiti sui buffer dei socket, non dalla
socket \var{sockfd}. Quest'ultimo (detto \textit{listening socket}) è quello
creato all'inizio e messo in ascolto con \func{listen}, e non viene toccato
dalla funzione. Se non ci sono connessioni pendenti da accettare la funzione
-mette in attesa il processo\footnote{a meno che non si sia settato il socket
- per essere non-bloccante, nel qual caso ritorna con l'errore \macro{EAGAIN}.
- Torneremo su questa modalità di operazione in
- \secref{sec:xxx_sock_noblock}.} fintanto che non ne arriva una.
+mette in attesa il processo\footnote{a meno che non si sia imopstato il socket
+ per essere non bloccante (vedi \secref{sec:file_noblocking}), nel qual caso
+ ritorna con l'errore \macro{EAGAIN}. Torneremo su questa modalità di
+ operazione in \secref{sec:xxx_sock_noblock}.} fintanto che non ne arriva
+una.
Il meccanismo di funzionamento di \func{accept} è essenziale per capire il
funzionamento di un server: in generale infatti c'è sempre un solo socket in
\secref{sec:sys_limits}).
\item \macro{EPIPE} \textit{Broken pipe}. Non c'è un processo che stia
leggendo l'altro capo della pipe. Ogni funzione che restituisce questo
- errore genera anche un segnale \macro{SIGPIPE}, la cui azione di default è
+ errore genera anche un segnale \macro{SIGPIPE}, la cui azione predefinita è
terminare il programma; pertanto non si potrà vedere questo errore fintanto
che \macro{SIGPIPE} non viene gestito o bloccato.
\item \macro{ENOTEMPTY} \textit{Directory not empty}. La directory non è vuota
\item \macro{EFTYPE} \textit{Inappropriate file type or format}. Il file è di
tipo sbagliato rispetto all'operazione richiesta o un file di dati ha un
formato sbagliato. Alcuni sistemi restituiscono questo errore quando si
- cerca di settare lo \textit{sticky bit} su un file che non è una directory.
+ cerca di impostare lo \textit{sticky bit} su un file che non è una directory.
\end{description}
fallita perché l'indirizzo richiesto è irraggiungibile (ad esempio la
sottorete della stazione remota è irraggiungibile).
\item \macro{ENETRESET} \textit{Network dropped connection because of reset}.
- Una connessione è stata resettata perché l'host remoto è caduto.
+ Una connessione è stata cancellata perché l'host remoto è caduto.
\item \macro{ECONNABORTED} \textit{Software caused connection abort}. Una
connessione è stata abortita localmente.
\item \macro{ECONNRESET} \textit{Connection reset by peer}. Una connessione è
destinazione. Nel caso di socket senza connessione (ad esempio socket UDP)
l'errore che si ottiene è \macro{EDESTADDRREQ}.
\item \macro{EDESTADDRREQ} \textit{Destination address required}. Non c'è un
- indirizzo di destinazione di default per il socket. Si ottiene questo errore
- mandando dato su un socket senza connessione senza averne prima specificato
- una destinazione.
+ indirizzo di destinazione predefinito per il socket. Si ottiene questo
+ errore mandando dato su un socket senza connessione senza averne prima
+ specificato una destinazione.
\item \macro{ESHUTDOWN} \textit{Cannot send after transport endpoint
shutdown}. Il socket su cui si cerca di inviare dei dati ha avuto uno
shutdown.
\bodydesc{La funzione in caso di successo restituisce il numero di file
descriptor (anche nullo) che sono attivi, e -1 in caso di errore, nel qual
- caso \var{errno} viene settata ai valori:
+ caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
degli insiemi.
Infine l'argomento \param{timeout}, specifica un tempo massimo di
attesa\footnote{il tempo è valutato come \textit{elapsed time}.} prima che la
-funzione ritorni; se settato a \macro{NULL} la funzione attende
+funzione ritorni; se impostato a \macro{NULL} la funzione attende
indefinitamente. Si può specificare anche un tempo nullo (cioè una \var{struct
- timeval} con i campi settati a zero), qualora si voglia semplicemente
+ timeval} con i campi impostati a zero), qualora si voglia semplicemente
controllare lo stato corrente dei file descriptor.
La funzione restituisce il totale dei file descriptor pronti nei tre insiemi,
\macro{FD\_ISSET}. In caso di errore la funzione restituisce -1 e gli insiemi
non vengono toccati.
-In Linux \func{select} modifica anche il valore di \param{timeout}, settandolo
-al tempo restante; questo è utile quando la funzione viene interrotta da un
-segnale, in tal caso infatti si ha un errore di \macro{EINTR}, ed occorre
-rilanciare la funzione; in questo modo non è necessario ricalcolare tutte le
-volte il tempo rimanente.\footnote{questo può causare problemi di portabilità
- sia quando si trasporta codice scritto su Linux che legge questo valore, sia
- quando si usano programmi scritti per altri sistemi che non dispongono di
- questa caratteristica e ricalcolano \param{timeout} tutte le volte. In
- genere la caratteristica è disponibile nei sistemi che derivano da System V
- e non disponibile per quelli che derivano da BSD.}
+In Linux \func{select} modifica anche il valore di \param{timeout},
+impostandolo al tempo restante; questo è utile quando la funzione viene
+interrotta da un segnale, in tal caso infatti si ha un errore di
+\macro{EINTR}, ed occorre rilanciare la funzione; in questo modo non è
+necessario ricalcolare tutte le volte il tempo rimanente.\footnote{questo può
+ causare problemi di portabilità sia quando si trasporta codice scritto su
+ Linux che legge questo valore, sia quando si usano programmi scritti per
+ altri sistemi che non dispongono di questa caratteristica e ricalcolano
+ \param{timeout} tutte le volte. In genere la caratteristica è disponibile
+ nei sistemi che derivano da System V e non disponibile per quelli che
+ derivano da BSD.}
Come accennato l'interfaccia di \func{select} è una estensione di BSD; anche
System V ha introdotto una sua interfaccia per gestire l'\textit{I/O
\bodydesc{La funzione restituisce il numero di file descriptor con attività in
caso di successo, o 0 se c'è stato un timeout; in caso di errore viene
- restituito -1 ed \var{errno} viene settata ai valori:
+ restituito -1 ed \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
degli insiemi.
\end{table}
La funzione ritorna, restituendo il numero di file per i quali si è verificata
-una delle condizioni di attesa richieste o un errore. Lo stato dei file
+una delle condizioni di attesa richieste od un errore. Lo stato dei file
all'uscita della funzione viene restituito nel campo \var{revents} della
-relativa struttura \type{pollfd}, che viene settato alla maschera binaria dei
-valori riportati in \tabref{tab:file_pollfd_flags}, ed oltre alle tre
+relativa struttura \type{pollfd}, che viene impostato alla maschera binaria
+dei valori riportati in \tabref{tab:file_pollfd_flags}, ed oltre alle tre
condizioni specificate tramite \var{events} può riportare anche l'occorrere di
una condizione di errore.
\bodydesc{La funzione in caso di successo restituisce il numero di file
descriptor (anche nullo) che sono attivi, e -1 in caso di errore, nel qual
- caso \var{errno} viene settata ai valori:
+ caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EBADF}] Si è specificato un file descriptor sbagliato in uno
degli insiemi.
race condition\footnote{in Linux però, non esistendo una system call apposita,
la funzione è implementata nelle \acr{glibc} usando \func{select}, e la
possibilità di una race condition resta.} quando si deve eseguire un test su
-una variabile settata da un manipolatore sulla base dell'occorrenza di un
+una variabile assegnata da un manipolatore sulla base dell'occorrenza di un
segnale per decidere se lanciare \func{select}. Fra il test e l'esecuzione è
presente una finestra in cui potrebbe arrivare il segnale che non sarebbe
rilevato; la race condition diventa superabile disabilitando il segnale prima
del flag \macro{O\_ASYNC},\footnote{l'uso del flag di \macro{O\_ASYNC} e dei
comandi \macro{F\_SETOWN} e \macro{F\_GETOWN} per \func{fcntl} è specifico
di Linux e BSD.} aprire un file in modalità asincrona, così come è possibile
-attivare in un secondo tempo questa modalità settando questo flag attraverso
+attivare in un secondo tempo questa modalità impostando questo flag attraverso
l'uso di \func{fcntl} con il comando \macro{F\_SETFL} (vedi
-\secref{sec:file_fcntl}).
+\secref{sec:file_fcntl}).
In realtà in questo caso non si tratta di I/O asincrono vero e proprio, quanto
di un meccanismo asincrono di notifica delle variazione dello stato del file
\secref{sec:sig_sigaction}).
Per far questo però occorre utilizzare le funzionalità dei segnali real-time
-(vedi \secref{sec:sig_real_time}) settando esplicitamente con il comando
+(vedi \secref{sec:sig_real_time}) imopstando esplicitamente con il comando
\macro{F\_SETSIG} di \func{fcntl} un segnale real-time da inviare in caso di
-I/O asincrono (il segnale di default è \macro{SIGIO}). In questo caso il
+I/O asincrono (il segnale predefinito è \macro{SIGIO}). In questo caso il
manipolatore tutte le volte che riceverà \macro{SI\_SIGIO} come valore del
campo \var{si\_code}\footnote{il valore resta \macro{SI\_SIGIO} qualunque sia
il segnale che si è associato all'I/O asincrono, ed indica appunto che il
essere specificato l'indirizzo del buffer usato per l'I/O, ed in
\var{aio\_nbytes} la lunghezza del blocco di dati da trasferire.
-Il campo \var{aio\_reqprio} permette di settare la priorità delle operazioni
+Il campo \var{aio\_reqprio} permette di impostare la priorità delle operazioni
di I/O.\footnote{in generale perché ciò sia possibile occorre che la
piattaforma supporti questa caratteristica, questo viene indicato definendo
le macro \macro{\_POSIX\_PRIORITIZED\_IO}, e
- \macro{\_POSIX\_PRIORITY\_SCHEDULING}.} La priorità viene settata a partire
-da quella del processo chiamante (vedi \secref{sec:proc_priority}), cui viene
-sottratto il valore di questo campo.
+ \macro{\_POSIX\_PRIORITY\_SCHEDULING}.} La priorità viene impostata a
+partire da quella del processo chiamante (vedi \secref{sec:proc_priority}),
+cui viene sottratto il valore di questo campo.
Il campo \var{aio\_lio\_opcode} è usato soltanto dalla funzione
\func{lio\_listio}, che, come vedremo più avanti, permette di eseguire con una
\param{aiocbp}.
\bodydesc{Le funzioni restituiscono 0 in caso di successo, e -1 in caso di
- errore, nel qual caso \var{errno} viene settata ai valori:
+ errore, nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EBADF}] Si è specificato un file descriptor sbagliato.
\item[\macro{ENOSYS}] La funzione non è implementata.
Se l'operazione non si è ancora completata viene restituito l'errore di
\macro{EINPROGRESS}. La funzione ritorna zero quando l'operazione si è
conclusa con successo, altrimenti restituisce il codice dell'errore
-verificatosi, ed esegue il corrispondente settaggio di \var{errno}. Il codice
-può essere sia \macro{EINVAL} ed \macro{EBADF}, dovuti ad un valore errato per
-\param{aiocbp}, che uno degli errori possibili durante l'esecuzione
+verificatosi, ed esegue la corrispondente impostazione di \var{errno}. Il
+codice può essere sia \macro{EINVAL} ed \macro{EBADF}, dovuti ad un valore
+errato per \param{aiocbp}, che uno degli errori possibili durante l'esecuzione
dell'operazione di I/O richiesta, nel qual caso saranno restituiti, a seconda
del caso, i codici di errore delle system call \func{read}, \func{write} e
\func{fsync}.
\bodydesc{La funzione restituisce il risultato dell'operazione con un codice
di positivo, e -1 in caso di errore, che avviene qualora si sia specificato
- un valore non valido di \param{fildes}, setta \var{errno} al valore
+ un valore non valido di \param{fildes}, imposta \var{errno} al valore
\macro{EBADF}.}
\end{prototype}
\bodydesc{La funzione restituisce 0 se una (o più) operazioni sono state
completate, e -1 in caso di errore nel qual caso \var{errno} viene
- settata ai valori:
+ impostata ai valori:
\begin{errlist}
\item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
\param{timeout}.
secondo la modalità \param{mode}.
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
- errore, nel qual caso \var{errno} viene settata ai valori:
+ errore, nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EAGAIN}] Nessuna operazione è stata completata entro
\param{timeout}.
blocca fino al completamento di tutte le operazioni richieste; se invece si
specifica \macro{LIO\_NOWAIT} la funzione ritorna immediatamente dopo aver
messo in coda tutte le richieste. In questo caso il chiamante può richiedere
-la notifica del completamento di tutte le richieste, settando l'argomento
+la notifica del completamento di tutte le richieste, impostando l'argomento
\param{sig} in maniera analoga a come si fa per il campo \var{aio\_sigevent}
di \type{aiocb}.
\bodydesc{Le funzioni restituiscono il numero di byte letti o scritti in
caso di successo, e -1 in caso di errore, nel qual caso \var{errno} viene
- settata ai valori:
+ impostata ai valori:
\begin{errlist}
\item[\macro{EBADF}] si è specificato un file descriptor sbagliato.
\item[\macro{EINVAL}] si è specificato un valore non valido per uno degli
\bodydesc{La funzione restituisce il puntatore alla zona di memoria mappata
in caso di successo, e \macro{MAP\_FAILED} (-1) in caso di errore, nel
- qual caso \var{errno} viene settata ai valori:
+ qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EBADF}] Il file descriptor non è valido, e non si è usato
\macro{MAP\_ANONYMOUS}.
\item[\macro{EACCES}] Il file descriptor non si riferisce ad un file
- normale, o si è richiesto \macro{MAP\_PRIVATE} ma \param{fd} non è
- aperto in lettura, o si è richiesto \macro{MAP\_SHARED} e settato
+ regolare, o si è richiesto \macro{MAP\_PRIVATE} ma \param{fd} non è
+ aperto in lettura, o si è richiesto \macro{MAP\_SHARED} e impostato
\macro{PROT\_WRITE} ed \param{fd} non è aperto in lettura/scrittura, o
- si è settato \macro{PROT\_WRITE} ed \param{fd} è in
+ si è impostato \macro{PROT\_WRITE} ed \param{fd} è in
\textit{append-only}.
\item[\macro{EINVAL}] I valori di \param{start}, \param{length} o
\param{offset} non sono validi (o troppo grandi o non allineati sulla
dimensione delle pagine).
- \item[\macro{ETXTBSY}] Si è settato \macro{MAP\_DENYWRITE} ma \param{fd} è
- aperto in scrittura.
+ \item[\macro{ETXTBSY}] Si è impostato \macro{MAP\_DENYWRITE} ma \param{fd}
+ è aperto in scrittura.
\item[\macro{EAGAIN}] Il file è bloccato, o si è bloccata troppa memoria.
\item[\macro{ENOMEM}] Non c'è memoria o si è superato il limite sul numero
di mappature possibili.
\hline
\macro{MAP\_FIXED} & Non permette di restituire un indirizzo diverso
da \param{start}, se questo non può essere usato
- \func{mmap} fallisce. Se si setta questo flag il
+ \func{mmap} fallisce. Se si imposta questo flag il
valore di \param{start} deve essere allineato
alle dimensioni di una pagina. \\
\macro{MAP\_SHARED} & I cambiamenti sulla memoria mappata vengono
questo caso dopo una scrittura, se non c'è più
memoria disponibile, si ha l'emissione di
un \macro{SIGSEGV}. \\
- \macro{MAP\_LOCKED} & Se settato impedisce lo swapping delle pagine
+ \macro{MAP\_LOCKED} & Se impostato impedisce lo swapping delle pagine
mappate. \\
\macro{MAP\_GROWSDOWN} & Usato per gli stack. Indica
che la mappatura deve essere effettuata con gli
Sincronizza i contenuti di una sezione di un file mappato in memoria.
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
- errore nel qual caso \var{errno} viene settata ai valori:
+ errore nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EINVAL}] O \param{start} non è multiplo di \macro{PAGESIZE},
o si è specificato un valore non valido per \param{flags}.
Rilascia la mappatura sulla sezione di memoria specificata.
\bodydesc{La funzione restituisce 0 in caso di successo, e -1 in caso di
- errore nel qual caso \var{errno} viene settata ai valori:
+ errore nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EINVAL}] L'intervallo specificato non ricade in una zona
precedentemente mappata.
\subsection{Il \textit{mandatory locking}}
\label{sec:file_mand_locking}
-Il \textit{mandatory locking} è una opzione introdotta inizialmente in SVr4,
-
-
+Il \textit{mandatory locking} è una opzione introdotta inizialmente in SVr4,
+per introdurre un file locking che come dice il nome, fosse effettivo
+indipendentemente dai controlli eseguiti da un processo. Con il
+\textit{mandatory locking} infatti è possibile far eseguire il blocco del file
+direttamente al sistema, così che anche qualora non si predisponessero le
+opportune verifiche nei processi, questo verrebbe comunque rispettato.
+
+Per poter utilizzare il \textit{mandatory locking} è stato introdotto un
+utilizzo particolare del bit \acr{suid}. Se si ricorda quanto esposto in
+\secref{sec:file_suid_sgid}), esso viene di norma utlizzato per cambiare
+l'\textit{effective user ID} con cui viene eseguito un programma, ed è
+pertanto sempre associato alla presenza del permesso di esecuzione. Impostando
+questo bit su un file senza permesso di esecuzione in un sistema che supporta
+il \textit{mandatory locking}, fa sì che quest'ultimo venga attivato per il
+file in questione. In questo modo una combinaizone dei permessi
+originariamente non contemplata, in quanto senza significato, diventa
+l'indicazione della presenza o meno del \textit{mandatory locking}.
dandogli nome \var{newpath}.
\bodydesc{La funzione restituisce zero in caso di successo e -1 in
- caso di errore. La variabile \var{errno} viene settata
+ caso di errore. La variabile \var{errno} viene impostata
opportunamente, i principali codici di errore sono:
\begin{errlist}
\item[\macro{EXDEV}] \var{oldpath} e \var{newpath} non sono sullo
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
errore, nel qual caso il file non viene toccato. La variabile
- \var{errno} viene settata secondo i seguenti codici di errore:
+ \var{errno} viene impostata secondo i seguenti codici di errore:
\begin{errlist}
\item[\macro{EISDIR}] \var{pathname} si riferisce ad una directory
(valore specifico ritornato da Linux che non consente l'uso di
scrittura su di essa (dato che si va a rimuovere una voce dal suo contenuto) e
il diritto di esecuzione sulla directory che la contiene (torneremo in
dettaglio sui permessi e gli attributi in \secref{sec:file_access_control}),
-se inoltre lo \textit{sticky} bit è settato occorrerà anche essere proprietari
-del file o proprietari della directory (o root, per cui nessuna delle
-restrizioni è applicata).
+se inoltre lo \textit{sticky} bit è impostato occorrerà anche essere
+proprietari del file o proprietari della directory (o root, per cui nessuna
+delle restrizioni è applicata).
Una delle caratteristiche di queste funzioni è che la creazione/rimozione
del nome dalla directory e l'incremento/decremento del numero di riferimenti
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
errore, nel qual caso il file non viene toccato. La variabile
- \var{errno} viene settata secondo i seguenti codici di errore:
+ \var{errno} viene impostata secondo i seguenti codici di errore:
\begin{errlist}
\item[\macro{EISDIR}] \var{newpath} è una directory mentre \var{oldpath} non
è una directory.
\bodydesc{La funzione restituisce il numero di caratteri letti dentro
\var{buff} o -1 per un errore, nel qual caso la variabile
- \var{errno} viene settata a:
+ \var{errno} viene impostata a:
\begin{errlist}
\item[\macro{EINVAL}] \param{path} non è un link simbolico o \param{size}
non è positiva.
un pathname possano essere seguiti un numero limitato di link simbolici, il
cui valore limite è specificato dalla costante \macro{MAXSYMLINKS}. Qualora
questo limite venga superato viene generato un errore ed \var{errno} viene
-settata al valore \macro{ELOOP}.
+impostata al valore \macro{ELOOP}.
Un punto da tenere sempre presente è che, come abbiamo accennato, un link
simbolico può fare riferimento anche ad un file che non esiste; ad esempio
\secref{sec:file_access_control}) specificati da \var{mode} (i cui possibili
valori sono riportati in \tabref{tab:file_permission_const}) sono modificati
dalla maschera di creazione dei file (si veda \secref{sec:file_umask}). La
-titolarità della nuova directory è settata secondo quanto riportato in
+titolarità della nuova directory è impostata secondo quanto riportato in
\secref{sec:file_ownership}.
La seconda funzione serve ad eliminare una directory già vuota (la directory
\begin{errlist}
\item[\macro{EPERM}] Il filesystem non supporta la cancellazione di
directory, oppure la directory che contiene \var{dirname} ha lo sticky bit
- settato e l'\textit{effective user id} del processo non corrisponde al
- proprietario della directory.
+ impostato e l'\textit{effective user id} del processo non corrisponde al
+ proprietario della directory.
\item[\macro{EACCESS}] Non c'è il permesso di scrittura per la directory che
contiene la directory che si vuole cancellare, o non c'è il permesso di
attraversare (esecuzione) una delle directory specificate in
socket sono un caso a parte, che vedremo in \capref{cha:socket_intro}).
La manipolazione delle caratteristiche di questi file e la loro cancellazione
-può essere effettuata con le stesse funzioni che operano sui file normali; ma
+può essere effettuata con le stesse funzioni che operano sui file regolari; ma
quando li si devono creare sono necessarie delle funzioni apposite. La prima
di queste funzioni è \func{mknod}, il suo prototipo è:
\begin{functions}
\end{functions}
La funzione permette di creare un file speciale, ma si può usare anche per
-creare file normali e fifo; l'argomento \param{mode} specifica il tipo di file
-che si vuole creare ed i relativi permessi, secondo i valori riportati in
+creare file regolari e fifo; l'argomento \param{mode} specifica il tipo di
+file che si vuole creare ed i relativi permessi, secondo i valori riportati in
\tabref{tab:file_mode_flags}, che vanno combinati con un OR binario. I
permessi sono comunque modificati nella maniera usuale dal valore di
\var{umask} (si veda \secref{sec:file_umask}).
Per il tipo di file può essere specificato solo uno fra: \macro{S\_IFREG} per
-un file normale (che sarà creato vuoto), \macro{S\_IFBLK} per un device a
+un file regolare (che sarà creato vuoto), \macro{S\_IFBLK} per un device a
blocchi, \macro{S\_IFCHR} per un device a caratteri e \macro{S\_IFIFO} per una
fifo. Un valore diverso comporterà l'errore \macro{EINVAL}. Qualora si sia
specificato in \param{mode} un file di dispositivo, il valore di \param{dev}
-viene usato per indicare a quale dispositivo si fa riferimento.
+viene usato per indicare a quale dispositivo si fa riferimento.
Solo l'amministratore può creare un file di dispositivo o un file regolare
usando questa funzione; ma in Linux\footnote{la funzione non è prevista dallo
che è quella a cui si fa riferimento quando un filename è espresso in forma
relativa, dove il ``relativa'' fa riferimento appunto a questa directory.
-Quando un utente effettua il login questa directory viene settata alla
+Quando un utente effettua il login questa directory viene impostata alla
\textit{home directory} del suo account. Il comando \cmd{cd} della shell
consente di cambiarla a piacere, spostandosi da una directory ad un'altra, il
comando \cmd{pwd} la stampa sul terminale. Siccome la directory corrente
\bodydesc{La funzione restituisce il puntatore \var{buffer} se riesce,
\macro{NULL} se fallisce, in quest'ultimo caso la variabile
- \var{errno} è settata con i seguenti codici di errore:
+ \var{errno} è impostata con i seguenti codici di errore:
\begin{errlist}
\item[\macro{EINVAL}] L'argomento \var{size} è zero e \var{buffer} non
è nullo.
Cambia la directory di lavoro corrente in \param{pathname}.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 per un errore,
- nel qual caso \var{errno} viene settata a:
+ nel qual caso \var{errno} viene impostata a:
\begin{errlist}
\item[\macro{ENOTDIR}] Non si è specificata una directory.
\item[\macro{EACCESS}] Manca il permesso di ricerca su uno dei componenti di
pathname.
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
- errore, in caso di errore \var{errno} viene settata ai valori
+ errore, in caso di errore \var{errno} viene impostata ai valori
\macro{EBADF} o \macro{EACCES}.}
\end{prototype}
\noindent anche in questo caso \param{fd} deve essere un file descriptor
non esistente al momento dell'invocazione.
\bodydesc{La funzione ritorna il puntatore alla stringa con il nome o
- \macro{NULL} in caso di fallimento, \var{errno} viene settata a
+ \macro{NULL} in caso di fallimento, \var{errno} viene impostata a
\macro{ENOMEM} qualora fallisca l'allocazione della stringa.}
\end{prototype}
\bodydesc{La funzione ritorna il puntatore allo stream associato al file
temporaneo in caso di successo e \macro{NULL} in caso di errore, nel qual
- caso \var{errno} viene settata a
+ caso \var{errno} viene impostata a
\begin{errlist}
\item[\macro{EINTR}] La funzione è stata interrotta da un segnale.
\item[\macro{EEXIST}] Non è stato possibile generare un nome univoco.
\bodydesc{La funzione ritorna il puntatore \param{template} in caso di
successo e \macro{NULL} in caso di errore, nel qual caso \var{errno} viene
- settata a:
+ impostata a:
\begin{errlist}
\item[\macro{EINVAL}] \param{template} non termina con \code{XXXXXX}.
\end{errlist}}
finali di \param{template}.
\bodydesc{La funzione ritorna il file descriptor in caso successo e
- -1 in caso di errore, nel qual caso \var{errno} viene settata a:
+ -1 in caso di errore, nel qual caso \var{errno} viene impostata a:
\begin{errlist}
\item[\macro{EINVAL}] \param{template} non termina con \code{XXXXXX}.
\item[\macro{EEXIST}] non è riuscita a creare un file temporano, il
essere una stringa costante. La funzione apre un file in lettura/scrittura con
la funzione \func{open}, usando l'opzione \macro{O\_EXCL} (si veda
\secref{sec:file_open}), in questo modo al ritorno della funzione si ha la
-certezza di essere i soli utenti del file. I permessi sono settati al valore
+certezza di essere i soli utenti del file. I permessi sono impostati al valore
\code{0600}\footnote{questo è vero a partire dalle \acr{glibc} 2.0.7, le
versioni precedenti delle \acr{glibc} e le vecchie \acr{libc5} e \acr{libc4}
usavano il valore \code{0666} che permetteva a chiunque di leggere i
\bodydesc{La funzione ritorna il puntatore al nome della directory in caso
successo e \macro{NULL} in caso di errore, nel qual caso \var{errno} viene
- settata a:
+ impostata a:
\begin{errlist}
\item[\macro{EINVAL}] \param{template} non termina con \code{XXXXXX}.
\end{errlist}
\label{sec:file_file_size}
Il membro \var{st\_size} contiene la dimensione del file in byte (se il file è
-un file normale, nel caso di un link simbolico la dimensione è quella del
+un file regolare, nel caso di un link simbolico la dimensione è quella del
pathname che contiene).
Il campo \var{st\_blocks} definisce la lunghezza del file in blocchi di 512
eccetto che si usa con un file aperto, specificato tramite il suo file
descriptor \var{fd}.
- \bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per
- un errore, nel qual caso \var{errno} viene settato opportunamente;
- per \func{ftruncate} si hanno i valori:
+ \bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per un
+ errore, nel qual caso \var{errno} viene impostata opportunamente; per
+ \func{ftruncate} si hanno i valori:
\begin{errlist}
\item[\macro{EBADF}] \var{fd} non è un file descriptor.
\item[\macro{EINVAL}] \var{fd} è un riferimento ad un socket, non a un file
\param{times}. Se questa è \macro{NULL} allora viene usato il tempo corrente.
\bodydesc{La funzione restituisce zero in caso di successo e -1 in caso
- di errore, nel qual caso \var{errno} è settata opportunamente.
+ di errore, nel qual caso \var{errno} è impostata opportunamente.
\begin{errlist}
\item[\macro{EACCESS}] non si ha il permesso di scrittura sul file.
\item[\macro{ENOENT}] \param{filename} non esiste.
\end{lstlisting}
L'effetto della funzione e i privilegi necessari per eseguirla dipendono da
-cosa è l'argomento \param{times}; se è \macro{NULL} la funzione setta il tempo
-corrente ed è sufficiente avere accesso in scrittura al file; se invece si è
-specificato un valore la funzione avrà successo solo se si è proprietari del
-file (o si hanno i privilegi di amministratore).
+cosa è l'argomento \param{times}; se è \macro{NULL} la funzione imposta il
+tempo corrente ed è sufficiente avere accesso in scrittura al file; se invece
+si è specificato un valore la funzione avrà successo solo se si è proprietari
+del file (o si hanno i privilegi di amministratore).
Si tenga presente che non è comunque possibile specificare il tempo di
cambiamento di stato del file, che viene comunque cambiato dal kernel tutte le
simbolico tutti i permessi come concessi; utente e gruppo a cui esso
appartiene vengono pure ignorati quando il link viene risolto, vengono
controllati solo quando viene richiesta la rimozione del link e quest'ultimo è
-in una directory con lo \textsl{sticky bit} settato (si veda
+in una directory con lo \textsl{sticky bit} impostato (si veda
\secref{sec:file_sticky}).
La procedura con cui il kernel stabilisce se un processo possiede un certo
\item se il relativo\footnote{per relativo si intende il bit di user-read se
il processo vuole accedere in scrittura, quello di user-write per
l'accesso in scrittura, etc.} bit dei permessi d'accesso dell'utente è
- settato, l'accesso è consentito
+ impostato, l'accesso è consentito
\item altrimenti l'accesso è negato
\end{itemize*}
\item Se l'\textit{effective group id} del processo o uno dei
\textit{supplementary group id} dei processi corrispondono al \acr{gid} del
file allora:
\begin{itemize*}
- \item se il bit dei permessi d'accesso del gruppo è settato, l'accesso è
+ \item se il bit dei permessi d'accesso del gruppo è impostato, l'accesso è
consentito,
\item altrimenti l'accesso è negato
\end{itemize*}
-\item se il bit dei permessi d'accesso per tutti gli altri è settato,
+\item se il bit dei permessi d'accesso per tutti gli altri è impostato,
l'accesso è consentito, altrimenti l'accesso è negato.
\end{enumerate}
\macro{S\_ISUID} e \macro{S\_ISGID}.
Come spiegato in dettaglio in \secref{sec:proc_exec}, quando si lancia un
-programma il comportamento normale del kernel è quello di settare
+programma il comportamento normale del kernel è quello di impostare
l'\textit{effective user id} e l'\textit{effective group id} del nuovo
processo all'\acr{uid} e al \acr{gid} del processo corrente, che normalmente
corrispondono dell'utente con cui si è entrati nel sistema.
Se però il file del programma\footnote{per motivi di sicurezza il kernel
ignora i bit \acr{suid} e \acr{sgid} per gli script eseguibili.} (che
-ovviamente deve essere eseguibile) ha il bit \acr{suid} settato, il kernel
+ovviamente deve essere eseguibile) ha il bit \acr{suid} impostato, il kernel
assegnerà come \textit{effective user id} al nuovo processo l'\acr{uid} del
proprietario del file al posto dell'\acr{uid} del processo originario. Avere
-il bit \acr{sgid} settato ha lo stesso effetto sull'\textit{effective group
+il bit \acr{sgid} impostato ha lo stesso effetto sull'\textit{effective group
id} del processo.
I bit \acr{suid} e \acr{sgid} vengono usati per permettere agli utenti normali
password, quest'ultimo ovviamente può essere scritto solo dall'amministratore,
ma non è necessario chiamare l'amministratore per cambiare la propria
password. Infatti il comando \cmd{passwd} appartiene a root ma ha il bit
-\acr{suid} settato per cui quando viene lanciato da un utente normale parte
+\acr{suid} impostato per cui quando viene lanciato da un utente normale parte
con i privilegi di root.
Chiaramente avere un processo che ha privilegi superiori a quelli che avrebbe
La presenza dei bit \acr{suid} e \acr{sgid} su un file può essere rilevata con
il comando \cmd{ls -l}, che visualizza una lettera \cmd{s} al posto della
\cmd{x} in corrispondenza dei permessi di utente o gruppo. La stessa lettera
-\cmd{s} può essere usata nel comando \cmd{chmod} per settare questi bit.
+\cmd{s} può essere usata nel comando \cmd{chmod} per impostare questi bit.
Infine questi bit possono essere controllati all'interno di \var{st\_mode} con
l'uso delle due costanti \macro{S\_ISUID} e \macro{S\_IGID}, i cui valori sono
riportati in \tabref{tab:file_mode_flags}.
proposito).
Infine Linux utilizza il bit \acr{sgid} per una ulteriore estensione mutuata
-da SVr4. Il caso in cui un file ha il bit \acr{sgid} settato senza che lo sia
+da SVr4. Il caso in cui un file ha il bit \acr{sgid} impostare senza che lo sia
anche il corrispondente bit di esecuzione viene utilizzato per attivare per
quel file il \textit{mandatory locking} (argomento che affronteremo in
dettagliopiù avanti in \secref{sec:file_mand_locking}).
parte un rimasuglio delle origini dei sistemi Unix. A quell'epoca infatti la
memoria virtuale e l'accesso ai files erano molto meno sofisticati e per
ottenere la massima velocità possibile per i programmi usati più comunemente
-si poteva settare questo bit.
+si poteva impostare questo bit.
L'effetto di questo bit era che il segmento di testo del programma (si veda
\secref{sec:proc_mem_layout} per i dettagli) veniva scritto nella swap la
\cmd{x} nei permessi per gli altri.
Ovviamente per evitare che gli utenti potessero intasare la swap solo
-l'amministratore era in grado di settare questo bit, che venne chiamato anche
-con il nome di \textit{saved text bit}, da cui deriva quello della costante.
-Le attuali implementazioni di memoria virtuale e filesystem rendono
+l'amministratore era in grado di impostare questo bit, che venne chiamato
+anche con il nome di \textit{saved text bit}, da cui deriva quello della
+costante. Le attuali implementazioni di memoria virtuale e filesystem rendono
sostanzialmente inutile questo procedimento.
Benché ormai non venga più utilizzato per i file, lo \textsl{sticky bit} ha
invece assunto un uso importante per le directory;\footnote{lo \textsl{sticky
bit} per le directory è un'estensione non definita nello standard POSIX,
Linux però la supporta, così come BSD e SVR4.} in questo caso se il bit è
-settato un file potrà essere rimosso dalla directory soltanto se l'utente ha
+impostato un file potrà essere rimosso dalla directory soltanto se l'utente ha
il permesso di scrittura su di essa ed inoltre è vera una delle seguenti
condizioni:
\begin{itemize*}
\item l'utente è proprietario della directory
\item l'utente è l'amministratore
\end{itemize*}
-un classico esempio di directory che ha questo bit settato è \file{/tmp}, i
-permessi infatti di solito sono settati come:
+un classico esempio di directory che ha questo bit impostato è \file{/tmp}, i
+permessi infatti di solito sono impostati come:
\begin{verbatim}
$ ls -ld /tmp
drwxrwxrwt 6 root root 1024 Aug 10 01:03 /tmp
semantica BSD. Linux invece segue quella che viene chiamata semantica SVr4; di
norma cioè il nuovo file viene creato, seguendo la prima opzione, con il
\acr{gid} del processo, se però la directory in cui viene creato il file ha il
-bit \acr{sgid} settato allora viene usata la seconda opzione.
+bit \acr{sgid} impostato allora viene usata la seconda opzione.
Usare la semantica BSD ha il vantaggio che il \acr{gid} viene sempre
automaticamente propagato, restando coerente a quello della directory di
partenza, in tutte le sottodirectory. La semantica SVr4 offre la possibilità
di scegliere, ma per ottenere lo stesso risultato di coerenza che si ha con
BSD necessita che per le nuove directory venga anche propagato anche il bit
-\acr{sgid}. Questo è il comportamento di default di \func{mkdir}, ed è in
+\acr{sgid}. Questo è il comportamento predefinito di \func{mkdir}, ed è in
questo modo ad esempio che Debian assicura che le sottodirectory create nelle
home di un utente restino sempre con il \acr{gid} del gruppo primario dello
stesso.
da \var{pathname}.
\bodydesc{La funzione ritorna 0 se l'accesso è consentito, -1 altrimenti; in
- quest'ultimo caso la variabile \var{errno} viene settata secondo i codici di
+ quest'ultimo caso la variabile \var{errno} viene impostata secondo i codici di
errore: \macro{EACCES}, \macro{EROFS}, \macro{EFAULT}, \macro{EINVAL},
\macro{ENAMETOOLONG}, \macro{ENOENT}, \macro{ENOTDIR}, \macro{ELOOP},
\macro{EIO}.}
anche se si è proprietari del file non tutte le operazioni sono permesse, in
particolare:
\begin{enumerate}
-\item siccome solo l'amministratore può settare lo \textit{sticky bit}, se
+\item siccome solo l'amministratore può impostare lo \textit{sticky bit}, se
l'\textit{effective user id} del processo non è zero esso viene
automaticamente cancellato (senza notifica di errore) qualora sia stato
indicato in \var{mode}.
\label{sec:file_umask}
Oltre che dai valori indicati in sede di creazione, i permessi assegnati ai
-nuovi file sono controllati anche da una maschera di bit settata con la
+nuovi file sono controllati anche da una maschera di bit impostata con la
funzione \func{umask}, il cui prototipo è:
\begin{prototype}{stat.h}
{mode\_t umask(mode\_t mask)}
- Setta la maschera dei permessi dei bit al valore specificato da \var{mask}
+ Imposta la maschera dei permessi dei bit al valore specificato da \var{mask}
(di cui vengono presi solo i 9 bit meno significativi).
\bodydesc{La funzione ritorna il precedente valore della maschera. È una
indicati nella maschera vengono infatti esclusi quando un nuovo file viene
creato.
-In genere questa maschera serve per impostare un default che escluda alcuni
-permessi (usualmente quello di scrittura per il gruppo e gli altri,
-corrispondente ad un valore di $022$). Essa è utile perché le routine
-dell'interfaccia ANSI C degli stream non prevedono l'esistenza dei permessi, e
-pertanto tutti i nuovi file vengono sempre creati con un default di $666$
-(cioè permessi di lettura e scrittura per tutti, si veda
+In genere questa maschera serve per impostare un valore predefinito dei
+permessi che ne escluda alcuni (usualmente quello di scrittura per il gruppo e
+gli altri, corrispondente ad un valore di $022$). Essa è utile perché le
+routine dell'interfaccia ANSI C degli stream non prevedono l'esistenza dei
+permessi, e pertanto tutti i nuovi file vengono sempre creati con un valore di
+$666$ (cioè permessi di lettura e scrittura per tutti, si veda
\tabref{tab:file_permission_const} per un confronto); in questo modo è
possibile cancellare automaticamente i permessi non voluti, senza doverlo fare
esplicitamente.
specificati dalle variabili \var{owner} e \var{group}.
\bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per
- un errore, in caso di errore \var{errno} viene settato ai valori:
+ un errore, in caso di errore \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EPERM}] L'\textit{effective user id} non corrisponde a quello
del proprietario del file o non è zero, o utente e gruppo non sono validi
\param{path}.
\bodydesc{La funzione restituisce zero in caso di successo e -1 per
- un errore, in caso di errore \var{errno} viene settato ai valori:
+ un errore, in caso di errore \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EPERM}] L'\textit{effective user id} non è zero.
\end{errlist}
\multicolumn{2}{|c|}{\textbf{Tipo di file}} & \textbf{Descrizione} \\
\hline
\hline
- \textit{regular file} & \textsl{file normale} &
+ \textit{regular file} & \textsl{file regolare} &
un file che contiene dei dati (l'accezione normale di file) \\
\textit{directory} & \textsl{cartella o direttorio} &
un file che contiene una lista di nomi associati a degli \textit{inodes}
fisici che contengono i dati e così via; le informazioni che la funzione
\func{stat} fornisce provengono dall'\textit{inode}; dentro una directory si
troverà solo il nome del file e il numero dell'\textit{inode} ad esso
- associato, cioè quella che da qui in poi chiameremo una \textsl{voce}
- (traduzione approssimata dell'inglese \textit{directory entry}, che non
- useremo anche per evitare confusione con le \textit{dentry} del kernel di
- cui si parlava in \secref{sec:file_vfs}).
+ associato, cioè quella che da qui in poi chiameremo una \textsl{voce} (come
+ traduzione dell'inglese \textit{directory entry}, che non useremo anche per
+ evitare confusione con le \textit{dentry} del kernel di cui si parlava in
+ \secref{sec:file_vfs}).
\item Come mostrato in \curfig\ si possono avere più voci che puntano allo
stesso \textit{inode}. Ogni \textit{inode} ha un contatore che contiene il
non sono presenti sugli altri filesystem Unix. Le principali sono le seguenti:
\begin{itemize}
\item i \textit{file attributes} consentono di modificare il comportamento del
- kernel quando agisce su gruppi di file. Possono essere settati su file e
+ kernel quando agisce su gruppi di file. Possono essere impostati su file e
directory e in quest'ultimo caso i nuovi file creati nella directory
ereditano i suoi attributi.
\item sono supportate entrambe le semantiche di BSD e SVr4 come opzioni di
con lo stesso identificatore di gruppo della directory che li contiene. La
semantica SVr4 comporta che i file vengono creati con l'identificatore del
gruppo primario del processo, eccetto il caso in cui la directory ha il bit
- di \acr{sgid} settato (per una descrizione dettagliata del significato di
+ di \acr{sgid} impostato (per una descrizione dettagliata del significato di
questi termini si veda \secref{sec:file_access_control}), nel qual caso file
e subdirectory ereditano sia il \acr{gid} che lo \acr{sgid}.
\item l'amministratore può scegliere la dimensione dei blocchi del filesystem
non fanno riferimento ad un dispositivo interattivo, e che lo standard
error non sia mai aperto in modalità \textit{fully buffered}.
-Linux, come BSD e SVr4, specifica il comportamento di default in maniera
+Linux, come BSD e SVr4, specifica il comportamento predefinito in maniera
ancora più precisa, e cioè impone che lo standard error sia sempre
\textit{unbuffered} (in modo che i messaggi di errore siano mostrati il più
rapidamente possibile) e che standard input e standard output siano aperti in
\bodydesc{Le funzioni ritornano un puntatore valido in caso di
successo e \macro{NULL} in caso di errore, in tal caso \var{errno}
- viene settata al valore ricevuto dalla funzione sottostante di cui è
+ viene impostata al valore ricevuto dalla funzione sottostante di cui è
fallita l'esecuzione.
Gli errori pertanto possono essere quelli di \code{malloc} per tutte
Nel caso si usi \func{fdopen} i valori specificati da \param{mode} devono
essere compatibili con quelli con cui il file descriptor è stato aperto.
Inoltre i modi \cmd{w} e \cmd{w+} non troncano il file. La posizione nello
-stream viene settata a quella corrente nel file descriptor, e le variabili di
+stream viene impostata a quella corrente nel file descriptor, e le variabili di
errore e di fine del file (vedi \secref{sec:file_io}) sono cancellate. Il file
non viene duplicato e verrà chiuso alla chiusura dello stream.
I nuovi file saranno creati secondo quanto visto in
-\secref{sec:file_ownership} ed avranno i permessi di accesso settati al
+\secref{sec:file_ownership} ed avranno i permessi di accesso impostati al
valore \macro{S\_IRUSR|S\_IWUSR|S\_IRGRP|S\_IWGRP|S\_IROTH|S\_IWOTH}
(pari a \macro{0666}) modificato secondo il valore di \acr{umask} per il
processo (si veda \secref{sec:file_umask}).
Chiude lo stream \param{stream}.
\bodydesc{Restituisce 0 in caso di successo e \macro{EOF} in caso di errore,
- nel qual caso setta \var{errno} a \macro{EBADF} se il file descriptor
+ nel qual caso imposta \var{errno} a \macro{EBADF} se il file descriptor
indicato da \param{stream} non è valido, o uno dei valori specificati
dalla sottostante funzione che è fallita (\func{close}, \func{write} o
\func{fflush}).}
valori diversi.} definito anch'esso nell'header \file{stdlib.h}.
Dato che le funzioni dell'interfaccia degli stream sono funzioni di libreria
-che si appoggiano a delle system call, esse non settano direttamente la
-variabile \var{errno}, che mantiene il valore settato dalla system call che ha
+che si appoggiano a delle system call, esse non impostano direttamente la
+variabile \var{errno}, che mantiene il valore impostato dalla system call che ha
riportato l'errore.
Siccome la condizione di end-of-file è anch'essa segnalata come errore, nasce
il problema di come distinguerla da un errore effettivo; basarsi solo sul
valore di ritorno della funzione e controllare il valore di \var{errno}
-infatti non basta, dato che quest'ultimo potrebbe essere stato settato in una
+infatti non basta, dato che quest'ultimo potrebbe essere stato impostato in una
altra occasione, (si veda \secref{sec:sys_errno} per i dettagli del
funzionamento di \var{errno}).
Controlla il flag di errore di \param{stream}.
\bodydesc{Entrambe le funzioni ritornano un valore diverso da zero se
- i relativi flag sono settati.}
+ i relativi flag sono impostati.}
\end{functions}
\noindent si tenga presente comunque che la lettura di questi flag segnala
soltanto che c'è stato un errore, o che si è raggiunta la fine del file in una
La funzione \func{fread} legge sempre un numero intero di elementi, se
incontra la fine del file l'oggetto letto parzialmente viene scartato
(lo stesso avviene in caso di errore). In questo caso la posizione dello
-stream viene settata alla fine del file (e non a quella corrispondente
+stream viene impostata alla fine del file (e non a quella corrispondente
alla quantità di dati letti).
In caso di errore (o fine del file per \func{fread}) entrambe le
i valori delle variabili, secondo la tecnica spiegata in
\secref{sec:proc_var_passing}).
-Se si passa alla funzione l'indirizzo ad un puntatore settato a
+Se si passa alla funzione l'indirizzo ad un puntatore impostato a
\macro{NULL} e \var{*n} è zero, la funzione provvede da sola
all'allocazione della memoria necessaria a contenere la linea. In tutti
i casi si ottiene dalla funzione un puntatore all'inizio del testo della
\begin{functions}
\headdecl{stdio.h}
- \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Setta la posizione
+ \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Imposta la posizione
corrente nello stream \param{stream} al valore specificato da \param{pos}.
\funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Scrive la posizione
Legge il file descriptor sottostante lo stream \param{stream}.
\bodydesc{Restituisce il numero del file descriptor in caso di successo, e
- -1 qualora \param{stream} non sia valido, nel qual caso setta \var{errno}
+ -1 qualora \param{stream} non sia valido, nel qual caso imposta \var{errno}
a \macro{EBADF}.}
\end{prototype}
\noindent ed in questo modo diventa possibile usare direttamente \func{fcntl}.
\begin{prototype}{stdio.h}{int setvbuf(FILE *stream, char *buf, int mode,
size\_t size)}
- Setta la bufferizzazione dello stream \param{stream} nella modalità indicata
- da \param{mode}, usando \param{buf} come buffer di lunghezza \param{size}.
+ Imposta la bufferizzazione dello stream \param{stream} nella modalità
+ indicata da \param{mode}, usando \param{buf} come buffer di lunghezza
+ \param{size}.
\bodydesc{Restituisce zero in caso di successo, ed un valore qualunque in
- caso di errore, nel qual caso \var{errno} viene settata opportunamente.}
+ caso di errore, nel qual caso \var{errno} viene impostata opportunamente.}
\end{prototype}
La funzione permette di controllare tutti gli aspetti della bufferizzazione;
\hline
\end{tabular}
\caption{Valori del parametro \param{mode} di \func{setvbuf}
- per il settaggio delle modalità di bufferizzazione.}
+ per l'impostazione delle modalità di bufferizzazione.}
\label{tab:file_stream_buf_mode}
\end{table}
-Per evitare che \func{setvbuf} setti il buffer basta passare un valore
+Per evitare che \func{setvbuf} imposti il buffer basta passare un valore
\macro{NULL} per \param{buf} e la funzione ignorerà il parametro \param{size}
usando il buffer allocato automaticamente dal sistema. Si potrà comunque
modificare la modalità di bufferizzazione, passando in \param{mode} uno degli
Forza la scrittura di tutti i dati bufferizzati dello stream \param{stream}.
\bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di
- errore, settando \var{errno} a \macro{EBADF} se \param{stream} non è
+ errore, impostando \var{errno} a \macro{EBADF} se \param{stream} non è
aperto o non è aperto in scrittura, o ad uno degli errori di
\func{write}.}
\end{prototype}
valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.}
\end{prototype}
-La funzione setta o legge lo stato della modalità di operazione di uno stream
+La funzione imposta o legge lo stato della modalità di operazione di uno stream
nei confronti del locking a seconda del valore specificato con \param{type},
che può essere uno dei seguenti:
\begin{basedescript}{\desclabelwidth{4.0cm}}
\item[\macro{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco
- implicito di default.
+ implicito predefinito.
\item[\macro{FSETLOCKING\_BYCALLER}] Al ritorno della funzione sarà l'utente a
dover gestire da solo il locking dello stream.
\item[\macro{FSETLOCKING\_QUERY}] Restituisce lo stato corrente della modalità
specificati da \var{mode}.
\bodydesc{La funzione ritorna il file descriptor in caso di successo e -1 in
- caso di errore. In questo caso la variabile \var{errno} viene settata ad
+ caso di errore. In questo caso la variabile \var{errno} viene impostata ad
uno dei valori:
\begin{errlist}
\item[\macro{EEXIST}] \var{pathname} esiste e si è specificato
l'accesso in scrittura.
\item[\macro{ENOTDIR}] si è specificato \macro{O\_DIRECTORY} e \var{pathname}
non è una directory.
- \item[\macro{ENXIO}] si sono settati \macro{O\_NOBLOCK} o \macro{O\_WRONLY}
+ \item[\macro{ENXIO}] si sono impostati \macro{O\_NOBLOCK} o \macro{O\_WRONLY}
ed il file è una fifo che non viene letta da nessun processo o
\var{pathname} è un file di dispositivo ma il dispositivo è assente.
\item[\macro{ENODEV}] \var{pathname} si riferisce a un file di dispositivo
\hline
\hline % modalità di operazione col file
\macro{O\_APPEND} & il file viene aperto in append mode. Prima di ciascuna
- scrittura la posizione corrente viene sempre settata alla fine del
+ scrittura la posizione corrente viene sempre impostata alla fine del
file. Può causare corruzione del file con NFS se più di un processo scrive
allo stesso tempo.\footnotemark\\
\macro{O\_NONBLOCK} & il file viene aperto in modalità non bloccante per
\macro{O\_NDELAY} & in Linux\footnotemark\ è sinonimo di
\macro{O\_NONBLOCK}.\\
\macro{O\_ASYNC} & apre il file per l'I/O in modalità
- asincrona (vedi \secref{sec:file_asyncronous_io}). Quando è settato viene
+ asincrona (vedi \secref{sec:file_asyncronous_io}). Quando è impostato viene
generato il segnale \macro{SIGIO} tutte le volte che sono disponibili
dati in input sul file. \\
\macro{O\_SYNC} & apre il file per l'input/output sincrono, ogni
Il nuovo file descriptor non è condiviso con nessun altro processo, (torneremo
sulla condivisione dei file, in genere accessibile dopo una \func{fork}, in
-\secref{sec:file_sharing}). Il nuovo file descriptor è settato di default per
-restare aperto attraverso una \func{exec} (come accennato in
-\secref{sec:proc_exec}) e l'offset è settato all'inizio del file.
+\secref{sec:file_sharing}). Il nuovo file descriptor è impostato per restare
+aperto attraverso una \func{exec} (come accennato in \secref{sec:proc_exec}) e
+l'offset è impostato all'inizio del file.
L'argomento \param{mode} specifica i permessi con cui il file viene
eventualmente creato; i valori possibili sono gli stessi già visti in
\item \textsl{i bit delle modalità di accesso}: specificano con quale modalità
si accederà al file: i valori possibili sono lettura, scrittura o
lettura/scrittura. Uno di questi bit deve essere sempre specificato quando
- si apre un file. Vengono settati alla chiamata da \func{open}, e possono
+ si apre un file. Vengono impostati alla chiamata da \func{open}, e possono
essere riletti con una \func{fcntl} (fanno parte del \textit{file status
flag}), ma non possono essere modificati.
\item \textsl{i bit delle modalità di apertura}: permettono di specificare
\item \textsl{i bit delle modalità di operazione}: permettono di specificare
alcune caratteristiche del comportamento delle future operazioni sul file
(come la \func{read} o la \func{write}). Anch'essi fanno parte del
- \textit{file status flag}. Il loro valore è settato alla chiamata di
+ \textit{file status flag}. Il loro valore è impostato alla chiamata di
\func{open}, ma possono essere riletti e modificati (insieme alle
caratteristiche operative che controllano) con una \func{fcntl}.
\end{itemize}
Chiude il descrittore \var{fd}.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
- ed in questo caso \var{errno} è settata ai valori:
+ ed in questo caso \var{errno} è impostata ai valori:
\begin{errlist}
\item[\macro{EBADF}] \var{fd} non è un descrittore valido.
\item[\macro{EINTR}] la funzione è stata interrotta da un segnale.
automaticamente spostata in avanti del numero di byte letti o scritti.
In genere (a meno di non avere richiesto la modalità \macro{O\_APPEND}) questa
-posizione viene settata a zero all'apertura del file. È possibile settarla ad
+posizione viene impostata a zero all'apertura del file. È possibile impostarla ad
un valore qualsiasi con la funzione \func{lseek}, il cui prototipo è:
\begin{functions}
\headdecl{sys/types.h}
\headdecl{unistd.h}
\funcdecl{off\_t lseek(int fd, off\_t offset, int whence)}
- Setta la posizione attuale nel file.
+ Imposta la posizione attuale nel file.
\bodydesc{La funzione ritorna valore della posizione corrente in caso di
- successo e -1 in caso di errore nel qual caso \var{errno} viene settata ad
+ successo e -1 in caso di errore nel qual caso \var{errno} viene impostata ad
uno dei valori:
\begin{errlist}
\item[\macro{ESPIPE}] \param{fd} è una pipe, un socket o una fifo.
ed inoltre \macro{EBADF}.}
\end{functions}
-La nuova posizione è settata usando il valore specificato da \param{offset},
+La nuova posizione è impostata usando il valore specificato da \param{offset},
sommato al riferimento dato da \param{whence}; quest'ultimo può assumere i
seguenti valori\footnote{per compatibilità con alcune vecchie notazioni
questi valori possono essere rimpiazzati rispettivamente con 0, 1 e 2 o con
\end{basedescript}
Come accennato in \secref{sec:file_file_size} con \func{lseek} è possibile
-settare la posizione corrente anche al di la della fine del file, e alla
+impostare la posizione corrente anche al di la della fine del file, e alla
successiva scrittura il file sarà esteso. La chiamata non causa nessuna
attività di input/output, si limita a modificare la posizione corrente nel
kernel (cioè \var{f\_pos} in \var{file}, vedi \figref{fig:file_proc_file}).
Si tenga presente inoltre che usare \macro{SEEK\_END} non assicura affatto che
successiva scrittura avvenga alla fine del file, infatti se questo è stato
aperto anche da un altro processo che vi ha scritto, la fine del file può
-essersi spostata, ma noi scriveremo alla posizione settata in precedenza.
+essersi spostata, ma noi scriveremo alla posizione impostata in precedenza.
(questa è una potenziale sorgente di
\textit{race condition}\index{race condition}, vedi \secref{sec:file_atomic}).
Cerca di leggere \var{count} byte dal file \var{fd} al buffer \var{buf}.
\bodydesc{La funzione ritorna il numero di byte letti in caso di successo e
- -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+ -1 in caso di errore, nel qual caso \var{errno} viene impostata ad uno dei
valori:
\begin{errlist}
\item[\macro{EINTR}] la funzione è stata interrotta da un segnale prima di
\var{offset}, nel buffer \var{buf}.
\bodydesc{La funzione ritorna il numero di byte letti in caso di successo e -1
- in caso di errore, nel qual caso \var{errno} viene settata secondo i valori
+ in caso di errore, nel qual caso \var{errno} viene impostata secondo i valori
già visti per \func{read} e \func{lseek}.}
\end{prototype}
\noindent che però diventa accessibile solo con la definizione della macro:
Scrive \var{count} byte dal buffer \var{buf} sul file \var{fd}.
\bodydesc{La funzione ritorna il numero di byte scritti in caso di successo
- e -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+ e -1 in caso di errore, nel qual caso \var{errno} viene impostata ad uno dei
valori:
\begin{errlist}
\item[\macro{EINVAL}] \var{fd} è connesso ad un oggetto che non consente la
\var{count} byte dal buffer \var{buf}.
\bodydesc{La funzione ritorna il numero di byte letti in caso di successo e -1
- in caso di errore, nel qual caso \var{errno} viene settata secondo i valori
+ in caso di errore, nel qual caso \var{errno} viene impostata secondo i valori
già visti per \func{write} e \func{lseek}.}
\end{prototype}
\noindent e per essa valgono le stesse considerazioni fatte per \func{pread}.
scrittura eccede la dimensione corrente del file questo verrà esteso
automaticamente con l'aggiornamento del campo \var{i\_size} nell'inode.
\item se un file è in modalità \macro{O\_APPEND} tutte le volte che viene
- effettuata una scrittura la posizione corrente viene prima settata alla
+ effettuata una scrittura la posizione corrente viene prima impostata alla
dimensione corrente del file letta dall'inode. Dopo la scrittura il file
viene automaticamente esteso.
\item l'effetto di \func{lseek} è solo quello di cambiare il campo \var{f\_pos}
nella struttura \var{file} della \textit{file table}, non c'è nessuna
operazione sul file su disco. Quando la si usa per porsi alla fine del file
- la posizione viene settata leggendo la dimensione corrente dall'inode.
+ la posizione viene impostata leggendo la dimensione corrente dall'inode.
\end{itemize}
\begin{figure}[htb]
corrente nel file varierà per entrambi i processi (in quanto verrà modificato
\var{f\_pos} che è la stesso per entrambi).
-Si noti inoltre che anche i flag di stato del file (quelli settati
+Si noti inoltre che anche i flag di stato del file (quelli impostati
dall'argomento \param{flag} di \func{open}) essendo tenuti nella voce della
\textit{file table}\footnote{per la precisione nel campo \var{f\_flags} di
\var{file}.}, vengono in questo caso condivisi. Ai file però sono associati
Un caso tipico di necessità di accesso condiviso in scrittura è quello in cui
vari processi devono scrivere alla fine di un file (ad esempio un file di
-log). Come accennato in \secref{sec:file_lseek} settare la posizione alla fine
+log). Come accennato in \secref{sec:file_lseek} impostare la posizione alla fine
del file e poi scrivere può condurre ad una
\textit{race condition}\index{race condition}:
infatti può succedere che un secondo processo scriva alla fine
del file fra la \func{lseek} e la \func{write}; in questo caso, come abbiamo
appena visto, il file sarà esteso, ma il nostro primo processo avrà ancora la
-posizione corrente settata con la \func{lseek} che non corrisponde più alla
+posizione corrente impostata con la \func{lseek} che non corrisponde più alla
fine del file, e la successiva \func{write} sovrascriverà i dati del secondo
processo.
Crea una copia del file descriptor \param{oldfd}.
\bodydesc{La funzione ritorna il nuovo file descriptor in caso di successo e
- -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+ -1 in caso di errore, nel qual caso \var{errno} viene impostata ad uno dei
valori:
\begin{errlist}
\item[\macro{EBADF}] \param{oldfd} non è un file aperto.
Rende \param{newfd} una copia del file descriptor \param{oldfd}.
\bodydesc{La funzione ritorna il nuovo file descriptor in caso di successo e
- -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+ -1 in caso di errore, nel qual caso \var{errno} viene impostata ad uno dei
valori:
\begin{errlist}
\item[\macro{EBADF}] \param{oldfd} non è un file aperto o \param{newfd} ha un
\bodydesc{La funzione ha valori di ritorno diversi a seconda
dell'operazione. In caso di errore il valore di ritorno è -1 e la
- variabile \var{errno} viene settata ad un opportuno codice, quelli validi
+ variabile \var{errno} viene impostata ad un opportuno codice, quelli validi
in generale sono:
\begin{errlist}
\item[\macro{EBADF}] \param{oldfd} non è un file aperto.
\macro{EINVAL} se \param{arg} è negativo o maggiore del massimo consentito o
\macro{EMFILE} se il processo ha già raggiunto il massimo numero di
descrittori consentito.
-\item[\macro{F\_SETFD}] setta il valore del \textit{file descriptor flag}
+\item[\macro{F\_SETFD}] imposta il valore del \textit{file descriptor flag}
al valore specificato con \param{arg}. Al momento l'unico bit usato è
quello di \textit{close on exec}, identificato dalla costante
\macro{FD\_CLOEXEC}.
\item[\macro{F\_GETFD}] ritorna il valore del \textit{file descriptor flag} di
- \var{fd}, se \macro{FD\_CLOEXEC} è settato i file descriptor aperti vengono
- chiusi attraverso una \func{exec} altrimenti (il default) restano aperti.
+ \var{fd}, se \macro{FD\_CLOEXEC} è impostato i file descriptor aperti
+ vengono chiusi attraverso una \func{exec} altrimenti (il comportamento
+ predefinito) restano aperti.
\item[\macro{F\_GETFL}] ritorna il valore del \textit{file status flag},
- permette cioè di rileggere quei bit settati da \func{open} all'apertura del
+ permette cioè di rileggere quei bit impostati da \func{open} all'apertura del
file che vengono memorizzati (quelli riportati nella prima e terza sezione
di \tabref{tab:file_open_flags}).
-\item[\macro{F\_SETFL}] setta il \textit{file status flag} al valore
- specificato da \param{arg}, possono essere settati solo i bit riportati
+\item[\macro{F\_SETFL}] imposta il \textit{file status flag} al valore
+ specificato da \param{arg}, possono essere impostati solo i bit riportati
nella terza sezione di \tabref{tab:file_open_flags}.\footnote{la man page
- riporta come settabili solo \macro{O\_APPEND}, \macro{O\_NONBLOCK} e
+ riporta come impostabili solo \macro{O\_APPEND}, \macro{O\_NONBLOCK} e
\macro{O\_ASYNC}.}
\item[\macro{F\_GETLK}] se un file lock è attivo restituisce nella struttura
\param{lock} la struttura \type{flock} che impedisce l'acquisizione del
- blocco, altrimenti setta il campo \var{l\_type} a \macro{F\_UNLCK} (per i
+ blocco, altrimenti imposta il campo \var{l\_type} a \macro{F\_UNLCK} (per i
dettagli sul \textit{file locking} vedi \secref{sec:file_locking}).
\item[\macro{F\_SETLK}] richiede il file lock specificato da \param{lock} se
\var{l\_type} è \macro{F\_RDLCK} o \macro{F\_WRLLCK} o lo rilascia se
\var{l\_type} è \macro{F\_UNLCK}. Se il lock è tenuto da qualcun'altro
- ritorna immediatamente restituendo -1 e setta \var{errno} a \macro{EACCES} o
+ ritorna immediatamente restituendo -1 e imposta \var{errno} a \macro{EACCES} o
\macro{EAGAIN} (per i dettagli sul \textit{file locking} vedi
\secref{sec:file_locking}).
\item[\macro{F\_SETLKW}] identica a \macro{F\_SETLK} eccetto per il fatto che
la funzione non ritorna subito ma attende che il blocco sia rilasciato. Se
- l'attesa viene interrotta da un segnale la funzione restituisce -1 e setta
+ l'attesa viene interrotta da un segnale la funzione restituisce -1 e imposta
\var{errno} a \macro{EINTR} (per i dettagli sul \textit{file locking} vedi
\secref{sec:file_locking}).
\item[\macro{F\_GETOWN}] restituisce il \acr{pid} del processo o il process
group che è preposto alla ricezione dei segnali \macro{SIGIO} e
\macro{SIGURG} per gli eventi associati al file descriptor \var{fd}. Il
process group è restituito come valore negativo.
-\item[\macro{F\_SETOWN}] setta il processo o process group che riceverà i
+\item[\macro{F\_SETOWN}] imposta il processo o process group che riceverà i
segnali \macro{SIGIO} e \macro{SIGURG} per gli eventi associati al file
- descriptor \var{fd}. I process group sono settati usando valori negativi.
+ descriptor \var{fd}. I process group sono impostati usando valori negativi.
\item[\macro{F\_GETSIG}] restituisce il valore del segnale mandato quando ci
- sono dati disponibili in input su un file descriptor aperto o settato in I/O
- asincrono. Il valore 0 indica il valore default (che è \macro{SIGIO}), un
- valore diverso da zero indica il segnale richiesto, (che può essere lo
- stesso \macro{SIGIO}).
-\item[\macro{F\_SETSIG}] setta il segnale da inviare quando diventa possibile
- effettuare I/O sul file descriptor in caso di I/O asincrono. Il valore zero
- indica di usare il segnale di default, \macro{SIGIO}. Un altro valore
- (compreso lo stesso \macro{SIGIO}) specifica il segnale voluto; l'uso di un
- valore diverso da zero permette inoltre, se si è installato il manipolatore
- del segnale come \var{sa\_sigaction} usando \macro{SA\_SIGINFO}, (vedi
- \secref{sec:sig_sigaction}), di rendere disponibili al manipolatore
- informazioni ulteriori informazioni riguardo il file che ha generato il
- segnale attraverso i valori restituiti in \type{siginfo\_t} (come vedremo in
+ sono dati disponibili in input su un file descriptor aperto o impostato in
+ I/O asincrono. Il valore 0 indica il valore predefinito (che è
+ \macro{SIGIO}), un valore diverso da zero indica il segnale richiesto, (che
+ può essere lo stesso \macro{SIGIO}).
+\item[\macro{F\_SETSIG}] imposta il segnale da inviare quando diventa
+ possibile effettuare I/O sul file descriptor in caso di I/O asincrono. Il
+ valore zero indica di usare il segnale predefinito, \macro{SIGIO}. Un altro
+ valore (compreso lo stesso \macro{SIGIO}) specifica il segnale voluto; l'uso
+ di un valore diverso da zero permette inoltre, se si è installato il
+ manipolatore del segnale come \var{sa\_sigaction} usando
+ \macro{SA\_SIGINFO}, (vedi \secref{sec:sig_sigaction}), di rendere
+ disponibili al manipolatore informazioni ulteriori informazioni riguardo il
+ file che ha generato il segnale attraverso i valori restituiti in
+ \type{siginfo\_t} (come vedremo in
\secref{sec:file_asyncronous_io}).\footnote{i due comandi \macro{F\_SETSIG}
e \macro{F\_GETSIG} sono una estensione specifica di Linux.}
\end{basedescript}
interagire con le stesse funzioni usate per i normali file di dati,
esisteranno sempre caratteristiche peculiari, specifiche dell'hardware e della
funzionalità che ciascuno di essi provvede, che non possono venire comprese in
-questa interfaccia astratta (un caso tipico è il settaggio della velocità di
+questa interfaccia astratta (un caso tipico è l'impostazione della velocità di
una porta seriale, o le dimensioni di un framebuffer).
Per questo motivo l'architettura del sistema ha previsto l'esistenza di una
\bodydesc{La funzione nella maggior parte dei casi ritorna 0, alcune
operazioni usano però il valore di ritorno per restituire informazioni. In
- caso di errore viene sempre restituito -1 e \var{errno} viene settata ad
+ caso di errore viene sempre restituito -1 e \var{errno} viene impostata ad
uno dei valori seguenti:
\begin{errlist}
\item[\macro{ENOTTY}] il file \param{fd} non è associato con un device, o la
\item l'esecuzione di una traccia audio di un CDROM.
\item i comandi di avanti veloce e riavvolgimento di un nastro.
\item il comando di espulsione di un dispositivo rimovibile.
-\item il settaggio della velocità trasmissione di una linea seriale.
-\item il settaggio della frequenza e della durata dei suoni emessi dallo
+\item l'impostazione della velocità trasmissione di una linea seriale.
+\item l'impostazione della frequenza e della durata dei suoni emessi dallo
speaker.
\end{itemize*}
\func{ioctl} in quasi tutte le implementazioni di Unix), qui riportiamo solo i
valori che sono definiti per ogni file:
\begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\macro{FIOCLEX}] Setta il bit di \textit{close on exec}.
+\item[\macro{FIOCLEX}] Imposta il bit di \textit{close on exec}.
\item[\macro{FIONCLEX}] Cancella il bit di \textit{close on exec}.
\item[\macro{FIOASYNC}] Abilita l'I/O asincrono.
-\item[\macro{FIONBIO}] Abilità l'I/O in modalità non bloccante.
+\item[\macro{FIONBIO}] Abilita l'I/O in modalità non bloccante.
\end{basedescript}
relativi ad operazioni comunque eseguibili anche attraverso \func{fcntl}.
\usepackage{listings}
\lstloadlanguages{C++}
\usepackage{color}
-\usepackage{mdwlist} % scommentare per la stampa (PS e PDF)
-\usepackage{boxedminipage} % scommentare per la stampa (PS e PDF)
+%\usepackage{mdwlist} % scommentare per la stampa (PS e PDF)
+%\usepackage{boxedminipage} % scommentare per la stampa (PS e PDF)
%\usepackage{footnote}
%\usepackage{mdwtab}
%
\tableofcontents
\clearemptydoublepage
-%\include{compatib} % commentare per la stampa PS e PDF
+\include{compatib} % commentare per la stampa PS e PDF
\include{macro}
\setcounter{secnumdepth}{-2}
\include{pref}
Questo però ci porta a scontrarci con una caratteristica peculiare delle pipe,
che a prima vista non è evidente. Per poter effettuare la conversione di un
PDF infatti è necessario, per la struttura del formato, dover eseguire delle
-\func{lseek} sul file da convertire; se si esegue \cmd{gs} su un file normale
+\func{lseek} sul file da convertire; se si esegue \cmd{gs} su un file regolare
non ci sono problemi, ma una pipe però è rigidamente sequenziale, ed il
tentativo di eseguire detta operazione su una pipe comporta l'immediato
fallimento con un errore di \macro{ESPIPE}. Questo ci dice che in generale la
stessa chiave due processi diversi potranno ricavare l'identificatore
associato ad un oggetto e accedervi entrambi.
-
Questa caratteristica mostra il primo dei problemi associati al sistema di IPC
di System V. Un secondo problema riguarda le modalità per l'accesso a questi
oggetti.
+
+
\subsection{Code di messaggi}
\label{sec:ipc_messque}
Il calcolo dei dati di autenticazione viene effettuato alla sorgente su una
versione speciale del pacchetto in cui il numero di salti nell'intestazione
-principale è settato a zero, così come le opzioni che possono essere
+principale è impostato a zero, così come le opzioni che possono essere
modificate nella trasmissione, e l'intestazione di routing (se usata) è posta
ai valori che deve avere all'arrivo.
Un'esigenza comune che si incontra nella programmazione è quella di dover
effettuare una serie di operazioni di pulizia (ad esempio salvare dei dati,
-ripristinare dei settaggi, eliminare dei file temporanei, ecc.) prima della
-conclusione di un programma. In genere queste operazioni vengono fatte in
-un'apposita sezione del programma, ma quando si realizza una libreria diventa
-antipatico dover richiedere una chiamata esplicita ad una funzione di pulizia
-al programmatore che la utilizza.
+ripristinare delle impostazioni, eliminare dei file temporanei, ecc.) prima
+della conclusione di un programma. In genere queste operazioni vengono fatte
+in un'apposita sezione del programma, ma quando si realizza una libreria
+diventa antipatico dover richiedere una chiamata esplicita ad una funzione di
+pulizia al programmatore che la utilizza.
È invece molto meno soggetto ad errori, e completamente trasparente
all'utente, avere la possibilità di effettuare automaticamente la chiamata ad
programma.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- fallimento, \var{errno} non viene settata.}
+ fallimento, \var{errno} non viene impostata.}
\end{prototype}
\noindent la funzione richiede come argomento l'indirizzo della opportuna
funzione di pulizia da chiamare all'uscita, che non deve prendere argomenti e
rispetto a quello di registrazione.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- fallimento, \var{errno} non viene settata.}
+ fallimento, \var{errno} non viene impostata.}
\end{prototype}
In questo caso la funzione da chiamare prende due parametri, il primo dei
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
- \var{errno} viene settata a \macro{ENOMEM}.
+ \var{errno} viene impostata a \macro{ENOMEM}.
\funcdecl{void *malloc(size\_t size)}
Alloca \var{size} byte nello heap. La memoria non viene inizializzata.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
- \var{errno} viene settata a \macro{ENOMEM}.
+ \var{errno} viene impostata a \macro{ENOMEM}.
\funcdecl{void *realloc(void *ptr, size\_t size)}
Cambia la dimensione del blocco allocato all'indirizzo \var{ptr}
portandola a \var{size}.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
- \var{errno} viene settata a \macro{ENOMEM}.
+ \var{errno} viene impostata a \macro{ENOMEM}.
\funcdecl{void free(void *ptr)}
Disalloca lo spazio di memoria puntato da \var{ptr}.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
- \var{errno} viene settata a \macro{ENOMEM}.
+ \var{errno} viene impostata a \macro{ENOMEM}.
\end{prototype}
\noindent ma in questo caso non è più necessario liberare la memoria (e quindi
non esiste un analogo della \func{free}) in quanto essa viene rilasciata
\var{end\_data\_segment}.
La funzione restituisce 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} viene settata a \macro{ENOMEM}.
+ fallimento, nel qual caso \var{errno} viene impostata a \macro{ENOMEM}.
\funcdecl{void *sbrk(ptrdiff\_t increment)} Incrementa lo spazio dati di un
programma di \var{increment}. Un valore zero restituisce l'attuale posizione
La funzione restituisce il puntatore all'inizio della nuova zona di memoria
allocata in caso di successo e \macro{NULL} in caso di fallimento, nel qual
- caso \macro{errno} viene settata a \macro{ENOMEM}.
+ caso \macro{errno} viene impostata a \macro{ENOMEM}.
\end{functions}
\noindent in genere si usa \func{sbrk} con un valore zero per ottenere
l'attuale posizione della fine del segmento dati.
\bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 in
- caso di errore, nel qual caso \var{errno} è settata ad uno dei
+ caso di errore, nel qual caso \var{errno} è impostata ad uno dei
valori seguenti:
\begin{errlist}
\item[\macro{ENOMEM}] alcuni indirizzi dell'intervallo specificato non
(il cosiddetto \textit{parsing}) per individuare le parole che la compongono,
ciascuna delle quali viene considerata un parametro. Di norma per individuare
le parole viene usato come carattere di separazione lo spazio o il tabulatore,
-ma il comportamento è modificabile attraverso il settaggio della variabile di
-ambiente \cmd{IFS}.
+ma il comportamento è modificabile attraverso l'impostazione della variabile
+di ambiente \cmd{IFS}.
\begin{figure}[htb]
\centering
così che alla fine della scansione gli elementi che non sono opzioni sono
spostati in coda al vettore. Oltre a questa esistono altre due modalità di
gestire gli elementi di \var{argv}; se \var{optstring} inizia con il carattere
-\texttt{'+'} (o è settata la variabile di ambiente \macro{POSIXLY\_CORRECT})
+\texttt{'+'} (o è impostata la variabile di ambiente \macro{POSIXLY\_CORRECT})
la scansione viene fermata non appena si incontra un elemento che non è
un'opzione. L'ultima modalità, usata quando un programma può gestire la
mescolanza fra opzioni e argomenti, ma se li aspetta in un ordine definito, si
\hline
\hline
\macro{USER} & $\bullet$ & $\bullet$ & $\bullet$ & Nome utente\\
- \macro{LOGNAME} & $\bullet$ & $\bullet$ & $\bullet$ & Nome utente\\
+ \macro{LOGNAME} & $\bullet$ & $\bullet$ & $\bullet$ & Nome di login\\
\macro{HOME} & $\bullet$ & $\bullet$ & $\bullet$ &
Directory base dell'utente\\
\macro{LANG} & $\bullet$ & $\bullet$ & $\bullet$ & Localizzazione\\
\macro{TERM} & $\bullet$ & $\bullet$ & $\bullet$ & Tipo di terminale\\
\macro{PAGER} & $\bullet$ & $\bullet$ & $\bullet$ & Programma per vedere i
testi\\
- \macro{EDITOR} & $\bullet$ & $\bullet$ & $\bullet$ & Editor di default\\
- \macro{BROWSER} & $\bullet$ & $\bullet$ & $\bullet$ & Browser di default\\
+ \macro{EDITOR} & $\bullet$ & $\bullet$ & $\bullet$ & Editor preferito\\
+ \macro{BROWSER} & $\bullet$ & $\bullet$ & $\bullet$ & Browser preferito\\
\hline
\end{tabular}
\caption{Variabili di ambiente più comuni definite da vari standard.}
Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
C, nell'evoluzione dei sistemi Unix ne sono state proposte altre, da
-utilizzare per settare e per cancellare le variabili di ambiente. Uno schema
+utilizzare per impostare e per cancellare le variabili di ambiente. Uno schema
delle funzioni previste nei vari standard e disponibili in Linux è riportato
in \ntab.
\headdecl{stdlib.h}
\funcdecl{int setenv(const char *name, const char *value, int overwrite)}
- Setta la variabile di ambiente \param{name} al valore \param{value}.
+ Imposta la variabile di ambiente \param{name} al valore \param{value}.
\funcdecl{int putenv(char *string)} Aggiunge la stringa \param{string}
all'ambiente.
La seconda funzione prende come parametro una stringa analoga quella
restituita da \func{getenv}, e sempre nella forma \var{NOME=valore}. Se la
variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
-invece esiste il suo valore sarà settato a quello specificato da
+invece esiste il suo valore sarà impostato a quello specificato da
\param{string}. Si tenga presente che, seguendo lo standard SUSv2, le
\acr{glibc} successive alla versione 2.1.2 aggiungono\footnote{il
comportamento è lo stesso delle vecchie \acr{libc4} e \acr{libc5}; nelle
periodo di attesa.
Se eseguiamo il comando senza specificare attese (come si può notare in
-\texttt{\small 17--19} i valori di default specificano di non attendere),
+\texttt{\small 17--19} i valori predefiniti specificano di non attendere),
otterremo come output sul terminale:
\footnotesize
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} settati
+\item i file aperti e gli eventuali flag di \textit{close-on-exec} impostati
(vedi \secref{sec:proc_exec} e \secref{sec:file_fcntl}).
\item gli identificatori per il controllo di accesso: il \textit{real user
id}, il \textit{real group id}, l'\textit{effective user id},
\begin{itemize*}
\item il valore di ritorno di \func{fork}.
\item il \textit{process id}.
-\item il \textit{parent process id} (quello del figlio viene settato al
+\item il \textit{parent process id} (quello del figlio viene impostato al
\acr{pid} del padre).
\item i valori dei tempi di esecuzione della struttura \var{tms} (vedi
\secref{sec:sys_cpu_times}) che nel figlio sono posti a zero.
rispetto all'esecuzione di un programma e può avvenire in un qualunque
momento. Per questo motivo, come accennato nella sezione precedente, una delle
azioni prese dal kernel alla conclusione di un processo è quella di mandare un
-segnale di \macro{SIGCHLD} al padre. L'azione di default (si veda
+segnale di \macro{SIGCHLD} al padre. L'azione predefinita (si veda
\secref{sec:sig_base}) per questo segnale è di essere ignorato, ma la sua
generazione costituisce il meccanismo di comunicazione asincrona con cui il
kernel avverte il processo padre che uno dei suoi figli è terminato.
qual caso \var{errno} può assumere i valori:
\begin{errlist}
\item[\macro{EACCES}] il file non è eseguibile, oppure il filesystem è
- montato in \cmd{noexec}, oppure non è un file normale o un interprete.
+ montato in \cmd{noexec}, oppure non è un file regolare o un interprete.
\item[\macro{EPERM}] il file ha i bit \acr{suid} o \acr{sgid}, l'utente non
è root, e o il processo viene tracciato, o il filesystem è montato con
l'opzione \cmd{nosuid}.
\var{tms\_cutime}, \var{tms\_ustime} (vedi \secref{sec:sys_cpu_times}).
\end{itemize*}
-Inoltre i segnali che sono stati settati per essere ignorati nel processo
-chiamante mantengono lo stesso settaggio pure nel nuovo programma, tutti gli
-altri segnali vengono settati alla loro azione di default. Un caso speciale è
-il segnale \macro{SIGCHLD} che, quando settato a \macro{SIG\_IGN}, può anche
-non essere resettato a \macro{SIG\_DFL} (si veda \secref{sec:sig_gen_beha}).
+Inoltre i segnali che sono stati impostati per essere ignorati nel processo
+chiamante mantengono la stessa impostazione pure nel nuovo programma, tutti
+gli altri segnali vengono impostati alla loro azione predefinita. Un caso
+speciale è il segnale \macro{SIGCHLD} che, quando impostato a
+\macro{SIG\_IGN}, può anche non essere reimpostato a \macro{SIG\_DFL} (si veda
+\secref{sec:sig_gen_beha}).
La gestione dei file aperti dipende dal valore che ha il flag di
\textit{close-on-exec} (trattato in \secref{sec:file_fcntl}) per ciascun file
-descriptor. I file per cui è settato vengono chiusi, tutti gli altri file
-restano aperti. Questo significa che il comportamento di default è che i 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 attraverso una \func{exec}, a meno di una chiamata esplicita a
-\func{fcntl} che setti il suddetto flag.
+\func{fcntl} che imposti il suddetto flag.
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 \secref{sec:file_dir_read}) che effettua da sola il
-settaggio del flag di \textit{close-on-exec} sulle directory che apre, in
+\func{opendir} (vedi \secref{sec:file_dir_read}) che effettua da sola
+l'impostazione del flag di \textit{close-on-exec} sulle directory che apre, in
maniera trasparente all'utente.
Abbiamo detto che il \textit{real user id} ed il \textit{real group id}
restano gli stessi all'esecuzione di \func{exec}; lo stesso vale per
l'\textit{effective user id} ed l'\textit{effective group id}, tranne quando
il file che si va ad eseguire abbia o il \acr{suid} bit o lo \acr{sgid} bit
-settato, in questo caso l'\textit{effective user id} e l'\textit{effective
- group id} vengono settati rispettivamente all'utente o al gruppo cui il file
+impostato, in questo caso l'\textit{effective user id} e l'\textit{effective
+ group id} 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
basata la gestione 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 verifica la conclusione dei programmi. Tutte le
-altre funzioni sono ausiliarie e servono la lettura e il settaggio dei vari
+altre funzioni sono ausiliarie e servono la lettura e l'impostazione dei vari
parametri connessi ai processi.
\end{table}
Al primo gruppo appartengono il \textit{real user id} e il \textit{real group
- id}: questi vengono settati al login ai valori corrispondenti all'utente con
-cui si accede al sistema (e relativo gruppo di default). Servono per
+ id}: 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 cambiati. In
realtà vedremo (in \secref{sec:proc_setuid}) che è possibile modificarli, ma
solo ad un processo che abbia i privilegi di amministratore; questa
possibilità è usata ad esempio da \cmd{login} che, una volta completata la
-procedura di autenticazione, lancia una shell per la quale setta questi
+procedura di autenticazione, lancia una shell per la quale imposta questi
identificatori ai valori corrispondenti all'utente che entra nel sistema.
Al secondo gruppo appartengono l'\textit{effective user id} e
Questi identificatori normalmente sono identici ai corrispondenti del gruppo
\textit{real} tranne nel caso in cui, come accennato in
\secref{sec:proc_exec}, il programma che si è posto in esecuzione abbia i bit
-\acr{suid} o \acr{sgid} settati (il significato di questi bit è affrontato in
-dettaglio in \secref{sec:file_suid_sgid}). In questo caso essi saranno settati
+\acr{suid} o \acr{sgid} impostati (il significato di questi bit è affrontato in
+dettaglio in \secref{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).
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 dalla funzione \func{exec} all'avvio del
+processo padre, e vengono impostati dalla funzione \func{exec} all'avvio del
processo, come copie dell'\textit{effective user id} e dell'\textit{effective
- group id} dopo che questo sono stati settati tenendo conto di eventuali
+ group id} 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.
\headdecl{unistd.h}
\headdecl{sys/types.h}
-\funcdecl{int setuid(uid\_t uid)} Setta l'\textit{user id} del processo
+\funcdecl{int setuid(uid\_t uid)} Imposta l'\textit{user id} del processo
corrente.
-\funcdecl{int setgid(gid\_t gid)} Setta il \textit{group id} del processo
+\funcdecl{int setgid(gid\_t gid)} Imposta il \textit{group id} del processo
corrente.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
L'effetto della chiamata è diverso a seconda dei privilegi del processo; se
l'\textit{effective user id} è zero (cioè è quello dell'amministratore di
sistema) allora tutti gli identificatori (\textit{real}, \textit{effective}
-e \textit{saved}) vengono settati al valore specificato da \var{uid},
-altrimenti viene settato solo l'\textit{effective user id}, e soltanto se il
+e \textit{saved}) vengono impostati al valore specificato da \var{uid},
+altrimenti viene impostato solo l'\textit{effective user id}, e soltanto se il
valore specificato corrisponde o al \textit{real user id} o al \textit{saved
user id}. Negli altri casi viene segnalato un errore (con \macro{EPERM}).
Come accennato l'uso principale di queste funzioni è quello di poter
-consentire ad un programma con i bit \acr{suid} o \acr{sgid} settati di
+consentire ad un programma con i bit \acr{suid} o \acr{sgid} impostati di
riportare l'\textit{effective user id} a quello dell'utente che ha lanciato il
programma, effettuare il lavoro che non necessita di privilegi aggiuntivi, ed
eventualmente tornare indietro.
un gruppo dedicato (\acr{utmp}) ed i programmi che devono accedervi (ad
esempio tutti i programmi di terminale in X, o il programma \cmd{screen} che
crea terminali multipli su una console) appartengono a questo gruppo ed hanno
-il bit \acr{sgid} settato.
+il bit \acr{sgid} impostato.
Quando uno di questi programmi (ad esempio \cmd{xterm}) viene lanciato, la
situazione degli identificatori è la seguente:
\end{eqnarray*}
in questo modo, dato che l'\textit{effective group id} è 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 settare
+questo punto il programma può eseguire una \code{setgid(getgid())} per impostare
l'\textit{effective group id} a quello dell'utente (e dato che il \textit{real
group id} corrisponde la funzione avrà successo), in questo modo non sarà
possibile lanciare dal terminale programmi che modificano detto file, in tal
\headdecl{unistd.h}
\headdecl{sys/types.h}
-\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Setta il \textit{real user
+\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta il \textit{real user
id} e l'\textit{effective user id} del processo corrente ai valori
specificati da \var{ruid} e \var{euid}.
-\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Setta il \textit{real group
+\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textit{real group
id} e l'\textit{effective group id} del processo corrente ai valori
specificati da \var{rgid} e \var{egid}.
di fallimento: l'unico errore possibile è \macro{EPERM}.}
\end{functions}
-I processi non privilegiati possono settare i \textit{real id} soltanto ai
+I processi non privilegiati possono impostare i \textit{real id} soltanto ai
valori dei loro \textit{effective id} o \textit{real id} e gli
\textit{effective id} ai valori dei loro \textit{real id}, \textit{effective
id} o \textit{saved id}; valori diversi comportano il fallimento della
usarle per correggere la situazione come nel caso precedente. Per questo
motivo in Linux tutte le volte che tali funzioni vengono usate per modificare
uno degli identificatori ad un valore diverso dal \textit{real id} precedente,
-il \textit{saved id} viene sempre settato al valore dell'\textit{effective
+il \textit{saved id} viene sempre impostato al valore dell'\textit{effective
id}.
\headdecl{unistd.h}
\headdecl{sys/types.h}
-\funcdecl{int seteuid(uid\_t uid)} Setta l'\textit{effective user id} del
+\funcdecl{int seteuid(uid\_t uid)} Imposta l'\textit{effective user id} del
processo corrente a \var{uid}.
-\funcdecl{int setegid(gid\_t gid)} Setta l'\textit{effective group id} del
+\funcdecl{int setegid(gid\_t gid)} Imposta l'\textit{effective group id} del
processo corrente a \var{gid}.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
di fallimento: l'unico errore possibile è \macro{EPERM}.}
\end{functions}
-Gli utenti normali possono settare l'\textit{effective id} solo al valore del
+Gli utenti normali possono impostare l'\textit{effective id} solo al valore del
\textit{real id} o del \textit{saved id}, l'amministratore può specificare
-qualunque valore. Queste funzioni sono usate per permettere a root di settare
+qualunque valore. Queste funzioni sono usate per permettere a root di impostare
solo l'\textit{effective id}, dato che l'uso normale di \func{setuid} comporta
-il settaggio di tutti gli identificatori.
+l'impostazione di tutti gli identificatori.
\subsection{Le funzioni \func{setresuid} e \func{setresgid}}
\headdecl{unistd.h}
\headdecl{sys/types.h}
-\funcdecl{int setresuid(uid\_t ruid, uid\_t euid, uid\_t suid)} Setta il
+\funcdecl{int setresuid(uid\_t ruid, uid\_t euid, uid\_t suid)} Imposta il
\textit{real user id}, l'\textit{effective user id} e il \textit{saved user
id} del processo corrente ai valori specificati rispettivamente da
\var{ruid}, \var{euid} e \var{suid}.
-\funcdecl{int setresgid(gid\_t rgid, gid\_t egid, gid\_t sgid)} Setta il
+\funcdecl{int setresgid(gid\_t rgid, gid\_t egid, gid\_t sgid)} Imposta il
\textit{real group id}, l'\textit{effective group id} e il \textit{saved group
id} del processo corrente ai valori specificati rispettivamente da
\var{rgid}, \var{egid} e \var{sgid}.
\subsection{Le funzioni \func{setfsuid} e \func{setfsgid}}
\label{sec:proc_setfsuid}
-Queste funzioni sono usate per settare gli identificatori usati da Linux per
+Queste funzioni sono usate per impostare gli identificatori usati da Linux per
il controllo dell'accesso ai file. Come già accennato in
\secref{sec:proc_access_id} in Linux è definito questo ulteriore gruppo di
identificatori, che di norma sono assolutamente equivalenti agli
\begin{functions}
\headdecl{sys/fsuid.h}
-\funcdecl{int setfsuid(uid\_t fsuid)} Setta il \textit{filesystem user id} del
+\funcdecl{int setfsuid(uid\_t fsuid)} Imposta il \textit{filesystem user id} del
processo corrente a \var{fsuid}.
-\funcdecl{int setfsgid(gid\_t fsgid)} Setta l'\textit{filesystem group id} del
+\funcdecl{int setfsgid(gid\_t fsgid)} Imposta l'\textit{filesystem group id} del
processo corrente a \var{fsgid}.
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
\bodydesc{La funzione restituisce il numero di gruppi letti in caso di
successo e -1 in caso di fallimento, nel qual caso \var{errno} viene
- settata a:
+ impostata a:
\begin{errlist}
\item[\macro{EFAULT}] \param{list} non ha un indirizzo valido.
\item[\macro{EINVAL}] il valore di \param{size} è diverso da zero ma
perché qualora il valore specificato sia troppo piccolo la funzione ritorna
-1, passando indietro il numero dei gruppi trovati.
-Per settare i gruppi supplementari di un processo ci sono due funzioni, che
+Per impostare i gruppi supplementari di un processo ci sono due funzioni, che
possono essere usate solo se si hanno i privilegi di amministratore. La prima
delle due è \func{setgroups}, ed il suo prototipo è:
\begin{functions}
\headdecl{sys/types.h}
\headdecl{grp.h}
- \funcdecl{int setgroups(size\_t size, gid\_t *list)} Setta i gruppi
+ \funcdecl{int setgroups(size\_t size, gid\_t *list)} Imposta i gruppi
supplementari del processo ai valori specificati in \param{list}.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} viene settata a:
+ fallimento, nel qual caso \var{errno} viene impostata a:
\begin{errlist}
\item[\macro{EFAULT}] \param{list} non ha un indirizzo valido.
\item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
\end{errlist}}
\end{functions}
-Se invece si vogliono settare i gruppi supplementari del processo a quelli di
+Se invece si vogliono impostare i gruppi supplementari del processo a quelli di
un utente specifico, si può usare \func{initgroups} il cui prototipo è:
\begin{functions}
\headdecl{sys/types.h}
\headdecl{grp.h}
- \funcdecl{int initgroups(const char *user, gid\_t group)} Setta i gruppi
+ \funcdecl{int initgroups(const char *user, gid\_t group)} Imposta i gruppi
supplementari del processo a quelli di cui è membro l'utente \param{user},
aggiungendo il gruppo addizionale \param{group}.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} viene settata agli stessi valori di
+ fallimento, nel qual caso \var{errno} viene impostata agli stessi valori di
\func{setgroups} più \macro{ENOMEM} quando non c'è memoria sufficiente per
allocare lo spazio per informazioni dei gruppi.}
\end{functions}
La funzione esegue la scansione del database dei gruppi (usualmente
\file{/etc/groups}) cercando i gruppi di cui è membro \param{user} e
costruendo una lista di gruppi supplementari a cui aggiunge \param{group}, che
-poi setta usando \func{setgroups}.
+poi imposta usando \func{setgroups}.
Si tenga presente che sia \func{setgroups} che \func{initgroups} non sono
definite nello standard POSIX.1 e che pertanto non è possibile utilizzarle
zero.
Analoga a \func{getpriority} la funzione \func{setpriority} permette di
-settare la priorità di uno o più processi; il suo prototipo è:
+impostare la priorità di uno o più processi; il suo prototipo è:
\begin{prototype}{sys/resource.h}
{int setpriority(int which, int who, int prio)}
- Setta la priorità per l'insieme dei processi specificati.
+ Imposta la priorità per l'insieme dei processi specificati.
\bodydesc{La funzione ritorna la priorità in caso di successo e -1 in caso di
errore, nel qual caso \var{errno} può assumere i valori:
\end{errlist}}
\end{prototype}
-La funzione setta la priorità al valore specificato da \param{prio} per tutti
+La funzione imposta la priorità al valore specificato da \param{prio} per 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
stessa priorità ed in stato \textit{runnable} entrano nel circolo.
\end{basedescript}
-La funzione per settare le politiche di scheduling (sia real-time che
+La funzione per impostare le politiche di scheduling (sia real-time che
ordinarie) ed i relativi parametri è \func{sched\_setscheduler}; il suo
prototipo è:
\begin{prototype}{sched.h}
{int sched\_setscheduler(pid\_t pid, int policy, const struct sched\_param *p)}
- Setta priorità e politica di scheduling per il processo \param{pid}.
+ Imposta priorità e politica di scheduling per il processo \param{pid}.
\bodydesc{La funzione ritorna la priorità in caso di successo e -1 in caso di
errore, nel qual caso \var{errno} può assumere i valori:
\end{errlist}}
\end{prototype}
-La funzione esegue il settaggio per il processo specificato; un valore nullo
-di \param{pid} esegue il settaggio per il processo corrente, solo un processo
-con i privilegi di amministratore può settare delle priorità assolute diverse
-da zero. La politica di scheduling è specificata dall'argomento \param{policy}
-i cui possibili valori sono riportati in \tabref{tab:proc_sched_policy}; un
-valore negativo per \param{policy} mantiene la politica di scheduling
-corrente.
+La funzione esegue l'impostazione per il processo specificato; un valore nullo
+di \param{pid} esegue l'impostazione per il processo corrente, solo un
+processo con i privilegi di amministratore può impostare delle priorità
+assolute diverse da zero. La politica di scheduling è specificata
+dall'argomento \param{policy} i cui possibili valori sono riportati in
+\tabref{tab:proc_sched_policy}; un valore negativo per \param{policy} mantiene
+la politica di scheduling corrente.
\begin{table}[htb]
\centering
I processi con politica di scheduling \macro{SCHED\_OTHER} devono specificare
un valore nullo (altrimenti si avrà un errore \macro{EINVAL}), questo valore
infatti non ha niente a che vedere con la priorità dinamica determinata dal
-valore di \var{nice}, che deve essere settato con le funzioni viste in
+valore di \var{nice}, che deve essere impostato con le funzioni viste in
precedenza.
\begin{figure}[!htb]
\headdecl{sched.h}
\funcdecl{int sched\_setparam(pid\_t pid, const struct sched\_param *p)}
- Setta la priorità assoluta del processo \param{pid}.
+ Imposta la priorità assoluta del processo \param{pid}.
\funcdecl{int sched\_getparam(pid\_t pid, struct sched\_param *p)}
Rilascia volontariamente l'esecuzione.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
- nel qual caso \var{errno} viene settata opportunamente.}
+ nel qual caso \var{errno} viene impostata opportunamente.}
\end{prototype}
La funzione fa si che il processo rilasci la CPU, in modo da essere rimesso in
kernel che causa la generazione un particolare tipo di segnale.
Quando un processo riceve un segnale, invece del normale corso del programma,
-viene eseguita una azione di default o una apposita routine di gestione (il
-cosiddetto \textit{signal handler} o \textsl{manipolatore}) che può essere
-stata specificata dall'utente (nel qual caso si dice che si
-\textsl{intercetta} il segnale).
+viene eseguita una azione predefinita o una apposita routine di gestione
+(quello che da qui in avanti chiameremo il \textsl{gestore} del segnale,
+dall'inglese\textit{signal handler}) che può essere stata specificata
+dall'utente (nel qual caso si dice che si \textsl{intercetta} il segnale).
\subsection{Le \textsl{semantiche} del funzionamento dei segnali}
Nella \textsl{semantica inaffidabile} (quella implementata dalle prime
versioni di Unix) la routine di gestione del segnale specificata dall'utente
non resta attiva una volta che è stata eseguita; è perciò compito dell'utente
-stesso ripetere l'installazione della stessa all'interno della routine di
-gestione, in tutti i casi in cui si vuole che il manipolatore esterno resti
-attivo.
+stesso ripetere l'installazione all'interno del \textsl{gestore} del segnale,
+in tutti quei casi in cui si vuole che esso resti attivo.
In questo caso è possibile una situazione in cui i segnali possono essere
perduti. Si consideri il segmento di codice riportato in
\secref{fig:sig_old_handler}, nel programma principale viene installato un
-manipolatore (\texttt{\small 5}), ed in quest'ultimo la prima operazione
+gestore (\texttt{\small 5}), ed in quest'ultimo la prima operazione
(\texttt{\small 11}) è quella di reinstallare se stesso. Se nell'esecuzione
-del manipolatore un secondo segnale arriva prima che esso abbia potuto
-eseguire la reinstallazione, verrà eseguito il comportamento di default
-assegnato al segnale stesso, il che può comportare, a seconda dei casi, che il
-segnale viene perso (se il default era quello di ignorarlo) o la terminazione
-immediata del processo; in entrambi i casi l'azione prevista non verrà
-eseguita.
+del gestore un secondo segnale arriva prima che esso abbia potuto eseguire la
+reinstallazione, verrà eseguito il comportamento predefinito assegnato al
+segnale stesso, il che può comportare, a seconda dei casi, che il segnale
+viene perso (se l'impostazione predefinita era quello di ignorarlo) o la
+terminazione immediata del processo; in entrambi i casi l'azione prevista non
+verrà eseguita.
\begin{figure}[!htb]
\footnotesize \centering
\end{lstlisting}
\end{minipage}
\normalsize
- \caption{Esempio di codice di un manipolatore di segnale per la semantica
+ \caption{Esempio di codice di un gestore di segnale per la semantica
inaffidabile.}
\label{fig:sig_old_handler}
\end{figure}
Questa è la ragione per cui l'implementazione dei segnali secondo questa
semantica viene chiamata \textsl{inaffidabile}; infatti la ricezione del
-segnale e la reinstallazione del suo manipolatore non sono operazioni
+segnale e la reinstallazione del suo gestore non sono operazioni
atomiche, e sono sempre possibili delle race condition\index{race condition}
(sull'argomento vedi quanto detto in \secref{sec:proc_multi_prog}).
di un segnale, pur mantenendo memoria del fatto che è avvenuto.
Nella semantica \textsl{affidabile} (quella utilizzata da Linux e da ogni Unix
-moderno) il manipolatore una volta installato resta attivo e non si hanno
+moderno) il gestore una volta installato resta attivo e non si hanno
tutti i problemi precedenti. In questa semantica i segnali vengono
\textsl{generati} dal kernel per un processo all'occorrenza dell'evento che
-causa il segnale. In genere questo viene fatto dal kernel settando l'apposito
+causa il segnale. In genere questo viene fatto dal kernel impostando l'apposito
campo della \var{task\_struct} del processo nella process table (si veda
\figref{fig:proc_task_struct}).
esso è detto \textsl{pendente} (o \textit{pending}). In genere questa
procedura viene effettuata dallo scheduler quando, riprendendo l'esecuzione
del processo in questione, verifica la presenza del segnale nella
-\var{task\_struct} e mette in esecuzione il manipolatore.
+\var{task\_struct} e mette in esecuzione il gestore.
In questa semantica un processo ha la possibilità di bloccare la consegna dei
segnali, in questo caso, se l'azione per il suddetto segnale non è quella di
ignorarlo, il segnale resta \textsl{pendente} fintanto che il processo non lo
-sblocca (nel qual caso viene consegnato) o setta l'azione di default per
+sblocca (nel qual caso viene consegnato) o imposta l'azione corrispondente per
ignorarlo.
Si tenga presente che il kernel stabilisce cosa fare con un segnale che è
\subsection{La notifica dei segnali}
\label{sec:sig_notification}
-Come accennato quando un segnale viene generato, se la sua azione di default
+Come accennato quando un segnale viene generato, se la sua azione predefinita
non è quella di essere ignorato, il kernel prende nota del fatto nella
\var{task\_struct} del processo; si dice così che il segnale diventa
\textsl{pendente} (o \textit{pending}), e rimane tale fino al momento in cui
-verrà notificato al processo (o verrà specificata come azione di default
-quella di ignorarlo).
+verrà notificato al processo (o verrà specificata come azione quella di
+ignorarlo).
Normalmente l'invio al processo che deve ricevere il segnale è immediato ed
avviene non appena questo viene rimesso in esecuzione dallo scheduler che
\begin{itemize*}
\item ignorare il segnale.
-\item catturare il segnale, ed utilizzare il manipolatore specificato.
-\item accettare l'azione di default per quel segnale.
+\item catturare il segnale, ed utilizzare il gestore specificato.
+\item accettare l'azione predefinita per quel segnale.
\end{itemize*}
Un programma può specificare queste scelte usando le due funzioni
\func{signal} e \func{sigaction} (vedi \secref{sec:sig_signal} e
-\secref{sec:sig_sigaction}). Se si è installato un manipolatore sarà
+\secref{sec:sig_sigaction}). Se si è installato un gestore sarà
quest'ultimo ad essere eseguito alla notifica del segnale. Inoltre il sistema
-farà si che mentre viene eseguito il manipolatore di un segnale, quest'ultimo
+farà si che mentre viene eseguito il gestore di un segnale, quest'ultimo
venga automaticamente bloccato (così si possono evitare race
condition\index{race condition}).
\textbf{Sigla} & \textbf{Significato} \\
\hline
\hline
- A & L'azione di default è terminare il processo. \\
- B & L'azione di default è ignorare il segnale. \\
- C & L'azione di default è terminare il processo e scrivere un \textit{core
+ A & L'azione predefinita è terminare il processo. \\
+ B & L'azione predefinita è ignorare il segnale. \\
+ C & L'azione predefinita è terminare il processo e scrivere un \textit{core
dump}. \\
- D & L'azione di default è fermare il processo. \\
+ D & L'azione predefinita è fermare il processo. \\
E & Il segnale non può essere intercettato. \\
F & Il segnale non può essere ignorato.\\
\hline
\end{tabular}
- \caption{Legenda delle azioni di default dei segnali riportate in
+ \caption{Legenda delle azioni predefinite dei segnali riportate in
\tabref{tab:sig_signal_list}.}
\label{tab:sig_action_leg}
\end{table}
-In \tabref{tab:sig_signal_list} si sono anche riportate le azioni di default
+In \tabref{tab:sig_signal_list} si sono anche riportate le azioni predefinite
di ciascun segnale (riassunte con delle lettere, la cui legenda completa è in
-\tabref{tab:sig_action_leg}), quando nessun manipolatore è installato un
+\tabref{tab:sig_action_leg}), quando nessun gestore è installato un
segnale può essere ignorato o causare la terminazione del processo. Nella
colonna standard sono stati indicati anche gli standard in cui ciascun segnale
è definito, secondo lo schema di \tabref{tab:sig_standard_leg}.
controllo \\
\macro{SIGINT} &PL & A & Interrupt da tastiera (\cmd{C-c}) \\
\macro{SIGQUIT} &PL & C & Quit da tastiera (\cmd{C-y}) \\
- \macro{SIGILL} &PL & C & Istruzione illegale \\
+ \macro{SIGILL} &PL & C & Istruzione illecita \\
\macro{SIGABRT} &PL & C & Segnale di abort da \func{abort} \\
\macro{SIGFPE} &PL & C & Errore aritmetico \\
\macro{SIGKILL} &PL &AEF& Segnale di terminazione forzata \\
proibita) e l'esecuzione non può essere proseguita.
In genere si intercettano questi segnali per permettere al programma di
-terminare in maniera pulita, ad esempio per ripristinare i settaggi della
+terminare in maniera pulita, ad esempio per ripristinare le impostazioni della
console o eliminare i file di lock prima dell'uscita. In questo caso il
-manipolatore deve concludersi ripristinando l'azione di default e rialzando il
+gestore deve concludersi ripristinando l'azione predefinita e rialzando il
segnale, in questo modo il programma si concluderà senza effetti spiacevoli,
-ma riportando lo stesso stato di uscita che avrebbe avuto se il manipolatore
-non ci fosse stato.
+ma riportando lo stesso stato di uscita che avrebbe avuto se il gestore non ci
+fosse stato.
-L'azione di default per tutti questi segnali è causare la terminazione del
+L'azione predefinita per tutti questi segnali è causare la terminazione del
processo che li ha causati. In genere oltre a questo il segnale provoca pure
la registrazione su disco di un file di \textit{core dump} che viene scritto
in un file \file{core} nella directory corrente del processo al momento
derivi da \textit{floating point exception} si applica a tutti gli errori
aritmetici compresa la divisione per zero e l'overflow.
- Se il manipolatore ritorna il comportamento del processo è indefinito, ed
+ Se il gestore ritorna il comportamento del processo è indefinito, ed
ignorare questo segnale può condurre ad un ciclo infinito.
% Per questo segnale le cose sono complicate dal fatto che possono esserci
\item[\macro{SIGILL}] Il nome deriva da \textit{illegal instruction},
significa che il programma sta cercando di eseguire una istruzione
- privilegiata o inesistente, in generale del codice illegale. Poiché il
+ privilegiata o inesistente, in generale del codice illecito. Poiché il
compilatore del C genera del codice valido si ottiene questo segnale se il
file eseguibile è corrotto o si stanno cercando di eseguire dei dati.
Quest'ultimo caso può accadere quando si passa un puntatore sbagliato al
posto di un puntatore a funzione, o si eccede la scrittura di un vettore di
una variabile locale, andando a corrompere lo stack. Lo stesso segnale viene
generato in caso di overflow dello stack o di problemi nell'esecuzione di un
- manipolatore. Se il manipolatore ritorna il comportamento del processo è
+ gestore. Se il gestore ritorna il comportamento del processo è
indefinito.
\item[\macro{SIGSEGV}] Il nome deriva da \textit{segment violation}, e
significa che il programma sta cercando di leggere o scrivere in una zona di
memoria protetta al di fuori di quella che gli è stata riservata dal
sistema. In genere è il meccanismo della protezione della memoria che si
- accorge dell'errore ed il kernel genera il segnale. Se il manipolatore
+ accorge dell'errore ed il kernel genera il segnale. Se il gestore
ritorna il comportamento del processo è indefinito.
È tipico ottenere questo segnale dereferenziando un puntatore nullo o non
programma può dover eseguire una serie di azioni di pulizia prima di
terminare, come salvare informazioni sullo stato in cui si trova, cancellare
file temporanei, o ripristinare delle condizioni alterate durante il
-funzionamento (come il modo del terminale o i settaggi di una qualche
+funzionamento (come il modo del terminale o le impostazioni di una qualche
periferica).
-L'azione di default di questi segnali è di terminare il processo, questi
+L'azione predefinita di questi segnali è di terminare il processo, questi
segnali sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\macro{SIGTERM}] Il nome sta per \textit{terminate}. È un segnale
INTR (interrupt, generato dalla sequenza \macro{C-c}).
\item[\macro{SIGQUIT}] È analogo a \macro{SIGINT} con la differenze che è
controllato da un'altro carattere di controllo, QUIT, corrispondente alla
- sequenza \verb|C-\|. A differenza del precedente l'azione di default,
- oltre alla terminazione del processo, comporta anche la creazione di un core
- dump.
+ sequenza \verb|C-\|. A differenza del precedente l'azione predefinita, oltre
+ alla terminazione del processo, comporta anche la creazione di un core dump.
In genere lo si può pensare come corrispondente ad una condizione di
errore del programma rilevata dall'utente. Per questo motivo non è opportuno
- fare eseguire al manipolatore di questo segnale le operazioni di pulizia
+ fare eseguire al gestore di questo segnale le operazioni di pulizia
normalmente previste (tipo la cancellazione di file temporanei), dato che in
certi casi esse possono eliminare informazioni utili nell'esame dei core
dump.
processo da parte di \macro{SIGKILL} costituirebbe un malfunzionamento del
kernel). Talvolta è il sistema stesso che può generare questo segnale quando
per condizioni particolari il processo non può più essere eseguito neanche
- per eseguire un manipolatore.
+ per eseguire un gestore.
\item[\macro{SIGHUP}] Il nome sta per \textit{hang-up}. Segnala che il
terminale dell'utente si è disconnesso (ad esempio perché si è interrotta la
rete). Viene usato anche per riportare la terminazione del processo di
\label{sec:sig_alarm}
Questi segnali sono generati dalla scadenza di un timer. Il loro comportamento
-di default è quello di causare la terminazione del programma, ma con questi
-segnali la scelta di default è irrilevante, in quanto il loro uso presuppone
-sempre la necessità di un manipolatore. Questi segnali sono:
+predefinito è quello di causare la terminazione del programma, ma con questi
+segnali la scelta predefinita è irrilevante, in quanto il loro uso presuppone
+sempre la necessità di un gestore. Questi segnali sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\macro{SIGALRM}] Il nome sta per \textit{alarm}. Segnale la scadenza di
un timer misurato sul tempo reale o sull'orologio di sistema. È normalmente
questo occorre comunque usare \func{fcntl} per abilitare un file descriptor a
generare questi segnali.
-L'azione di default è di essere ignorati. Questi segnali sono:
+L'azione predefinita è di essere ignorati. Questi segnali sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\macro{SIGIO}] Questo segnale viene inviato quando un file descriptor è
pronto per eseguire dell'input/output. In molti sistemi solo i socket e i
cui si trattano gli argomenti relativi. Questi segnali sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\macro{SIGCHLD}] Questo è il segnale mandato al processo padre quando un
- figlio termina o viene fermato. L'azione di default è di ignorare il
+ figlio termina o viene fermato. L'azione predefinita è di ignorare il
segnale, la sua gestione è trattata in \secref{sec:proc_wait}.
\item[\macro{SIGCLD}] Per Linux questo è solo un segnale identico al
precedente, il nome è obsoleto e andrebbe evitato.
\item[\macro{SIGCONT}] Il nome sta per \textit{continue}. Il segnale viene
usato per fare ripartire un programma precedentemente fermato da
\macro{SIGSTOP}. Questo segnale ha un comportamento speciale, e fa sempre
- ripartire il processo prima della sua consegna. Il comportamento di default
+ ripartire il processo prima della sua consegna. Il comportamento predefinito
è di fare solo questo; il segnale non può essere bloccato. Si può anche
- installare un manipolatore, ma il segnale provoca comunque il riavvio del
+ installare un gestore, ma il segnale provoca comunque il riavvio del
processo.
La maggior pare dei programmi non hanno necessità di intercettare il
segnale, in quanto esso è completamente trasparente rispetto all'esecuzione
che riparte senza che il programma noti niente. Si possono installare dei
- manipolatori per far si che un programma produca una qualche azione speciale
+ gestori per far si che un programma produca una qualche azione speciale
se viene fermato e riavviato, come per esempio riscrivere un prompt, o
inviare un avviso.
\item[\macro{SIGSTOP}] Il segnale ferma un processo (lo porta in uno stato di
ferma il processo interattivamente, ed è generato dal carattere SUSP
(prodotto dalla combinazione \macro{C-z}), ed al contrario di
\macro{SIGSTOP} può essere intercettato e ignorato. In genere un programma
- installa un manipolatore per questo segnale quando vuole lasciare il sistema
+ installa un gestore per questo segnale quando vuole lasciare il sistema
o il terminale in uno stato definito prima di fermarsi; se per esempio un
- programma ha disabilitato l'eco sul terminale può installare un manipolatore
+ programma ha disabilitato l'eco sul terminale può installare un gestore
per riabilitarlo prima di fermarsi.
\item[\macro{SIGTTIN}] Un processo non può leggere dal terminale se esegue una
sessione di lavoro in background. Quando un processo in background tenta di
leggere da un terminale viene inviato questo segnale a tutti i processi
- della sessione di lavoro. L'azione di default è di fermare il processo.
+ della sessione di lavoro. L'azione predefinita è di fermare il processo.
L'argomento è trattato in \secref{sec:sess_xxx}.
\item[\macro{SIGTTOU}] Segnale analogo al precedente \macro{SIGTTIN}, ma
generato quando si tenta di scrivere o modificare uno dei modi del
- terminale. L'azione di default è di fermare il processo, l'argomento è
+ terminale. L'azione predefinita è di fermare il processo, l'argomento è
trattato in \secref{sec:sess_xxx}.
\end{basedescript}
che impediscono il completamento dell'esecuzione dovute all'interazione con il
resto del sistema.
-L'azione di default di questi segnali è di terminare il processo, questi
+L'azione predefinita di questi segnali è di terminare il processo, questi
segnali sono:
\begin{basedescript}{\desclabelwidth{2.0cm}}
\item[\macro{SIGPIPE}] Sta per \textit{Broken pipe}. Se si usano delle pipe o
\item[\macro{SIGUSR2}] Insieme a \macro{SIGUSR1} è un segnale a disposizione
dell'utente che li può usare per quello che vuole. Possono essere utili per
implementare una comunicazione elementare fra processi diversi, o per
- eseguire a richiesta una operazione utilizzando un manipolatore. L'azione di
- default è terminare il processo.
+ eseguire a richiesta una operazione utilizzando un gestore. L'azione
+ predefinita è di terminare il processo.
\item[\macro{SIGWINCH}] Il nome sta per \textit{window (size) change} e viene
generato in molti sistemi (GNU/Linux compreso) quando le dimensioni (in
righe e colonne) di un terminale vengono cambiate. Viene usato da alcuni
programmi testuali per riformattare l'uscita su schermo quando si cambia
- dimensione a quest'ultimo. L'azione di default è di essere ignorato.
+ dimensione a quest'ultimo. L'azione predefinita è di essere ignorato.
\item[\macro{SIGINFO}] Il segnale indica una richiesta di informazioni. È
usato con il controllo di sessione, causa la stampa di informazioni da parte
del processo leader del gruppo associato al terminale di controllo, gli
\func{strsignal} e \func{psignal}, che stampano un messaggio di descrizione
dato il numero. In genere si usano quando si vuole notificare all'utente il
segnale avvenuto (nel caso di terminazione di un processo figlio o di un
-manipolatore che gestisce più segnali); la prima funzione è una estensione
+gestore che gestisce più segnali); la prima funzione è una estensione
GNU, accessibile avendo definito \macro{\_GNU\_SOURCE}, ed è analoga alla
funzione \func{strerror} (si veda \secref{sec:sys_strerror}) per gli errori:
\begin{prototype}{string.h}{char *strsignal(int signum)}
eventi che possono accadere in un qualunque momento durante l'esecuzione di un
programma. Per questa loro caratteristica la loro gestione non può essere
effettuata all'interno del normale flusso di esecuzione dello stesso, ma è
-delegata appunto agli eventuali manipolatori che si sono installati.
+delegata appunto agli eventuali gestori che si sono installati.
In questa sezione vedremo come si effettua gestione dei segnali, a partire
dalla loro interazione con le system call, passando per le varie funzioni che
-permettono di installare i manipolatori e controllare le reazioni di un
+permettono di installare i gestori e controllare le reazioni di un
processo alla loro occorrenza.
loro stretta relazione con la creazione di nuovi processi.
Come accennato in \secref{sec:proc_fork} quando viene creato un nuovo processo
-esso eredita dal padre sia le azioni che sono state settate per i singoli
+esso eredita dal padre sia le azioni che sono state impostate per i singoli
segnali, che la maschera dei segnali bloccati (vedi \secref{sec:sig_sigmask}).
Invece tutti i segnali pendenti e gli allarmi vengono cancellati; essi infatti
devono essere recapitati solo al padre, al figlio dovranno arrivare solo i
Quando si mette in esecuzione un nuovo programma con \func{exec} (si ricordi
quanto detto in \secref{sec:proc_exec}) tutti i segnali per i quali è stato
-installato un manipolatore vengono resettati a \macro{SIG\_DFL}. Non ha più
+installato un gestore vengono reimpostati a \macro{SIG\_DFL}. Non ha più
senso infatti fare riferimento a funzioni definite nel programma originario,
che non sono presenti nello spazio di indirizzi del nuovo programma.
Si noti che questo vale solo per le azioni per le quali è stato installato un
-manipolatore; viene mantenuto invece ogni eventuale settaggio dell'azione a
-\macro{SIG\_IGN}. Questo permette ad esempio alla shell di settare ad
+gestore; viene mantenuto invece ogni eventuale impostazione dell'azione a
+\macro{SIG\_IGN}. Questo permette ad esempio alla shell di impostare ad
\macro{SIG\_IGN} le risposte per \macro{SIGINT} e \macro{SIGQUIT} per i
programmi eseguiti in background, che altrimenti sarebbero interrotti da una
successiva pressione di \texttt{C-c} o \texttt{C-y}.
segnale. Esse sono dette \textsl{veloci} in quanto la loro esecuzione è
sostanzialmente immediata; la risposta al segnale viene sempre data dopo che
la system call è stata completata, in quanto attendere per eseguire un
-manipolatore non comporta nessun inconveniente.
+gestore non comporta nessun inconveniente.
In alcuni casi però alcune system call (che per questo motivo vengono chiamate
\textsl{lente}) possono bloccarsi indefinitamente. In questo caso non si può
attendere la conclusione della sistem call, perché questo renderebbe
-impossibile una risposta pronta al segnale, per cui il manipolatore viene
+impossibile una risposta pronta al segnale, per cui il gestore viene
eseguito prima che la system call sia ritornata. Un elenco dei casi in cui si
presenta questa situazione è il seguente:
\begin{itemize}
\item la funzione \func{wait} (se nessun processo figlio è ancora terminato).
\end{itemize}
-In questo caso si pone il problema di cosa fare una volta che il manipolatore
+In questo caso si pone il problema di cosa fare una volta che il gestore
sia ritornato. La scelta originaria dei primi Unix era quella di far ritornare
anche la system call restituendo l'errore di \macro{EINTR}. Questa è a
tutt'oggi una scelta corrente, ma comporta che i programmi che usano dei
-manipolatori controllino lo stato di uscita delle funzioni per ripeterne la
+gestori controllino lo stato di uscita delle funzioni per ripeterne la
chiamata qualora l'errore fosse questo.
Dimenticarsi di richiamare una system call interrotta da un segnale è un
\begin{prototype}{signal.h}
{sighandler\_t signal(int signum, sighandler\_t handler)}
- Installa la funzione di gestione \param{handler} (il manipolatore) per il
+ Installa la funzione di gestione \param{handler} (il gestore) per il
segnale \param{signum}.
- \bodydesc{La funzione ritorna il precedente manipolatore in caso di successo
+ \bodydesc{La funzione ritorna il precedente gestore in caso di successo
o \macro{SIG\_ERR} in caso di errore.}
\end{prototype}
operatori del C, senza di esse si sarebbe definita una funzione che ritorna
un puntatore a \ctyp{void} e non un puntatore ad una funzione \ctyp{void}.}
La funzione \func{signal} quindi restituisce e prende come secondo argomento
-un puntatore a una funzione di questo tipo, che è appunto il manipolatore del
+un puntatore a una funzione di questo tipo, che è appunto il gestore del
segnale.
Il numero di segnale passato in \param{signum} può essere indicato
direttamente con una delle costanti definite in \secref{sec:sig_standard}. Il
-manipolatore \param{handler} invece, oltre all'indirizzo della funzione da
-chiamare all'occorrenza del segnale, può assumere anche i due valori costanti
+gestore \param{handler} invece, oltre all'indirizzo della funzione da chiamare
+all'occorrenza del segnale, può assumere anche i due valori costanti
\macro{SIG\_IGN} con cui si dice ignorare il segnale e \macro{SIG\_DFL} per
-installare l'azione di di default.\footnote{si ricordi però che i due segnali
+reinstallare l'azione predefinita.\footnote{si ricordi però che i due segnali
\macro{SIGKILL} e \macro{SIGSTOP} non possono essere ignorati né
intercettati.}
La funzione restituisce l'indirizzo dell'azione precedente, che può essere
salvato per poterlo ripristinare (con un'altra chiamata a \func{signal}) in un
-secondo tempo. Si ricordi che se si setta come azione \macro{SIG\_IGN} (o si
-setta un \macro{SIG\_DFL} per un segnale il cui default è di essere ignorato),
-tutti i segnali pendenti saranno scartati, e non verranno mai notificati.
+secondo tempo. Si ricordi che se si imposta come azione \macro{SIG\_IGN} (o si
+imposta un \macro{SIG\_DFL} per un segnale la cui azione predefinita è di
+essere ignorato), tutti i segnali pendenti saranno scartati, e non verranno
+mai notificati.
L'uso di \func{signal} è soggetto a problemi di compatibilità, dato che essa
si comporta in maniera diversa per sistemi derivati da BSD o da System V. In
questi ultimi infatti la funzione è conforme al comportamento originale dei
-primi Unix in cui il manipolatore viene disinstallato alla sua chiamata,
+primi Unix in cui il gestore viene disinstallato alla sua chiamata,
secondo la semantica inaffidabile; Linux seguiva questa convenzione fino alle
-\acr{libc5}. Al contrario BSD segue la semantica affidabile, non resettando il
-manipolatore e bloccando il segnale durante l'esecuzione dello stesso. Con
-l'utilizzo delle \acr{glibc} dalla versione 2 anche Linux è passato a questo
-comportamento; quello della versione originale della funzione, il cui uso è
-deprecato per i motivi visti in \secref{sec:sig_semantics}, può essere
-ottenuto chiamando \func{sysv\_signal}. In generale, per evitare questi
-problemi, tutti i nuovi programmi dovrebbero usare \func{sigaction}.
+\acr{libc5}. Al contrario BSD segue la semantica affidabile, non
+disinstallando il gestore e bloccando il segnale durante l'esecuzione
+dello stesso. Con l'utilizzo delle \acr{glibc} dalla versione 2 anche Linux è
+passato a questo comportamento; quello della versione originale della
+funzione, il cui uso è deprecato per i motivi visti in
+\secref{sec:sig_semantics}, può essere ottenuto chiamando \func{sysv\_signal}.
+In generale, per evitare questi problemi, tutti i nuovi programmi dovrebbero
+usare \func{sigaction}.
È da tenere presente che, seguendo lo standard POSIX, il comportamento di un
processo che ignora i segnali \macro{SIGFPE}, \macro{SIGILL}, o
\macro{SIGSEGV} (qualora non originino da una \func{kill} o una \func{raise})
-è indefinito. Un manipolatore che ritorna da questi segnali può dare luogo ad
+è indefinito. Un gestore che ritorna da questi segnali può dare luogo ad
un ciclo infinito.
Il valore di \param{sig} specifica il segnale che si vuole inviare e può
essere specificato con una delle macro definite in
\secref{sec:sig_classification}. In genere questa funzione viene usata per
-riprodurre il comportamento di default di un segnale che sia stato
+riprodurre il comportamento predefinito di un segnale che sia stato
intercettato. In questo caso, una volta eseguite le operazioni volute, il
-manipolatore potrà reinstallare l'azione di default, e attivarla con
-\func{raise}.
+gestore potrà reinstallare l'azione predefinita, e attivarla con \func{raise}.
Se invece si vuole inviare un segnale ad un altro processo occorre utilizzare
la funzione \func{kill}; il cui prototipo è:
appartengano alla stessa sessione. Inoltre, dato il ruolo fondamentale che
riveste nel sistema (si ricordi quanto visto in \secref{sec:sig_termination}),
non è possibile inviare al processo 1 (cioè a \cmd{init}) segnali per i quali
-esso non abbia un manipolatore installato.
+esso non abbia un gestore installato.
Infine, seguendo le specifiche POSIX 1003.1-2001, l'uso della chiamata
\code{kill(-1, sig)} comporta che il segnale sia inviato (con la solita
\label{tab:sig_setitimer_values}
\end{table}
-Il valore della struttura specificata \param{value} viene usato per settare il
+Il valore della struttura specificata \param{value} viene usato per impostare il
timer, se il puntatore \param{ovalue} non è nullo il precedente valore viene
salvato qui. I valori dei timer devono essere indicati attraverso una
struttura \type{itimerval}, definita in \figref{fig:file_stat_struct}.
permette una precisione fino al microsecondo.
Ciascun timer decrementa il valore di \var{it\_value} fino a zero, poi invia
-il segnale e resetta \var{it\_value} al valore di \var{it\_interval}, in
+il segnale e reimposta \var{it\_value} al valore di \var{it\_interval}, in
questo modo il ciclo verrà ripetuto; se invece il valore di \var{it\_interval}
è nullo il timer si ferma.
può però essere intercettato per effettuare eventuali operazioni di chiusura
prima della terminazione del processo.
-Lo standard ANSI C richiede inoltre che anche se il manipolatore ritorna, la
+Lo standard ANSI C richiede inoltre che anche se il gestore ritorna, la
funzione non ritorni comunque. Lo standard POSIX.1 va oltre e richiede che se
-il processo non viene terminato direttamente dal manipolatore sia la stessa
+il processo non viene terminato direttamente dal gestore sia la stessa
\func{abort} a farlo al ritorno dello stesso. Inoltre, sempre seguendo lo
standard POSIX, prima della terminazione tutti i file aperti e gli stream
saranno chiusi ed i buffer scaricati su disco. Non verranno invece eseguite le
quello di usare la funzione \func{pause}, il cui prototipo è:
\begin{prototype}{unistd.h}{int pause(void)}
- Pone il processo in stato di sleep fino al ritorno di un manipolatore.
+ Pone il processo in stato di sleep fino al ritorno di un gestore.
\bodydesc{La funzione ritorna solo dopo che un segnale è stato ricevuto ed
- il relativo manipolatore è ritornato, nel qual caso restituisce -1 e setta
+ il relativo gestore è ritornato, nel qual caso restituisce -1 e imposta
\var{errno} a \macro{EINTR}.}
\end{prototype}
Pone il processo in stato di sleep per \param{usec} microsecondi.
\bodydesc{La funzione restituisce zero se l'attesa viene completata, o -1 in
- caso di errore, nel qual caso \var{errno} è settata a \macro{EINTR}.}
+ caso di errore, nel qual caso \var{errno} è impostata a \macro{EINTR}.}
\end{prototype}
In caso di interruzione restituisce il tempo restante in \param{rem}.
\bodydesc{La funzione restituisce zero se l'attesa viene completata, o -1 in
- caso di errore, nel qual caso \var{errno} è settata a
+ caso di errore, nel qual caso \var{errno} è impostata a
\begin{errlist}
\item[\macro{EINVAL}] si è specificato un numero di secondi negativo o un
numero di nanosecondi maggiore di 999.999.999.
\subsection{Un esempio elementare}
\label{sec:sig_sigchld}
-Un semplice esempio per illustrare il funzionamento di un manipolatore di
-segnale è quello della gestione di \macro{SIGCHLD}. Abbiamo visto in
+Un semplice esempio per illustrare il funzionamento di un gestore di segnale è
+quello della gestione di \macro{SIGCHLD}. Abbiamo visto in
\secref{sec:proc_termination} che una delle azioni eseguite dal kernel alla
conclusione di un processo è quella di inviare questo segnale al
padre.\footnote{in realtà in SVr4 eredita la semantica di System V, in cui il
segnale si chiama \macro{SIGCLD} e viene trattato in maniera speciale; in
- System V infatti se si setta esplicitamente l'azione a \macro{SIG\_IGN} il
+ System V infatti se si imposta esplicitamente l'azione a \macro{SIG\_IGN} il
segnale non viene generato ed il sistema non genera zombie (lo stato di
terminazione viene scartato senza dover chiamare una \func{wait}). L'azione
- di default è sempre quella di ignorare il segnale, ma non attiva questo
+ predefinita è sempre quella di ignorare il segnale, ma non attiva questo
comportamento. Linux, come BSD e POSIX, non supporta questa semantica ed usa
il nome di \macro{SIGCLD} come sinonimo di \macro{SIGCHLD}.} In generale
dunque, quando non interessa elaborare lo stato di uscita di un processo, si
-può completare la gestione della terminazione installando un manipolatore per
+può completare la gestione della terminazione installando un gestore per
\macro{SIGCHLD} il cui unico compito sia quello chiamare \func{waitpid} per
completare la procedura di terminazione in modo da evitare la formazione di
zombie.
In \figref{fig:sig_sigchld_handl} è mostrato il codice della nostra
-implementazione del manipolatore; se aggiungiamo al codice di
-\file{ForkTest.c} l'installazione di questo manipolatore potremo verificare che
+implementazione del gestore; se aggiungiamo al codice di
+\file{ForkTest.c} l'installazione di questo gestore potremo verificare che
ripetendo l'esempio visto in \secref{sec:proc_termination} che non si ha più
la creazione di zombie.
% naturale usare un esempio che ci permette di concludere la trattazione della
% terminazione dei processi.
% In questo caso si è tratterà di illustrare un esempio relativo ad un
-% manipolatore per che è previsto ritornare,
+% gestore per che è previsto ritornare,
\begin{figure}[!htb]
\end{lstlisting}
\end{minipage}
\normalsize
- \caption{Un manipolatore per il segnale \texttt{SIGCHLD}.}
+ \caption{Un gestore per il segnale \texttt{SIGCHLD}.}
\label{fig:sig_sigchld_handl}
\end{figure}
-Il codice del manipolatore è di lettura immediata; come buona norma di
+Il codice del gestore è di lettura immediata; come buona norma di
programmazione (si ricordi quanto accennato \secref{sec:sys_errno}) si
comincia (\texttt{\small 12-13}) con il salvare lo stato corrente di
\var{errno}, in modo da poterlo ripristinare prima del ritorno del
-manipolatore (\texttt{\small 22-23}). In questo modo si preserva il valore
+gestore (\texttt{\small 22-23}). In questo modo si preserva il valore
della variabile visto dal corso di esecuzione principale del processo, che
sarebbe altrimenti sarebbe sovrascritto dal valore restituito nella successiva
chiamata di \func{wait}.
-Il compito principale del manipolatore è quello di ricevere lo stato di
+Il compito principale del gestore è quello di ricevere lo stato di
terminazione del processo, cosa che viene eseguita nel ciclo in
(\texttt{\small 15-21}). Il ciclo è necessario a causa di una caratteristica
fondamentale della gestione dei segnali: abbiamo già accennato come fra la
-generazione di un segnale e l'esecuzione del manipolatore possa passare un
-certo lasso di tempo e niente ci assicura che il manipolatore venga eseguito
+generazione di un segnale e l'esecuzione del gestore possa passare un
+certo lasso di tempo e niente ci assicura che il gestore venga eseguito
prima della generazione di ulteriori segnali dello stesso tipo. In questo caso
normalmente i segnali segnali successivi vengono ``fusi'' col primo ed al
processo ne viene recapitato soltanto uno.
\figref{fig:sig_sleep_wrong}.
Dato che è nostra intenzione utilizzare \macro{SIGALRM} il primo passo della
-nostra implementazione di sarà quello di installare il relativo manipolatore
+nostra implementazione di sarà quello di installare il relativo gestore
salvando il precedente (\texttt{\small 14-17}). Si effettuerà poi una
chiamata ad \func{alarm} per specificare il tempo d'attesa per l'invio del
segnale a cui segue la chiamata a \func{pause} per fermare il programma
(\texttt{\small 17-19}) fino alla sua ricezione. Al ritorno di \func{pause},
-causato dal ritorno del manipolatore (\texttt{\small 1-9}), si ripristina il
-manipolatore originario (\texttt{\small 20-21}) restituendo l'eventuale tempo
+causato dal ritorno del gestore (\texttt{\small 1-9}), si ripristina il
+gestore originario (\texttt{\small 20-21}) restituendo l'eventuale tempo
rimanente (\texttt{\small 22-23}) che potrà essere diverso da zero qualora
l'interruzione di \func{pause} venisse causata da un altro segnale.
Questo problema può essere risolto (ed è la modalità con cui veniva fatto in
SVr2) usando la funzione \func{longjmp} (vedi \secref{sec:proc_longjmp}) per
-uscire dal manipolatore; in questo modo, con una condizione sullo stato di
+uscire dal gestore; in questo modo, con una condizione sullo stato di
uscita di quest'ultima, si può evitare la chiamata a \func{pause}, usando un
codice del tipo di quello riportato in \figref{fig:sig_sleep_incomplete}.
\label{fig:sig_sleep_incomplete}
\end{figure}
-In questo caso il manipolatore (\texttt{\small 18-26}) non ritorna come in
+In questo caso il gestore (\texttt{\small 18-26}) non ritorna come in
\figref{fig:sig_sleep_wrong}, ma usa \func{longjmp} (\texttt{\small 24}) per
rientrare nel corpo principale del programma; dato che in questo caso il
valore di uscita di \func{setjmp} è 1, grazie alla condizione in
Ma anche questa implementazione comporta dei problemi; in questo caso infatti
non viene gestita correttamente l'interazione con gli altri segnali; se
-infatti il segnale di allarme interrompe un altro manipolatore, in questo caso
-l'esecuzione non riprenderà nel manipolatore in questione, ma nel ciclo
+infatti il segnale di allarme interrompe un altro gestore, in questo caso
+l'esecuzione non riprenderà nel gestore in questione, ma nel ciclo
principale, interrompendone inopportunamente l'esecuzione. Lo stesso tipo di
problemi si presenterebbero se si volesse usare \func{alarm} per stabilire un
timeout su una qualunque system call bloccante.
Un secondo esempio è quello in cui si usa il segnale per notificare una
-qualche forma di evento; in genere quello che si fa in questo caso è settare
-nel manipolatore un opportuno flag da controllare nel corpo principale del
+qualche forma di evento; in genere quello che si fa in questo caso è impostare
+nel gestore un opportuno flag da controllare nel corpo principale del
programma (con un codice del tipo di quello riportato in
\figref{fig:sig_event_wrong}).
\label{fig:sig_event_wrong}
\end{figure}
-La logica è quella di far settare al manipolatore (\texttt{\small 14-19}) una
+La logica è quella di far impostare al gestore (\texttt{\small 14-19}) una
variabile globale preventivamente inizializzata nel programma principale, il
quale potrà determinare, osservandone il contenuto, l'occorrenza o meno del
segnale, e prendere le relative azioni conseguenti (\texttt{\small 6-11}).
\bodydesc{Le prime quattro funzioni ritornano 0 in caso di successo, mentre
\func{sigismember} ritorna 1 se \param{signum} è in \param{set} e 0
- altrimenti. In caso di errore tutte ritornano -1, con \var{errno} settata a
+ altrimenti. In caso di errore tutte ritornano -1, con \var{errno} impostata a
\macro{EINVAL} (il solo errore possibile è che \param{signum} non sia un
segnale valido).}
\end{functions}
errore, nel qual caso \var{errno} assumerà i valori:
\begin{errlist}
\item[\macro{EINVAL}] Si è specificato un numero di segnale invalido o si è
- cercato di installare il manipolatore per \macro{SIGKILL} o
+ cercato di installare il gestore per \macro{SIGKILL} o
\macro{SIGSTOP}.
\item[\macro{EFAULT}] Si sono specificati indirizzi non validi.
\end{errlist}}
\end{prototype}
La funzione serve ad installare una nuova \textsl{azione} per il segnale
-\param{signum}; si parla di \textsl{azione} e non di \textsl{manipolatore}
+\param{signum}; si parla di \textsl{azione} e non di \textsl{gestore}
come nel caso di \func{signal}, in quanto la funzione consente di specificare
le varie caratteristiche della risposta al segnale, non solo la funzione che
verrà eseguita alla sua occorrenza. Per questo lo standard raccomanda di
\end{figure}
Il campo \var{sa\_mask} serve ad indicare l'insieme dei segnali che devono
-essere bloccati durante l'esecuzione del manipolatore, ad essi viene comunque
+essere bloccati durante l'esecuzione del gestore, ad essi viene comunque
sempre aggiunto il segnale che ne ha causato la chiamata, a meno che non si
sia specificato con \var{sa\_flag} un comportamento diverso. Quando il
-manipolatore ritorna comunque la maschera dei segnali bloccati (vedi
+gestore ritorna comunque la maschera dei segnali bloccati (vedi
\secref{sec:sig_sigmask}) viene ripristinata al valore precedente
l'invocazione.
L'uso di questo campo permette ad esempio di risolvere il problema residuo
dell'implementazione di \code{sleep} mostrata in
\secref{fig:sig_sleep_incomplete}. In quel caso infatti se il segnale di
-allarme avesse interrotto un altro manipolatore questo non sarebbe stato
+allarme avesse interrotto un altro gestore questo non sarebbe stato
eseguito correttamente; la cosa poteva essere prevenuta installando gli altri
-manipolatori usando \var{sa\_mask} per bloccare \macro{SIGALRM} durante la
+gestori usando \var{sa\_mask} per bloccare \macro{SIGALRM} durante la
loro esecuzione. Il valore di \var{sa\_flag} permette di specificare vari
aspetti del comportamento di \func{sigaction}, e della reazione del processo
ai vari segnali; i valori possibili ed il relativo significato sono riportati
fermato da uno dei segnali \macro{SIGSTOP},
\macro{SIGTSTP}, \macro{SIGTTIN} o
\macro{SIGTTOU}.\\
- \macro{SA\_ONESHOT} & Ristabilisce l'azione per il segnale al valore di
- default una volta che il manipolatore è stato
+ \macro{SA\_ONESHOT} & Ristabilisce l'azione per il segnale al valore
+ predefinito una volta che il gestore è stato
lanciato, riproduce cioè il comportamento della
semantica inaffidabile.\\
\macro{SA\_RESETHAND}& Sinonimo di \macro{SA\_ONESHOT}. \\
segnale; riproduce cioè il comportamento standard
di BSD.\\
\macro{SA\_NOMASK} & Evita che il segnale corrente sia bloccato durante
- l'esecuzione del manipolatore.\\
+ l'esecuzione del gestore.\\
\macro{SA\_NODEFER} & Sinonimo di \macro{SA\_NOMASK}.\\
\macro{SA\_SIGINFO} & Deve essere specificato quando si vuole usare un
- manipolatore in forma estesa usando
+ gestore in forma estesa usando
\var{sa\_sigaction} al posto di \var{sa\_handler}.\\
\macro{SA\_ONSTACK} & Stabilisce l'uso di uno stack alternativo per
- l'esecuzione del manipolatore (vedi
+ l'esecuzione del gestore (vedi
\secref{sec:sig_specific_features}).\\
\hline
\end{tabular}
real-time (vedi \secref{sec:sig_real_time}). In precedenza era possibile
ottenere alcune informazioni addizionali usando \var{sa\_handler} con un
secondo parametro addizionale di tipo \var{struct sigcontext}, che adesso è
- deprecato.} di utilizzare due forme diverse di manipolatore, da
+ deprecato.} di utilizzare due forme diverse di gestore, da
specificare, a seconda dell'uso o meno del flag \macro{SA\_SIGINFO},
rispettivamente attraverso i campi \var{sa\_sigaction} o \var{sa\_handler},
(che devono essere usati in maniera alternativa, in certe implementazioni
questi vengono addirittura definiti come \ctyp{union}): la prima è quella
classica usata anche con \func{signal}, la seconda permette invece di usare un
-manipolatore in grado di ricevere informazioni più dettagliate dal sistema,
+gestore in grado di ricevere informazioni più dettagliate dal sistema,
attraverso la struttura \type{siginfo\_t}, riportata in
\figref{fig:sig_siginfo_t}.
\label{fig:sig_siginfo_t}
\end{figure}
-Installando un manipolatore di tipo \var{sa\_sigaction} diventa allora
+Installando un gestore di tipo \var{sa\_sigaction} diventa allora
possibile accedere alle informazioni restituite attraverso il puntatore a
-questa struttura. Tutti i segnali settano i campi \var{si\_signo}, che riporta
+questa struttura. Tutti i segnali impostano i campi \var{si\_signo}, che riporta
il numero del segnale ricevuto, \var{si\_errno}, che riporta, quando diverso
da zero, il codice dell'errore associato al segnale, e \var{si\_code}, che
viene usato dal kernel per specificare maggiori dettagli riguardo l'evento che
\func{signal} occorre molta attenzione, in quanto le due funzioni possono
interagire in maniera anomala. Infatti l'azione specificata con
\var{sigaction} contiene un maggior numero di informazioni rispetto al
-semplice indirizzo del manipolatore restituito da \func{signal}. Per questo
-motivo se si usa quest'ultima per installare un manipolatore sostituendone uno
+semplice indirizzo del gestore restituito da \func{signal}. Per questo
+motivo se si usa quest'ultima per installare un gestore sostituendone uno
precedentemente installato con \func{sigaction}, non sarà possibile effettuare
un ripristino corretto dello stesso.
Per questo è sempre opportuno usare \func{sigaction}, che è in grado di
-ripristinare correttamente un manipolatore precedente, anche se questo è stato
+ripristinare correttamente un gestore precedente, anche se questo è stato
installato con \func{signal}. In generale poi non è il caso di usare il valore
di ritorno di \func{signal} come campo \var{sa\_handler}, o viceversa, dato
che in certi sistemi questi possono essere diversi. In definitiva dunque, a
\label{sec:sig_sigmask}
Come spiegato in \secref{sec:sig_semantics} tutti i moderni sistemi unix-like
-permettono si bloccare temporaneamente (o di eliminare completamente, settando
+permettono si bloccare temporaneamente (o di eliminare completamente, impostando
\macro{SIG\_IGN} come azione) la consegna dei segnali ad un processo. Questo è
fatto specificando la cosiddetta \textsl{maschera dei segnali} (o
\textit{signal mask}) del processo\footnote{nel caso di Linux essa è mantenuta
l'insieme dei segnali la cui consegna è bloccata. Abbiamo accennato in
\secref{sec:proc_fork} che la \textit{signal mask} viene ereditata dal padre
alla creazione di un processo figlio, e abbiamo visto al paragrafo precedente
-che essa può essere modificata, durante l'esecuzione di un manipolatore,
+che essa può essere modificata, durante l'esecuzione di un gestore,
attraverso l'uso dal campo \var{sa\_mask} di \var{sigaction}.
Uno dei problemi evidenziatisi con l'esempio di \secref{fig:sig_event_wrong} è
\macro{SIG\_UNBLOCK} & I segnali specificati in \param{set} sono rimossi
dalla maschera dei segnali, specificare la
cancellazione di un segnale non bloccato è legale.\\
- \macro{SIG\_SETMASK} & La maschera dei segnali è settata al valore
+ \macro{SIG\_SETMASK} & La maschera dei segnali è impostata al valore
specificato da \param{set}.\\
\hline
\end{tabular}
\secref{fig:sig_event_wrong}, proteggendo la sezione fra il controllo del flag
e la sua cancellazione.
-La funzione può essere usata anche all'interno di un manipolatore, ad esempio
+La funzione può essere usata anche all'interno di un gestore, ad esempio
per riabilitare la consegna del segnale che l'ha invocato, in questo caso però
occorre ricordare che qualunque modifica alla maschera dei segnali viene
perduta alla conclusione del terminatore.
\begin{prototype}{signal.h}
{int sigsuspend(const sigset\_t *mask)}
- Setta la \textit{signal mask} specificata, mettendo in attesa il processo.
+ Imposta la \textit{signal mask} specificata, mettendo in attesa il processo.
\bodydesc{La funzione restituisce zero in caso di successo e -1 per un
errore, nel qual caso \var{errno} assumerà i valori:
Come esempio dell'uso di queste funzioni proviamo a riscrivere un'altra volta
l'esempio di implementazione di \code{sleep}. Abbiamo accennato in
\secref{sec:sig_sigaction} come con \func{sigaction} sia possibile bloccare
-\macro{SIGALRM} nell'installazione dei manipolatori degli altri segnali, per
+\macro{SIGALRM} nell'installazione dei gestori degli altri segnali, per
poter usare l'implementazione vista in \secref{fig:sig_sleep_incomplete} senza
interferenze. Questo però comporta una precauzione ulteriore al semplice uso
della funzione, vediamo allora come usando la nuova interfaccia è possibile
Per evitare i problemi di interferenza con gli altri segnali in questo caso
non si è usato l'approccio di \figref{fig:sig_sleep_incomplete} evitando l'uso
-di \func{longjmp}. Come in precedenza il manipolatore (\texttt{\small 35-37})
+di \func{longjmp}. Come in precedenza il gestore (\texttt{\small 35-37})
non esegue nessuna operazione, limitandosi a ritornare per interrompere il
programma messo in attesa.
La prima parte della funzione (\texttt{\small 11-15}) provvede ad installare
-l'opportuno manipolatore per \macro{SIGALRM}, salvando quello originario, che
+l'opportuno gestore per \macro{SIGALRM}, salvando quello originario, che
sarà ripristinato alla conclusione della stessa (\texttt{\small 28}); il passo
successivo è quello di bloccare \macro{SIGALRM} (\texttt{\small 17-19}) per
evitare che esso possa essere ricevuto dal processo fra l'esecuzione di
di usare uno stack alternativo per i segnali; è cioè possibile fare usare al
sistema un altro stack (invece di quello relativo al processo, vedi
\secref{sec:proc_mem_layout}) solo durante l'esecuzione di un
-manipolatore. L'uso di uno stack alternativo è del tutto trasparente ai
-manipolatori, occorre però seguire una certa procedura:
+gestore. L'uso di uno stack alternativo è del tutto trasparente ai
+gestori, occorre però seguire una certa procedura:
\begin{enumerate*}
\item Allocare un'area di memoria di dimensione sufficiente da usare come
stack alternativo.
\item Usare la funzione \func{sigaltstack} per rendere noto al sistema
l'esistenza e la locazione dello stack alternativo.
-\item Quando si installa un manipolatore occorre usare \func{sigaction}
+\item Quando si installa un gestore occorre usare \func{sigaction}
specificando il flag \macro{SA\_ONSTACK} (vedi \tabref{tab:sig_sa_flag}) per
dire al sistema di usare lo stack alternativo durante l'esecuzione del
- manipolatore.
+ gestore.
\end{enumerate*}
In genere il primo passo viene effettuato allocando un'opportuna area di
allocare una quantità di spazio opportuna, in modo da evitare overflow. La
prima delle due è la dimensione canonica per uno stack di segnali e di norma è
sufficiente per tutti gli usi normali. La seconda è lo spazio che occorre al
-sistema per essere in grado di lanciare il manipolatore e la dimensione di uno
+sistema per essere in grado di lanciare il gestore e la dimensione di uno
stack alternativo deve essere sempre maggiore di questo valore. Quando si
-conosce esattamente quanto è lo spazio necessario al manipolatore gli si può
+conosce esattamente quanto è lo spazio necessario al gestore gli si può
aggiungere questo valore per allocare uno stack di dimensione sufficiente.
Come accennato per poter essere usato lo stack per i segnali deve essere
\func{exec} cancella ogni stack alternativo.
Abbiamo visto in \secref{fig:sig_sleep_incomplete} come si possa usare
-\func{longjmp} per uscire da un manipolatore rientrando direttamente nel corpo
-del programma; sappiamo però che nell'esecuzione di un manipolatore il segnale
+\func{longjmp} per uscire da un gestore rientrando direttamente nel corpo
+del programma; sappiamo però che nell'esecuzione di un gestore il segnale
che l'ha invocato viene bloccato, e abbiamo detto che possiamo ulteriormente
modificarlo con \func{sigprocmask}.
Resta quindi il problema di cosa succede alla maschera dei segnali quando si
-esce da un manipolatore usando questa funzione. Il comportamento dipende
+esce da un gestore usando questa funzione. Il comportamento dipende
dall'implementazione; in particolare BSD ripristina la maschera dei segnali
precedente l'invocazione, come per un normale ritorno, mentre System V no. Lo
standard POSIX.1 non specifica questo comportamento per \func{setjmp} e
\begin{description}
\item[I segnali non sono accumulati]
- se più segnali vengono generati prima dell'esecuzione di un manipolatore
+ se più segnali vengono generati prima dell'esecuzione di un gestore
questo sarà eseguito una sola volta, ed il processo non sarà in grado di
accorgersi di quante volte l'evento che ha generato il segnale è accaduto.
\item[I segnali non trasportano informazione]
\begin{itemize*}
\item i segnali sono inseriti in una coda che permette di consegnare istanze
multiple dello stesso segnale qualora esso venga inviato più volte prima
- dell'esecuzione del manipolatore; si assicura così che il processo riceva un
+ dell'esecuzione del gestore; si assicura così che il processo riceva un
segnale per ogni occorrenza dell'evento che lo genera.
\item è stata introdotta una priorità nella consegna dei segnali: i segnali
vengono consegnati in ordine a seconda del loro valore, partendo da quelli
con un numero minore, che pertanto hanno una priorità maggiore.
\item è stata introdotta la possibilità di restituire dei dati al
- manipolatore, attraverso l'uso di un campo apposito nella struttura
- \type{siginfo\_t} accessibile tramite manipolatori di tipo
+ gestore, attraverso l'uso di un campo apposito nella struttura
+ \type{siginfo\_t} accessibile tramite gestori di tipo
\var{sa\_sigaction}.
\end{itemize*}
I segnali con un numero più basso hanno una priorità maggiore e vengono
consegnati per primi, inoltre i segnali real-time non possono interrompere
-l'esecuzione di un manipolatore di un segnale a priorità più alta; la loro
-azione di default è quella di terminare il programma. I segnali ordinari
-hanno tutti la stessa priorità, che è più alta di quella di qualunque segnale
+l'esecuzione di un gestore di un segnale a priorità più alta; la loro azione
+predefinita è quella di terminare il programma. I segnali ordinari hanno
+tutti la stessa priorità, che è più alta di quella di qualunque segnale
real-time.
Si tenga presente che questi nuovi segnali non sono associati a nessun evento
sepcifico (a meno di non utilizzarli, come vedremo in
\secref{sec:file_asyncronous_io}, per l'I/O asincrono) e devono essere inviati
-esplicitamente. Tutti i segnali real-time restituiscono al manipolatore, oltre
+esplicitamente. Tutti i segnali real-time restituiscono al gestore, oltre
ai campi \var{si\_pid} e \var{si\_uid} di \type{siginfo\_t} una struttura
\type{sigval} (riportata in \figref{fig:sig_sigval}) in cui può essere
restituito al processo un valore o un indirizzo, che costituisce il meccanismo
\end{minipage}
\normalsize
\caption{La struttura \type{sigval}, usata dai segnali real time per
- restituire dati al manipolatore.}
+ restituire dati al gestore.}
\label{fig:sig_sigval}
\end{figure}
{int sigqueue(pid\_t pid, int signo, const union sigval value)}
Invia il segnale \param{signo} al processo \param{pid}, restituendo al
- manipolatore il valore \param{value}.
+ gestore il valore \param{value}.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} viene settata ai valori:
+ errore, nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EAGAIN}] La coda è esarita, ci sono già \macro{SIGQUEUE\_MAX}
segnali in attesa si consegna.
di errore senza inviare nessun segnale.
Se il segnale è bloccato la funzione ritorna immediatamente, se si è
-installato un manipolatore con \macro{SA\_SIGINFO} e ci sono risorse
+installato un gestore con \macro{SA\_SIGINFO} e ci sono risorse
disponibili, vale a dire che c'è posto nella coda\footnote{la profondità della
coda è indicata dalla costante \macro{SIGQUEUE\_MAX}, una della tante
costanti di sistema definite dallo standard POSIX, che non abbiamo riportato
standard, \macro{\_POSIX\_SIGQUEUE\_MAX}, è pari a 32.}, esso viene inserito
e diventa pendente; una volta consegnato riporterà nel campo \var{si\_code} di
\var{siginfo} il valore \macro{SI\_QUEUE} e il campo \var{si\_value} riceverà
-quanto inviato con \param{value}. Se invece si è installato un manipolatore
+quanto inviato con \param{value}. Se invece si è installato un gestore
nella forma classica il segnale sarà generato, ma tutte le caratteristiche
tipiche dei segnali real-time (priorità e coda) saranno perse.
Attende che uno dei segnali specificati in \param{set} sia pendente.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} viene settata ai valori:
+ errore, nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EINTR}] La funzione è stata interrotta.
\item[\macro{EINVAL}] Si è specificato un valore non valido per
Per un funzionamento corretto la funzione richiede che alla sua chiamata i
segnali di \param{set} siano bloccati. In caso contrario si avrebbe un
-conflitto con gli eventuali manipolatori: pertanto non si deve utilizzare per
+conflitto con gli eventuali gestori: pertanto non si deve utilizzare per
lo stesso segnale questa funzione e \func{sigaction}. Se questo non avviene il
comportamento del sistema è indeterminato: il segnale può sia essere
consegnato che essere ricevuto da \func{sigwait}, il tutto in maniera non
\bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} viene settata ai valori già visti per
+ errore, nel qual caso \var{errno} viene impostata ai valori già visti per
\func{sigwait}, ai quali se aggiunge, per \func{sigtimedwait}:
\begin{errlist}
\item[\macro{EAGAIN}] Si è superato il timeout senza che un segnale atteso
L'uso di queste funzioni è principalmente associato alla gestione dei segnali
com i thread. In genere esse vengono chiamate dal thread incaricato della
gestione, che al ritorno della funzione esegue il codice che usualmente
-sarebbe messo nel manipolatore, per poi ripetere la chiamata per mettersi in
-attesa del segnale successivo. Questo ovviamente comporta che non devono
-essere installati manipolatori, che solo il thread di gestione deve usare
-\func{sigwait} e che, per evitare che venga eseguita l'azione di default, i
-segnali gestiti in questa maniera devono essere mascherati per tutti i thread,
-compreso quello dedicato alla gestione, che potrebbe riceverlo fra due
-chiamate successive.
+sarebbe messo nel gestore, per poi ripetere la chiamata per mettersi in attesa
+del segnale successivo. Questo ovviamente comporta che non devono essere
+installati gestori, che solo il thread di gestione deve usare \func{sigwait} e
+che, per evitare che venga eseguita l'azione predefinita, i segnali gestiti in
+questa maniera devono essere mascherati per tutti i thread, compreso quello
+dedicato alla gestione, che potrebbe riceverlo fra due chiamate successive.
%%% Local Variables:
%%% mode: latex
Tutto questo riguarda la connessione, c'è però da tenere conto dell'effetto
del procedimento di chiusura del processo figlio nel server (si veda quanto
esaminato in \secref{sec:proc_termination}). In questo caso avremo l'invio del
-segnale \macro{SIGCHILD} al padre, ma dato che non si è installato un
-manipolatore e che l'azione di default per questo segnale è quella di essere
+segnale \macro{SIGCHLD} al padre, ma dato che non si è installato un
+manipolatore e che l'azione predefinita per questo segnale è quella di essere
ignorato, non avendo predisposto la ricezione dello stato di terminazione,
-otterremo che il processo figlio entrerà nello stato di zombie, come risulterà
-ripetendo il comando \cmd{ps}:
+otterremo che il processo figlio entrerà nello stato di zombie (si riveda
+quanto illustrato in \secref{sec:sig_sigchld}), come risulterà ripetendo il
+comando \cmd{ps}:
\begin{verbatim}
2356 pts/0 S 0:00 ./echod
2359 pts/0 Z 0:00 [echod <defunct>]
Apre un socket.
\bodydesc{La funzione restituisce un intero positivo se riesce, e -1 se
- fallisce, in quest'ultimo caso la variabile \var{errno} è settata con i
+ fallisce, in quest'ultimo caso la variabile \var{errno} è impostata con i
seguenti codici di errore:
\begin{errlist}
prevede numeri di porta, che sono utilizzati solo dai protocolli di livello
superiore come TCP e UDP. Questa struttura però viene usata anche per i socket
RAW che accedono direttamente al livello di IP, nel qual caso il numero della
-porta viene settato al numero di protocollo.
+porta viene impostato al numero di protocollo.
-Il membro \var{sin\_family} deve essere sempre settato; \var{sin\_port}
+Il membro \var{sin\_family} deve essere sempre impostato; \var{sin\_port}
specifica il numero di porta (vedi \secref{sec:TCPel_port_num}; i numeri di
porta sotto il 1024 sono chiamati \textsl{riservati} in quanto utilizzati da
servizi standard. Soltanto processi con i privilegi di root (effective uid
\label{fig:sock_sa_ipv6_struct}
\end{figure}
-Il campo \var{sin6\_family} deve essere sempre settato ad
+Il campo \var{sin6\_family} deve essere sempre impostato ad
\macro{AF\_INET6}, il campo \var{sin6\_port} è analogo a quello di IPv4 e
segue le stesse regole; il campo \var{sin6\_flowinfo} è a sua volta diviso
in tre parti di cui i 24 bit inferiori indicano l'etichetta di flusso, i
Entrambe le funzioni accettano l'argomento \param{af} che indica il tipo di
indirizzo e può essere \macro{AF\_INET} o \macro{AF\_INET6}. Se la famiglia
-indicata non è valida entrambe le funzioni settano la variabile \var{errno}
+indicata non è valida entrambe le funzioni impostano la variabile \var{errno}
al valore \macro{EAFNOSUPPORT}. I prototipi delle suddette funzioni sono i
seguenti:
\begin{prototype}{sys/socket.h}
\bodydesc{La funzione restituisce un puntatore non nullo a \var{dest} in
caso di successo e un puntatore nullo in caso di fallimento, in
- quest'ultimo caso viene settata la variabile \var{errno} con il valore
+ quest'ultimo caso viene impostata la variabile \var{errno} con il valore
\macro{ENOSPC} in caso le dimensioni dell'indirizzo eccedano la lunghezza
specificata da \var{len} o \macro{ENOAFSUPPORT} in caso \var{af} non sia
una famiglia di indirizzi valida.}
\macro{STREAM\_MAX}& 8& massimo numero di stream aperti per
processo in contemporanea.\\
\macro{TZNAME\_MAX}& 6& dimensione massima del nome di una
- \texttt{timezone} (vedi ).\\
+ \texttt{timezone} (vedi
+ \secref{sec:sys_time_base})).\\
\macro{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
processo (vedi \secref{sec:proc_access_id}).\\
\macro{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
\macro{\_POSIX\_STREAM\_MAX} & 8& massimo numero di stream aperti per
processo in contemporanea.\\
\macro{\_POSIX\_TZNAME\_MAX} & & dimensione massima del nome di una
- \texttt{timezone} (vedi ).\\
+ \texttt{timezone} (vedi
+ \secref{sec:sys_date}). \\
\macro{\_POSIX\_NGROUPS\_MAX}& 0& numero di gruppi supplementari per
processo (vedi
\secref{sec:proc_access_id}).\\
\bodydesc{La funzione restituisce indietro il valore del parametro
richiesto, o 1 se si tratta di un'opzione disponibile, 0 se l'opzione non
- è disponibile e -1 in caso di errore (ma \var{errno} non viene settata).}
+ è disponibile e -1 in caso di errore (ma \var{errno} non viene impostata).}
\end{prototype}
La funzione prende come argomento un intero che specifica quale dei limiti si
Restituisce il valore del parametro \param{name} per il file \param{path}.
\bodydesc{La funzione restituisce indietro il valore del parametro
- richiesto, o -1 in caso di errore (ed \var{errno} viene settata ad uno
+ richiesto, o -1 in caso di errore (ed \var{errno} viene impostata ad uno
degli errori possibili relativi all'accesso a \param{path}).}
\end{prototype}
Restituisce informazioni sul sistema nella struttura \param{info}.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} viene settata a \macro{EFAULT}.}
+ fallimento, nel qual caso \var{errno} viene impostata a \macro{EFAULT}.}
\end{prototype}
La funzione, che viene usata dal comando \cmd{uname}, restituisce le
da uno standard, ogni sistema può avere una sua serie di altri parametri di
configurazione, che, non essendo mai fissi e variando da sistema a sistema,
non sono stati inclusi nella standardizzazione della sezione precedente. Per
-questi occorre, oltre al meccanismo di settaggio, pure un meccanismo di
+questi occorre, oltre al meccanismo di impostazione, pure un meccanismo di
lettura.
Affronteremo questi argomenti in questa sezione, insieme alle funzioni che si
\subsection{La funzione \func{sysctl} ed il filesystem \file{/proc}}
\label{sec:sys_sysctl}
-La funzione che permette la lettura ed il settaggio dei parametri del sistema
-è \func{sysctl}; è una funzione derivata da BSD4.4, ma l'implementazione è
-specifica di Linux; il suo prototipo è:
+La funzione che permette la lettura ed l'impostazione dei parametri del
+sistema è \func{sysctl}; è una funzione derivata da BSD4.4, ma
+l'implementazione è specifica di Linux; il suo prototipo è:
\begin{functions}
\headdecl{unistd.h}
\headdecl{linux/unistd.h}
Legge o scrive uno dei parametri di sistema.
\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} viene settato ai valori:
+ errore, nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EPERM}] il processo non ha il permesso di accedere ad uno dei
componenti nel cammino specificato per il parametro, o non ha il permesso
\item[\macro{EFAULT}] si è specificato \param{oldlenp} zero quando
\param{oldval} è non nullo.
\item[\macro{EINVAL}] o si è specificato un valore non valido per il
- parametro che si vuole settare o lo spazio provvisto per il ritorno di un
+ parametro che si vuole impostare o lo spazio provvisto per il ritorno di un
valore non è delle giuste dimensioni.
\item[\macro{ENOMEM}] talvolta viene usato più correttamente questo errore
quando non si è specificato sufficiente spazio per ricevere il valore di un
L'indirizzo a cui il valore corrente del parametro deve essere letto è
specificato da \param{oldvalue}, e lo spazio ivi disponibile è specificato da
\param{oldlenp} (passato come puntatore per avere indietro la dimensione
-effettiva di quanto letto); il valore che si vuole settare nel sistema è
+effettiva di quanto letto); il valore che si vuole impostare nel sistema è
passato in \param{newval} e la sua dimensione in \param{newlen}.
Si può effettuare anche una lettura e scrittura simultanea, nel qual caso il
costante \macro{MS\_MGC\_MSK} per ottenere la parte di \param{mountflags}
riservata al \textit{magic number}.} mentre i 16 meno significativi sono
usati per specificare le opzioni; essi sono usati come maschera binaria e
-vanno settati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
+vanno impostati con un OR aritmetico della costante \macro{MS\_MGC\_VAL} con i
valori riportati in \ntab.
\begin{table}[htb]
\label{tab:sys_mount_flags}
\end{table}
-Per il settaggio delle caratteristiche particolari di ciascun filesystem si
+Per l'impostazione delle caratteristiche particolari di ciascun filesystem si
usa invece l'argomento \param{data} che serve per passare le ulteriori
informazioni necessarie, che ovviamente variano da filesystem a filesystem.
\textsl{rimontaggio} di un filesystem, cosa che permette di cambiarne al volo
alcune delle caratteristiche di funzionamento (ad esempio passare da sola
lettura a lettura/scrittura). Questa operazione è attivata attraverso uno dei
-bit di \param{mountflags}, \macro{MS\_REMOUNT}, che se settato specifica che
+bit di \param{mountflags}, \macro{MS\_REMOUNT}, che se impostato specifica che
deve essere effettuato il rimontaggio del filesystem (con le opzioni
specificate dagli altri bit), anche in questo caso il valore di \param{source}
viene ignorato.
Smonta il filesystem montato sulla directory \param{target}.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di
- fallimento, nel qual caso \var{errno} viene settata a:
+ fallimento, nel qual caso \var{errno} viene impostata a:
\begin{errlist}
\item[\macro{EPERM}] il processo non ha i privilegi di amministratore.
\item[\macro{EBUSY}] \param{target} è la directory di lavoro di qualche
posto il file specificato.
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} viene settato ai valori:
+ errore, nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{ENOSYS}] il filesystem su cui si trova il file specificato non
supporta la funzione.
riguardo al filesystem su cui si trova il file specificato; queste vengono
restituite una struttura \param{buf} di tipo \type{statfs} definita come in
\ref{fig:sys_statfs}, ed i campi che sono indefiniti per il filesystem in
-esame sono settati a zero. I valori del campo \var{f\_type} sono definiti per
+esame sono impostati a zero. I valori del campo \var{f\_type} sono definiti per
i vari filesystem nei relativi file di header dei sorgenti del kernel da
costanti del tipo \macro{XXX\_SUPER\_MAGIC}, dove \macro{XXX} in genere è il
nome del filesystem stesso.
Restituiscono le informazioni relative all'utente specificato.
\bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
- altrimenti, nel qual caso \var{errno} sarà settato opportunamente.}
+ altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
\end{functions}
In questo caso l'uso è molto più complesso, in quanto bisogna prima allocare
viene restituito il puntatore ai dati ottenuti, cioè \param{buffer} nel caso
l'utente esista, o \macro{NULL} altrimenti. Qualora i dati non possano essere
contenuti nei byte specificati da \param{buflen}, la funzione fallirà
-restituendo \macro{ERANGE} (e \param{result} sarà comunque settato a
+restituendo \macro{ERANGE} (e \param{result} sarà comunque impostato a
\macro{NULL}).
Del tutto analoghe alle precedenti sono le funzioni \func{getgrnam} e
Restituiscono le informazioni relative al gruppo specificato.
\bodydesc{Le funzioni ritornano 0 in caso di successo e un codice d'errore
- altrimenti, nel qual caso \var{errno} sarà settato opportunamente.}
+ altrimenti, nel qual caso \var{errno} sarà impostata opportunamente.}
\end{functions}
Il comportamento di tutte queste funzioni è assolutamente identico alle
Le funzioni viste finora sono in grado di leggere le informazioni sia dal file
delle password in \file{/etc/passwd} che con qualunque altro metodo sia stato
utilizzato per mantenere il database degli utenti. Non permettono però di
-settare direttamente le password; questo è possibile con un'altra interfaccia
+impostare direttamente le password; questo è possibile con un'altra interfaccia
al database degli utenti, derivata da SVID, che però funziona soltanto con un
database che sia tenuto su un file che abbia il formato classico di
\file{/etc/passwd}.
\end{figure}
In genere il superamento di un limite comporta o l'emissione di un segnale o
-il fallimento della system call che lo ha provocato; per far leggere o settare
+il fallimento della system call che lo ha provocato; per far leggere o impostare
i limiti di utilizzo delle risorse da parte di un processo le \acr{glibc}
prevedono due funzioni, \func{getrlimit} e \func{setrlimit}, i cui prototipi
sono:
\funcdecl{int setrlimit(int resource, const struct rlimit *rlim)}
- Setta il limite per la risorsa \param{resource}.
+ Imposta il limite per la risorsa \param{resource}.
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
- errore, nel qual caso \var{errno} viene settata ai valori:
+ errore, nel qual caso \var{errno} viene impostata ai valori:
\begin{errlist}
\item[\macro{EINVAL}] I valori per \param{resource} non sono validi.
\item[\macro{EPERM}] Un processo senza i privilegi di amministratore ha
\label{tab:sys_rlimit_values}
\end{table}
-\footnotetext{Settare questo limite a zero è la maniera più semplice per
+\footnotetext{Impostare questo limite a zero è la maniera più semplice per
evitare la creazione di \file{core} file.}
È inoltre definita la costante \macro{RLIM\_INFINITY} che permette di
variabile su cui duplicare il valore di ritorno.
Analoga a \func{time} è la funzione \func{stime} che serve per effettuare
-l'operazione inversa, e cioè per settare il tempo di sistema qualora questo
+l'operazione inversa, e cioè per impostare il tempo di sistema qualora questo
sia necessario; il suo prototipo è:
\begin{prototype}{time.h}{int stime(time\_t *t)}
- Setta a \param{t} il valore corrente del \textit{calendar time}.
+ Imposta a \param{t} il valore corrente del \textit{calendar time}.
\bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
che può essere \macro{EFAULT} o \macro{EPERM}.}
\funcdecl{int settimeofday(const struct timeval *tv, const struct timezone
*tz)}
- Setta il tempo di sistema.
+ Imposta il tempo di sistema.
\bodydesc{Entrambe le funzioni restituiscono 0 in caso di successo e -1 in
caso di errore, nel qual caso \var{errno} può assumere il valori
seguito) può essere utilizzata solo da un processo coi privilegi di
amministratore. Il secondo parametro di entrambe le funzioni è una struttura
\var{timezone}, che storicamente veniva utilizzata per specificare appunto la
-\textit{timezone}, cioè l'insieme del fuso orario e delle convenzioni per
+\textit{time zone}, cioè l'insieme del fuso orario e delle convenzioni per
l'ora legale che permettevano il passaggio dal tempo universale all'ora
locale. Questo parametro è obsoleto e in Linux non è mai stato utilizzato e
non è supportato né dalle vecchie \textsl{libc5}, né dalle \textsl{glibc}:
-pertanto deve essere sempre settato a \macro{NULL}.
+pertanto deve essere sempre impostato a \macro{NULL}.
Modificare l'orologio di sistema con queste funzioni è comunque problematico,
in quanto esse effettuano un cambiamento immediato. Questo può creare dei
buchi o delle ripetizioni nello scorrere dell'orologio di sistema, con
conseguenze indesiderate; ad esempio se si porta avanti l'orologio si possono
perdere delle esecuzioni di \cmd{cron} programmate nell'intervallo che si è
-saltato. Per questo motivo la modalità più corretta per settare l'ora è quella
+saltato. Per questo motivo la modalità più corretta per impostare l'ora è quella
di usare la funzione \func{adjtime}, il cui prototipo è:
\begin{prototype}{sys/time.h}
{int adjtime(const struct timeval *delta, struct timeval *olddelta)}
così come effettuata in \file{sys/timex.h}, è riportata in
\figref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
-specificato in un opportuno campo di \var{timex}, deve essere settato. Un
+specificato in un opportuno campo di \var{timex}, deve essere impostato. Un
valore nullo serve per leggere i parametri correnti; i valori diversi da zero
devono essere specificati come OR binario delle costanti riportate in
\secref{tab:sys_timex_mode}.
\textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \macro{ADJ\_OFFSET} & 0x0001 & Setta la differenza fra il tempo
+ \macro{ADJ\_OFFSET} & 0x0001 & Imposta la differenza fra il tempo
reale e l'orologio di sistema, che
deve essere indicata in microsecondi
nel campo \var{offset} di
\var{timex}.\\
- \macro{ADJ\_FREQUENCY} & 0x0002 & Setta la differenze in frequenza
+ \macro{ADJ\_FREQUENCY} & 0x0002 & Imposta la differenze in frequenza
fra il tempo reale e l'orologio di
sistema, che deve essere indicata
in parti per milione nel campo
\var{frequency} di \var{timex}.\\
- \macro{ADJ\_MAXERROR} & 0x0004 & Setta il valore massimo dell'errore
+ \macro{ADJ\_MAXERROR} & 0x0004 & Imposta il valore massimo dell'errore
sul tempo, espresso in microsecondi
nel campo \var{maxerror} di
\var{timex}.\\
- \macro{ADJ\_ESTERROR} & 0x0008 & Setta la stima dell'errore
+ \macro{ADJ\_ESTERROR} & 0x0008 & Imposta la stima dell'errore
sul tempo, espresso in microsecondi
nel campo \var{esterror} di
\var{timex}.\\
- \macro{ADJ\_STATUS} & 0x0010 & Setta alcuni
+ \macro{ADJ\_STATUS} & 0x0010 & Imposta alcuni
valori di stato interni usati dal
sistema nella gestione
dell'orologio specificati nel campo
\var{status} di \var{timex}.\\
- \macro{ADJ\_TIMECONST} & 0x0020 & Setta la larghezza di banda del PLL
+ \macro{ADJ\_TIMECONST} & 0x0020 & Imposta la larghezza di banda del PLL
implementato dal kernel,
specificato nel campo
\var{constant} di \var{timex}.\\
- \macro{ADJ\_TICK} & 0x4000 & Setta il valore dei tick del timer
+ \macro{ADJ\_TICK} & 0x4000 & Imposta il valore dei tick del timer
in microsecondi, espresso nel campo
\var{tick} di \var{timex}.\\
- \macro{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Setta uno spostamento una tantum
+ \macro{ADJ\_OFFSET\_SINGLESHOT}&0x8001&Imposta uno spostamento una tantum
dell'orologio secondo il valore del
campo \var{offset} simulando il
comportamento di \func{adjtime}.\\
\begin{verbatim}
"Wed Jun 30 21:49:08 1993\n"
\end{verbatim}
-e settano anche la variabile \var{tzname} con l'informazione della \textit{time
+e impostano anche la variabile \var{tzname} con l'informazione della \textit{time
zone} corrente; \func{ctime} è banalmente definita in termini di
\func{asctime} come \code{asctime(localtime(t)}. Dato che l'uso di una stringa
statica rende le funzioni non rientranti POSIX.1c e SUSv2 prevedono due
permette di tenere conto anche della differenza fra tempo universale e ora
locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
variabili globali mostrate in \figref{fig:sys_tzname}, cui si accede quando si
-include \file{time.h}. Queste variabili vengono settate quando si chiama una
+include \file{time.h}. Queste variabili vengono impostate quando si chiama una
delle precedenti funzioni di conversione, oppure invocando direttamente la
funzione \func{tzset}, il cui prototipo è:
\begin{prototype}{sys/timex.h}
{void tzset(void)}
- Setta le variabili globali della \textit{time zone}.
+ Imposta le variabili globali della \textit{time zone}.
\bodydesc{La funzione non ritorna niente e non dà errori.}
\end{prototype}
restituiti dalle funzioni. Il programma di esempio \cmd{errcode} stampa il
codice relativo ad un valore numerico con l'opzione \cmd{-l}.
-Il valore di \var{errno} viene sempre settato a zero all'avvio di un
-programma, gran parte delle funzioni di libreria settano \var{errno} ad un
+Il valore di \var{errno} viene sempre impostato a zero all'avvio di un
+programma, gran parte delle funzioni di libreria impostano \var{errno} ad un
valore diverso da zero in caso di errore. Il valore è invece indefinito in
caso di successo, perché anche se una funzione ha successo, può chiamarne
altre al suo interno che falliscono, modificando così \var{errno}.
\bodydesc{La funzione ritorna il puntatore alla stringa col messaggio di
errore in caso di successo e \macro{NULL} in caso di errore, nel qual caso
- \var{errno} sarà settata a \macro{EINVAL} se si è specificato un numero di
+ \var{errno} sarà impostata a \macro{EINVAL} se si è specificato un numero di
errore non valido.}
\end{prototype}
per il fatto che, separati con il solito due punti-spazio, vengono inseriti un
nome di file indicato da \param{fname} ed un numero di linea subito dopo la
stampa del nome del programma. Inoltre essa usa un'altra variabile globale,
-\var{error\_one\_per\_line}, che settata ad un valore diverso da zero fa si
+\var{error\_one\_per\_line}, che impostata ad un valore diverso da zero fa si
che errori relativi alla stessa linea non vengano ripetuti.
projects / gapil.git / commitdiff